C++方式封装顺序表、单链表和双向链表

最新推荐文章于 2018-08-31 12:09:04 发布
最新推荐文章于 2018-08-31 12:09:04 发布
阅读量483 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Elay0701/article/details/77600258
版权

1.顺序表

Seqlist.h


#pragma once

typedef int DataType;

class Seqlist
{
public:
	Seqlist()//构造
		:_array(NULL)
		, _size(0)
		, _capacity(0)
	{}
	Seqlist(const Seqlist& s)//拷贝构造
	{
		_array = (DataType*)malloc(sizeof(DataType)*s._size);
		memcpy(_array, s._array, sizeof(DataType)*s._size);
		_size = _capacity = s._size;
	}
	Seqlist& operator=(const Seqlist& s)//赋值运算符的重载
	{
		if (this != &s)
		{
			free(_array);
			_array = (DataType*)malloc(sizeof(DataType)*s._size);
			memcpy(_array, s._array, sizeof(DataType)*s._size);
		}
		return *this;
	}
	~Seqlist()//析构
	{
		if (_array)
		{
			free(_array);
			_size = _capacity;
			_array = NULL;
		}
	}
	void PushBack(DataType x)//尾插
	{
		CheckCapacity();
		_array[_size++] = x;
	}
	void PopBack()//尾删
	{
		assert(_size > 0);
		--_size;
	}
	void PushFront(DataType x)//头插
	{
		CheckCapacity();
		int end = _size - 1;
		while (end >= 0)
		{
			_array[end + 1] = _array[end];
			--end;
		}
		_array[0] = x;
		++_size;
	}
	void PopFront()//头删
	{
		assert(_size > 0);
		for (size_t i = 1; i < _size; ++i)
		{
			_array[i - 1] = _array[i];
		}
		--_size;
	}
	inline void Insert(size_t pos, DataType x)//指定一个位置插入
	{
		assert(pos <= _size);
		CheckCapacity();
		for (int end = _size - 1; end >= (int)pos; --end)
		{
			_array[end + 1] = _array[end];
		}
		_array[pos] = x;
		++_size;
	}
	inline void Erase(size_t pos)//指定一个位置删除
	{
		assert(pos <= _size);
		for (size_t i = pos + 1; i < _size; ++i)
		{
			_array[i - 1] = _array[i];
		}
		--_size;
	}
	inline DataType& operator[](size_t pos)//[]重载   修改任意位置的数据
	{
		assert(pos < _size);
		return _array[pos];
	}
	void CheckCapacity()//检查容量
	{
		if (_size == _capacity)
		{
			_capacity = _capacity * 2 + 3;
			_array = (DataType*)realloc(_array, _capacity*sizeof(DataType));
		}
	}
	void Print()//打印函数
	{
		for (size_t i = 0; i < _size; ++i)
		{
			cout << _array[i] << " ";
		}
		cout << endl;
	}
private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};
void TestSeqlist()
{
	Seqlist s;
	s.PushBack(1);
	s.PushBack(2);
	s.PushBack(3);
	s.PushBack(4);
	s.Print();
	s.PopBack();
	s.Print();
	s.PushFront(0);
	s.Print();
	s.PopFront();
	s.Print();
	s.Insert(0, 30);
	s.Print();
	s.Erase(0);
	s.Print();
}

test.cpp


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

#include "Seqlist.h"

int main()
{
	TestSeqlist();
	system("pause");
	return 0;
}

2.单链表

SList.h


#pragma once

typedef int DataType;

struct SlistNode
{
	SlistNode* _next;
	DataType _data;
	SlistNode(DataType x)
		:_data(x)
		,_next(NULL)
	{}
};
class Slist
{
	typedef SlistNode Node;
public:
	Slist()
	: _head(NULL)
	, _tail(NULL)
	{}
	Slist(const Slist& s);
	Slist& operator=(const Slist& s);
	~Slist()
	{
			Node* cur = _head;
			while (cur)
			{
				Node* next = cur->_next;
				delete cur;
				cur = next;
			}
			_head = _tail = NULL;
		}
	Node* BuyNode(DataType x)
	{
		Node* node = (Node*)malloc(sizeof(Node));
		node->_data = x;
		node->_next = NULL;
		return node;
	}
	void PushBack(DataType x)
	{
		if (_head == NULL)
		{
			_head = _tail = new Node(x);
		}
		else
		{
			_tail->_next = new Node(x);
			_tail = _tail->_next;
		}
	}
	void PopBack()
	{
		if (_head == NULL)
		{
			return;
		}
		else if (_head == _tail)
		{
			delete _head;
			_head = _tail = NULL;
		}
		else
		{
			Node* prev = _head;
			while (prev->_next != _tail)
			{
				prev = prev->_next;
			}
			delete _tail;
			_tail = prev;
			_tail->_next = NULL;
		}
	}
	void PushFront(DataType x)
	{
		if (_head == NULL)
		{
			_head = _tail = new Node(x);
		}
		else
		{
			Node* tmp = new Node(x);
			tmp->_next = _head;
			_head = tmp;
		}
	}
	void PopFront()
	{
		if (_head == NULL)
		{
			return;
		}
		else if (_head == _tail)
		{
			delete _head;
			_head = _tail = NULL;
		}
		else
		{
			Node* del = _head;
			_head = _head->_next;
			delete del;
		}
	}
	void Print()
	{
		Node* cur = _head;
		while(cur)
		{
			cout << cur->_data << " ";
			cur = cur->_next;
		}
		cout << endl;
	}
private:
	Node* _head;
	Node* _tail;
};
void TestSlist()
{
	Slist s;
	s.PushBack(1);
	s.PushBack(2);
	s.PushBack(3);
	s.PushBack(4);
	s.PushBack(5);
	s.Print();
}
test.cpp 

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

#include "SList.h"

int main()
{
	TestSlist();
	system("pause");
	return 0;
}

3.双向链表

List.h


#pragma once

typedef int DataType;

struct ListNode
{
	ListNode* _next;
	ListNode* _prev;
	DataType _data;

	ListNode(DataType x)
		:_next(NULL)
		,_prev(NULL)
		,_data(x)
	{}
};

class List
{
	typedef ListNode Node;

public:
	List()//构造
		:_head(NULL)
		,_tail(NULL)
	{}

	List(const List& s)//拷贝构造
		:_head(NULL)
		,_tail(NULL)
	{
		Node* cur = s._head;
		while (cur)
		{
			PushBack(cur->_data);
			cur = cur->_next;
		}
	}

	List& operator=(const List& s)//赋值运算符的重载
	{
		if (this != &s)
		{
			Node* cur = _head;
			while (cur)
			{
				Node* next = cur->_next;
				delete cur;
				cur = next;
			}
			_head = _tail = NULL;
			Node* tmp = s._head;
			while (tmp)
			{
				PushBack(tmp->_data);
				tmp = tmp->_next;
			}
		}
		return *this;
	}

	~List()//析构
	{
		if (_head)
		{
			Node* cur = _head;
			while (_head)
			{
				cur = _head;
				_head = _head->_next;
				delete cur;
			}
			_head = _tail = NULL;
		}
	}

	void PushBack(DataType x)//尾插
	{
		if (_head == NULL)
		{
			Node* cur = new Node(x);
			cur->_next = NULL;
			cur->_prev = NULL;
			_head = _tail = cur;
		}
		else
		{
			Node* cur = new Node(x);
			_tail->_next = cur;
			cur->_prev = _tail;
			_tail = cur;
		}
	}

	void PopBack()//尾删
	{
		if (_head == NULL)
		{
			return;
		}
		else if (_head->_next == NULL)
		{
			delete _head;
			_head = _tail = NULL;
		}
		else
		{
			Node* cur = _tail;
			_tail = _tail->_prev;
			_tail->_next = NULL;
			delete cur;
		}
	}

	void PushFront(DataType x)//头插
	{
		if (_head == NULL)
		{
			_head = _tail = new Node(x);
		}
		else
		{
			Node* cur = new Node(x);
			cur->_next = _head;
			_head->_prev = cur;
			_head = _head->_prev;
		}
	}

	void PopFront()//头删
	{
		if (_head == NULL)
		{
			return;
		}
		else if (_head->_next == NULL)
		{
			delete _head;
			_head = _tail = NULL;
		}
		else
		{
			Node* cur = _head;
			_head = _head->_next;
			delete cur;
			_head->_prev = NULL;
		}
	}

	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);
		if(pos->_prev == NULL)
		{
			PushFront(x);
		}
		else
		{
			Node* front = pos->_prev;
			Node* last = new Node(x);
			last->_prev = front;
			last->_next = pos;
			front->_next = last;
			pos->_prev = last;
		}
	}

	void Erase(Node* pos)//删除指定位置
	{
		assert(pos);
		if(pos->_prev == NULL)
		{
			PopFront();
		}
		else if (pos->_next == NULL)
		{
			PopBack();
		}
		else
		{
			Node* front = pos->_prev;
			Node* last = pos->_next;
			front->_next = last;
			last->_prev = front;
			delete pos;
		}
	}

	void Print()//打印函数
	{
		Node* cur = _head;
		while (cur)
		{
			cout << cur->_data << " ";
			cur = cur->_next;
		}
		cout << endl;
	}

private:
	Node* _head;
	Node* _tail;
};

void TestList()
{
	List s;
	s.PushBack(1);
	s.PushBack(2);
	s.PushBack(3);
	s.PushBack(4);
	s.Print();
	s.PopBack();
	s.Print();
	s.PushFront(0);
	s.Print();
	s.PopFront();
	s.Print();
	s.Insert(s.Find(1), 0);
	s.Print();
	s.Erase(s.Find(0));
	s.Print();
	List s1(s);
	s1.Print();
	List s2;
	s2 = s1;
	s2.Print();
	s2 = s2;
	s2.Print();
}
test.cpp 

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

#include "List.h"

int main()
{
	TestList();
	system("pause");
	return 0;
}

Eray_fan
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单链表的实现C++封装
J.Anson的博客
10-03 2173
数据结构之单链表，C语言给出算法，C++封装
单项链表的方法封装
qq_56607109的博客
08-23 296
我们先来认识一下, 链表中应该有哪些常见的操作。
用C++封装顺序表和双循环链表。
ymk1507050118的博客
08-31 314
今天我来用C++封装一下以前写过的顺序表以及双循环链表。 一。顺序表： #include&lt;iostream&gt; using namespace std; //定义一个内置类型int。 typedef int DataType; //写一个动态顺序表： class Myvector { public: //形参为空的构造函数 Myvector() :_array(new ...
C++模版类实现顺序表、单链表、双链表
10-28
压缩包内为线性表的工程包；工程内包括顺序表、单链表、双链表的类的定义与实现；附适当注释；完全面向对象，类封装；测试类中用（纯）虚函数实现多态。
单链表之C++封装
小米的修行之路
07-18 1149
前面的顺序表是用一组地址连续的存储单元来保存数据的，所以它具有随机存取的特点。即查找快速，但是做插入或删除动作是，需要移动大量元素，效率较低。 链表 链表是线性表的链式存储结构，它相比于顺序表，在插入和删除元素时，效率要高很多。 链表，是用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。 每个数据单元有两部分组成，一个是数据域，存储数据值；另一个是
new_infor.rar_双向链表_电话簿类C++
09-23
双向链表在电话簿类的实现中很有用，因为它提供了一种高效的方式来添加、删除和查找联系人，同时还能保持数据的有序性。 首先，让我们详细了解一下双向链表。双向链表中的每个节点都包含三个部分：数据、前向指针...
数据结构 合并有序链表 单链表 初学
最新发布
02-17
- 在C++或Java等面向对象的语言中，可以创建一个链表节点类来封装数据和指针。 为了更好地理解和掌握这一概念，可以动手实践编写代码，或者通过提供的“合并有序链表”压缩包文件进行学习。这些资源可能包含了示例...
线性表和链表的存储和增删改查c++
01-28
- **查找**：按值或位置查找元素，顺序表可以通过索引快速定位，链表则需遍历。 - **修改**：更改某个元素的值，找到该元素后直接更新数据域。 ### 5. C++实现线性表操作 C++中，可以创建一个模板类`List`来封装...
数据结构与算法:单向链表实现与封装
08-26
单向链表可以分为单向有头链表和单向无头链表，本文将针对单向有头链表进行实现。单向有头链表的特点是，每个节点都有一个指向下一个节点的指针，并且头节点不存储数据。 list_head.h文件中，我们定义了链表节点的...
C++实现顺序表和单链表
chuxinlgz的博客
07-27 504
顺序表：顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。 确定了起始位置，就可通过公式计算出表中任一元素的地址：LOC（ai）=LOC（a1）+（i-1）*L 　1≤i≤n （L是元素占用存储单元的长度） 顺序表的实现一般是实现连续开辟一段空间，然后在进行数据的增删查改（静态顺序表） 其代码实现如下： #include #in
C语言实现的单向链表和双向链表
01-16
slist.h为单向链表，blist为双向链表
单向链表的封装
03-24 168
#include<iostream>typedef int DataType;typedef int Status;typedef struct Node{ DataType data; struct Node *Next;}Node,*LinkList;#define TRUE 1#define FALSE 0#define OK 1#define E...
数据结构封装之《LinkList单向链表》
BeiJiaan的博客
08-28 1039
数据结构封装之《LinkList线性链表》 本人健忘，留作记录。
C++ 使用Json封装数据和解析数据
热门推荐
学会简单的博客
08-30 3万+
使用C++和别的语言做交互比较常用的一种数据操作方式就是json。可以到GitHub上下载对应C++的json库源码，我自己下了一套之前的版本，可以正常使用。jsoncpp-src 编译出来的库名：json_vc71_libmtd.lib(debug) | json_vc71_libmt.lib(release) 需要包含的头文件： jsoncpp-src(对应源码)/include/json (
C++实现顺序表和链表
zhangye3017的博客
04-22 421
更多C++知识：c++目录索引 顺序表： Vector.h #pragma once typedef int DataType; class Vector { public: Vector();//构造 Vector( const Vector&amp; v);//拷贝构造 Vector&amp; operator=(const Vector&amp; v...
【C++】——用类的形式封装动态顺序表
Paranoid_cc的博客
07-23 338
在前面已经用C语言实现过了 https://blog.csdn.net/Paranoid_cc/article/details/79773441 今天用另一种语言C++ 以类的形式来实现一下 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物...
C++实现封装链表
yang5915的专栏
05-15 1000
C++实现封装链表 #include #include using namespace std; template class node                          //节点 { public: T data;     node *next; }; template class list { public: list(
C++实现链表操作详解
在C++编程中，链表是一种非常重要的数据结构，它不同于数组，数组在声明时就固定了大小和顺序，而链表允许动态地添加和删除元素，且元素的位置可以灵活改变。链表的核心在于它的每一个元素，即结点（Node），每个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值