线性表--顺序表

最新推荐文章于 2023-07-22 20:47:08 发布
最新推荐文章于 2023-07-22 20:47:08 发布
阅读量160 收藏
点赞数
分类专栏： 数据结构 文章标签： 顺序表 线性表 类模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/snypxk/article/details/87884865
版权

SequentialList.h

#include<iostream>
using namespace std;
const int MAXSIZE = 200;//线性表的最大长度

template <class DataType>
class SequentialList
{
public:
	SequentialList();//无参数构造函数
	SequentialList(DataType a[], int n);//有参数构造函数:用含n个元素的数组初始化线性表
	~SequentialList();//析构函数
	int GetLength();//获得线性表长度
	int GetLocationByValue(DataType x);//按元素的值查找返回元素位置【下标】
	bool IsEmpty();//判断线性表是否为空
	DataType GetValueByLocation(int i);//按位查找返回线性表的第i个元素
	DataType DeleteByLocation(int i);//删除线性表的第i个元素并返回删除的值
	DataType DeleteAtHead();//删除头部元素
	DataType DeleteAtTail();//删除尾部元素
	DataType GetMaxElement();//获得线性表的最大元素
	DataType GetMinElement();//获得线性表的最小元素
	DataType Josephus(SequentialList<DataType> seq, int m);//约瑟夫环问题：从第一个元素seq.data[0]开始报数，报到m的出局，返回最后一个出局的元素的值【不是对应的下标】
	void GetJosephusSequence(SequentialList<DataType> seq, int m);//获得约瑟夫环问题序列
	void Insert(int i, DataType x);//按位插入元素
	void InsertAtHead(DataType x);//在头部插入元素
	void InsertAtTail(DataType x);//在尾部插入元素
	void SetValueAtLocation_iBy_x(int i, DataType x);//设置位置i的元素的值为x
	void PrintSequentialList();//遍历线性表
	void ClearSequentialList();//清空线性表
	void ReverseSequentialList();//倒置【反转】线性表
	void LeftRotate_kBit_I(int k);//线性表循环左移k位   #时间复杂度【O(kn)】 #空间复杂度【O(1)】
	void SegmentationReverseSequentialList(int from, int to);//分段倒置线性表：倒置下标从from到to的元素
	void LeftRotate_kBit_II(int k);//线性表循环左移k位  #时间复杂度【O(3n)】 #空间复杂度【O(1)】
	void MergeIncrementally(SequentialList<DataType> A, SequentialList<DataType> B, SequentialList<DataType> &C);//递增合地并顺序表A和B并存储在C中
	void SequentialListByInsertSort();//线性表从小到大排序
private:
	int length;//线性表长度
	DataType data[MAXSIZE];//存入数据元素的数组
};

SequentialList.cpp

#include"SequentialList.h"

template<class DataType>
SequentialList<DataType>::SequentialList()
{
	length = 0;
}

template<class DataType>
SequentialList<DataType>::SequentialList(DataType a[], int n)
{
	if (n > MAXSIZE) {
		cout << "initial error!" << endl;
		return;
	}
	for (int i = 0; i < n; i++) {
		data[i] = a[i];
	}
	length = n;
}

template<class DataType>
SequentialList<DataType>::~SequentialList()
{

}

template<class DataType>
int SequentialList<DataType>::GetLength()
{
	return length;
}

template<class DataType>
int SequentialList<DataType>::GetLocationByValue(DataType x)
{
	if ( length==0 ) {
		cout << "get error!" << endl;
		return -1;
	}
	for (int i = 0; i < length; i++) {
		if (data[i] == x) return i + 1;
	}
	cout << "get error!" << endl;
	return -1;
}

template<class DataType>
bool SequentialList<DataType>::IsEmpty()
{
	if (length == 0)
		return true;
	else 
		return false;
}

template<class DataType>
DataType SequentialList<DataType>::GetValueByLocation(int i)
{
	if ((i > length) || i<1) {
		cout << "get error!" << endl;
		return -1;
	}
	return data[i-1];
}

template<class DataType>
DataType SequentialList<DataType>::DeleteByLocation(int i)
{
	if ((i > length) || i<1 || length==0) {
		cout << "delete error!" << endl;
		return -1;
	}
	int j = i - 1;
	DataType delete_value = data[j];
	for (;j<length-1; j++) {
		data[j] = data[j + 1];
	}
	length--;
	return delete_value;
}

template<class DataType>
DataType SequentialList<DataType>::DeleteAtHead()
{
	if (length==0) {
		cout << "delete error!" << endl;
		return -1;
	}
	DataType delete_value = data[0];
	for (int j=0; j<length - 1; j++) {
		data[j] = data[j + 1];
	}
	length--;
	return delete_value;
}

template<class DataType>
DataType SequentialList<DataType>::DeleteAtTail()
{
	if (length == 0) {
		cout << "delete error!" << endl;
		return -1;
	}
	length--;
	return data[length+1];
}

template<class DataType>
DataType SequentialList<DataType>::GetMaxElement()
{
	if (length == 0) {
		cout << "get error!" << endl;
		return -1;
	}
	DataType max = data[0];
	for (int i = 1; i < length; i++) {
		if (data[i] > max)max = data[i];
	}
	return max;
}

template<class DataType>
DataType SequentialList<DataType>::GetMinElement()
{
	if (length == 0) {
		cout << "get error!" << endl;
		return -1;
	}
	DataType min = data[0];
	for (int i = 1; i < length; i++) {
		if (data[i] < min)min = data[i];
	}
	return min;
}

template<class DataType>
DataType SequentialList<DataType>::Josephus(SequentialList<DataType> seq, int m)
{
	int i;
	DataType *array = new DataType[seq.length];
	for (i = 0; i < seq.length; i++) {//复制data到array，这样可以不破坏原始数据
		array[i] = seq.data[i];
	}
	int start = 0;//start为每次报数的起始点
	for (i = seq.length; i >= 2; i--) {
		start = (start + m - 1) % i;//采用取模运算使报数从表尾回到表头
		for (int j = start + 1; j < i; j++) {
			array[j - 1] = array[j];
		}
	}
	DataType temp = array[0];
	delete[] array;
	return temp;
}

template<class DataType>
void SequentialList<DataType>::GetJosephusSequence(SequentialList<DataType> seq, int m)
{
	int i;
	DataType *array = new DataType[seq.length];
	for (i = 0; i < seq.length; i++) {//复制data到array，这样可以不破坏原始数据
		array[i] = seq.data[i];
	}
	int start = 0;//start为每次报数的起始点
	for (i = seq.length; i >= 2; i--) {
		start = (start + m - 1) % i;//采用取模运算使报数从表尾回到表头
		cout << array[start] << " ";
		for (int j = start + 1; j < i; j++) {
			array[j - 1] = array[j];
		}
	}
	cout << array[0] << endl;
	delete[] array;
}

template<class DataType>
void SequentialList<DataType>::Insert(int i, DataType x)
{
	if ((length + 1 > MAXSIZE) || i<1 || i>length+1) {
		cout << "insert error!"<<endl;
		return;
	}
	for (int j = length; j >= i; j--) {
		data[j] = data[j - 1];
		}
		data[i - 1] = x;
	length++;
}

template<class DataType>
void SequentialList<DataType>::InsertAtHead(DataType x)
{
	if (length + 1 > MAXSIZE){
		cout << "insert error!" << endl;
		return;
	}
	for (int j = length; j > 0; j--) {
		data[j] = data[j - 1];
	}
	data[0] = x;
	length++;
}

template<class DataType>
void SequentialList<DataType>::InsertAtTail(DataType x)
{
	if (length + 1 > MAXSIZE) {
		cout << "insert error!" << endl;
		return;
	}
	data[length] = x;
	length++;
}

template<class DataType>
void SequentialList<DataType>::SetValueAtLocation_iBy_x(int i, DataType x)
{
	if (i<1 || i>length) {
		cout << "set value error!" << endl;
		return;
	}
	data[i - 1] = x;

}

template<class DataType>
void SequentialList<DataType>::PrintSequentialList()
{
	if (length == 0) {
		cout << "print error!" << endl;
		return;
	}
	for (int i = 0; i < length; i++) {
		cout << data[i]<<" ";
	}
	cout << endl;
}

template<class DataType>
void SequentialList<DataType>::ClearSequentialList()
{
	length = 0;
}

template<class DataType>
void SequentialList<DataType>::ReverseSequentialList()
{
	if (length == 0) {
		cout << "reverse error!" << endl;
		return;
	}
	DataType temp;
	for (int i = 0; i < length/2; i++) {
		temp = data[i];
		data[i] = data[length - i - 1];
		data[length - i - 1] = temp;
	}
}

template<class DataType>
void SequentialList<DataType>::LeftRotate_kBit_I(int k)
{
	if (length == 0) {
		cout << "LeftRotate error!" << endl;
		return;
	}
	DataType temp;
	for (int i = 0; i < k; i++) {
		temp = data[0];
		for (int j = 0; j < length - 1; j++) {
			data[j] = data[j + 1];
		}
		data[length - 1] = temp;
	}
}

template<class DataType>
void SequentialList<DataType>::SegmentationReverseSequentialList(int from, int to)
{
	if (length == 0 || from<0 || to>length-1) {
		cout << "LeftRotate error!" << endl;
		return;
	}
	DataType temp;
	for (int i = 0; i <= (to - from) / 2; i++) {
		temp = data[from + i];
		data[from + i] = data[to - i];
		data[to - i] = temp;
	}
}

template<class DataType>
void SequentialList<DataType>::LeftRotate_kBit_II(int k)
{
	if (length == 0) {
		cout << "reverse error!" << endl;
		return;
	}
	SegmentationReverseSequentialList(0, k - 1);//前(0-k)个元素倒置
	SegmentationReverseSequentialList(k, length - 1);//后(n-k)个元素倒置
	SegmentationReverseSequentialList(0, length - 1);//(0-n)个元素全部倒置
}

template<class DataType>
void SequentialList<DataType>::MergeIncrementally(SequentialList<DataType> A, SequentialList<DataType> B, SequentialList<DataType>& C)
{
	int i = 0;
	int j = 0;
	int k = 0;
	int tempA, tempB;
	A.SequentialListByInsertSort();
	B.SequentialListByInsertSort();
	while (i < A.length && j < B.length) {
		tempA = A.GetValueByLocation(i + 1);
		tempB = B.GetValueByLocation(j + 1);
		if (tempA == tempB) {
			C.data[k++] = tempA;
			i++; 
			j++;
		}
		else if (tempA < tempB) {
			C.data[k++] = tempA;
			i++;
		}
		else {
			C.data[k++] = tempB;
			j++;
		}
	}
	while (i < A.length) {
		tempA = A.GetValueByLocation(i + 1);
		C.data[k++] = tempA;
		i++;
	}
	while (j < B.length) {
		tempB = B.GetValueByLocation(j + 1);
		C.data[k++] = tempB;
		j++;
	}
	C.SetLength(k);
}

template<class DataType>
void SequentialList<DataType>::SequentialListByInsertSort()
{
	if (length == 0) {
		cout << "reverse error!" << endl;
		return;
	}
	//选用插入排序
	DataType temp;
	for (int i = 1; i < length; i++) {
		for (int j = i; j > 0 && data[j] < data[j - 1]; j--) {
			temp = data[j];
			data[j] = data[j - 1];
			data[j - 1] = temp;
		}
	}
}

SequentialListtTest.cpp

#include"SequentialList.cpp"

void main()
{
	int a[17] = { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 };
	SequentialList<int> Test1(a, 17);
	cout << "           打印线性表：";
	Test1.PrintSequentialList();
	cout << "     获得线性表的长度：" << Test1.GetLength() << endl;

	cout << "获得值为5的元素的位置：" << Test1.GetLocationByValue(5) << endl;

	cout << "   删除位置为10的元素：" << Test1.DeleteByLocation(10) << endl;
	cout << "         删除头部元素：" << Test1.DeleteAtHead() << endl;
	cout << "         删除尾部元素：" << Test1.DeleteAtTail() << endl;

	cout << "           打印线性表：";
	Test1.PrintSequentialList();
	cout << "     获得线性表的长度：" << Test1.GetLength() << endl;

	cout << "    位置为4的元素的值：" << Test1.GetValueByLocation(4) << endl;

	cout << "    在位置7插入元素33: " << endl;
	Test1.Insert(7, 33);
	cout << "     在头部插入元素23: " << endl;
	Test1.InsertAtHead(23);
	cout << "     在尾部插入元素43: " << endl;
	Test1.InsertAtTail(43);

	cout << "           打印线性表：";
	Test1.PrintSequentialList();
	cout << "     获得线性表的长度：" << Test1.GetLength() << endl;

	cout << " 置位置6的元素的值为7：" << endl;
	Test1.SetValueAtLocation_iBy_x(6,7);

	cout << "           打印线性表：";
	Test1.PrintSequentialList();
	cout << "     获得线性表的长度：" << Test1.GetLength() << endl;

	cout << "   倒置【反转】线性表：" << endl;
	Test1.ReverseSequentialList();

	cout << "           打印线性表：";
	Test1.PrintSequentialList();
	cout << "     获得线性表的长度：" << Test1.GetLength() << endl;

	cout << "    方法一循环左移4位：" << endl;
	Test1.LeftRotate_kBit_I(4);

	cout << "           打印线性表：";
	Test1.PrintSequentialList();
	cout << "     获得线性表的长度：" << Test1.GetLength() << endl;

	cout << "    方法二循环左移4位：" << endl;
	Test1.LeftRotate_kBit_II(4);

	cout << "           打印线性表：";
	Test1.PrintSequentialList();
	cout << "     获得线性表的长度：" << Test1.GetLength() << endl;

	cout << "   获得线性表的最大值：" << Test1.GetMaxElement() << endl;
	cout << "   获得线性表的最小值：" << Test1.GetMinElement() << endl;

	cout << "   线性表从小到大排序：" << endl;
	Test1.SequentialListByInsertSort();

	cout << "           打印线性表：";
	Test1.PrintSequentialList();
	cout << "     获得线性表的长度：" << Test1.GetLength() << endl;

	cout << "   判断线性表是否为空：" << Test1.IsEmpty() << endl;

	cout << "           清空线性表：" << endl;
	Test1.ClearSequentialList();

	cout << "   判断线性表是否为空：" << Test1.IsEmpty() << endl;

	cout << "           打印线性表：";
	Test1.PrintSequentialList();
	cout << "     获得线性表的长度：" << Test1.GetLength() << endl;
}

在这里插入图片描述

snypxk
关注
专栏目录
【项目5 线性表-- 顺序表存储应用】分离元素<之一>
Sailor_luo的博客
09-17 809
*问题描述:设顺序表有10个元素，其元素类型为整型。 设计一个算法，以第一个元素为分界线，将所有小于它的元素移到该元素的前面， 将所有大于它的元素移到该元素的后面
数据结构线性表的应用实现数据的倒序显示，实现两个数组的合并，从小到大排序
qq_51279057的博客
04-19 625
案例：实现数据的倒序显示，如数据{30,56，74,87,23,90}显示为{90,23,87,74,56,30} 实现两个数组的合并。要求数据从小到大排序。 A:{23,45,46,67,89} B:{12,56,87,99} 合并以后为：{12,23,45,46,56,67,87,89,99}。（笔记2.0） Seqlist类 public class SeqList extends LinearList<Integer> { protected Integer[] data; //
Java实现头插和尾插的单链表
qq_62745502的博客
07-22 386
Java实现头插和尾插的单链表
6-2 顺序表操作集（20 point(s)）
热门推荐
codeswarrior的博客
11-02 2万+
6-2 顺序表操作集（20 point(s)） 本题要求实现顺序表的操作集。 函数接口定义： List MakeEmpty(); Position Find( List L, ElementType X ); bool Insert( List L, ElementType X, Position P ); bool Delete( List L, Position P );
链表排序
guoyong的专栏
05-24 742
链表的排序(转) ==========================  功能：选择排序(由小到大)  返回：指向链表表头的指针 ========================== */ /*  选择排序的基本思想就是反复从还未排好序的那些节点中，  选出键值（就是用它排序的字段，我们取学号num为键值）最小的节 点，  依次重新组合成一个链表。  我认为写链表这类程序，
数据结构线性表--顺序表
11-17
使用软件为dev c++，使用c语言，用计算机类书籍《数据结构》中介绍的线性表中的顺序存储结构，建立了一个学生年龄表，可以实现基本的 插入 查找 删除 遍历，各个功能函数写有注释，方便阅读。
线性表--顺序表操作
12-12
在本主题中，我们将深入探讨线性表的两种主要实现方式：顺序表和链式存储。 **顺序表**是一种将线性表中的元素连续存储在内存中的数据结构。这种存储方式使得访问元素变得非常高效，因为元素的位置可以通过其索引...
2.C-数据结构-线性表-顺序表源码
最新发布
08-30
2.C-数据结构-线性表-顺序表源码
算法-理论基础- 线性表- 顺序表（包含源程序）.rar
09-16
这个压缩包“算法-理论基础- 线性表- 顺序表（包含源程序）.rar”包含了关于线性表特别是顺序表的理论知识和实际源代码，是学习数据结构与算法的重要资源。 线性表的顺序存储结构，也称为顺序表，是最简单也是最...
一些东华自命题考研算法题
yichudu
11-19 5018
1.试编写算法，对一棵以孩子-兄弟链表表示的一般树统计其叶子的个数。   2.试编写算法，将单链表L1拆成两个链表，其中以L1为头的链表保持原来向后的链接，另一个链表的头为L2，其链表方向与L1相反， L1包含原链表的奇数序号的节点，L2包含原链表的偶数序号的节点。
线性表排序
weixin_41030848的博客
08-03 4392
void sort(SeList l)//冒泡排序法 {//从小到大排 int i,j; ElemType temp; for(i=0; i &lt; l.length - 1; i++) for(j=0;j &lt; l.length - i - 1; j++) { if(l.data[j] &gt; l.data[j + 1])//数组 { ...
6-2有序顺序表的插入（函数题）
qq_43839907的博客
11-26 2084
本题要求实现递增顺序表的有序插入函数。L是一个递增的有序顺序表，函数Status ListInsert_SortedSq(SqList &L, ElemType e)用于向顺序表中按递增的顺序插入一个数据。 比如：原数据有：2 5，要插入一个元素3，那么插入后顺序表为2 3 5。 要考虑扩容的问题。 函数接口定义： Status ListInsert_SortedSq(SqList &am...
PTA 数据结构 6-2 顺序表基本操作
sensen426521的博客
10-14 3603
6-2 顺序表基本操作（10 分）本题要求实现顺序表元素的增、删、查找以及顺序表输出共4个基本操作函数。L是一个顺序表，函数Status ListInsert_Sq(SqList &L, int pos, ElemType e)是在顺序表的pos位置插入一个元素e（pos应该从1开始），函数Status ListDelete_Sq(SqList &L, int pos, ElemType &e)是
线性表的选择排序
stulcc的博客
09-14 1861
选择排序；直接选择排序和堆排序
对顺序表中元素从小到大排序的算法
DX奥特曼的博客
12-29 1万+
）编写一个对顺序表中元素从小到大排序的算法，函数接口如下： //初始条件：线性表L已经存在，且元素个数大于1 //操作结果：将L中的元素从小到大排序 Status ListSort_Sq(SqList &L); 然后，在main函数中调用ListSort_Sq函数，对之前创建的顺序表进行排序。 实现两个有序顺序表的合并操作。然后在主函数中再创建一个顺序表实例，输入5个元素，并
线性表（一）
夜阑听风
03-16 295
为了学习好数据结构，准备把书上的算法都亲自敲一遍，每天都要敲一些，是对自己的承诺吧。1：已知一个线性表，其中的元素递增有序排列，设计一个算法，插入一个元素x(int型)；保证该顺序表依然递增有序排列，这里，假设每次都能够插入成功：解答：线性表分为两种，数组和链表；这道题，其实就是插入排序的一部分逻辑。package linetable; public class InsertElement { ...
PTA 6-2顺序表操作集
qq_25175067的博客
03-13 5249
这道题题目很简单，但是我一直写错了一个判断条件： 我把判断出界条件的if(P &gt; L-&gt;Last+1 || P&lt;0) 一直写错成if(P &gt; MAXISIZE || P&lt;0) 比较对照之后才能发现自己的问题吧，本来觉得也可以自己一步步调试的，但是实在是懒，不过这种错误还是很好发现的，希望自己以后在顺序表上不会犯这种低级错误。 6-2 ...
数据结构的线性表-顺序表插入、删除、查找实现功能
04-17
线性表是一种常见的数据结构，顺序表是线性表的一种实现方式。顺序表使用数组来存储数据，具有随机访问的特点。下面是顺序表的插入、删除和查找的实现功能： 1. 插入操作： - 在指定位置插入元素：首先判断插入位置是否合法，即在数组范围内；然后将插入位置后的元素依次后移一位；最后将要插入的元素放入指定位置。 - 在末尾插入元素：直接将元素放入数组的最后一个位置。 2. 删除操作： - 删除指定位置的元素：首先判断删除位置是否合法；然后将删除位置后的元素依次前移一位；最后将数组最后一个位置置空。 - 删除指定值的元素：遍历数组，找到第一个与指定值相等的元素，然后将该元素后面的元素依次前移一位；最后将数组最后一个位置置空。 3. 查找操作： - 按索引查找：直接通过索引访问数组中的元素。 - 按值查找：遍历数组，找到第一个与指定值相等的元素。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值