离散存储-链表 （创建、遍历、排序、插入、删除） 郝斌老师-数据结构

#include <stdio.h>
#include<malloc.h>
#include<stdlib.h>
typedef struct Node
{
	int data;//数字域，数字域可以很复杂
	struct Node *pNext;//指针域
}NODE, *PNODE;//NODE等价于struct Node，PNODE等价于struct Node *

//函数声明,把结构体声明放到最上面，没声明之前NODE，PODE没法使用
PNODE create_list(void);//创建链表不需要参数
void traverse_list(PNODE pHead);//遍历不需要返回值
bool is_empty(PNODE pHead);//判断链表是否为空，一般不会判断链表是否为满
int length_list(PNODE);//测试链表的长度

//在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值是val，并且pos的值是从1开始
bool insert_list(PNODE, int, int);//PNODE表示链表，int插入的位置，int需要插入的数值

bool delete_list(PNODE, int, int*);//PNODE表示链表，int删除的是那一个节点,可以将删除的节点的参数放到int*里
//调用形式：delet_list(pHead, 3,&val);

void sort_list(PNODE);//排序
int main(void)

{
	PNODE pHead = NULL;//等价于struct Node *pHead=NULL
	int val;
	pHead = create_list();//create_list（）功能：创建一个非循环单链表，并将该链表的头结点的地址赋给pHead
	traverse_list(pHead);//traverse_list访问遍历，将链表中的内容逐一访问
	
	insert_list(pHead, 3, NULL);
	traverse_list(pHead);

	if (delete_list(pHead, 4, &val))
	{
		printf("删除成功，您删除的元素是： %d\n", val);
	}
	else
	{
		printf("删除失败！\n");
	}


	int len = length_list(pHead);
	printf("链表的长度是%d\n", len);
	
	sort_list(pHead);
	traverse_list(pHead);
	
	if (is_empty(pHead))
		printf("链表为空！\n");
	else
		printf("链表不空！\n");
	return 0;
}

PNODE create_list(void)
{
	int len;//用来存放有效节点的个数
	int i;
	int val;//用来临时存放用户输入的节点的值
	
	//分配了一个不存放有效数据的头结点，pHead是头指针，指向的是头结点
	PNODE pHead = (PNODE)malloc(sizeof(NODE));//sizeof（NODE）返回节点本身的数据类型
	if (NULL == pHead)//一定要判断申请内存是否成功
	{
		printf("分配失败，程序终止！\n");
		exit(-1);
	}

	//pTail永远指向尾节点
	PNODE pTail = pHead;//将pHead赋给pTail，两者都指向头结点
	pTail->pNext = NULL;//将pTail的指针域清空，使得pTail永远指向尾节点
	printf("请输入你需要生成的的链表节点的个数：len= ");
	scanf_s("%d", &len);
	//在for循环前面先生成头结点，再生成有效节点
	for (i = 0; i < len; i++)
	{
		printf("请输入第%d个节点的值", i+1);//生成有效节点的值
		scanf_s("%d", &val);
		
		//p指向一个临时分配的节点，循环一次p就指向临时分配的新的节点，然后挂到已有的节点的后面
		//每循环一次，就有一个新节点pNew（分配新的节点）
		PNODE pNew = (PNODE)malloc(sizeof(NODE));
		if (NULL == pNew)//一定要判断申请内存是否成功
		{
			printf("分配失败，程序终止！\n");
			exit(-1);
		}
		
		/*//存在问题（生成的节点全部挂到了头结点的后面且指针域全为空）
		pNew->data = val;//pNew生成一个临时节点，将val的数据放到临时节点的数据域中
		pHead->pNext = pNew;//将新节点挂到pHead的尾节点，pHead指向头结点的指针域是pNew
		pNew->pNext = NULL;//将临时指针域清空，临时节点已变成最后节点*/

		//解决问题的方法是定义一个指针，永远指向最后一个节点
		//生成的节点不是挂到头结点的后面，而是挂到整个链表的节点的后面
		pNew->data = val;
		pTail->pNext = pNew;//pNew挂到了尾节点的后面
		pNew->pNext = NULL;//新节点变成尾节点
		pTail = pNew;//pNew赋给pTail，尾节点的名字变为pTail
	}
	return pHead;
}

void traverse_list(PNODE pHead)
{
	PNODE p = pHead->pNext;//p指向第一个有效节点，p的值可能为空，则只有一个头结点无有效节点
	
//p的指针域不为空，输出数值data，同时p向后移动一个节点，否则只输出数值data
	while (NULL != p)//意味着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 = pHead->pNext;//p指向的节点不为空，len+1，直到p指向为NULL
	int len = 0;
	while (NULL != p)
	{
		len++;
		p = p->pNext;
	}
	return len;
}

//数组排序函数
/*数组的排序算法：升序排列
{
	int i, j, t, len;
	for (i = 0; i < len - 1; i++)
	{
		for (j = i + 1; j < len; j++)
		{
			if (a[i] > a[j])
			{
				t = a[i];
				a[i] = a[j];
				a[j] = t;
			}
		}
	}

}*/

//链表排序，对比数组的排序
void sort_list(PNODE pHead)
{
	int i, j, t;
	 int len = length_list(pHead);
	PNODE p, q;

	//i=0是数组中第一个有效元素的下标，p=pHead->pNext是链表中第一个有效元素的地址
	for (i = 0,p=pHead->pNext; i < len- 1; i++,p=p->pNext)
	{//j是数组中a[i]下一个元素的下标，q是p的下一个节点
		for (j = i + 1,q=p->pNext; j < len; j++,q=q->pNext)
		{
			if (p->data>q->data)//类似于数组中：a[i] > a[j]
			{
				t = p->data;      //类似于数组中：t = a[i];
				p->data = q->data;//类似于数组中：a[i] = a[j];
				q->data = t;      //类似于数组中：a[j] = t;
			}
		}
	}
	return;
}

//在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值是val，并且pos的值是从1开始
//链表一般不存在满的问题，但是要判断pos的值链表的长度的大小，如pos=10，链表的长度i=5，不可插入
//插入不须确保第pos个节点是存在的，删除必须确保第pos节点是存在的
bool insert_list(PNODE pHead, int pos, int val)
{
	int i = 0;
	PNODE p = pHead;

	//不需要判断链表是否为空，是否溢出，同时也不需要求链表的长度
	//最后结果为（pos-1）结束循环，若链表的长度为（pos-1），插入的位置的数最大是pos即链表的最后一位
	//如链表的长度为5，插入的节点的值最大为6
	while(NULL != p&&i < pos - 1)//在第pos个节点插入，必须确保pos的前一个节点存在
	{
		p = p->pNext;
		i++;
	}
	if (i > pos - 1 || NULL == p)
		return false;//搞定
	

	//如果程序能执行到这一行说明p已经指向了第pos-1个结点,但第pos-1个节点是否存在无所谓
	//分配新的结点
	PNODE pNew = (PNODE)malloc(sizeof(NODE));//一定要判断申请内存是否成功
	if (NULL == pNew)
	{
		printf("动态内存分配失败！\n");
		exit(-1);
	}
	pNew->data = val;

	//将新的结点存入p节点的后面
	PNODE q = p->pNext;
	p->pNext = pNew;
	pNew->pNext = q;
	return true;
}

//删除节点
bool delete_list(PNODE pHead, int pose, int *pVal)
{
	int i = 0;
	PNODE p = pHead;
	while (NULL != p->pNext&&i < pose - 1)//必须确保第pos个节点是存在的
	{
		p = p->pNext;
		i++;
	}
	if (NULL == p->pNext || i > pose - 1)
		return false;

	//如果程序能执行到这一行说明p已经指向了第pos-1个结点，并且第pos个节点是存在的
	PNODE q = p->pNext;//q指向待删除的结点
	*pVal = q->data;

	//删除p节点后面的节点
	p->pNext = p->pNext->pNext;

	//释放q所指向的节点所占的内存
	free(q);
	q = NULL;

	return true;
}

[注]：刚开始学习链表，可能存在理解上的误差