c语言实现链表的相关的操作

最近复习了一下C语言数据结构的内容，实现了C语言链表的相关的操作，链表采用的是带有头结点的链表，个人觉得这种方式操作链表的时候比较的方便，对于插入或删除首节点的时候比较的方便。

#include<stdio.h>
#include <malloc.h>
#include<stdlib.h>
#include <math.h>

typedef struct Node 
{
	int data;				//数据域
	struct Node *pNode;                    //指针域
	
}NODE,*PNODE;

//函数申明
struct Node* creat_list();									//创建一个链表
void traverse_list(struct Node* pHead) ;		//将链表遍历输出
void nixutraverse_list(struct Node* pHead) ;		//将链表遍历输出
void maxsort_list(struct Node*pHead);			//将链表按照从大到小的顺序排列
void minsort_list(struct Node*pHead);			//将链表按照从小到大的顺序排列
void clear_list(struct Node*);						//将链表清空
void destroy_list(struct Node*pHead);
bool delete_list(struct Node*pHead,int,int*); //删除链表的元素
bool insert_list(struct Node*pHead,int,int);  //在链表中插入一个元素//在pHead所指向的链表的第pos个节点前面插入一个新的节点，该节点的值是val，并且pos的值从1
bool is_empty(struct Node*pHead);				//判断链表是否为空
int find(struct Node*pHead,int);					//查找链表中的元素
struct Node* delete_list(struct Node*pHead,int pos,int num);
//1开始

int length_list(struct Node*pHead);					//链表的长度
void clear_zero(struct Node*pHead);
int main()
{
	int num;
	struct Node* pHead =NULL;
	pHead=creat_list();	//创建一个非循环的单链表，并将该链表的头节点的地址付给PHEAD
	//maxsort_list(pHead);
	//destroy_list(pHead);
	traverse_list(pHead);
	//clear_list(pHead);
				
	if(is_empty(pHead))
		printf("链表为空\n");
	else
		printf("链表不为空\n");
	int a=length_list(pHead);
	printf("链表的长度为%d\n",a);
	int c,d;
	scanf("%d%d",&c,&d);
	printf("你将要在第%d的位置上插入数%d\n",c,d);
	if(insert_list(pHead,c,d))
		printf("添加成功\n");
	else
		printf("添加失败\n");
	traverse_list(pHead);
	printf("\n");
	int pos,s,n;
	scanf("%d",&pos);
	printf("你将要删除第%d个元素",pos);
	if(delete_list(pHead,pos,&num))
		printf("删除成功,删除了%d\n",num);
	else
		printf("删除失败\n");
	//minsort_list(pHead);
	//maxsort_list(pHead);
	nixutraverse_list(pHead);
	traverse_list(pHead);
	struct Node *p=pHead->pNode;
	printf("%d\n",p->data);
	printf("输入你要查找的元素：");
	scanf("%d",&n);
	s=find(pHead,n);
	if(s==-1)
		printf("查找失败，没有这个元素");
	else
		printf("你要查找的元素是滴%d个元素",s+1);
	clear_zero(pHead);
		traverse_list(pHead);
	return 0;
}


//创建一个链表
struct Node* creat_list()
{
	int len;		//用来存放有效节点的个数
	int val;		//用来临时存放用户输入节点的值
	printf("请输入您要生成的链表节点的个数len=");
	scanf("%d",&len);
	
	struct Node* pHead =(struct Node*)malloc(sizeof(struct Node));
	
	struct Node*pTail=pHead;
	pTail->pNode=NULL;
	
	if(NULL==pHead)
	{
								printf("分配内存失败，程序终止\n");
								exit(-1);
	}
	for(int i=0;i<len;i++)
	{
								printf("请输入第%d个节点的值：",i+1);
								scanf("%d",&val);
								//为每一个节点分配内存
								struct Node* pnew =(struct Node*)malloc(sizeof(struct Node));
								if(NULL==pnew)
								{
									printf("分配内存失败，程序终止\n");
									exit(-1);
								}
								pnew->data=val;
								pTail->pNode=pnew;
								pnew->pNode=NULL;
								pTail=pnew;
	}
	return pHead;
}

//链表的正序输出
void traverse_list(struct Node* pHead) 
{
	struct Node *p=pHead->pNode;
	while(NULL!=p)
	{
		printf("%d ",p->data);
		p=p->pNode;
	}
	printf("\n");
}

//链表的逆序输出
void nixutraverse_list(struct Node* pHead)
{
	struct Node * current;
	struct Node *p;
	current=pHead->pNode;
	while(current->pNode!=NULL)
	{
		p=current->pNode;
		current->pNode=p->pNode;
		p->pNode=pHead->pNode;
		pHead->pNode=p;
	}
}

//判断链表是否为空
bool is_empty(struct Node*pHead)
{
	if(pHead->pNode==NULL)
		return true;
	else 
		return false;
}

//计算链表的长度
int length_list(struct Node*pHead)
{
	int cnt=0;
	struct Node *p=pHead->pNode;
	while(p!=NULL)
	{
		cnt++;
		p=p->pNode;
	}
	return cnt;
}

//在pHead所指向的链表的第pos个节点前面插入一个新的节点，该节点的值是val，并且pos的值从1
//1开始
bool insert_list(struct Node*pHead,int pos,int val)
{
	
	int c=0;
	struct Node *p=pHead;
	while(c<pos-1)
	{
		c++;
		p=p->pNode;
	}
	if(c>pos-1 || NULL==p)
		return false;
	struct Node *r;
	struct Node *q=(struct Node*)malloc(sizeof(struct Node));
	if(NULL==q)
	{
		printf("分配内存失败，程序终止\n");
		exit(-1);
	}
	q->data=val;
	r=p->pNode;
	p->pNode=q;
	q->pNode=r;
	return true;
}


bool delete_list(struct Node*pHead,int pos,int* val)//删除链表的元素
{
	int c=0;
	struct Node* p=pHead;
	while(c<pos-1 && NULL!=p)
	{
		c++;
		p=p->pNode;
	}
	if(c>pos-1 || NULL==p)
		return false;
	*val=p->pNode->data;
	struct Node *r;
	r=p->pNode;
	p->pNode=p->pNode->pNode;
	free(r);
	return true;
}

//将链表按照从小到大的顺序排列
void maxsort_list(struct Node*pHead)		
{
	int i,j,t;
	struct Node * p;
	struct Node *q;
	int len=length_list(pHead);
	for(i=0,p=pHead->pNode;i<len-1;i++,p=p->pNode)
	{
		for(j=i+1,q=p->pNode;j<len;j++,q=q->pNode)
		{
			if(p->data>q->data)		
			{
				t=p->data;					
				p->data=q->data;		
				q->data=t;			
			}
		}
	}
}

//将链表从大到小输出
void minsort_list(struct Node*pHead)
{
	struct Node*p;
	struct Node*q;
	int i,j,t;
	int len=length_list(pHead);
	for(i=0,p=pHead->pNode;i<len-1;i++,p=p->pNode)
	{
		for(j=i+1;q=p->pNode;j++,q=q->pNode)
		{
			if(p->data<q->data)
				t=p->data;
			p->data=q->data;
			q->data=t;
		}
	}
}

int find(struct Node*pHead,int val)					
{
	//maxsort_list(pHead);
	int mid,low,high,i=0;
	struct Node*p=pHead->pNode; 
	low=0;
	high=length_list(pHead)-1;
	while(low<=high)
	{
		mid=(low+high)/2;
		while(i<mid)
		{
			p=p->pNode;	
			i++;  
		}
		if(p->data>val)
			low=mid+1;
		else if(p->data<val)
			high=mid-1;
		else
			return mid;	
		p=pHead->pNode;
		i=0;
	}
	return -1;
}
void clear_list(struct Node*pHead)
{
	
	if(is_empty(pHead))
		return;
	else
	{
		struct Node*p=pHead->pNode;
		struct Node*q;
		while(p!=NULL)
		{
			q=p->pNode;
			free(p);
			p=q;
		}
	}
	pHead->pNode=NULL;
}
//线性表L已存在。操作结果：销毁线性表L
void destroy_list(struct Node*pHead)
{
	struct Node *p=pHead->pNode;
	struct Node *q;
	while(q!=NULL)
	{
		q=p->pNode;
		free(p);
		p=q;
	}
	
}

//删除链表中所有为k的节点
struct Node* delete_list(struct Node*pHead,int pos,int num)
{
	struct Node* p=pHead,*q;
	q=p->pNode;
	while(q!=NULL){
		if(q->data==pos)
		{
			p->pNode=q->pNode;
				q=q->pNode;
		}
		else{
			p=q;
			q=q->pNode;
				}
	}
	if(pos==pHead->data)
	pHead=pHead->pNode;
	return pHead;
}

void clear_zero(struct Node*pHead)
{
	struct Node*p=pHead,*q;
		q=p->pNode;
		while(q!=NULL)
		{
			if(fabs(q->data)<=0.0000001)
			{	
			p->pNode=q->pNode;
			free(q);
			q=p->pNode;	
			}
			else
			{
				p=p->pNode;
				q=q->pNode;
			}
		}
}