王道第二章【链表】

1.

void Delete(LNode *&L,int x)
{
   
	LNode *p; //p指向待删除结点
	if(L == NULL) //递归出口
		return;
	if(L->data == x) //若L所指结点的值为x
	{
   
		p = L;
		L = L->next;
		free(p);
		Delete(L,x); //递归调用
	}
	else //若L所指结点的值不为x
	{
   
		Delete(L->next,x); //递归调用
	}
}

2.

//要删除一个结点必须知道其前驱结点
void Delete(LNode *&L,int x)
{
   
	LNode *p = L->next; 
	LNode *pre = L;
	LNode *q;
	while(p != NULL)
	{
   
		if(p->data == x)
		{
   
			q = p; //q
			p = p->next;
			pre ->next = p;
			free(q);
		}
		else
		{
   
			pre = p;
			p = p->next;
		}
	}
}

void Delete(LNode *&L,int x)
{
   
	LNode *p = L-next; //p为工作指针，用来扫描整个链表，指向开始结点
	LNode *r = L; //r指向尾结点，其初值为头结点
	LNode *q;
	while(p != NULL)
	{
   
		if(p->data != x) //p结点不为x时将其链接到L尾部
		{
   
			r->next = p;
			r = p; //r始终指向尾结点
			p = p-next; //继续扫描
		}
		else
		{
   
			q = p; //接收要被删除的结点
			p = p->next; //继续扫描
			free(q);
		}
	}
	r-next = NULL;
}

3.

void RePrint(LNode *L)
{
   
	if(L-next != NULL)
	{
   
		RePrint(L->next); //递归
	}
	print(L->data); //输出函数
}

4.

void DeleteMin(LNode *&L)
{
   
	LNode *p = L->next;
	LNode *pre = L;
	LNode *minp = p;
	LNode *preminp = pre;
	while(p != NULL)
	{
   
		if(p->data < minp->data)
		{
   
			minp = p;
			preminp = pre;
		}
		pre = p;
		p = p->next;
	}
	preminp->next = minp->next;
	free(minp);
}

5.

void Reverse(LNode *L)
{
   
	LNode *p = L->next; //p为工作指针，用来扫描整个链表
	LNode *r; //r为p的后继，以防断链
	L->next = NULL; //将头结点L的next域置为NULL
	while(p != NULL) //头插法建立链表
	{
   
		r = p->next; //暂存p结点的后继
		p->next = L->next;
		L-next = p;
		p = r;
	}
}

void Reverse(LNode *L)
{
   
	LNode *pre;
	LNode *p = L->next;
	LNode *r = p->next;
	p->next = NULL; //处理第一个结点
	while(r != NULL) //r为空则说明p为最后一个结点
	{
   
		pre = p; //依次继续遍历
		p = r;
		r = r->next;
		p->next = pre; //指针反转
	}
	L->next = p; //处理最后一个结点
}

6.

void Sort(LNode *&L)
{
    //本算法实现将单链表L的结点重排，使其递增有序
	LNode *p = L->next;
	LNode *pre;
	LNode *r = p->next; //r保持*p后继结点指针，以保证不断链
	p->next = NULL; //构造只含一个数据结点的有序表
	p = r;
	while(p != NULL)
	{
   
		r = p->next; //保存*p的后继结点指针
		pre = L;