数据结构实验报告-顺序表的创建、遍历及有序合并操作

数据结构实验一顺序表实验报告
数据结构是计算机科学中的一门基础课程，在学习数据结构的过程中，顺序表是我们必须深入了解和掌握的重要数据结构之一。

在实验一中，我们对顺序表进行了一系列的操作，实现了增删改查等基本操作。

我们先来介绍一下顺序表的基本概念。

顺序表是将线性表中的数据存储在一段连续的存储空间中的数据结构，其查找效率高，但插入和删除操作效率较低。

顺序表需要预先分配一定的存储空间，当存储空间不足时需要进行动态扩容，即重新申请更大的存储空间并将原有数据复制到新的存储空间中。

在实验中，我们首先学习了顺序表的实现方式，包括顺序表的结构体定义、创建顺序表、插入元素、删除元素、修改元素以及查询元素等基本操作。

我们通过 C 语言来实现了这些操作，并将其封装成一个顺序表的 API，使其更加易于使用和维护。

在实验过程中，我们还发现顺序表中数据的存储顺序非常重要，因为顺序表中元素的存储顺序与元素的下标是一一对应的，如果存储的顺序错误，可能会导致元素的下标与我们想象中的不一致，从而造成一些意想不到的结果。

总的来说，实验一帮助我们更深入地了解了顺序表的实现方式和基本操作，同时也挖掘出了一些潜在问题，这对于我们今后的学习和实践都起到了很大的帮助。

实验一顺序表的基本操作一、实验目的掌握线性表的顺序表基本操作：建立、插入、删除、查找、合并、打印等运算。

二、实验要求包含有头文件和main函数；1.格式正确，语句采用缩进格式；2.设计子函数实现题目要求的功能；3.编译、连接通过，熟练使用命令键；4.运行结果正确，输入输出有提示，格式美观。

三、实验设备、材料和工具1.奔腾2计算机或以上机型2.turboc2,win-tc四、实验内容和步骤1. 建立一个含n个数据元素的顺序表并输出该表中各元素的值及顺序表的长度。

2. 往该顺序表中第i位置插入一个值为x的数据元素。

3. 从该顺序表中第j位置删除一个数据元素，由y返回。

4. 从该顺序表中查找一个值为e的数据元素，若找到则返回该数据元素的位置，否则返回“没有找到”。

五、程序#include<stdio.h>#include<stdlib.h>#define list_init_size 10#define increment 2typedef struct {int *elem;int length,listsize;}sqlist; //类型定义void initlist_sq(sqlist &L) //初始化顺序表{ }void output(sqlist L) //输出顺序表{ }void insertlist(sqlist &L,int i, int x) //顺序表中插入x{ }void deletelist(sqlist &L,int j, int y) //顺序表中删除y{ }int locateelem(sqlist &L,int e) //顺序表中查找e{ }void main(){ }【运行结果】void initlist_sq(sqlist &L) //初始化顺序表{L.elem=(int*)malloc(LIST_INIT_SIZE*sizeof(int));if(!L.elem) exit (OVERFLOW);L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}void output(sqlist L) //输出顺序表{for(int i=0;i<=L.length-1;i++)printf("%d,",L.elem[i]);return OK;}void insertlist(sqlist &L,int i, int x) //顺序表中插入x{int p,q;if(i<1||i>L.length+1)return ERROR;if(L.length>=L.listsize){newbase=(int*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(int));if(!newbasde)exit(OVERFLOW);L.elem=newbase;L.listsize+=LISTINCREMENT;}q=&(L.elem[i-1];for(p=&(L.elem[L.length-1]);p>=q;--p*(p+1)=*p;*p=x;++L.length;return ok;}void deletelist(sqlist &L,int j, int y) //顺序表中删除y{int p,q;if(i<1||I>L.length+1) return ERROR;p=&(L.elem[i-1]);y=*p;q=L.elem+L.length-1;for(++p;p<=q;++p)*(p-1)=*p;--L.length;return ok;}int locateelem(sqlist &L,int e) //顺序表中查找e { int p;i=1;p=L.elem;while(i<=L.length&&!(*p++,e))++i;if(i<=L.length) return i;else return 0;}void main(){int d,p,a,b;int c;initlist_sq(&L);output( L);insertlist( &L, d, a);deletelist( &L, p, b);locateelem( &L, c);}。

顺序表的实现实验报告顺序表的实现实验报告1. 引言顺序表是一种常见的数据结构，它可以用于存储一组有序的元素。

在本实验中，我们将探索顺序表的实现方式，并通过实验验证其性能和效果。

2. 实验目的本实验的主要目的是掌握顺序表的实现原理和基本操作，并通过实验对比不同操作的时间复杂度。

3. 实验方法3.1 数据结构设计我们选择使用静态数组作为顺序表的底层存储结构。

通过定义一个固定大小的数组，我们可以实现顺序表的基本操作。

3.2 基本操作实现在顺序表的实现中，我们需要实现以下基本操作：- 初始化操作：创建一个空的顺序表。

- 插入操作：向顺序表中插入一个元素。

- 删除操作：从顺序表中删除一个元素。

- 查找操作：在顺序表中查找指定元素。

- 获取长度：获取顺序表中元素的个数。

4. 实验步骤4.1 初始化操作首先，我们需要创建一个空的顺序表。

这可以通过定义一个数组和一个变量来实现，数组用于存储元素，变量用于记录当前顺序表的长度。

4.2 插入操作在顺序表中插入一个元素的过程如下：- 首先，判断顺序表是否已满，如果已满则进行扩容操作。

- 然后，将要插入的元素放入数组的末尾，并更新长度。

4.3 删除操作从顺序表中删除一个元素的过程如下：- 首先，判断顺序表是否为空，如果为空则返回错误信息。

- 然后，将数组中最后一个元素删除，并更新长度。

4.4 查找操作在顺序表中查找指定元素的过程如下：- 首先，遍历整个数组，逐个比较元素与目标元素是否相等。

- 如果找到相等的元素，则返回其位置；如果遍历完仍未找到，则返回错误信息。

4.5 获取长度获取顺序表中元素个数的过程如下：- 直接返回记录长度的变量即可。

5. 实验结果与分析在实验中，我们通过对大量数据进行插入、删除、查找等操作，记录了每个操作的耗时。

通过对比不同操作的时间复杂度，我们可以得出以下结论：- 初始化操作的时间复杂度为O(1)，因为只需要创建一个空的顺序表。

- 插入和删除操作的时间复杂度为O(n)，因为需要遍历整个数组进行元素的移动。

《数据结构》实验报告一系别：班级：学号：姓名：日期：指导教师：一、上机实验的问题和要求：顺序表的查找、插入与删除。

设计算法，实现线性结构上的顺序表的产生以及元素的查找、插入与删除。

具体实现要求：从键盘输入10个整数，产生顺序表，并输入结点值。

从键盘输入1个整数，在顺序表中查找该结点的位置。

若找到，输出结点的位置；若找不到，则显示“找不到”。

从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出顺序表所有结点值，观察输出结果。

从键盘输入1个整数，表示欲删除结点的位置，输出顺序表所有结点值，观察输出结果。

二、程序设计的基本思想，原理和算法描述：（包括程序的结构，数据结构，输入/输出设计，符号名说明等）三、源程序及注释：#include <stdio.h>/*顺序表的定义：*/#define ListSize 100 /*表空间大小可根据实际需要而定，这里假设为100*/ typedef int DataType; /*DataType可以是任何相应的数据类型如int, float或char*/ typedef struct{ DataType data[ListSize]; /*向量data用于存放表结点*/int length; /*当前的表长度*/}SeqList;/*子函数的声明*/void CreateList(SeqList * L,int n); /*创建顺序表函数*/int LocateList(SeqList L,DataType x); /*查找顺序表*/void InsertList(SeqList * L,DataType x,int i); /*在顺序表中插入结点x*/void DeleteList(SeqList * L,int i);/*在顺序表中删除第i个结点*/void PrintList(SeqList L,int n); /*打印顺序表中前n个结点*/void main(){SeqList L;int n=10,x,i; /*欲建立的顺序表长度*/L.length=0;/*调用创建线性表函数*/printf("create function:\n");CreateList(&L,n); /*建立顺序表*/PrintList(L,n); /*打印顺序表*//*调用查找函数*/printf("search function:\n");printf("input the data you want to search:");scanf("%d",&x);i=LocateList(L,x); /*顺序表查找*/if (i==0)printf("sorry,don't find %d!\n\n",x);elseprintf("i have find the %d，it locate in %d!\n\n",x,i);/*调用插入函数*/printf("Insert function:\n");printf("输入要插入的位置：(input the position:)");scanf("%d",&i);printf("输入要插入的元素：(input the data:)");scanf("%d",&x);InsertList(&L,x,i); /*顺序表插入 */PrintList(L,n); /*打印顺序表 *//*调用删除函数*/printf("delete function:\n");printf("输入要删除的位置：(input the position:)");scanf("%d",&i);DeleteList(&L,i); /*顺序表删除 */PrintList(L,n); /*打印顺序表 */}/*顺序表的建立：*/void CreateList(SeqList *L,int n){ int i;for (i=0;i<n;i++){ printf("\ninput the %d data:",i+1);scanf("%d",&(*L).data[i]);}(*L).length=n;}/*顺序表的查找：*/int LocateList(SeqList L,DataType x){ int i=0;while (i<L.length&&x!=L.data[i])++i;if (i<L.length) return i+1;else return 0;}/*顺序表的插入：*/void InsertList(SeqList *L,DataType x,int i){/*将新结点x插入L所指的顺序表的第i个结点的位置上 */ int j;if (i<0||i>(*L).length){printf("插入位置非法");exit(0);}if ((*L).length>=ListSize){printf("表空间溢出，退出运行");exit(0);}for (j=(*L).length-1;j>=i-1;j--)(*L).data[j+1]=(*L).data[j]; /*顺序表元素从后向前依次后移*/ (*L).data[i-1]=x; /*将x插入第i个结点位置*/(*L).length++; /*表长自增1*/}/*顺序表的删除：*/void DeleteList(SeqList *L,int i){/*从L所指的顺序表中删除第i个结点 */int j;if (i<0 || i>(*L).length){printf("删除位置非法");exit(0);}for (j=i;j<=(*L).length-1;j++)(*L).data[j]=(*L).data[j+1]; /*顺序表自第i个结点开始，依次前移*/ (*L).length--; /*表长自减1*/}/*顺序表的打印：*/void PrintList(SeqList L,int n){ int i;printf("the sequal list data is:");for (i=0;i<n;i++)printf("%d ",L.data[i]);printf("\n\n");}四、运行输出结果：五、调试和运行程序过程中产生的问题及采取的措施：六、对算法的程序的讨论、分析，改进设想，其它经验教训：七、对实验方式、组织、设备、题目的意见和建议：。

顺序表实验报告一、实验内容和目的实验目的：掌握顺序表的建立、查找、插入和删除操作。

掌握有序表的建立、合并、插入操作。

实验内容：1. 顺序表的建立2. 顺序表的遍历3. 顺序表的元素查找4. 顺序表的元素插入5. 顺序表的元素删除6. 有序表的建立7. 有序表的遍历8. 有序表的元素插入9. 有序表的合并二、实验原理基本原理：通过连续的地址空间实现逻辑上和物理上连续的储存的一系列元素。

并在此基础上进行元素的添加，查找，删除操作。

有序表的插入算法：元素插入之前的，先跟有序表中的逐个元素进行对比，以找到合适的插入位置。

例如，已有有序表L，要向L 中插入元素18L={13,15,17,19,20,35,40}第一步：将18与L1进行比较，18 > L1，不是合适的插入位置。

第二步：将18与L2进行比较，18>L2，仍然不是不是的插入位置。

重复上述步骤，知道找到18≤Ln，然后在(n-1) 和n之间插入元素。

（如果元素比有序表中的所有元素都要大，则把该元素放到有序表的最后）此例子中，L n-1 = 17，L n = 19插入元素之后的有序表L为：L′={13,15,17,18,19,20,35,40}仍然保持有序。

重置光标的位置：程序接受两种方式的输入。

一种是输入数字后按回车，一种是利用空格间隔的连续几个数字。

然而，在使用后者输入数字的时候，会出现提示输出不正确的问题。

（如图）这个问题的原因简单如下：当程序输出“请输入第2个数字：”的时候，应该等待用户输入；然而，在程序等待输入第一个数字的时候，用户输入了五个数字。

因此，程序输出“输入第2个提示以后”，程序发现仍然有数据没有进行处理，因此把上次输入但未处理的字符当成是用户的输入。

所以没让用户输入数据就自动继续执行。

解决这个问题的思路：每次输出提示时，将光标移动到行首，因此，输出提示的时候会自动覆盖已经输出的提示信息。

效果如下：具体的解决方法：#include<windows.h>// 将光标移动到行首void ResetCursor(){HANDLE hOut;COORD cTarget;CONSOLE_SCREEN_BUFFER_INFO info;int y = 0;hOut = GetStdHandle(STD_OUTPUT_HANDLE);GetConsoleScreenBufferInfo(hOut, &info);y = info.dwCursorPosition.Y;cTarget.X = 0;cTarget.Y = y;SetConsoleCursorPosition(hOut, cTarget);}三、程序流程图四、实现步骤4.1 创建顺序表的实现①通过scanf 函数从键盘中读入数据，并通过scanf函数的返回值判断用户输入的是数字还是非数字，作为判断输入结束的判断。

数据结构实验报告-顺序表的创建、遍历及有序合并操作二、实验内容与步骤实现顺序表的创建、遍历及有序合并操作，基本数据结构定义如下：typedef int ElemType;#define MAXSIZE 100#define FALSE 0#define TRUE 1typedef struct{ElemType data[MAXSIZE];int length;}seqlist;创建顺序表，遍历顺序表#include<stdio.h>#include<stdlib.h>#define MAXSIZE 100#define Icreament 20#define FALSE 0#define TRUE 1typedef int ElemType; //用户自定义数据元素类型// 顺序表结构体的定义typedef struct{ElemType *elem; //顺序表的基地址int length; //顺序表的当前长度int listsize; //预设空间容量}SqList; //线性表的顺序存储结构SqList* InitList() //创建空的顺序表{SqList* L = (SqList*)malloc(sizeof(SqList));//定义顺序表Lif(!L){printf("空间划分失败，程序退出\n");return NULL;}L->elem=(ElemType *)malloc(MAXSIZE*sizeof(ElemType));if(!L->elem){printf("空间划分失败，程序退出\n");return NULL;}L->length=0;L->listsize=MAXSIZE;return L;}int CreateList(SqList* L) //创建顺序表（非空）{int number; //顺序表中元素的个数int i; //循环变量printf("请输入顺序表中元素的个数：");scanf("%d",&number);if(number > MAXSIZE) //一定要判断输入的个数是否大于顺序表的最大长度{printf("输入个数大于顺序表的长度\n");return 0;}for(i=0;i<number;i++){printf("输入第%d个数: ",i+1);scanf("%d",L->elem+i); //L->elem+i：每次的输入都保存在顺序表元素中的下一个地址，而不是一直放在元素的首地址}//给顺序表中每个数据元素赋值L->length=number; //当前顺序表的长度return 1;}void print(SqList* L) //遍历顺序表{int i;printf("\n开始遍历顺序表\n");for(i=0;i<L->length;i++){printf("%d",*(L->elem + i)); //L->elem+i：和输入是一个道理}printf("\n遍历结束\n");printf("\n");}int main(){SqList* L = InitList(); //申请一个指向顺序表的指针，并对其初始化if(!L) //判断申请是否成功{printf("初始化线性表失败\n");return 1;}if(!CreateList(L)) //判断创建顺序表是否成功{printf("创建顺序表失败\n");return 1;}print(L); //打印顺序表与上面遍历顺序表相对应，若没有就不遍历free(L->elem); //释放申请的顺序表元素的内存free(L); //释放申请的顺序表内存return 0;}表的有序合并#include <stdio.h>#include <stdlib.h>#define MAXSIZE 100typedef int ElemType;//顺序表结构体的定义typedef struct{ElemType data[MAXSIZE] ;int size;}seqlist;//函数声明void init(seqlist *slt) ;void display(seqlist slt) ;void sort(seqlist *s) ;void combine( seqlist *s1 ,seqlist *s2 ,seqlist *s3) ;//顺序表的初始化函数void init(seqlist *slt){slt->size=0 ;}//顺序表的显示函数void display(seqlist slt){int i;if(!slt.size){printf("\n顺序表为空") ;}else{for(i=0;i<slt.size;i++)printf("\n%d\n",slt.data[i]) ;}}//顺序表排序void sort(seqlist *s){int i ;int j ;int temp ;for(i=0;i<s->size-1;i++){for(j=i+1;j<s->size;j++){if(s->data[i]>=s->data[j]){temp=s->data[i];s->data[i]=s->data[j];s->data[j]=temp;}}}}//两个有序顺序表连接函数void combine(seqlist *s1 , seqlist *s2 , seqlist *s3 ) {int i=0 ;int j=0 ;int k=0 ;while( i < s1->size && j < s2->size) {if(s1->data[i]<=s2->data[j]){s3->data[k]=s1->data[i];i++;}else{s3->data[k]=s2->data[j];j++;}k++;}if(i==s1->size){while(j<s2->size){s3->data[k]=s2->data[j];k++;j++;}}if(j==s2->size){while(i<s1->size){s3->data[k]=s1->data[i];k++;i++;}}s3->size=k;}//主函数int main(){int i ;int j ;int x ;int n ;seqlist list1 ;seqlist list2 ;seqlist list3 ;init(&list1);printf("第一个顺序表元素个数：\n"); scanf("%d" ,&n) ;printf("第一个顺序表输入：\n");for(i=0 ; i<n ; i++){scanf("%d",&list1.data[i]) ;list1.size++ ;}sort(&list1);//第一个表排序init(&list2);printf("第二个顺序表元素个数：\n"); scanf("%d" ,&n) ;printf("第二个顺序表输入：\n");for(i=0 ; i<n ; i++){scanf("%d",&list2.data[i]) ;list2.size++ ;}sort(&list2);//第二个表排序init(&list3) ;combine(&list1 ,&list2 ,&list3) ;printf("表一与表二连接后:\n") ;display(list3) ;return 0;}。

实验报告课程数据结构及算法实验项目 1.顺序表的建立和基本运算成绩专业班级*** 指导教师***姓名*** 学号*** 实验日期***实验一顺序表的建立和基本运算一、实验目的1、掌握顺序表存储结构的定义及C/C++语言实现2、掌握顺序表的各种基本操作及C/C++语言实现3、设计并实现有序表的遍历、插入、删除等常规算法二、实验环境PC微机，Windows，DOS，Turbo C或者Visual C++三、实验内容1、顺序表的建立和基本运算（1）问题描述顺序表时常进行的运算包括：创建顺序表、销毁顺序表、求顺序表的长度、在顺序表中查找某个数据元素、在某个位置插入一个新数据元素、在顺序表中删除某个数据元素等操作。

试编程实现顺序表的这些基本运算。

（2）基本要求实现顺序表的每一个运算要求用一个函数实现。

（3）算法描述参见教材算法2.3、算法2.4、算法2.5等顺序表的常规算法。

（4）算法实现#include<malloc.h> // malloc()等#include<stdio.h> // NULL, printf()等#include<process.h> // exit()// 函数结果状态代码#define OVERFLOW -2#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等typedef int Boolean; // Boolean是布尔类型,其值是TRUE或者FALSE//-------- 线性表的动态分配顺序存储结构-----------#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量#define LIST_INCREMENT 2 // 线性表存储空间的分配增量typedef int ElemType;struct SqList{ElemType *elem; // 存储空间基址int length; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(int)为单位)};void InitList(SqList &L) // 算法2.3{ // 操作结果：构造一个空的顺序线性表LL.elem=new ElemType[LIST_INIT_SIZE];if(!L.elem)exit(OVERFLOW); // 存储分配失败L.length=0; // 空表长度为0L.listsize=LIST_INIT_SIZE; // 初始存储容量}void DestroyList(SqList &L){ // 初始条件：顺序线性表L已存在。

数据结构实验一顺序表实验报告一、实验目的本次实验的主要目的是通过实现顺序表的基本操作，深入理解线性表的逻辑结构和存储结构，掌握顺序表的插入、删除、查找等操作的实现方法，提高编程能力和问题解决能力。

二、实验环境本次实验使用的编程语言为 C 语言，编程环境为 Visual Studio 2019。

三、实验原理顺序表是一种线性表的存储结构，它使用一组连续的存储单元依次存储线性表中的元素。

在顺序表中，元素的逻辑顺序与物理顺序是一致的。

顺序表的基本操作包括初始化、插入、删除、查找、遍历等。

在实现这些操作时，需要考虑顺序表的存储空间是否已满、插入和删除元素时元素的移动等问题。

四、实验内容（一）顺序表的定义｀｀｀cdefine MAXSIZE 100 ／／定义顺序表的最大长度typedef struct ｛int dataMAXSIZE; ／／存储顺序表的元素int length; ／／顺序表的当前长度｝ SeqList;｀｀｀（二）顺序表的初始化｀｀｀cvoid InitList(SeqList L) ｛L>length ＝ 0;｝｀｀｀（三）顺序表的插入操作｀｀｀cint InsertList(SeqList L, int i, int e) ｛if （L>length ＝＝ MAXSIZE) ｛／／顺序表已满return 0;｝if （i ＜ 1 ｜｜ i ＞ L>length ＋ 1) ｛／／插入位置不合法return 0;｝for （int j ＝ L>length; j ＞＝ i; j) ｛／／移动元素L>dataj ＝ L>dataj 1;｝L>datai 1 ＝ e; ／／插入元素L>length+＋；return 1;｝｀｀｀（四）顺序表的删除操作｀｀｀cint DeleteList(SeqList L, int i, int e) ｛if （L>length ＝＝ 0) ｛／／顺序表为空return 0;｝if （i ＜ 1 ｜｜ i ＞ L>length) ｛／／删除位置不合法｝e ＝ L>datai 1; ／／取出被删除的元素for （int j ＝ i; j ＜ L>length; j+＋）｛／／移动元素L>dataj 1 ＝ L>dataj;｝L>length;return 1;｝｀｀｀（五）顺序表的查找操作｀｀｀cint SearchList(SeqList L, int e) ｛for （int i ＝ 0; i ＜ Llength; i+＋）｛if （Ldatai ＝＝ e) ｛return i ＋ 1;｝｝｝｀｀｀（六）顺序表的遍历操作｀｀｀cvoid TraverseList(SeqList L) ｛for （int i ＝ 0; i ＜ Llength; i+＋）｛printf(＂％d ＂， Ldatai)；｝printf(＂＼n"）；｝｀｀｀五、实验步骤1、打开 Visual Studio 2019，创建一个新的 C 语言项目。

实验题目：顺序表的合并一、实验目的掌握顺序表的基本操作理解并分析算法的时间复杂度二、实验内容：实现两个有序（从小到大）的顺序表合并成为一个顺序表，合并后的结果放在第一个顺序表中（假设这两个有序顺序表中没有两个相同的元素）。

三、设计与编码1、基本思想从第二个表中从小到大依次取出一个元素与第一个表中的元素逐个进行比较，如果遇到第一个比它小的数就插到这个数后面，直到第二个表全部比较完。

2、编码#include <stdlib.h>#include <iostream.h>const int MaxSize=100; //100只是示例性的数据，可以根据实际问题具体定义class SeqList{public:SeqList(); //无参构造函数SeqList(int a[], int n); //有参构造函数~SeqList(){} //析构函数为空int Length(){return length;} //求线性表的长度int Get(int i); //按位查找，取线性表的第i个元素friend void MergeList(SeqList &A,SeqList B); //合并顺序表void PrintList(); //遍历线性表，按序号依次输出各元素private:int data[MaxSize]; //存放数据元素的数组int length; //线性表的长度};SeqList::SeqList(int a[],int n){if(n>MaxSize)cout<<"参数非法";for(int i=0;i<n;i++){data[i]=a[i];length=n;}}int SeqList::Get(int i){if (i<1||i>length) throw "查找位置非法";else return data[i-1];int x=data[i-1];}void SeqList::PrintList(){for(int i=0;i<length;i++)cout<<data[i]<<" ";cout<<endl;}void MergeList(SeqList &A,SeqList B){int a;for (int i=0;i<B.length;i++){a=-1;for(int j=0;j<A.length;j++){if (B.data[i]<A.data[j]){a=j;break;}}if(a==-1){A.data[A.length]=B.data[i];A.length++;}else{for(int k=A.length-1;k>=a;k--)A.data[k+1]=A.data[k];A.data[a]=B.data[i];A.length++;}}}void main(){int a[100];int n=4;for(int i=0;i<n;i++ ){cin>>a[i];}int b[100];int m=4;for(int j=0;j<m;j++ ){cin>>b[j];}SeqList La(a,4),Lb(b,4);La.PrintList ();Lb.PrintList ();MergeList(La,Lb);La.PrintList ();}四、调试与运行1、调试时遇到的主要问题及解决遇到的主要问题：没有把找到的位置用一个变量记下解决方法：通过请教同学2、运行结果（输入及输出，可以截取运行窗体的界面）五、实验心得写程序的过程中如果卡住了就一定要请教一下同学，不要一错再错，也许一经过同学提醒就一下子懂了，胜过你一直在那儿磨。