链表上的基本操作实现

在单链表存储结构上实现基本操作:初始化、创建、插入、删除、查找、遍历、逆置、合并运算。

#include <iostream>
#include <cstdlib>
using namespace std;
template<typename T>
class LinkNode
{
public:
    T data;
    LinkNode<T>* next;
    LinkNode(const T& item, LinkNode<T>* ptr=NULL)
    {
        data=item;
        next=ptr;
    }
    LinkNode(LinkNode<T>* ptr=NULL)
    {
        next=ptr;
    }
};
template<typename T>
class List
{
private:
    LinkNode<T>* first;
    LinkNode<T>* rear;
public:

    List()
    {
        first=NULL;
        rear=first;
    }
    List(const List<T>& L)
    {
        first=NULL;
        CopyList(L);
    }
    List<T>& operator=(const List<T>& L)
    {
        if(this==&L)
        {
            return *this;
        }
        MakeEmpty();
        CopyList(L);
        return *this;
    }
    ~List()
    {
        MakeEmpty();
    }

    void InputFront(const T& elem)
    {
        LinkNode<T>* newNode=new LinkNode<T>(elem);
        newNode->next=first;
        first=newNode;
    }
    void InputRear(const T& elem)
    {
        LinkNode<T>* newNode=new LinkNode<T>(elem);
        if(IsEmpty())
        {
            first=newNode;
        }
        else
        {
            rear=first;
            while(rear->next)
            {
                rear=rear->next;
            }
            rear->next=newNode;
        }
    }
    bool Insert(int i,const T& elem)
    {

        LinkNode<T>* pre;
        LinkNode<T>* newNode;
        pre=first;
        for(int j=1; j<i-1; j++)
        {
            if(pre==NULL)
                break;
            pre=pre->next;
        }
        if(pre==NULL)
        {
            cerr<<"无效的插入位置"<<endl;
            return false;
        }
        else
        {
            newNode=new LinkNode<T>(elem);
            newNode->next=pre->next;
            pre->next=newNode;
        }
        return true;

    }
    bool Remove(int i,T& elem)
    {
        LinkNode<T>* pre;
        LinkNode<T>* newNode;
        pre=first;
        if(i<1)
        {
            return false;
        }
        if(i==1)
        {
            newNode=first;
            first=first->next;
            elem=newNode->data;
        }
        else
        {
            while(i-->2)
            {
                if(pre==NULL)
                {
                    return false;
                }
                pre=pre->next;
            }
            newNode=pre->next;
            elem=pre->data;
            pre->next=newNode->next;
            delete newNode;
        }
        return true;
    }
    bool Search(const T& elem,int &x)
    {
        LinkNode<T>* pre;
        int num=0;
        pre=first;
        while(pre!=NULL)
        {
            num++;
            if(pre->data==elem)
            {
                x=num;
                return true;
            }
            pre=pre->next;
        }
        return false;
    }
    LinkNode<T>* Locate(int i)
    {
        LinkNode<T>* newNode=NULL;
        LinkNode<T>* pre=first;
        if(i==1)
        {
            newNode=first;
        }
        else
        {
            while(i>1&&pre!=NULL)
            {
                pre=pre->next;
                i--;
            }
            newNode=pre;
        }
        return newNode;
    }
    bool GetData(int i,T& elem)
    {
        LinkNode<T>* newNode=NULL;
        LinkNode<T>* pre=first;
        if(i==1)
        {
            newNode=first;
        }
        else
        {
            while(i>1)
            {
                pre=pre->next;
                i--;
            }
            newNode=pre;
        }
        if(newNode!=NULL)
        {
            elem=newNode->data;
            return true;
        }
        return false;
    }
    void SetData(int i,const T& elem)
    {
        LinkNode<T>* newNode=NULL;
        LinkNode<T>* pre=first;
        if(i==1)
        {
            newNode=first;
        }
        else
        {
            while(i>1&&pre!=NULL)
            {
                pre=pre->next;
                i--;
            }
            newNode=pre;
        }
        if(newNode!=NULL)
        {
            newNode->data=elem;
        }

    }
    void MakeEmpty()
    {
        LinkNode<T>* pnd=NULL;
        while(first!=NULL)
        {
            pnd=first;
            first=first->next;
            delete pnd;
        }
    }
    void CopyList(const List<T>& L)
    {
        if(L.first==NULL)
        {
            return;
        }
        LinkNode<T> *newNode=new LinkNode<T>(L.first->data);
        first=newNode;
        LinkNode<T> *iter=L.first->next;
        rear=newNode;
        while(iter)
        {
            newNode=new LinkNode<T>(iter->data);
            rear->next=newNode;
            iter=iter->next;
            rear=rear->next;
        }
    }
    int Length()const
    {

        int i=0;
        LinkNode<T>* pre=first;
        while(pre!=NULL)
        {
            i++;
            pre=pre->next;
        }
        return i;
    }
    bool IsEmpty()const
    {
        return first==NULL;
    }
    void Reverse()
    {
        List<T> p;
        for(int i=0; i<Length(); i++)
        {
            p.InputFront(Locate(i+1)->data);
        }
        *this=p;
    }
    void Combine(List<T> L)
    {
        LinkNode<T>* pre1=first;
        LinkNode<T>* pre2=L.first;
        List<T> newList;
        while(pre1!=NULL&&pre2!=NULL)
        {
            if(pre1->data<pre2->data)
            {
                newList.InputRear(pre1->data);
                pre1=pre1->next;
            }
            else
            {
                newList.InputRear(pre2->data);
                pre2=pre2->next;
            }
        }
        while(pre1!=NULL)
        {
            newList.InputRear(pre1->data);
            pre1=pre1->next;
        }
        while(pre2!=NULL)
        {
            newList.InputRear(pre2->data);
            pre2=pre2->next;
        }
        *this=newList;
    }
    friend ostream& operator<<(ostream& out,const List<T>& L)
    {
        LinkNode<T>* pre;
        pre=L.first;
        while(pre)
        {
            out<<pre->data<<" ";
            pre=pre->next;
        }
        return out;
    }
    friend istream& operator>>(istream& in,List<T>& L)
    {
        int n;
        in>>n;
        T *elem;
        elem=new T[n];
        for(int i=0; i<n; i++)
        {
            in>>elem[i];
            L.InputRear(elem[i]);
        }
        return in;
    }
};
int main()
{
    List<int> a,b;
    cin>>a;
    int m,n;
    cin>>m>>n;
    a.Insert(n,m);
    cout<<a<<endl;
    int x,y;
    cin>>x;
    a.Remove(x,y);
    cout<<a<<endl;
    int num,s;
    cin>>num;
    if(a.Search(num,s)==false)
    cout<<"Not found"<<endl;
    else
    cout<<s<<endl;
    a.Reverse();
    cout<<a<<endl;
    cin>>b;
    a.Combine(b);
    cout<<a<<endl;
    return 0;
}

猜你喜欢

转载自www.cnblogs.com/xbnl-bk-zm-2018/p/11354883.html
今日推荐