C语言单链表的实现（+链表逆置）-创新互联

1、linklist.h文件

#ifndef __LINKLIST_H__
#define __LINKLIST_H__

typedef char datatype;

//定义结点类型
typedef struct Node{
	union{
		int len; 	//头结点数据域
		datatype data; 	//普通结点数据域
	};
	struct Node *next; 	//指针域
}LinkList;

//创建链表
LinkList *list_create();

//判空
int list_empty(LinkList *L);

//申请结点封装数据
LinkList *buy_node(datatype e);

//头插
int list_insert_head(LinkList *L,datatype e);

//尾插
int list_insert_tail(LinkList *L,datatype e);

//按位置查找返回位置
LinkList* find_node(LinkList *L,int pos);

//任意位置插入
int list_insert_pos(LinkList *L,int pos,datatype e);

//遍历
void list_show(LinkList *L);

//头删
int list_delete_head(LinkList *L);

//尾删
int list_delete_tail(LinkList *L);

//任意位置删除
int list_delete_pos(LinkList *L,int pos);

//按位置修改
int list_update_pos(LinkList *L,int pos,datatype new_e);

//按值进行修改
int list_update_value(LinkList *L,datatype e,datatype new_e);

//按值查找返回结点位置
int list_find_value(LinkList *L,datatype e);

//链表逆置
void list_reverse(LinkList *L);

//释放
void list_free(LinkList *L);

#endif

2、linklist.c文件

#include#include#include "linklist.h"

//创建链表
LinkList *list_create(){
	//申请一个结点的空间
	LinkList *L = (LinkList *)malloc(sizeof(LinkList));
	if(NULL==L){
		printf("创建失败\n");
		return NULL;
	}

	//进行初始化
	L->len = 0;
	L->next = NULL;
	printf("创建成功\n");
	return L;
}

//判空
int list_empty(LinkList *L){
	return L->next==NULL;
//	return L->next==NULL ? 1:0;   1表示空，0便是非空
}

//申请结点封装数据
LinkList *buy_node(datatype e){
	LinkList *p = (LinkList*)malloc(sizeof(LinkList));
	if(NULL==p){
		printf("空间申请失败\n");
		return NULL;
	}

	//将数据封装到结点的数据域中
	p->data = e;
	p->next = NULL;
	return p;
}

//头插
int list_insert_head(LinkList *L,datatype e){
	//判断逻辑
	if(NULL==L){
		printf("所给的链表不合法\n");
		return 0;
	}
	
	//申请结点封装数据
	LinkList *p = buy_node(e);

	//头插逻辑	
	p->next = L->next;
	L->next = p;

	//表的变化
	L->len++;
	printf("头插成功\n");
	return 1;
}

//尾插
int list_insert_tail(LinkList *L,datatype e){
	//判断逻辑
	if(NULL==L){
		printf("所给的链表不合法\n");
		return 0;
	}
	//申请结点封装数据
	LinkList *p =buy_node(e);

	//定义遍历指针，指向最后一个结点
	LinkList *q = L;
	while(q->next != NULL){
		q = q->next;
	}

	//尾插逻辑
	p->next = q->next;
	q->next = p;

	//表长变化
	L->len++;
	printf("尾插成功\n");
	return 1;
}

//按位置查找返回位置
LinkList* find_node(LinkList *L,int pos){
	LinkList *q = L;
	//判断逻辑
	if(pos<0||pos>L->len){
		printf("查找失败\n");
		return NULL;
	}
	//查找逻辑
	//定义遍历指针从头结点出发
	for(int i=0;inext; 	//遍历指针往后偏移
	}
	return q; 		//将找到的结点返回
}

//任意位置插入
int list_insert_pos(LinkList *L,int pos,datatype e){
	//判断逻辑
	if(pos<1||pos>L->len+1){
		printf("插入失败\n");
		return 0;
	}

	//申请结点封装数据
	LinkList *p = buy_node(e);
	if(NULL == p){
		printf("结点申请失败，插入失败\n");
	}
	//找到要插入的前驱结点
	LinkList *q = find_node(L,pos-1);
	if(NULL == q){
		printf("结点前驱查找失败\n");
		return 0;
	}
	//插入逻辑
	p->next = q->next;
	q->next = p;

	//表长变化
	L->len++;
	printf("插入成功\n");
}


//遍历
void list_show(LinkList *L){
	//判断逻辑
	if(NULL == L){
		printf("遍历失败\n");
		return;
	}

	//遍历逻辑
	LinkList *q = L->next; 	//定义指针指向结点
	while(q != NULL){ 		
		printf("%c\t",q->data);
		q = q->next; 		//指针指向下一个结点
	}
	putchar(10);
}

//头删
int list_delete_head(LinkList *L){
	//判断逻辑
	if(NULL == L){
		printf("删除失败\n");
		return 0;
	}

	//删除逻辑
	LinkList *p = L->next;
	L->next = p->next;
	free(p);
	p = NULL;

	//表的变化
	L->len--;
	printf("删除成功\n");
}

//尾删
int list_delete_tail(LinkList *L){
	//判断逻辑
	if(NULL == L){
		printf("删除失败\n");
		return 0;
	}

	//定义遍历指针，指向倒数第二个结点
	//LinkList *q = find_node(L,L->len-1);
	LinkList *q = L;
	while(q->next->next != NULL){
		q = q->next;
	}

	//删除逻辑(1)
//	free(q->next);
//	q->next = NULL;
//
	//删除逻辑(2)
	LinkList *p = q->next;
	q->next = p->next;
	free(p);
	p = NULL;

	//表长变化
	L->len--;
	printf("删除成功\n");
}

//任意位置删除
int list_delete_pos(LinkList *L,int pos){
	//判断逻辑
	if(NULL==L||list_empty(L)||pos<1||pos>L->len){
		printf("删除失败\n");
		return 0;
	}
	//找到要删除位置的前驱结点
	LinkList *q = find_node(L,pos-1);

	//删除逻辑
	LinkList *p = q->next;
	q->next = p->next;
	free(p);
	p = NULL;

	//表长变化
	L->len--;
	printf("删除成功\n");
	return 1;
}

//按位置修改
int list_update_pos(LinkList *L,int pos,datatype new_e){
	//判断逻辑
	if(NULL==L||list_empty(L)||pos<1||pos>L->len){
		printf("修改失败\n");
		return 0;
	}
	
	//查找到要修改的结点
	LinkList *p = find_node(L,pos);

	//修改数据
	p->data = new_e;
	printf("修改成功\n");
	return 1;
}

//按值进行修改
int list_update_value(LinkList *L,datatype e,datatype new_e){
	//判断逻辑
	if(NULL==L){
		printf("修改失败\n");
		return 0;
	}

	//修改逻辑
	LinkList *q = L->next;
	for(int i=1;ilen;i++){
		if(q->data == e){
		q->data = new_e;
		}
		q = q->next;
	}
	return 1;
}

//按值查找返回结点位置
int list_find_value(LinkList *L,datatype e){
	//判断逻辑
	if(NULL == L||list_empty(L)){
		printf("查找失败\n");
		return -1;
	}

	//查找逻辑
	LinkList *q = L->next;
	for(int i=0;i<+L->len;i++){
		if(q->data == e){
			return i;
		}
		q = q->next;
	}
	return 0;
}

//链表逆置
void list_reverse(LinkList *L){
	//判断逻辑
	if(NULL==L||list_empty(L)){
		printf("逆置失败\n");
		return;
	}

	//逆置逻辑
	LinkList *p = L->next;
	LinkList *q;
	L->next =NULL;
	while(p != NULL){
		q = p;
		p = p->next;
		q->next = L->next;
		L->next = q;
	}
	printf("逆置成功\n");
	return;
}

//释放
void list_free(LinkList *L){
	if(NULL != L){
		//循环进行头删，直到链表中没有结点
		while(L->next != NULL){
			list_delete_head(L);
		}

		//释放头结点
		free(L);
		L = NULL;
		printf("释放成功\n");
	}
}

3、main.c文件

#include#include "linklist.h"

int main(int argc, const char *argv[])
{
	LinkList *L = list_create();
	if(NULL==L){
		return -1;
	}
	
	//调用头插
	list_insert_head(L,'Q');
	list_insert_head(L,'W');
	list_insert_head(L,'E');
	list_insert_head(L,'R');
	//调用遍历
	list_show(L);

	//调用尾插
	list_insert_tail(L,'A');
	list_insert_tail(L,'S');
	list_insert_tail(L,'D');
	list_insert_tail(L,'F');
	//调用遍历
	list_show(L);

	//调用任意位置插入
	list_insert_pos(L,3,'K');
	//调用遍历
	list_show(L);

	//头删
	list_delete_head(L);
	//调用遍历
	list_show(L);

	//尾删
	list_delete_tail(L);
	//调用遍历
	list_show(L);

	//调用任意位置删除
	list_delete_pos(L,5);
	//调用遍历
	list_show(L);

	//调用任意位置修改
	list_update_pos(L,2,'M');
	//调用遍历
	list_show(L);
	
	//调用按值进行修改
	list_update_value(L,'Q','X');
	//调用遍历
	list_show(L);

	//调用按值查找返回结点
	int res = list_find_value(L,'W');
	if(res<=0)
		printf("查找失败\n");
	else
		printf("你要查找的值在第%d个结点上\n",res);

	//调用链表逆置
	list_reverse(L);
	//调用遍历
	list_show(L);

	//调用释放函数
	list_free(L);
	L = NULL;
	list_show(L);

	return 0;
}

4、效果截图

你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧