单链表的操作

编译环境：vs

语言：c/c++

1.节点类型：

//单链表节点所装的数据
typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LNode, *LinkList;

2.把数据封装成节点单独做成一个函数，简洁明了。

//给一个数据data，做成一个节点类型
LNode* GetNode(ElemType e)
{
	LNode * Node=(LNode *)malloc(sizeof(LNode));
	Node->data=e;
	Node->next=NULL;
	return Node;
}

3…单链表的头插法形成链表
注意：先分节点 在读数据。如果先读数据 在做节点的话会导致-1也做成节点

 void List_HeadInsert(LinkList &L)
{
	L=GetNode(0);
	int x=0;   
	while( x != -1 )
	{
		printf("请输入插入数据：");	
		LNode *s=GetNode(x);  //先分节点 在读数据。如果先读数据 在做节点的话会导致-1也做成节点
		scanf("%d",&x);
		s->next=L->next;
		L->next=s;
	}
}

4.单链表的尾插法形成链表

//尾插法建立链表
void List_TailInsert(LinkList &L)
{
	L=GetNode(0);
	LNode *p= L;
	int x=0;
	while( x != -1 )
	{
		printf("请输入插入数据：");	
		LNode *s=GetNode(x);
		scanf("%d",&x);
		s->data=x;
		p->next=s;
		p=p->next;
	}
}

5.按序号查找节点i为第几个节点

//按序号查找节点
LNode * GetElem(LinkList L,int i)
{
	int j=0;
	LNode *p=L;
	if(i<0)
		return NULL;
	while( p && j<i )
	{
		p=p->next;
		j++;
	}
	return p;
}

6.按值查到表的节点，代码简洁明了

//按值查到表的节点
LNode *LocateElem(LinkList L, ElemType e)
{
	LNode *p= L->next;
	while( p!=NULL && p->data != e)
	{
		p=p->next;
	}
	return p;
}

7.任意第 i 位置插入节点e
扩展前插操作：方法一，同下述方法可以找到i-1的节点，后插法即可；方法二，找到第 i 的节点，进行后插法，data数据进行互换。

//任意i位置插入节点
void ListInsert_i(LinkList &L,int i, ElemType e)
{
	LNode *p=GetElem(L,i-1);  //获得前驱节点
	LNode *s=GetNode(e);
	s->next=p->next;          
	p->next=s;
}

8.删除第i个位置的节点，找i-1进行删除
扩展方法：找到i，换掉 i 和 i+1的data，删除后继i+1。

//删除第i个位置的节点
void Delete_Node(LinkList &L,int i)
{
	LNode *p=GetElem(L,i-1);
	LNode *q=p->next;
	p->next=q->next;
	free(q);
}

9.单链表其他常用算法操作

//（1）递归删除不带头节点L中所有值为x的节点
void Del_x_1(LinkList &L, ElemType x)
{
	LNode *p;
	if(L == NULL)
		return;
	if(L->data == x)
	{
		p = L;
		L = L->next;
		free(p);         //注意：此处不会断链
		Del_x_1(L,x);
	}
	else
		Del_x_1(L->next,x);
}
//(2)单链表中删除所有值为x的节点
void Del_x_2(LinkList &L,ElemType x)
{
	LNode * p=L->next;
	LNode * pre=L;
	while(p!=NULL)
	{
		if(p->data ==x)
		{
			LNode *q =p;
			p=p->next;
			pre->next=p;
			free(q);
		}
		else
		{
			pre=p;
			p=p->next;
		}
	}
}
//(3)逆置链表递归法，有空间的消耗
void Reverse_Print(LinkList L)
{
	if(L->next!=NULL)
		Reverse_Print(L->next);
	if( L->data!=0)
	   printf("%d ",L->data);
}
//(4)O(n)算法删除单链表中最小的数,算法思想，冒泡法到剩最后两个数。
void Del_Min(LinkList &L)
{
	if(L->next ==NULL)
		return;
	LNode *pre=L->next;    //pre指向第一个节点
	if(pre->next==NULL)    //保证单链表有两个节点以上，若只有一个则删除第一个
	{
		L->next=NULL;
		free(pre);
	}
	LNode *p=L->next->next;//p指向第二个节点
	while(p->next!=NULL)   //遍历单链表冒泡法到最后两个数
	{
		if(pre->data > p->data )
		{
			pre=p;
			p=p->next;
		}
		else
		{
			ElemType temp=pre->data;
			pre->data=p->data;
			p->data=temp;
			pre=p;
			p=p->next;
		}
	}
	if(pre->data < p->data)  //最后两个前驱小的话,交换数据
	{
		pre->data=p->data;
	}
	pre->next=NULL;
	free(p);
}
//(5)链表的逆置，两种非递归解法，空间O(1),第（3）题是逆置的递归解法但有空间消耗
void Reverse_List_1(LinkList &L)
{
	if(L->next==NULL || L->next->next == NULL)//一个节点不用逆置，保证有两个或两个以上
		return;
	LNode *p=L->next->next;  //p从第二个节点开始头插法。
	LNode *r=p->next;        //防止断链
	L->next->next=NULL;      //第一个节点next为空
	while(p!=NULL)
	{
		p->next=L->next;
		L->next=p;
		p=r;
		if(r!=NULL)
		   r=p->next;
	}
}
void Reverse_List_2(LinkList &L)
{
	if(L->next==NULL) //保证至少有一个节点
		return;
	LNode *pre=L;     
	LNode *p=L->next; 
	LNode *r=p->next;
	p->next=NULL;
	while(r!=NULL)    //逆置并且全部后移
	{
		pre=p;
		p=r;;
		r=r->next;
		p->next=pre;
	}
	L->next=p;
}