线性表--循环单链表

最新推荐文章于 2023-04-04 17:25:32 发布
最新推荐文章于 2023-04-04 17:25:32 发布
阅读量219 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/snypxk/article/details/88060675
版权

CircularSingleLinkList.h

#pragma once

template <class DataType>
struct Node
{
	DataType data;
	Node<DataType> *next;
};

template <class DataType>
class CircularSingleLinkList
{
public:
	CircularSingleLinkList();//无参数构造函数
	CircularSingleLinkList(int n, DataType a[]);//有参数构造函数:用含n个元素的数组采用尾接法初始化循环单链表【尾接法】
	~CircularSingleLinkList();//析构函数
	int GetLength();//获得循环单链表长度
	bool IsEmpty();//判断循环单链表是否为空
	DataType GetValueByLocation(int i);//从头结点的下一结点起，按位查找返回循环单链表的第i个元素
	DataType DeleteByLocation(int i);//从头结点的下一结点起，删除循环单链表的第i个元素并返回删除的值
	DataType DeleteAtHead();//删除头部元素并返回删除的值
	DataType DeleteAtTail();//删除尾部元素并返回删除的值
	DataType GetMaxElement();//获得循环单链表的最大元素
	DataType GetMinElement();//获得循环单链表的最小元素
	Node<DataType> *GetFirst();//获得循环单链表的头结点指针
	void Insert(int i, DataType x);//从头结点的下一结点起，按位插入元素
	void InsertAtHead(DataType x);//在头部插入元素
	void InsertAtTail(DataType x);//在尾部插入元素
	void PrintSingleLinkList();//遍历循环单链表
	void ClearSingleLinkList();//清空循环单链表
	void SetValueAtLocation_iBy_x(int i, DataType x);//从头结点的下一结点起，设置位置i的元素的值为x
	void SortSingleLinkList();//把循环单链表从小到大排序

private:
	Node<DataType> *first;
};

CircularSingleLinkList.cpp

#include"CircularSingleLinkList.h"

template<class DataType>
CircularSingleLinkList<DataType>::CircularSingleLinkList()
{
	first = new Node<DataType>;
	first->next = first;
	first->data = 0;
}

template<class DataType>
CircularSingleLinkList<DataType>::CircularSingleLinkList(int n, DataType a[])
{
	first = new Node<DataType>;
	Node<DataType> *temp = first;//temp作为尾指针
	Node<DataType> *s;
	for (int i = 0; i < n; i++) {
		s = new Node<DataType>;
		s->data = a[i];
		temp->next = s;
		temp = s;
	}
	temp->next = first;
	first->data = n;
}

template<class DataType>
CircularSingleLinkList<DataType>::~CircularSingleLinkList()
{
	Node<DataType> *p = first->next;
	while (p != first) 
	{//先删去除了头结点的所有结点
		Node<DataType> *q = p;
		p = p->next;
		delete q;
	}
	delete first;//最后删去头结点
}

template<class DataType>
int CircularSingleLinkList<DataType>::GetLength()
{
	return first->data;
}

template<class DataType>
bool CircularSingleLinkList<DataType>::IsEmpty()
{
	if (first->data == 0 || first->next == first)
		return true;
	else return false;
}

template<class DataType>
DataType CircularSingleLinkList<DataType>::GetValueByLocation(int i)
{
	if (i > first->data || IsEmpty()) {
		cout << "delete error!" << endl;
		return -1;
	}
	Node<DataType> *p = first->next;
	for (int j = 1; j < i; p = p->next) {
		j++;
	}
	return p->data;
}

template<class DataType>
DataType CircularSingleLinkList<DataType>::DeleteByLocation(int i)
{
	if (i > first->data || IsEmpty()) {
		cout << "delete error!" << endl;
		return -1;
	}
	int j = 1;
	Node<DataType> *q = first;
	Node<DataType> *p = first->next;
	while (j < i)
	{
		q = p;
		p = p->next;
		j++;
	}
	q->next = p->next;
	DataType temp = p->data;
	first->data--;
	delete p;
	return temp;
}

template<class DataType>
DataType CircularSingleLinkList<DataType>::DeleteAtHead()
{
	if (first->data ==0 || IsEmpty()) {
		return -1;
	}
	Node<DataType> *p = first->next;
	first->next = p->next;
	DataType temp = p->data;
	first->data--;
	delete p;
	return temp;
}

template<class DataType>
DataType CircularSingleLinkList<DataType>::DeleteAtTail()
{
	if (first->data == 0 || IsEmpty()) {
		return -1;
	}
	Node<DataType> *p = first;
	Node<DataType> *q = first->next;
	while (q->next != first)
	{
		p = q;
		q = q->next;
	}
	p->next = first;
	DataType temp = q->data;
	first->data--;
	delete q;
	return temp;
}

template<class DataType>
DataType CircularSingleLinkList<DataType>::GetMaxElement()
{
	if (first->data == 0 || IsEmpty()) {
		cout << "get error!" << endl;
		return -1;
	}
	Node<DataType> *p = first->next;
	DataType max = p->data;
	for (p = p->next; p != first; p = p->next) {
		if (p->data > max) {
			max = p->data;
		}
	}
	return max;
}

template<class DataType>
DataType CircularSingleLinkList<DataType>::GetMinElement()
{
	if (first->data == 0 || IsEmpty()) {
		cout << "get error!" << endl;
		return -1;
	}
	Node<DataType> *p = first->next;
	DataType min = p->data;
	for (p = p->next; p != first; p = p->next) {
		if (p->data < min) {
			min = p->data;
		}
	}
	return min;
}

template<class DataType>
Node<DataType>* CircularSingleLinkList<DataType>::GetFirst()
{
	if (first->data == 0 || IsEmpty()) {
		cout << "get error!" << endl;
		return nullptr;
	}
	return first;
}

template<class DataType>
void CircularSingleLinkList<DataType>::Insert(int i, DataType x)
{
	if (first->data == 0 || IsEmpty() || i > first->data+1) {
		cout << "insert error!" << endl;
		return;
	}
	int j = 1;
	Node<DataType> *q = first;
	Node<DataType> *p = first->next;
	while (j < i)
	{
		q = p;
		p = p->next;
		j++;
	}
	Node<DataType> *temp = new Node<DataType>;
	temp->data = x;
	q->next = temp;
	temp->next = p;
	first->data++;
}

template<class DataType>
void CircularSingleLinkList<DataType>::InsertAtHead(DataType x)
{
	Node<DataType> *temp = new Node<DataType>;
	temp->data = x;
	temp->next = first->next;
	first->next = temp;
	first->data++;
}

template<class DataType>
void CircularSingleLinkList<DataType>::InsertAtTail(DataType x)
{
	Node<DataType> *q = first;
	while (q->next != first)
	{
		q = q->next;
	}
	Node<DataType> *temp = new Node<DataType>;
	q->next = temp;
	temp->next = first;
	temp->data = x;
	first->data++;
}

template<class DataType>
void CircularSingleLinkList<DataType>::PrintSingleLinkList()
{
	if (first->data == 0 || IsEmpty()) {
		cout << "print error!" << endl;
		return;
	}
	int j = 0;
	Node<DataType> *q = first->next;
	while (q != first)
	{
		cout << q->data << "  ";
		q = q->next;
		j++;
		if (j % 50 == 0)
			cout << endl;
	}
	cout << endl;
}

template<class DataType>
void CircularSingleLinkList<DataType>::ClearSingleLinkList()
{
	Node<DataType> *p;
	Node<DataType> *q = first->next;
	while (q != first)
	{
		p = q;
		q = q->next;
		delete p;
	}
	first->next = first;
	first->data = 0;
}

template<class DataType>
void CircularSingleLinkList<DataType>::SetValueAtLocation_iBy_x(int i, DataType x)
{
	if (i > first->data || IsEmpty()) {
		cout << "set error!" << endl;
		return;
	}
	int j = 1;
	Node<DataType> *p = first->next;
	while (j < i)
	{
		p = p->next;
		j++;
	}
	p->data = x;
}

template<class DataType>
void CircularSingleLinkList<DataType>::SortSingleLinkList()
{
	if (first->data == 0 || IsEmpty()) {
		cout << "sort error!" << endl;
		return;
	}
	int i;
	int N = first->data;
	DataType *arr = new DataType[N];
	Node<DataType> *p = first->next;
	for (i = 0; p != first; p = p->next, i++) {//先把所有结点的数据提取到一个数组arr中存储
		arr[i] = p->data;
	}
	DataType temp;
	for (i = 1; i < N; i++) {	//选用插入排序对数组arr从小到大排序
		for (int j = i; j > 0 && arr[j] < arr[j - 1]; j--) {
			temp = arr[j];
			arr[j] = arr[j - 1];
			arr[j - 1] = temp;
		}
	}
	for (i = 0, p = first->next; p != first; p = p->next, i++) {//为每个结点从小到大赋值
		p->data = arr[i];
	}
	delete[] arr;
}

CircularSingleLinkListTest.cpp

#include<iostream>
#include"CircularSingleLinkList.cpp"
using namespace std;

void main()
{
	float a[] = { -0.1, 2.5, 56, 4, 6.7, 8, -5.22, 23.4, -31.8, 9.999, 5.20, 37, -33.33 };
	//float b[] = { 1, 6.6, 8.8, -7.5, -0.91, 52.033, 3.3, 3.20, 1.5, -4.4 };

	CircularSingleLinkList<float> Test1(sizeof(a)/sizeof(a[0]), a);
	cout << "打印尾接法初始化的循环单链表：";
	Test1.PrintSingleLinkList();
	cout << "       获得循环单链表1的长度：" << Test1.GetLength() << endl;

	cout << "     获得循环单链表1的最大值：" << Test1.GetMaxElement() << endl;
	cout << "     获得循环单链表1的最小值：" << Test1.GetMinElement() << endl;

	cout << "     循环单链表1删除头部元素：" << Test1.DeleteAtHead() << endl;
	cout << "     循环单链表1删除尾部元素：" << Test1.DeleteAtTail() << endl;
	cout << "             打印循环单链表1：";
	Test1.PrintSingleLinkList();
	cout << "      获得循环单链表1的长度：" << Test1.GetLength() << endl;

	cout << "循环单链表1位置为6的元素的值：" << Test1.GetValueByLocation(6) << endl;
	cout << "循环单链表1删除位置为8的元素：" << Test1.DeleteByLocation(8) << endl;
	cout << "             打印循环单链表2：";
	Test1.PrintSingleLinkList();
	cout << "       获得循环单链表1的长度：" << Test1.GetLength() << endl;

	cout << "循环单链表1在头部插入元素1.21：" << endl;
	Test1.InsertAtHead(1.21);
	cout << "  循环单链表1在尾部插入元素-1：" << endl;
	Test1.InsertAtTail(-1);

	cout << "             打印循环单链表1：";
	Test1.PrintSingleLinkList();
	cout << "       获得循环单链表1的长度：" << Test1.GetLength() << endl;

	cout << "设置循环单链表1中位置为8的元素为888：" << endl;
	Test1.SetValueAtLocation_iBy_x(8,888);

	cout << "             打印单链表1：";
	Test1.PrintSingleLinkList();
	cout << "       获得循环单链表1的长度：" << Test1.GetLength() << endl;

	cout << "  循环单链表由小到大排序：" << endl;
	Test1.SortSingleLinkList();

	cout << "             打印循环单链表1：";
	Test1.PrintSingleLinkList();

	cout << "   判断循环单链表1是否为空表：" << Test1.IsEmpty() << endl;
	cout << "             清空循环单链表1：" << endl;
	Test1.ClearSingleLinkList();
	cout << "   判断循环单链表1是否为空表：" << Test1.IsEmpty() << endl;

	cout << "循环单链表1删除位置为5的元素：";
	Test1.DeleteByLocation(5);
}

运行结果：

在这里插入图片描述

snypxk
关注
专栏目录
(王道408考研数据结构)第二章线性表-第三节3：循环单链表和循环双链表
快乐江湖的博客
11-10 1303
文章目录一：循环链表定义二：循环单链表三：循环双链表 一：循环链表定义 循环链表：规定好头尾结点的指向形成环状 循环单链表：其尾节点的next指针由原本的空改为指向头结点 循环双链表：其尾节点的next指针由原本的空改为指向头结点，同时头结点的prior指针指向尾节点 二：循环单链表 原来的单链表如果p是尾节点，一定有p->next=NULL; 循环单链表如果p是尾节点，一定有p->next=Head; 注意循环单链表的初始化 bool InitList(LNode*& He
数据结构-线性表-单链表
zhh9426的博客
08-09 483
数据结构-线性表-单链表
循环链表及线性表的应用
dcw142857的博客
05-26 253
循环链表的应用之约瑟夫环问题以及线性表总结之顺序表与链表的比较 1.1问题说明 问题描述：编号为1，2，···，n的n个人围坐在一圆桌旁，每人持有一个正整数的密码。从第一个人开始报数，报到一个预先约定的正整数m时，停止报数，报m的人退席，下一个人又重新从1开始报数，依此重复，直至所有的人都退席。编一程序输出他们退席的编号序列。例如，设m=20，n=7，7个人的密码依次是3，1，7，2，4，8，4，则退席的人的编号依次为6，1，7，5，3，2，4。 基本要求：用不带表头结点的循环单链表表示围成圆圈的n个人;要
链表的各种操作与代码实现(下节)
凡是过往，皆为序章
07-29 209
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言5、链表：打印一个链表（递归）：6、链表：反转一个链表（递归）：7、链表：双向链表的实现：8、链表：双向链表的实现：总结 前言 最近在学数据结构，对链表的一些常见操作以及代码实现进行了总结，分享一下。 提示：以下是本篇文章正文内容，下面案例可供参考 5、链表：打印一个链表（递归）： //Print Linked List using Recursion #include<stdio.h> #include<
数据结构（二）：链表及面试常考的算法
bb8886的博客
04-04 209
链表及面试题
单链表头结点后插入元素及遍历单链表educoder
打码少年风萧的博客
06-03 2635
//遍历单链表，请把代码补全 void PrintList(Node *first) { Node *p; p=first->next; while(p) { printf("%d ",p->data); p=p->next; } printf("\n"); } /*本函数的功能是在头结点后面插入一个新结点，结点的数据域的值为x*/ void InsertAtHead(Node *first,DataType x) { Node *T; T=(Node *)m
单链表插入（完整版程序 在表头和表尾插入算法）
理工科的杜小甫的博客
06-21 3612
#include<stdio.h> #include<stdlib.h> #include<malloc.h> #include<string.h> #define N 3 typedef struct node { char name[20]; struct node *next; }ListNode;ListNode *creat(int n) { ListNode *p
实验1-2 线性表-单链表.doc
最新发布
04-11
### 实验1-2 线性表-单链表 #### 实验目的 本次实验旨在帮助学生理解和掌握单链表的基本概念与操作方法。通过实际编程实践，学生能够熟悉以下内容： 1. **掌握使用C Free 5.0进行程序调试的方法**：通过这个实验，...
二、线性表--单链表
weixin_44706466的博客
06-27 121
自用
数据结构 线性表-单链表的定义及基本操作
Mi-ronin的博客
03-16 2796
文章目录一.引入二.线性表链式存储结构的定义2.1 顺序结构和链式结构的区别2.2结点定义 一.引入 对于线性表来说，有顺序存储结构，然而顺序结构是有缺点的：插入和删除时需要移动大量元素；因此我们需要解决这一系列问题，线性表的链式存储结构刚好解决了这些问题。 二.线性表链式存储结构的定义 2.1 顺序结构和链式结构的区别 在顺序结构中，每个数据元素只需要存数据元素信息就可以了，在链式结构中，除了要存储元素信息外，还要存储后继元素的存储地址，因此，我们引入了结点。 2.2结点定义 为了表示每个数据元素 a 与
CStringArray的使用
qingkongxiaoyang的专栏
12-12 9159
四、CStringArray的使用：同样，CStringArray也是我比较喜欢用的类型之一哦，不过，不是任何时候都可以用的啊。 1、向CStringArray中添加数据：Add CStringArray m; m.Add("one"); m.Add("two");2、返回CStingArray的长度： GetSize Gets number of elements
单向链表
qq_39557517的博客
07-22 252
#include <stdio.h> #include <stdlib.h> int N = 20; struct Node{ int data; struct Node* next; }; int searchfor(int *a, int len, int x){ if(len<1) return -1; if(*a == x) return N-len;
数据结构
chuojuedeng3068的博客
12-30 1150
国外 IT 教育学院 Educative.io 创始人 Fahim ul Haq 写过一篇过万赞的文章，总结了程序员面试中需要掌握的 8 种数据结构知识。Fahim ul Haq 曾在 Facebook 和微软任职，面试过不少程序员，所以这篇文章还是值得参考的。以下内容编译自他的这篇《准备下次...
常见数据结构及面试常见代码题(1)
weiqu4386的博客
05-14 270
数组 基本操作： 插入、删除、返回指定位置的元素、得到数组所有元素的数量。 面试常见问题： 寻找数组第k大的数字 找到数组中第一个不重复的整数 合并两个有序数组 重新排列数组中的正值和负值 栈 应用： 撤销操作 基本操作： Push 顶部插入 Pop 移除栈顶元素 isEmpty 栈为空则返回true Top 返回顶部元素，但不移除 面试常见问题： 用栈计算后缀表达式 对栈的元素进行排序 判断表达式是否括号平衡 队列 应用： 银行排队 基本操作： Enqueue(): 在队列尾部插入 Dequeue()
数据结构 链式堆栈C／C++
manba
10-08 282
堆栈分为顺序存储 和 链式存储 两种 下面给大家提供一个链式存储的，这里小编是用 C++来描述的堆栈 思路： 堆栈是先进后出的特点，利用这个特点，把表头后作为堆栈口。 设置一个　head表头保持不动，因为　堆栈是只能在一头操作的，所以需要　把　表头后作为堆栈的口，进行出栈入栈操作   #include &lt;iostream&gt; using namespace std; ty...
c语言insertHead函数怎么用,(C语言)写一个函数insert,用来向一个动态链表插入节点...
weixin_39777488的博客
05-20 651
写一个函数insert,用来向一个动态链表插入节点用creat,print,del,insert四个函数,编写主函数,先后调用这些函数,实现链表的建立,输出,删除和插入,从主函数中指定需要删除和插入的节点的数据 https://blog..net/qq_41071068/article/details/90117026#define _CRT_SECURE_NO_WARNINGS#include#...
LeetCode 707：设计链表
昨天今天和明天
12-02 396
题目描述：设计链表 解题思路： 一、单指针实现 首先我们回顾链表的数据结构，它至少要有一个头指针，指向链表的第一个Node，数据和指向下一结点的指针存放在Node中。 //头指针 private Node head; //静态内部类Node，用于存放实际的数据 private static final class Node{ private int val; private Node ne...
在单链表的头结点后插入一个结点
vener_的博客
09-24 1849
typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; void Insert(LinkList &L,ElemType x) { if(L==NULL) return; LNode *s=(LNode*)malloc(sizeof(LNode)); s->data=x; s->next=L->next; L->next=s; } 2013年.
线性表详解：循环单链表与循环双链表
"带头结点的循环单链表和循环双链表是数据结构中线性表的链式存储方式的扩展，它们主要用于解决线性数据的动态存储和操作问题。" 在数据结构中，线性表是一种基本的数据组织形式，它由0个或多个具有相同类型的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值