C语言链表基础操作

注：

1.注意让尾部等于NULL

2.注意->value和->next存不存在

3.不要随便用for

4.每次malloc都要判断是否申请成功

删除最小值

struct nodes* delet(struct nodes* head)

{

struct nodes *p1=head->next,*pt;

int min=p1->value;

while(p1->next!=NULL)

{

p1=p1->next;

if(p1!=NULL&&p1->value<min)

min=p1->value;

}

p1=head;

while(p1->next!=NULL)

{

if(p1->next->value==min)

{

pt=p1->next;

p1->next=p1->next->next;

free(pt);        

}//删掉一个节点后，p1->next是下一个值，不用让p1后移

else

p1=p1->next;

}
return head;

}

创建链表(别忘了让结尾=NULL)

 

有辅助表元的：

h=(intNode *)malloc(sizeof(intNode));

h->next=tail=NULL;

思路：

创一个头，一个尾，一个新表元代表。

先让让尾为NULL，头与尾连接上

开始循环：

让p创空间并赋值进去

无辅助表元：

若是第一轮（h==NULL），让头、尾都等于p//要不然没创空间给头尾，它们还是NULL，没有tail->next

不是第一轮，同有辅助表元的一样

有辅助表元的：

让tail连接p，再让tail往后移到最新的尾巴p

 

排序创建

无辅助表元的：

 

有辅助表元的：（从大到小）

struct node*pcreate(int n)
{
	struct node *u,*v,*p,*head;
	int k=0;
	head=(struct node *)malloc(sizeof(struct node));
	head->next=p;
	for(k=0;k<n;k++)
	{
		p=(struct node *)malloc(sizeof(struct node));
		if(p==NULL)
		{
			printf("空间申请失败\n")；
			return NULL；
		}
		scanf("%d",&p->value); 
		v=head;
		do
		{
			u=v;
			v=v->next;
		}while(v!=NULL&&p->value<v->value);//用while的话第一次u还没赋值为v,下面就用了u->next
		u->next=p;
		p->next=v;
	} 
return head; 
}

把head2插入有序的head1里：

有辅助表元的

void charu(struct nodes*head1,struct nodes*head2)
{
	struct nodes *p1,*p2,*pt;
for(p2=head2->next;p2!=NULL;p2=pt)
{
	pt=p2->next;
	for(p1=head1;p1->next!=NULL;p1=p1->next)
	{
		if(p2->value<=p1->next->value) 
		{
			p2->next=p1->next;
			p1->next=p2;
			break; 
		}
	}
	if(p1->next==NULL)
	{
		p1->next=p2;
		p2->next=NULL;
	} 
}
}

从小到大（未规定链表元素个数，而是输入回车就结束）：

struct node*pcreate(struct node* h)
{
	struct node*pre,*p;
	h=(struct node*)malloc(sizeof(struct node));
	h->next=NULL;
	char c=' ';
	while(c!='\n')
	{
		p=(struct node*)malloc(sizeof(struct node));
		if(p==NULL)
		{
			printf("空间申请失败\n")；
			return NULL；
		}
		scanf("%d",&p->value);
		c=getchar();
		pre=h;
		while(pre->next!=NULL&&pre->next->value<p->value)
		{
			pre=pre->next;
		}
			p->next=pre->next;
			pre->next=p; 
	}//这个不需要p->next=NULL;因为最后一遍p不一定在最后。最后的p也已经->next=NULL了
	return h;
}

插入表元

无辅助表元

struct Node *insert(struct Node *head, int value, int index)
{
	struct Node *p=head,*add;
	add=(struct Node*)malloc(sizeof(struct Node));
	if(add==NULL)
	{
		printf("空间申请失败\n")；
		return NULL；
	}
	add->value=value; 
	int i;
	if(index==0)
	{
		add->next=head;
		head=add;
	}
	else
	{
		for(i=0;i<index-1;i++)
		{
		p=p->next;
		}
		
		add->next=p->next;
		p->next=add;
	}
	return head;
}

有辅助表元

struct Node *insert(struct Node *head, int value, int index)
{
	struct Node *p=head,*add;
	add=(struct Node*)malloc(sizeof(struct Node));
	if(add==NULL)
	{
		printf("空间申请失败\n")；
		return NULL；
	}
	add->value=value; 
	int i;
		for(i=0;i<index;i++)
			p=p->next;
		add->next=p->next;
		p->next=add;
	}
	return head;
}

反转链表

无辅助表元

struct Node *reverse(struct Node *head)
{
	int i;
	struct Node *yp,*zp,*p;
	zp=NULL;
	p=head;
	yp=p->next;
	while(p!=NULL)
	{
		p->next=zp;
		zp=p;
		p=yp;
		if(p==NULL)
			head=zp;
		else
			yp=p->next;
	} 
	return head;
}

有辅助表元

struct Node *reverse(struct Node *head)
{
	int i;
	struct Node *yp,*zp,*p;
	zp=NULL;
	p=head->next;
	yp=p->next;
	while(p!=NULL)
	{
		p->next=zp;
		zp=p;
		p=yp;
		if(p==NULL)
			head->next=zp;
		else
			yp=p->next;
	} 
	return head;
}

链表排序

无辅助表元的

struct Node *mergeNodeList(struct Node *l1,struct Node *l2)
{
	struct Node *prepi,*pi,*prepj,*pj,*p,*pt;
	p=l1;
	int i,j,i1,j1,count;
	while(p->next!=NULL)
	{
		p=p->next;
	}
	p->next=l2;
	//把第一个元素单拎出来考虑就不用malloc一个空间了
	for(prepj=l1;prepj->next!=NULL;prepj=prepj->next)
	{
		pi=l1;
		pj=prepj->next;
		if(pj->value<pi->value)
		{
			if(pi->next==pj)
			{
				l1=pj;
				pi->next=pj->next;
				pj->next=pi;
				prepj=pj; 
			}
			else
			{
				pt=pj->next;
				pj->next=pi->next;
				l1=pj;
				prepj->next=pi;
				pi->next=pt;
			}
		}
	}
	for(prepi=l1;prepi->next!=NULL;prepi=prepi->next)
	{
		pi=prepi->next;	
		for(prepj=pi;prepj->next!=NULL;prepj=prepj->next)
		{
			pi=prepi->next;
			pj=prepj->next;
			if(pj->value<pi->value)
			{
				if(pi->next==pj)
				{
					prepi->next=pj;
					pi->next=pj->next;
					pj->next=pi;
					prepj=pj; 
				}
				else
				{
					pt=pj->next;
					pj->next=pi->next;
					prepi->next=pj;
					prepj->next=pi;
					pi->next=pt;
				}
			}
		}
	}
	return l1;
}

有辅助表元的

struct Node *mergeNodeList(struct Node *l1,struct Node *l2)
{
	struct Node *prepi,*pi,*prepj,*pj,*p,*pt;
	p=l1;
	prepi=(struct Node*)malloc(sizeof(struct Node));//有辅助表元就不需要了
	if(prepi==NULL)
	{
		printf("空间申请失败\n")；
		return NULL；
	}
	int i,j,i1,j1,count;
	while(p->next!=NULL)
	{
		p=p->next;
	}
	p->next=l2->next;
	for(prepi->next=l1;prepi->next!=NULL;prepi=prepi->next)
	{
		if(count==2)
		free(pt);
		pi=prepi->next;	
		for(prepj=pi;prepj->next!=NULL;prepj=prepj->next)
		{
			pi=prepi->next;
			pj=prepj->next;
			if(pj->value<pi->value)
			{
				if(pi->next==pj)
				{
					prepi->next=pj;
					pi->next=pj->next;
					pj->next=pi;
					prepj=pj; 
				}
				else
				{
					pt=pj->next;
					pj->next=pi->next;
					prepi->next=pj;
					prepj->next=pi;
					pi->next=pt;
				}
			}
	
		}
		if(count==0)//有辅助表元就不用了，没有辅助表元的话
		{
			l1=prepi->next；
			count++;
		}
		if(count==1）
		{
		count++
		pt=prepi;
		}
	}
	return l1;
}

删除链表里所有的最小值

#include<stdio.h>
#include<stdlib.h>
struct nodes* delet(struct nodes*); //不可以变成void
struct nodes* create(struct nodes*);//也可以变成void
void print(struct nodes*);
struct nodes
{
	int value;
	nodes *next;
	
};//别忘了分号！！！
int main()
{
struct nodes* head=NULL;
head=create(head);
head=delet(head);
print(head);

	return 0;
}
struct nodes* create(struct nodes* head)
{
	struct nodes *p,*prep;
	char c=' ';
	head=(struct nodes*)malloc(sizeof(struct nodes));//改变了head本身的值（即地址值）而外面的head没变所以不能改成void.注意是head来malloc而不是p=head然后pmalloc
	if(head==NULL)
	{
		printf("空间申请失败\n")；
		return NULL；
	}
	prep=head;
	while(c!='\n')
	{
		p=(struct nodes*)malloc(sizeof(struct nodes));
		if(p==NULL)
		{
			printf("空间申请失败\n")；
			return NULL；
		}
		scanf("%d",&p->value);
		c=getchar();
		prep->next=p;
		prep=p;
	}
	p->next=NULL;
	return head;
}
struct nodes* delet(struct nodes* head)
{
	struct nodes *p1=head->next,*pt;
	int min=p1->value;
	while(p1->next!=NULL)
	{
		p1=p1->next;
		if(p1!=NULL&&p1->value<min)
		min=p1->value;
	}
	p1=head;
	while(p1->next!=NULL)
	{
		if(p1->next->value==min)
		{
			pt=p1->next;
			p1->next=p1->next->next;
			free(pt);	
		}
		else
			p1=p1->next;
	}

	return head;
}
void print(struct nodes *head)
{
	struct nodes *p=head->next;
	while(p!=NULL)
	{
		printf("%d ",p->value);
		p=p->next;
	}
}

并集

struct node*U(struct node* a,struct node* b)
{
	struct node *pre1=a,*p1,*pre2=b,*p2;
	while(pre2->next!=NULL)
	{
		p2=pre2->next;
		for(pre1=a;pre1->next!=NULL;pre1=pre1->next)
		{
			p1=pre1->next;
			if(p1->value==p2->value)
			break;
		}
		if(pre1->next==NULL)
		{
			pre1->next=p2;
			pre2->next=p2->next;
			p2->next=NULL; 
		}
		else
		pre2=pre2->next;//注意不可以用for循环，放在for循环的最后，因为如果b中有元素被加入a了，所以不需要后移pre2
	}	
	return a;
}

做完之后a就是U，b就是N。其实不用return。

交集

struct node*N(struct node* a,struct node* b)
{
	struct node *pre1=NULL,*p1,*pre2=b,*p2,*pre,*p,*h;
	int value;
	h=(struct node*)malloc(sizeof(struct node*));
	pre=h;
	for(pre1=a;pre1->next!=NULL;pre1=pre1->next)
	{
		p1=pre1->next;
		value=p1->value;
		for(pre2=b;pre2->next!=NULL;pre2=pre2->next)
		{
			p2=pre2->next;	
			if(p2->value==value)
			{
				p=(struct node*)malloc(sizeof(struct node*));
				p->value=value;
				pre->next=p;
				pre=pre->next;
			}
		}
	}
	p->next=NULL;
	return h;
}

释放free

void freeNodeList(struct Node *head)
{
	struct Node *pre,*p;
	pre=head;
	while(pre->next!=NULL)
	{
		p=pre->next;
		free(pre);
		pre=p;
		p=pre->next;
	}
	free(pre);
}