单链表的遍历与优化

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;
}

小结：

• 单链表的遍历需要在线性时间内完成
• 在单链表的内部定义游标变量（指针），通过游标变量提高效率
• 遍历的函数需要相互依赖，相互的配合
• 封装节点的申请和删除操作有利于增强扩展性