带头结点的单链表就地逆置_循环单链表_C语言「抄作业」

最新推荐文章于 2023-02-12 00:04:22 发布
最新推荐文章于 2023-02-12 00:04:22 发布
阅读量397 收藏
点赞数
文章标签： 带头结点的单链表就地逆置
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39748445/article/details/113329276
版权

d4c543160051e75494ef5ec4d3790575.png

C语言「抄作业」系列之循环单链表

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

#define lElemType int				/* 循环单链表元素数据类型 */
#define LNODE_SIZE sizeof (struct lNode)	/* 循环单链表结点空间大小 */

#define status int	/* 状态型变量 */
#define OVERFLOW -1	/* 内存溢出状态码 */
#define ERROR 0		/* 错误状态码 */
#define OK 1		/* 正确状态码 */

/* 循环单链表数据结构 */
typedef struct lNode {
	lElemType data;
	struct lNode *next;
} lNode, *cirLinkList;

/**************************** 带头结点的循环单链表基本操作(12个) ****************************/
void initList (cirLinkList *L);		/* 初始化 */
void destroyList (cirLinkList L);	/* 销毁 */
void clearList (cirLinkList L);		/* 清空 */

status listIsEmpty (cirLinkList L);	/* 判断循环单链表是否为空 */
int listLength (cirLinkList L);		/* 获取循环单链表的长度 */
status getElem (cirLinkList L, int i, lElemType *e);	/* 获取循环单链表指定元素值 */

/* 寻找符合特征(compare)元素的位序 */
int locateElem (cirLinkList L, lElemType e, status (*compare)(lElemType, lElemType));

status priorElem (cirLinkList L, lElemType cur_e, lElemType *pre_e);	/* 获取指定元素的前驱 */
status nextElem (cirLinkList L, lElemType cur_e, lElemType *next_e);	/* 获取指定元素的后继 */

status listInsertNode (cirLinkList L, int i, lElemType e);	/* 循环单链表指定位置前插入新元素 */
status listDeleteNode (cirLinkList L, int i, lElemType *e);	/* 删除循环单链表指定位置元素 */

void listTraverse (cirLinkList L, void (*vi)(lElemType));	/* 依次对循环单链表的每个元素调用函数vi() */ 
/********************************************************************************************/
status compare (lElemType des, lElemType src);	/* compare函数，数据元素特征判定 */
void vi (lElemType e);				/* visit函数，定义为打印元素值 */
/********************************************************************************************/

/* 初始化 */
/* 操作结果：构造一个带头结点的空循环单链表L */
void initList (cirLinkList *L) {
	*L = (cirLinkList) malloc (LNODE_SIZE); /* 产生第一个结点，并使L指向此结点 */
	if (!*L) /* 内存分配失败 */
		exit (OVERFLOW);
	(*L)->next = *L; /* 指针域指向头结点 */
}

/* 销毁 */
/* 初始条件：循环单链表L已存在*/
/* 操作结果：销毁循环单链表L */
void destroyList (cirLinkList L) {
	cirLinkList p, q;
	
	p = L->next; /* p指向第一个结点 */
	while (p != L) { /* 没到表尾 */
		q = p->next;
		free (p);
		p = q;
	}
	free (L);
}

/* 清空 */
/* 初始条件：循环单链表L已存在 */
/* 操作结果：将L重置为空表 */
void clearList (cirLinkList L) {
	cirLinkList p, q;
	
	p = L->next; /* p指向第一个结点 */
	while (p != L) { /* 没到表尾 */
		q = p->next;
		free (p);
		p = q;
	}
	L->next = L; /* 指针域指向头结点 */
}

/* 判断循环单链表是否为空 */
/* 初始条件：循环单链表L已存在 */
/* 操作结果：若L为空表，则返回TRUE，否则返回FALSE */
status listIsEmpty (cirLinkList L) {
	return L->next == L;
}

/* 获取循环单链表的长度 */
/* 初始条件：循环单链表L已存在 */
/* 操作结果：返回L中数据元素个数 */
int listLength (cirLinkList L) {
	int i = 0;
	cirLinkList p = L->next; /* p指向第一个结点 */
	
	if (!p) /* 空表 */
		return i;
	while (p != L) { /* 没到表尾 */
		i++;
		p = p->next;
	}
	return i;
}

/* 获取循环单链表指定位序元素值 */
/* 初始条件：循环单链表L已存在 */
/* 操作结果：在带头结点的循环单链表L中，当第i个元素存在时，其值赋予e并返回OK，否则返回ERROR */
status getElem (cirLinkList L, int i, lElemType *e) {
	int j = 1; /* j为计数器 */
	cirLinkList p = L->next; /* p指向第一个结点 */
	
	while (j<i) { /* 寻找第i个结点 */
		p = p->next;
		if (p!=L) /* 计数时跳过头结点 */
			j++;
	}
	
	if (j>i) /* 位置不合理：i小于1 */
		return ERROR;
	
	*e = p->data; /* 取第i个元素 */
	
	return OK;
}

/* 寻找符合特征(compare)元素的位序 */
/* 初始条件: 循环单链表L已存在，compare()是数据元素判定函数(满足为1，否则为0) */
/* 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序 */
/* 若这样的数据元素不存在，则返回值为0 */
int locateElem (cirLinkList L, lElemType e, status (*compare)(lElemType, lElemType)) {
	cirLinkList p = L->next;
	int i = 0;
	
	while (p != L) { /* 没到表尾 */
		i++;
		if (compare (p->data, e)) /*找到这样的数据元素*/
			return i;
		p = p->next;
	}
	
	return 0;
}

/* 获取指定元素的前驱 */
/* 初始条件: 循环单链表L已存在 */
/* 操作结果: 若cur_e是L的数据元素，且不是第一个，则其前驱元素值赋予pre_e并返回OK */
/* 否则操作失败，pre_e无定义，返回ERROR */
status priorElem (cirLinkList L, lElemType cur_e, lElemType *pre_e) {
	cirLinkList q, p = L->next; /* p指向第一个结点 */
	
	if (cur_e == p->data) { /* cur_e是表头 */
		while (p->next != L)
			p = p->next;
		*pre_e = p->data; /* pre_e即为表尾 */
		return OK;
	}
	
	while (p->next != L) {
		q = p->next; /* q为p的后继 */
		if (q->data == cur_e) {
			*pre_e = p->data;
			return OK;
		}
		p = q; /* p向后移 */		
	}
	
	return ERROR;
}

/* 获取指定元素的后继 */
/* 初始条件：循环单链表L已存在 */
/* 操作结果：若cur_e是L的数据元素，且不是最后一个，则其后继元素值赋予next_e并返回OK */
/* 否则操作失败，next_e无定义，返回ERROR */
status nextElem (cirLinkList L, lElemType cur_e, lElemType *next_e) {
	cirLinkList p = L->next; /* p指向第一个结点 */
	
	while (p->next != L) {
		if (p->data == cur_e) {
			*next_e = p->next->data;
			return OK;
		}
		p = p->next;
	}
	
	if (p->data == cur_e) { /* cur_e是表尾 */
		*next_e = L->next->data; /* pre_e即为表头 */
		return OK;
	}
	
	return ERROR;
}

/* 循环单链表指定位置前插入新元素 */
/* 初始条件：循环单链表L已存在 */
/* 操作结果：在带头结点的循环单链表L中第i个位置之前插入元素e */
status listInsertNode (cirLinkList L, int i, lElemType e) {
	int j = 0;
	cirLinkList p = L, s;
	
	while (j<i-1) { /* 寻找第i-1个结点 */
		p = p->next;
		if (p!=L) /* 计数时跳过头结点 */
			j++;
	}
	
	if (j>i-1) /* 插入位置不合理：i小于1 */
		return ERROR;
	
	/* 生成新结点，并插入L中 */
	s = (cirLinkList) malloc (LNODE_SIZE);
	if (!s) /* 内存分配失败 */
		exit (OVERFLOW);
	s->data = e;
	s->next = p->next; /* s链接到第i个结点之前 */
	p->next = s; /* 第i-1个结点连接到s之前 */
	
	return OK;
}

/* 删除循环单链表指定位置元素 */
/* 初始条件：循环单链表L已存在 */
/* 操作结果：在带头结点的循环单链表L中，删除第i个元素，其值赋予e */
status listDeleteNode (cirLinkList L, int i, lElemType *e) {
	int j = 0;
	cirLinkList p = L, q;
	
	while (j<i-1) { /* 寻找第i-1个结点 */
		p = p->next;
		if (p!=L) /* 计数时跳过头结点 */
			j++;
	}
	if (p->next == L) /* 第i-1个结点是尾结点 */
		p = L;
	
	if (j>i-1) /* 删除位置不合理：i小于1 */
		return ERROR;
	
	/* 删除并释放结点 */
	q = p->next;
	p->next = q->next;
	*e = q->data;
	free (q);
	
	return OK;
}

/* 依次对循环单链表的每个元素调用函数vi() */
/* 初始条件：循环单链表L已存在 */
/* 操作结果：依次对L的每个数据元素调用函数vi() */
void listTraverse (cirLinkList L, void (*vi)(lElemType)) {
	cirLinkList p = L->next; /* p指向第一个结点 */
	
	if (p == L) {
		puts ("The circular linked list is empty! ");
		return;
	}
	
	while (p != L) { /* 没到表尾 */
		vi (p->data);
		p = p->next;
	}
	putchar ('n');
}

/* compare函数，数据元素特征判定 */
/* 满足返回TRUE，否则返回FALSE */
status compare (lElemType des, lElemType src) {
	return des == src;
}

/* visit函数，定义为打印元素值 */
void vi (lElemType e) {
	printf ("%d ", e);
}

int main (void) {
	cirLinkList L;
	lElemType e, pre_e, next_e;
	lElemType a=1, b=2, c=3, d=4;
	int index, len;
	status sts;
	
	/* 初始化循环单链表 */
	initList (&L);
	printf ("initList: &L -> L's Address: %pn", L);
	putchar ('n');
	
	/* 循环单链表指定位置前插入新元素 */
	index = 1;
	sts = listInsertNode (L, index, a);
	printf ("listInsertNode: L,i=%d,a=%d -> status: %dn", index, a, sts);
	index = 2;
	sts = listInsertNode (L, index, b);
	printf ("listInsertNode: L,i=%d,b=%d -> status: %dn", index, b, sts);
	index = 3;
	sts = listInsertNode (L, index, c);
	printf ("listInsertNode: L,i=%d,c=%d -> status: %dn", index, c, sts);
	index = 4;
	sts = listInsertNode (L, index, d);
	printf ("listInsertNode: L,i=%d,d=%d -> status: %dn", index, d, sts);
	putchar ('n');
	
	/* 依次对循环单链表的每个元素调用函数vi() */ 
	/* 打印循环单链表 */
	printf ("L: ");
	listTraverse (L, &vi);
	putchar ('n');
	
	/* 指定一个大于表长的位置，插入新元素 */
	index = 7; /* 等价于listLength%index */
	e = 5;
	sts = listInsertNode (L, index, e);
	printf ("listInsertNode: L,i=%d,e=%d -> status: %dn", index, e, sts);
	putchar ('n');
	
	/* 打印循环单链表 */
	printf ("L: ");
	listTraverse (L, &vi);
	putchar ('n');	
	
	/* 判断循环单链表是否为空 */
	sts = listIsEmpty (L);
	printf ("listIsEmpty: L -> isEmpty: %dn", sts);
	
	/* 获取循环单链表的长度 */
	len = listLength (L);
	printf ("listLength: L -> length: %dn", len);
	putchar ('n');
	
	/* 获取循环单链表指定元素值 */
	index = 2;
	sts = getElem (L, index, &e);
	printf ("getElem: L,i=%d,&e -> status: %d, e: %dn", index, sts, e);
	
	/* 寻找符合特征(compare)元素的位序 */
	e = 3;
	index = locateElem (L, e, &compare);
	printf ("locateElem: L,e=%d,&compare -> index: %dn", e, index);
	putchar ('n');
	
	/* 获取指定元素的前驱 */
	e = 1;
	sts = priorElem (L, e, &pre_e);
	printf ("priorElem: L,e=%d,&pre_e -> status: %d, pre_e: %dn", e, sts, pre_e);
	e = 3;
	sts = priorElem (L, e, &pre_e);
	printf ("priorElem: L,e=%d,&pre_e -> status: %d, pre_e: %dn", e, sts, pre_e);
	/* 获取指定元素的后继 */
	e = 4;
	sts = nextElem (L, e, &next_e);
	printf ("nextElem: L,e=%d,&next_e -> status: %d, next_e: %dn", e, sts, next_e);
	e = 3;
	sts = nextElem (L, e, &next_e);
	printf ("nextElem: L,e=%d,&next_e -> status: %d, next_e: %dn", e, sts, next_e);
	putchar ('n');
	
	/* 删除循环单链表指定位置元素 */
	index = 3;
	sts = listDeleteNode (L, index, &e);
	printf ("listDeleteNode: L,i=%d,&e -> status: %d, e: %dn", index, sts, e);
	putchar ('n');
	
	/* 打印循环单链表 */
	printf ("CL: ");
	listTraverse (L, &vi);
	putchar ('n');
	
	/* 指定一个大于表长的位置，删除元素 */
	index = 8; /* 等价于listLength%index */
	sts = listDeleteNode (L, index, &e);
	printf ("listDeleteNode: L,i=%d,&e -> status: %d, e: %dn", index, sts, e);
	putchar ('n');
	
	/* 打印循环单链表 */
	printf ("L: ");
	listTraverse (L, &vi);
	putchar ('n');	
	
	/* 清空循环单链表 */
	clearList (L);
	printf ("clearList: L -> donen");
	sts = listIsEmpty (L);
	printf ("listIsEmpty: L -> isEmpty: %dn", sts);
	putchar ('n');
	
	/* 销毁循环单链表 */
	destroyList (L);
	printf ("destroyList: L -> donen");
	putchar ('n');
	
	printf ("press any key to exit.n");
	
	getch (); /* 屏幕暂留 */ 
	return 0 ;
}

运行结果

3c9cb337d9dbab0c6e328587233cb4f4.png
碧海风：数据结构篇_C语言「抄作业」​zhuanlan.zhihu.com
95dd649c90a07fc8cec47b1fa219a2bf.png

C语言抄作业系列，只有答案，没有讲解！

计算机科学专业毕业多年的一个啥也没学会而转行做了产品经理的家伙，从当年的各种作业里搬运来的一些乱七八糟的东西。

C语言「抄作业」​www.zhihu.com
9ef7bc39484994fdd419753f1dd2bae1.png
weixin_39748445
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线形表---链表---带头节点单链表的就地逆置
11-27
用c语言描述的线形表---链表---带头节点单链表的就地逆置
带头结点的单链表就地逆置
Treasuredd的博客
10-29 434
{{}}{= NULL){}i < n / 2;i++){}}
带头结点单链表就地逆置算法
qq_50504109的博客
09-17 4384
1、带头结点单链表就地逆置算法 部分函数调用参考如下：https://blog.csdn.net/qq_50504109/article/details/120288749 /** * 单向链表的逆置，说白了就是头插法的利用，只不过我们这次插入的数据，不是自己决定的节点 * 而是用已经存在的，那我们每次操作的时候，把下一个节点的地址保存起来就可以了，这样就相当于是我们创建了一个 * 那这不就和头插法一模一样了么？ */ #include <stdio.h> #includ
056 单链表就地逆置 C语言
06-01
056 单链表就地逆置 C语言
单链表就地逆置的方法
10-31
单链表 就地逆置的方法 逆置 txt
数据结构C语言版之单链表的逆置.cpp
10-07
数据结构老师布置的作业，运用课本代码，较为基础经典，适合大学本科在上数据结构这门课的同学参考，简单易懂，关于单链表的逆置问题
单链表的就地逆置与删除
03-25
单链表操作就地逆置删除mink到maxk之间的元素#include<stdio.h>
单链表的逆置（c语言）.txt
最新发布
12-26
c语言
对单链表实现就地逆置算法
04-17
对以单链表为存储结构的表实现就地逆置，即在原有空间上实现逆置，不开辟新空间
实现带头结点的单链表元素就地逆置
weixin_60956192的博客
07-27 4837
数据结构算法基础题2-1
c语言将一个已知头结点的单链表逆序_C语言单链表逆向(逆置)
weixin_42513054的博客
12-23 415
<1> 最近参加了一次面试，让编写一个单链表操作，包括创建，删除，逆向什么的.其它的操作，这里就不写了这里把要求逆向的操作贴出来，供大家参考，同时也希望能提出意见。<2>源程序int converse(list *list){list *tmp1,*tmp2,*tmp3;tmp1=list;if(tmp1->next!=null)//链表多于一个结点{tmp2=t...
数据结构学习-带头结点的单链表就地逆置
weixin_30900589的博客
01-16 736
所谓“就地是指辅助空间复杂度为O(1)。 解法一：将头结点摘下，然后从第一结点开始，依次前插入到头结点的后面（头插法），直到最后一个结点为止。 代码如下 LinkList Reverse (LinkList L) { 　　LNode *p,*r;//p为工作指针，r为p的后继以防断链 　　p=L->next;//从第一个元素结点开始 　　L->next...
带头节点的单链表的就地逆置
Lee贤的博客
02-12 1348
本题要求编写函数实现带头结点的单链线性表的就地逆置操作函数。
就地逆置带头结点的单链表
Disco_very的博客
03-20 1604
#include<stdio.h> #include<stdlib.h> #include<iostream> /* 2017年3月20日19:50:49 就地逆置 首先要了解“就地逆置”的含义：不再需要额外的空间来保存这个链表中的任何节点的数据域。而不是不需要任何空间。比如下面的例子就需要两个指针的空间。 思路：①将原来的头结点拆下来，作为新的逆置链表的头结点
王道数据结构2.2.4——5、带头结点的单链表就地逆置
Hillbox
10-11 218
思路 把头结点取下，然后用头插法逆置 代码 void reverse(LinkList &L){ LNode *p=L->next,*r; L->next=NULL; while(p!=NULL){ r=p->next; p->next=L->next; L->next=p;...
用c语言编写实现带头结点单链表就地逆置的成员函数
03-29
以下是一个用C语言编写的带头结点单链表就地逆置的成员函数： ```c void reverseList(Node *head) { if (head == NULL || head->next == NULL) { return; } Node *prev = NULL; Node *curr = head->next; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值