单向链表与模板实现-优快云博客

本文介绍单向链表的基本操作及链表类模板的实现方法，包括节点的添加、遍历、删除等，并提供了完整的C++代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

（1）单向链表

//单向链表
#include<iostream.h>
#include<iomanip.h>
class CNode  //节点类
{
public:
    CNode *m_pNext;
    int m_Data;
    CNode():m_pNext(NULL){}
};

class CList  //链表类
{
public:
    CList()
    {
        m_pHeader=NULL;
        m_NodeSum=0;
    }
    CNode* MoveTrail(CNode *pNode)//移动到尾节点
    {
        CNode *pTmp=m_pHeader;
        for(int i=1;i<m_NodeSum;i++)
        {
            pTmp=pTmp->m_pNext;
        }
        return pTmp;
    }
    void AddNode(CNode *pNode)//添加节点
    {
        if(0==m_NodeSum)
        {
            m_pHeader=pNode;
        }
        else
        {
            CNode *pTrail=MoveTrail(pNode);
            pTrail->m_pNext=pNode;
        }
        m_NodeSum++;
    }
    void PassList()//遍历链表
    {
        if(m_NodeSum>0)
        {
            CNode *pTmp=m_pHeader;
            cout<<setw(5)<<pTmp->m_Data;
            for(int i=1;i<m_NodeSum;i++)
            {
                pTmp=pTmp->m_pNext;
                cout<<setw(5)<<pTmp->m_Data;
            }
        }
        cout<<endl;
    }
    ~CList()//定义链表的析构函数
    {
        if(m_NodeSum>0)
        {
            CNode *pDelete=m_pHeader;
            CNode *pTmp=NULL;
            for(int i=1;i<m_NodeSum;i++)
            {
                pTmp=pDelete->m_pNext;
                delete pDelete;
                pDelete=pTmp;
            }
            m_NodeSum=0;
            pDelete=NULL;
            pTmp=NULL;
        }
        m_pHeader=NULL;
    }
private:
    CNode *m_pHeader;
    int m_NodeSum;
};

void main()
{
    CList list;
    for(int i=0;i<5;i++)
    {
        CNode *pNode=new CNode();
        pNode->m_Data=i;
        list. AddNode(pNode);
    }
    list.PassList();
}

（2）链表类模板

//链表类模板
#include<iostream.h>
#include<iomanip.h>
class CNode  //节点类1
{
public:
    CNode *m_pNext;
    int m_Data;
    CNode():m_pNext(NULL){}
};

class CNet//节点类2
{
    public:
    CNet *m_pNext;
    int m_Data;
    CNet():m_pNext(NULL){}
};

template<class T>
class CList  //链表类
{
public:
    CList()
    {
        m_pHeader=NULL;
        m_NodeSum=0;
    }
    T* MoveTrail(T*pNode)//移动到尾节点
    {
        T *pTmp=m_pHeader;
        for(int i=1;i<m_NodeSum;i++)
        {
            pTmp=pTmp->m_pNext;
        }
        return pTmp;
    }
    void AddNode(T*pNode)//添加节点
    {
        if(0==m_NodeSum)
        {
            m_pHeader=pNode;
        }
        else
        {
            T *pTrail=MoveTrail(pNode);
            pTrail->m_pNext=pNode;
        }
        m_NodeSum++;
    }
    void PassList()//遍历链表
    {
        if(m_NodeSum>0)
        {
            T *pTmp=m_pHeader;
            cout<<setw(5)<<pTmp->m_Data;
            for(int i=1;i<m_NodeSum;i++)
            {
                pTmp=pTmp->m_pNext;
                cout<<setw(5)<<pTmp->m_Data;
            }
        }
        cout<<endl;
    }
    ~CList()//定义链表的析构函数
    {
        if(m_NodeSum>0)
        {
            T *pDelete=m_pHeader;
            T *pTmp=NULL;
            for(int i=1;i<m_NodeSum;i++)
            {
                pTmp=pDelete->m_pNext;
                delete pDelete;
                pDelete=pTmp;
            }
            m_NodeSum=0;
            pDelete=NULL;
            pTmp=NULL;
        }
        m_pHeader=NULL;
    }
private:
    T *m_pHeader;
    int m_NodeSum;
};

void main()
{
    CList<CNode> list1;
    for(int i=0;i<5;i++)
    {
        CNode *pNode=new CNode();
        pNode->m_Data=i;
        list1.AddNode(pNode);
    }
    list1.PassList();
    CList<CNet> list2;
    for(int j=5;j<10;j++)
    {
        CNet *pNode=new CNet();
        pNode->m_Data=j;
        list2.AddNode(pNode);
    }
    list2.PassList();
}

本文转自：http://www.cnblogs.com/KeenLeung/archive/2012/04/21/2461172.html

二：

#include <iostream>

#include <iomanip>

using namespace std;
template <class T>
class node //节点
{
public:
T data;
node *next;
};

template <class T>
class list
{
public:
list();
void Create();                      //创建链表
bool Empty() const;                 //判断链表是否为空
void InsertLast(const T e);         //从尾部插入一个元素
void InsertFirst(const T e);        //从头部插入一个元素
void DeleteFirst();                 //从头删除一个元素
void DeleteLast();                  //从尾删除元素
    void Display() const;               //显示链表
node<T>* GetNode(int i);                //返回第i个节点
    void Reverse();                     //链表逆置
bool Find(const T e);               //在链表中查找某个值
~list();                            //销毁链表
private:
    node<T> *head;                        //头节点
};

template <class T>
list<T>::list()
{
head=new node<T>;
head->next=NULL;
}

template <class T>
void list<T>::Create()
{
    node<T> *p,*q;
p=head;
q=new node<T>;
cout<<"请输入值(按'ctrl+z'停止): ";
while(cin>>q->data)
{
   p->next=q;
   p=q;
   q=new node<T>;
}
p->next=NULL;
}

template <class T>
bool list<T>::Empty() const
{
return (head->next==NULL);
}

template <class T>
void list<T>::InsertFirst(const T e)
{
node<T> *p=new node<T>;
p->data=e;
p->next=head->next;
head->next=p;
}

template <class T>
void list<T>::InsertLast(const T e)
{
node<T> *p,*q;
p=head;
q=new node<T>;
q->data=e;
while(p->next)
{
p=p->next;
}
p->next=q;
q->next=NULL;
}

template <class T>
void list<T>::DeleteFirst()
{
head->next=head->next->next;
}

template <class T>
void list<T>::DeleteLast()
{
node<T> *p;
p=head;
while(p->next->next)
p=p->next;
p->next=NULL;
}

template <class T>
void list<T>::Display() const             //显示链表
{
node<T> *p;
p=head->next;
while(p)
{
   cout<<p->data<<" ";
   p=p->next;
}
}

template <class T>
node<T>* list<T>::GetNode(int i)              //返回第i个节点
{
int k=0;
    node<T> *p;
p=head;
while(p && k<i)
{
   p=p->next;
   ++k;
}
return p;
}

template <class T>
void list<T>:: Reverse()                   //链表逆置
{
     node<T> *p,*q;
p=head->next;
int count=0;
while(p)                 //求链表的长度
{
   p=p->next;
   count++;
}
int i,j;
i=1;
j=count;
while(i<=count/2 && j>=count/2)
{
   p=GetNode(i);
   q=GetNode(j);
   T temp=p->data;
   p->data=q->data;
   q->data=temp;
   ++i;
   --j;
}
}

template <class T>
bool list<T>::Find(const T e)             //在链表中查找某个值
{
bool flag=false;
    node<T> *p;
p=head->next;
while(p)
{
   if(p->data==e)
   {
    flag=true;
     break;
   }
   p=p->next;
}
return flag;
}

template <class T>
list<T>::~list()
{
node<T> *p;
while(head)
{
   p=head->next;
   delete head;
   head=p;
}
}

int main()
{
list<int> ilist;
ilist.Create();        //创建链表
ilist.Display();       //输出链表
cout<<endl;
ilist.InsertFirst(123); //从头插入一个值
ilist.InsertLast(456); //从尾插入一个值
    ilist.Display();
cout<<endl;
    if(ilist.Find(123))
   cout<<"123 在链表中"<<endl;
else
   cout<<"123 不在链表中"<<endl;
ilist.DeleteFirst();   //从头删除一个值
ilist.DeleteLast();    //从尾删除一个值
ilist.Display();
cout<<endl;
ilist.Reverse();       //逆序
ilist.Display();
cout<<endl;
system("pause");
return 0;
}