链表的相关操作算法

1、创建单链表的步骤
                       构造一个头结点
                       构造一个尾节点并初始化使其和头结点相同
                       尾节点的指针域置空
                       利用循环创建新节点赋值并挂在尾节点上
                       新节点指针域置空
                       新节点变为尾节点  见程序实现
2、链表遍历
                         定义指针p
                         初始化p为首节点
                         利用循环p输出p中数据域内容
                         指针p下移直至为空   见程序

3、链表插入节点算法

         源于：大话数据结构

4.链表删除节点算法

源于：大话数据结构

5、链表排序算法 见程序

6、链表倒置算法（觉得倒置相对于链表的其他算法一时比较难理解现做详细说明）

                      1、定义两个指针p，q    

                       2、头结点指针域清空

                       3、q指向p指向的节点

                       4、p指向下一节点

                       5、q指向头结点指向的节点

                       6、头结点指向q

      执行顺序：                1、2、3、4、5、6判断p是否为空不空返回执行3

       伪算法如下：

                                   

void reserve(Listlist L)
{
  Lnode *p;
  p=L->next;
  L->next=NULL;
  while(p)
   { 
      q=p; 
      p=p->next;
      q->next=L->next;
      L->next=q;
   }
}

下图为其算法分解示意图

图中1 2  3 分别代表第一次第二次第三次循环

7、其余算法相对比较好理解见程序

#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>					//包含exit函数

typedef struct Node
{
	int data;
	struct Node *pNext;			
}NODE,*pNODE;						//NODE 相当于struct Node ；pNODE相当于struct Node*	
/*函数声明*/

pNODE creat_list();					//创建一个单链表
void travese_list(pNODE pHead);		//遍历单链表
bool is_empty(pNODE pHead);			//判断链表是否为空
void sort_list(pNODE pHead);		//给链表里面的数据排序
int length_list(pNODE pHead);		//计算链表的长度
bool insert_list(pNODE pHead, int pos, int val);//在第pos个节点前插入一个节点值为val
bool delete_list(pNODE pHead, int pos,int *pVal);//删除第pos个节点把值放入val中
int get_elem(pNODE pHead,int pos);				//获取第pos个节点的值
void inverse_list(pNODE pHead);				//将链表内的数据倒置

int main (void)
{
	int len;
	int val;
	int get_val;
	pNODE pHead = NULL;
	pHead = creat_list();
	travese_list(pHead);
	if(is_empty(pHead))
		printf("链表为空\n");
	len = length_list(pHead);
	printf("链表长度是：%d\n", len);
	insert_list(pHead,3,44);       //在第三个节点前插入值为44
	travese_list(pHead);
	delete_list(pHead, 4,&val);		//删除第四个节点，把值放入val中
	printf("删除元素为%d\n",val);
	travese_list(pHead);
	sort_list(pHead);
	printf("排序后的数组显示为\n");
	travese_list(pHead);
	get_val = get_elem(pHead,3);
	printf("获取的元素为%d\n",get_val);
	inverse_list(pHead);
	travese_list(pHead);
	return 0;
}
pNODE creat_list()
{
	int len;
	int val;	
	printf("请输入创建列表的长度\n");
	scanf("%d",&len);
	pNODE pHead = (pNODE) malloc(sizeof(NODE));
	if(NULL == pHead)
		{
			printf("链表创建失败\n");
			exit (-1);
	}
	pNODE pTail = pHead;				//一定要定义一个尾指针每次把创建的节点挂在尾指针上
	pTail->pNext = NULL;
	for(int i = 0; i < len; i++)
	{
		printf("请输入第%d各元素的值\n",i+1);
		scanf("%d",&val);
		pNODE pNew = (pNODE) malloc(sizeof(NODE));	//犯的错误：pNODE 必须用括号括起
		if(NULL == pNew)
		{
			printf("链表创建失败\n");
			exit (-1);
		}
		pNew->data = val;
		pTail->pNext = pNew;
		pNew->pNext = NULL;
		pTail = pNew;
	}
	return pHead;
}
void travese_list(pNODE pHead)
{
	pNODE p = pHead->pNext;
	while(NULL != p)
	{
		printf("%d ",p->data);
		p = p->pNext;
	}
	printf("\n");
	return;
}
bool is_empty(pNODE pHead)
{
	if(NULL == pHead->pNext)
		return true;
	else 
		return false;
}
int length_list(pNODE pHead)
{
	pNODE p;
	int len = 0;
	p = pHead->pNext;
	while(NULL != p)
	{
		++len;
		p = p->pNext;
	}
	return len;
}
void sort_list(pNODE pHead)										//和数组的操作基本样 冒泡排序
{
	int i, j, t,len = length_list(pHead);
	pNODE p, q;
	for(i = 0,p = pHead->pNext; i < len; i++, p = p->pNext)
	{
		for(j = i+1, q= p->pNext; j<len; j++,q = q->pNext)
		{
			if(p->data > q->data)
			{
				t = p->data;
				p->data = q->data;
				q->data = t;
			}
		}
	}
}
bool insert_list(pNODE pHead, int pos, int val)
{
	pNODE p = pHead->pNext;
	int i = 1;
	while(i < pos-1 && NULL != p)
	{
		p = p->pNext;
		++i;
	}
	if(pos < 1 || pos > length_list(pHead)+1)
	{
		printf("插入链表节点失败\n");
		exit(-1);
	}
	pNODE pNew = (pNODE)malloc(sizeof(Node));
	if(NULL == pNew)
	{
		printf("动态内存分配失败\n");
		exit(-1);
	}
	pNew->data = val;
	pNew->pNext = p->pNext;
	p->pNext = pNew;
	return true;
}
bool delete_list(pNODE pHead, int pos,int *pVal)
{
	pNODE p = pHead->pNext;
	int i = 1;
	while(i < pos-1 && NULL != p)
	{
		p = p->pNext;
		++i;
	}
	if(pos < 1 || pos > length_list(pHead))
	{
		printf("删除链表节点失败\n");
		exit(-1);
	}
	pNODE q = p->pNext;
	*pVal = q->data;
	p->pNext = q->pNext;
	free(q);
	q = NULL;
	return true;
}
int get_elem(pNODE pHead,int pos)
{
	pNODE p = pHead->pNext;
	int i = 1;
	while(i < pos && NULL != p)
	{
		p = p->pNext;
		++i;
	}
	if(pos < 1 || pos > length_list(pHead))
	{
		printf("非法位置获取\n");
		exit(-1);
	}
	int val = p->data;
	return val;
}
void inverse_list(pNODE pHead)
{
	pNODE p;
	pNODE q;
	p = pHead->pNext;
	pHead->pNext = NULL;
	while(p != NULL)
	{ 
		q = p; 
	    p = p->pNext;
	    q->pNext = pHead->pNext;
	    pHead->pNext = q;
	}									
	return;
}

输入链表长度4 各元素值 22、 10 、15 、8程序运行如下：

请输入创建列表的长度
4
请输入第1各元素的值
22
请输入第2各元素的值
10
请输入第3各元素的值
15
请输入第4各元素的值
8
22 10 15 8
链表长度是：4
22 10 44 15 8
删除元素为15
22 10 44 8
排序后的数组显示为
8 10 22 44
获取的元素为22
44 22 10 8
请按任意键继续. . .