数据结构-单链表_c++

**

节点结构的定义：**

templateT>
struct Node
{
T data；
Node * link；
Node(){Link=NULL;}
Node(T x,Node *next=NULL)
{ data=x; link=next; }
};

单链表类的定义

template
class LinkList 
{
   Node * head;//单链表头指针
public:
   LinkList();//默认构造函数
   LinkList(T a[ ],int n);//生成有n个数据的链表(采用尾插法)
   ~LinkList();//析构函数
   Node *invert(Node *x);//单链表的反转
   int ListLength();//求单链表的长度
   T get(int pos);//按位查找
   int Locate(T item);//按值查找
   void PrintLinkList();//遍历单链表输出
   bool Insert(int i,const T &item);//单链表的插入
   bool Remove(int i,T&x);//单链表的删除
};

**

3 算法设计与实现（类的成员函数实现）

**
（1） 默认构造函数

template<class T>
LinkList::LinkList()    //构造函数1
{ //创建带表头结点的空单链表
    head=new Node;//创建表头结点
}

（2）有参构造函数

template<class T>
LinkList::LinkList(T a[],int n)    //构造函数2
{  //用尾插法创建单链表
    Node *p,*r;
    head=p=new Node;//创建表头结点，p指针指向当前单链表的最后一个结点
    for(int i=0;inew Node(data[i]);
        p->link=r;       //链接到p指针所指结点之后
        p=p->link;       //p指针后移
    }
}

（3）析构函数

template<class T>
LinkList::~LinkList()   //清空操作，将各元素结点空间释放，单链表为空表
{

Node *current=head->link; // current指向首元结点
    while(current!=NULL) //依次扫描链表结点，并逐个释放空间
    {   
        Node *r=current;
        current=current->link;
        delete r;
    }
    head->link =NULL; //单链表为空
}

（4）单链表的反转

template
Node LinkList::*invert(Node *x)
{
    Node *p,*q,*r;
    p=x;
    q=NULL;
    while(p)
    {
        r=q;
        q=p;
        p=p->link;
        q->link=r;
    }
    return q;
}

(5)求单链表的长度

template
int LinkList::ListLength()
{
    int num=0;
    Node *p=head->link;
    while(P)
    {
        p=p->link;
        num++;
    }
    return num;
}

(6)按位查找

template
T LinkList::Get(int pos)
{
    Node *p=head->link;
    j=1;
    while(p&&j<pos)
    {
        p=p->link;
        j++;
     }
     if(!p||j>pos)
     {
         cout<<"查找位置非法"<exit(1);
     }
     else
      return p->data;
}

(7)按值查找

template<classT>
int LinkList<T>::Locate(T item)
{
    Node<T>*p=head->link;
    int j=1;
    while(p&&p->data!=item)
    {
        p=p->link;
        j++;
    }
    if(p) return j;
    else return 0;
}

（8） 插入操作
算法描述：
① 若i<1，则插入失败，结束；
② 扫描单链表，寻找单链表中第i-1个元素结点的指针p；
③ 若p存在（p非空）则在其后插入，操作成功，否则不能插入。

template<class T>
bool LinkList<T>::Insert(int i,const T&item)
{ //在单链表的第i个元素之前插入元素item，插入成功返回true,否则返回false。
    if(i<1) //插入位置不合法
        return false;
    Node<T> *s,*p=head;
    int count=0; // count是计数器
    while(p && count<i-1)//找第i-1个元素结点的指针front
    {
        p=p->link;
        count++;
    }
    if(!p) //插入位置不合法
        return false; 
    s=new Node<T>(item,p->link);
        s->data=item;
        s->link= p->link;//确定待插入结点（s所指结点）的link指针（s->link）指向
    p->link=s; //修改链表中的指针（p->link）指向
    return true;
}

（9） 删除操作
a) 算法步骤：（删除单链表中的第pos个元素）
① 若pos<1，则删除失败，结束；
② 在单链表中找第pos -1个元素结点的指针p；
③ 若p和p->link均非空，则删除p->link所指结点，否则删除失败。

template<classT>
bool LinkList<T>::Remove(int i,T&x) //删除单链表的第i个元素，并置入x
{
    if(i<1)   //删除位置不合法
        return false;
    Node<T> *current,*p=head;
    int count=0;// count是计数器
    while(p->link && count<i-1)//找第i-1个元素结点的指针
    {
        p=p->link;
        count++;
    }
    if(!p->link)  //删除位置不合法,pos大于表长
        return false;
    current=p->link;  // current指向被删除结点
    p->link=current->link; //修改链表指针
    x= current->data;
    delete current;
    return true;
}

(10)打印整个链表

template<class T>
void LinkList<T>::PrintLinkList()
{
    Node<T>*current = head->link;
    while(current)
    {
        cout<<current->data<<" ";
        current=current->link;
    }
    cout<<endl;
}