数据结构 ——单链表操作的算法

单链表操作的算法：

#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 *

PNODE create_list(void);                             //创建链表函数声明
void traverse_list(PNODE pHead);	 	     //遍历链表函数声明
bool is_empty(PNODE pHead);		             //判断链表为空函数声明
int length_list(PNODE pHead);                        //计算链表长度函数声明
void sort_list(PNODE pHead);                         //排序函数声明
bool insert_list(PNODE pHead,int pos,int Val);       //插入函数声明
bool delete_list(PNODE pHead,int pos,int *pVal);     //删除函数声明


int main(void)
{
	PNODE pHead=NULL;                            //等价于struct Node*pHead=NULL
	int val;

	pHead=create_list();                         //创建链表
	printf("原始链表是：");
	traverse_list(pHead);

	if(is_empty(pHead))
		printf("链表为空！\n");
	else
		printf("链表不为空！\n");

	int len=length_list(pHead);
		printf("链表的长度是%d\n",len);
	
	sort_list(pHead);
	printf("链表排序后顺序：\n");
	traverse_list(pHead);
	

	insert_list(pHead,2,54);
	printf("在链表第二个位置插入54后是：\n");
	traverse_list(pHead);
	
	if(delete_list(pHead,3,&val))
		printf("删除第三个元素成功是：%d\n",val);
	else
		printf("删除失败！\n");

	return 0;
}

PNODE create_list(void)                               //不需要参数
{
	int len;                                      //用来存储有效节点的个数
	int val;                                      //临时存放数据节点的值
	
	PNODE pHead=(PNODE)malloc(sizeof(NODE));      //动态申请，返回NODE结点本身
	if(NULL==pHead)
	{
		printf("分配失败，终止程序！\n");
		exit(-1);
	}
	PNODE pTail=pHead;
	pTail->pNext=NULL;                            //指针域清空

	printf("您输入的单链表的节点个数是：len=");
	scanf("%d",&len);

	for(int i=0;i<len;++i)
	{
		printf("请输入第%d个节点的值",i+1);
		scanf("%d",&val);
		
		PNODE pNew=(PNODE)malloc(sizeof(NODE));
		if(NULL==pNew)
		{
			printf("分配失败，终止程序！\n");
			exit(-1);
		}
		pNew->data=val;

		pTail->pNext=pNew;
		pNew->pNext=NULL;
		pTail=pNew;
	}
	return pHead;
}

void traverse_list(PNODE pHead)
{
	PNODE p=pHead->pNext;                     //p先指向第一个节点

	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=pHead->pNext;
	int len=0;
	while(NULL!=p)
	{
		++len;
		p=p->pNext;
	}
	return len;
}

void sort_list(PNODE pHead)
{
	int i,j,t;
	int len=length_list(pHead);
	PNODE p,q;

	for(i=0,p=pHead->pNext;i<len-1;++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;
			}
		}
	}
	return ;
}

bool insert_list(PNODE pHead,int pos,int val)
{
	int i=0;
	PNODE p=pHead;

	while(NULL!=p && i<pos-1)
	{
		p=p->pNext;
		++i;
	}
	if(NULL==p || i>pos-1)
		return false;	
	
	
	PNODE pNew=(PNODE)malloc(sizeof(NODE));
	if(NULL==pNew)
	{
		printf("内存分配失败，程序终止！\n");
		exit(-1);
	}
	pNew->data=val;

	pNew->pNext=p->pNext;       //也可以是：PNODE q=p->Next; p->pNext=pNew; pNew->pNext=q;
	p->pNext=pNew;                

	return true;
}

bool delete_list(PNODE pHead,int pos,int *pVal)
{
	int i=0;
	PNODE p=pHead;

	while(NULL!=p->pNext && i<pos-1)
	{
		p=p->pNext;
		++i;
	}
	if(NULL==p->pNext || i>pos-1)
		return false;

	PNODE q=p->pNext;
	*pVal=q->data;

	p->pNext=p->pNext->pNext;        //删除p节点后面的结点
	free(q);
	q=NULL;

	return true;
}