顺序表的基本操作

合集下载

顺序表基本操作

实验1：顺序表实验(4学时)一．实验目的1．学会定义线性表的顺序存储类型，实现C程序的基本结构对线性表的一些基本操作和具体的函数定义。

2．掌握顺序表的基本操作，实现顺序表的插入，删除，查找基本运算。

3．掌握对于多函数程序的输入，编辑，调试和运算过程。

二．实验要求1．预习C语言中结构体的定义和基本的操作方法。

2．对顺序表每个基本操作用一个单独函数实现。

3．编写完整程序完成下面实验内容并且上机运行。

三．实验内容编写完整程序完成下面基本操作并且上机运行1．初始化顺序表La；2．将顺序表La设置为空表；3．测试顺序表La是否上空表；4．在顺序表La插入一个新元素；5．删除顺序表La中某个元素；6. 在顺序表La中查找某个元素，查找成功，返回位序，否则返回0；7. 建立顺序表La；8. 打印顺序表La所有元素；9. 输入n个元素建立顺序表La；10. 归并非递减表La和Lb成为非递减表Lc要求编写一个主菜单调用上面各个基本操作。

;程序：#include <stdio.h>#include <conio.h>#include <stdlib.h>#define LIST_INIT_SIZE 10#define LISTINCREMENT 3#define TRUE 1#define FALSE 0#define OK 1#define ERROR -1#define OVERFLOW -2typedef int status;typedef int Elemtype;typedef struct {int *elem;int length;int listsize;}sqlist;status Printf_sq(sqlist *L){if(!L) return ERROR;else for(int i=0;i<L->length;i++)printf("%d",L->elem[i]);return OK;}status InitList_Sq(sqlist *L) {L->elem=(Elemtype *)malloc(LIST_INIT_SIZE*sizeof(Elemtype));if(!L->elem) return ERROR;//如果用exit的话一但退出就退出整个程序L->length=0;L->listsize=LIST_INIT_SIZE;L->elem[0]=0;L->elem[1]=1;L->elem[2]=2;L->length=3;Printf_sq(L);return OK; }status ClearList_sq(sqlist *L){L->length=0;Printf_sq(L);return OK;}status ListEmpty_sq(sqlist *L){if(L->length==0) return OK;else return ERROR;}status ListInsert_sq(sqlist *L,int i,int e){int *q,*p;if (i<1 || i>L->length+1)return ERROR;if (L->length >= L->listsize) {int *newbase;newbase = (Elemtype *) realloc(L->elem, (L->listsize + LISTINCREMENT) * sizeof (Elemtype));L->elem = newbase;L->listsize += LISTINCREMENT;}q = &(L->elem[i-1]);for (p=&(L->elem[L->length-1]);p>=q;--p)*(p+1)=*p;*q = e;++L->length;Printf_sq(L);return OK;}status ListDelete_sq(sqlist *L,int i,int e){int *q,*p;if((i<1)||(i>L->length)) return ERROR;p=&(L->elem[i-1]);e=*p;q=L->elem+L->length-1;for(++p;p<=q;++p)*(p-1)=*p;--L->length;Printf_sq(L);return OK;}status LocateElem_sq(sqlist *L, int e){for(int i=0;i<L->listsize;i++){if(L->elem[i]==e)return i;if(i==LIST_INIT_SIZE)return OVERFLOW;}return OK;}status Creat_sq(sqlist *L){L->elem=(Elemtype *)malloc(LIST_INIT_SIZE*sizeof(Elemtype)); if(!L->elem) return ERROR;L->length=0;L->listsize=LIST_INIT_SIZE;L->elem[0]=0;L->elem[1]=1;L->elem[2]=2;L->length=3;Printf_sq(L);return OK;}void MergeList_Sq(sqlist La, sqlist Lb, sqlist &Lc) {int *pa,*pb,*pc,*pa_last,*pb_last;pa = La.elem; pb = Lb.elem;Lc.listsize = Lc.length = La.length+Lb.length;pc = Lc.elem = (Elemtype *)malloc(Lc.listsize*sizeof(Elemtype)); if (!Lc.elem)exit(OVERFLOW);pa_last = La.elem+La.length-1;pb_last = Lb.elem+Lb.length-1;while (pa <= pa_last && pb <= pb_last) {if (*pa <= *pb) *pc++ = *pa++;else *pc++ = *pb++;}while (pa <= pa_last) *pc++ = *pa++;while (pb <= pb_last) *pc++ = *pb++;Printf_sq(&Lc);}void main(){int e=1;int i=1;sqlist La,Lb,Lc,Ld,Le,Lf,Lg,Lh;InitList_Sq( &La);InitList_Sq( &Lb);InitList_Sq( &Lc);InitList_Sq( &Ld);InitList_Sq( &Le);InitList_Sq( &Lf);InitList_Sq( &Lg);InitList_Sq( &Lh);ClearList_sq(&Lb);ListEmpty_sq(&Lc);ListInsert_sq(&Ld,i,e);ListDelete_sq(&Le,i,e);LocateElem_sq(&Lf, e);Creat_sq(&Lg);Printf_sq(&Lg);MergeList_Sq(La, Lb, Lh);}实验2：单链表实验(6学时)一实验目的1．学会定义线性表的链表存储类型，实现C程序的基本结构对线性表的一些基本操作和具体的函数定义。

java顺序表的基本操作代码

Java顺序表的基本操作代码一、什么是顺序表顺序表（Sequential List）是一种常见的线性数据结构，它由一组按照顺序存储的元素组成，其中每个元素都有唯一的索引值。

顺序表中的元素在物理存储上是连续的。

在Java中，顺序表可以通过数组进行实现，也可以通过ArrayList类来实现。

本文将分别介绍这两种实现方式。

二、数组实现顺序表1. 创建顺序表int[] array = new int[capacity];int size = 0;上述代码创建了一个容量为capacity的整型数组array，同时将顺序表的大小初始化为0。

2. 插入元素在顺序表的末尾插入元素：public void addLast(int element) {if (size == array.length) {// 扩容操作int[] newArray = new int[array.length * 2];System.arraycopy(array, 0, newArray, 0, array.length);array = newArray;}array[size] = element;size++;}在指定位置插入元素：public void add(int index, int element) {if (index < 0 || index > size) {throw new IndexOutOfBoundsException();}if (size == array.length) {// 扩容操作int[] newArray = new int[array.length * 2];System.arraycopy(array, 0, newArray, 0, index);System.arraycopy(array, index, newArray, index + 1, size - index); array = newArray;} else {System.arraycopy(array, index, array, index + 1, size - index);}array[index] = element;size++;}3. 删除元素删除末尾元素：public void removeLast() {if (size == 0) {throw new NoSuchElementException();}size--;}删除指定位置的元素：public void remove(int index) {if (index < 0 || index >= size) {throw new IndexOutOfBoundsException();}System.arraycopy(array, index + 1, array, index, size - index - 1);size--;}4. 获取元素获取指定位置的元素：public int get(int index) {if (index < 0 || index >= size) {throw new IndexOutOfBoundsException();}return array[index];}修改指定位置的元素：public void set(int index, int element) {if (index < 0 || index >= size) {throw new IndexOutOfBoundsException();}array[index] = element;}5. 查询元素查找指定元素的索引：public int indexOf(int element) {for (int i = 0; i < size; i++) {if (array[i] == element) {return i;}}return -1;}判断顺序表是否为空：public boolean isEmpty() {return size == 0;}三、ArrayList实现顺序表ArrayList是Java提供的一个动态数组类，它实现了List接口，可以方便地进行顺序表的操作。

codeblock数据结构算法实现-顺序表基本操作

数据结构算法实现-顺序表基本操作序号一、引言二、顺序表的定义三、顺序表的基本操作1.初始化操作2.插入操作3.删除操作4.查找操作四、顺序表的实现五、总结一、引言数据结构是计算机科学中非常重要的一部分，它是计算机存储、组织数据的方式。

而顺序表是其中的一种基本数据结构，它采用一组位置区域连续的存储单元依次存放线性表中的元素。

本文将着重介绍顺序表的基本操作及其算法实现。

二、顺序表的定义顺序表是一种基本的线性表，顺序表中元素的逻辑顺序和物理顺序是一致的。

顺序表的特点是利用一组连续的存储单元依次存放线性表中的元素。

顺序表可以用数组实现，其元素在内存中是连续存储的，可以通过下标直接访问元素。

由于顺序表的存储方式，使得其在查找、插入和删除等操作上具有较好的性能。

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

下面分别介绍这些操作的实现方法。

1.初始化操作初始化操作是指将一个空的顺序表初始化为一个具有初始容量的顺序表，并为其分配内存空间。

初始化操作的实现方法主要有两种，一种是静态分配内存空间，另一种是动态分配内存空间。

静态分配内存空间时，需要预先指定顺序表的容量大小，然后在程序中创建一个数组，并为其分配指定大小的内存空间。

动态分配内存空间时，可以根据需要动态创建一个数组，并为其分配内存空间。

下面是一个简单的初始化操作的实现示例：```C代码#define MAXSIZE 100 // 定义顺序表的最大容量typedef struct {ElementType data[MAXSIZE]; // 定义顺序表的元素数组int length; // 定义顺序表的当前长度} SeqList;2.插入操作插入操作是指将一个新元素插入到顺序表的指定位置。

插入操作的实现方法主要包括在指定位置插入元素，同时对其他元素进行后移操作。

下面是一个简单的插入操作的实现示例：```C代码Status Insert(SeqList *L, int i, ElementType e) {if (i < 1 || i > L->length + 1) { // 判断插入位置是否合法return ERROR;}if (L->length >= MAXSIZE) { // 判断顺序表是否已满return ERROR;}for (int j = L->length; j >= i; j--) { // 插入位置及之后的元素后移L->data[j] = L->data[j - 1];}L->data[i - 1] = e; // 插入新元素L->length++; // 顺序表长度加1return OK;}```3.删除操作删除操作是指将顺序表中指定位置的元素删除。

java顺序表的基本操作代码

java顺序表的基本操作代码Java顺序表是一种基于数组实现的线性结构，具有随机访问、元素插入和删除等基本操作。

在Java中，我们可以通过定义一个数组来创建一个顺序表，并通过编写一些基本操作代码来实现对该顺序表的操作。

一、顺序表的定义和初始化在Java中，我们可以通过定义一个数组来创建一个顺序表。

下面是一个简单的代码示例：```public class SeqList<T> {private Object[] elementData; // 存储元素的数组private int size; // 当前元素个数// 构造函数public SeqList(int capacity) {elementData = new Object[capacity];size = 0;}}```在上述代码中，我们定义了一个SeqList类，其中包含了存储元素的数组elementData和当前元素个数size两个成员变量。

构造函数SeqList(int capacity)用于创建指定长度为capacity的数组，并将当前元素个数初始化为0。

二、顺序表的插入操作1. 在指定位置插入元素在Java中，我们可以通过下标来访问数组中的元素。

因此，在进行插入操作时，需要先将要插入位置之后的所有元素向后移动一位，然后再将新元素插入到指定位置上。

下面是一个简单的代码示例：```// 在指定位置插入元素public void insert(int index, T element) {if (index < 0 || index > size) {throw new IndexOutOfBoundsException("插入位置越界"); }// 判断数组是否已满，若已满则扩容if (size == elementData.length) {ensureCapacity(size * 2);}// 将要插入位置之后的所有元素向后移动一位for (int i = size - 1; i >= index; i--) {elementData[i + 1] = elementData[i];}// 插入新元素elementData[index] = element;size++;}// 扩容方法private void ensureCapacity(int minCapacity) {if (minCapacity > elementData.length) {Object[] newArray = new Object[minCapacity];System.arraycopy(elementData, 0, newArray, 0, size);elementData = newArray;}}```在上述代码中，我们首先判断要插入的位置是否越界。

顺序表的基本操作-完整代码和拆开分析

顺序表的基本操作-完整代码和拆开分析1 #include<stdio.h> //增+删+改+初始化+输出2 #include<stdlib.h>3#define MaxSize 10 此数决定了后⾯插⼊数据的多少，超过该数字输出顺序表的时候不是正确的数4 typedef int ElementType;5struct SqList {6 ElementType elem[MaxSize];7int Length;8 };910 typedef struct SqList *PtrNode;11 typedef PtrNode List;1213 List InitList();14int InSert(List L, int i, ElementType x) ;15int Delete(List L, int i);16int GetElem(List L, int i);17int Print(List L);1819int main() {20int a;21 ElementType x;22 List list;23 list=InitList();24 InSert(list, 1, 1);25 InSert(list, 2, 2);26 InSert(list, 3, 3);27 Print(list);28 printf("第⼀处的元素为:%d\n",GetElem(list,1));29 printf("要删除第⼏处的数据");30 scanf("%d", &a);31 Delete(list, a);32 Print(list);33 }34 List InitList() { //初始化35 List L;36 L = (List)malloc(sizeof(struct SqList));37 L->Length = 0;38 printf("初始化成功\n");39return L;40 }41//插⼊42int InSert(List L, int i, ElementType x) {43int j;44if (i<1 || i>L->Length + 1) {45 printf("越界"); return0;46 }47for (j = L->Length; j >= i; j--) {48 L->elem[j] = L->elem[j-1]; L—>elem[j+1]=L->elem[j];是错误的，j是数组长度，⽤作数组索引时要⼩⼼，所以上⾯的条件不应该是j>i49 }50 L->elem[i - 1] = x; //第i处，因为是数组所以减⼀51 L->Length++;52return1;53 }54//删除55int Delete(List L, int i) {56int j;57if (i<1 || i>L->Length) {58 printf("越界"); return0;59 }60for (j = i - 1; j < L->Length-1; j++)61 L->elem[j] = L->elem[j+1];62 L->Length--;63return1;6465 }66//查找第i处的数据67int GetElem(List L, int i) {68if (i<1 || i>L->Length) {69 printf("越界"); return0;70 }71return L->elem[i - 1];72 }73//遍历输出74int Print(List L) {75int i = 0;76for (i; i < L->Length; i++)77 printf("%d\n", L->elem[i]);78 }1. 初始化：1 List InitList() { //初始化2 List L;3 L = (List)malloc(sizeof(struct SqList));4 L->Length = 0;5 printf("初始化成功\n");6return L;7 }（1）malloc开辟空间，L指向该空间（2）空间的Length属性赋值为零；2.插⼊：int InSert(List L, int i, ElementType x) {43int j;44if (i<1 || i>L->Length + 1) {45 printf("越界"); return0;46 }47for (j = L->Length; j > i; j--) {48 L->elem[j + 1] = L->elem[j];49 }此处错误，修改见上⾯完整代码50 L->elem[i - 1] = x; //第i处，因为是数组所以减⼀51 L->Length++;52return1;53 }（1）判断输⼊的待插⼊位置是否合理------要插⼊的位置是否⼩于1，或者⼤于顺序表的长度Length+1【与其他的不同：可以在Length+1位置插⼊】（2）如果不满⾜（1），则循环赋值------从顺序表最后⼀个位置开始，从后向前依次将前⼀个位置的值赋给后⼀个位置（3）插⼊待插⼊数x-------将x赋值给待插⼊位置（4）顺序表长度加⼀3.删除：int Delete(List L, int i) {56int j;57if (i<1 || i>L->Length) {58 printf("越界"); return0;59 }60for (j = i - 1; j < L->Length-1; j++)61 L->elem[j] = L->elem[j+1];62 L->Length--;63return1;6465 }（1）判断输⼊的待插⼊位置是否合理------要插⼊的位置是否⼩于1，或者超出顺序表的长度Length（2）如果不满⾜（1），则循环赋值-------从待删除位置开始，从前向后依次将后⼀个位置的值赋值给前⼀个位置（3）顺序表长度减⼀4.查找：67int GetElem(List L, int i) {68if (i<1 || i>L->Length) {69 printf("越界"); return0;70 }71return L->elem[i - 1];72 }（1）判断输⼊的待插⼊位置是否合理------要插⼊的位置是否⼩于1，或者超出顺序表的长度Length（2）直接根据数组下标返回该值5.输出：74int Print(List L) {75int i = 0;76for (i; i < L->Length; i++)77 printf("%d\n", L->elem[i]);78 }根据数组下标直接循环输出**********************************************Tips:初始化和查找必须有返回值（初始化要将创建的顺序表名返回；查找要将找到的值返回），其他函数可以不设返回值或者返回1。

数据结构(c语言版)课后习题答案完整版

数据结构(c语言版)课后习题答案完整版数据结构(C语言版)课后习题答案完整版一、数据结构概述数据结构是计算机科学中一个重要的概念，用来组织和存储数据，使之可以高效地访问和操作。

在C语言中，我们可以使用不同的数据结构来解决各种问题。

本文将提供完整版本的C语言数据结构的课后习题答案。

二、顺序表1. 顺序表的定义和基本操作顺序表是一种线性表，其中的元素在物理内存中连续地存储。

在C 语言中，我们可以通过定义结构体和使用指针来实现顺序表。

以下是顺序表的一些基本操作的答案：（1）初始化顺序表```ctypedef struct{int data[MAX_SIZE];int length;} SeqList;void InitList(SeqList *L){L->length = 0;}```（2）插入元素到顺序表中```cbool Insert(SeqList *L, int pos, int elem){if(L->length == MAX_SIZE){return false; // 顺序表已满}if(pos < 1 || pos > L->length + 1){return false; // 位置不合法}for(int i = L->length; i >= pos; i--){L->data[i] = L->data[i-1]; // 向后移动元素 }L->data[pos-1] = elem;L->length++;return true;}```（3）删除顺序表中的元素```cbool Delete(SeqList *L, int pos){if(pos < 1 || pos > L->length){return false; // 位置不合法}for(int i = pos; i < L->length; i++){L->data[i-1] = L->data[i]; // 向前移动元素 }L->length--;return true;}```（4）查找顺序表中的元素```cint Search(SeqList L, int elem){for(int i = 0; i < L.length; i++){if(L.data[i] == elem){return i + 1; // 找到元素，返回位置 }}return -1; // 未找到元素}```2. 顺序表习题解答（1）逆置顺序表```cvoid Reverse(SeqList *L){for(int i = 0; i < L->length / 2; i++){int temp = L->data[i];L->data[i] = L->data[L->length - 1 - i]; L->data[L->length - 1 - i] = temp;}}```（2）顺序表元素去重```cvoid RemoveDuplicates(SeqList *L){for(int i = 0; i < L->length; i++){for(int j = i + 1; j < L->length; j++){if(L->data[i] == L->data[j]){Delete(L, j + 1);j--;}}}}```三、链表1. 单链表单链表是一种常见的链式存储结构，每个节点包含数据和指向下一个节点的指针。

顺序表的基本操作实验报告

湖南第一师范学院信息科学与工程系实验报告课程名称：数据结构与算法成绩评定：实验项目名称：顺序表的基本操作指导教师：王杰文学生姓名：沈丽桃学号：10403080118 专业班级：教育技术实验项目类型：验证性实验地点：科B305 实验时间： 2011年 10月8 日一、实验目的与要求：实验目的：实现顺序表的创建、查找、插入、删除与输出基本原理：顺序表的基本操作二、实验环境：（硬件环境、软件环境）1.硬件环境：奔ⅣPC。

2.软件环境：Windows XP 操作系统，TC2.0或VC＋＋。

三、实验内容：（原理、操作步骤、程序代码等）#include<stdio.h># define maxlength 100 /#后不应该有空格/struct LIST{int elements[maxlength];int last;}L;typedef int position;void main(){position p,p1; /p和x最好赋值/int x,x1,i,choice;position Locate(int x,struct LIST*y);void Insert(int x,position p,struct LIST*y);void Delete(position p,struct LIST *y);printf("option:Locate 1,Insert 2,Delete 3\n");printf("please choice:");scanf("%d",&choice);switch(choice){case 1:{printf("please input a number:");scanf("%d",&x);p1=Locate(x,&L);if(p1==101)printf(“the number does not exist”);else printf("the position is:%d",p1); /break；/}case 2:{printf("please input a numer:");scanf("%d",x1); /x1钱应加取地址符&/printf("please input the position:");scanf("%d",&p);Insert(x1,p,&L);for(i=0;i<=st;i++)printf("%d",L.elements[i]);printf("\n"); /break；/}case 3:{printf("please input the position:");scanf("%d",&p);Delete(p,&L);for(i=0;i<=st;i++)printf("%d",L.elements[i]);printf("\n"); /break；/}}position Locate(int x,struct LIST*y) /把变量x改为m/{int q;if(st>maxlength-1)printf("error:list is full");else if((p>st)||(p<1))printf("error:position does not exist");else{for(q=1;q<st;q++){if(elements[q]==x) /x改为m/（主要错误是elements[q]应改为L.elements[q] return q;else return 101;}}}void Insert(int x,position p,struct LIST*y){position q;if(st>maxlength-1)printf("error:list is full");else if((p>st)||(p<1))printf("error:position does not exist");else{for(q=st;q>=p;q--){L.elements[q+1]=L.elements[q];st=st+1;L.elements[q]=x;}}}Void Delete(position p,struct LIST*y) /这个问题重复出现，V要改为小写/ {position q;if(st>maxlength-1)printf("error:list is full");else if((p>st)||(p<1))printf("error:position does not exist");else{st=st-1;for(q=p;q<=st;q++)L.elements[q]=L.elements[q+1];}}error C2146:syntax error:missing’)’before identifier’p’error C2081:’position’:name in formal parameter list illegalerror C2146:syntax error:missing’:’before identifier’p’error C2059:syntax error:’type’error C2059:syntax error:’)’error C2143:syntax error:missing’;’before’type’warning C4020:’Insert’:too many actual parameterswarning C4013:’delete’undefined;assuming extern returning interror C2065:’position’:undeclared identifiererror C2146:syntax error:missing’)’before identifier ‘Locate’error C2143:syntax error:missing’)’before ‘type’error C2198:’Locate’:too few avtual parameterserror C2059:syntax error:’)’error C2065:’q’:undeclared identifiererror C2065:’elements’:undeclared identifiererror C2109:subscript requires array or pointer typewarning C4098:’main’:’void’function returning a valuewarning C4098:’main’:’void’function returning a valueerror C2146:syntax error:missing’);before identifier ’p’error C2081:’position’:name in formal parameter list illegalerror C2061:syntax error:identifier’p’error C2059:syntax error:’;’error C2059:syntax error:’,’error C2059:syntax error :’)’四、实验体会# define maxlength 100 /#后不应该有空格/要先对数组进行初始化，存入一些数据position p,p1; /p和x最好赋值/scanf("%d",x1); /x1钱应加取地址符&/if(elements[q]==x) /x改为m/（主要错误是elements[q]应改为L.elements[q]Void Delete(position p,struct LIST*y) /这个问题重复出现，V要改为小写/switch每个case语句写完要加break;一开始不知所措，首先应该有一个大的方向，把主程序编号，再逐步求精，落实到每一个函数的编写。

实验一顺序表的基本操作实验报告

元素之后的所有数据都前移一个位置，最将线性表长减1。

3．顺序表查找操作的基本步骤：要在顺序表中查找一个给定值的数据元素则可以采用顺序查找的方法，从表中第 1 个数据元素开始依次将值与给定值进行比较，若相等则返回该数据元素在顺序表中的位置，否则返回0 值。

线性表的动态分配顺序存储结构—C语言实现#define MaxSize 50//存储空间的分配量Typedef char ElemType；Typedef struct{ElemType data[MaxSize];int length; //表长度（表中有多少个元素）}SqList;动态创建一个空顺序表的算法：void InitList(SqList *&L) //初始化线性表{L=(SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间L->length=0; //置空线性表长度为0}线性表的插入：status Sqlist_insert(Sqlist &L,int i,Elemtype x)/*在顺序表L中第i个元素前插入新元素x*/{ if (i<1||i>L.length+1) return ERROR; /*插入位置不正确则出错*/if (L.length>=MAXLEN)return OVERFLOW;/*顺序表L中已放满元素，再做插入操作则溢出*/for(j=L.length-1;j>=i-1;j--)L.elem[j+1]=L.elem[j]; /*将第i个元素及后续元素位置向后移一位*/L.elem[i-1]=x; /*在第i个元素位置处插入新元素x*/L.length++; /*顺序表L的长度加1*/return OK;}线性表的删除：status Sqlist_delete(Sqlist &L,int i,Elemtype &e)/*在顺序表L中删除第i个元素*{ if (i<1||i>L.length) return ERROR; /*删除位置不正确则出错*/for(j=i;j<=L.length-1;j++)L.elem[j-1]=L.elem[j]; /*将第i+1个元素及后继元素位置向前移一位*/L.length--;/*顺序表L的长度减1*/return OK；}线性表元素的查找：int LocateElem(SqList *L, ElemType e) //按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++; //查找元素eif (i>=L->length) //未找到时返回0return 0;elsereturn i+1; //找到后返回其逻辑序号}输出线性表：void DispList(SqList *L) //输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}输出线性表第i个元素的值：bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false; //参数错误时返回falsee=L->data[i-1]; //取元素值return true; //成功找到元素时返回true}代码：#include <stdio.h>#include <malloc.h>#define MaxSize 50typedef char ElemType;typedef struct{ElemType data[MaxSize];int length;} SqList;void InitList(SqList *&L);void DestroyList(SqList *L);bool ListEmpty(SqList *L);int ListLength(SqList *L);void DispList(SqList *L);bool GetElem(SqList *L,int i,ElemType &e);int LocateElem(SqList *L, ElemType e);bool ListInsert(SqList *&L,int i,ElemType e);bool ListDelete(SqList *&L,int i,ElemType &e);void InitList(SqList *&L)//初始化线性表{L=(SqList *)malloc(sizeof(SqList));//分配存放线性表的空间L->length=0;//置空线性表长度为0 }void DestroyList(SqList *L)//销毁线性表{free(L);}bool ListEmpty(SqList *L)//判线性表是否为空表{return(L->length==0);}int ListLength(SqList *L)//求线性表的长度{return(L->length);}void DispList(SqList *L)//输出线性表{int i;if (ListEmpty(L)) return;for (i=0;i<L->length;i++)printf("%c ",L->data[i]);printf("\n");}bool GetElem(SqList *L,int i,ElemType &e)//求线性表中某个数据元素值{if (i<1 || i>L->length)return false;//参数错误时返回falsee=L->data[i-1];//取元素值return true;//成功找到元素时返回true}int LocateElem(SqList *L, ElemType e)//按元素值查找{int i=0;while (i<L->length && L->data[i]!=e)i++;//查找元素eif (i>=L->length)//未找到时返回0return 0;elsereturn i+1;//找到后返回其逻辑序号}bool ListInsert(SqList *&L,int i,ElemType e)//插入数据元素{int j;if (i<1 || i>L->length+1)return false;//参数错误时返回falsei--;//将顺序表逻辑序号转化为物理序号for (j=L->length;j>i;j--)//将data[i]及后面元素后移一个位置L->data[j]=L->data[j-1];L->data[i]=e;//插入元素eL->length++;//顺序表长度增1return true;//成功插入返回true}bool ListDelete(SqList *&L,int i,ElemType &e)//删除数据元素{int j;if (i<1 || i>L->length)//参数错误时返回falsereturn false;i--;//将顺序表逻辑序号转化为物理序号e=L->data[i];for (j=i;j<L->length-1;j++)//将data[i]之后的元素前移一个位置L->data[j]=L->data[j+1];L->length--;//顺序表长度减1return true;//成功删除返回true}void main(){SqList *L;ElemType e;printf("顺序表的基本运算如下:\n");printf(" (1)初始化顺序表L\n");InitList(L);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");ListInsert(L,1,'a');ListInsert(L,2,'b');ListInsert(L,3,'c');ListInsert(L,4,'d');ListInsert(L,5,'e');printf(" (3)输出顺序表L:");DispList(L);printf(" (4)顺序表L长度=%d\n",ListLength(L));printf(" (5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));GetElem(L,3,e);printf(" (6)顺序表L的第3个元素=%c\n",e);实验结果：心得体会：通过本次实验，实现了数据结构在程序设计上的作用，了解了数据结构语言，加深了对c语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法，掌握顺序表基本操作的算法实现，同时了解了顺序表的应用。

数据结构中顺序表的基本操作

数据结构中顺序表的基本操作
顺序表是一种线性表的存储结构，使用一组连续的存储单元来存储元素，其基本操作包括：
1. 初始化：创建一个空顺序表，设置其长度为0。

2. 插入元素：在顺序表的指定位置插入一个元素，需要将插入位置之后的元素依次向后移动，然后将新元素放入插入位置，并更新顺序表的长度。

3. 删除元素：删除顺序表中的指定位置的元素，需要将删除位置之后的元素依次向前移动，然后更新顺序表的长度。

4. 查找元素：根据元素的值，查找顺序表中第一个与该值相等的元素，并返回其位置。

如果不存在，则返回-1。

5. 获取元素：根据位置，返回顺序表中指定位置的元素。

6. 修改元素：根据位置，修改顺序表中指定位置的元素。

7. 清空顺序表：将顺序表的长度设置为0，即清空元素。

这些基本操作可以根据具体需求进行使用和扩展。

顺序表的基本操作与应用实验报告

实验报告课程名称数据结构实验名称顺序表基本操作与应用姓名专业班级学号试验日期试验地点E3-502指导老师邹汉斌成绩一、实验目的1.学会定义线性表的顺序存储类型，实现C程序的基本结构，对线性表的一些基本操作和具体的函数定义。

2.掌握顺序表的基本操作，实现顺序表的插入、删除、查找以及求并集等运算。

3.掌握对多函数程序的输入、编辑、调试和运行过程。

二、实验要求1．预习C语言中结构体的定义与基本操作方法。

2．对顺序表的每个基本操作用单独的函数实现。

3．编写完整程序完成下面的实验内容并上机运行。

4．整理并上交实验报告。

三、实验内容：1．编写程序实现顺序表的下列基本操作：(1) 初始化顺序表La；(2) 将La置为空表；(3) 销毁La (4) 在La中插入一个新的元素；(5) 删除La中的某一元素；(6) 在La中查找某元素，若找到，则返回它在La中第一次出现的位置，否则返回0 ；(7) 打印输出La中的元素值。

2．定义一个包含学生信息（学号，姓名，成绩）的顺序表，使其具有如下功能：(1) 根据指定学生个数，逐个输入学生信息；(2) 逐个显示学生表中所有学生的相关信息；(3) 根据姓名进行查找，返回此学生的学号和成绩；(4) 根据指定的位置可返回相应的学生信息（学号，姓名，成绩）；(5) 给定一个学生信息，插入到表中指定的位置；(6) 删除指定位置的学生记录；(7) 统计表中学生个数。

实验提示：第2题可在第1题的基础上将数据结构的定义修改成下面形式后，程序适当修改即可。

学生信息的定义：typedef struct {char no[8]; //8位学号char name[20]; //姓名int score; //成绩}Student;typedef Student ElemType;顺序表的定义typedef struct {ElemType *elem; //指向数据元素的基地址int length; //线性表的当前长度}SqList；四、思考与提高1.编写程序完成下面的操作：（每位同学必做）(1)构造两个顺序线性表La和Lb，其元素都按值非递减顺序排列；(2)实现归并La和Lb得到新的顺序表Lc，Lc的元素也按值非递减顺序排列；(3)假设两个顺序线性表La和Lb 分别表示两个集合A和B，利用union_Sq操作实现A=A∪B。

实验一顺序表的基本操作实验报告

元素之后的所有数据都前移一个位置，最将线性表长减1。

实验1 线性顺序表的基本操作

实验一一、实验目的1、掌握使用VC6.0上机调试线性表的基本方法；2、掌握线性表的基本操作：插入、删除、查找以及线性表合并等运算在顺序存储结构和链接存储结构上的运算。

二、实验要求1、认真阅读和掌握本实验的程序。

2、上机运行本程序。

3、保存和打印出程序的运行结果，并结合程序进行分析。

4、按照你对线性表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果三、注意事项：在磁盘上创建一个目录，专门用于存储数据结构实验的程序。

四、实验内容程序1：线性表基本操作的实现这个程序中演示了顺序表的创建、插入、删除和查找，请修改并完成。

程序如下：#include <stdio.h>#include <stdlib.h>/*顺序表的定义：*/#define ListSize 100typedef struct{ int data[ListSize]; /*向量data用于存放表结点*/int length; /*当前的表长度*/}SeqList;void CreateList(SeqList *L,int n);void PrintList(SeqList *L,int n);int LocateList(SeqList *L,int x);void InsertList(SeqList *L,int x,int i);void DeleteList(SeqList *L,int i);void main(){SeqList L;int i,x;int n=10; /*THE LENGTH OF LIST*/L.length=0;clrscr();CreateList(&L,n); /*CREAT THE LIST*/PrintList(&L,n); /*PRINT THE LIST*/printf("INPUT THE RESEARCH ELEMENT");scanf("%d",&x);i=LocateList(&L,x);printf("the research position is %d\n",i); /*顺序表查找*/printf("input the position of insert:\n");scanf("%d",&i);printf("input the value of insert\n");scanf("%d",&x);InsertList(&L,x,i); /*顺序表插入*/PrintList(&L,n); /*打印顺序表*/printf("input the position of delete\n");scanf("%d",&i);DeleteList(&L,i); /*顺序表删除*/PrintList(&L,n);getch();/*打印顺序表*/}/*顺序表的建立：*/void CreateList(SeqList *L,int n){int i;printf("please input n numbers\n");for(i=1;i<=n;i++){scanf("%d",&L->data[i]);}L->length=n;}/*顺序表的打印：*/void PrintList(SeqList *L,int n){int i;printf("the sqlist is\n");for(i=1;i<=n;i++)printf("%d ",L->data[i]);}/*顺序表的查找：*/int LocateList(SeqList *L,int x){int i;for(i=1;i<=10;i++)if((L->data[i])==x) return(i);else return(0);}/*顺序表的插入：*/void InsertList(SeqList *L,int x,int i){int j;for(j=L->length;j>=i;j--)L->data[j+1]=L->data[j];L->data[i]=x;L->length++;}/*顺序表的删除：*/void DeleteList(SeqList *L,int i) { int j;for(j=i;j<=(L->length)-1;j++)L->data[j]=L->data[j+1];}。

数据结构c++顺序表、单链表的基本操作,查找、排序代码

} return 0; }
实验三查找
实验名称：实验3 查找实验目的：掌握顺序表和有序表的查找方法及算法实现；掌握二叉排序树和哈希表的构造和查找方法。通过上机操作,理解如何科学地组织信息存储,并选择高效的查找算法。实验内容：（2选1）内容1：基本查找算法；内容2：哈希表设计。实验要求：1）在C++系统中编程实现；2）选择合适的数据结构实现查找算法；3）写出算法设计的基本原理或画出流程图；4）算法实现代码简洁明了；关键语句要有注释；5）给出调试和测试结果；6）完成实验报告。实验步骤： (1)算法设计 a.构造哈希函数的方法很多，常用的有(1)直接定址法(2)数字分析法;(3) 平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法；本实验采用的是除留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈希地址 (2)算法实现 hash hashlist[n]; void listname(){ char *f; int s0,r,i; NameList[0].py="baojie"; NameList[1].py="chengቤተ መጻሕፍቲ ባይዱoyang"; ……………………………… NameList[29].py="wurenke"; for(i=0;i<q;i++){s0=0;f=NameList[i].py; for(r=0;*(f+r)!='\0';r++) s0+=*(f+r);NameList[i].k=s0; }} void creathash(){int i;
v[k-1]=v[k]; nn=nn-1; return ; } int main() {sq_LList<double>s1(100); cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.ins_sq_LList(0,1.5); s1.ins_sq_LList(1,2.5); s1.ins_sq_LList(4,3.5); cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.del_sq_LList(0); s1.del_sq_LList(2); cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); return 0; } 运行及结果：

顺序表的基本操作

2.输入5个数，分别为1,2,3,4,5
3.求线性表是否为空：
4.求线性表的长度：
5.输出顺序表的第4个元素：
6.输出第一次出现元素3的位置：
7.向线性表中插入一个元素：
8.删除元素4，并输出
9.输出线性表的元素：
10.在线性表的-1位置插入数据：
11.清空线性表的所有元素
五、实验总结
1.由于线性表是采用的是数组存储，因此，在第i个位置添加或删除
一个元素时，需要移动n-i个位置，其时间复杂度为O(n)
2.顺序表的删除并非真正意义的删除，由于数组的特殊原因，只是
显示的一种“假象”，如果采用动态的扩展空间，可以实现真正意。

数据结构-顺序表的基本操作的实现-课程设计-实验报告

数据结构-顺序表的基本操作的实现-课程设计-实验报告顺序表的基本操作的实现一、实验目的1、掌握使用VC++上机调试顺序表的基本方法；2、掌握顺序表的基本操作：建立、插入、删除等运算。

二、实验仪器安装VC++软件的计算机。

三、实验原理利用线性表的特性以及顺序存储结构特点对线性表进行相关的基本操作四、实验内容程序中演示了顺序表的创建、插入和删除。

程序如下：#include#include/*顺序表的定义：*/#define ListSize 100typedef struct{ int data[ListSize]; /*向量data用于存放表结点*/i nt length; /*当前的表长度*/}SeqList;void main(){ void CreateList(SeqList *L,int n);v oid PrintList(SeqList *L,int n);i nt LocateList(SeqList *L,int x);v oid InsertList(SeqList *L,int x,int i);v oid DeleteList(SeqList *L,int i);SeqList L;i nt i,x;i nt n=10;L.length=0;c lrscr();C reateList(&L,n); /*建立顺序表*/P rintList(&L,n); /*打印建立后的顺序表*/p rintf("INPUT THE RESEARCH ELEMENT");s canf("%d",&x);i=LocateList(&L,x);p rintf("the research position is %d\n",i); /*顺序表查找*/ p rintf("input the position of insert:\n");s canf("%d",&i);p rintf("input the value of insert\n");s canf("%d",&x);I nsertList(&L,x,i); /*顺序表插入*/P rintList(&L,n); /*打印插入后的顺序表*/p rintf("input the position of delete\n");s canf("%d",&i);D eleteList(&L,i); /*顺序表删除*/P rintList(&L,n); /*打印删除后的顺序表*/g etchar();}/*顺序表的建立：*/void CreateList(SeqList *L,int n){int i;printf("please input n numbers\n");for(i=1;i<=n;i++)scanf("%d",&L->data[i]);L->length=n;}/*顺序表的打印：*/void PrintList(SeqList *L,int n){int i;printf("the sqlist is\n");for(i=1;i<=n;i++)printf("%d ",L->data[i]);}/*顺序表的查找：*/int LocateList(SeqList *L,int x){int i;for(i=1;i<=10;i++)if((L->data[i])==x) return(i);else return(0);}/*顺序表的插入：*/void InsertList(SeqList *L,int x,int i){int j;for(j=L->length;j>=i;j--)L->data[j+1]=L->data[j];L->data[i]=x;L->length++;}void DeleteList(SeqList *L,int i) /*顺序表的删除：*/ { int j;for(j=i;j<=(L->length)-1;j++)L->data[j]=L->data[j+1];}五、实验步骤1、认真阅读和掌握本实验的程序。

顺序表的建立、输入、输出、查找、插入、删除（数据结构）

顺序表的建⽴、输⼊、输出、查找、插⼊、删除（数据结构）1.顺序表的基本操作实践。

(1)建⽴4个元素的顺序表list[]={2，3，4，5}，实现顺序表建⽴的基本操作。

(2)在list[]={2，3，4，5}的元素4和5之间插⼊⼀个元素9，实现顺序表插⼊的基本操作。

(3)在list[]={2，3，4，9，5}中删除指定位置（i=3）上的元素4，实现顺序表的删除的基本操作。

#include <stdio.h>#include <stdlib.h>#include <iostream>#define MAXSIZE 10using namespace std;typedef int ElemType;typedef struct {ElemType a[MAXSIZE];int length;} S;void CreatList(S &L) {scanf("%d", &L.length);for(int i = 1; i <= L.length; i ++) scanf("%d",&L.a[i]);} //创建列表void PutList(S L) {for(int i = 1; i <= L.length; i ++) {printf("%d ",L.a[i]);}printf("\n");} //输出列表void InserElem(S &L, int i, ElemType x) { j iif(i < 1 || i > L.length) return; 2 3 4 5 9for(int j = L.length+1; j > i; j --) { j-1jL.a[j] = L.a[j-1]; 2 3 4 9 5}L.a[i] = x;L.length++;} //插⼊void DeleElem(S &L, int i) {for(int j = i; j < L.length; j ++) {L.a[j] = L.a[j+1]; j j+1} 2 3 4 9 5L.length--;}//删除int main() {S L;CreatList(L);InserElem(L,4,9);PutList(L);DeleElem(L,3);PutList(L);return0;}结果E:\c++>b42345234952395。

c++有序顺序表的建立与基本操作

c++有序顺序表的建立与基本操作【C++有序顺序表的建立与基本操作】一、引言在C++编程中，有序顺序表是非常常见的数据结构之一。

它可以帮助我们存储和操作一组有序的数据，是程序中非常实用的工具。

本文将从有序顺序表的概念入手，逐步深入探讨其建立和基本操作，帮助读者更好地理解和运用这一数据结构。

二、有序顺序表的概念有序顺序表是一种线性表，其中元素按照一定的顺序排列。

在C++中，我们通常使用数组来实现有序顺序表。

通过数组，我们可以轻松地存储一组有序的数据，并且可以方便地进行各种基本操作，如插入、删除、查找等。

三、有序顺序表的建立1. 定义结构体或类我们需要定义一个结构体或类，用于表示有序顺序表。

结构体或类中应包含元素存储的数组，以及记录当前元素个数和表长的变量。

2. 初始化在建立有序顺序表时，我们需要对其进行初始化。

可以通过动态内存分配来分配数组空间，并对其他变量进行初始化。

需要注意的是，数组的大小应该根据实际需要进行调整，以防止空间浪费。

3. 插入元素在有序顺序表中插入元素是一个常见的操作。

当插入元素时，我们需要保持顺序表的有序性。

可以通过比较元素大小的方式，找到合适的位置并将元素插入其中。

四、有序顺序表的基本操作1. 插入操作有序顺序表的插入操作是比较常见的操作之一。

当我们需要向顺序表中插入新元素时，我们首先需要找到合适的位置，然后将其插入其中。

2. 删除操作删除操作是有序顺序表中另一个重要的操作。

当我们需要删除某个元素时，我们可以通过查找元素的方式找到需要删除的元素，然后将其后的元素向前移动，从而达到删除的目的。

3. 查找操作有序顺序表中的查找操作也是常见的操作之一。

当我们需要查找某个元素时，可以通过顺序查找或二分查找的方式进行查找，以获取所需的元素。

五、个人观点和理解有序顺序表是C++编程中非常常见的数据结构之一。

它能够帮助我们高效地存储和操作数据，是程序中的重要工具。

在实际应用中，我们需要灵活地运用有序顺序表的建立和基本操作，以解决实际问题。

顺序表的定义及基本操作

}
printf("数据插入成功！\n");
}
else if(temp == 3)
DispList(h);
else if(temp == 4)
printf("该单链表的长度= %d\n",ListLength(h));
else if(temp == 5)
{
int N;
scanf("%d", &N);
if(N<1||N>ListLength(h))
}
printf("\n");
}
int GetElem(LinkList *L,int i,ElemType &e) //获取链表中的任意位置的元素。但是不能越界
{
int j=1;
LinkList *p=L->next;
while (j<i && p!=NULL)
{
j++;
p=p->next;
}
if (p==NULL)
}
if (p==NULL)//未找到第i-1个结点
{
printf("未找到第%d个节点！\n", (i-1));
return 0;
}
else//找到第i-1个结点*p
{
s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*s
s->data=e;
s->next=p->next;//将*s插入到*p之后
while(temp != 0)
{
printf("********************************************************************************");

顺序表的基本操作--插入,删除,合并

printf("Please input the place of insert:\n");
scanf("%d",&i);
printf("Please input the elemvalue:\n");
scanf("%d",&e);
if(ListInsert_Sq(&La,i,e)==OK)
{
for(i=1;i<=;i++)
for(i=1;i<=n;i++)
{
scanf("%d",&e) ;
if(ListInsert_Sq(&La,i,e)!=OK)break;
}
for(i=1;i<=;i++)
printf("e[%d]=%d\n",i-1,[i-1]);
printf("Length: %d\n\n",;
/*-------------INSERT-----------------*/
printf("Length: %d\n",;
printf("Listsize: %d\n\n",;
}
else
printf("error!");
/*------------------INIT-----------------*/
if(InitList_sq(&Lc))
{
printf("Init is ok!\n");
printf("Please input the values of Lb:\n");

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

实验一：顺序表的基本操作。

编写一个完整的程序，实现顺序表的建立、插入、删除、输出等基本运算。

（1）建立一个顺序表，含有n个数据元素。

（2）输出顺序表及顺序表的长度。

（3）在顺序表中删除值为x的结点或者删除给定位置i的结点。

（4）将顺序表就地逆置，即利用原表的存储空间将线性表（a1,a2,...,a n）逆置为（a n,a n-1,...,a1）。

（5）将顺序表按升序排序。

（6）设顺序表中的数据元素递增有序，将x插入到顺序表的适当位置上，以保持该表的有序性。

（7）将两个顺序有序表A和B合并为一个有序表C。

（8）在主函数中设计一个简单的菜单，分别测试上述算法。

#include<stdio.h>#include<stdlib.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define OK 1#define OVERFLOW -2#define ERROR 0typedef int ElemType;typedef struct{ElemType *elem;int length;int listsize;}SqList;int cmp(const void *a,const void *b){return *(int*)a-*(int*)b;}//创建一个空表int InitList(SqList &L){L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));//分配空间if(!L.elem)return OVERFLOW;L.length=0;L.listsize=LIST_INIT_SIZE;return OK;}//在创建的空表中插入数据int ListInsert(SqList &L,int i,ElemType e){ElemType* newbase;//ElemType* q;if(i<0 || i>L.length+1)return ERROR;if(L.length>=L.listsize)//当前空间已满，增加新空间{newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));if(!newbase)return OVERFLOW;L.elem=newbase;L.listsize+=LISTINCREMENT;}L.elem[i]=e;//printf("%d ",L.elem[i]);L.length++;return OK;}//删除位置为i的节点int ListDelete(SqList &L,int i){ElemType* p;ElemType* q;if(i<0 || i>L.length)return ERROR;p=&(L.elem[i-1]);//e=*p;q=L.elem+L.length-1;for(++p;p<=q;p++)*(p-1)=*p;L.length--;return OK;}//在顺序表中删除数据xint DeleteX(SqList &L, int x){ElemType* p;int i;for(i=0;i<L.length;i++)if(L.elem[i]==x){break;}p=&L.elem[i];//free(p);for(int j=i;j<L.length-1;j++){L.elem[j]=L.elem[j+1];}L.length--;return OK;}//反转顺序表int TurnArrond(SqList &L)//翻转顺序表{ElemType* p;ElemType* q;int t;p=&(L.elem[0]);q=L.elem+L.length-1;for(p;p<q;p++,q--){t=*q;*q=*p;*p=t;}return OK;}//升序排列顺序表int ABC(SqList &L){int a[10000];int i;for(i=0;i<L.length;i++)a[i]=L.elem[i];qsort(a,L.length,sizeof(a[0]),cmp);for(i=0;i<L.length;i++)L.elem[i]=a[i];return OK;}//把顺序表升序排列后插入元素eint ListInsertABC(SqList &L,ElemType e){ElemType* newbase;int i,j;if(L.length+1>=L.listsize)//当前空间已满，增加新空间{newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));if(!newbase)return OVERFLOW;L.elem=newbase;L.listsize+=LISTINCREMENT;}for(i=0;i<L.length;i++)if(e<L.elem[i])break;for(j=L.length;j>i;j--){L.elem[j]=L.elem[j-1];}L.length++;L.elem[j]=e;//printf("%d ",L.elem[i]);return OK;}//合并顺序表L，L1为L2int MergeList(SqList L,SqList L1,SqList &L2){ElemType* pa;ElemType* pb;ElemType* pc;ElemType* pa_last;ElemType* pb_last;pa=L.elem;pb=L1.elem;// L2.elem=pc;L2.listsize=L.listsize+L1.listsize;pc=L.elem=(ElemType*)malloc(L2.listsize * sizeof(ElemType));pa_last=L.elem+L.length-1;pb_last=L1.elem+L1.length-1;while(pa<=pa_last && pb<=pb_last){if(*pa<=*pb)*pc++=*pa++;else*pc++=*pb++;}while(pa<=pa_last)*pc++=*pa++;while(pb<=pb_last)*pc++=*pb++;for(int i=0;i<L2.length;i++)printf("%d ",L2.elem[i]);return OK;}//打印菜单void printScreen(){//printf("1.建立一个顺序表，含有n个数据元素。

\n");printf("1.输出顺序表L1及其长度\n");printf("2.删除给定位置i的结点\n");printf("3.在顺序表中删除值为x的结点\n");printf("4.逆置顺序表\n");printf("5.将顺序表按升序排序\n");printf("6.设顺序表中的数据元素递增有序，将x插入到顺序表的适当位置上，以保持该表的有序性\n");printf("7.将两个顺序有序表L和L1合并为一个有序表L2\n");printf("0.退出操作系统。

\n");printf("请输入需要的操作序号：");}//输出顺序表Lvoid printSqList(SqList &L){int i;for(i=0;i<L.length;i++)printf("%d ",L.elem[i]);printf("\n");}int main(){SqList L,L1,L2;InitList(L);InitList(L1);InitList(L2);int n,e,muse,i,x;bool flag;//建立第一个的顺序表printf("请输入第一个数据表的长度：");scanf("%d",&n);printf("请以次输入长度为%d的顺序表：",n);for(i=0;i<n;i++){scanf("%d",&e);ListInsert(L,i,e);//依次在第i个位置插入顺序表}printf("第一个顺序表的次序为：");printSqList(L);//建立第二个顺序表printf("建立第二个顺序表，请输入要第二个建立数据表的长度：");scanf("%d",&n);printf("请以次输入长度为%d的顺序表：",n);for(i=0;i<n;i++){scanf("%d",&e);ListInsert(L1,i,e);//依次在第i个位置插入顺序表}printf("第二个顺序表的次序为：");printSqList(L1);//打印菜单printScreen();scanf("%d",&muse);flag=true;while(1){switch(muse){case 0:flag=false;break;case 1:printf("顺序表的长度为：");printf("%d\n",L.length);break;case 2:printf("请输入要删除的节点：");scanf("%d",&i);//删除顺序表的节点if(ListDelete(L,i)){printf("删除成功！\n");printSqList(L);}elseprintf("删除失败！\n");break;case 3:printf("请输入要删除的节点x的值：");scanf("%d",&x);if(DeleteX(L,x)){printf("删除成功！\n顺序表为：");printSqList(L);}elseprintf("删除失败！\n");break;case 4://逆序顺序表if(TurnArrond(L)){printf("逆序成功！\n");printf("顺序表的次序为：");printSqList(L);}elseprintf("逆序失败！\n");break;case 5://顺序表升序排列if(ABC(L)){printf("顺序表升序排列成功！\n");printf("顺序表的次序为：");printSqList(L);}elseprintf("顺序表升序排列失败！\n");printf("请输入要插入的数据：");scanf("%d",&e);if(ListInsertABC(L,e)){printf("顺序插入成功！\n");printf("顺序表的次序为：");printSqList(L);}elseprintf("顺序插入失败！\n");break;case 6:ABC(L);printf("请输入要插入的数字x的值：");scanf("%d",&x);if(ListInsertABC(L,x)){printf("操作成功！\n");printf("顺序表的次序为：");printSqList(L);}else printf("操作失败！\n");break;case 7:if(MergeList(L,L1,L2)){printf("顺序表L，L1合并成功!\n");//printf("顺序表的次序为：");//printSqList(L2);}elseprintf("顺序表合并失败！\n");break;default:break;}if(!flag)break;printf("\n请输入你要的下一步操作序号：");scanf("%d",&muse);}if(L.elem)free(L.elem);if(L1.elem)free(L1.elem);if(L2.elem)free(L2.elem);return 0;}。