408-王道-循环单链表

已于 2022-12-26 11:21:20 修改
阅读量304 收藏 2
点赞数 1
分类专栏： 王道考研408-数据结构 文章标签： 数据结构 算法 链表
于 2022-11-26 19:14:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_56553975/article/details/128053790
版权

1.操作菜单

在这里插入图片描述

2.头插法

  1. 要注意的就是我们的尾部的next指针指向的是头结点，但是我们用的是头插法，我们要保证尾部的next指向头节点，所以我在这用一个计数器来解决这个问题

  2. 监视
    操作
    监视

  3. 代码参考

//头插法
void insertHead(LinkList& L) {
	L = (LinkList)malloc(sizeof(LNode));
	L->nextNode = NULL;
	LinkList temp;
	ElemType data;
	int count = 0;
	scanf("%d", &data);
	while (data != 999) {
		count++;
		temp = (LinkList)malloc(sizeof(LNode));
		temp->data = data;
		if (count == 1) {
			L->nextNode = temp;
			temp->nextNode = L;
		}
		else {
			temp->nextNode = L->nextNode;
			L->nextNode = temp;
		}
		scanf("%d", &data);
	}
	return;
}

2.尾插法

  1. 尾部的next要指向头结点，所以要一直修改当前尾节点的指向
  2. 监视
    在这里插入图片描述
    在这里插入图片描述
  3. 代码参考
//尾插法 
void insertEnd(LinkList& L) {
	L = (LinkList)malloc(sizeof(LNode));
	ElemType data;
	LinkList temp;
	LinkList end = L;
	scanf("%d", &data);
	while (data != 999) {
		temp = (LinkList)malloc(sizeof(LNode));
		temp->data = data;
		temp->nextNode = L;
		end->nextNode = temp;
		end = temp;
		scanf("%d", &data);
	}	
}

3.修改元素

  1. 注意里面的size方法和单链表的不一样
  2. 代码参考
bool modifyNode(LinkList& L, int index, ElemType data) {
	LinkList temp = (LinkList)malloc(sizeof(LNode));
	int count = 0;
	temp = L->nextNode;
	if (index<1 || index>size(L)) {
		return false;
	}
	while (temp != NULL) {
		count++;
		if (count == index) {
			temp->data = data;
			return true;
		}
		else {
			temp = temp->nextNode;
		}
	}
	return false;
}

4.查找元素

  1. 判断索引是否在合法范围之内
  2. 参考代码
LinkList location(LinkList L, int index) {
	int count = 0;
	LinkList temp = L->nextNode;
	if (index<1 || index>size(L)) {
		return NULL;
	}
	while (temp != NULL) {
		count++;
		if (count == index) {
			return temp;
		}
		temp = temp->nextNode;
	}
	return NULL;
}

5.删除元素

//这块代码写的不简便
bool deleteNode(LinkList L, int index) {
	if (index<1 || index>size(L)) {
		return false;
	}
	else {
		//第一个结点
		if (index == 1 && size(L) == 1) {
			LinkList deleteNode = L->nextNode;
			L->nextNode = L->nextNode->nextNode;
			deleteNode->nextNode = NULL;
			free(deleteNode);
			L->nextNode = L;
			return true;
		}
		else if (index == 1 &&size(L)!=1) {
			LinkList deleteNode = L->nextNode;
			L->nextNode = L->nextNode->nextNode;
			deleteNode->nextNode = NULL;
			free(deleteNode);
			return true;
		}
		//最后一个结点
		else if (index == size(L)) {
			LinkList parentNode = searchParent(L, index - 1);
			parentNode->nextNode = NULL;
			free(parentNode->nextNode);
			parentNode->nextNode = L;
			return true;
		}
		//不是头和尾结点的结点
		else {
			LinkList parentNode = searchParent(L, index - 1);
			parentNode->nextNode = parentNode->nextNode->nextNode;
			return true;
		}	
	}

}

6.遍历元素

  1. 注意循环条件
void printLinkList(LinkList L) {
	LinkList temp = L->nextNode;
	while (temp!=L) {
		printf("%3d\n", temp->data);
		temp = temp->nextNode;
	}
}

7.长度

int size(LinkList L) {
	int count = 0;
	LinkList temp = L->nextNode;
	while (temp!= L) {
		count++;
		temp = temp->nextNode;
	}
	return count;
}

8.汇总

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>

/*
1.头插法
2.尾插法
3.修改
4.查找
5.删除
6.遍历
*/

typedef int ElemType;

typedef struct LNode {
	ElemType data;
	struct LNode* nextNode;
}LNode, * LinkList;
void insertHead(LinkList& L);
void insertEnd(LinkList& L);
void printLinkList(LinkList L);
int size(LinkList L);
void menu(LinkList& L);
void choice(LinkList& L);
LinkList searchParent(LinkList& L, int index);

//头插法
void insertHead(LinkList& L) {
	L = (LinkList)malloc(sizeof(LNode));
	L->nextNode = NULL;
	LinkList temp;
	ElemType data;
	int count = 0;
	scanf("%d", &data);
	while (data != 999) {
		count++;
		temp = (LinkList)malloc(sizeof(LNode));
		temp->data = data;
		if (count == 1) {
			L->nextNode = temp;
			temp->nextNode = L;
		}
		else {
			temp->nextNode = L->nextNode;
			L->nextNode = temp;
		}
		scanf("%d", &data);
	}
	return;
}

//尾插法 
void insertEnd(LinkList& L) {
	L = (LinkList)malloc(sizeof(LNode));
	ElemType data;
	LinkList temp;
	LinkList end = L;
	scanf("%d", &data);
	while (data != 999) {
		temp = (LinkList)malloc(sizeof(LNode));
		temp->data = data;
		temp->nextNode = L;
		end->nextNode = temp;
		end = temp;
		scanf("%d", &data);
	}	
}
//修改
bool modifyNode(LinkList& L, int index, ElemType data) {
	LinkList temp = (LinkList)malloc(sizeof(LNode));
	int count = 0;
	temp = L->nextNode;
	if (index<1 || index>size(L)) {
		return false;
	}
	while (temp != NULL) {
		count++;
		if (count == index) {
			temp->data = data;
			return true;
		}
		else {
			temp = temp->nextNode;
		}
	}
	return false;
}
LinkList searchParent(LinkList& L, int index) {
	int count = 0;
	LinkList temp = L->nextNode;
	if (index == 0) {
		return L;
	}
	while (temp != NULL) {
		count++;
		if (index == count) {
			return temp;
		}
		else {
			temp = temp->nextNode;
		}
	}
}

//查找
LinkList location(LinkList L, int index) {
	int count = 0;
	LinkList temp = L->nextNode;
	if (index<1 || index>size(L)) {
		return NULL;
	}
	while (temp != NULL) {
		count++;
		if (count == index) {
			return temp;
		}
		temp = temp->nextNode;
	}
	return NULL;
}
//删除
bool deleteNode(LinkList L, int index) {
	if (index<1 || index>size(L)) {
		return false;
	}
	else {
		//第一个结点
		if (index == 1 && size(L) == 1) {
			LinkList deleteNode = L->nextNode;
			L->nextNode = L->nextNode->nextNode;
			deleteNode->nextNode = NULL;
			free(deleteNode);
			L->nextNode = L;
			return true;
		}
		else if (index == 1 &&size(L)!=1) {
			LinkList deleteNode = L->nextNode;
			L->nextNode = L->nextNode->nextNode;
			deleteNode->nextNode = NULL;
			free(deleteNode);
			return true;
		}
		//最后一个结点
		else if (index == size(L)) {
			LinkList parentNode = searchParent(L, index - 1);
			parentNode->nextNode = NULL;
			free(parentNode->nextNode);
			parentNode->nextNode = L;
			return true;
		}
		//不是头和尾结点的结点
		else {
			LinkList parentNode = searchParent(L, index - 1);
			parentNode->nextNode = parentNode->nextNode->nextNode;
			return true;
		}	
	}

}


//遍历
void printLinkList(LinkList L) {
	LinkList temp = L->nextNode;
	while (temp!=L) {
		printf("%3d\n", temp->data);
		temp = temp->nextNode;
	}
}
int size(LinkList L) {
	int count = 0;
	LinkList temp = L->nextNode;
	while (temp!= L) {
		count++;
		temp = temp->nextNode;
	}
	return count;
}
void menu(LinkList& L) {
	printf("----------------循环单链表---------------\n");
	printf("               1.头插法                 \n");
	printf("               2.尾插法                 \n");
	printf("               3.修改元素               \n");
	printf("               4.查找元素               \n");
	printf("               5.删除元素               \n");
	printf("               6.遍历元素               \n");
	printf("               7.链表长度               \n");
	choice(L);
}
void choice(LinkList& L) {
	int choice;
	printf("请输入你的选择：");
	scanf("%d", &choice);
	switch (choice) {
	case 1:
		insertHead(L);
		break;
	case 2:
		insertEnd(L);
		break;
	case 3: {
		int index;
		ElemType data;
		printf("请输入你要修改的位置：");
		scanf("%d", &index);
		printf("请输入待修改的值为：");
		scanf("%d", &data);
		bool modify = modifyNode(L, index, data);
		if (modify) {
			printf("修改成功\n");
		}
		else {
			printf("修改失败\n");
		}
		break;
	}

	case 4: {
		int index;
		printf("请输入你要查找的序号:");
		scanf("%d", &index);

		LinkList locationed = location(L, index);
		if (NULL != locationed) {
			printf("查找成功 元素为%d\n", locationed->data);
		}
		else {
			printf("查找失败\n");
		}
		break;
	}
	case 5: {
		int index;
		printf("请输入你要删除的元素序号:");
		scanf("%d", &index);
		bool deleted = deleteNode(L, index);
		if (deleted) {
			printf("删除成功\n");
		}
		else {
			printf("删除失败\n");
		}

		break;
	}
	case 6:
		printLinkList(L);
		break;
	case 7: {
		int len = size(L);
		printf("长度为%d\n", len);
		break;
	}

	default:
		break;
	}
	menu(L);

}


int main() {
	LinkList L;
	menu(L);
	return 0;
}
王道数据结构实践代码----循环单链表的实现（C语言版）
繁臻的小窝
08-30 685
王道数据结构实践代码----循环单链表的实现（C语言版） 前言 日期：2021年8月30日 书籍：王道2021年数据结构考研复习指导 代码内容：实现循环单链表的实现，包括初始化，插入新元素，删除新元素，输出，查询 代码展示 1.预编译内容 #include <stdio.h> #include <stdlib.h> #include <assert.h> //设置bool #define bool char #define true 1 #define false
王道考研数据结构之------单链表操作
liquid_road的博客
08-07 378
参考视频 王道2021数据结构 链接： 王道2021数据结构链接 提取码：rpy8 –来自百度网盘超级会员V4的分享 #include <stdio.h> #include <stdlib.h> typedef int ElemType; typedef struct LNode{ ElemType data; LNode *next; }LNode, *LinkList; //初始化一个空的单链表(不带头结点) bool IniList(LinkList &L){
王道书P40 T16（单链表实现）
shengruyu的博客
07-15 202
王道书P40 T16（单链表实现）
王道单链表
沉晨尘宸的博客
07-22 382
13.两个乱序单链表合并成一个有序单链表。14.将一个链表分解成偶数连与奇数连。12.建立一个非递减有序单链表。1.按位序插入（带头结点）2.按位序插入（不带头结点）5.按位序删除（带头结点）10.单链表创建带头结点。3.指定结点的后插操作。4.指定结点的前插操作。7.尾插法建立单链表。......
王道书P40 T18（循环单链表实现）
shengruyu的博客
07-14 209
王道书P40 T18（循环单链表实现）
王道考研数据结构之------循环单链表
liquid_road的博客
08-12 238
链接： 王道2021数据结构链接 提取码：rpy8 –来自百度网盘超级会员V4的分享` typedef int ElemType;//元素的类型 typedef int ElemType;//元素的类型 typedef struct LNode { ElemType data; LNode* next; }LNode,*LinkList; /*--------------------------------*/ //初始化单链表 void InitList(LinkList &L){ //
2023王道考研数据结构第二章---单链表
weixin_52572034的博客
08-17 1423
2023王道考研数据结构第二章---单链表
王道考研数据结构之------单链表操作(不带头结点)
liquid_road的博客
08-20 526
链接： 王道2021数据结构链接 提取码：rpy8 –来自百度网盘超级会员V4的分享` typedef int ElemType;//元素的类型 typedef int ElemType;//元素的类型 typedef struct LNode { ElemType data; LNode* next; }LNode,*LinkList; /*--------------------------------*/ //初始化单链表 void InitList(LinkList &L){ //
王道数据结构实践代码----单链表的实现（C语言版）
繁臻的小窝
08-26 3946
王道数据结构实践代码----单链表的实现（C语言版） 前言 日期：2021年8月26日 书籍：王道2021年数据结构考研复习指导 代码内容：实现单链表的实现，包括初始化，插入新元素，删除新元素，输出，查询 代码难点 1.C语言的指针和C++的引用转换 … 指针我太阳你个** 简而言之,王道书上的单链表声明和初始化是以C++为模板的,C语言无法直接使用,需要做一定的转换,介于我指针学的也不是很好,就不说这中间的转换过程和原理了,日后有闲暇了再慢慢研究 2.头插法和尾插法的区别,带头指针和不带头指针的区别
23王道——单链表
下次再说的博客
03-14 1515
#include<iostream>
王道考研数据结构单链表代码（带头节点）
05-28
自己写的王道考研数据结构单链表（带头结点）例题和习题代码，所有函数运行都没问题。
王道数据结构——单链表
UncleJokerly
08-05 437
单链表
数据结构：单链表（王道2022）
weixin_45091567的博客
07-17 1271
王道数据结构2022代码单链表不带头节点的单链表按位序插入（带头结点）按位序插入（不带头结点）按位序删除（带头结点）指定节点的删除中间节点最后节点 单链表 不带头节点的单链表 typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; //初始化一个空链表 bool InitList(LinkList &L){ L = NULL; //空链表，暂时没有其他节点 } //判断单链表是否为空 boo
408-王道-单链表
m0_56553975的博客
11-17 145
初学数据结构-单链表
王道数据结构2.3.7——18、循环单链表的合并
Hillbox
10-12 198
思路 主要是注意结尾的处理 代码 void merge(LinkList &h1,LinkList h2){ LNode *p=h1->next; while(p->next!=h1){ p=p->next; } p->next=h2->next; while(p->next!=h2){ ...
王道数据结构精简笔记——单链表
最新发布
weixin_53830825的博客
07-10 581
/ 定义单链表结点类型（结点） ElemType data;// 每个结点存放一个数据元素（数据域） struct LNode * next;// 指针指向下一个结点（指针域） } LNode , * LinkList;// LinkList是指向结构体首地址的指针使用LinkList：强调这是一个单链表；使用LNode *：强调这是一个结点；
王道数据结构——单链表（后插法和其他操作）
UncleJokerly
08-05 311
单链表（后插法和其他操作）
王道书 P41 T19（循环单链表实现）
shengruyu的博客
07-14 162
王道书P41 T19（循环单链表实现）
王道数据结构——链表、循环单链表实现
qq_42242452的博客
04-29 1571
王道考研单链表、循环单链表代码实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值