顺序表的基本操作

最新推荐文章于 2025-10-14 11:15:38 发布
原创 最新推荐文章于 2025-10-14 11:15:38 发布 · 5.8k 阅读 · 16 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

（1）输出顺序表中的所有元素；
（2）按序号查找指定元素，即输出顺序表中的第i个元素；
（3）按值查找指定元素，即输出顺序表中值为x的元素的序号；
（4）在指定位置插入元素，即在第i个元素前面插入值为x的元素；
（5）删除指定元素，即删除第i个元素；
（6）删除顺序表中所有值在[x,y]范围内的元素，要求时间复杂度达到O(n)；
（7）单值化操作，即删除表中重复元素中的多余元素，只保留其中序号最小的一个，例如，顺序表(2,4,4,3,2,4)单值化后的结果为(2,4,3)；
（8）简单划分操作，即将顺序表 (a1，a2，… ，an) 重新排列为以指定元素a1为界的两部分：a1前面的值均小于等于a1，a1后面的值均大于a1；
（9）采用直接插入法将顺序表排列为升序序列，参见教材P236对直接插入排序法基本操作步骤的讲解；
（10）销毁顺序表并退出。

/*
	要实现的操作
	（1）输出顺序表中的所有元素；
	（2）按序号查找指定元素，即输出顺序表中的第i个元素；
	（3）按值查找指定元素，即输出顺序表中值为x的元素的序号；
	（4）在指定位置插入元素，即在第i个元素前面插入值为x的元素；
	（5）删除指定元素，即删除第i个元素；
	（6）删除顺序表中所有值在[x,y]范围内的元素，要求时间复杂度达到O(n)；
	（7）单值化操作，即删除表中重复元素中的多余元素，只保留其中序号最小的一个，例如，顺序表(2,4,4,3,2,4)单值化后的结果为(2,4,3)；
	（8）简单划分操作，即将顺序表 (a1，a2，... ，an) 重新排列为以指定元素a1为界的两部分：a1前面的值均小于等于a1，a1后面的值均大于a1；
	（9）采用直接插入法将顺序表排列为升序序列，参见教材P236对直接插入排序法基本操作步骤的讲解；
	（10）销毁顺序表并退出。
*/

#include<iostream>
#include<vector>

using namespace std;

typedef int Status;
typedef int ElemType;
#define MAXSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
//定义线性表结构
typedef struct {
	ElemType* Link;
	int length;
}Sqlist;


Status Init(Sqlist& QL);
Status Create(Sqlist& QL, int length);

Status Display(const Sqlist& QL);
Status GetElem(const Sqlist& QL, ElemType& e, int index);
Status LocateElem(const Sqlist& QL, ElemType e, int& index);
Status Insert(Sqlist& QL, ElemType e, int index);
Status Delete(Sqlist& QL, int index);
Status DeleteAll(Sqlist& QL, ElemType value, ElemType value2);
Status Uniform(Sqlist& QL);
Status Division(Sqlist& QL, int index);
Status InsertSort(Sqlist& QL);
Status Destroy(Sqlist& QL);
Status GetLength(const Sqlist& QL, ElemType& e);
Status IsEmpty(const Sqlist& QL);
Status IsFull(const Sqlist& QL);

int main()
{
	int index, length;
	ElemType e;
	//创建顺序表并初始化
	Sqlist L;
	Init(L);
	cout << "请您输入线性表的长度";
	cin >> length;
	Create(L, length);
	cout << "----------------------------------------\n";
	int key = 1;
	while (key != 10)
	{
		
		cout << "欢迎使用线性表\n"
		     << "请您输入您要执行的操作\n"
			 << "1 输出顺序表中所有元素\n"
			 << "2 按序号查找指定元素，即输出顺序表的第i个元素\n"
			 << "3 按值查找指定元素，即输出顺序表中值为x的元素的序号\n"
			 << "4 在指定位置插入元素，即在第i个元素前面插入值为x的元素；\n"
			 << "5 删除指定元素，即删除第i个元素；\n"	
			 << "6 删除顺序表中所有值在[x,y]范围内的元素\n"
			 << "7 单值化操作,即删除表中重复元素中的多余元素，只保留其中序号最小的一个；\n"
			 << "8 简单划分操作，即将顺序表 (a1，a2，... ，an) 重新排列为以指定元素"
			 << "a1为界的两部分。a1前面的值均小于等于a1，a1后面的值均大于a1\n"
			 << "9 升序排序。\n"
			 << "10 销毁顺序表并退出。\n"
			 << "----------------------------------------\n";

		cin >> key;
		switch (key)
		{
		case 1:
			Display(L); 
			break;
		case 2:
			cout << "请您输入您想要取的元素下标__\b\b";
			cin >> index;
			if (GetElem(L, e, index)) {
				cout <<"第" << index <<"个元素为" <<e << endl;
			}
			break;
		case 3:
			cout << "请输入您想要查找的元素__\b\b";
			cin >> e;
			if (LocateElem(L, e, index)) {
				cout << "您查找的元素下标在:" << index << endl;
			}
			break;
		case 4:
			cout << "请您输入您要插入的位置和元素,以空格分割__\b\b";
			cin >> index >> e;
			Insert(L, e, index);
			cout << "在" << index << "位置插入" << e << "之后的结果\n";
			Display(L); 
			break;
		case 5:
			cout << "请您输入您要删除的位置__\b\b";
			cin >> index;
			Delete(L, index);
			cout << "在" << index << "位置删除元素之后的结果\n";
			Display(L);
			break;
		case 6:
			ElemType value1, value2;
			cout << "请您输入要删除的值范围[x,y],以空格分开";
			cin >> value1 >> value2;
			DeleteAll(L, value1, value2);
			cout << "删除" << value1 << "和" << value2 << "之间的值之后的结果\n";
			Display(L);
			break;
		case 7:
			Uniform(L);
			cout << "单值化之后的结果\n";
			Display(L);
			break;
		case 8:
			cout << "请您输入指定元素的下标";
			cin >> index;
			Division(L, index);
			cout << "以" << index << "为下标简单划分之后的结果\n";
			Display(L);
			break;
		case 9:
			InsertSort(L);
			cout << "升序排序之后的结果\n";
			Display(L);
			break;
		case 10:
			Destroy(L);
			cout << "Bye!\n"; break;
		default:
			cout << "请您输入正确的操作\n";
			break;
		}

		cout << "----------------------------------------\n";
	}
	return 0;
}


Status Init(Sqlist& QL)
{
	QL.Link = new ElemType[MAXSIZE];
	if (!QL.Link)
	{
		return OVERFLOW;
	}
	QL.length = 0;
	return OK;
}

Status Create(Sqlist& QL, int length)
{
	QL.length = length;
	if (QL.length > MAXSIZE)
	{
		cout << "溢出\n";
		QL.length = 0;
		return OVERFLOW;
	}

	if (QL.length < 0)
	{
		cout << "输入长度不可以为负数\n";
		QL.length = 0;
		return ERROR;
	}

	cout << "请输入顺序表内的元素";
	for (int i = 0; i < QL.length; i++)
	{
		cin >> QL.Link[i];
	}
	return OK;
}

Status IsEmpty(const Sqlist& QL)
{
	if (QL.length == 0)
	{
		cout << "顺序表为空\n";
		return true;
	}
	else
	{
		return false;
	}
}

Status IsFull(const Sqlist& QL)
{
	if (QL.length == MAXSIZE)
	{
		cout << "顺序表已满\n";
		return true;
	}
	else
	{
		return false;
	}
}

Status Display(const Sqlist& QL)
{
	if (IsEmpty(QL))
	{
		return ERROR;
	}

	for (int i = 0; i < QL.length; i++)
	{
		cout << QL.Link[i] << ' ';
	}
	cout << endl;
	return OK;
}

Status GetElem(const Sqlist& QL, ElemType& e, int index)
{

	if (index > QL.length)
	{
		cout << "超过顺序表长度\n";
		return ERROR;
	}

	if (index < 0)
	{
		cout << "下标不应该为负数\n";
		return ERROR;
	}

	//这里想要想要取得的元素是客户指出的，但是顺序表中的首个元素是从0开始
	e = QL.Link[index - 1];
	return OK;
}

Status LocateElem(const Sqlist& QL, ElemType e, int& index)
{
	if (IsEmpty(QL))
	{
		return ERROR;
	}

	for (int i = 0; i < QL.length; i++)
	{
		if (QL.Link[i] == e)
		{
			index = i + 1;
			return OK;
		}
	}

	cout << "未找到该元素\n";
	return ERROR;
}

Status Insert(Sqlist& QL, ElemType e, int index)
{
	if (IsFull(QL))
	{
		return ERROR;
	}

	if (index < 0 || index>QL.length + 1)
	{
		cout << "插入位置不合理\n";
		return ERROR;
	}
	QL.Link[QL.length] = 0;
	for (int k = QL.length; k >= index; k--)
	{
		QL.Link[k] = QL.Link[k - 1];
	}
	QL.Link[index - 1] = e;
	QL.length++;
	return OK;
}

Status Delete(Sqlist& QL, int index)
{
	if (IsEmpty(QL))
	{
		return ERROR;
	}

	if (index > QL.length || index <= 0)
	{
		cout << "删除位置不合理\n";
		return ERROR;
	}

	for (int k = index - 1; k < QL.length - 1; k++)
	{
		QL.Link[k] = QL.Link[k + 1];
	}
	QL.length--;
	return OK;
}

Status GetLength(const Sqlist& QL, ElemType& e)
{
	e = QL.length;
	return OK;
}

Status DeleteAll(Sqlist& QL, ElemType value1, ElemType value2)
{
	if (IsEmpty(QL))
	{
		return ERROR;
	}

	ElemType temp1 = min(value1, value2);
	ElemType temp2 = max(value1, value2);
	int len;
	int k = 0;
	GetLength(QL, len);
	for (int i = 0; i < len; i++)
	{
		QL.Link[i-k] = QL.Link[i];
		if (QL.Link[i] >= temp1 && QL.Link[i] <= temp2)
		{
			k++;
		}
	}
	QL.length -= k;
	return OK;
}

//将重复的元素只保留第一个元素
Status Uniform(Sqlist& QL)
{
	if (IsEmpty(QL))
	{
		return ERROR;
	}

	int len;
	GetLength(QL, len);

	vector<int> book(len);
	int i,j ,k = 0;
	for (i = 0; i < len; i++)
	{

		QL.Link[i - k] = QL.Link[i];
		for (j = 0; j < book.size(); j++)
		{
			if (QL.Link[i] == book[j])
			{
				k++;
				break;
			}
		}
		if (j == book.size())
		{
			book.push_back(QL.Link[i]);
		}
	}
	QL.length -= k;
	return OK;
}

//前小后大
Status Division(Sqlist& QL, int index)
{
	if (IsEmpty(QL))
	{
		return OK;
	}

	if (index > QL.length)
	{
		cout << "Index超过顺序表长度";
		return ERROR;
	}
	int i = 0, j = QL.length;
	int key = QL.Link[index - 1];
	while (i!=j)
	{
		while(QL.Link[i]<key&&i!=j)
		{
			i++;
		}

		if (i != j)
		{
			QL.Link[j] = QL.Link[i];
			j--;
		}

		while (QL.Link[j] > key && i != j)
		{
			j--;
		}

		if (i != j)
		{
			QL.Link[i] = QL.Link[j];
			i++;
		}
	}
	QL.Link[i] = key;
	return OK;
}

//升序排列
Status InsertSort(Sqlist& QL)
{
	if (IsEmpty(QL))
	{
		return ERROR;
	}

	for (int i = 1; i < QL.length; i++)
	{
		ElemType key = QL.Link[i];
		int j = i-1;
		while (QL.Link[j]>key&&j>=0)
		{
			QL.Link[j+1] = QL.Link[j];
			j--;
		}
		QL.Link[j+1] = key;
	}
	return OK;
}

Status Destroy(Sqlist& QL)
{
	delete[] QL.Link;
	QL.length = 0;
	return OK;
}
C语言-数据结构-可变长顺序表的初始化，插入和输出
w_nxsxs的博客
10-28 3034
问题描述: 实现可变长顺序表的建表过程。任务要求：通过顺序表的初始化、插入算法，实现顺序表的建表，并依次输出顺序表元素。 【输入形式】 第一行输入整数N(1<=N<=100)，表示创建长度为N的顺序表； 第二行输入N个整数，表示顺序表的N个元素，依次放入表中； 【输出形式】 依次输出顺序表的全部元素。(以空格分隔） 【样例输入】 5 1 2 3 4 5 【样例输出】 1 2 3 4 5 实现可变长顺序表要定义：初始的存储空间空间(INIT_SIZE)和空间再分配的增量大小
顺序表基本操作
04-14
顺序表基本操作 顺序表实现 顺序表
顺序表和链表（1）
最新发布
qq_62286331的博客
10-14 318
线性表是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串等线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
顺序表的基本操作（初始化，增，删，查，改等等）
weixin_74795859的博客
05-07 1131
千万不要写成ps->a[ps->sz-1]=0;但这个代码存在一定的问题，因为一直尾删ps->sz--如果一直--下去，它会出现越界，会出现ps->sz=-1的位置存放有效数据，相当于越界，当一直尾删到ps->sz==0的位置再减减ps->sz==-1，然后再进行尾插的时候就会出现越界，还有断言pos，因为在我们插入数据的时候，可能会超过size本身的容量就插入，比如有4个空间，别人在空间以外20的位置插入了30，就会发生越界行为，所以我们要断言一下0
精选资源
实验一：顺序表基本操作
03-03
实验一顺序表基本操作 实验一顺序表基本操作是大学生实验作业的一部分，旨在让学生掌握线性表中元素的前驱、后继的概念，以及顺序表的建立、插入元素、删除表中某元素的算法。在该实验中，学生需要完成并实现顺序表...
精选资源
数据结构上机_顺序表基本操作_数据结构基础_
09-29
在本课题中，我们将深入探讨"数据结构上机_顺序表基本操作_数据结构基础_"这一主题，这涉及到一系列在顺序表上的基本操作，包括初始化、输出、插入、删除、计算长度、逆置、排序以及合并有序顺序表等。 顺序表是一...
顺序表基本操作c++.zip
09-12
以上便是关于顺序表基本操作的详细知识介绍，它涵盖了顺序表的基础概念、C++实现方法、操作细节以及在实际应用和编程教育中的重要性。了解和掌握顺序表的基本操作对于一名程序员来说是非常重要的基础技能之一。通过...
实验一 顺序表基本操作的实现
12-18
在本实验“实验一 顺序表基本操作的实现”中，我们将深入探讨数据结构的核心概念——顺序表。数据结构是计算机科学中一个至关重要的领域，它研究如何有效地组织和存储数据，以便进行高效的检索、更新和删除等操作。...
顺序表中基本操作
weixin_30416497的博客
08-27 294
前言：最近玩esp8266和ucos-iii以及在学c++比较多,接触的大部分都是指针、结构体、链表；刚好自己又在看数据结构（数据结构真的非常重要，要好好学，是学算法的敲门砖，哈哈哈），个人看法在对顺序表进行元素增和删操作，效率比较低（要移动非常多的其他元素），而我之前写的对链表操作，使用指针操作，效率就高多了。好了，来看今天的学习总结吧！ 一、顺序表的初始化： 算法步骤： 1、为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

下坠丷

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值