数据结构之单链表 c++

**

节点结构的定义：**

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

单链表类的定义

template<class T>
class LinkList 
{
   Node<T> * head;//单链表头指针
public:
   LinkList();//默认构造函数
   LinkList(T a[ ],int n);//生成有n个数据的链表(采用尾插法)
   ~LinkList();//析构函数
   Node<T> *invert(Node<T> *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<T>::LinkList()    //构造函数1
{ //创建带表头结点的空单链表
	head=new Node<T>;//创建表头结点
}

（2）有参构造函数

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

（3）析构函数

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

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

（4）单链表的反转

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

(5)求单链表的长度

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

(6)按位查找

template<classT>
T LinkList<T>::Get(int pos)
{
	Node<T> *p=head->link;
	j=1;
	while(p&&j<pos)
	{
		p=p->link;
		j++;
     }
     if(!p||j>pos)
     {
	     cout<<"查找位置非法"<<endl;
	     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;
}