单链表、双链表、循环链表总结

1.单链表（为升序链表，value按升序排列）

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

typedef struct NODE
{
	struct NODE *link;
	int 	value;
	
} Node;//最好放在头文件中


Node 	*sll_creat();
int 	sll_length(Node *p);
Node 	*sll_del(Node *head,int value);
void 	sll_print(Node *head);
Node 	*sll_insert(Node *head,int n);
Node 	*sll_reverse(Node *head);

int main()
{
	Node *p;
	p=sll_creat();
	sll_print(p);
	p=sll_del(p,3);
	sll_print(p);
	p=sll_insert(p,4);
	sll_print(p);
	p=sll_reverse(p);
	sll_print(p);
	return 0;
}

Node *sll_creat()
{
	int data;
	Node *p;
	Node *head;
	Node *new;
	Node *temp;//用来删除没用的head
	head=(Node *)malloc(sizeof(Node));
	p=head;//head没有改变， 改变的是p， head用来返回
	printf("please input the values,end with EOF:\n");
	while(scanf("%d",&data)==1)
	{
		new=(Node *)malloc(sizeof(Node));
		if(new==NULL)
		{
			printf("malloc error!\n");
			return NULL;
		}
		new->value=data;
		p->link=new;
		p=new;
	}
	temp=head;
	head=head->link;//将第一个无用节点head去除,如何free掉?
	p->link=NULL;
	free(temp);//删除没用的head，防止内存泄露
	return head;
}

int sll_length(Node *p)
{
	int count=0;
	while(p->link!=NULL)
	{
		count++;
		p=p->link;
	}
	count++;//由于尾节点的存在
	return count;

}
void sll_print(Node *head)
{
	int n;
	Node *p=head;
	n=sll_length(p);
	printf("there are %d records,they are:\n",n);
	while(p->link!=NULL)
	{
		printf("%d\n",p->value);
		p=p->link;
	}
	printf("%d\n",p->value);
}
/*
*1.此函数缺点是只能删除第一个value出现的节点
*2.此函数验证了在结构体中的value跟局部变量value不冲突
*/
Node *sll_del(Node *head,int value)//缺点，只能删除第一个value所在的节点
{
	Node *p1,*p2;
	p1=head;
	while(value!=p1->value&&p1->link!=NULL)//遍历链表，找到需要删除的节点
	{
		p2=p1;
		p1=p1->link;
	}
	if(value==p1->value)
	{
		if(p1==head)//单独处理头节点
		{
			head=p1->link;
			free(p1);
		}
		else
		{
			p2->link=p1->link;
			free(p1);
		}	
	}
	else
	{
		if(p1->value==value)//单独处理尾节点
		{
			p2->link=NULL;
			free(p1);
		}
		else
			printf("can't find the value:%d",value);
	}
	return head;
	
}
/*
*此函数是在节点中的数字递增的前提下才起作用（即该链表要为有序链表，value按升序排列）
*
*/
Node *sll_insert(Node *head,int n)
{
	Node *p=head;
	Node *p_prev;
	Node *p0=(Node *)malloc(sizeof(Node));
	while(n>=p->value&&p->link!=NULL)
	{
			p_prev=p;
			p=p->link;
	}
	if(p->value>n)
	{
		if(p==head)
		{
			p0->value=n;
			p0->link=head;
			head=p0;
			
		}
		else
		{
			p0->value=n;
			p_prev->link=p0;
			p0->link=p;
		}
	}
	else
	{	
		p0->value=n;
		p->link=p0;
		p0->link=NULL;
	}
	return head;
}

Node *sll_reverse(Node *head)
{
	Node *p1;
	Node *p2;
	Node *p3;
	p1=head;p2=p1->link;
	if(p1==NULL)
	{
		return head;
	}
	else if(p1->link==NULL)
	{
		head=p1->link;
		head->link=p1;
		p1->link=NULL;
	}
	else
	{
		while(p2->link)
		{
			p3=p2->link;
			p2->link=p1;
			p1=p2;
			p2=p3;
		}
	}
	p2->link=p1;
	head->link=NULL;
	head=p2;
	return head;
}

2.双链表:（value升序）

#include <stdio.h>
#include <malloc.h>
typedef struct NODE
{
	struct NODE	*next;
	struct NODE	*prev;
	int	value;
} Node;//不要忘了分号
Node	*dll_creat();
void	dll_print(Node *head);
int 	dll_length(Node *head);
Node	*dll_del(Node *head,int value);
Node *dll_insert(Node *head,int n);
int main()
{
	Node *p=dll_creat();
	dll_print(p);
	p=dll_del(p,5);
	dll_print(p);
	p=dll_insert(p,6);
	dll_print(p);
	return 0;
}
Node *dll_creat()
{	
	Node *head;
	Node *p;
	Node *temp;
	Node *new;
	int value;
	printf("please input the values,end with eof:\n");
	head=(Node *)malloc(sizeof(Node));
	if(head==NULL)
	{
		printf("malloc error!!!\n");
		return NULL;
	}
	p=head;
	while(scanf("%d",&value)==1)
	{
		new=(Node *)malloc(sizeof(Node));
		if(new==NULL)
		{	
			printf("malloc error!!!\n");
			return NULL;
		}
		new->value=value;
		p->next=new;
		new->prev=p;
		p=new;
	}
	temp=head;
	head=head->next;
	head->prev=NULL;
	p->next=NULL;
	free(temp);
	return head;
}
int 	dll_length(Node *head)
{
	Node *p;
	int length=0;
	p=head;
	while(p->next!=NULL)
	{
		p=p->next;	
		length++;
	}
	length++;
	return length;
}
void	dll_print(Node *head)
{
	int n=dll_length(head);
	Node *p=head;
	printf("there are %d records,they are :\n",dll_length(p));
	while(p->next!=NULL)
	{
		printf("%d\n",p->value);
		p=p->next;
		
	}
	printf("%d\n",p->value);
}
Node 	*dll_del(Node *head,int value)
{
	Node *p=head;
	while(p->value!=value&&p->next!=NULL)
	{
		p=p->next;
	}
	if(p->next==NULL)//尾节点
	{
		if(p->value==value)
		{
			p->prev->next=NULL;
			p->prev=NULL;
			free (p);
		}
		else 
		printf("can't find %d\n",value);
	}
	if(p->value==value)
	{
		if(p==head)//头节点
		{
			head=head->next;
			head->prev=NULL;
			free(p);
		}
		else//中间节点
		{
			p->prev->next=p->prev->next->next;
			p->next->prev=p->next->prev->prev;
			free (p);
		}
	}
	return head;
}

Node *dll_insert(Node *head,int n)
{
	Node *new;
	Node *p=head;
	while(p->value<n&&p->next!=NULL)
	{
		p=p->next;
	}
	new=(Node*)malloc(sizeof(Node));
	if(new==NULL)
	{
		printf("malloc error!!!\n");
		return NULL;
	}
	new->value=n;
	
	if(p->next==NULL)//尾节点
	{
		p->next=new;
		new->prev=p;
		new->next=NULL;
	}
	else if(p==head)//头节点
	{
		new->prev=NULL;
		new->next=p;
		p->prev=new;
		head=new;
	}
	else//中间节点
	{
		p->prev->next=new;
		new->prev=p->prev;
		new->next=p;
		p->prev=new;
	}
	return head;
}