C++实现顺序表&单链表&双链表

最新推荐文章于 2022-07-27 13:06:53 发布
最新推荐文章于 2022-07-27 13:06:53 发布
阅读量309 收藏 3
点赞数 1
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37922654/article/details/75905380
版权

c++实现顺序表

#include<iostream>
#include<assert.h>
using namespace std;

typedef int DataType;
class Seqlist
{
public:
	Seqlist() //构造函数
		:_arr(NULL)
		, _capacity(0)
		, _size(0)
	{}
	Seqlist(const Seqlist& s)  //拷贝构造
	{
		_arr = new DataType[s._size];
		memcpy(_arr, s._arr, s._size*sizeof(DataType));
		_size = s._size;
		_capacity = _size;
	}
	void Release()
	{
		if (_arr)
		{
			delete[] _arr;
			_size = 0;
			_capacity = 0;
			_arr = NULL;
		}
	}
	~Seqlist()  //析构函数
	{
		Release();
	}
	Seqlist& operator=(Seqlist s)  //赋值运算符重载
	{
		swap(_arr, s._arr);
		swap(_size, s._size);
	    swap(_capacity, s._capacity);
		return *this;
	}
	void check_capacity();
	void Print();
	void PushBack(DataType x);
	void PushFront(DataType x);
	void PopBack();
	void PopFront();
	void Insert(size_t pos, DataType x);
	void Erase(size_t pos);
	size_t Find(DataType x);
private:
	DataType* _arr;
	size_t _capacity;
	size_t _size;
};
void Seqlist::check_capacity()
{
	if (_size == _capacity)
	{
		_capacity = 2 * _capacity + 1;
		_arr = (DataType*)realloc(_arr, _capacity*sizeof(DataType));
	}
}
void Seqlist::Print()
{
	size_t i = 0;
	for (i = 0; i < _size; i++)
	{
		cout << _arr[i] << " ";
	}
	cout << endl;
}
void Seqlist::PushBack(DataType x)
{
	check_capacity();
	_arr[_size++] = x;
}
void Seqlist::PushFront(DataType x)
{
	check_capacity();
	int i = 0;
	for (i = _size; i > 0; i--)
	{
		_arr[i] = _arr[i - 1];
	}
	_arr[0] = x;
	_size++;
}
void Seqlist::PopBack()
{
	if (_size == 0)
	{
		return;
	}
	_size--;
}
void Seqlist::PopFront()
{
	if (_size == 0)
	{
		return;
	}
	size_t i = 0;
	for (i = 0; i < _size; i++)
	{
		_arr[i] = _arr[i + 1];
	}
	_size--;
}
void Seqlist::Insert(size_t pos, DataType x)
{
	    assert(pos<_size);
		check_capacity();
		size_t i = 0;
		for (i = _size; i > pos; i--)
		{
			_arr[i] = _arr[i - 1];
		}
		_arr[pos] = x;
		_size++;
}
size_t Seqlist::Find(DataType x)
{
	size_t i = 0;
	for (i = 0; i < _size; i++)
	{
		if (_arr[i] == x)
		{
			return i;
		}
	}
	return -1;
}
void Seqlist::Erase(size_t pos)
{
	    if (_size == 0)
		return;	
		size_t i = 0;
		for (i = pos; i < _size; i++)
		{
			_arr[i] = _arr[i + 1];
		}
		_size--;
}

void test()
{
	Seqlist s;
	s.PushBack(1);
	s.PushBack(2);
	s.PushBack(3);
	s.PushBack(4);
	s.PushFront(5);
	s.PushFront(6);
	s.Print();
	cout << "- - - - - - - - - - - - - -" << endl;
	s.PopBack();
	s.Print();
	s.PopFront();
	s.Print();
	s.Insert(2, 8);
	s.Print();
	s.Erase(2);
	s.Print();
}
int main()
{
	test();
	system("pause");
	return 0;
}
运行结果


C++实现单链表

#include<iostream>
#include<assert.h>
using namespace std;

typedef int DataType;
struct SListNode
{
	DataType _data;
	SListNode* _next;
	SListNode(DataType x) //构造函数
		:_data(x)
	    ,_next(NULL)
	{}
};

class Slist
{
	typedef SListNode Node;
public:
	Slist()  //构造函数
		:_head(NULL)
		,_tail(NULL)
	{}
	Slist(const Slist& s)  //拷贝构造
	{
		Node* cur = s._head;
		while (cur)
		{
			PushBack(cur->_data);
			cur = cur->_next;
		}
	}
	void Release()
	{
		Node* cur = _head;
		while (cur)
		{
			Node* next = cur->_next;
			delete cur;
			cur = next;
		}
		_head = NULL;
		_tail = NULL;
	}
	~Slist()
	{
		Release();
	}
	Slist& operator=(const Slist& s)
	{
		if (this != &s)
		{
			Release();
			Node* tmp = s._head;
			while (tmp)
			{
				PushBack(tmp->_data);
				tmp = tmp->_next;
			}
		}
		return *this;
	}
	Node* BuyNode(DataType x)
	{
		Node* Newnode = (Node*)malloc(sizeof(Node));
		Newnode->_data = x;
		Newnode->_next = NULL;
		return Newnode;
	}
	void PushBack(DataType x)
	{
		//1 空链表
		//2 只有一个结点
		//3 多个结点
		if ((_head == NULL) && (_tail==NULL))
		{
			_head = _tail = new Node(x);
		}
		else
		{
			_tail->_next = new Node(x);
			_tail = _tail->_next;
		}
	}
	void Print()
	{
		Node* cur = _head;
		while (cur)
		{
			cout << cur->_data << "->";
			cur = cur->_next;
		}
		cout << "NULL" << endl;
	}
	void PushFront(DataType x)
	{
		//1 空链表
		//2 至少有一个结点
		if ((_head == NULL) && (_tail == NULL))
		{
			_head = _tail = new Node(x);
		}
		else
		{
			Node* tmp = new Node(x);
			tmp->_next = _head;
			_head = tmp;
		}
	}
	void PopBack()//尾删
	{
		//1 空链表
		//2 只有一个结点
		//3 多个结点
		if (_head == NULL)
		{
			return;
		}
		else if (_head == _tail)
		{
			delete _head;
			_head = NULL;
			_tail = NULL;
		}
		else
		{
			Node* tmp = _head;
			while (tmp->_next!=_tail)
			{
				tmp = tmp->_next;
			}
			delete _tail;
			tmp->_next = NULL;
		}
	}
	void PopFront()
	{
		if (_head == NULL)
		{
			return;
		}
		else if (_head == _tail)
		{
			delete _head;
			_head = NULL;
			_tail = NULL;
		}
		else
		{
			Node* next = _head->_next;
			delete _head;
			_head = next;
		}
	}
	Node* Find(DataType x)
	{
		Node* cur = _head;
		while (cur)
		{
			if (cur->_data == x)
			{
				return cur;
			}
			cur = cur->_next;
		}
		return NULL;
	}

	void Insert(Node* pos, DataType x)
	{
		assert(pos);
		assert(_head);
		//1 头插
		//2 中间插
		if (pos == _head)
		{
			PushFront(x);
		}
		else
		{
			Node* cur = _head;
			while (cur->_next != pos)
			{
				cur = cur->_next;
			}
			Node* tmp = new Node(x);
			cur->_next = tmp;
			tmp->_next = pos;
		}
	}
	void Erase(Node* pos)
	{
		assert(pos);
		assert(_head);
		//1 头删
		//2 尾删
		//3 从中间删
		if (pos == _head)
		{
			PopFront();
		}
		else if (pos == _tail)
		{
			PopBack();
		}
		else
		{
			Node* cur = _head;
			while (cur->_next != pos)
			{
				cur = cur->_next;
			}
			cur->_next = pos->_next;
			delete pos;
			pos = NULL;
		}
	}
private:
	SListNode* _head;
	SListNode* _tail;
};

void test()
{
	Slist s;
	s.PushBack(1);
	s.PushBack(2);
	s.PushBack(3);
	s.PushBack(4);
	s.Print();
	s.PushFront(5);
	s.PushFront(6);
	s.Print();
	cout << "- - - - - - - - - - - -" << endl;
	s.PopBack();
	s.Print();
	s.PopFront();
	s.Print();
	s.Insert(s.Find(3), 4);
	s.Print();
	s.Erase(s.Find(2));
	s.Print();
}
int main()
{
	test();
	system("pause");
	return 0;
}
运行结果


C++实现双链表

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
typedef int DataType;
struct Node
{
	Node(const DataType& data)
	:_next(NULL)
	, _prev(NULL)
	, _data(data)
	{}
	Node* _next;
	Node* _prev;
	DataType _data;
};

class List
{
public:
	List()
	:_head(NULL)
	, _tail(NULL)
	{}
	List(const List& l) //拷贝构造
	: _head(NULL)
	, _tail(NULL)
	{
		Node* cur = l._head;
		if (l._head != NULL)
		{
			while (cur)
			{
				PushBack(cur->_data);
			    cur = cur->_next;
			}				
		}
	}
	~List()
	{
		if (_head != NULL)
		{
			Node* cur = _head;
			delete _head;
			_head = cur;
			_head = NULL;
			_tail = NULL;
		}
	}
	List& operator=(const List& l)
	{
		if (this->_head != l._head)
		{
			List tmp(l);
			swap(_head, tmp._head);
			swap(_tail, tmp._tail);
		}
	}
	List(size_t n, DataType data);
	void PushBack(const DataType& data)
	{
		//1 没有结点
		//2 有一个结点
		//3 有多个结点
		if (_head == NULL)
		{
			_head = _tail = new Node(data);
		}
		else if (_head->_next == NULL)
		{
			_head->_next = new Node(data);
			_tail = _head->_next;
			_tail->_prev = _head;
		}
		else
		{
			Node* cur = _tail;
			_tail->_next = new Node(data);
			_tail = _tail->_next;
			_tail->_prev = cur;
		}
	}
	void Print()
	{
		Node* cur = _head;
		while (cur)
		{
			cout << cur->_data << "->";
			cur = cur->_next;
		}
		cout << "NULL" << endl;
	}
	void PopBack() //尾删
	{
		//1 没有结点
		//2 有一个结点
		//3 有多个结点
		if (_head == NULL)
			return;
		else if (_head->_next == NULL)
		{
			delete _head;
			_head = NULL;
			_tail = NULL;
		}
		else
		{
			Node* tmp = _tail;
			_tail = _tail->_prev;
			_tail->_next = NULL;
			delete tmp;
		}
	}
	void PushFront(const DataType& data) //头插
	{
		//1 没有结点
		//2 有一个结点
		//3 有多个结点
		if (_head == NULL)
		{
			_head = _tail = new Node(data);
		}
		else
		{
			Node* cur = _head;
			_head = new Node(data);
			_head->_next=cur;			
		}
	}
	void PopFront() //头删
	{
		//1 没有结点
		//2 有一个结点
		//3 有多个结点
		if (_head == NULL)
			return;
		else if (_head->_next == NULL)
		{
			delete _head;
			_head = NULL;
			_tail = NULL;
		}
		else
		{
			Node* tmp = _head;
			_head = _head->_next;
			delete tmp;
		}
	}
	Node* Find(const DataType& data)
	{
		Node* cur = _head;
		while (cur)
		{
			if (cur->_data == data)
				return cur;
			else
				cur = cur->_next;
		}
		return NULL;
	}
	void Insert(Node* pos, const DataType& data)
	{
		assert(pos);
		assert(_head);
		if (pos == _head)
			PushFront(data);
		else
		{
			Node* tmp = new Node(data);
			pos->_prev->_next = tmp;
			tmp->_prev = pos->_prev;
			tmp->_next = pos;
			pos->_prev = tmp;
		}
	}
	void Erase(Node* pos)
	{
		assert(pos);
		assert(_head);
		if (pos == _head || pos->_prev == NULL)
			PopFront();
		else if (pos == _tail || pos->_next == NULL)
			PopBack();
		else
		{
			Node* front = pos->_prev;
			Node* back = pos->_next;
			front->_next = back;
			back->_prev = front;
		}
	}
	void Empty() 
	{
		Node* cur = _head;
		Node* tmp = NULL;
		while (cur)
		{
			tmp = cur;
			cur= cur->_next;
			delete tmp;
		}
		_head = _tail = NULL;
		cout << "clear" << endl;
	}
		
private:
	Node* BuyNode(const DataType& data)
	{
		return new Node(data);
	}
private:
	Node* _head;
	Node* _tail;
};

void test()
{
	List l;
	l.PushBack(4);
	l.PushBack(3);
	l.PushBack(2);
	l.PushBack(1);
	l.PushBack(5);
	l.Print();
	l.PopBack();
	l.Print();
	l.PushFront(5);
	l.PushFront(6);
	l.Print();
	l.PopFront();
	l.Print();
	cout << "- - - - - - - - - - " << endl;
	l.Insert(l.Find(2), 0);
	l.Print();
	l.Erase(l.Find(3));
	l.Print();
	l.Empty();
	

}
int main()
{
	test();
	system("pause");
	return 0;
}
运行结果

weixin_37922654
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++模版类实现顺序表、单链表、双链表
10-28
压缩包内为线性表的工程包；工程内包括顺序表、单链表、双链表的类的定义与实现；附适当注释；完全面向对象，类封装；测试类中用（纯）虚函数实现多态。
【C++】实现顺序表、单链表和双向链表
qq_37924645的博客
08-10 277
1. 实现顺序表 #pragma once typedef int DataType; class SeqList { public: SeqList() :_array(NULL) ,_size(0) ,_capacity(0) {} SeqList(const SeqList& s) { _array = (DataType*)malloc(sizeof(Dat
C++方式封装顺序表、单链表和双向链表
Elay0701的博客
08-26 496
1.顺序表 Seqlist.h #pragma once typedef int DataType; class Seqlist { public: Seqlist()//构造 :_array(NULL) , _size(0) , _capacity(0) {} Seqlist(const Seqlist& s)//拷贝构造 { _array = (Da
用c语言实现顺序表和链表,利用C++简单实现顺序表和单链表的示例代码
weixin_39950824的博客
05-21 382
本文主要给大家介绍了关于C++实现顺序表和单链表的相关内容，分享出来供大家参考学习，话不多说，来一起看看详细的介绍：一、顺序表示例代码：#include #include using namespace std;typedef int Datatype;class SeqList{public:SeqList():_array(NULL),_size(0),_capacity(0){}SeqLis...
c++实现链表简单操作（单链表、循环链表与双向链表）
u011251945的博客
07-25 249
链表，对比数组可以节省空间，由数据域与指针域构成一个数据块，操作方便。 1 单链表创建算法思路： 申明一节点p 初始化一空链表 头指针指向NULL，即建立一个带表头节点的单链表 循环查找要插入地方或删除 包括头插与尾插两种方式实现节点插入，c++模板方式构建结构体，简单实现插入与删除节点 #include&lt;iostream&gt; using namespace std; t...
C++顺序表，单链表，循环双链表，栈，实例
03-22
本文将深入探讨C++中的四个关键数据结构：顺序表、单链表、循环双链表以及栈，并通过实例来阐述它们的实现与应用。 1. **顺序表**：顺序表是最基础的数据结构，它在内存中连续存储元素，通过索引来访问。在C++中，...
c++ || 顺序表 单链表及链表习题
LQEmptycity的博客
07-27 742
数据 线性表
数据结构实战——线性表（顺序表、链表——单链表、双链表、循环链表、静态链表）
wypds的博客
04-09 1015
数据结构线性表实战 顺序表、单链表（头插法、尾插法、双链表、循环链表、静态链表） 一、什么是线性表 二、顺序表 三、链表 一、单链表 1、头插法 2、尾插法 二、双链表 三、循环链表 四、静态链表 前言 提示：这里可以添加本文要记录的大概内容： 数据结构——线性表 提示：以下是本篇文章正文内容，下面案例可供参考 一、什么是线性表 线性表是具有相同数据类型的n(>=0)个数据元素的有限序列，n为表长，n=0时线性表是一个空表。若用L命名线性表，一般表示为：L=(a[1]，a[2]，a[3]，.
顺序表，单链表，双向链表
01-04
本主题将深入探讨顺序表、单链表和双向链表的概念、实现以及它们之间的区别。 首先，顺序表是一种线性数据结构，它在内存中连续存储元素。这种存储方式使得随机访问变得高效，因为可以通过索引直接计算元素的地址。...
顺序表与单链表(C/C++实现)
lpblog的博客
09-02 1134
1.预备知识 1.学习结构体类型数据的动态储存分配 2.最好可以学懂链表基本语法 3.理解类型定义符typedef 4.理解并学会C++中引用知识
单链表的代码实现（C++）
qq_46601680的博客
08-01 1275
依据严蔚敏数据结构教材编写。 编写了以下功能：初始化、头插法创建表、尾插法创建表、输出链表、按位置查找、按值查找返回地址、按值查找返回位置、插入、删除、判断链表是否为空、求表长、清空链表、销毁链表。 完整代码如下： #include <iostream> using namespace std; typedef struct LNode{ //定义单链表存储结构 int data; //数据域 struct LNode *next; //指针域 }LNode
C++实现顺序表和单链表
青云衣兮白霓裳
10-29 499
1、顺序表 C++实现顺序表代码如下：//Seqlist.h #pragma once #include<iostream> #include<string.h> #include<assert.h>typedef int DataType;class SeqList { public: SeqList()//构造函数 :_array(NULL) , _si
c/c++实现顺序表和单链表
min954584739的博客
03-18 584
实现基于C/C++的数据结构的顺序表，单链表等，此程序未经过严格实验，只是提供大概思路，供大家参考指正
数据结构之线性表（顺序表、单链表、双链表）
C语言与CPP编程的博客
10-26 1959
1 线性表的基本概念 对于同一个线性表，其每一个数据元素的值虽然不同，但必须具有相同的数据类型； 数据元素之间具有一种线性的或“一对一”的逻辑关系； 第一个数据元素没有前驱，这个数据元素被称为开始节点； 最后一个数据元素没有后继，这个数据元素被称为终端节点； 除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继； 2 线性表抽象数据类型描述 基本操作如下： 线性表的置空操作clear()：将一个已经存在的线性表置为空表；
【数据结构】线性表：顺序表、单链表、双链表、单循环链表、双循环链表（java实现）
昂萨哈凯尔可真难记啊
11-04 916
目录 顺序表 单链表 双链表 单循环链表 双循环链表 总结 顺序表 package com.list; import java.lang.*; import java.util.*; /** * @author PangWanjia * @date 2020/11/3 14:50 */ /* 顺序表和java的ArrayList类 创建顺序表，顺序表的增删查改都是通过下标和容量实现的 */ class SqListClass<E>{ ..
C++模板类实现单链表
Nou_Camp的博客
04-08 4728
c++模板类实现单链表#include<iostream> using namespace std; #include<assert.h> #include<string> template<class T> struct LinkNode { LinkNode<T>* _next; T _data; LinkNode(const T& x) :_data(x
C++实现单链表（含完整代码）
热门推荐
Henry的博客
03-28 2万+
C++实现单链表（含完整代码） 使用C++实现单链表的基本操作 1、创建单链表 2、遍历单链表 3、插入单链表元素 4、单链表删除元素 5、判断单链表是否为空 6、单链表的长度 7、查找单链表元素 完整代码： #include <iostream> using namespace std; struct List { int val; struct List*.........
单链表，循环链表，双链表及其基本操作（C++实现）
My vegetable has exploded.
07-16 8072
    最近在学习严蔚敏教授的《数据结构》，有一些感想，在这里写下来，留做笔记，希望能对以后学习有所帮助。     我们知道，线性表就是n个数据元素的有限序列，它有两种实现方式，其一为顺序表，即数组+伪指针的方式实现，另一为链表，采用的是指针的方式实现。由于顺序表的知识偏向基础且其应用灵活性不高，故在此不再介绍，本文主要说明几种常用的链表是如何实现的以及其基本操作。 1.单链表：     单...
nginx-1.24.0.tar
最新发布
09-06
Nginx 1.24.0 是 Nginx 开源项目发布的一个重要更新版本，该版本在性能优化、功能增强以及安全性提升方面带来了诸多改进。当您下载 Nginx 1.24.0 的压缩包时，您将获得一个包含 Nginx 源代码的压缩文件，通常命名为 nginx-1.24.0.tar.gz（对于 GNU/Linux 和 macOS 系统）或类似的格式，具体取决于发布平台。 这个压缩包包含了编译 Nginx 服务器所需的所有源代码文件、配置文件模板（如 nginx.conf）、模块源码以及构建和安装说明。通过解压这个压缩包，您可以在支持 C 语言编译器的操作系统上编译并安装 Nginx 1.24.0。 Nginx 1.24.0 引入了一系列新特性和优化，可能包括但不限于对 HTTP/2 和 HTTP/3 协议的进一步支持、性能提升、新的模块或模块更新，以及对已知安全漏洞的修复。这使得 Nginx 能够在保持其作为高性能 HTTP 和反向代理服务器的声誉的同时，继续满足不断发展的网络需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值