《数据结构与算法》——线性表之顺序表（SqList）总结

最新推荐文章于 2024-02-27 13:23:49 发布
最新推荐文章于 2024-02-27 13:23:49 发布
阅读量1.8w 收藏 80
点赞数 16
分类专栏： 数据结构与算法 文章标签： 数据结构与算法 顺序表 考研
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kwzc4/article/details/96594791
版权

《数据结构与算法》——线性表之顺序表（SqList）总结

 

从前天开始着手复习线性表部分，整了3个下午才用C++对顺序表的部分内容进行了成功实现，下面就简单进行以下总结。

目录

《数据结构与算法》——线性表之顺序表总结

定义

class SqList

方法实现

错误

难点

参考文献

定义

线性表：具有线性存储结构的抽象数据类型，它是由n个数据元素组成的有限序列。其中数据元素可以是很多种，int、string、char甚至是自定义类型。

课本上还有个定义是说其他几个名词的关系：若干数据项组成了一条记录（数据元素），含有大量记录的线性表被称为文件。

在书上对抽象数据类型的线性表定义如下图：

 

 

线性表分为顺序表和链表，在本文中将对线性表中的顺序表以C++语言的方式，构建SqList类，并对其类方法进行实现。

 

class SqList

 

class SqList {
	private:
		T *data=NULL;//设置成动态的 
		int len,Max;
		int step;
	public:
		SqList(int Max , T t );//{//构造函数, int step = 50 
		void InitList(int Max , T t);//初始化 
		int length();
		int LocateElem(T elem);//按值查找
		T GetElem(int i); //按位查找
		void ListtInsert(int i ,T elem);
		void ListDelete(T elem);//删除元素
		void PrintList(); 
		bool Empty();
		void DestroyList();
		void MergeList(SqList lb);//合并两个表，有序 
		~ SqList();//析构函数 
};

 

方法实现

 

/*编译环境：
win10专业版
DEV C++ 5.11
TDM-GCC 4.9.2 64bit
*/

#include<iostream>
#include<stdlib.h> 
using namespace std;
#define STEP 50
#define OVERFLOW 0

template <typename T >
class SqList {
	private:
		T *data=NULL;//设置成动态的 
		int len,Max;
		int step;
	public:
		SqList(int Max , T t );//{//构造函数, int step = 50 
		void InitList(int Max , T t);//初始化 
		int length();
		int LocateElem(T elem);//按值查找
		T GetElem(int i); //按位查找
		void ListtInsert(int i ,T elem);
		void ListDelete(T elem);//删除元素
		void PrintList(); 
		bool Empty();
		void DestroyList();
		void MergeList(SqList lb);//合并两个表，有序 
		~ SqList();//析构函数 
};

template <typename T > SqList<T>::SqList(int Max , T t){//构造函数, int step = 50
	/*
	* 初始化最大容量，元素类型&错误标记，步长 
	*/
	T *tt = (T*)malloc(sizeof(T)*Max);
	if(!tt){
		cout<<"空间分配失败"<<endl; 
		exit(OVERFLOW);//空间分配失败 
	}
	this->data	= tt;
	this->data[0] = t;
	this->Max  =  Max;
	this->len  =  0;
	this->step =  STEP;
}

template <typename T> void SqList<T>::InitList(int Max , T t){//初始化 
	SqList(Max , t);
}

template <typename T>
int  SqList<T>::length(){//返回顺序表长度 
	return len;
}

template <typename T>
int  SqList<T>::LocateElem(T elem){//按值查找
	int i = 0;
	for( ; i<=this->len && data[i]!= elem;i++);
	if( i <= this->len)
		return i;
	return 0;//无此值 
		 
}

template <typename T>
T    SqList<T>::GetElem(int i){ //按位查找
	if(i<=this->len && i>0 )
		return data[i];
	return data[0]; 
}

template <typename T>
void SqList<T>::ListtInsert(int i ,T elem){//按位插值 
	if (i==0||i>=this->len+2)
		return ;
	if(this->len >= this->Max) {//重新分配内存块 
  		T * Temp = (T *) realloc(this->data, sizeof(T)*(this->Max + this->step));
  		if (Temp == NULL)// {
  			exit(OVERFLOW);//<<"The memory relloced failed!"<<endl; 
		//}
    	this->data = Temp;
		this->Max = this->Max + this->step;
	}
	
	this->len ++;//长度增加 
	int j = this->len ;
	for( ; j>i ;j--){
		this->data[j] = this->data[j-1];
	}
	this->data[j] = elem;
} 

template <typename T>
void SqList<T>::ListDelete(T elem){//删除元素
	int i=0;
	while(i<len && this->data[++i]!=elem);
	if(i==len&&this->data[i]!=elem)
		return ; 
	else{
		while(i<len){
			this->data[i] = this->data[i+1];
			i++;
		}
		this->len--;
	}
}

template <typename T>
void SqList<T>::PrintList(){//输出顺序表 
	cout<<"[";
	if(len==0)
		cout<<" ";
	else{
		for(int i = 1 ; i < len ;i++){
			cout<<this->data[i]<<" ";
		}
		cout<<this->data[len];
	}
	cout<<"]"<<endl;
}

template <typename T>
bool SqList<T>::Empty(){//判空 
	if(this->len==0)
		return 1;
	else 
		return 0; 
}

template <typename T>
void SqList<T>::DestroyList(){//销毁顺序表 
	len=0;
	free(this->data); 
	this->data = NULL;
}

template <typename T>
void SqList<T>::MergeList(SqList<T> lb){//合并两个顺序表
	/*
	*分为两种情况，有序和无序，无序直接合并，有序则按序合并 
	*/
	int i=0,j=0;
	bool flag = 1; 
	while(((++i)<this->len) && (this->data[i] <= this->data[i+1]) );//判断当前字符串是否有序 
	if((i <= this->len) && (this->data[this->len] < this->data[this->len-1]) )//无序 
		flag = 0 ;
	else{
		while(((++j) < lb.len) && (lb.data[j] <= lb.data[j+1]) );//判断合并字符串是否有序 
		if((j == lb.len)  && (lb.data[j] >= lb.data[j-1]) )//有序 
			flag = 1 ;//有序
		else
			flag = 0 ; //无序 
	}
	if(flag){//有序

		T * Temp = (T *) malloc(sizeof(T)*(this->Max));
		int len = this->len,j=1,k=1,l=1;
		if (!Temp)
  			exit(OVERFLOW);
  		while(j<=len)//辅助数组 
		  Temp[j]= this->data[j++];
		
		if(this->Max < this->len + lb.len ){//空间不足 //对A扩充空间 
			T *tem = (T*) realloc(this->data, sizeof(T)*(this->Max + lb.Max));
		if (!tem)
  			//exit(OVERFLOW);
  		this->data = tem ;
  		flag=0; 
		}
		else
			flag = 1;
		//比较大小合并 
		j = 1;
		while(j<=len && k<=lb.len)
			if(Temp[j] <= lb.data[k])
				this->data[l++] = Temp[j++];
			else
				this->data[l++] = lb.data[k++];
		while(j<=len) this->data[l++] = Temp[j++];
		while(k<=lb.len) this->data[l++] = lb.data[k++];
	}
	else{//无序
		T * Temp = (T*) realloc(this->data, sizeof(T)*(this->Max + lb.Max));
		lb.PrintList(); 
		if (!Temp)
  			exit(OVERFLOW);
    	this->data = Temp;
    	j=1;
    	while(j<=lb.len){
    		this->data[len+j] = lb.data[j++];
		}
	}	
	this->Max = flag?this->Max :this->Max + lb.Max;
	this->len = this->len + lb.len;
} 

template <typename T>
SqList<T>::~SqList(){//析构 
	len=0;
	free(this->data); 
	this->data = NULL;
}







int main() {
	
	SqList<int> l(50,-1);
	cout<<"初始化："; l.PrintList();
	l.ListtInsert(1,6);
	cout<<"在第1位插入6：";l.PrintList();
	l.ListtInsert(2,8);
	cout<<"在第2位插入8：";l.PrintList();
	l.ListtInsert(2,7);
	cout<<"在第2位插入7：";l.PrintList();
	l.ListtInsert(4,9);l.ListtInsert(1,5);
	l.ListtInsert(1,4);l.ListtInsert(1,3);
	l.ListtInsert(1,2);l.ListtInsert(1,1);
	cout<<"在插入很多数据后：";l.PrintList();
	cout<<"当前表长度为："<<l.length()<<endl; 
	l.ListDelete(4);
	cout<<"删除元素4："; l.PrintList();
	cout<<"查询第6个元素是："<<l.GetElem(6)<<endl;
	cout<<"查询元素6的位置为："<<l.LocateElem(6)<<endl;

	//新建一个顺序表
	SqList<int> l2(50,-1);
	l2.ListtInsert(1,6);l2.ListtInsert(1,5);l2.ListtInsert(1,4);
	l2.ListtInsert(1,3);l2.ListtInsert(1,2);l2.ListtInsert(1,1);
	cout<<"l2有序初始化："; l2.PrintList();
	l.MergeList(l2);
	cout<<"l与l2合并结果："; l.PrintList();

	//新建一个顺序表
	SqList<int> l3(50,-1);
	l3.ListtInsert(1,9);l3.ListtInsert(1,8);l3.ListtInsert(1,5);
	l3.ListtInsert(1,7);l3.ListtInsert(1,4);l3.ListtInsert(1,2);
	cout<<"l3无序初始化："; l3.PrintList();
	l.MergeList(l3);
	cout<<"l与l3合并结果："; l.PrintList();
	l3.DestroyList();
	cout<<"销毁l3："; l3.PrintList();
	return 0;
}

 

错误

在代码实现的过程中，采用了模板类+外联函数的方式，主要是为了达到C++和数据结构同时复习的目的。但在过程中以下代码总是报错：

template <typename T , int step=50 >
class SqList {
	private:
		T *data=NULL;//设置成动态的 
		int len,Max;
		int step;
	public:
		SqList(int Max , T t );//{//构造函数, int step = 50 
		......

};
template <typename T,int step = 50  > SqList<T>::SqList(int Max , T t){//构造函数, int step = 50
	T *tt = (T*)malloc(sizeof(T)*Max);
	if(!tt){
		cout<<"空间分配失败"<<endl; 
		exit(OVERFLOW);//空间分配失败 
	}
	this->data	= tt;
	this->data[0] = t;
	this->Max  =  Max;
	this->len  =  0;
	this->step =  step;
}
//错误：
/* [Error] invalid use of incomplete type 'class SqList<T>'
*[Error] declaration of 'class SqList<T>'
*原因？ 
*/

将其改为内联函数错误便消失，但是就想用外联函数，找原因也不知个所以然，所以就将其中的默认参数给删掉了，解决了问题。如下：

 

template <typename T >
class SqList {
	private:
		T *data=NULL;//设置成动态的 
		int len,Max;
		int step;
	public:
		SqList(int Max , T t );//{//构造函数, int step = 50 
		......

};

template <typename T> SqList<T>::SqList(int Max , T t){//构造函数, int step = 50
	T *tt = (T*)malloc(sizeof(T)*Max);
	if(!tt){
		cout<<"空间分配失败"<<endl; 
		exit(OVERFLOW);//空间分配失败 
	}
	this->data	= tt;
	this->data[0] = t;
	this->Max  =  Max;
	this->len  =  0;
	this->step =  STEP;//宏定义STEP
}

 

难点

对于“数据结构”这一部分学习的难点，我认为一是对实际问题进行抽象化处理，二是对数据结构实现时的不熟练，这部分应归结于语言和编程能力的不足。

参考文献

严蔚敏，吴伟民. 数据结构（C语言版）[M]. 北京： 清华大学出版社，2013.

 

如有错误，还请朋友不吝指正。

Kwzc4
关注
  • 16
    点赞
  • 踩
  • 80
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构SqList （c语言实现代码）
05-21
数据结构SqList （c语言实现代码）
数据结构---顺序线性表（SqList C++）
06-24
顺序线性表（Sequential List，简称 SqList）是一种常见的数据结构，它按照元素的顺序存储数据，通常在内存中连续分配空间。在本项目中，我们使用 C++ 实现了一个基于顺序线性表的数据结构，并且支持从文本文件读取...
Sqlist
weixin_52653118的博客
09-19 234
顺序表**
sqlist
热门推荐
hyl52101314的博客
11-22 1万+
当你没有弄明白一些基本的东西而纠结一些稍微高级点的用法的时候,你会越纠结越迷茫的. 如果对SqList L不明白的话, 那么int L,int &L, int *L这几个能说一下区别吗? 关于&是引用运算符的说法是C++中的概念,  在C中,&就只有两种用法:  逻辑与和取地址. 这两种用法的区别是一眼就能看出来的(对于刻意写的那种让人看不明白的代码没有讨论的价值, 正常人不会写那种代
数据结构-顺序表（SqList）
qq_54429049的博客
10-22 8630
数据结构-顺序表的设计与实现
C语言中的SqList 含义
最新发布
2301_79629384的博客
02-27 2407
在C语言中，"SqList" 通常是指线性表（List）的顺序存储结构，其中 "Sq" 是 "Sequential" 的缩写。线性表是一种数据结构，它是一组按照顺序排列的元素的集合，其中每个元素都有唯一的前驱和后继。通常，SqList 的操作包括插入、删除、查找等，通过数组下标可以直接访问元素，这使得在顺序存储结构中进行一些基本的操作变得相对简单。是线性表中元素的类型，可以是整数、字符、结构体等。数组用于存储线性表的元素，而。通过这样的定义，可以使用数组。存储线性表中的元素，而。记录当前线性表的长度。
SQList
qq_44834369的博客
04-10 1692
线性表的顺序实现/动态数组(C语言实现) /** * 线性表的顺序实现 * 逻辑关系上相邻的两个元素物理上也相邻 * 优点在于可以随机存取 * 缺点在于插入或删除元素需要移动大量的元素 */ /*导入必要的头文件*/ #include "stdlib.h" //malloc, realloc #include "stdio.h" //printf, scanf /*通用的定义*/ #define TR
c语言sqlist头文件,C语言实现顺序表的基本操作
weixin_36459547的博客
05-23 2541
数据结构C语言实现顺序表的基本操作2009-09-19 11:42:39| 分类： C语言实现数据结 |字号 订阅头文件Sqlist1.h#include#include#include#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW 0#define LIST_INIT_SIZE 10//线性表存储...
数据结构算法代码实现——线性表的顺序表示与实现（二） 定义线性表节点的结构.pdf
04-18
数据结构算法代码实现——线性表的顺序表示与实现（二）定义线性表节点的结构 本资源主要介绍了数据结构中线性表的顺序表示和实现，包括线性表的定义、顺序存储结构、基本操作等内容。 线性表的定义 线性表是一种...
算法与数据结构实验一（1）顺序表
06-29
此外，为了优化性能，可以考虑使用更高效的数据结构或算法，例如在合并有序顺序表时，如果表长度很大，可以使用归并排序的合并操作，这将减少元素比较的次数。对于重新排列顺序表，这个简单的方法已经满足了题目要求...
【数据结构】线性表顺序表（全）测试代码用C语言C++实现动态及静态顺序表的定义、插入、删除 定义线性表节点的结构.pdf
04-18
数据结构与算法 - 线性表顺序表（全）测试代码用C语言C++实现动态及静态顺序表的定义、插入、删除 数据结构是计算机科学中的一种基本概念，线性表是数据结构中的一种基本类型。线性表是指由零个或多个数据元素组成...
数据结构——线性表分享.pdf
01-01
数据结构——线性表分享 一、顺序存储结构 在数据结构中，顺序存储结构是一种常用的存储方式，它将线性表的每个元素存储在一块连续的存储空间中。这种存储方式的优点是可以快速访问任意一个元素，但缺点是插入或...
线性表---顺序表
qq_49788160的博客
05-05 98
init(self, capacity)：初始化一个容量为capacity的空列表。len(self)：返回列表的长度。getitem(self, index)：获取列表中索引为index的元素。setitem(self, index, value)：将列表中索引为index的元素设置为value。str(self)：返回列表的字符串表示。append(self, value)：将value添加到列表的末尾。
【数据结构——顺序表】
qq_61719813的博客
04-26 582
文章目录1. 线性表2.1 线性表的定义2.2 线性表的抽象数据类型3.1 顺序表1. 顺序表的结构代码2. 初始化3. 输出顺序表元素4. 插入5. 删除6.定位7. 查找8. 清空列表9. 运行截图完整代码 1. 线性表 2.1 线性表的定义 线性表（List）：零个或多个数据元素的有限序列。 2.2 线性表的抽象数据类型 ADT 线性表(List) Data 线性表的数据对象集合为{a1,a2,……,an},每个元素的类型均为DataType。其中，除第一个元素a1外，每一个元素有且只有一个直接前
Go数据结构之顺序表(SqList)
weixin_33854644的博客
04-26 195
顺序表－SqList 顺序表是在计算机内存中以数组的形式保存的，是一组地址连续的存储单元依次存储的结构，特点：查询是常数时间，添加和删除是线性时间O(n)。 以下是我用Go语言实现的顺序表，其实里面还是用Go自身的Slice存储，程序还是相对简单： /** * Created with IntelliJ IDEA. * Date: 4/24/14 *...
SQLite使用报告
weixin_30920853的博客
01-28 594
一、 SQLite简介 SQLite是遵守ACID的关联式数据库管理系统，它包含在一个相对小的C库中。它是D.RichardHipp建立的公有领域项目。 不像常见的客户-服务器范例，SQLite引擎不是个程序与之通信的独立进程，而是连接到程序中成为它的一个主要部分。所以主要的通信协议是在编程语言内的直接API调用。这在消耗总量、延迟时间和整体简单性上有积极的作用。整个数...
SqList *L 和 SqList * &L的一些理解以及多重指针的简单应用
weixin_44374545的博客
08-18 5103
SqList *L 和 SqList * &L 关于 SqList *L 和 SqList * &L 的理解 复习数据结构（李春葆 c++版本）时看到了 SqList * &L 当时好像没弄明白今天花点时间理顺下： typedef struct { Elemtype data[MaxSize]； int length; }SqList; // void CreateList(SqList * &L,ElemType a[ ],int n) { int i;
sqlist顺序表
Amily_K的专栏
07-13 2073
#include "sqList.h" /**********函数实现*******/ Status InitList(SqList &L) {//初始化顺序表 L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType)); if(!L.elem) exit(OVERFLOW); L.length=0; L.lists
实现线性表的顺序查找算法
05-31
顺序查找算法，也称为线性查找算法，是一种简单直观的查找算法。它的基本思想是从线性表的一端开始，逐个对比查找元素，直到找到目标元素或搜索到线性表的末尾为止。 下面是实现线性表的顺序查找算法的示例代码： ```c #include <stdio.h> #define MAXSIZE 100 // 定义线性表最大长度 // 定义线性表结构体 typedef struct { int data[MAXSIZE]; // 存储数据元素 int length; // 线性表长度 } SqList; // 线性表顺序查找算法 int Search_Seq(SqList L, int key) { int i; for (i = 0; i < L.length; i++) { if (L.data[i] == key) { return i; // 查找成功，返回元素下标 } } return -1; // 查找失败，返回-1 } int main() { SqList L = {{1, 3, 5, 7, 9}, 5}; // 初始化线性表 int key = 5; // 要查找的元素值 int result = Search_Seq(L, key); // 进行顺序查找 if (result == -1) { printf("查找失败！\n"); } else { printf("元素%d的位置为%d\n", key, result); } return 0; } ``` 在上面的示例代码中，我们先定义了一个结构体 `SqList` 用来表示线性表，其中包括一个数组 `data` 用来存储数据元素，和一个变量 `length` 表示线性表长度。然后定义了一个函数 `Search_Seq` 用来进行线性表的顺序查找，该函数接收两个参数：线性表 `L` 和要查找的元素值 `key`，返回值为目标元素在线性表中的下标，如果查找失败则返回-1。最后在 `main` 函数中初始化了一个线性表 `L`，并进行了一次元素为5的顺序查找。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值