数据据结构实验——顺序表实验

一、实验任务

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

(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,20,30,40,50,60,70,80,90,100）,

x分别为25，85，110和8

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

实验测试数据基本要求：

第一组数据：顺序表元素为（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）

(5)求两个递增有序顺序表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）

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

实验测试数据基本要求：

第一组数据：顺序表元素为（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）

二、顺序表扩展实验

非必做内容，有兴趣的同学选做，

1. 递增有序顺序表L1、L2，对2表进行合并，并使得合并后成为一个集合，集合的元素放回L1表中保存，要求时间性能最好。

2.（递增有序）顺序表表示集合A、B，实现：

C=AB，C=AB，C=A-B

A=AB，A=AB，A=A-B

3.（递增有序）顺序表表示集合A、B，判定A是否B的子集。

4. (2011)（15 分）一个长度为L（L≥1）的升序序列S，处在第个位置的数称为S 的中位数。例如，若序列S1=(11, 13, 15, 17, 19)，则S1 的中位数是15。两个序列的中位数是含它们所有元素的升序序列的中位数。例如，若S2=(2, 4, 6, 8, 20)，则S1 和S2 的中位数是11。

现有两个等长升序序列A 和B，试设计一个在时间和空间两方面都尽可能高效的算法，找出两个序列A 和B 的中位数。要求：

（1）给出算法的基本设计思想。

（2）根据设计思想，采用C 或C++语言描述算法，关键之处给出注释。

（3）说明你所设计算法的时间复杂度和空间复杂度。

三、算法设计

（除书上给出的基本运算（这部分不必给出设计思想），其它实验内容要给出算法设计思想）

（3）递增插入：从后往前搜索，同时移动元素。当元素值大于 x时后移，重复进行，直到第一个小于等于x 元素，回退一个单元即x的插入位置。

（4）分为奇偶：建立两个新表1和2，对原表进行处理。在遍历过程中，当找到奇数时插入到新表1中；找到偶数时插入到新表2中。

（5）有序C = A交B：每次取A和B中的一个最小元素，依次插入 C表即可。

当A->data[i] < B->data[j]时，A表中当前元素较小，插入C表。执行i++ ，继续取A表的下一个元素，而j不变；

当A->data[i] > B->data[j]时，B表中当前元素较小，插入C表。执行j++，继续取B表的下一个元素，而i不变；

当A->data[i] == B->data[j]时，A、B表元素相同，或同时插入C表，或插入一个。同时插入，执行i++，j++，同时取下一个元素。

重复执行上述判断、插入过程，直到A和B表中有一个结束。

（6）删除重复元素：首先判度少于 2 个元素，直接退出。

然后，将元素分成：已经处理元素和待处理元素。分别用i，j表示。初始化i = 0， j=1。

当data[i] == data[j]，说明j指示的是i的重复元素，继续处理 j 的下一个元素，即执行j++。

当data[i] < data[j]时，因为 L 递增，所以剩下情况只能是data[i] < data[j]，j 为目标元素。如果 j == i+1，说明j紧随i，无需移动元素，直接i++、j++即可。若不同j元素复制到 i+1。无论那种情况，都需要同时后移 i、j。循环执行上述操作，直到表尾。修改L的长度为 i+1。

（7）A = A 并 B：设置两个指针i、j分别指向A、B表当前处理的元素；

当A->data[i] < B->data[j]时，A表中当前元素较小，执行i++。

当A->data[i] > B->data[j]时，B表中当前元素较小，因为递增性，j指示的元素不可能在A中,将该元素加入A后面。

当A->data[i] == B->data[j]时，A、B表元素相同，执行i++，j++，同时取下一个元素。

重复执行上述判断、插入过程，直到A和B表中有一个结束。若A表剩余直接就在其中，若B表剩余，则全满足，加入A表后面

（8）A = A 并 B（见第7题）

A = A 交 B：设置两个指针ia、ib分别指向A、B表当前处理的元素；设置一个指针 i 示已经求取的交集元素在 A 的表中的最后元素位置

当A->data[ia] == B->data[ib]时，则 ia 或 ib 是交集元素。然后让三个指针后移ia++，ib++，i++。

当A->data[ia] < B->data[ib]时，当前元素为非交集元素，但可能在B元素后面，所以只需移动 ib。

当A->data[ia] > B->data[ib]时，同理只需要移动ia。

重复以上过程，直至 A、B 中至少一个表结束。修改 A 表长度为 i+1。

A = A 差 B：设置两个指针 ia、ib 分别指向 A、B 表当前处理的元素；设置一个指针指示已经求取的差集元素在 A 的表中的最后元素位置；

当A->data[ia] == B.data[ib]，则ia或ib是交集元素，不是A-B 中元素，直接跳过,执行ia++，ib++。

当A->data[ia] > B->data[ib]，ia 指示的元素可能在 B 表 ib 指示的元素后面，ia不动，移动ib。

当A->data[ia] < B->data[ib]，ia 指示的元素不可能在 B 中出现，故比为 A-B 中元素。需要写入A中，然后执行i++，ia++。

重复以上过程，直至 A、B 中至少一个表结束。若B 表已结束，剩下元素全为 A-B 中元素，全部迁移到目标位置。若A表已结束，则直接结束。最后，修改 A 表长度为 i+1。

C = A 并 B：设置两个指针i、j、k分别指向A、B、C表当前处理的元素；

当A->data[i] < B->data[j]时，A表中当前元素较小，因为递增性，i指示的元素

不可能在B中,将该元素插入C表，执行i++，k++。

当A->data[i] > B->data[j]时，B表中当前元素较小，因为递增性，j指示的元素

不可能在A中,将该元素加入C中，执行j++，k++。

当A->data[i] == B->data[j]时，A、B表元素相同，插入一个到C中，执行i++，j++，k++同时取下一个元素。

重复执行上述判断、插入过程，直到A和B表中有一个结束。若A表剩余直接插入C中，若B表剩余，则直接插入C中。最后，修改 C 表长度。

C = A 交 B：（见第5题）。

C = A 差 B：设置两个指针i、j、k分别指向A、B、C表当前处理的元素；

当A->data[i] == B.data[j]，则i或j是交集元素，不是A-B 中元素，直接跳过,执行i++，j++。

当A->data[i] > B->data[j]，i指示的元素可能在 B 表 j指示的元素后面，i不动，移动j。

当A->data[i] < B->data[j]，i指示的元素不可能在 B 中出现，故比为 A-B 中元素。需要写入C中，然后执行i++，j++， k++。

重复以上过程，直至 A、B 中至少一个表结束。若B 表已结束，剩下元素全为 A-B 中元素，全部迁移到目标位置。若A表已结束，则直接结束。最后，修改 C 表长度。

（9）是否为子集：设用ia和ib分别为A和B中元素的编号。

当A->data[ia] > B->data[ib]时，即A表中当前元素大于B表中当前元素，因而需要继续在B表中搜索，即要执行ib++以使ib指向B表中下一个元素并继续搜索。

当A->data[ia] == B->data[ib]时，A表中当前元素在B表中，即查找成功，同时后移。

当A->data[ia] < B->data[ib]时，即A表中当前元素小于B表中当前元素，因而肯定小于其后面的所有元素，所以该元素肯定不在B中，所以不是子集，返回0。

重复执行上述判断过程，直到ia和ib中至少有一个指向表尾之后为止。此时，A表未结束。可返回结论1。若B表结束，可返回0。

（10）分别求两个升序序列A、B 的中位数，设为mid1和mid2。若mid1 = mid2，则mid1或mid2即为所求的中位数；否则，舍弃mid1和mid2中较小者所在序列之较小一半，同时舍弃较大者所在序列之较大一半，要求两次舍弃的元素个数相同。在保留的两个升序序列中，重复上述过程，直到两个序列中均只含一个元素时为止，则较小者即为所求的中位数。

#define MAXLEN 100
#include <iostream>using namespace std;
typedef struct sList{int data[MAXLEN];int listLen;
}seqList;
//初始化一个新顺序表
void initList(seqList *&L){L = new seqList;L->listLen = 0;
}
//读取数组元素到顺序表中
void creatList(seqList *&L, int a[], int n){int i, j;L = new seqList;  //实例化一个顺序表 if(n == 0){        //若为空，直接返回 return;}for(i = 0, j = 0; i < n; i++, j++){  //将数组元素读入顺序表中 L->data[j] = a[i];} L->listLen = n;
}
//展示顺序表元素
void displayL(seqList *L){if(L->listLen == 0){cout << "表为空！"; } for(int i = 0; i < L->listLen; i++){   //遍历打印出顺序表元素 cout << L->data[i] << " "; }cout << endl;
}
//基本插入元素
bool listInsert(seqList *L, int x, int i){bool flag = 0;if(L->listLen == MAXLEN)cout << "表满，插入错误！" << endl;   //溢出，不能插入 else if(i < 1 || i > L->listLen + 1)cout << "序号" << i << "超出范围，插入失败！" << endl; //超出范围也不能插入 else{for(int j = L->listLen - 1; j >= i - 1; j--){L->data[j + 1] = L->data[j];  //后移一位 }L->data[i - 1] = x; //插入元素 L->listLen++;flag = 1;}return flag;
}
//基本删除元素
bool listDelete(seqList *L, int i){bool flag = 0;if(L->listLen <= 0)cout << "空表，删除错误！" << endl;     // 空表，不能删除else if(i < 1 || i > L->listLen)cout << "序号" << i << "超出范围，删除失败！" << endl;      //超出范围，不能删除else{for(int j = i; j <= L->listLen - 1; j++){L->data[j - 1] = L->data[j];           //前移一位 }L->listLen--;flag = 1;}return flag;
}
//递增有序插入
void Insert(seqList *L, int x){int i,j;if(L->listLen == MAXLEN){cout << "表满，插入错误！" << endl;    //溢出，不能插入 return; }for(i = L->listLen - 1; L->data[i] > x && i >= 0; i--){L->data[i+1]=L->data[i]; //指针从最后开始后移一位 }L->data[i + 1] = x;L->listLen++;
}
//分为奇偶顺序表
void part(seqList *L, seqList *A, seqList *B){int i = 0, j = 0, p = 0;while(i < L->listLen){       if(L->data[i] % 2 == 0)    //为偶数，进入A中 {A->data[j] = L->data[i];j++;A->listLen++;i++;}else{      //为奇数，进入B中 B->data[p] = L->data[i];p++;B->listLen++;i++;} }
}
//C = A 交 B
void merge(seqList *A, seqList *B, seqList *C){int i = 0, j = 0, k = 0;while (i < A->listLen && j < B->listLen){if (A->data[i] < B->data[j]){//A小于B，A元素可能在B元素后面，A元素后移 i++;}else if (A->data[i] > B->data[j]){j++;//B小于A，B元素可能在A元素后面，B元素后移}else{//交集元素，加入C C->data[k] = B->data[j];j++;i++;k++;}}C->listLen = k;
}
//删除重复元素
int DeleteRepeatData(seqList *L){int i, j, sum; if(L->listLen < 2)return 0; //少于 2 个元素，直接退出i = 0; j = 1;sum = 0;while(j < L->listLen){if(L->data[i] == L->data[j]) //j 为重复元素，j 后移j++;else{ //因为 L 递增，所以剩下情况即 L.data[i]<L.data[j]，j 为目标元素if((i+1) != j){//如果 j==i+1，说明 j 紧随 i，无需移动元素，直接 i++、j++即可L->data[i+1] = L->data[j]; //j 元素复制到 i+1sum++;}i++; //无论那种情况，都需要同时后移 i、jj++;}}L->listLen = i+1; //修改表的实际长度return sum;
}
//A = A 并 B
void Add(seqList *L1, seqList *L2){int i = 0, j = 0;while(i < L1->listLen && j < L2->listLen){if(L1->data[i] == L2->data[j]){//两表元素相同, 同时i++，j++，i++;j++;}else if(L1->data[i] < L2->data[j]){i++;//l1小于l2,则直接后移   }else{//L1大于L2，因为递增性，j指示的元素不可能在L1中,将该元素加入L1后面 L1->data[L1->listLen] = L2->data[j];L1->listLen++;j++;}}//L1表剩余直接就在其中，L2表剩余，则全满足，加入L1后面 while(j < L2->listLen){L1->data[L1->listLen] = L2->data[j];L1->listLen++;j++;}
}
//A = A 交 B
void InterSet(seqList *A, seqList *B){int i = 0; int ia = 0, ib = 0; //A、B 表当前元素的数组下标while(ia < A->listLen && ib < B->listLen){if(A->data[ia] == B->data[ib]){ //ia 和 ib 指示的是交集元素A->data[i] = A->data[ia];i++;ia++;ib++;}else if(A->data[ia] < B->data[ib]) //以下为非交集元素处理ia++;elseib++;}A->listLen = i; //更新 A 表长度，使等于交集元素个数。
}
//A = A 差 B
void SetSubtraction(seqList *A, seqList *B){int i = 0; //指示 A 中已经处理的最后元素int ia = 0, ib = 0; //指示 A、B 中，当前待处理的元素，初始指向第一个元素while(ia < A->listLen && ib < B->listLen ){if(A->data[ia] == B->data[ib]){ //元素相等，一定非 A-B 中元素，ia、ib 同时后移ia++;ib++;}else if(A->data[ia] > B->data[ib]) ib++; //ia 指示元素可能在 B 中 ib 指示的元素后面，移动 ib。else{   //A<B，因为递增性，ia 指示的元素不可能在 B 中。A->data[i] = A->data[ia];i++; ia++; }}
//处理 B 已经，A 尚未结束情况，A 中剩下部分元素全部为 A-B 元素    while(ia < A->listLen) {A->data[i] = A->data[ia];i++; ia++; }A->listLen = i; //更新表 A 的长度
}
//C = A 并 B
void MergeList(seqList *A, seqList *B, seqList *C){int i = 0, j = 0, k = 0;while(i < A->listLen && j < B->listLen){if(A->data[i] == B->data[j]){ //A、B表元素相同,插入一个。同时i++，j++，C->data[k++] = A->data[i];i++;j++;}else if(A->data[i] < B->data[j]){  //A表中当前元素较小，插入C表。执行i++ ，C->data[k++] = A->data[i++]; //继续取A表的下一个元素，而j不变；}else{                             //B表中当前元素较小，插入C表。执行j++，C->data[k++] = B->data[j++];  //继续取B表的下一个元素，而i不变；   }}//下面处理一个表结束，另一个表未结束情况while(i < A->listLen){C->data[k++] = A->data[i++];}while(j < B->listLen){C->data[k++] = B->data[j++];}C->listLen = k;
}
//C = A 差 B
void cha(seqList *A, seqList *B, seqList *C){int i = 0, j = 0, k = 0;while(i < A->listLen && j < B->listLen){if(A->data[i] == B->data[j]){ //元素相等，一定非 A-B 中元素，i、j 同时后移i++;j++;}else if(A->data[i] < B->data[j]){  //A<B，因为递增性，i指示的元素不可能在 B 中。C->data[k++] = A->data[i++];}else{j++;//i指示元素可能在 B 中j指示的元素后面，移动 j。}}//处理 B 已经，A 尚未结束情况，A 中剩下部分元素全部为 A-B 元素    while(i < A->listLen){C->data[k++] = A->data[i++];}C->listLen = k;//更新C表长度
}
//判断是否为子集
bool ZiJi(seqList *A, seqList *B){ int ia = 0, ib = 0; while (ia < A->listLen && ib < B->listLen){if (A->data[ia] == B->data[ib]){    //相等则直接下一个 ia++; ib++;}else if (A->data[ia]> B->data[ib]) ib++;      //A数大于B，则与A相等的数可能在下一个 else return 0; //A数小于B，则不可能是自己，直接返回 0 }//一表结束后if (ia >= A->listLen) return 1; //A表结束elsereturn 0; //A未结束，B结束
}
//查找中位数    参考网络
int M_Search(int A[], int B[], int n){int start1, end1, mid1, start2, end2, mid2; start1 = 0;end1 = n - 1;start2 = 0;end2 = n - 1;while(start1 != end1 || start2 != end2){mid1 = (start1 + end1) / 2;mid2 = (start2 + end2) / 2;if(A[mid1] == B[mid2])return A[mid1];if(A[mid1] < B[mid2]){//分别考虑奇数和偶数，保持两个子数组元素个数相等if((start1 + end1) % 2 == 0){//若元素为奇数个start1 = mid1; //舍弃A中间点以前的部分且保留中间点end2 = mid2; //舍弃B 中间点以后的部分且保留中间点}else{ //若元素为偶数个start1 = mid1 + 1;//舍弃A 的前半部分end2 = mid2; //舍弃B 的后半部分}}else{if((start1 + end1) % 2 == 0){//若元素为奇数个end1 = mid1; //舍弃A 中间点以后的部分且保留中间点start2 = mid2; //舍弃B 中间点以前的部分且保留中间点}else{//若元素为偶数个end1 = mid1; //舍弃A 的后半部分start2 = mid2 + 1;//舍弃B 的前半部分}}}return A[start1] < B[start2] ? A[start1] : B[start2];    //取较小的为中位数
}

数据据结构实验——顺序表实验相关推荐

考试报名管理系统C语言顺序表,学生信息管理系统(顺序表)实验
<学生信息管理系统(顺序表)实验>由会员分享,可在线阅读,更多相关<学生信息管理系统(顺序表)实验(29页珍藏版)>请在人人文库网上搜索. 1.精品文档数据结构课程 ...
数据结构（二）:线性表包括顺序存储结构（顺序表、顺序队列和顺序栈）和链式存储结构（链表、链队列和链栈）...
还记得数据结构这个经典的分类图吧: 今天主要关注一下线性表. 什么是线性表线性表的划分是从数据的逻辑结构上进行的.线性指的是在数据的逻辑结构上是线性的.即在数据元素的非空有限集中 (1) 存在唯一的 ...
3、线性表的顺序存储结构（顺序表）
线性表的顺序存储结构简称为顺序表.线性表的顺序存储结构是把线性表中的元素中的元素按照其逻辑顺序依次存储到计算机存储器中指定位置开始的一块连续的存储空间中,它直接将线性表的逻辑结构映射到存储结构上,既 ...
数据结构严蔚敏C语言版—线性表顺序存储结构（顺序表）C语言实现相关代码
数据结构严蔚敏C语言版-线性表顺序存储结构(顺序表)C语言实现相关代码 1.运行环境 2.准备工作 1)项目构建 1>新建一个SeqList项目 2>新建两个文件Sources和Heade ...
实验报告微型计算机拆卸顺序表,实验一线性表的顺序存储结构实验报告页.doc...
实验一线性表的顺序存储结构实验报告页.doc 1 攀枝花学院实验报告实验课程数据结构实验项目线性表的顺序存储实验日期系班级姓名学号同组人指导老师成绩实验目的1. ...
数据结构实验——顺序表操作
提示:本文代码主要是根据数据结构教程5-李春葆改写的文章目录前言一.实验目的二.实验总代码三.每个功能的具体函数 1.建立顺序表 2.输出顺序表 3.插入数据元素删除数据元素总结前言 ...
实验一：顺序表实验报告
一.实验目的 1.熟练掌握线性表的结构特点,掌握顺序表的基本操作. 2.巩固 C++相关的程序设计方法与技术. 3.学会使用顺序表解决实际问题.
基于Python的数据结构实验——顺序表与单链表建立与操作（附详细代码和注释）
1.创建一个名为 prac02_01.py 的文件,在其中编写一个顺序表的类,该类必须包含顺序表的定义及基本操作,并通过以下步骤测试基本操作的实现是否正确,给出运行结果. (1)初始化一个顺序表 S ...
线性表的顺序存储结构之顺序表类的实现_Java
在上一篇博文--线性表接口的实现_Java中,我们实现了线性表的接口,今天让我们来实现线性表的顺序存储结构--顺序表类. 首先让我们来看下顺序表的定义: 线性表的顺序存储是用一组连续的内存单元依次存放 ...

数据据结构实验——顺序表实验

数据据结构实验——顺序表实验相关推荐

最新文章

热门文章