线性表的插入,删除,修改
线性表 知识点总结
线性表知识点总结线性表的特点：1. 有序性：线性表中的元素是有序排列的，每个元素都有唯一的前驱和后继。
2. 可变性：线性表的长度是可变的，可以进行插入、删除操作来改变表的元素数量。
3. 线性关系：线性表中的元素之间存在明确的前驱和后继关系。
4. 存储结构：线性表的存储结构有顺序存储和链式存储两种方式。
线性表的操作：1. 查找操作：根据元素的位置或值来查找线性表中的元素。
2. 插入操作：将一个新元素插入到线性表中的指定位置。
3. 删除操作：将线性表中的某个元素删除。
4. 更新操作：将线性表中的某个元素更新为新的值。
线性表的顺序存储结构：顺序存储结构是将线性表的元素按照其逻辑顺序依次存储在一块连续的存储空间中。
线性表的顺序存储结构通常采用数组来实现。
数组中的每个元素都可以通过下标来访问，因此可以快速的进行查找操作。
但是插入和删除操作会导致元素位置的变动，需要进行大量数据搬移，效率较低。
线性表的链式存储结构：链式存储结构是将线性表的元素通过指针相连，形成一个链式结构。
每个元素包含数据和指向下一个元素的指针。
链式存储结构不需要连续的存储空间，可以动态分配内存，适合插入和删除频繁的场景。
但是链式结构的元素访问不如顺序结构高效，需要通过指针来逐个访问元素。
线性表的应用场景：1. 线性表适用于数据元素之间存在明确的前后关系，有序排列的场景。
2. 顺序存储结构适用于元素的插入和删除操作较少，对元素的随机访问较频繁的场景。
3. 链式存储结构适用于插入和删除操作较频繁的场景，对元素的随机访问较少。
线性表的操作的时间复杂度：1. 查找操作：顺序存储结构的时间复杂度为O(1)，链式存储结构的时间复杂度为O(n)。
2. 插入和删除操作：顺序存储结构的时间复杂度为O(n)，链式存储结构的时间复杂度为O(1)。
线性表的实现：1. 顺序存储结构的实现：使用数组来存储元素，通过下标来访问元素。
2. 链式存储结构的实现：使用链表来实现，每个元素包含数据和指向下一个元素的指针。
实验一 线性表的插入和删除
实验一线性表的插入和删除一、实验目的1、掌握用Turbo C上机调试线性表的基本方法；2、掌握线性表的基本操作，插入、删除、查找，以及线性表合并等运算在顺序存储结构和链接存储结构上的运算。
二、实验内容线性表基本操作的实现当我们要在线性表的顺序存储结构上的第i个位置上插入一个元素时，必须先将线性表的第i个元素之后的所有元素依次后移一个位置，以便腾空一个位置，再把新元素插入到该位置。
若要删除第i个元素时，也必须把第i个元素之后的所有元素前移一个位置。
程序实现：typedef Null 0;typedef int datatype;#define maxsize 1024;typedef struct{ datatype data[maxsize];int last;}sequenlist;int insert(L, x, i)sequenlist *L;int i;{ int j;if ((*L).last= =maxsize-1){ printf(“overflow”);return Null;}elseif ((i<1)‖(i>(*L).last+1){ printf(“error”);return Null;}else{ for(j=(*L).last; j>=i-1; j--) (*L).data[j+1]=(*L).data[j]; (*L).data[i-1]=x;(*L).last=(*L).last+1;}return(1);}int delete(L,i)sequenlist *L;int i;{ int j;if ((i<1)‖(i>(*L).last+1)){printf (“error”);return Null;}else{ for(j=i, j<=(*L).last; j++)(*L).data[j-1]=(*L).data[j];(*L).data - -;}return(1);}void creatlist( ){ sequenlist *L;int n, i, j;printf(“请输入n个数据\n”); scanf(“%d”,&n);for(i=0; i<n; i++){ printf(“data[%d]=”, i);scanf (“%d”, (*L).data[i]);}(*L).last=n-1;print f(“\n”);}printout (L)sequenlist *L;{ int i;for(i=0; i<(*L).last; i++){ printf(“data[%d]=”, i);printf(“%d”, (*L).data[i]);}}main( ){ sequenlist *L;char cmd;int i, t;clscr( );printf(“i, I…..插入\n”);printf(“d,D…..删除\n”);printf(“q,Q……退出\n”);do{ do{cmd =getchar( );}while((cmd!=‘d’)‖(cmd!=‘D’)‖(cmd!=‘q’)‖(cmd!=‘Q’)‖(cmd!=‘i’)‖(cmd!=‘I’));switch (cmd){ case ‘i’,‘I’; scanf(&x);scanf(&i);insert(L, x, i);printout(L);break;case ‘d’,‘D’; scanf(&i);delete(L, i);printout(L);break;}}while ((cmd!=‘q’)&&( cmd!=‘Q’));}。
【数据结构】线性表的基本操作
【数据结构】线性表的基本操作【数据结构】线性表的基本操作1：定义1.1 线性表的概念1.2 线性表的特点2：基本操作2.1 初始化操作2.1.1 空表的创建2.1.2 非空表的创建2.2 插入操作2.2.1 在指定位置插入元素2.2.2 在表头插入元素2.2.3 在表尾插入元素2.3 删除操作2.3.1 删除指定位置的元素2.3.2 删除表头的元素2.3.3 删除表尾的元素2.4 查找操作2.4.1 按值查找元素2.4.2 按位置查找元素2.5 修改操作2.5.1 修改指定位置的元素 2.5.2 修改指定值的元素3：综合操作3.1 反转线性表3.2 合并两个线性表3.3 排序线性表3.4 删除重复元素3.5 拆分线性表4：线性表的应用场景4.1 数组的应用4.2 链表的应用4.3 栈的应用4.4 队列的应用附件：无法律名词及注释：- 线性表：根据某种规则排列的一组元素的有限序列。
- 初始化操作：创建一个空的线性表，或者创建一个已经包含一定元素的线性表。
- 插入操作：在线性表的指定位置或者表头、表尾插入一个新元素。
- 删除操作：从线性表中删除掉指定位置或者表头、表尾的元素。
- 查找操作：在线性表中按照指定的元素值或者位置查找元素。
- 修改操作：更改线性表中指定位置或者值的元素。
- 反转线性表：将线性表中的元素顺序颠倒。
- 合并线性表：将两个线性表合并成一个新的线性表。
- 排序线性表：按照某种规则对线性表中的元素进行排序。
- 删除重复元素：将线性表中重复的元素删除，只保留一个。
- 拆分线性表：将一个线性表分成多个不重叠的子线性表。
线性表的存储结构定义及基本操作
一、实验目的：. 掌握线性表的逻辑特征. 掌握线性表顺序存储结构的特点，熟练掌握顺序表的基本运算. 熟练掌握线性表的链式存储结构定义及基本操作. 理解循环链表和双链表的特点和基本运算. 加深对顺序存储数据结构的理解和链式存储数据结构的理解，逐步培养解决实际问题的编程能力二、实验内容：（一）基本实验内容（顺序表）：建立顺序表，完成顺序表的基本操作：初始化、插入、删除、逆转、输出、销毁, 置空表、求表长、查找元素、判线性表是否为空；1．问题描述：利用顺序表,设计一组输入数据（假定为一组整数），能够对顺序表进行如下操作：. 创建一个新的顺序表，实现动态空间分配的初始化；. 根据顺序表结点的位置插入一个新结点(位置插入)，也可以根据给定的值进行插入(值插入)，形成有序顺序表；. 根据顺序表结点的位置删除一个结点(位置删除)，也可以根据给定的值删除对应的第一个结点，或者删除指定值的所有结点(值删除)；. 利用最少的空间实现顺序表元素的逆转；. 实现顺序表的各个元素的输出；. 彻底销毁顺序线性表，回收所分配的空间；. 对顺序线性表的所有元素删除，置为空表；. 返回其数据元素个数；. 按序号查找，根据顺序表的特点，可以随机存取，直接可以定位于第i 个结点，查找该元素的值，对查找结果进行返回；. 按值查找，根据给定数据元素的值，只能顺序比较，查找该元素的位置，对查找结果进行返回；. 判断顺序表中是否有元素存在，对判断结果进行返回；. 编写主程序，实现对各不同的算法调用。
2．实现要求：对顺序表的各项操作一定要编写成为C（C++）语言函数，组合成模块化的形式，每个算法的实现要从时间复杂度和空间复杂度上进行评价；. “初始化算法”的操作结果：构造一个空的顺序线性表。
对顺序表的空间进行动态管理，实现动态分配、回收和增加存储空间；. “位置插入算法”的初始条件：顺序线性表L 已存在，给定的元素位置为i，且1≤i≤ListLength(L)+1 ；操作结果：在L 中第i 个位置之前插入新的数据元素e，L 的长度加1；. “位置删除算法”的初始条件：顺序线性表L 已存在，1≤i≤ListLength(L) ；操作结果：删除L 的第i 个数据元素，并用e 返回其值，L 的长度减1 ；. “逆转算法”的初始条件：顺序线性表L 已存在；操作结果：依次对L 的每个数据元素进行交换，为了使用最少的额外空间，对顺序表的元素进行交换；. “输出算法”的初始条件：顺序线性表L 已存在；操作结果：依次对L 的每个数据元素进行输出；. “销毁算法”初始条件：顺序线性表L 已存在；操作结果：销毁顺序线性表L；. “置空表算法”初始条件：顺序线性表L 已存在；操作结果：将L 重置为空表；. “求表长算法”初始条件：顺序线性表L 已存在；操作结果：返回L 中数据元素个数；. “按序号查找算法”初始条件：顺序线性表L 已存在，元素位置为i，且1≤i≤ListLength(L)操作结果：返回L 中第i 个数据元素的值. “按值查找算法”初始条件：顺序线性表L 已存在，元素值为e；操作结果：返回L 中数据元素值为e 的元素位置；. “判表空算法”初始条件：顺序线性表L 已存在；操作结果：若L 为空表，则返回TRUE，否则返回FALSE；分析: 修改输入数据，预期输出并验证输出的结果，加深对有关算法的理解。
线性表的插入和删除(数据结构)
电子信息工程学系实验报告——适用于计算机课程课程名称：Array实验项目名称：线性表的插入和删除实验时间： 2012、3、班级：计应102 姓名：学号：实验目的:熟悉掌握线性表的基本操作在顺序存储结构和链式存储结构上的实现，并熟悉其各自的优缺点及适用性。
实验环境:C—Free5.0实验内容及过程:题目1：编写程序实现下列的要求：(1) 设数据元素为整数，实现这样的线性表的顺序存储表示。
(2) 键盘输入10个数据元素，利用顺序表的基本操作，建立该表。
(3) 利用顺序表的基本操作，找出表中的最大的和最小的数据元素（用于比较的数据元素为整数）。
(4) * 若数据元素为学生成绩（含姓名、成绩等字段），重新编程，实现上面的要求。
要求尽可能少地修改前面的程序来得到新程序。
（这里用于比较的字段为分数）题目2：编写程序实现下列的要求：(1) 设学生成绩表中的数据元素为学生成绩（含姓名、成绩字段），实现这样的线性表的链式存储表示。
(2) 键盘输入若干个数据元素（用特殊数据来标记输入数据的结束），利用链表的基本操作（前插或后插算法），建立学生成绩单链表。
(3) 键盘输入关键字值x，打印出表中所有关键字值<=x的结点数据。
（用于比较的关键字字段为分数）。
(4) 输入关键字值x，删除表中所有关键字值<=x的结点。
（用于比较的关键字字段为分数）。
实验结果及分析：题目一：（4）：题目二：实验心得：通过这次的实验，对线性表和单链表的创建和修改有了初步的认识，和同学的讨论互相弥补了不足，相信在未来的学习中会有更大的收获。
附录：题目一代码：#include "stdio.h"#include "conio.h"typedef int datatype;struct seqlist{int maxnum;int n;datatype *element;};typedef struct seqlist *Pseqlist;Pseqlist creatnulllist_seq(int m) /* 建立空的顺序表*/{Pseqlist p=(Pseqlist)malloc(sizeof(struct seqlist));if(p!=NULL){p->element=(datatype *)malloc(sizeof(datatype)*m);if(p->element!=NULL){p->maxnum=m;p->n=0;}else free(p);}printf("out of space");return NULL;}Pseqlist init_seq(Pseqlist p,int n) /* 初始化空的顺序表，即填充数据，顺序表的实际元素个数n 由参数提供*/{int i;printf("input the element of seqlist:");for(i=0;i<n;i++)scanf("%d",&p->element[i]);p->n=n;return(p);}int insertpost_seq(Pseqlist p,int i,datatype x) /* 在i之后插入一个元素x */{int j;if(p->n>=p->maxnum){printf("overflow");return(0);}if(i<0 || i>p->n ){printf("not exist");return(0);}for(j=p->n-1; j>=i+1; j--)p->element[j+1]=p->element[j];p->element[i+1]=x;p->n++;return(1);}void print(Pseqlist p) /* 打印顺序表中的元素*/{int i;for(i=0;i<p->n;i++)int FinMax(Pseqlist p){int max=p->element[0];int i;for(i=1;i<p->n;++i){if(max<p->element[i])max=p->element[i];}return max;}int FinMin(Pseqlist p){int min=p->element[0];int i;for(i=1;i<p->n;++i){if(min>p->element[i])min=p->element[i];}return min;}main(){Pseqlist p;int m,n,i,x,k;printf("input the size of seqlist m:"); /* 输入顺序表的最大空间m，建立空的顺序表*/ scanf("%d",&m);p=creatnulllist_seq(m);printf("input the real number of seqlist n(n<m):"); /* 输入顺序表的实际长度n，初始化顺序表*/ scanf("%d",&n);p=init_seq(p,n);/* 输出插入之前顺序表的元素*/ print(p);printf("\n");printf("input i,x:");scanf("%d%d",&i,&x); /* k的值用来表示是否插入成功*/k=insertpost_seq(p,i,x);if(k==1) print(p); /* 如果插入成功，输出插入之后顺序表的元素*/ printf("\nmax:%d,min:%d\n",FinMax(p),FinMin(p));}题目一的（4）的代码：#include "stdio.h"#include "conio.h"//typedef int datatype;typedef struct student{int score;char name[30];}datatype;struct seqlist{int maxnum;int n;datatype *element;};typedef struct seqlist *Pseqlist;Pseqlist creatnulllist_seq(int m) /* 建立空的顺序表*/{Pseqlist p=(Pseqlist)malloc(sizeof(struct seqlist));if(p!=NULL){p->element=(datatype *)malloc(sizeof(datatype)*m);if(p->element!=NULL){p->maxnum=m;p->n=0;return(p);}else free(p);}printf("out of space");return NULL;}Pseqlist init_seq(Pseqlist p,int n) /* 初始化空的顺序表，即填充数据，顺序表的实际元素个数n 由参数提供*/{int i;printf("输入10个分数:输入10个名字：");for(i=0;i<n;i++)scanf("%d%s",&p->element[i].score,p->element[i].name);return(p);}int insertpost_seq(Pseqlist p,int i,datatype x) /* 在i之后插入一个元素x */ {int j;if(p->n>=p->maxnum){printf("overflow");return(0);}if(i<0 || i>p->n ){printf("not exist");return(0);}i-=2;for(j=p->n-1; j>=i+1; j--)p->element[j+1]=p->element[j];p->element[i+1]=x;p->n++;return(1);}int FinMax(Pseqlist p){int max=p->element[0].score;int i;for(i=1;i<p->n;++i){if(max<p->element[i].score)max=p->element[i].score;}return max;}int FinMin(Pseqlist p){int min=p->element[0].score;int i;for(i=1;i<p->n;++i){if(min>p->element[i].score)min=p->element[i].score;}return min;void print(Pseqlist p) /* 打印顺序表中的元素*/{int i;for(i=0;i<p->n;i++)printf("姓名：%s 分数：%d",p->element[i].name,p->element[i].score);}main(){Pseqlist p;int m,n,i,x,k;datatype aa;printf("input the size of seqlist m:"); /* 输入顺序表的最大空间m，建立空的顺序表*/scanf("%d",&m);p=creatnulllist_seq(m);printf("input the real number of seqlist n(n<m):"); /* 输入顺序表的实际长度n，初始化顺序表*/ scanf("%d",&n);p=init_seq(p,n);/* 输出插入之前顺序表的元素*/ print(p);printf("\n");printf("input i,x.score,:");scanf("%d%d%s",&i,&aa.score,); /* k的值用来表示是否插入成功*/ k=insertpost_seq(p,i,aa);if(k==1) print(p);/* 如果插入成功，输出插入之后顺序表的元素*/printf("\n%d %d",FinMax(p),FinMin(p));printf("分别是最大的和最小的数据");getch();}题目二代码：/* 线性表的单链表表示：类型和界面函数定义*/#include <stdio.h>/* 定义链接表元素类型。
数据结构实验报告
数据结构实验报告一、实验目的本实验旨在通过对数据结构的学习和实践，掌握基本的数据结构概念、原理及其应用，培养学生的问题分析与解决能力，提升编程实践能力。
二、实验背景数据结构是计算机科学中的重要基础，它研究数据的存储方式和组织形式，以及数据之间的关系和操作方法。
在软件开发过程中，合理选用和使用数据结构，能够提高算法效率，优化内存利用，提升软件系统的性能和稳定性。
三、实验内容本次实验主要涉及以下几个方面的内容：1.线性表的基本操作：包括线性表的创建、插入、删除、查找、修改等操作。
通过编程实现不同线性表的操作，掌握它们的原理和实现方法。
2.栈和队列的应用：栈和队列是常用的数据结构，通过实现栈和队列的基本操作，学会如何解决实际问题。
例如，利用栈实现括号匹配，利用队列实现银行排队等。
3.递归和回溯算法：递归和回溯是解决很多求解问题的常用方法。
通过编程实现递归和回溯算法，理解它们的思想和应用场景。
4.树和二叉树的遍历：学习树和二叉树的遍历方法，包括前序、中序和后序遍历。
通过编程实现这些遍历算法，加深对树结构的理解。
5.图的基本算法：学习图的基本存储结构和算法，包括图的遍历、最短路径、最小生成树等。
通过编程实现这些算法，掌握图的基本操作和应用。
四、实验过程1.具体实验内容安排：根据实验要求，准备好所需的编程环境和工具。
根据实验要求逐步完成实验任务，注意记录并整理实验过程中遇到的问题和解决方法。
2.实验数据采集和处理：对于每个实验任务，根据要求采集并整理测试数据，进行相应的数据处理和分析。
记录实验过程中的数据和结果。
3.实验结果展示和分析：将实验结果进行适当的展示，例如表格、图形等形式，分析实验结果的特点和规律。
4.实验总结与反思：总结实验过程和结果，回顾实验中的收获和不足，提出改进意见和建议。
五、实验结果与分析根据实验步骤和要求完成实验任务后，得到了相应的实验结果。
对于每个实验任务，根据实验结果进行适当的分析。
数据结构--实验报告 线性表的基本操作
数据结构--实验报告线性表的基本操作数据结构--实验报告线性表的基本操作一、引言本实验报告旨在通过实际操作，掌握线性表的基本操作，包括初始化、插入、删除、查找等。
线性表是最基本的数据结构之一，对于理解和应用其他数据结构具有重要的作用。
二、实验目的1·了解线性表的定义和基本特性。
2·掌握线性表的初始化操作。
3·掌握线性表的插入和删除操作。
4·掌握线性表的查找操作。
5·通过实验巩固和加深对线性表的理解。
三、线性表的基本操作1·初始化线性表线性表的初始化是将一个线性表变量设置为空表的过程。
具体步骤如下：（1）创建一个线性表的数据结构，包括表头指针和数据元素的存储空间。
（2）将表头指针指向一个空的数据元素。
2·插入元素插入元素是向线性表中指定位置插入一个元素的操作。
具体步骤如下：（1）判断线性表是否已满，如果已满则无法插入元素。
（2）判断插入位置是否合法，如果不合法则无法插入元素。
（3）将插入位置及其后面的元素都向后移动一个位置。
（4）将待插入的元素放入插入位置。
3·删除元素删除元素是从线性表中删除指定位置的元素的操作。
具体步骤如下：（1）判断线性表是否为空，如果为空则无法删除元素。
（2）判断删除位置是否合法，如果不合法则无法删除元素。
（3）将删除位置后面的元素都向前移动一个位置。
（4）删除最后一个元素。
4·查找元素查找元素是在线性表中查找指定元素值的操作。
具体步骤如下：（1）从线性表的第一个元素开始，逐个比较每个元素的值，直到找到目标元素或遍历完整个线性表。
（2）如果找到目标元素，则返回该元素的位置。
（3）如果未找到目标元素，则返回找不到的信息。
四、实验步骤1·初始化线性表（1）定义线性表的数据结构，包括表头指针和数据元素的存储空间。
（2）将表头指针指向一个空的数据元素。
2·插入元素（1）判断线性表是否已满。
线性表的基本操作
实验一线性表的基本操作一、实验目的学习掌握线性表的顺序存储结构、链式存储结构。
设计顺序表的创建、插入、删除等基本操作，设计单链表的建立、插入、删除等基本操作。
二、实验内容1.顺序表的实践（1）顺序表的创建：基于顺序表的动态分配存储结构，创建一个顺序表S，初始状态S=(1，2，3，4，5)。
（2）顺序表的遍历：依次输出顺序表的每个数据元素。
（3）顺序表的插入：在顺序表S=(1，2，3，4，5)的数据元素4和5之间插入一个值为9的数据元素。
（4）顺序表的删除：顺序表S=(1，2，3，4，9，5)中删除指定位置（i=3）的数据元素3。
（5）顺序表的按值查找：查找顺序表S中第1个值等于4的数据元素位序。
（6）顺序表的清空：释放顺序表的存储空间。
2.单链表的实践（1）单链表的创建：创建一个包括头结点和4个元素结点的单链表L=（5，4，2，1）。
（2）单链表的遍历：依次输出顺序表的每个数据元素。
（3）单链表的取值：输出单链表中第i个（i=2）数据元素的值。
（4）单链表的插入：在已建好的单链表的指定位置（i=3）插入一个结点3。
（5）单链表的删除：在一个包括头结点和5个结点的单链表L=（5，4，3，2，1）中，删除指定位置（i=2）的结点，实现的基本操作。
（6）求单链表的表长：输出单链表的所有元素和表长。
（7）单链表的判空：判断单链表是否为空表。
（8）单链表的清空：释放单链表的存储空间。
三、程序源代码1.线性表的基本操作#include <iostream>#include<stdlib.h>using namespace std;#define OK 1#define OVERFLOW -2#define ERROR 0#define LIST_INIT_SIZE 100#define LISTINCEREMENT 10typedef int Status;typedef int Elemtype;typedef Elemtype *Triplet;typedef struct { //定义结构体类型：顺序表Elemtype *elem;int length;int listsize;} Sqlist;Status Initlist( Sqlist &L ) { //int n,i;L.elem = (Elemtype*) malloc (LIST_INIT_SIZE*sizeof(Elemtype));if(!L.elem) {return(OVERFLOW);}cout << "输入元素个数和各元素的值:";cin >> n;for(int i=0; i<n; i++) {cin >> L.elem[i];}L.length = n;L.listsize = LIST_INIT_SIZE;return OK;}Status TraverList(Sqlist L) {for(int i=0; i<L.length; i++) {cout << L.elem[i]<<" ";}cout << endl;}Status ListInsert (Sqlist &L,int i,Elemtype e) { //插入Elemtype *newbase,*p,*q;if(i<1||i>L.length+1) return ERROR;//i不合法if(L.length >= L.listsize) { //需要重新分配存储空间newbase = (Elemtype *) realloc(L.elem,(L.listsize + LISTINCEREMENT)*sizeof (Elemtype));if(!newbase) exit(OVERFLOW);//分配失败L.elem = newbase;L.listsize += LISTINCEREMENT;}q = &(L.elem[i-1]);for(p=&(L.elem[L.length-1]); p>=q; --p)*(p+1)=*p;*q=e;++L.length;return OK;}Status ListDelete(Sqlist &L,int i,Elemtype &e) { //删除Elemtype *p,*q;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;return OK;}Status LocateElem(Sqlist L,Elemtype &e) { //查找int i;Elemtype *p;i=1;p=L.elem;while(i<=L.length&&*(p++)!=e) ++i;if(i<=L.length) return i;else return 0;}Status ClearList(Sqlist &L) {free(L.elem);cout << "该表已被清空！";return OK;}int main() {Sqlist L;int i,z;Elemtype e;if(Initlist(L)==OVERFLOW) {cout << endl << "OVERFLOW";return 0;}TraverList(L);while(1) {cout << "-------------------" << endl;cout << "选择要执行的基本操作：" << endl << "1:插入元素" << endl << "2.删除元素" << endl << "3.查找元素" << endl<< "4.退出" << endl;cin >> z;switch(z) {case 1:cout << "输入要插入元素的位置和值：" << endl;cin >> i >> e;if(ListInsert(L,i,e)==OK)TraverList(L);elsecout << "插入的位置不合法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
i=1; j=n;
while (i<=j)
{ k=(i+j)/2;
if (v[k-1]==x) return(k-1);
if (v[k-1]>x) j=k-1;
elsei=k+1;
}
return(-1);
}
bubsort(v,n)intn;v[];
{intm,k,j,i, d; k=0;
else if ((p[i]>=p[k])&&(p[k]>=p[j])) u=k;
else u=i;
t=p[u]; p[u]=p[i];
while (i!=j)
{ while ((i<j)&&(p[j]>=t)) j=j-1;
if (i<j){ p[i]=p[j];i=i+1;
while ((i<j)&&(p[i]<=t))i=i+1;
scanf("%d",&i);
printf("请输入线性表插入元素:");
scanf("%d",&b);
insl(v,m,n,i,b); /*调用线性表插入函数*/
printf("输出操作后线性表:");
output(v,*n); /*调用线性表输出函数*/
printf("\n");
printf("请输入线性表删除点位置:");
printf("请输入线性表容量:");
scanf("%d",&m);
v=inistl(m,n); /*调用创建线性表函数*/
printf("请输入线性表实际个数:");
scanf("%d",n);
printf("请输入线性表起始元素：");
input(v,*n); /*调用线性表元素输入函数*/
printf("请输入线性表插入点位置:");
return;
}
if((i<1)||(i>*n)) /*删除点在首部以前和尾部以后特殊情况排除*/
{printf("not this element in the list!\n");
return;
}
for (j=i;j<=*n-1;j++) /*在允许位置做删除操作*/
v[j-1]=v[j];
*n=*n-1; /*元素统计指针减1*/
elseprintf("the element in the line is %d\n",++k);
}
#include"stdio.h"
#include"stdlib.h"
int*inistl(intm,int*n) /*建立线性表函数*/
{int*v=NULL;
v=malloc(m*sizeof(int*)); /*创建链表，并把首地址赋给指针V*/
n=0;
return v;
}
voidinsl(int*v,intm,int*n,inti,intb)/*在链表指定位置插入元素b*/
m=n-1; while (k<m) /*子表未空*/
{ j=m-1; m=0;
for(i=k;i<=j;i++) /*从前往后扫描*/
if (v[i]>v[i+1]) /*发现逆序进行交换*/
{d=v[i];v[i]=p[i+1];v[i+1]=d;m=i;}
j=k+1; k=0;
for (i=m;i>=j;i--) /*从后往前扫描*/
scanf("%d",&i);
desl(v,m, n,i); /*调用线性表元素删除函数*/
printf("输出操作后线性表:");
output(v,*n); /*调用线性表输出函数*/
printf("\n");
printf("请输入要查找的元素:");
scanf("%d",&x);
printf("\n");
if (v[i-1]>v[i]) /*发现逆序进行交换*/
{d=v[i];v[i]=v[i-1];v[i-1]=d;k=i;}
}
return;
}
qksort1(p,m,n)
intm,n;p[];
{
inti;if(n>m) /*子表不空*/
{
i=split(p,m,n); /*分割*/
qksort1(p,m,i-1); /*对前子表进行快速排序*/
printf("%d",*(v+i)); /*指针移动指向下一个节点依次输出元素*/
}
serch(int*v,intn,intx)
{intk;
k=0;
while ((k<n)&&(v[k]=!x)) k=k+1;
if (k==n) k=-1;
return(k);
}
bserch(int*v,intn,intx)
printf("please put choose 1 is search 2 isbsearch\n");
scanf("%d",&y);
switch(y)
{case 1:k=serch(v,*n,x);
case 2:k=bserch(v,*n,x);
}
if(k==-1)
printf("not find the element in line!\n");
{
intj;
if(*n>=m) /*检查是否链表溢出*/
{printf("the stack is overflow\n");
return;
}
if(i>*n-1)i=*n+1; /*若插入点大于元素位置则在表的结束插入*/
if(i<1)i=1; /*空表在首部插入元素*/
for(j=*n;j>=i;j--) /*首位之间任意位置的插入*/
return;
}
void input(int*v,intn) /*空表起始输入元素函数*/
{inti;
for(i=0;i<n;i++) /*利用循环指针输入元素*/
scanf("%d",v+i);
}
void output(int*v,intn) /*线性表输出打印函数*/
{inti;
for(i=0;i<n;i++)
if (i<j)
{p[j]=p[i]; j=j-1;}
}
}
p[i]=t;
return(i);
}
void main() /*主函数（功能调用函数）*/
{int*v,m,*n,i,b,x,y,k; /*v链表空间首地址m线性表容量n线性表实际元素i改变线性表元素位置b插入或删除元素*/
n=(int*)malloc(sizeof(int)); /*开辟链表空间*/
qksort1(p,i+1,n); /*对后子表进行快速排序*/
}
return;
}
intsplit(p,m,n) /*返回分界线位置*/
intm,n; p[];
{inti,j,k,u;t;
i=m; j=n;k=(i+j)/2;
if ((p[i]>=p[j])&&(p[j]>=p[k])) u=j; /*选取一个元素*/
v[j]=v[j-1];
v[i-1]=b;
*n=*n+1; /*插入后元素统计指针加1*/
}
voiddesl(int*v,intm,int*n,inti) /*线性表删除函数*/
{intj;
if(*n==0) /*判断线性表是否为空*/
{printf("the stack is underflow\n ");