7.26链表的学习

_(:з」∠)_301

已于 2024-07-29 18:46:11 修改

阅读量276

点赞数 9

文章标签：学习

于 2024-07-27 14:21:02 首次发布

本文链接：https://blog.csdn.net/qq_67412653/article/details/140734777

版权

单向链表

头文件 head.h

#ifndef _HEAD_H_
#define _HEAD_H_
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef int data;
typedef struct link
{
	union
	{
		int len;
		data id;

	};
	struct link *next;

}linklist,*linkptr;

linkptr my_create();//创建链表
int  p_empty(linkptr H);//判空
linkptr  node_create(data e);//封装函数
int head_add(linkptr H,data e);//头插
void show(linkptr H);//遍历链表
int tail_add(linkptr H,data e);//尾插
int index_add(linkptr H,data e,int index);
//任意地方插入
int head_del(linkptr H);
int tail_del(linkptr H);
int index_del(linkptr H,int index);
int index_change(linkptr H,int index,data e);
void num_change(linkptr H,data e,data n);
int resever(linkptr H);
void del_free(linkptr H);
#endif

调用函数head.c

#include "head.h"
linkptr my_create()//创建单向链表
{
	linkptr H=(linkptr)malloc(sizeof(linklist));
	if(NULL==H)
	{
		printf("创建失败\n");
		return NULL;
	}
	H->len=0;
	H->next=NULL;
	printf("success\n");
	return H;
	
}
//链表判空
int p_empty(linkptr H)
{
	if(NULL==H)
	{
		printf("判空失败\n");
		return -1;
	}
	return H->len==0; 
}
//申请节点，封装数据
linkptr node_create(data e)
{
	linkptr p=(linkptr)malloc(sizeof(linklist));
	
	if(NULL==p)
	{
		printf("分装数据失败\n");
		return NULL;
	}
	p->id=e;
	p->next=NULL;
	return p;
}
//头插
int head_add(linkptr H,data e)
{
	if(NULL==H)
	{
		printf("头插失败\n");
		return 0;
	}
	linkptr p=node_create(e);
	p->next=H->next;
	H->next=p;
	H->len++;
	return 1;


}
//遍历链表，不断访问指针指向的指针域的链表
void show(linkptr H)
{
	if(NULL==H||p_empty(H))
	{
		printf("链表遍历失败\n");
		return ;
	}
	linkptr p=H;
		for(int i=0;i<H->len;i++)
		{
			p=p->next;
			printf("%d ",p->id);
		}
	printf("\n");
}
//尾插
int tail_add(linkptr H,data e)
{
	if(NULL==H)
	{
		printf("尾插失败\n");
		return 0;
	}
	linkptr p=node_create(e);//创建尾差封装空间
	linkptr q=H;//遍历整个链表的指针
//遍历指针指向链表末端
	while(q->next!=NULL)
	{
		q=q->next;
	}
	q->next=p;//尾差
	H->len++;
	return 1;
}
//任意位置插入
int index_add(linkptr H,data e,int index)
{
	if(NULL==H||p_empty(H)||index<0||index>H->len)
	{
		printf("插入失败\n");
		return 0;
	}
	linkptr q=H;
	linkptr p=node_create(e);
	for(int i=0;i<index-1;i++)
	{
		q=q->next;
	}
	p->next=q->next;
	q->next=p;
	H->len++;
	return 1;
}
//头删
int head_del(linkptr H)
{
	if(NULL==H||p_empty(H))
	{
		printf("头删失败\n");
		return 0;
	}
	linkptr p=H->next;
	H->next=p->next;
	free(p);
	p=NULL;
	H->len--;
	return 1;
}
//尾删
int tail_del(linkptr H)
{
	if(NULL==H||p_empty(H))
	{
		printf("尾删失败\n");
		return 0;
	}
	linkptr p=H;
	for(int i=0;i<H->len-1;i++)
	{
		p=p->next;
	}//p指向倒数第二个节点
	linkptr q=p->next;//q指向最后一个节点
	p->next=q->next;//倒数第二个节点指针越过最后一个链域指向null
	free(q);//用完释放
	q=NULL;
	H->len--;
	return 1;
}
//任意位置删除
int index_del(linkptr H,int index)
{
	if(NULL==H||p_empty(H)||index<0||index>H->len)
	{
		printf("任意删除失败\n");
		return 0;
	}
	linkptr p=H;
	for(int i=0;i<index-1;i++)
	{
		p=p->next;
	}
	linkptr q=p->next;
	p->next=q->next;
	free(q);//用完释放
	q=NULL;
	H->len--;
	return 1;
}
//销毁单向链表

void del_free(linkptr H)
{
	if(NULL==H||p_empty(H))
	{
		printf("销毁失败\n");
		return ;
	}
	while(NULL!=H->next)
	{
		index_del(H,1);
	}
	free(H);
	H=NULL;
	printf("销毁成功\n");
}
//选择位置修改
int index_change(linkptr H,int index,data e)
{
	if(NULL==H||p_empty(H)||index<0||index>H->len)
	{
		printf("修改失败\n");
		return 0;
	}
	linkptr p=H;
	for(int i=0;i<index;i++)
	{
		p=p->next;
	}
	if(p->id==e)
	{
		return 0;
	}
	p->id=e;

	return 1;
}
void num_change(linkptr H,data e,data n)
{
	if(NULL==H||p_empty(H))
	{
		printf("修改失败\n");
		return ;
	}
	linkptr p=H;
	for(int i=0;i<H->len;i++)
	{
		p=p->next;
	
	if(p->id==e)
	{
	p->id=n;
	return ;
	}
	}
printf("查无此数据\n");
}
int resever(linkptr H)
{
	if(NULL==H||H->len<=1)
	{
		printf("反转失败\n");
		return 0;
	}
	linkptr H2=H->next;
	H->next=NULL;
	linkptr p;
	while(H2!=NULL)
	{
		p=H2;
		H2=H2->next;
		p->next=H->next;
		H->next=p;
	}
	return 1;
}

主函数main.c

#include "head.h"
int main(int argc, const char *argv[])
{
	linkptr X=my_create();
	head_add(X,5);
	head_add(X,4);
	head_add(X,3);
	head_add(X,2);
	head_add(X,1);
	printf("链表长度：%d\n",X->len);
	show(X);
	tail_add(X,6);
	tail_add(X,7);
	tail_add(X,8);
	tail_add(X,9);
	tail_add(X,10);
	printf("链表长度：%d\n",X->len);
	show(X);
	index_add(X,77,4);
	index_add(X,90,6);
	index_add(X,41,9);
	index_del(X,8);
	printf("链表长度：%d\n",X->len);
	index_change(X,1,11);
	index_change(X,2,22);
	index_change(X,3,33);
	index_change(X,4,44);
	index_change(X,5,55);
	printf("链表长度：%d\n",X->len);
	show(X);
	num_change(X,11,111);
	printf("链表长度：%d\n",X->len);
	show(X);
	resever(X);
	printf("反转后\n");
	printf("链表长度：%d\n",X->len);
	show(X);
	del_free(X);
	return 0;
}

双向链表（多加了一个回指针）

头文件声明double.h

#ifndef _DOUBLE_H_
#define _DOUBLE_H_
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct link
{
	union
	{
		int len;
		int id;
	};
	struct link *next;
	struct link *piror;
}Doublelink,*Doubleptr;

Doubleptr my_create();
int d_empty(Doubleptr q);
Doubleptr node_create(int e);
int head_add(Doubleptr H,int e);
void show(Doubleptr H);
int index_add(Doubleptr H,int index,int e);
int index_del(Doubleptr H,int index);
void free_double(Doubleptr H);
#endif

函数调用double.c

#include "double.h"
//创建双向链表头结点
Doubleptr my_create()
{
	Doubleptr q=(Doubleptr)malloc(sizeof(Doubleptr));
	if(NULL==q)
	{
		printf("创建失败\n");
		return NULL;
	}
	q->len=0;
	q->next=NULL;
	q->piror=NULL;
	printf("创建成功\n");
	return q;
}
//判空
int d_empty(Doubleptr q)
{
	if(NULL==q)
	{
		printf("判空失败\n");
		return -1;
	}
	return q->next==NULL;
	//return q->len==0;
}
//堆区申请节点
Doubleptr node_create(int e)
{
	Doubleptr p=(Doubleptr)malloc(sizeof(Doublelink));
	if(NULL==p)
	{
		printf("申请节点失败\n");
		return NULL;
	}
	p->id=e;
	p->next=NULL;
	p->piror=NULL;
return p;
}
//头插
int head_add(Doubleptr H,int e)
{
	if(NULL==H)
	{
		printf("头插失败\n");
		return 0;
	}
	Doubleptr q=node_create(e);
	if(H->next!=NULL)
	{
		q->next=H->next;
		q->piror=H;
		H->next->piror=q;
		H->next=q;
	}
	else
	{
		q->piror=H;
		H->next=q;
	}
	H->len++;
	return 1;

}
//遍历链表
void show(Doubleptr H)
{
	if(NULL==H||d_empty(H))
	{
		printf("遍历失败\n");
	}
	Doubleptr p=H;
	while(p->next!=NULL)
	{
		p=p->next;
		printf("%d ",p->id);
	}
	putchar(10);
	printf("链表长度:%d\n",H->len);

}
//任意位置插入
int index_add(Doubleptr H,int index,int e)
{
	if(NULL==H||index<0||index>H->len)
	{
		printf("插入失败\n");
		return 0;
	}
	Doubleptr p=H;
	Doubleptr q=node_create(e);
	for(int i=0;i<index-1;i++)
	{
		p=p->next;
	}
	if(H->next!=NULL)
	{
		q->next=p->next;
		q->piror=p;
		p->next->piror=q;
		p->next=q;
	}
	else
	{
		q->piror=p;
		p->next=q;
	}
	H->len++;
	return 1;
}
//任意位置删除

int index_del(Doubleptr H,int index)
{
	if(NULL==H||index<0||index>H->len)
	{
		printf("失败\n");
		return 0;
	}
	Doubleptr p=H;
	for(int i=0;i<index;i++)
	{
		p=p->next;
	}
	if(p->next==NULL)
	{
		p->piror->next=NULL;
	}
	else
	{
		p->piror->next=p->next;
		p->next->piror=p->piror;

	}
		free(p);
		p=NULL;
	H->len--;
	return 1;
}
void free_double(Doubleptr H)
{
	if(NULL==H)
	{
		printf("销毁失败\n");
		return;
	}
	while(H->next!=NULL)
	{
		index_del(H,1);
	}
	free(H);
	H=NULL;
	printf("销毁成功\n");

}

主函数main.c

#include "double.h"
int main(int argc, const char *argv[])
{
	Doubleptr X= my_create();
	head_add(X,23);
	head_add(X,24);
	head_add(X,25);
	head_add(X,26);
	head_add(X,27);
	head_add(X,28);
	head_add(X,29);
	index_add(X,3,66);
	show(X);
	index_del(X,3);
	show(X);
	free_double(X);
	return 0;
}

单向循环链表

头文件声明head.h

#ifndef _HEAD_H_
#define _HEAD_H_
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef int data;
typedef struct link
{
	union
	{
		int len;
		data id;

	};
	struct link *next;//指向后一级
	struct link *piror;//指向前一级


}looplink,*looplinkptr;

looplinkptr my_create();//创建链表
int  p_empty(looplinkptr H);//判空
void show(looplinkptr H);//遍历链表
int tail_add(looplinkptr H,data e);//尾插
int tail_del(looplinkptr H);
void del_free(looplinkptr H);
#endif

函数调用head.c

#include "head.h"
looplinkptr my_create()//创建单向循环链表
{
	looplinkptr H=(looplinkptr)malloc(sizeof(looplink));
	if(NULL==H)
	{
		printf("创建失败\n");
		return NULL;
	}
	H->len=0;
	H->next=H;//尾指头
//	H->piror=NULL;
	printf("success\n");
	return H;
	
}
//链表判空
int p_empty(looplinkptr H)
{
	if(NULL==H)
	{
		printf("判空失败\n");
		return -1;
	}
	return H->next==H; 
}
//遍历链表，不断访问指针指向的指针域的链表
void show(looplinkptr H)
{
	if(NULL==H||p_empty(H))
	{
		printf("遍历失败\n");
		return ;
	}
	looplinkptr p=H;
	while(p->next!=H)
	{
		p=p->next;
//		p->next->piror=p;
		printf("%d ",p->id);
	}
	putchar(10);
	
}
//尾插
int tail_add(looplinkptr H,data e)
{
	if(NULL==H)
	{
		printf("插入失败\n");
		return 0;
	}
	looplinkptr p=(looplinkptr)malloc(sizeof(looplink));
	if(NULL==p)
	{
		printf("尾插创建失败\n");
		return 0;
	}
	p->id=e;
	p->next=NULL;
//	p->piror=NULL;
	looplinkptr q=H;
	while(q->next!=H)
	{
		q=q->next;
	}
//	p->piror=q;
	q->next=p;
	p->next=H;
	H->len++;
	return 1;
	
}
//尾删
int tail_del(looplinkptr H)
{
	if(NULL==H||p_empty(H))
	{
		printf("尾删失败\n");
		return 0;
	}
	looplinkptr q=H;
	for(int i=0;i<H->len-1;i++)
	{
		q=q->next;
	}
	free(q->next);

	q->next=H;
	H->len--;
	return 1;
	
}
//销毁单向链表

void del_free(looplinkptr H)
{
	if(NULL==H)
	{
		printf("销毁失败\n");
		return;
	}
	while(H->next!=H)
	{
		tail_del(H);
	}
	free(H);
	H=NULL;
	printf("销毁成功\n");
}

主函数main.c

#include "head.h"
int main(int argc, const char *argv[])
{
	looplinkptr X=my_create();
	tail_add(X,1);
	tail_add(X,2);
	tail_add(X,3);
	tail_add(X,4);
	tail_add(X,5);
	tail_add(X,6);
	tail_add(X,7);
	tail_add(X,8);
	tail_add(X,9);
	show(X);
	tail_del(X);
	show(X);
	del_free(X);
	return 0;
}