顺序表的基本操作-----------------实验一

最新推荐文章于 2023-08-20 22:59:32 发布
最新推荐文章于 2023-08-20 22:59:32 发布
阅读量1.6k 收藏 15
点赞数 2
分类专栏： 顺序表 文章标签： c++ 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mqvv520/article/details/124912434
版权

顺序表的要求：

编写算法实现下列问题的求解。

  1. 在第i个结点位置插入值为x的结点。

实验测试数据基本要求：1 2 3 4 5 6 7 8 9 10

第一组数据：顺序表长度n≥10，x=100,  i分别为5,n,n+1,0,1,n+2

第二组数据：顺序表长度n=0，x=100，i=5

  1. 删除顺序表中第i个元素结点。

实验测试数据基本要求：

第一组数据：顺序表长度n≥10，i分别为5,n,1,n+1,0

第二组数据：顺序表长度n=0， i=5

  1. 在一个递增有序的顺序表L中插入一个值为x的元素，并保持其递增有序特性。

实验测试数据基本要求：10 20 30 40 50 60 70 80 90 100

顺序表元素为 （10,20,30,40,50,60,70,80,90,100）,

x分别为25，85，110和8

  1. 将顺序表Ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），分别放入新的顺序表中，然后原表和新表元素同时输出到屏幕上，以便对照求解结果。

实验测试数据基本要求：

第一组数据：顺序表元素为 （1 2 3 4 5 6 7 8 9 10 20 30 40 50 60）

第二组数据：顺序表元素为 （10 20 30 40 50 60 70 80 90 100）

  1. 求两个递增有序顺序表L1和L2中的公共元素，放入新的顺序表L3中。

实验测试数据基本要求：

第一组

第一个顺序表元素为 （1 3 6 10 15 16 17 18 19 20）

第二个顺序表元素为 （1 2 3 4 5 6 7 8 9 10 18 20 30）

第二组

第一个顺序表元素为 （1 3 6 10 15 16 17 18 19 20）

第二个顺序表元素为 （2 4 5 7 8 9 12 22）

第三组

第一个顺序表元素为 （）

第二个顺序表元素为 （1，2，3，4，5，6，7，8，9，10）

  1. 删除递增有序顺序表中的重复元素，并统计移动元素次数，要求时间性能最好。

实验测试数据基本要求：

第一组数据：顺序表元素为 （1 2 3 4 5 6 7 8 9）

第二组数据：顺序表元素为 （1 1 2 2 2 3 4 5 5 5 6 6 7 7 8 8 9）

第三组数据：顺序表元素为 （1 2 3 4 5 5 6 7 8 8 9 9 9 9 9）

 算法实现部分;

#include<iostream>
#pragma once
using namespace std;
#define MAXLEN 100
typedef int elementType;
typedef struct sList
{
	elementType data[MAXLEN];//定义储存表中的元素数组
	int listLen;//定义表的长度
}seqList;


//函数声明
void create(seqList* L);//创建链表
void initList(seqList* L);//链表初始化
void print(seqList* L);//遍历顺序表，并输出
void menoprint();//菜单输出
int listInsert(seqList* L, int i, elementType x);//1.在第i个结点前插入值为x的结点
int listDelete(seqList* L, int i);//2.删除顺序表中第i个元素结点。
void OrderlistInsert(seqList* L, int x);//3.在一个递增有序的顺序表L中插入一个值为x的元素，并保持其递增有序特性
void  listseparate(seqList* L1, seqList* L2, seqList* L3);//4.将顺序表Ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），分别放入新的顺序表中，然后原表和新表元素同时输出到屏幕上，以便对照求解结果。
void listcommon(seqList* L, seqList* L1, seqList* L2); //5.求两个递增有序顺序表L1和L2中的公共元素，放入新的顺序表L3中。
void listdeleteReapt(seqList* L);//6.删除递增有序顺序表中的重复元素，并统计移动元素次数


//函数实现
//创建链表
void create(seqList* L)
{
	int i = 0;
	cin >> i;
	while (i != -1)
	{
		L->data[L->listLen] = i;
		L->listLen++;
		cin >> i;
	}
}

//链表初始化
void initList(seqList* L)
{
	L->listLen = 0;
}

//遍历链表，并输出
void print(seqList* L)
{
	int i;
	for (i = 0; i < L->listLen; i++)
	{
		cout << L->data[i] << " ";
	}
	cout << endl;
}


//菜单输出
void menoprint()
{
	cout << "******************************************************************************************************" << endl;
	cout << "**		输入0或-1退出程序                                                                   **" << endl;
	cout << "**		输入1创建链表                                                                       **" << endl;
	cout << "**		输入2初始化链表                                                                     **" << endl;
	cout << "**		输入3遍历并显示链表                                                                 **" << endl;
	cout << "**		输入4插入元素                                                                       **" << endl;
	cout << "**		输入5删除第i个位置元素                                                              **" << endl;
	cout << "**		输入6在一个递增有序的顺序表L中插入一个值为x的元素，并保持其递增有序特性。           **" << endl;
	cout << "**		输入7将顺序表Ｌ中的奇数项和偶数项结点分解开                                         **" << endl;
	cout << "**		输入8求两个递增有序顺序表L1和L2中的公共元素，放入新的顺序表L3中                     **" << endl;
	cout << "**		输入9删除递增有序顺序表中的重复元素，并统计移动元素次数                             **" << endl;
	cout << "******************************************************************************************************" << endl;
}

//1.在第i个结点前插入值为x的结点。
int listInsert(seqList* L,int i,elementType x)
{
	int j;
	if (i == MAXLEN)
	{
		cout << "链表已满" << endl;
		return 0;
	}
		
	else if (i<1 || i>L->listLen + 1)
	{
		cout << "输入的插入位置不正确" << endl;
		return 1;
	}
		
	else
	{
		for (j = L->listLen - 1; j >= i - 1; j--)
		{
			L->data[j + 1] = L->data[j];
		}
		L->data[i - 1] = x;
		L->listLen++;
		return 2;
	}
}

//2.删除顺序表中第i个元素结点。
int listDelete(seqList* L, int i)
{
	int j;
	if (L->listLen <= 0)
	{
		cout << "输入的位置不正确" << endl;
		return 0;

	}
		
	else if (i > L->listLen || i <= 0)
	{
		cout << "输入的位置不正确" << endl;
		return 1;
	}
	else
	{
		for (j = i; j <= L->listLen - 1; j++)
		{
			L->data[j-1] = L->data[j];
		}
		L->listLen--;
		return 2;
	}
}


//3.在一个递增有序的顺序表L中插入一个值为x的元素，并保持其递增有序特性。
void OrderlistInsert(seqList* L, int x)
{
	int i =0;
	if (L->listLen == MAXLEN)
		cout << "链表已满" << endl;
	while (L->data[i] <= x)
	{
		if (i == L->listLen)
		{
			break;
		}
		else
		{
			i++;
		}
	}
	listInsert(L, i+1, x);
}


//4.将顺序表Ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），分别放入新的顺序表中，然后原表和新表元素同时输出到屏幕上，以便对照求解结果。
void  listseparate(seqList* L, seqList* L1, seqList* L2)
{
	int k = 0, i = 0, j = 0;
	for (i = 0; i < L->listLen; i++)
	{
		if (L->data[i] % 2)
		{
			while (j != L->listLen)
			{
				L1->data[j] = L->data[i];
				L1->listLen++;
				j++;
				break;
			}
		}
		else
		{
			while (k != L->listLen)
			{
				L2->data[k] = L->data[i];
				L2->listLen++;
				k++;
				break;
			}
		}
	}
}


//5.求两个递增有序顺序表L1和L2中的公共元素，放入新的顺序表L3中。
void listcommon(seqList* L1, seqList* L2, seqList* L3)
{
	int i = 0, p = 0, q = 0;
	while (p != L1->listLen && q != L2->listLen)
	{
		if (L1->data[p] == L2->data[q])
		{
			while (i != L1->listLen)
			{
				L3->data[i] = L1->data[p];
				L3->listLen++;
				break;
			}
			i++;
			q++;
			p++;
		}
		else if (L1->data[p] < L2->data[q])
			p++;
		else
			q++;
	}
}


//6.删除递增有序顺序表中的重复元素，并统计移动元素次数
void listdeleteReapt(seqList*L) {
	//删除有序表重复值
	int same = 0;
	for (int i = 0; i < L->listLen; i++)
	{
		for (int j = i + 1; j < L->listLen; j++) {
			if (L->data[i] == L->data[j])
			{
				same++;
			}
			else {
				L->data[j - same] = L->data[j];
			}
		}
		L->listLen = L->listLen- same;
	}
	cout << "移动次数" << same << endl;
}

算法测试部分：

#include"squlist.h"
int main()
{
	int j, i = 100;
	int x;
	seqList L, L1, L2, L3;
	initList(&L);
	initList(&L1);
	initList(&L2);
	initList(&L3);
	while (i != -1)
	{
		menoprint();
		cin >> i;
		switch (i)
		{
		case 0:
			exit(0);
		case 3:
			cout << "链表为：";
			print(&L);
			break;
		case 4:
			cout << "请输入插入的位置" << endl;
			cin >> j;
			cout << "请输入插入元素：" << endl;
			cin >> x;
			if (listInsert(&L, j, x)!=2)
			{

			}
			else
			{
				cout << "插入后的链表" << endl;
				print(&L);
			}
			break;
		case 5:
			cout << "请输入要删除的元素位置" << endl;
			cin >> j;
			if (listDelete(&L, j)!=2)
			{

			}
			else
			{
				cout << "删除元素的链表为" << endl;
				print(&L);
			}
			break;
		case 6:
			/*initList(&L);
			cout << "提示  输入-1结束" << endl;
			cout << "请输入顺序表数据" << endl;
			create( & L);*/
			cout << "原表为：" << endl;
			print(&L);
			cout << "请输入插入的元素" << endl;
			cin >> x;
			OrderlistInsert(&L, x);
			cout << "插入后的链表" << endl;
			print(&L);
			//initList(&L);
			break;
		case 7:
			//initList(&L);
			initList(&L1);
			initList(&L2);
			//cout << "提示  输入-1结束" << endl;
			//cout << "请输入顺序表L数据：(提示  输入-1结束)" << endl;
			//create(&L);
			cout << "表L为：" << endl;
			//print(&L);
			listseparate(&L, &L1, &L2);
			cout << "链表L1为：";
			print(&L1);
			cout << "链表L2为：";
			print(&L2);
			//initList(&L);
			break;
		case 8:
			initList(&L1);
			initList(&L2);
			initList(&L3);
			cout << "请输入递增有序顺序表L1数据：(提示  输入-1结束)" << endl;
			create(&L1);
			cout << "请输入递增有序顺序表L2数据：(提示  输入-1结束)" << endl;
			create(&L2);
			listcommon(&L1, &L2, &L3);
			cout << "表L3" << endl;
			print(&L3);
			break;
		case 9:
			/*cout << "提示  输入-1结束" << endl;
			cout << "请输入递增有序顺序表L数据：" << endl;
			create(&L);*/
			cout << "原表为：";
			print(&L);
			listdeleteReapt(&L);
			cout << "删除重复的元素后表" << endl;
			print(&L);
			break;
		case 1:
			cout << "请输入递增有序顺序表L数据：(提示  输入-1结束)" << endl;
			create(&L);
			cout << "数据成功录入" << endl;
			break;
		case 2:
		{
			initList(&L);
			cout << "\n初始化\n" << endl;
			break;
		}
		}
		system("pause");
		system("cls");
	}
	return 0;
	system("pause");
}

实验结果展示：

 

七倾
关注
专栏目录
数据据结构实验——顺序表实验
qq_65814357的博客
06-10 1827
一、实验任务编写算法实现下列问题的求解。(1)在第i个结点位置插入值为x的结点。实验测试数据基本要求：第一组数据：顺序表长度n≥10，x=100, i分别为5,n,n+1,0,1,n+2第二组数据：顺序表长度n=0，x=100，i=5(2)删除顺序表中第i个元素结点。实验测试数据基本要求：第一组数据：顺序表长度n≥10，i分别为5,n,1,n+1,0第二组数据：顺序表长度n=0， i=5(3)在一个递增有序的顺序表L中插入一个值为x的元素，并保持其递增有序特性。实验测试数据基本要求：顺序表元素为 （10,
C语言(每日一题)——数据结构——在一条创建好的单链表中添加一个值为x的节点(详细过程)
yingyang20010112的博客
07-16 1293
代码】C语言(每日一题)——数据结构——在一条创建好的单链表中添加一个值为x的节点(详细过程)
下列算法完成在顺序表 SeqL 的第 i 个位置插入元素 x，正常插入返回 1，否则返回 0 或-1， 请在空的下划线上填写合适的内容完成该算法
qq_36833593的博客
09-27 3937
下列算法完成在顺序表 SeqL 的第 i 个位置插入元素 x，正常插入返回 1，否则返回 0 或-1， int seq_ins(SeqList *SeqL,int i, DataType x) { int j; if ( SeqL->len ==maxsize ) /*表满*/ { printf("the l...
2.11√ 设顺序表中L的数据递增有序，试写一算法，将x插入到顺序表中适当的位置，以保持该顺序表的有序性
qq_43661234的博客
09-10 2328
#include<stdio.h> typedef struct { char *data; int length; }SqList; void creat(SqList *L, int len) { int startnumber, step; printf("请输入初值和步长："); scanf("%d%d", &startnum...
设顺序表A中的数据元素递增有序，试写一程序，将x插入到顺序表的适当位置上，使该表仍然有序。
热门推荐
fyy_lufan的博客
12-27 1万+
下面提供两种做法，分别用顺序表和单链表实现。 顺序表： #include &lt;iostream&gt; #include &lt;cstdio&gt; #include &lt;stdlib.h&gt; #include &lt;malloc.h&gt; using namespace std; const int LIST_INIT_SIZE = 100; const int LI...
利用顺序表的操作，实现以下的函数。
weixin_41290863的博客
10-21 1490
(1) 从顺序表中删除具有最小值的元素并由函数返回被删元素的值。空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行。 (2) 从顺序表中删除第i个元素并由函数返回被删元素的值。如果i不合理或顺序表为空则显示出错信息并退出运行。 (3) 向顺序表中第i个位置插入一个新的元素x。如果i不合理则显示出错信息并退出运行。 (4) 从顺序表中删除具有给定值x的所有元素。 (5) 从顺序表中删除其值在给定值s与t之间（要求s小于t）的所有元素，如果s或t不合理或顺序表为空则显示出错信息并退出运行
ARCGIS实验四-网络分析.doc
04-19
本次实验旨在通过实践操作，使学生能够熟练掌握ArcGIS软件中网络分析的基本技能，包括如何利用ArcGIS的网络分析功能来解决现实生活中的问题。通过完成一系列具体的任务，加深对网络分析原理和技术的理解。 #### 二...
顺序表的基本操作--插入-删除-合并.doc
11-30
在本实验中，我们主要探讨了顺序表的基本操作，包括创建、插入、删除以及有序表的合并。顺序表是一种常见的线性数据结构，它将所有元素存储在一个连续的内存空间中，具有简单高效的特性。 首先，我们需要理解顺序表...
顺序表的应用-数据结构实验报告.docx
10-10
通过本实验，学生能够掌握顺序表的基本操作方法，并能够熟练地运用C语言实现这些操作。 #### 实验目的 1. **掌握顺序表的定义与实现：**学习如何定义线性表的顺序存储结构，并能够实现C程序的基本框架，包括对...
链表顺序表实验报告--数据结构与算法分析.doc
10-10
3. 熟练掌握电脑系统的基本操作方法，了解如何编译、运行一个 C++ 程序 4. 上机调试程序，掌握查错、排错使程序能正确运行 实验的环境包括硬件环境：索尼笔记本电脑，Intel(R) Core(TM) i7-3632M，8GB 内存可；软件...
一个有序顺序表，插入一个元素x之后，仍然保持有序
最新发布
weixin_61453630的博客
08-20 1889
【代码】一个有序顺序表，插入一个元素x之后，仍然保持有序。
线性表中元素有序且按顺序存储于计算机中。要求设计一算法完成：用最少时间在表中查找数值为X的元素，若找到将其与后继元素位置交换，若找不到将其插入表中并使表中元素仍递增有序
yyy_zxc的博客
10-30 416
因为题目要求用最少时间查找，所以这使用折半查找。
PTA 6-3 求顺序表最小值
wcd278212784的博客
03-31 3478
6-3 求顺序表最小值添加链接描述 本题要求实现一个函数，要求返回顺序表的最小值，空表返回0。题目保证顺序表中所有元素都为正整数。 函数接口定义： int GetMin(SqList L); 其中SqList结构定义如下： typedef struct{ ElemType *elem; int length; }SqList; ``` 裁判测试程序样例： #include <stdio.h> #include <stdlib.h> #define MAXSIZE 5 typedef
建立一有序的顺序表，并实现下列操作: 1.把元素x插入表中并保持有序； 2.查找值为x的元素，若找到将其删除； 3.输出表中各元素的值。
Alan_King79的博客
10-27 6352
一.内容： 建立一有序的顺序表，并实现下列操作: 1.把元素x插入表中并保持有序； 2.查找值为x的元素，若找到将其删除； 3.输出表中各元素的值。 二.算法思想： 在主函数中定义顺序表L，并定义插入元素和被删除元素的值；再给顺序表L分配内存空间，通过调用InitList函数，初始化顺序表L，利用冒泡法将键盘输入的值进行排序，再调用printList函数进行输出。从键盘输入要插入的数的值，通过调用InsList函数，将该值插入，再通过调用printList函数进行输出。从键盘输入要查找的数，调用Locate
顺序表-插入一个元素x后保持该顺序表L递增有序排序（查找+元素后移插入）
muyu_muyu的博客
12-18 3880
顺序表的存储结构： typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList; 分析： 要保持插入一个元素后，仍然要保持有序。肯定先要查找插入位置。 怎么找插入位置？ 和单链表有什么不同？ 定义一个位置变量i, 通过循环i++. 而单链表是p = p->next; 找到了位置如何插入？这里又和单链表有什么不同？ 这里是元素后移，让位插入， 而单链表是
在有序的顺序表 L 中保序插入数据元素 x
积极奋斗的蜗牛
04-09 1万+
设顺序表L中的数据元素递增有序。 试写一算法，将x插入到L的适当位置上，并保 持该表的有序性。 实现函数如下：
编写算法，从顺序表中在第1个位置插入一个元素x，然后输出顺序表中的所有元素。在删除顺序表中第k个元素，然后输出顺序表中的所有元素。
m0_74956976的博客
03-18 601
j--) { //如果插入的元素的大小位于顺序表中任一相邻两个元素之间，则插入元素。if (x > L.data[i] && x < L.data[i + 1]) { //边遍历边比较，同时顺序表挪位置!//为顺序表分配内存地址。if (L.length == MAXSIZE - 1) { //检查插入位置的合理性，如果表满了，就不能插入元素。if (x == L.data[i]) { //当插入数据等于顺序表中的任一元素时，无法保持顺序性，无法插入。//将数组里面的值通过循环赋值给顺序表。
顺序表的基本操作实现
Gefangen的博客
10-13 3580
目录 1.　顺序表的定义 2.　顺序表的基本操作的实现 (1)　插入操作 (2)　删除操作 (3)　按值查找（顺序查找） 1.　顺序表的定义 　　线性表的顺序存储又称顺序表。它是一组地址连续的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理位置上也相邻。 假定线性表的元素类型为 ElemType ，则线性表的顺序存储类型描述为： #define Max...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值