删除顺序表中在【x,y】之间的所有元素
集合删除元素的方法
集合删除元素的方法
集合删除元素是很常见的操作，基本上所有的计算机语言都可以实现此功能。
通常来讲，集合删除元素时，有两种不同的方法：通过索引值来删除和通过元素的值来删除。
通过索引值来删除元素：
当我们想要删除集合中的元素时，可以使用索引值来删除。
此处的索引值指的是元素在集合中的位置，即该元素在集合中的第几个；比如说，一个集合中有5个元素，索引值分别为0，1，2，3，4；因此，可以通过其索引值来删除该集合中任意一个元素。
通过元素的值来删除元素：
当我们想要删除集合中的元素时，也可以通过元素的值来删除。
由于集合中的元素有可能是重复的，因此，即使是指定元素的值，有可能也会删除多个元素；但是，也存在“删除单个元素”的情况，此处的单个元素指的是，只有一个元素的值与指定的元素值一样。
总之，集合删除元素的方法有两种：一种是通过索引值来删除；另一种是通过元素的值来删除。
这两种方法都可以有效删除集合中的元素，具体使用哪一种方法，要根据实际情况而定。
C语言数据结构_从顺序表中删除元素
C语⾔数据结构_从顺序表中删除元素
从静态顺序表中删除第i个位置元素的代码如下：
void DelElem(ElemType Sqlist[], int &n, int i){
int j;
if(i<1 || i>n)
exit(0); //⾮法删除
for(j=i; j<n; j++)
Sqlist[j-1]=Sqlist[j]; //将第i位置以后的元素依次前移
n--; //表长减1
}
从动态⽣成的顺序表中删除第i个位置元素的代码如下：
void DelElem(Sqlist *L,int i)
{
ElemType *delItem,*q;
if(i<1 || i>L->length) exit(0);
delItem=&(L->elem[i-1]);
q=L->elem + L->length - 1;
for(++delItem;delItem<=q;++delItem)
{
*(delItem-1)=*delItem;
}
L->length--;
}
函数DelElem()的作⽤是在顺序表中删除第i个位置的元素,并将顺序表的长度减少1。
其实现过程如下：
(1)判断删除的元素是否合法。
⼀个长度为n的顺序表的可能删除元素的位置是1~n+1,因此如果i<1或者i>n+1,都是⾮法的。
(2)将顺序表的i位置以后的元素顺序后前移动⼀个元素的位置，这样会覆盖第i个元素的位置，起到删除第i个元素的作⽤。
(3)将表长减1。
顺序表作业答案
data[m] = data[L.length]; L.length--; //空出位置由最后元素填补, 表最后元素位置减1
return e;
}
(2) 向顺序表中第i个位置插入一个新的元素x。如果i不合理则显示出错信息并退出运行
InsertList ( List L,int i, elemType & x )
(1) 从顺序表中删除具有最小值的元素并由函数返回被删元素的值。空出的位置由最后一个
元素填补，若顺序表为空则显示出错信息并退出运行。
elemtype DelMin (List L ,elemtype &e )
{
if ( L.length <0 ) //表空, 中止操作返回
if ( i <= L.length )
{ for ( int j = 1; i + j <= L.length; j++ ) //循环, 寻找值 > t 的第一个元素
if ( L.data[i+j] > t ) break; //退出循环时, i+j指向该元素
for ( int k = i+j; k <= L.length; k++ ) //删除满足条件的元素, 后续元素前移
{ if ( L.length == N-1|| i < 0 || i > L.length+1 ) //表满或参数i不合理, 中止操作返回
{ printf(" List is Full or Parameter is out range! ” ); exit(1); }
C数据结构中的删除顺序表中值相同的多余的元素
C数据结构中的删除顺序表中值相同的多余的元素题目如下:按下面两种情况分别编写算法删除顺序表中值相同的多余元素.1) 顺序表元素值递增有序.2)顺序表元素值无序.由于时间原因,两个给合成一个来编了,比方先给顺序表赋值为:0,1,2,3,4,4,6,7,8,9,4把里面多余的4删除,实现代码:#include<iostream.h>#include<stdio.h>#define dint int#define max 100typedef struct//定义顺序表的结构体{dint data[max];int last;}sqlist;void del(sqlist *a)//删除函数,要删除多余元素时调用{int i,j,k;dint temp;//定义一个临时变量,用来放循环时的变量,用他来比较里面有没重复的元素for(i=0;i<=a->last;i++)//循环开始{temp=a->data;//.把顺序表中的数据一个个和其它数据比较,看有重复没for(j=i+1;j<=a->last;j++)//和其它数比较开始if(temp==a->data[j])//判断是否相等,相等则进入下一循环,把重复的删去{for(k=j;k<=a->last;k++)//删除循环开始{a->data[k]=a->data[k+1];}a->last--;//删除成功,顺序表结构中元素个数减一}}}void main(){int i;sqlist lb;//定义顺序表结构体st=0;//给表置空for(i=0;i<10;i++)//给表赋值,分别放入0,1,2,3,4,4,6,7,8,9{if(i==5){lb.data=i-1;printf(" %d",lb.data);lb.data[++i]=i;st++;}elselb.data=i;st++;printf(" %d",lb.data);}lb.data[st]=4;//再放入一个4,购成第二小题的不是顺序删除st++;printf(" %d",lb.data[st-1]);//输出,原来的元素printf("\n");del(&lb);//进行删除调用函数for(i=0;i<=st;i++)//输出删除后的值printf(" %d",lb.data);printf("\n");}写得这么详细了,如还有不明白的,赶快提出吧,[ 此贴被腾马在2007-。
顺序表删除值为x的元素
顺序表删除值为x的元素思路： 不要去考虑删除的字眼，要考虑如何进⾏保存⾮ x 的值这⾥提供两种解法，殊途同归： 1.将其中⾮ x 的元素统计并保存 2.统计为 x 的元素个数，并将⾮ x 的元素保存注意事项：注意这⾥代码由于使⽤了引⽤(&)，只能在 C++ 中编译通过使⽤指针的时候⼀定要注意开辟空间，否则之后可能发现⽆法预知的错误代码如下：1 #include <stdio.h>2 #include <stdlib.h>3#define MaxSize 504 typedef int ElemType;56 typedef struct {7 ElemType data[MaxSize];8int length;9 } Sqlist;1011//将其中⾮ x 的元素统计并保存12void delnode1(Sqlist* &L, ElemType x) {13int k = 0, i;14for(i = 0; i < L -> length; i++) {15if(L -> data[i] != x) {16 L -> data[k] = L -> data[i];17 k++;18 }19 }20 L -> length = k;21 }2223//统计为 x 的元素个数，并将⾮ x 的元素保存24void delnode2(Sqlist* &L, ElemType x) {25int k = 0, i;26for (i = 0; i < L -> length; i++) {27if (L -> data[i] == x) {28 k++;29 } else {30 L -> data[i - k] = L -> data[i];31 }32 }33 L -> length -= k;34 }3536void createList(Sqlist* &L, ElemType a[], int n) {37int i;38 L = (Sqlist *)malloc(sizeof(Sqlist));39for (i = 0; i < n; i++) {40 L -> data[i] = a[i];41 }42 L -> length = n;43 }4445void dispList(Sqlist *L) {46int i;47for (i = 0; i < L -> length; i++) {48 printf("%d ", L -> data[i]);49 }50 printf("\n");51 }5253int main(int argc, char const *argv[]) {54 Sqlist *L;55 ElemType a[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};56 createList(L, a, 10);57 printf("原始线性表：\n");58 dispList(L);59 delnode1(L, 3);60 printf("删除 3 后：\n");61 dispList(L);62 delnode2(L, 4);63 printf("删除 4 后：\n");64 dispList(L);65return0;66 }轻点加号，代码即现运⾏结果在这⼉*^_^*原始线性表：0123456789删除3后：012456789删除4后：01256789。
《c语言数据结构》第2章 自测卷答案
第2章自测卷答案姓名班级一、填空（每空1分，共13分）1. 【严题集2.2①】在顺序表中插入或删除一个元素，需要平均移动表中一半元素，具体移动的元素个数与表长和该元素在表中的位置有关。
2. 线性表中结点的集合是有限的，结点间的关系是一对一的。
3. 向一个长度为n的向量的第i个元素(1≤i≤n+1)之前插入一个元素时，需向后移动n-i+1 个元素。
4. 向一个长度为n的向量中删除第i个元素(1≤i≤n)时，需向前移动n-i 个元素。
5. 在顺序表中访问任意一结点的时间复杂度均为O(1)，因此，顺序表也称为随机存取的数据结构。
6. 【严题集2.2①】顺序表中逻辑上相邻的元素的物理位置必定相邻。
单链表中逻辑上相邻的元素的物理位置不一定相邻。
7. 【严题集2.2①】在单链表中，除了首元结点外，任一结点的存储位置由其直接前驱结点的链域的值指示。
8．在n个结点的单链表中要删除已知结点*p，需找到它的前驱结点的地址，其时间复杂度为O（n）。
二、判断正误（在正确的说法后面打勾，反之打叉）（每小题1分，共10分）（×）1. 链表的每个结点中都恰好包含一个指针。
答：错误。
链表中的结点可含多个指针域，分别存放多个指针。
例如，双向链表中的结点可以含有两个指针域，分别存放指向其直接前趋和直接后继结点的指针。
（×）2. 链表的物理存储结构具有同链表一样的顺序。
错，链表的存储结构特点是无序，而链表的示意图有序。
（×）3. 链表的删除算法很简单，因为当删除链中某个结点后，计算机会自动地将后续的各个单元向前移动。
错，链表的结点不会移动，只是指针内容改变。
（×）4. 线性表的每个结点只能是一个简单类型，而链表的每个结点可以是一个复杂类型。
错，混淆了逻辑结构与物理结构，链表也是线性表！且即使是顺序表，也能存放记录型数据。
（×）5. 顺序表结构适宜于进行顺序存取，而链表适宜于进行随机存取。
顺序表的基本操作【c语言】【创建、插入、删除、输出】
顺序表的基本操作【c语⾔】【创建、插⼊、删除、输出】作为数据结构初学者，上课时对⼀些知识点掌握得不是很透彻，所以利⽤课余时间通过微博平台总结所学知识，加深对知识的见解，记录学习历程便于后需要时参考。
1 #include<stdio.h>2 #include<malloc.h>3#define OK 14#define ERROR 05#define LIST_INIT_SIZE 1006#define LISTINCREMENT 107#define ElemType int顺序表的基本操作之结构体的创建：1 typedef struct2 {3int *elem;//存储空间基址，也就是该数据得到的内存分配的起始地址4int length;//当前长度5int listsize;//当前分配的存储容量6 } SqList;构造⼀个空的线性表：int InitList_Sq(SqList &L) //&此符号不是c语⾔⾥的取地址符号，⽽是C++⾥的引⽤符号，⽤法为为主函数⾥的T，取⼀个别名，这样⼦对L操作即相当于对T操作{// 该线性表预定义⼤⼩为LIST_INIT_SIZEL.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));//ElemType即为intif(!L.elem) return0;//malloc返回值为void*,void* 类型可以强制转换为任何其它类型的指针，在这⾥L.elem为⾮零。
L.length=0;L.listsize=LIST_INIT_SIZE;//LIST_INIT_SIZE=100return OK;}在顺序线性表L中第i个位置之前插⼊新的元素e：1int ListInsert_Sq(SqList &L,int i,int e)2 {3int *newbase;//声明整型指针变量4int *q,*p;5if(i<1||i>L.length+1) return ERROR;//判断i值是否合法，1<i<L.length+16if(L.length>=L.listsize)//判断当前长度是否⼤于当前的存储容量，如果⼤于，则增加LISTINCREMENT长度，即107 {8 newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));9if(!newbase) return0;10 L.elem=newbase;11 L.listsize+=LISTINCREMENT;12 }13 q=&(L.elem[i-1]);//把插⼊位置的地址赋值给q14for(p=&(L.elem[L.length-1]); p>=q; p--)15 *(p+1)=*p;//把i后⾯的元素都向后移⼀位16 *q=e;//在i位置插⼊e17 ++L.length;//长度增加18return OK;19 }在顺序线性表L中删除第i个位置的元素，并⽤e返回其值：int ListDelete_Sq(SqList &L,int i, int &e){// i的合法值为1≤i≤L.lengthint *p;int *q;if(i<1||i>L.length) return ERROR;p=&(L.elem[i-1]);//把i位置的地址赋值给pe=*p;//把i位置的值赋值给eq=L.elem+L.length-1;for(++p; p<=q; ++p)*(p-1)=*p;//i后⾯的元素向前移⼀位，直接覆盖i位置的值--L.length;//长度减少return OK;}顺序表基本操作之输出：int Load_Sq(SqList &L){// 输出顺序表中的所有元素int i;if(L.length==0) printf("The List is empty!");else{printf("The List is: ");for( i=0; i<L.length; i++) printf("%d ",L.elem[i]); // 请填空}printf("\n");return OK;}下⾯是主函数：1int main()2 {3 SqList T;4int a, i;5 ElemType e, x;6if(InitList_Sq(T)) // 判断顺序表是否创建成功7 {8 printf("A Sequence List Has Created.\n");9 }10while(1)11 {12 printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");13 scanf("%d",&a);14switch(a)15 {16case1:17 scanf("%d%d",&i,&x);18if(!ListInsert_Sq(T,i,x)) printf("Insert Error!\n"); // 判断i值是否合法19else printf("The Element %d is Successfully Inserted!\n", x);20break;21case2:22 scanf("%d",&i);23if(!ListDelete_Sq(T,i,e)) printf("Delete Error!\n"); // 判断i值是否合法24else printf("The Element %d is Successfully Deleted!\n", e);25break;26case3:27 Load_Sq(T);28break;29case0:30return1;31 }32 }33 }。
实现顺序表的各种基本运算的算法
实现顺序表的各种基本运算的算法顺序表是一种线性表，可以用数组来实现。
在顺序表中，数据元素在数组中的存储位置是按照逻辑顺序依次排列的。
顺序表中的基本运算包括插入、删除、查找、遍历等。
1. 插入操作顺序表的插入操作是指在顺序表中的指定位置插入一个元素。
插入操作分为两种情况：(1) 在顺序表的末尾插入元素；(2) 在顺序表的中间插入元素。
插入操作算法如下：(1) 在顺序表的末尾插入元素：a. 判断顺序表是否已满，如果已满则输出错误信息；b. 否则将元素插入到顺序表的末尾。
(2) 在顺序表的中间插入元素：a. 判断顺序表是否已满，如果已满则输出错误信息；b. 否则将指定位置之后的元素向后移动一个位置；c. 将新元素插入到指定位置。
2. 删除操作顺序表的删除操作是指删除顺序表中指定位置的元素。
删除操作分为两种情况：(1) 删除顺序表的末尾元素；(2) 删除顺序表的中间元素。
删除操作算法如下：(1) 删除顺序表的末尾元素：a. 判断顺序表是否为空，如果为空则输出错误信息；b. 否则删除顺序表的最后一个元素。
(2) 删除顺序表的中间元素：a. 判断顺序表是否为空，如果为空则输出错误信息；b. 否则将指定位置之后的元素向前移动一个位置；c. 删除指定位置的元素。
3. 查找操作顺序表的查找操作是指在顺序表中查找指定元素的位置。
查找操作分为两种情况：(1) 查找顺序表中第一个符合条件的元素；(2) 查找顺序表中所有符合条件的元素。
查找操作算法如下：(1) 查找顺序表中第一个符合条件的元素：a. 从表头开始遍历顺序表；b. 如果找到符合条件的元素，则返回该元素的位置；c. 如果遍历完整个顺序表都没有找到符合条件的元素，则返回错误信息。
(2) 查找顺序表中所有符合条件的元素：a. 从表头开始遍历顺序表；b. 如果找到符合条件的元素，则输出该元素的位置；c. 如果遍历完整个顺序表都没有找到符合条件的元素，则输出错误信息。
《数据结构与算法》课后习题答案
2.3 课后习题解答2.3.2 判断题1．线性表的逻辑顺序与存储顺序总是一致的。
（×）2．顺序存储的线性表可以按序号随机存取。
（√）3．顺序表的插入和删除操作不需要付出很大的时间代价，因为每次操作平均只有近一半的元素需要移动。
（×）4．线性表中的元素可以是各种各样的，但同一线性表中的数据元素具有相同的特性，因此属于同一数据对象。
（√）5．在线性表的顺序存储结构中，逻辑上相邻的两个元素在物理位置上并不一定相邻。
（×）6．在线性表的链式存储结构中，逻辑上相邻的元素在物理位置上不一定相邻。
（√）7．线性表的链式存储结构优于顺序存储结构。
（×）8．在线性表的顺序存储结构中，插入和删除时移动元素的个数与该元素的位置有关。
（√）9．线性表的链式存储结构是用一组任意的存储单元来存储线性表中数据元素的。
（√）10．在单链表中，要取得某个元素，只要知道该元素的指针即可，因此，单链表是随机存取的存储结构。
（×）11．静态链表既有顺序存储的优点，又有动态链表的优点。
所以它存取表中第i个元素的时间与i无关。
（×）12．线性表的特点是每个元素都有一个前驱和一个后继。
（×）2.3.3 算法设计题1．设线性表存放在向量A[arrsize]的前elenum个分量中，且递增有序。
试写一算法，将x 插入到线性表的适当位置上，以保持线性表的有序性，并且分析算法的时间复杂度。
【提示】直接用题目中所给定的数据结构（顺序存储的思想是用物理上的相邻表示逻辑上的相邻，不一定将向量和表示线性表长度的变量封装成一个结构体），因为是顺序存储，分配的存储空间是固定大小的，所以首先确定是否还有存储空间，若有，则根据原线性表中元素的有序性，来确定插入元素的插入位置，后面的元素为它让出位置，（也可以从高下标端开始一边比较，一边移位）然后插入x ，最后修改表示表长的变量。
int insert (datatype A[],int *elenum,datatype x) /*设elenum为表的最大下标*/ {if (*elenum==arrsize-1) return 0; /*表已满，无法插入*/else {i=*elenum;while (i>=0 && A[i]>x) /*边找位置边移动*/{A[i+1]=A[i];i--;}A[i+1]=x; /*找到的位置是插入位的下一位*/(*elenum)++;return 1; /*插入成功*/}}时间复杂度为O(n)。
数据结构预算法 习题解答第2章
1．循环队列的优点是什么？如何判别它的空和满？ 循环队列的优点是能够克服“假溢满”现象。 设有循环队列 sq，队满的判别条件为： （sq->rear+1）%maxsize==sq->front;或 sq->num==maxsize。 队空的判别条件为： sq->rear==sq->front。 2．栈和队列数据结构各有什么特点，什么情况下用到栈，什么情况下用到队列？ 栈和队列都是操作受限的线性表，栈的运算规则是“后进先出”，队列的运算规则是“先进先出”。栈 的应用如数制转换、递归算法的实现等，队列的应用如树的层次遍历等。 3．什么是递归？递归程序有什么优缺点？ 一个函数在结束本函数之前，直接或间接调用函数自身，称为递归。例如，函数 f 在执行中，又调用 函数 f 自身，这称为直接递归；若函数 f 在执行中，调用函数 g，而 g 在执行中，又调用函数 f，这称为间 接递归。在实际应用中，多为直接递归，也常简称为递归。 递归程序的优点是程序结构简单、清晰，易证明其正确性。缺点是执行中占内存空间较多，运行效率 低。 4．设有编号为 1,2,3,4 的四辆车，顺序进入一个栈式结构的站台，试写出这四辆车开出车站的所有可 能的顺序（每辆车可能入站，可能不入站，时间也可能不等）。 1234，1243，1324，1342，1432，213，2143，2314，2341，2431，3214，3241，3421，4321
【提示】对顺序表 A，从前向后依次判断当前元素 A->data[i]是否介于 x 和 y 之间，若是，并不立即删除， 而是用 n 记录删除时应前移元素的位移量；若不是，则将 A->data[i]向前移动 n 位。n 用来记录当前已删除 元素的个数。
void delete(Seqlist *A,int x,int y)
数据结构——从顺序表中删除重复的元素
数据结构——从顺序表中删除重复的元素问题描述：设计⼀个算法从顺序表中删除重复的元素，并使剩余元素间的相对次序保持不变。
例如：原顺序表为｛4 2 8 4 2 1 2 1 3 5 2｝，执⾏该算法后，顺序表为：｛4 2 8 1 3 5｝。
另外，顺序表的初始值通过调⽤算法initRandomize(int *arr, int n, int min, int max)产⽣。
rand()函数⽤来产⽣随机数，但是，rand()的内部实现是⽤线性同余法实现的，是伪随机数，由于周期较长，因此在⼀定范围内可以看成是随机的。
rand()会返回⼀个范围在0到RAND_MAX（32767）之间的伪随机数（整数）。
在调⽤rand()函数之前，可以使⽤srand()函数设置随机数种⼦，如果没有设置随机数种⼦，rand()函数在调⽤时，⾃动设计随机数种⼦为1。
随机种⼦相同，每次产⽣的随机数也会相同。
rand()函数需要的头⽂件是：<stdlib.h>rand()函数原型：int rand(void);使⽤rand()函数产⽣1-100以内的随机整数：int number1 = rand() % 100+1;⼆、srand()srand()函数需要的头⽂件仍然是：<stdlib.h>srand()函数原型：void srand (usigned int seed);srand()⽤来设置rand()产⽣随机数时的随机数种⼦。
参数seed是整数，通常可以利⽤time(0)或geypid(0)的返回值作为seed。
使⽤rand()和srand()产⽣1-100以内的随机整数:srand(time(0));int number1 = rand() % 100+1;三、使⽤rand()和srand()产⽣指定范围内的随机整数的⽅法“模除+加法”的⽅法因为，对于任意数，0<=rand()%(n-m+1)<=n-m因此，0+m<=rand()%(n-m+1)+m<=n-m+m因此，如要产⽣[m,n]范围内的随机数num，可⽤：int num=rand()%(n-m+1)+m;其中的rand()%(n-m+1)+m算是⼀个公式，记录⼀下⽅便以后查阅。
数据结构课后习题答案
线性表：是具有相同属性的n（n≥0）个数据元素的有限序列。
顺序表：顺序表（Sequential List）是采用顺序存储结构的线性表。
{if(p->data!=q->data) q=q->next;
else {p=p->next; q=y;}
}return p;}
2.10 已知递增有序的两个单链表A和B各存储了一个集合。设计算法实现求两个集合的交集运算C=A∩B。
typedef intDataType;
typedefstructNode
structNode*next;
}LinkList;
intdeleteDupNode(LinkList*L,DataTypeitem)
{LinkList *p,*q,*r;
q=L;p=L->next;
while (p)
if (p->data==item){q->next=p->next;free(p);p=q->next;}
三种经典结构：线性表、树和图。
线性表：有且仅有一个开始结点和一个终端结点，其余的内部结点都有且仅有一个前趋结点和一个后继结点，数据元素间存在着一对一的相互关系。
树：有且仅有一个开始结点，可有若干个终端结点，其余的内部结点都有且仅有一个前趋结点，可以有若干个后继结点，数据元素间存在着一对多的层次关系。
q=L->next->next;L->next->next=NULL;
数据结构第二章习题
第2章线性表一、单项选择题1．线性表是具有n个_________的有限序列。
A．表元素B．字符C．数据元素D．数据项2．线性表是_________。
A．一个有限序列，可以为空B．一个有限序列，不可以为空C．一个无限序列，可以为空D．一个无限序列，不可以为空3．线性表采用链表存储时，其地址_________。
A．必须是连续的B．一定是不连续的C．部分地址必须是连续的D．连续与否均可以4．链表不具备的特点是_________。
A．可随机访问任一结点B．插入删除不需要移动元素C．不必事先估计存储空间D．所需空间与其长度成正比5．设线性表有n个元素，以下操作中，_________在顺序表上实现比在链表上实现效率更高。
A．输出第i(1≤i≤n)个元素值B．交换第1个元素与第2个元素的值C．顺序输出这n个元素的值D．输出与给定值x相等的元素在线性表中的序号6．设线性表中有2n个元素，以下操作中，_________在单链表上实现要比在顺序表上实现效率更高。
A．删除指定的元素B．在最后一个元素的后面插入一个新元素C．顺序输出前k个元素D．交换第i个元素和第2n-i-1个元素的值(i=0,1…,n-1)7．如果最常用的操作是取第i个结点及其前驱，则采用_________存储方式最节省时间。
A．单链表B．双链表C．单循环链表D．顺序表8．与单链表相比，双链表的优点之一是_________。
A．插入和删除操作更简单B．可以进行随机访问C．可以省略表头指针或表尾指针D．访问前后相邻结点更灵活9．带头结点的单链表L为空的判定条件是_________。
A．L= =NULL B．L->next= =NULLC．L->next= =L D．L!=NULL10．在一个具有n 个结点的有序单链表中插入一个新结点并仍然保持有序的时间复杂度是_________。
A．O(1) B．O(n)C．O(n2) D．O(nlog2n)11．在一个长度为n(n>1)的带头结点的单链表h上，另设有尾指针r（指向尾结点），执行_________操作与链表的长度有关。
删除顺序表中多馀的元素
p=L.elem; // p的初值为第1个元素的存储位置
while(i<=L.length&&(*p++!=e))
#define ERROR 0
#define INFEASIBLE -1 // 不可实行的
#define OVERFLOW -2 // 溢出
#include<process.h> // exit()
InitList(&L); // 创建空表L成功
printf("請輸入順序表中的元素個數n的值：");
scanf("%d",&n);
printf("请输入L的%d个数据元素：",n);
for(j=1;j<=n;j++) // 在表L中插入元素
{
ElemType *newbase,*q,*p;
if(i<1||i>(*L).length+1) // i值不合法
return ERROR;
if((*L).length>=(*L).listsize) // 当前存储空间已满，增加分配
q=L.elem+L.length-1; // 表尾元素的位置
for(p;p<=q;++p) // 被删除元素之后的元素左移
*p=*(p+1);
q=(*L).elem+i-1; // q为插入位置
for(p=(*L).elem+(*L).length-1;p>=q;--p) // 插入位置及之后的元素右移
练习1设有两个按元素递增的有序表A与B,设计一个算法将
针，试设计一个算法，将这两个有序链表合并成一个非递减有 序单链表。要求结果链表仍使用原来两个链表的存储空间，不 另外占用其他的存储空间。表中允许有重复的数据。
2019/1/21
1：
SLink *MaxNode(SLink *sq) { SLink *p=sq->next,*q=p; while (p!=NULL) { if (p->data>q->data) q=p; p=p->next; } return q; }
2019/1/21
void Move(SqList A) { //将整型元素互不相等的线性表A中的奇数移到偶数之前 int i=0,j,k; j=A.len-1; ElemType temp; while(i<=j) { while(A.data[i]%2==0) i++; while(A.data[j]%2==1) j--; if(i<j) { temp=A.data[i];A.data[i]=A.data[j];A.data[j]=temp;} } }
删除线性表中元素值在（x,y）之间的元素
删除线性表中元素值在（x,y）之间的元素思路：如果找到⼀个需要删除的元素就⽴即删除，可能会造成许多元素被多次向前移动，时间复杂度为O(n2)。
为了提⾼效率，可以设置两个下标变量si和di。
si指向源，di指向⽬标。
先是si向后移，直到si指向的数不在(x,y)的范围内。
然后将源复制到⽬标，直到si指向的数在(x,y)的范围内。
时间复杂度：该每个元素都要检查⼀次，判断是否应该删除，最后情况下，第⼀个元素在(x,y)范围内，以后的元素都不在次范围内，此时需要移动n-1次，所以时间代价为O(n)。
程序代码： void del_elem(PSeqList plist,int x,int y) { int si,di,n; si = 0; di = 0; n = plist->n; while(si<n) { while(si<n && plist->element[si]>x && plist->element[si]<y) { si++; plist->n--; } while(si<n && (plist->element[si]<=x || plist->element[si]>=y)) { if (si == di) { si++; di++; } else plist->element[di++] = plist->element[si++] } return plist; }。