C++实现双链表和双向循环链表和静态链表

已于 2022-11-20 18:08:42 修改
阅读量354 收藏 1
点赞数
文章标签： c++ 链表 数据结构
于 2022-11-20 16:26:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52041679/article/details/127950492
版权 
#pragma once
#include<iostream>
using namespace std;

//静态链表---一维数组

#define MAXSIZE 201//静态链表的大小---0不存放数据 从下标一开始存放数据

enum NODEUSE
{
	e_NOUSE = -1,//没有使用为-1
	e_LAST=-2,//最后一个元素为-2
};

template<class T>
struct STNode
{
	T data;
	int cur;//记录下个静态链表的节点的数组下标
};

template<class T>
class StaticList
{
public:
	StaticList();
	~StaticList();

public:
	int findAnIdlePos();//找到一个空闲的位置存放数据
	bool ListInsert(int pos,const T&e);
	bool ListDelete(int pos);

	bool GetElem(int pos, T& e);;
	int LocateElem(const T& e);

	void DispList();
	int  LengthList();
	bool EmptyList();

private:
	STNode<T> m_data[MAXSIZE];
	int m_length;
};

template<class T>
StaticList<T>::StaticList()
{
	for (int i = 1; i < MAXSIZE; i++)
	{
		m_data[i].cur = e_NOUSE;//标记这些为存放数据
	}
	m_length = 0;
}

template<class T>
int StaticList<T>::findAnIdlePos()//找到一个空闲的位置存放数据,没找到返回-1
{
	for (int i = 1; i < MAXSIZE; i++)
	{
		if (m_data[i].cur == e_NOUSE)
		{
			return i;
		}
	}
	return -1;
}

template<class T>
bool StaticList<T>::ListInsert(int pos, const T& e)
{
	if (pos<1 || pos>(m_length + 1))
	{
		cout << "不合法" << endl;
		return false;
	}

	int index;
	if ((index=findAnIdlePos()) == -1)
	{
		cout << "满了" << endl;
		return false;
	}

	int dataCount = 1;//记录元素个数
	int indexPrev;//保存插入位置前一个位置对于的数组下标

	if (pos == 1)//在第一个位置插入
	{
		m_data[index].data = e;
		if (m_length == 0)//空表---标记其为尾
		{
			m_data[index].cur = e_LAST;
		}
		else//非空表记录即cur的下标值，即下一个存放数据的位置
		{
			m_data[index].cur = m_data[0].cur;
		}
		m_data[0].cur = index;
	}
	else
	{
		int posCount = 0;//位置计数
		int tmpcur = m_data[0].cur;
		while (true)
		{
			posCount++;
			if (posCount >= (pos - 1))
			{
				indexPrev = tmpcur;
				break;
			}
		}
		int iTmpcurr = m_data[indexPrev].cur;
		m_data[indexPrev].cur = index;
		m_data[index].data = e;
		m_data[index].cur = iTmpcurr;
	}
	m_length++;
	cout << "插入成功" << endl;
	return true;
}

template<class T>
bool StaticList<T>::ListDelete(int pos)
{
	if (m_length < 1 || pos<1 || pos>m_length)
	{
		cout << "不合法" << endl;
		return false;
	}
	int tmpcur = m_data[0].cur;

	if (pos == 1)//在第一个位置删除
	{
		if (m_length != 1)
		{
			m_data[0].cur = m_data[tmpcur].cur;
		}
		m_data[tmpcur].cur = e_NOUSE;
		cout << "删除成功" << endl;
	}
	else
	{
		while (true)
		{
			posCount++;
			if (posCount >= (pos - 1))
			{
				indexPrev = tmpcur;
				break;
			}
			tmpcur= m_data[tmpcur].cur;
		}
		int iTmpcurr = m_data[indexPrev].cur;//要删除下标
		m_data[indexPrev].cur = m_data[iTmpcurr].cur;//删除节点前一个cur指向要删除的节点cur
		m_data[iTmpcurr].cur = e_NOUSE;

		cout << "删除成功" << endl;
	}
	m_length--;
	return true;
}

template<class T>
bool StaticList<T>::GetElem(int pos, T& e)
{
	if (m_length < 1 || pos<1 || pos>m_length)
	{
		cout << "不合法" << endl;
		return false;
	}

	int tmpcur = m_data[0].cur;
	int ppos = 0;
	while (true)
	{
		ppos++;
		if (ppos == pos)
		{
			e = m_data[tmpcur].data;
			cout << "找到了" << e << endl;
			return true;
		}
		tmpcur = m_data[tmpcur].cur;
	}
	return false;
}

template<class T>
int StaticList<T>::LocateElem(const T&e)
{
	if (m_length < 1 || pos<1 || pos>m_length)
	{
		cout << "不合法" << endl;
		return -1;
	}

	int tmpcur = m_data[0].cur;
	int ppos = 0;
	while (true)
	{
		ppos++;
		if (m_data[tmpcur].data == e && m_data[tmpcur].cur != e_NOUSE)
		{
			cout << "找到了" << ppos << endl;
			return tmpcur;
		}
		if (m_data[tmpcur].cur == e_LAST)
		{
			break;
		}
		tmpcur = m_data[tmpcur].cur;
	}
	cout << "没找到" << endl;
	return -1;
}


template<class T>
void StaticList<T>::DispList()
{
	if (m_length < 1)
	{
		cout << "链表为空" << endl;
	}

	int tmpcur = m_data[0].cur;
	while (true)
	{
		cout << m_data[tmpcur].data << " ";
		if ((tmpcur = m_data[tmpcur].cur) == e_LAST)
		{
			break;
		}
		cout << endl;
	}

}


template<class T>
int  StaticList<T>::LengthList()
{
	return m_length;
}

template<class T>
bool StaticList<T>::EmptyList()
{
	if (m_length < 1)
		return true;
	return false;
}


template<class T>
StaticList<T>::~StaticList()
{

}


#pragma once
#include<iostream>
using namespace std;

//双链表

template<class T>
struct DNode
{
	T data;
	DNode<T>* prior;
	DNode<T>* next;
};

template<class T>
class DList
{
public:
	DList();
	~DList();

public:
	bool DListInsert(int i, const T& e);
	bool DListDelete(int i);

	bool GetElem(int i,T&e);
	int LocateElem(const T& e);

	int GetLength();
	bool Empty();
	void DispDList();

private:
	DNode<T>* m_head;
	int m_length;
};

template<class T>
DList<T>::DList()
{
	m_head = new DNode<T>;
	m_head->next = nullptr;
	m_head->prior = nullptr;
	m_length = 0;
}

template<class T>
bool DList<T>::DListInsert(int i, const T& e)
{
	if (i<1 || i>(m_length + 1))
	{
		cout << "不合法" << endl;
		return false;
	}

	DNode<T>* p_curr = m_head;
	for (int j = 0; j < (i - 1); j++)
	{
		p_curr = p_curr->next;
	}
	DNode<T>* node = new DNode<T>;
	node->data = e;
	node->next = p_curr->next;
	node->prior = p_curr;
	if (p_curr->next!= nullptr)
	{
		p_curr->next->prior = node;
	}
	p_curr->next = node;
	m_length++;

	cout << "插入成功" << endl;
	return true;

}

template<class T>
bool DList<T>::DListDelete(int i)
{
	if (i<1 || i>(m_length + 1)||m_length<1)
	{
		cout << "删除不合法" << endl;
		return false;
	}

	DNode<T>* p_curr = m_head;
	for (int j = 0; j < (i - 1); j++)
	{
		p_curr = p_curr->next;
	}
	DNode<T>* p_willptr = p_curr->next;
	p_curr->next = p_willptr->next;
	if (p_willptr->next != nullptr)
	{
		p_willptr->next->prior = p_curr;
	}
	delete p_willptr;
	m_length--;

	cout << "删除成功" << endl;
	return true;
}

template<class T>
bool DList<T>::GetElem(int i, T& e)
{
	if (i<1 || i>m_length || m_length < 1)
	{
		cout << "链表为空" << endl;
		return false;
	}

	DNode<T>* p_curr = m_head;
	for (int j = 0; j < (i - 1); j++)
	{
		p_curr = p_curr->next;
	}
	e = p_curr->next->data;
	cout << "查找值：" << p_curr->next->data << endl;
	return true;
}

template<class T>
int DList<T>::LocateElem(const T& e)
{
	DNode<T>* p_curr = m_head;
	for (int j = 0; j <= m_length; j++)
	{
		if (p_curr->next->data == e)
		{
			cout << "找到：" << p_curr->next->data << " ";
			return j;
		}
		p_curr = p_curr->next;
	}
	cout << "找不到" << endl;

	return -1;
}

template<class T>
int DList<T>::GetLength()
{
	return m_length;
}

template<class T>
void DList<T>::DispDList()
{
	DNode<T>* p = m_head->next;
	while (p != nullptr)
	{
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}

template<class T>
bool DList<T>::Empty()
{
	if (m_length == 0)
	{
		return true;
	}
	return false;
}

template<class T>
DList<T>::~DList()
{
	DNode<T>* pnode = m_head->next;
	DNode<T>* ptmp;
	while (pnode != nullptr)
	{
		ptmp = pnode;
		pnode = pnode->next;
		delete ptmp;
	}
	delete m_head;
	m_head = nullptr;
	m_length = 0;
}

#pragma once
#include<iostream>
using namespace std;

//双向循环链表

template<class T>
struct SNode
{
	T data;
	SNode<T>* prior;
	SNode<T>* next;
};

template<class T>
class SList
{
public:
	SList();
	~SList();

public:
	bool SListInsert(int i,const T& e);
	bool DListDelete(int i);

	bool GetElem(int i, T& e);
	int LocateElem(const T& e);

	int GetLength();
	bool Empty();
	void DispDList();

private:
	int m_length;
	SNode<T>* m_head;
};

template<class T>
SList<T>::SList()
{
	m_head = new SNode<T>;
	m_head->next = m_head;
	m_head->prior = m_head;
	m_length = 0;
}

template<class T>
bool SList<T>::SListInsert(int i, const T& e)
{
	if (i<1 || i>(m_length + 1))
	{
		cout << "不合法" << endl;
		return false;
	}

	SNode<T>* p_curr = m_head;
	for (int j = 0; j < (i - 1); j++)
	{
		p_curr = p_curr->next;
	}
	SNode<T>* node = new SNode<T>;
	node->data = e;
	node->next = p_curr->next;
	node->prior = p_curr;
	if (p_curr->next != m_head)
	{
		p_curr->next->prior = node;
	}
	p_curr->next = node;
	m_length++;

	cout << "插入成功" << endl;
	return true;
}
template<class T>
bool SList<T>::DListDelete(int i)
{
	if (i<1 || i>(m_length + 1))
	{
		cout << "不合法" << endl;
		return false;
	}

	SNode<T>* p_curr = m_head;
	for (int j = 0; j < (i - 1); j++)
	{
		p_curr = p_curr->next;
	}
	SNode<T>* p_willptr = p_curr->next;
	p_curr->next = p_willptr->next;
	if (p_willptr->next != m_head)
	{
		p_willptr->next->prior = p_curr;
	}
	delete p_willptr;
	m_length--;

	cout << "删除成功" << endl;
	return true;
}

template<class T>
bool SList<T>::GetElem(int i, T& e)
{
	if (i<1 || i>m_length || m_length < 1)
	{
		cout << "链表为空" << endl;
		return false;
	}

	SNode<T>* p_curr = m_head;
	for (int j = 0; j < (i - 1); j++)
	{
		p_curr = p_curr->next;
	}
	e = p_curr->next->data;
	cout << "查找值：" << p_curr->next->data << endl;
	return true;
}

template<class T>
int SList<T>::LocateElem(const T& e)
{
	SNode<T>* p_curr = m_head;
	for (int j = 0; j <= m_length; j++)
	{
		if (p_curr->next->data == e)
		{
			cout << "找到：" << p_curr->next->data << " ";
			return j;
		}
		p_curr = p_curr->next;
	}
	cout << "找不到" << endl;

	return -1;
}

template<class T>
int SList<T>::GetLength()
{
	return m_length;
}

template<class T>
bool SList<T>::Empty()
{
	if(m_head->next==m_head)
	{
		return true;
	}
	return false;
}

template<class T>
void SList<T>::DispDList()
{
	SNode<T>* p = m_head;
	while (p->next != m_head )
	{
		cout << p->next->data << " ";
		p = p->next;
	}
	cout << endl;
}

template<class T>
SList<T>::~SList()
{
	SNode<T>* pnode = m_head->next;
	SNode<T>* ptmp;
	while (pnode != m_head)
	{
		ptmp = pnode;
		pnode=pnode->next;
		delete ptmp;
	}
	delete m_head;
	m_head = nullptr;
	m_length = 0;
}


void test_List_D()//双链表
{
	DList<int> dl;
	//插入
	dl.DListInsert(1, 10);
	dl.DListInsert(1, 20);
	dl.DListInsert(1, 30);
	dl.DispDList();

	//删除
	dl.DListDelete(1);
	dl.DispDList();

	int val = 0;
	dl.GetElem(1, val);

	int pos = dl.LocateElem(10);
	if (pos != -1)
	{
		cout << "该值下标为:" << pos << endl;
	}
}
void test_List_S()//双向循环链表
{
	SList<int> sl;
	sl.SListInsert(1, 10);
	sl.SListInsert(1, 20);
	sl.DispDList();

	sl.DListDelete(1);
	sl.DispDList();

}
int main()
{
	test_List_D();
	test_List_S();
	system("pause");
	return 0;
}
随便问玩玩啊哈
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
静态双向链表的多数组实现
乘风破浪会有时
08-27 974
使用静态多数组实现链表，结构体及相关函数声明如下：typedef struct ITEM { int key; void * statellite; } item_t; typedef struct STATIC_DOUBLE_ARRAY_DOUBLE_LINKED_LIST { int size; int count; int head; int f
c++编的双线循环链表
07-05
在学习和实践中，你可能还会遇到内存管理（如动态内存分配和释放）、异常处理以及多态等C++特性，这些都是在实现高效、可靠的双向循环链表时需要考虑的重要方面。通过深入研究和不断实践，你可以更深入地理解和运用...
双链表
weixin_52621900的博客
04-27 317
双链表 实现一个双链表，双链表初始为空，支持 55 种操作： 在最左侧插入一个数； 在最右侧插入一个数； 将第 kk 个插入的数删除； 在第 kk 个插入的数左侧插入一个数； 在第 kk 个插入的数右侧插入一个数 现在要对该链表进行 MM 次操作，进行完所有操作后，从左到右输出整个链表。 注意:题目中第 kk 个插入的数并不是指当前链表的第 kk 个数。例如操作过程中一共插入了 nn 个数，则按照插入的时间顺序，这 nn 个数依次为：第 11 个插入的数，第 22 个插入的数，…第 nn 个插入的数。
【c++数据结构】链表类实现（循环 双向 静态）
Ljyyy826的博客
05-09 204
#include<iostream> using namespace std; //有附加头节点的循环链表 template <class T> struct CircLinkNode { T data; CircLinkNode<T>* link; CircLinkNode(CircLinkNode* next = NULL) { data = 0; link = next; } CircLinkNode(T d, CircLinkNode* ne.
学习笔记：2.3 静态链表 循环链表 双向链表
张小憨憨的博客
10-08 524
2.3 静态链表 循环链表 双向链表 （注意：所有代码均已成功测试。编译环境：devC++） 1. 静态链表 用数组描述的链表叫做静态链表，又称游标实现法。 首先，让数组的元素都是由两个数据域组成,data和cur。即为,数组的每一个下标都对应一个data和一个cur。数据域data，用来存放数据元素，而cur相当于单链表中的next指针，存放该元素的后继在数组中的下标，我们通常把cur叫做下标。 注意：为了方便插入数据，通常会把数据建立得大一些，以便可以有一些空闲空间便于插入时不至于溢出。 //线性表的静
数据结构图文解析之：数组、单链表、双链表介绍及C++模板实现
weixin_33713707的博客
02-01 406
0. 数据结构图文解析系列 数据结构系列文章 数据结构图文解析之：数组、单链表、双链表介绍及C++模板实现 数据结构图文解析之：栈的简介及C++模板实现 数据结构图文解析之：队列详解与C++模板实现 数据结构图文解析之：树的简介及二叉排序树C++模板实现. 数据结构图文解析之：AVL树详解及C++模板实现 数据结构图文解析之：二叉堆详解及C++模板实现 1....
链表演示工具设计说明1
08-03
考虑到不同链表类型的共性，软件使用双向循环链表作为基础，根据用户选择展现不同特性。图像显示部分则依据链表类型展示不同形状的结点，并动态显示操作过程，如插入和删除时结点的变动。为了防止图像闪烁，采用了双...
简易链表的实现
06-06
### 知识点详解 #### 一、链表的基本概念 **链表**是一种常见的线性数据结构，它与数组类似，...通过以上分析，我们可以了解到这个简易链表的实现方法及其工作原理，这对于理解链表的基础概念和操作是非常有帮助的。
一个简单的链表
04-19
在这个主题中，我们将深入探讨“一个简单的链表”，它是一个基于C++实现的静态链表模型，非常适合初学者入门。通过理解这个简单的链表，我们可以为后续更复杂的链表操作打下坚实的基础。 首先，链表不同于数组，它...
C++语言实现一个多级文件目录管理系统，采用链表的数据结构。.zip
最新发布
02-28
下面我们将深入讨论C++语言和链表数据结构在实现这一系统中的应用。 首先，C++是一种静态类型的、编译式的、通用的、大小写敏感的、不仅支持过程化编程，也支持面向对象编程的程序设计语言。它的强大之处在于提供...
静态双向链表的单数组实现
乘风破浪会有时
08-28 845
静态双向链表的单数组实现方式
静态双链表
m0_74745356的博客
07-18 57
【代码】静态双链表。
链表 - 双链表/循环链表/静态链表
Mafia的博客
03-09 1576
双链表/循环链表/静态链表双链表初始化插入删除双链表的遍历循环链表插入删除静态链表定义静态链表基本操作 双链表 单链表无法逆向检索，有时候不太方便； 使用双链表，可进可退，存储密度比单链表低一些，因为一个节点除了后继指针next还多了一个前驱指针prior typedef struct DNode{ //定义双链表节点类型 ElemType data; //数据域 struct DNode *prior, *next; //前驱和后继指针 }DNode, *DLinklist; 初始化 带头结点：
数据结构——双向循环链表（一）双向静态链表
chenchen_fcj程序猿的博客
07-24 672
双向静态链表（在栈上开辟）本身基本不会用到，主要是为了理解其原理。 先看图 直接看例子： #include &lt;stdio.h&gt; //双向静态链表 typedef struct _DNode   //double node {         int data;         struct  _DNode * next;   //后继         struct  _DNod...
双向静态链表的实现
qq_36578537的博客
03-15 571
#ifndef __LIST_H__ #define __LIST_H__ #define MAX_SIZE 20 typedef struct Static_List { char data; int front; int cur; } Static_List_t; extern void Reserve_List(Static_List_t *list); exter...
数据结构作业三：双向链表与静态链表
greatwaves11的博客
05-02 710
双向链表： 双向链表也叫双链表，是链表的一种，它的每个数据 结点 中都有两个 指针 ，分别指向直接后继和直接前驱。 所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。 一，结构体定义及宏 #include <stdio.h> #include <malloc.h> /** * 定义字符双向链表。 */ typedef struct DoubleLinkNode{ char data; struct...
《数据结构》—— 循环链表与静态链表
博樽
09-12 603
循环单双链表的思考，以及静态链表逻辑表示的不同。
循环链表静态链表（及其操作）（考研数据结构）
qq_43603281的博客
08-26 298
1循环单链表： 循环单链表：尾结点的next指针指向头结点，从一个结点出发，可以找到链表中任何一个结点(可以找到前驱结点)。单链表初始化： typedef struct LNode{ ElemType data; struct LNode *prior,*next; }LNode,*LinkList; bool InitList(LinkList & L){//初始化一个循环单链表 L=(LNode*)malloc(sizeof(LNode));...
神机百炼1.22-静态双链表
buptsd的博客
05-14 304
三个变量，三个数组，完成静态双链表6大操作，精简代码快速掌握
C++每个链表之间的区别是什么
07-09
4. 静态链表（Static Linked List）：使用数组来实现的链表，节点的位置在创建时静态分配，不能动态地增加或删除节点。 每种链表都有其适用的场景和优缺点。选择合适的链表类型取决于具体的需求和操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值