链表的各种常见操作的C语言实现

数据结构中List链表的各种常见操作实现

PNODE CreatList();
void traverse_list (PNODE pHead);               //遍历链表
bool is_empty(PNODE pHead);                    //判断是否为空
int length(PNODE pHead);                            //求长度
void insert_list(PNODE);                               //插入一个数值
void delete_list(PNODE,int,int*);                   //删除一个数值并返回
void sort(PNODE);                                        //冒泡排序 
void Del(PNODE pHead,int x);                     //删除值链表中值为x的节点 
void R_Print(PNODE L);                               //逆序输出
PNODE Reverse(PNODE pHead);              // 逆置链表
void DelSame(PNODE pHead);                   //删除有序链表中相同的值，只保留一个
//void Del_List(PNODE pHead,int x);           //废函数，递归删除值为x的节点，好像断链了？

#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 CreatList();
void traverse_list (PNODE pHead);              //遍历链表
bool is_empty(PNODE pHead);                    //判断是否为空
int length(PNODE pHead);                       //求长度
void insert_list(PNODE);                       //插入一个数值
void delete_list(PNODE,int,int*);              //删除一个数值并返回
void sort(PNODE);                              //冒泡排序 
void Del(PNODE pHead,int x);                   //删除值链表中值为x的节点 
void R_Print(PNODE L);                         //逆序输出
PNODE Reverse(PNODE pHead);                    // 逆置链表
void DelSame(PNODE pHead);                     //删除有序链表中相同的值，只保留一个
//void Del_List(PNODE pHead,int x);            //废函数，递归删除值为x的节点，好像断链了？




int main(void)
{
	int val;
	PNODE pHead=CreatList();                    //创建一个链表
		traverse_list(pHead);                   //遍历，下同
		printf("链表长度为%d\n",length(pHead));

	insert_list(pHead);                         //插入一个数
		traverse_list(pHead); 
		printf("链表长度为%d\n",length(pHead)); 
		
	sort(pHead);                                //排序链表，用的是冒泡
		traverse_list(pHead); 
		
	delete_list(pHead,3,&val);                 
		printf("删除了%d\n",val);
		traverse_list(pHead); 
	
	return 0;
}
//—————————————————————————————————————————— 
/*void Del_List(PNODE pHead,int x)//断链了！！！！ 题目中遇见的，但这个函数实现不了
{
	PNODE p;
	if(pHead==NULL)
	return;
	if(pHead->data==3){
		p=pHead;
		pHead=pHead->pNext;
		free(p);
		Del_List(pHead,3);	
	}else{
		Del_List(pHead->pNext,3);
	}
}
*/

PNODE CreatList(){
	int len,val;
	PNODE pHead=(PNODE)malloc(sizeof(NODE));
	PNODE pTail=pHead;                            //分配了一个工具指针 
	printf("生成链表结点个数：");
	 scanf("%d",&len);
		for(int i=0;i<len;i++)                    //循环键入链表的值
		{
			printf("请输入第%d个结点的数据：",i+1);
			scanf("%d",&val);
			PNODE pNew=(PNODE)malloc(sizeof(NODE));//动态分配节点的空间
			pNew->data=val;
			pTail->pNext=pNew;
			pTail=pNew;	
			pNew->pNext=NULL;
		}
	return pHead;	                               //返回头结点
}

void DelSame(PNODE pHead){        //删除有序链表中相同的值
	PNODE q,p=pHead->pNext;
	if(pHead==NULL)
	return;
	while(p->pNext!=NULL){
		q=p->pNext;
		if(p->data==q->data){
			p->pNext=q->pNext;
			free(q);
		}else
		p=p->pNext;
	}
}

PNODE Reverse(PNODE pHead){        //逆置链表
	PNODE p,r;
	p=pHead->pNext;
	pHead->pNext=NULL;
	while(p!=NULL){
		r=p->pNext;
		p->pNext=pHead->pNext;
		pHead->pNext=p;
		p=r;
	}
	return pHead;
}

void R_Print(PNODE L){            //递归实现逆序输出
                                  //使用时用pHead
	if(L->pNext!=NULL)
		R_Print(L->pNext);
	if(L!=NULL&&L->data<9999)     //如果这里不加999，要用pHead->pnext,因为头结点里没东西
	printf("%d ",L->data);
}

void Del(PNODE pHead,int x) 
{
	while(pHead->pNext!=NULL){
		if(pHead->pNext->data==x){
			PNODE p=pHead->pNext;
			pHead->pNext=p->pNext;
			free(p);
		}else
		pHead=pHead->pNext;
	}
}

void traverse_list(PNODE pHead)
{
	PNODE pTail=pHead;
	while (pTail->pNext!=NULL)
	{
		pTail=pTail->pNext;
		printf("%d ",pTail->data);
	}
	printf("\nTraverse Over\n");
	
}

bool is_empty(PNODE pHead)
{
	if(pHead->pNext==NULL)
	return true;
	else
	return false;
}

int length(PNODE pHead)
{
	int cnt=0;
	while(pHead->pNext!=NULL)
	{
		cnt++;
		pHead=pHead->pNext;
		}	
	return cnt;
}

void insert_list(PNODE p)
{
	int po;
	int val;
	PNODE pNew=(PNODE)malloc(sizeof(NODE));
	    pNew->pNext=NULL;
	printf("插入位置："); 
	    scanf("%d",&po);
	printf("插入数据：");
	    scanf("%d",&val); 
	for(int i=1;i<po;i++){
		p=p->pNext;
	}
	pNew->pNext=p->pNext;
	p->pNext=pNew;
	pNew->data=val;
	
}

void sort(PNODE pHead)                        //冒泡排序链表
{
	int i,j,k;
	PNODE p,q;
	int len=length(pHead);
	for(p=pHead->pNext;p!=NULL;p=p->pNext)
	{
		for(q=p->pNext;q!=NULL;q=q->pNext)    //注意这里的pq代替了i++j++
		{
				if(p->data>q->data){
					k=p->data;
					p->data=q->data;
					q->data=k;
				}
		}
	}
	
	return ;
}

void delete_list(PNODE pHead,int po,int *pval)
{
	int i;
	PNODE p=pHead;
	for(i=1;i<po;i++)
	{
		p=p->pNext;
	}
	PNODE q=p->pNext;
	*pval=q->data;
	p->pNext=q->pNext;
	free(q);
	q=NULL;
//	return val;
}