單鏈表的遍歷與優化

1. 單鏈表存在的問題

(1). 問題引入

怎么樣遍歷單鏈表中的元素？

(2). 原來單鏈表的遍歷

#include <iostream>
#include "linklist.h"
 
using namespace std;
using namespace DTLib;
 
int main()
{
    LinkList<int> l;
 
    for(int i=0;i<6;i++)   //時間復雜度O(n)
    {
        l.insert(0,i);
    }
 
    for(int i=0;i<l.length();i++)//時間復雜度O（n）
    {
     cout<<l.get(i)<<endl;        //時間復雜度O(n)
    }
}

 

 

 

根據事件復雜度分析可知道遍歷時的時間復雜度為了O(n ²)

時間復雜度太多效率低  所以需要改進

 

2. 設計的思路

(1) 在單鏈表內部定義一個 游標( Node* m_current)

(2) 遍歷開始前將游標 指向位置為0的數據元素

(3) 獲取游標指向的數據元素

(4)  通過節點中的 next指針移動游標

 

• 增加的與遍歷相關函數如下

 

 

• 函數原型為

 //LinkList.h

#ifndef LINKLIST_H
#define LINKLIST_H
#include "List.h"
namespace DataStructureLib
{
    template <typename T>

    class LinkList:public List<T>
    {
    protected:
        struct Node{
            T value;
            Node* next;
        };

        mutable Node m_header;//頭結點 、mutable為了讓get函數中的const屬性導致的&m_header（編譯器認為是要修改成員變量）mutable就允許const成員函數取地址
        int m_length;//鏈表的長度

        Node* position(int i) const//返回第i和元素的指針
        {
            Node* ret=&m_header;

            for(int p=0;p<i;p++)
            {
                ret=ret->next;
            }

            return ret;//元素地址保存在該節點的next指針域中
        }
        
        //游標
        int m_step;
        Node* m_current ;
    public:
        LinkList()
        {
            m_header.next=NULL;
            m_length=0;
            m_step=1;
            m_current=NULL;
        }
        
        bool insert(int index, const T& elem)//思路：1.找到index位置處的元素；2.在該元素尾部insert新元素
        {
            bool ret=(index<=m_length)&&(index>=0);

            Node* NewNode=new Node ;

            if (ret)
            {
                if (NULL!=NewNode)
                {
                    NewNode->value=elem;

                    Node* indexNode=position(index);
                    NewNode->next=indexNode->next;
                    indexNode->next=NewNode;

                    m_length++;
                }
                else{
                    throw("has Not enougth memory to insert new element ...");
                }

            }
            return ret;
        }

        bool remove(int index)
        {
            bool ret=((index<=m_length)&&(index>=0));

            if (ret)
            {
                Node* CurrentNode=position(index);
                Node* toDelNode=CurrentNode->next;
                CurrentNode->next=toDelNode->next;

                delete toDelNode ;
                m_length--;
            }

            return ret;
        }
        
        bool set(int index,const T& e)
        {
            bool ret=((0<=index)&&(index<=m_length));

            if (ret)
            {
                Node* CurrentNode=position(index);
                CurrentNode->next->value=e;
            }
            
            return  ret; 
        }

        bool get(int index, T& elem) const
        {
            bool ret=((index<=m_length)&&(index>=0));

            if (ret)
            {
                Node* CurrentNode=position(index);
                elem= CurrentNode->next->value;
            }

            return ret;
        }

        T get(int index)
        {
            T ret;
            if((index<m_length)&&(0<=index))
            {
                Node* CurrentNode=position(index);
                ret= CurrentNode->next->value;
            }

            return ret; 
        }
        int getlength() const
        {
            return m_length;

        }

        void clear()
        {
                                
            while (m_header.next)
            {
                Node* toDelNode=m_header.next;
                m_header.next=toDelNode->next;
                delete toDelNode;
            }
            m_length=0;
        }
        
        //尋找e元素所在的位置，
        //返回值 失敗：-1    成功：e元素所在的位置的id
        int find(T& e)
        { 
            int ret = -1;
            for (int i=0;i<m_length;i++)
            {
                if (e==get(i))
                {
                    ret=i;
                }
            }

            return ret;
        }   


        bool move(int i,int step=1)//將游標定位到目標位置，//i代表目標位置  step游標每次移動的節點的數目
        {
            bool ret= (0<=i)&&(i<m_length)&&(step>0);

            if (ret)
            {
                m_current=position(i)->next;
                m_step=step;
            }

        return ret;

        }

        bool end()//游標有無到達鏈表尾部
        {
            return (m_current==NULL);
        }

        T current()//獲取游標所指向的數據元素
        {
            if(!end())
            {
                return  m_current->value ;
            }
            else
            {
                throw("No Value at current position...");
            }
        }

        //移動游標  相當於每次移動的大小m_step
        bool next()
        {

            int i=0;

            while ((m_step>i)&&(!end()))
            {
                m_current=m_current->next;
                i++;
            }

            return (i==m_step);
        }
        
        ~LinkList()
        {
            clear();
        }
};

}
#endif

測試：

#include<iostream>
#include "object.h"
#include "SeqList.h"
#include "LinkList.h"

using namespace std;
using namespace DataStructureLib;


int main(int argc, char const *argv[])
{
    LinkList<int> l;

    for(int i=0;i<6;i++)
    {
        l.insert(0,i);
    }

    for(l.move(0,1);(!l.end());l.next())
    {
        cout<<l.current()<<endl;
    }
    system("pause"); 
    return 0;
}

小結：

• 單鏈表的遍歷需要在線性時間內完成
• 在單鏈表的內部定義游標變量（指針），通過游標變量提高效率
• 遍歷的函數需要相互依賴，相互的配合
• 封裝節點的申請和刪除操作有利於增強擴展性