数据结构-顺序表与单链表的C++模板类实现

最新推荐文章于 2021-08-05 21:15:08 发布
最新推荐文章于 2021-08-05 21:15:08 发布
阅读量761 收藏 8
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 线性表 顺序表 单链表 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Alan_1550587588/article/details/70002324
版权

C++模板类实现顺序表

实现功能: 

1.尾插，2.头插，3.显示，4.尾删，5.头删，6.按位置，7.插按值插，8.按位置删，9.按值删，10.按值查，11.求表长，12.清除数据，13.摧毁该顺序表，14.反转，15.冒泡排序。

顺序表模板类实现代码:

//顺序表***************************************************************

#include <iostream>

using namespace std;

const int INIT_SIZE = 100;
template<class Type>
class SeqList
{
public:
	SeqList(size_t sz = INIT_SIZE);             //构造长度为len的顺序表
	int Length(){ return length; }              //求顺序表长度
	Type Get(int i);                            //按位查找
	void push_back(const Type &x);              //尾插  
	void push_front(const Type &x);             //头插  
	void show_list();                           //显示  
	void pop_back();                            //尾删  
	void pop_front();                           //头删  
	void insert_pos(int pos, const Type &x);    //按位置插  
	void insert_val(const Type &x);             //按值插  
	void delete_pos(int pos);                   //按位置删  
	void delete_val(const Type &x);             //按值删  
	int  find(const Type &key);                 //按值查  
	int  length()const;                         //求表长  
	void clear();                               //清除数据  
	void destroy();                             //摧毁该顺序表  
	void reserv();                              //反转  
	void sort(/*int low,int high*/);            //排序  
	bool isfull()const{return size >= capacity;}//判断顺序表是否满
	bool isempty()const{ return size == 0; }    //判断顺序表是否空

private:
	Type *base;
	size_t capacity;
	size_t size;
};
template<class Type>//构造长度为len的顺序表
SeqList<Type>::SeqList(size_t sz)
{
	capacity = sz > INIT_SIZE  ? sz : INIT_SIZE ;
	base = new Type[capacity];
	size = 0;
}
template<class Type>//尾插
void SeqList<Type>::push_back(const Type &value_X)
{
	if (isfull())
	{
		cout << "顺序表已满,不能尾插!" << endl;
		return;
	}
	base[size++] = value_X;
}
template<class Type>//头插
void SeqList<Type>::push_front(const Type &value_X)
{
	if (isfull())
	{
		cout << "顺序表已满,不能头插!" << endl;
		return;
	}
	for (int i = size; i > 0; --i)
		base[i] = base[i - 1];
	base[0] = value_X;
	size++;
}
template<class Type>
void SeqList<Type>::show_list()//显示
{
	for (int i = 0; i< size; ++i)
		cout << base[i] << " ";
	cout << endl;
}
template<class Type>
void SeqList<Type>::pop_back()//尾删
{
	if (isempty())
	{
		cout << "顺序表已满" << endl;
		return;
	}
	size = size - 1;
}
template<class Type>
void SeqList<Type>::pop_front()//头删  
{
	int i;
	for (i = 0; i< size - 1; i++)
	{
		base[i] = base[i + 1];
	}
	size--;
}
template<class Type>
void SeqList<Type>::insert_pos(int pos, const Type &x)//按位置插 
{
	if (pos < 0 || pos > size)
	{
		cout << "要插入的位置非法!" << endl;
		return;
	}
	if (isfull())
	{
		cout << "顺序表已满,不能插入!" << endl;
		return;
	}

	for (int i = size; i > pos; --i)
		base[i] = base[i - 1];
	base[pos] = x;
	size++;
}
template<class Type>
int SeqList<Type>::find(const Type &key) //按值查 
{
	for (int i = 0; i<size; ++i)
		if (base[i] == key)
			return i;
	return -1;
}
template<class Type>
void SeqList<Type>::insert_val(const Type &x)//按值插
{
	int pos;
	pos = find(x);
	insert_pos(pos, x);
}

template<class Type>
void SeqList<Type>::delete_pos(int pos)//按位置删
{
	
	for (int i = pos; i<size - 1; ++i)
	{
		base[i] = base[i + 1];
	}
	size--;
}
template<class Type>
void SeqList<Type>::delete_val(const Type &x)//按值删 
{
	int pos = find(x);
	if (pos == -1)
	{
		return;
	}

	for (int i = pos; i<size; ++i)
	{
		base[i] = base[i + 1];
	}
	size--;
}
template<class Type>
int SeqList<Type>::length()const//求表长
{
	cout << "表长是:" << size << endl;
	return size;
}

template<class Type>
void SeqList<Type>::clear()//清除数据 
{
	while (size)
		base[size--] = 0;
}
template<class Type>
void SeqList<Type>::destroy()//摧毁该顺序表 
{
	int i;
	delete base;
	base = 0;
	capacity = 0;
	size = 0;
}

template<class Type>
void SeqList<Type>::reserv()//反转
{
	int m = size - 1;
	for (int i = 0; i <= ((size - 1) / 2); ++i)
	{
		int tmp = base[i];
		base[i] = base[m];
		base[m] = tmp;
		m--;
	}
}
template<class Type>
void SeqList<Type>::sort()//冒泡排序  
{
	for (int i = 0; i <= size; i++)
	for (int j = i + 1; j <= size - 1; j++)
	{
		if (base[i]>base[j])
		{
			int tmp = base[j];
			base[j] = base[i];
			base[i] = tmp;
		}
	}
}
//主函数
int main()
{
	SeqList<int> mylist;


	int select = 1;
	int Item;
	int pos;
	while (select)
	{
		cout << "数据结构--顺序表**********************" << endl;
		cout << "**************************************" << endl;
		cout << "* [1] push_back       [2] push_front *" << endl;
		cout << "* [3] show_list       [0] quit_system*" << endl;
		cout << "* [4] pop_back        [5] pop_front  *" << endl;
		cout << "* [6] insert_pos      [7] insert_val *" << endl;
		cout << "* [8] delete_pos      [9] delete_val *" << endl;
		cout << "* [10] find           [11]length     *" << endl;
		cout << "* [12] clear          [13]destroy    *" << endl;
		cout << "* [14] reserv         [15]sort       *" << endl;
		cout << "**************************************" << endl;
		cout << "请选择:>";
		cin >> select;
		switch (select)
		{
		case 1:
			cout << "请输入要插入的值(-1结束):>";
			while (cin >> Item, Item != -1)
			{
				mylist.push_back(Item);
			}
			break;
		case 2:
			cout << "请输入要插入的值(-1结束):>";
			while (cin >> Item, Item != -1)
			{
				mylist.push_front(Item);
			}
			break;
		case 3:
			mylist.show_list();
			break;
		case 4:
			mylist.pop_back();
			break;
		case 5:
			mylist.pop_front();
			break;
		case 6:
			cout << "请输入要插入的位置:>";
			cin >> pos;
			cout << "请输入要插入的值:>";
			cin >> Item;
			mylist.insert_pos(pos, Item);
			break;
		case 7:
			cout << "请输入要插入的值:>";
			cin >> Item;
			mylist.insert_val(Item);
		case 8:
			cout << "请输入要删除的位置:>";
			cin >> pos;
			mylist.delete_pos(pos);
			break;
		case 9:
			cout << "请输入要删除的值:>";
			cin >> Item;
			mylist.delete_val(Item);
			break;
		case 10:
			cout << "请输入要查找的值:>";
			cin >> Item;
			int pos;
			pos = mylist.find(Item);
			break;
		case 11:
			mylist.length();
			break;
		case 12:
			mylist.clear();
			break;
		case 13:
			mylist.destroy();
			break;
		case 14:
			mylist.reserv();
			break;
		case 15:
			mylist.sort();
			break;
		default:
			break;
		}
	}

	return 0;
}
单链表模板类实现代码: 
//单链表********************************************************
#include <iostream>

using namespace std;
//线性表抽象类的定义**
template <class dataType>  
class list
{
public:        
	virtual void empty() = 0;   //清空线性表       
	virtual int  getLength()=0;   //求表的长度        
	virtual void insert(int i,const dataType& x)=0;   //在表中第i个位置插入值为x的元素       
	virtual void remove(int i)=0; //删除表中第i个位置的元素        
	virtual int search(const dataType& x)=0;  //查找并返回值为x的元素在表中的位置       
	virtual dataType visit(int i)=0;  //访问表中第i个元素的值       
	virtual void traverse()=0;    //遍历线性表 
}; 

template <class dataType>  
class linkList :public list<dataType>       //公有继承自list类     
{                                           
public:          
	linkList();                             //构造函数，创建对象时生成空链表         
	void empty();                           //清空链表          
	int getLength();                        //求表的长度          
	void insert(int i,const dataType& x);   //在表中第i个位置插入值为x的元素         
	void remove(int i);                     //删除表中第i个位置的元素          
	int search(const dataType& x);          //查找并返回值为x的元素在表中的位置         
	dataType visit(int i);                  //访问表中第i个元素的值         
	void traverse();                        //将表中的元素逐一输出         
	~linkList();                            //析构函数     
private:                                    //定义节点         
	struct node
	{             
		dataType data;            
		node* next;              
		node():next(0){};             
		node(dataType d):data(d),next(0){}; 
	};            
	node* head;                             //链表头         
	node* tail;                             //链表尾          
	int currentLength;                      //链表长度 
}; 

template <class dataType> 
linkList<dataType>::linkList()
{ 
	head = new node;     
	tail = new node;     
	head->next = tail;     
	currentLength = 0;        
	cout << "\nCreate list success!\n"; 
}   
template <class dataType>  
void linkList<dataType>::empty()
{
	if (currentLength == 0)
	{
		cout << "\nThe list is empty!\n";
		return;
	}
	node* nowPos = head->next;    
	while (nowPos != tail)
	{ 
		node* tmp = nowPos;        
		nowPos = nowPos->next;        
		delete tmp; 
	}     
	head->next = tail;    
	currentLength = 0;      
	cout << "\nEmpty list success!\n"; }   

template <class dataType>  
int linkList<dataType>::getLength()
{ 
	return currentLength; 
}    
template <class dataType>  
void linkList<dataType>::insert(int i, const dataType& x)
{
	if (i<0 || i>currentLength)
	{ 
		cout << "\nThe index is out of range!\n";         
		return; 
	}       
	node* add = new node(x);     
	if (i == 0)
	{ 
		add->next = head->next;        
		head->next = add;
	}
	else
	{          
		//找到第i-1个节点         
		node* nowPos=head->next;         
		while(--i)
		{             
			nowPos=nowPos->next;   
		}          
		add->next=nowPos->next;        
		nowPos->next=add;  
	}      ++currentLength;      
	cout<<"\nInsert data success!\n";
}   
template <class dataType>
void linkList<dataType>::remove(int i)
{   
	if(i<0||i>=currentLength)
	{        
		cout<<"\nThe index is out of range!\n";     
		return;    
	}     
	if(i==0)
	{        
		node* tmp=head->next->next;        
		delete head->next;        
		head->next=tmp;    
	}      
	else
	{          
		//找到第i-1个节点   
		node* nowPos=head->next;  
		while(--i)
		{           
			nowPos=nowPos->next;    
		} 
		node* tmp = nowPos->next->next;  
		delete nowPos->next;        
		nowPos->next = tmp;
	}   
	--currentLength;        
	cout << "\nDelete data success!\n";
}  
template <class dataType>
int linkList<dataType>::search(const dataType& x)
{
	node* nowPos = head;    
	int i;     
	for (i = 0; i<currentLength; ++i)
	{
		nowPos = nowPos->next;  
		if (nowPos->data == x)
			break; 
	}      
	if (i == currentLength)
		return -1;    
	return i; 
}  
template <class dataType> 
dataType linkList<dataType>::visit(int i)
{     
	//下标越界抛出异常值0     
	if(i<0||i>=currentLength)
	{
		cout << " 越界" << endl;
		return 0;
		throw 0;     
	}       
	//找到第i个节点     
	node* nowPos=head->next;   
	while(i--)
	{         
		nowPos=nowPos->next;  
	}      
	return nowPos->data;
}  
template <class dataType> 
void linkList<dataType>::traverse()
{    
	if(currentLength==0)
	{          
		cout<<"\nThe list is empty!\n";     
		return;    
	}
	node* nowPos = head->next;     
	cout << nowPos->data;   
	nowPos = nowPos->next;    
	while (nowPos != tail)
	{
		cout << " " << nowPos->data; 
		nowPos = nowPos->next;
	}     
	cout << endl;
}   
template <class dataType> 
linkList<dataType>::~linkList()
{ 
	empty();   
	delete head;  
	delete tail; 
}


//主函数
int main()
{
	
	linkList<int> mylist;

	int select = 1;
	int Item;
	int pos;
	while (select)
	{
		cout << "数据结构--单链表************" << endl;
		cout << "****************************" << endl;
		cout << "* [1] 按位访问             *" << endl;
		cout << "* [2] 遍历打印             *" << endl;
		cout << "* [3] 按位插入             *" << endl;
		cout << "* [4] 按位删除             *" << endl;
		cout << "* [5] 按值查找             *" << endl;
		cout << "* [6] 单链表长度           *" << endl;
		cout << "* [7] 释放单链表内存       *" << endl;
		cout << "* [8] 清空单链表           *" << endl;
		cout << "****************************" << endl;
		cout << "请选择:>";
		cin >> select;
		switch (select)
		{
		case 1:
			cout << "请输入要访问的位置(-1结束):>";
			while (cin >> Item, Item != -1)
			{
			cout<<	mylist.visit(Item)<<endl;
			}
			break;
		case 2:
			mylist.traverse();
			break;
		case 3:
			cout << "请输入要插入的位置:>";
			cin >> pos;
			cout << "请输入要插入的值:>";
			cin >> Item;
			mylist.insert(pos, Item);
			break;
		case 4:
			cout << "请输入要删除的位置:>";
			cin >> pos;
			mylist.remove(pos);
			break;
		case 5:
			cout << "请输入要查找的值:>";
			cin >> Item;
			cout << mylist.search(Item) << endl;
			break;
		case 6:
		cout<<"单链表长度:"<<	mylist.getLength()<<endl;
			break;
		case 7:
			mylist.~linkList();
			cout << "单链表内存已释放" << endl;
			break;
		case 8:
			mylist.empty();
			cout << "单链表已清空"<<endl;
			break;
		default:
			break;
		}
	}
	return 0;
}

参考博客：

http://www.bubuko.com/infodetail-825525.html

http://3y.uu456.com/bp_8mpdu2v9r83gznb0fxez_1.html

Alan_147
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++模板类实现顺序表
心之所向，一如既往
02-26 345
#define _CRT_SECURE_NO_WARNINGS #include using namespace std; #include #define length 10 typedef int DataType; class Vector { public: // 构造函数 explicit Vector(size_t capacity = 100) //若不给
C++模版类实现顺序表、单链表、双链表
10-28
压缩包内为线性表的工程包；工程内包括顺序表、单链表、双链表的类的定义与实现；附适当注释；完全面向对象，类封装；测试类中用（纯）虚函数实现多态。
查找元素（线性表实训）
韶言大雅
04-28 2972
在线性表中查找特定元素是线性表的常用操作之一。要求补全函数search，实现在一个链表中搜索包含指定数据的结点。如果链表中有多个结点包含该数据，则返回第一个。 相关知识 由于链表结点都是动态内存分配得到的，在内存中不是连续存储，没法使用二分法之类的算法来实现信息检索，但可以使用顺序查找的方法。 顺序查找需要遍历整个链表，逐个检查每个结点是否满足条件。程序中的printList函数已实现了遍历功能，...
C++中顺序线性表的基本功能实现
qq_45674520的博客
12-01 773
编写线性表定义及基本操作函数 例如：建立具有5个元素的顺序表。 　L=(a,b,c,d,f) 　 并完成如下操作： (1)输出线性表 (2)求线性表L的长度 (3)获取第3个元素的值 (4)获取元素 a 在线性表中的位置 (5)在第4个元素前，插入元素g (6)删除第5个元素的值 #include <malloc.h> #include <stdio.h> #define MaxSize 50 using namespace std; typedef char ElemType; 定
顺序链表C语言实现
zcg_741454897的博客
11-04 3327
顺序链表没什么说的啦，直接上代码，参考了传智播客出版的数据结构。创建工程的时候不小心弄成c++了，不过没关系，都一样。 Operation中有一处语法上的疑惑，就是插入的那个函数中，node为什么要强制转换成整型，既然等式两边都是指针，为什么不是转化成int* ，有心人帮忙解答一下，谢谢。 SeqList.h头文件 #ifndef _SEQLIST_H_ #define _SEQLIST_...
算法与数据结构(一)：线性表（C++实现）
qq_41918762的博客
10-19 858
文章目录算法与数据结构(一)：线性表（C++实现）头文件定义线性表类的成员变量和成员函数头文件类成员函数的实现主函数参考：算法分析与设计(C++描述) 石志国、刘冀伟、姚亦飞编著 算法与数据结构(一)：线性表（C++实现） 在计算机内存中存放线性表的最简单和最常用的方式使用一组地址上连续的存储单元依次存储线性表的每一个元素。使线性表中相邻的元素存放在地址中相邻的物理存储单元中，这种存储结构称作顺序...
ShiYan1_单链表_C++_顺序表_数据结构_
09-29
（3）在顺序表类模板中增加成员函数max()和min()，它们分别返回顺序表中元素值最大的数据元素序号。 2．单链表的验证 （1）定义一个结构体，描述学生信息。学生信息包括：学号、姓名、性别、班级和电话号码等。用...
数据结构（顺序表和单链表）C++实现
04-20
本话题主要探讨了两种基本的数据结构——顺序表和单链表，并提供了C++的实现。下面将详细阐述这两种数据结构及其C++实现的关键概念。 1. **顺序表（Sequential List）** 顺序表是一种线性数据结构，其中元素在内存...
数据结构与算法 c++实现 //删除顺序递增表中的重复元素 //对单链表实现就地逆置 //删除递增单链表中的重复元素
06-04
本篇文章将深入探讨在C++中实现数据结构，特别是顺序表和单链表的操作，以及如何处理它们的重复元素和逆序问题。 1. **顺序表**：顺序表是一种简单的数据结构，它的元素存储在一块连续的内存空间中，通过数组的形式...
数据结构各种算法实现(C++模板)1
最新发布
08-08
这些C++模板为理解和实现数据结构提供了基础框架，学习者可以通过阅读和修改这些代码来深入理解数据结构的工作原理。在实际编程中，选择合适的数据结构对解决复杂问题至关重要，例如在处理大量动态变化的数据时，...
数据结构-----顺序表与单链表的实现
bobopeng
10-16 1054
1.顺序表 //////////////////////////////////////////////////////////// // // 实现顺序表的初始化，插入，删除，查找，逆置，合并等操作 // //////////////////////////////////////////////////////////// ////////////// #include #incl
数据结构图文解析之：数组、单链表、双链表介绍及C++模板实现
weixin_33713707的博客
02-01 402
0. 数据结构图文解析系列 数据结构系列文章 数据结构图文解析之：数组、单链表、双链表介绍及C++模板实现 数据结构图文解析之：栈的简介及C++模板实现 数据结构图文解析之：队列详解与C++模板实现 数据结构图文解析之：树的简介及二叉排序树C++模板实现. 数据结构图文解析之：AVL树详解及C++模板实现 数据结构图文解析之：二叉堆详解及C++模板实现 1....
C++ 线性表之顺序表的构建
qq_29762941的博客
07-22 2087
(一)该顺序表下标从一开始，具有增删查等操作 实现如下: #include&lt;iostream&gt; using namespace std; const int maxSize = 100; class sqlist{ public: sqlist():length(0){} int LocateElem(int x);//查找元素位置 int insert(int ...
c++实现双向链表，类模板双向链表
热门推荐
hugang的博客
09-06 1万+
c++实现双向链表的思想和c很类似，不同的是c++是将实现的函数放在类中，这样就可以由类实例化出对象再调用类中的函数进行添加、删除、查找、插入元素等功能。类模板实现双向链表在最后进行说明和实现，方法依然类似。 c++实现双向链表 #include #include using namespace std; typedef int Datatype; typedef
分别基于顺序表和链表实现栈
Josvin
04-26 204
栈 一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 基于顺序表实现 package src.bit0414.Test; /** * @ Created with IntelliJ IDEA. * @ClassName MyStack * ...
C++实现顺序表（数组和链表）
weixin_40417029的博客
04-21 1694
    在C++中，引入了类的概念，要用类来实现顺序表，一定要注意代码的复用，这样会使实现更加容易。数组实现顺序表：        定义三个指针，_first指向数组开始位置，_finish指向最后一个元素的下一个位置，_endofstorage指向数组末尾的下一个位置。如图所示，假设数组中有元素1234567：构造函数：让三个指针指向空；typedef int DataType; class ...
C++模板实现链表,顺序表
宇哲
08-29 1110
Seqlist.h#define _CRT_SECURE_NO_WARNINGS 1#include<iostream> #include<string> #include<cassert>using namespace std;template<typename T> class SeqList { public: SeqList(); ~SeqList(); SeqLis
数据结构与算法_【2】线性表（顺序表链表）（C++实现）
gXh的博客
08-05 1524
参考：数据结构与算法基础（青岛大学-王卓） 线性表 线性表是具有相同特性的数据元素的一个有限序列 抽象数据类型线性表定义： ADT List{ Data:线性表的数据对象集合为{a1,a2,...an}，每个元素的类型均为DataType。数据元素之间的关系是一对一关系。 Operation： InitList(*L);//初始化操作，建立一个空的线性表L ListEmpty(L);//若线性表为空，返回True，否则返回False ClearList(*L);//将线性表清空 GetElem(L,i,
C++实现顺序表->单链表->双向链表
Quinn0918的博客
07-20 1350
C++实现顺序表Seqlist.h#pragma once typedef int DataType; #include<assert.h> class Seqlist { public: Seqlist()//构造函数 :_data(NULL) , _size(0) , _capa(0) { } ~Seqlist()//
数据结构与算法实验指导书.doc
05-06
数据结构与算法实验指导书.doc

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值