完成单链表的按值进行修改函数。完成单向链表的翻转：void list_reverse(LinkList *L)； 例如：原链表元素为：ABCD 翻转后：DCBA

于 2022-11-28 22:24:33 发布
阅读量169 收藏
点赞数
文章标签： 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dongjl02/article/details/128088649
版权

 linklist.c:

#include <stdio.h>
#include"linklist.h"
#include <stdlib.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 ? 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;
}

//遍历
void list_show(LinkList *L)
{
	if(NULL==L || list_empty(L))
	{
	printf("遍历失败\n");
	return;
	}
	//遍历逻辑
	LinkList *q = L->next;//定义指针指向第一个结点
	while(q != NULL)
	{
	printf("%c\t",q->data);//指针指向下一个结点
	q = q->next;
	}
	//尾插
}	
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)
{
	//判断逻辑
	if(pos<0 || pos>L->len)
	{
		printf("查找失败\n");
		return NULL;
	}
	//查找逻辑
	//定义遍历指针从头结点出发
	LinkList *q = L;
	for(int i=0;i<pos;i++)
	{
		q=q->next;   //遍历指针往后偏移

	}
	return q;   //将找到的结点返回
	
}

//按位置插入
int list_insert_pos(LinkList *L,int pos,datatype e)
{
	//判断逻辑
	if(NULL==L || pos<1 || pos>L->len+1)
	{
		printf("插入失败\n");
		return 0;
	}
	//申请结点封装数据
	LinkList *p = buy_node(e);
	if(NULL==p)
	{
		printf("结点申请不成功，申请失败\n");
		return 0;
	}
	//找到要插入位置的前驱结点
	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");
	return 1;
}

//头删
int list_delete_head(LinkList *L)
{
	//判断逻辑
	if(NULL==L || list_empty(L))
	{
		printf("删除失败\n");
		return 0;
	}
	//删除逻辑
	LinkList *p = L->next;    //标记要删除的结点
	L->next = p->next;      //L->next = L->next->next;
	free(p);
	p = NULL;
	//表的变化
	L->len--;
	printf("删除成功\n");
	return 1;
}


//尾删
int list_delete_tail(LinkList *L)
{
	//判断逻辑
	if(NULL==L || list_empty(L))
	{
		printf("删除失败\n");
		return 0;
	}
	//找到倒数第二个结点
	//LinkList *q = find_node(L,L->len-1);
	LinkList *q = L; //定义遍历指针从头结点出发
	while(q->next->next!=NULL)
	{
		q = q->next;
	}
	//删除逻辑
//	free(q->next);   	//将最后一个结点释放
//	q->next = NULL;  	//倒数第二个结点变成最后一个结点

	LinkList *p = q->next;
	q->next = p->next;
	free(p);
	p = NULL;
	//表长变化
	L->len--;
	printf("删除成功\n");
	return 1;
}


//任意位置删除
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);
	if(q==NULL)
	{
		printf("删除失败\n");
		return 0;
	}
	//删除操作
	LinkList *p = q->next;
	q->next = p->next;
	free(p);
	p = NULL;
	//表长变化
	L->len--;
	printf("删除成功\n");
	return 1;
}
//按位置修改
int list_updata_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_search_value(LinkList *L,datatype e)
{
	//判断逻辑
	if(NULL==L || list_empty(L))
	{
		printf("查找失败\n");
		return -1;
	}
	//查找逻辑
	LinkList *q = L->next;
	for(int i=1;i<=L->len;i++)
	{
		if(q->data == e)
		{
			return i;
		}
		q = q->next;  //继续判断下一个结点
	}
	return 0;  		//说明,没找到
}
//按值修改
int list_updata_value(LinkList *L,int e,datatype new_e)
{
	if(NULL==L || list_empty(L))
	{
		printf("查找失败\n");
		return -1;
	}
	LinkList *q = L->next;
	L->next = q;
	for(int i=2;i<=L->len;i++)
	{
		if(q->data == e)
		{
			q->data = new_e;
		}

		q = q->next;
	}
	printf("修改成功\n");
	return 0;

}
//单链表的翻转
void list_reverse(LinkList *L)
{
	LinkList *p=L->next;
	L->next=NULL;
	while(p!=NULL)
	{
		LinkList *q=p;
		p=p->next;
		q->next=L->next;
		L->next=q;
	}
	printf("翻转成功\n");
}
//释放
  void list_free(LinkList *L)
  {
//判断逻辑
	if(NULL != L)
	{
		while(L->next != NULL)
		{
			list_delete_head(L);
		}
		free(L);
		L = NULL;
		printf("释放成功\n");
	}
}

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);
//遍历
void list_show(LinkList *L);
//尾插
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);
//头删
int list_delete_head(LinkList *L);

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

//任意位置删除
int list_delete_pos(LinkList *L,int pos);
//按位置修改
int list_updata_pos(LinkList *L,int pos,datatype new_e);
//按值查找
int list_search_value(LinkList *L,datatype e);
//按值修改
int list_updata_value(LinkList *L,int e,datatype new_e);
//单链表的翻转
void list_reverse(LinkList *L);
//释放
void list_free(LinkList *L);


#endif

main.c:

#include <stdio.h>
#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,'D');
	list_insert_tail(L,'F');
	list_show(L);


//根据位置查找

//调用任意位置
list_insert_pos(L,3,'X');
list_show(L);

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

//调用尾删
list_delete_tail(L);
list_show(L);
//调用任意位置删除
list_delete_pos(L,3);
list_show(L);
//调用按位置修改
list_updata_pos(L,2,'G');
list_show(L);

//按值查找
int res = list_search_value(L,'Q');
if(res<=0)
{
	printf("查找失败\n");

}
else
{
	printf("在第%d个节点上\n",res);
}
//按值修改
list_updata_value(L,'Q','Z');
list_show(L);
//单链表的翻转
list_reverse(L);
list_show(L);
//调用释放函数
list_free(L);
L = NULL;
list_show(L);



return 0;
}

结果：

 

Dongjl02
关注
单向链表的建立
07-11
单向链表的建立是很多人的一大难点 上传代码给大家一些参考 欢迎指正
用C++类实现单向链表的增删查和反转操作方法
08-30
在本文中，我们将深入探讨如何使用C++类来实现单向链表的基本操作，包括增删查和反转。单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。下面我们将按照文章的结构详细...
2022-11-28作业
weixin_63506558的博客
11-28 121
单向链表
单链表--更改值
weixin_47311994的博客
08-02 544
目的：在链表中，将A值更改为B值 实现思路：通过遍历链表，查找到该节点对应的value值，将其value值与给定的value值进行比较，如果是给定的value值，就将其更改为要更改的值 public void change(T srcValue, T aimValue) { for(Node<T> p=head;p!=null;p=p.next){ if(p.value.compareTo(srcValue)==0){ p.value=aim
建立单向链表
XIAOYUELIN_的博客
12-30 420
建立单向链表 链表本质上是用指针链接起来的多个结构体，所以建立链表的第一步就是定义一个结构体变量 如struct libi {int data; struct libi *next; } 第二步定义头节点与结构体指针struct libi *head,*p,*p1; 第三步为其申请空间，使用malloc函数（包含在stdlib.h函数库中）head=p=(struct libi*)malloc(...
创建单向链表
lyh030105的博客
09-06 154
创建单向链表
linklist-reverse.rar_linklist reverse
09-24
在本程序"linklist-reverse.rar_linklist reverse"中，主要涉及了链表的创建以及链表元素的逆序显示两个关键知识点。下面将详细阐述这两个概念及其在实际编程中的应用。 首先，我们来了解链表的基本概念。链表不同...
要求编写函数实现带头结点的单链线性表的就地逆置操作函数。L是一个带头结点的单链表，函数ListReverse_L(LinkList &L)要求在不新开辟节点的前提下将单链表中的元素进行逆置，如原单链表元素依次为1,2,3,4，则逆置后为4,3,2,1。
05-25
void ListReverse_L(LinkList &L) { if (L == NULL || L->next == NULL) { // 空表或只有一个结点，无需逆置 return; } // pre: 前驱结点；p: 当前结点；q: 后继结点 ListNode *pre = NULL, *p = L->next, *q ...
本题要求编写函数实现带头结点的单链线性表的就地逆置操作函数。l是一个带头结点的单链表，函数listreverse_l(linklist &l)要求在不新开辟节点的前提下将单链表中的元素进行逆置，如原单链表元素依次为1,2,3,4，则逆置后为4,3,2,1。
最新发布
06-28
题目要求编写一个函数listreverse_l(linklist &l)，实现带头结点的单链线性表的就地逆置操作，即将单链表中的元素进行逆置，不新开辟节点。例如，原单链表元素依次为1,2,3,4，则逆置后为4,3,2,1。
void Reverse_L(LinkList &L) {//逆置带头结点的单链表L /**************begin************/ /**************end************/ }
05-26
void Reverse_L(LinkList &L) { if (L == NULL || L->next == NULL) { return; } ListNode *pre = L->next; ListNode *p = pre->next; while (p != NULL) { ListNode *q = p->next; p->next = pre; pre = p...
建立一个单链表
12-17
建立一个单链表，在单链表上实现插入、删除和查找等操作，有菜单。 ⑴初始化字符型单链表H; ⑵采用尾插法建立单链表H，如（a,b,c,d,c）； ⑶输出单链表H的长度； ⑷输出单链表H的第i个元素，如输出单链表H的第3个元素； ⑸输出给定元素的位置，如输出元素a的位置； ⑹在第i个元素前插入给定元素，如在第4个元素前插入元素f； ⑺删除单链表H的第i个元素，如删除单链表H的第3个元素。 ⑻输出单链表
单链表的逆转算法
小白代码进阶之路
03-21 1276
单链表逆转算法 代码虽短，信息量挺大的，建议画图理解 void reverse(linklist *L) { linklist p,q; p = null;q = L; while(q！=null) { *L = q->next; q->next = p; p = q; q = *L; } L = p; }...
单向链表的建立（C语言）
拉风小宇的博客
10-31 2330
貌似有段时间没有做原创文章了，聒噪的很，开始正式学习数据结构啦哈哈，今天先做单向链表的建立，希望和大家一起分享 数组作为存放同类数据的集合，给我们在程序设计时带来很多的方便，增加了灵活性。但数组也同样存在一些弊病。如数组的大小在定义时要事先规定，不能在程序中进行调整，这样一来，在程序设计中针对不同问题有时需要30个大小的数组，有时需要50个数组的大小，难于统一。我们只能够根据可能的最大需求来
单链表的增、删、改、查操作
Angety 的博客
07-16 339
定义一个接口，里面包含增、删、改、查等操作 public interface List<E> { void addHead(E value); void addTail(E value); void removeHead(); void removeTail(); void removeValue(E value); void change(E srcValue, E aimValue); boolean cont...
单向链表创建（一）
人间有味是清欢
04-03 551
一，建立正序链表`#include using namespace std; struct node { int data; node *next; }; int main() { node *head=NULL,*p,*s; s=new node; cin>>s->data; head=s; p=s; wh
单链表-添加-修改-删除
lankerens
07-19 535
单链表： 在内存结构的物理地址中，一般是不连续的， 在逻辑结构上，是连续的。 在删除单链表时， 实际就是将当前删除的上一个节点next 指向 当前删除的下一个节点，而这个当前删除的节点并不需要我们手动的或是怎样释放它占有的资源， 当内存不足、或者某些条件触发了jvm垃圾回收时，会回收掉没有任何引用指向它的这块资源。 /** * 链表 */ class SingleLinkedList { /** * 初始化头节点, 头节点不要.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值