链表常用函数总结

//创建单链表  
PNODE creat_list()
{
	int len;
	int i;
	int val;
	PNODE pHead=NULL;
	pHead=(PNODE)malloc(sizeof(NODE));
	if(NULL==pHead)
	{
		printf("分配内存失败，请重新输入"); 
	}
	PNODE pTail=pHead;
	pTail->Next=NULL;
	printf("请您输入需要链表的的个数%d",len); 
	scanf("%d",&len);
	for(i=0;i<len;i++)
	{
		printf("请您输入链表的%d个节点的值",i+1);
		scanf("%d",&val);
		PNODE pNew=(PNODE)malloc(sizeof(NODE));
		pNew->data=val;
		pTail->Next=pNew;
		pNew->Next=NULL;
		pTail=pNew;
	}
	return pHead;
}

//遍历输出 
void traverse_list(PNODE pHead)
{
   PNODE p=NULL;
   p=pHead->Next;
   while(p)
    {
	    printf("%d ",p->data);
    	p=p->Next;
    }	
    printf("\n");
    return;
}

//判断是否为空 
bool empty_list(PNODE pHead)
{
	if(NULL==pHead->Next)
	return true;
	else
	return false;
}

//求链表长度 
int length_list(PNODE pHead)
{
	
	PNODE p=pHead->Next;
	int len=0;
	while(NULL!=p)
	{
		++len;
		p=p->Next;
	}
	return len;
}

//排序 
void sort_list(PNODE pHead)
{
	int i,j,t;
	int len=length_list(pHead);
	PNODE p,q;
	for(i=0,p=pHead->Next;i<len-1;i++,p=p->Next)
	{ 
		for(j=i+1,q=p->Next;j<len;j++,q=q->Next)
		{
			if(p->data>q->data)//类似于数组中的：a[i]>a[j] 
			{
				t=p->data;//类似于数组中的：a[i]>a[j] 
				p->data=q->data;//a[i]=a[j]
				q->data=t;//a[j]=t
			}
		}
	}
return;
}

//在pHead所指向链表的第pos个节点的前面插入一个新节点，该节点的值是val，并且pos的值是从1开始 
bool insert_list(PNODE pHead,int pos,int val )
{
	int i=0;
	PNODE p=pHead;
	while(NULL!=p&&i<pos-1)
	{
		p=p->Next;
		i++;
	}
	if(i>pos-1||NULL==p)
	return false;
	PNODE pNew=(PNODE)malloc(sizeof(NODE));
	if(NULL==pNew)
	{
		printf("动态内存分配失败！\n");
	    exit(-1);
	}
	pNew->data=val;
	PNODE q=p->Next;
	p->Next=pNew;
	pNew->Next=q;
	return true;
}

//删除某个节点的值 
bool delete_list(PNODE pHead,int pos,int *pVal)
{
	int i=0;
	PNODE p=pHead;
	while(NULL!=p->Next&&i<pos-1)
	{
		p=p->Next;
		i++;
	}
	if(i>pos-1||NULL==p->Next)
	return false;
	PNODE q=p->Next; 
	//存放被删除的那个 
	*pVal=q->data;
	//删除p节点后面的节点 
	p->Next=p->Next->Next;
	free(q);
	q=NULL;
	return true;
}

 完整代码如下：

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
typedef struct st{
	int data;
	struct st*Next;
}NODE,*PNODE; 
PNODE creat_list();
void traverse_list(PNODE pHead);
bool empty_list(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;
	int val;
	pHead=creat_list();
	traverse_list(pHead);
    if(delete_list(pHead,4,&val)){
    	printf("删除成功，您删除的元素是:%d\n",val);
	}
	else
	{
		printf("删除失败！您删除的元素不存在\n");
	}
	//insert_list(pHead,4,33);
	traverse_list(pHead);
	//int len=length_list(pHead);
	//printf("链表长度为%d\n",len);
	//sort_list(pHead);
	//traverse_list(pHead);
	/*if(empty_list(pHead))
	  printf("链表为空");
	else
	  printf("链表不空"); */
}
//创建单链表  
PNODE creat_list()
{
	int len;
	int i;
	int val;
	PNODE pHead=NULL;
	pHead=(PNODE)malloc(sizeof(NODE));
	if(NULL==pHead)
	{
		printf("分配内存失败，请重新输入"); 
	}
	PNODE pTail=pHead;
	pTail->Next=NULL;
	printf("请您输入需要链表的的个数%d",len); 
	scanf("%d",&len);
	for(i=0;i<len;i++)
	{
		printf("请您输入链表的%d个节点的值",i+1);
		scanf("%d",&val);
		PNODE pNew=(PNODE)malloc(sizeof(NODE));
		pNew->data=val;
		pTail->Next=pNew;
		pNew->Next=NULL;
		pTail=pNew;
	}
	return pHead;
}
//遍历输出 
void traverse_list(PNODE pHead)
{
   PNODE p=NULL;
   p=pHead->Next;
   while(p)
    {
	    printf("%d ",p->data);
    	p=p->Next;
    }	
    printf("\n");
    return;
}
//判断是否为空 
bool empty_list(PNODE pHead)
{
	if(NULL==pHead->Next)
	return true;
	else
	return false;
}
//求链表长度 
int length_list(PNODE pHead)
{
	
	PNODE p=pHead->Next;
	int len=0;
	while(NULL!=p)
	{
		++len;
		p=p->Next;
	}
	return len;
}
/*狭义的算法是与数据的存数方式密切相关
广义的算法是与数据的存储方式无关
泛型：
利用某种技术达到的效果就是:不同的存数方式，执行的操作一样的 
*/ 
//排序 
void sort_list(PNODE pHead)
{
	int i,j,t;
	int len=length_list(pHead);
	PNODE p,q;
	for(i=0,p=pHead->Next;i<len-1;i++,p=p->Next)
	{ 
		for(j=i+1,q=p->Next;j<len;j++,q=q->Next)
		{
			if(p->data>q->data)//类似于数组中的：a[i]>a[j] 
			{
				t=p->data;//类似于数组中的：a[i]>a[j] 
				p->data=q->data;//a[i]=a[j]
				q->data=t;//a[j]=t
			}
		}
	}
return;
}
//在pHead所指向链表的第pos个节点的前面插入一个新节点，该节点的值是val，并且pos的值是从1开始 
bool insert_list(PNODE pHead,int pos,int val )
{
	int i=0;
	PNODE p=pHead;
	while(NULL!=p&&i<pos-1)
	{
		p=p->Next;
		i++;
	}
	if(i>pos-1||NULL==p)
	return false;
	PNODE pNew=(PNODE)malloc(sizeof(NODE));
	if(NULL==pNew)
	{
		printf("动态内存分配失败！\n");
	    exit(-1);
	}
	pNew->data=val;
	PNODE q=p->Next;
	p->Next=pNew;
	pNew->Next=q;
	return true;
}
//删除某个节点的值 
bool delete_list(PNODE pHead,int pos,int *pVal)
{
	int i=0;
	PNODE p=pHead;
	while(NULL!=p->Next&&i<pos-1)
	{
		p=p->Next;
		i++;
	}
	if(i>pos-1||NULL==p->Next)
	return false;
	PNODE q=p->Next; 
	//存放被删除的那个 
	*pVal=q->data;
	//删除p节点后面的节点 
	p->Next=p->Next->Next;
	free(q);
	q=NULL;
	return true;
}

 /狭义的算法是与数据的存数方式密切相关
广义的算法是与数据的存储方式无关
泛型：
利用某种技术达到的效果就是:不同的存数方式，执行的操作一样的

题外话：你们的支持是我不懈的动力，还请大家多多支持