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

合集下载

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法顺序表是一种基本的数据结构,它可以存储线性结构,支持随机访问,具有较好的存储效率。

在实际应用中,我们需要实现顺序表的各种基本运算,包括插入、删除、查找、遍历、排序等操作。

下面介绍一些实现顺序表基本运算的算法。

1.插入算法顺序表插入算法的基本思路是:将插入位置之后的所有元素向后移动一位,然后将待插入元素放入插入位置。

具体实现如下:```void Insert(SqList &L, int pos, int data){if (pos < 1 || pos > L.length + 1) // 插入位置非法return;if (L.length == L.MAXSIZE) // 顺序表已满return;for (int i = L.length; i >= pos; i--) // 将pos以后的元素依次后移,腾出pos位置L.data[i] = L.data[i - 1];L.data[pos - 1] = data; // 将新元素插入pos位置L.length++; // 顺序表长度+1}```2.删除算法顺序表删除算法的基本思路是:将待删除元素之后的所有元素向前移动一位,然后将顺序表长度减1。

具体实现如下:```void Delete(SqList &L, int pos){if (pos < 1 || pos > L.length) // 删除位置非法return;for (int i = pos; i < L.length; i++) // 将pos以后的元素依次前移,覆盖pos位置L.data[i - 1] = L.data[i];L.length--; // 顺序表长度-1}```3.查找算法顺序表查找算法的基本思路是:从表头开始逐个比较元素,直到找到目标元素或者搜索到表尾。

具体实现如下:```int Search(SqList L, int data){for (int i = 0; i < L.length; i++){if (L.data[i] == data) // 找到目标元素,返回其下标return i;}return -1; // 未找到目标元素,返回-1}```4.遍历算法顺序表遍历算法的基本思路是:从表头开始依次输出元素。

顺序表的初始化插入删除等基本操作算法(C语言)

顺序表的初始化插入删除等基本操作算法(C语言)

/* Linear Table On Sequence Structure */#include <stdio.h>#include<stdlib.h>#include <string.h>#include <windows.h>/*------------------------------------------------------*/typedef int status;#define LISTINCREMENT 10#define LIST_INIT_SIZE 100#define TRUE 1#define FALSE 0#define OVERFLOW -2#define ERROR 0#define OK 1typedef struct{int item1;}Elemtype;typedef struct{Elemtype * elem;int length;int listsize;}SqList;/*------------------------------------------------------*/status Getlist_One(SqList *L);status SaveData(SqList * L);status InitList_One(SqList *L);status IntiaList(SqList * L);status DestroyList(SqList * L);status ClearList(SqList* L);status ListEmpty(SqList L);int ListLength(SqList L);status GetElem(SqList L,int i,Elemtype * e);status LocatElem(SqList L,Elemtype e);/*status PriorElem(SqList L,Elemtype cur,Elemtype * pre_e); status NextElem(SqList L,Elemtype cur,Elemtype * next_e); */status ListInsert(SqList * L,status i, Elemtype e);status ListDelete(SqList * L);status ListTrabverse(SqList L,void (* visit)(Elemtype e));/*------------------------------------------------------*/status equal(Elemtype x, Elemtype y);void display(Elemtype e);/*------------------------------------------------------*/void menu(void);/*------------------------------------------------------*/void main(void){SqList L1,L2;int op=0;L1.elem=L2.elem=NULL;char*L1_info_filename="L1.dat";InitList_One(&L1);/*L1.elem=(Elemtype *) malloc(sizeof(Elemtype)*10);L1.length=4;L1.elem[0].item1=1;L1.elem[1].item1=2;L1.elem[2].item1=3;L1.elem[3].item1=4;*/do{//clrscr();menu();printf(" Please input your option[0-12]:");scanf("%d",&op);switch(op){case 0: break;case 1: printf("\n here is IntiaList(),which being realized\n");if(IntiaList(&L1)==OK)printf("\n 初始化成功\n");elseprintf(" 初始化失败\n");getchar();getchar();break;case 2: printf("\n here is DestroyList(),which being realized\n");DestroyList(&L1);if(L1.elem==NULL)printf("\n 销毁成功\n");else printf("\n 销毁失败\n");getchar();getchar();break;case 3: printf("\n here is ClearList(),which being realized\n");ClearList(&L1);if(L1.length==0)printf("\n 置空成功\n");else printf("\n 置空失败\n");getchar();getchar();break;case 4: printf("\n here is ListEmpty(),which being realized\n");if(ListEmpty(L1)==TRUE)printf("\n 该表为空\n");else printf("\n 该表不为空\n");getchar();getchar();break;case 5: printf("\n here is ListLength() ,which being realized\n");int i5;i5=ListLength(L1);printf(" 表长为:%d\n",i5);getchar();getchar();break;case 6: printf("\n here is GetElem(),which being realized\n");int i6;Elemtype e6;printf(" 输入需得到元素的序号:");scanf("%d",&i6);GetElem(L1,i6,&e6);printf(" 第%d个元素的值为:%d\n",i6,e6.item1);getchar();getchar();break;case 7: printf("\n here is LocatElem(),which being realized\n");Elemtype a;printf(" 输入需寻找的元素的值:");scanf("%d",&a.item1);if(LocatElem(L1,a)==TRUE)printf("\n 线性表中存在该元素。

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法

实现顺序表的各种基本运算的算法
1.初始化顺序表:首先需要定义一个数组来存储顺序表中的元素,在初始化顺序表时,需要给定顺序表的大小,即可创建一个空的顺序表。

2. 插入元素:要在顺序表中插入一个元素,需要确定插入位置
和插入元素的值。

插入元素时,需要将插入位置后面的元素都向后移动一位,然后将插入元素插入到插入位置。

3. 删除元素:要从顺序表中删除一个元素,需要确定删除位置。

删除元素时,需要将删除位置后面的元素都向前移动一位,然后将最后一个元素移到删除位置处,即可完成删除操作。

4. 查找元素:要在顺序表中查找一个元素,可以使用顺序查找
或者二分查找算法。

顺序查找需要遍历整个顺序表,而二分查找需要先对顺序表进行排序,然后再进行查找。

5. 修改元素:要修改顺序表中的一个元素,需要先查找到该元
素的位置,然后再进行修改操作。

6. 获取顺序表长度:顺序表的长度就是顺序表中元素的个数,
可以通过遍历整个顺序表来获取其长度。

7. 清空顺序表:清空顺序表就是将顺序表中的元素全部删除,
可以通过遍历整个顺序表进行删除操作来实现。

8. 销毁顺序表:销毁顺序表就是释放顺序表所占用的内存空间,可以通过调用系统函数来实现。

以上就是实现顺序表的各种基本运算的算法。

实现顺序表各种基本运算的算法.doc

实现顺序表各种基本运算的算法.doc

实现顺序表各种基本运算的算法.doc
创建顺序表:创建顺序表需要先确定表的大小,即容量。

可以通过动态分配内存来创建顺序表,或者直接在程序中定义一个静态数组作为顺序表的存储空间。

创建时需要初始化表中元素的数量为0。

插入元素:在顺序表中插入元素时,需要先判断表是否已满。

如果表已满,则需要扩容。

扩容可以通过动态分配更大的内存空间,并将原有元素拷贝到新的内存空间中来实现。

如果表未满,则可以直接在表的末尾插入元素。

如果要在指定位置插入元素,则需要先将该位置及其后面的元素依次后移一个位置,再在该位置插入新元素。

删除元素:在顺序表中删除元素时,需要先判断要删除的元素是否存在。

如果不存在,则无需进行任何操作。

如果存在,则可以直接删除该元素。

如果要删除指定位置的元素,则需要先将该位置后面的元素依次前移一个位置,再将表中元素的数量减1。

查找元素:在顺序表中查找元素时,可以使用顺序查找或二分查找算法。

顺序查找的时间复杂度为O(n),而二分查找的时间复杂度为O(log n)。

在使用二分查找时,需要保证顺序表中的元素已经按照升序或降序排列。

修改元素:在顺序表中修改元素时,需要先查找该元素的位置,然后将其修改为新值。

输出顺序表:输出顺序表时,需要遍历表中所有元素,并将它们依次输出。

可以使用循环来实现遍历。

总之,实现顺序表的基本运算需要涉及到动态内存分配、数组操作、循环遍历和查找算法等知识点。

在实际应用中,还需要考虑如何优化算法效率、如何处理异常情况等问题。

顺序表(完整可运行代码)

顺序表(完整可运行代码)
if(lp->length<=0)
{
printf("No data!\n");
return;
}
for(i=0;i<lp->length;i++)
printf("%d ",lp->data[i]);
printf("\nlength of the list is: %d",lp->length);
}
void insertlist(list_type *lp,int i,int a) //插入一个元素
{
int j;
if(lp->length>=MAXNUM)
{
printf("the list is full,can not insert.");
}
if(i<1 || i>lp->length+1)
{
printf("\n%d is invalid value",i);
}
for(j=lp->length-1;j>i-1;j--)
3)在已创建好的顺序表中删除一个元素:从键盘读入欲删除的元素位置(序号),调用删除函数完成删除操作;然后将顺序表元素依次输出到屏幕上。#include<stdio.h>
#define MAXNUM 20
#define true 1
#define false 0
typedef struct
{
int data[MAXNUM];
return(false);
}
for(j=i;j<lp->length;j++)

实验报告

实验报告
2.熟练掌握单链表上的建立、插入、删除和查找等算法。
二、实验内容
编写实现单链表的基本算法(初始化、查找、插入、删除等)的函数,并在此基础上设计一个主程序完成如下功能:
⑴初始化单链表H;
⑵采用尾插法建立单链表H,如(a,b,c,d,c);
⑶输出单链表H的长度;
⑷输出单链表H的第i个元素,如输出单链表H的第3个元素;
ch=getchar();
}
//初始化链表
Lnode *establish_h(Lnode*p)
{
Lnode *q;int i;int t;
p=(Lnode*)malloc(sizeof(Lnode));
printf("请输入需要输入的元素个数\n");
scanf("%d",&t);
p->data=t;//头节点存储元素个数
⑴初始化顺序表L;
⑵建立顺序表L,如(a,b,c,d,c);
⑶输出顺序表L的长度;
⑷输出顺序表L的第i个元素,如第3个元素;
⑸输出给定元素的位置,如输出元素a的位置;
⑹在第i个元素前插入给定元素,如在第4个元素前插入元素f;
⑺删除顺序表L的第i个元素,如删除顺序表L的第3个元素。
注:最好编写输出顺序表L的函数供主程序调用,以检验⑵⑹⑺操作是否成功。
scanf("%d",&e);
insert_sq(&a,i,e);
out_list(a);
}break;
case 3:{
printf("\n请输入要删除元素位置(大于等于1,小于等于%d):",a.length);
scanf("%d",&i);

实现顺序表的各种基本运算

实现顺序表的各种基本运算
{int i;
if(ListEmpty(L))return;
for(i=0;i<L->length;i++)
printf("%c",L->data[i]);
printf("\n");
}
int GetElem(SqList*L,int i,ElemType e)/*获取顺序表L中的第i个元素*/
{if(i<1||i>L->length)//查找是否有这个i,若没有返回0
GetElem(L,3,12);
printf("(6)顺序表第3个元素=%d\n",12);
printf("(7)元素a的位置=%d\n",LocateEmpty(L,'a'));
printf("(8)在第4个数位置上插入8元素\n");
ListInsert(L,4,'8');
printf("(9)输出顺序表L:");
{ElemType data[MaxSize];
int length;
}SqList;//顺序表类型的定义
void InitList(SqList*&L)//初始化顺序表L
{L=(SqList*)malloc(sizeof(SqList));
L->length=0;
}
void DestroyList(SqList*&L)//释放顺序表L
7、在顺序表中查找一个给定元素在表中的位置;
8、顺序表的删除;9、释放顺序表
三、算法思想与算法描述简图
四、实验步骤与算法实现
#include<stdio.h>

顺序表的建立与基本算法代码

顺序表的建立与基本算法代码

顺序表的建立与基本算法代码顺序表是一种线性数据结构,它是由一块连续的内存空间组成的,可以存储一定数量的元素。

顺序表的建立需要定义一个结构体来存储元素和一些基本的算法代码。

在建立顺序表之前,需要定义一个元素的数据类型,例如:```typedef struct {int data;} Element;```接着,定义顺序表结构体,包括元素数组和当前元素个数等信息: ```typedef struct {Element *array;int length;int capacity;} SeqList;```在创建顺序表时,需要传入容量参数来初始化结构体:```SeqList* createSeqList(int capacity) {SeqList *list = (SeqList *)malloc(sizeof(SeqList));list->array = (Element *)malloc(capacity *sizeof(Element));list->length = 0;list->capacity = capacity;return list;}```向顺序表中插入元素需要判断当前元素数量是否已达到容量上限,如果是则需要扩容。

插入元素的算法代码如下:```bool insert(SeqList *list, Element e, int index) {if (list->length >= list->capacity) {list->array = (Element *)realloc(list->array,(list->capacity + 1) * sizeof(Element));list->capacity++;}if (index < 0 || index > list->length) {return false;}for (int i = list->length; i > index; i--) {list->array[i] = list->array[i - 1];}list->array[index] = e;list->length++;return true;}```删除元素同样需要判断当前元素数量是否足够,如果可以缩小容量则需要进行缩容操作。

顺序表的建立、输出、插入、删除

顺序表的建立、输出、插入、删除

顺序表的建⽴、输出、插⼊、删除1.顺序表的建⽴,⼀定要记得要分配内存,然后就把输⼊的数插⼊进去就可以了。

//建⽴顺序表Status InitList_Sq(SqList &L,int n){L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));//分配内存if(!L.elem)exit(OVERFLOW);//判断是否溢出printf("请输⼊顺序表中元素:");for(int i=0;i<n;i++){scanf("%d",&L.elem[i]);}L.length=n;L.listsize=LIST_INIT_SIZE;return OK;}2.插⼊元素的时候,要判断位置是否有效,还要注意内存分配的问题,要判断,如果内存不够他插⼊新的元素就要重新分配内存,然后插⼊要从最后⼀个往下移,倒数第⼆个移到倒数第⼀个.......顺序不要弄反了。

//顺序表的插⼊Status InsertList_Sq(SqList &L,int i,ElemType e){if(i<1||i>L.length+1)return ERROR;//判断位置是否有效if(L.length>=L.listsize){//判断是否需要重新分配内存ElemType *newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));//重新分配内存,这⾥newbase对应的是elem,所以定义的时候必须是ElemType *newbase if(!newbase)exit(OVERFLOW);//重新分配完之后还要判断是否溢出L.elem=newbase;//把新的内存赋给L.elemL.listsize+=LISTINCREMENT;}ElemType *q=&(L.elem[i-1]);//定义⼀个指针指向需要插⼊的位置ElemType *p=&(L.elem[L.length-1]);//定义⼀个指针指向指针的末尾for(p;p>=q;p--){*(p+1)=*p;//就是把倒数第⼀赋给倒数第⼆,倒数第三赋给倒数第⼆......}*q=e;//最后吧需要插⼊的元素的值赋给qL.length++;//顺序表的长度加⼀return OK;}3.删除的时候还是要先判断删除的位置是否有效,然后就找到删除的位置,让他下⾯的元素依次往上赋值//顺序表的删除Status DeleteList_Sq(SqList &L,int i){if(i<1||i>L.length)return ERROR;//判断位置是否有效ElemType *p=&(L.elem[i-1]);//定义⼀个指针指向要删除位置ElemType *q=&(L.elem[L.length-1]);//定义⼀个指针指向顺序表的末尾for(p;p<=q;p++){*p=*(p+1);//将删除位置以下的元素依次向上赋值}L.length--;//顺序表的长度减⼀return OK;}4.总的代码为#include <stdio.h>#include<malloc.h>//分配内存的时候需要使⽤#include <iostream>//exit需要使⽤#define OK 1#define ERROR 0#define OVERFLOW -1//判断是否溢出的时候要使⽤#define LIST_INIT_SIZE 10#define LISTINCREMENT 100typedef int ElemType;typedef int Status;typedef struct{ElemType *elem;int length;int listsize;}SqList;//建⽴顺序表Status InitList_Sq(SqList &L,int n){L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));//分配内存if(!L.elem)exit(OVERFLOW);printf("请输⼊顺序表中元素:");for(int i=0;i<n;i++){scanf("%d",&L.elem[i]);}L.length=n;L.listsize=LIST_INIT_SIZE;return OK;}//输出顺序表中的元素Status ExitList_Sq(SqList L){for(int i=0;i<L.length;i++){printf("%d ",L.elem[i]);}printf("\n");}//顺序表的插⼊Status InsertList_Sq(SqList &L,int i,ElemType e){if(i<1||i>L.length+1)return ERROR;//判断位置是否有效if(L.length>=L.listsize){//判断是否需要重新分配内存ElemType *newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));//重新分配内存,这⾥newbase对应的是elem,所以定义的时候必须是ElemType *newbaseif(!newbase)exit(OVERFLOW);//重新分配完之后还要判断是否溢出L.elem=newbase;//把新的内存赋给L.elemL.listsize+=LISTINCREMENT;}ElemType *q=&(L.elem[i-1]);//定义⼀个指针指向需要插⼊的位置ElemType *p=&(L.elem[L.length-1]);//定义⼀个指针指向指针的末尾for(p;p>=q;p--){*(p+1)=*p;//就是把倒数第⼀赋给倒数第⼆,倒数第三赋给倒数第⼆...... }*q=e;//最后吧需要插⼊的元素的值赋给qL.length++;//顺序表的长度加⼀return OK;}//顺序表的删除Status DeleteList_Sq(SqList &L,int i){if(i<1||i>L.length)return ERROR;//判断位置是否有效ElemType *p=&(L.elem[i-1]);//定义⼀个指针指向要删除位置ElemType *q=&(L.elem[L.length-1]);//定义⼀个指针指向顺序表的末尾for(p;p<=q;p++){*p=*(p+1);//将删除位置以下的元素依次向上赋值}L.length--;//顺序表的长度减⼀return OK;}int main(){SqList L;int n;printf("请输⼊顺序表中元素的个数:");scanf("%d",&n);InitList_Sq(L,n);//建⽴顺序表ExitList_Sq(L);int i;ElemType e;//顺序表的插⼊printf("请输⼊想插⼊的位置:");scanf("%d",&i);printf("请输⼊想插⼊的元素:");scanf("%d",&e);InsertList_Sq(L,i,e);ExitList_Sq(L);printf("请输⼊想删除的位置:");//顺序表的删除int m;scanf("%d",&m);DeleteList_Sq(L,m);ExitList_Sq(L);}5.实验结果。

编写顺序表的初始化、插入、删除和查找算法。

编写顺序表的初始化、插入、删除和查找算法。

编写顺序表的初始化、插入、删除和查找算法。

顺序表是一种数据结构,它是由一组连续的存储单元组成的线性表,其中每个元素占用一个存储单元,并按线性顺序存储。

在编写顺序表的算法时,需要实现以下几个基本操作:初始化、插入、删除和查找。

1. 初始化初始化顺序表的算法是将顺序表中的元素全部置为0或者空,以便后续的操作可以正确执行。

以下是一个初始化顺序表的算法:void init(int *a, int n){for(int i = 0; i < n; i++){a[i] = 0;}}其中,a表示顺序表,n表示顺序表的长度。

2. 插入插入元素是向顺序表中添加新元素的操作,常用的方法是在指定位置插入元素,此时需要将插入位置之后的元素后移。

以下是一个插入元素的算法:void insert(int *a, int n, int pos, int value){for(int i = n-1; i >= pos; i--){a[i+1] = a[i];}a[pos] = value;}其中,a表示顺序表,n表示顺序表的长度,pos表示插入位置,value表示插入的元素值。

3. 删除删除元素是从顺序表中删除指定元素的操作,常用的方法是删除指定位置的元素,此时需要将删除位置之后的元素前移。

以下是一个删除元素的算法:void remove(int *a, int n, int pos){for(int i = pos; i < n-1; i++){a[i] = a[i+1];}a[n-1] = 0;}其中,a表示顺序表,n表示顺序表的长度,pos表示删除位置。

4. 查找查找元素是从顺序表中查找指定元素的操作,常用的方法是遍历整个顺序表,逐个比较元素值。

以下是一个查找元素的算法:int search(int *a, int n, int value){for(int i = 0; i < n; i++){if(a[i] == value){return i;}}return -1;}其中,a表示顺序表,n表示顺序表的长度,value表示查找的元素值。

数据结构 顺序表基本运算实现

数据结构 顺序表基本运算实现
printf("这些元素分别是:\n");
; //依次打印输出顺序表中的元素
printf("\n");
}
//查找
locate(SeqList *list, int e)
{
int i;
printf("插入元素,请输入需要插入的位置:\n");
scanf("%d",&i);
insert(list,i,e);
printList(list);
break;
3.编写一个完整的程序实现顺序表的下列基本操作:
(1) 新建一个顺序表。。
(2) 打印输出顺序表中的元素。
(3) 在顺序表中查找某个元素。
(4) 在顺序表中指定位置插入元素。
(5) 在顺序表中删除指定位置的元素。
(6) 删除顺序表La中的某一元素。
编写一个主菜单,调用以上基本操作。
参考程序代码如下,请将其补充完整,并上机调试运行。
//顺序表的建立、查找、插入与删除,表元素为数字
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#define MAX 100 //表最大长度
//选择顺序表操作动作
printf("请输入操作对应的数字进行顺序表的操作:\n");
printf("————查询(1)\n);
printf("————插入(2)\n);
printf("————删除(3)\n);
printf("————退出(0)\n);

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

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

元素之后的所有数据都前移一个位置,最将线性表长减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语言的认识掌并掌握了线性表的顺序存储结构的表示和实现方法,掌握顺序表基本操作的算法实现,同时了解了顺序表的应用。

顺序表的基本操作【c语言】【创建、插入、删除、输出】

顺序表的基本操作【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 }。

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

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

⽤C语⾔编写⼀个完整的程序,实现顺序表的建⽴、插⼊、删除、输出等基本运算。

#include<stdio.h>#include<stdlib.h>#define maxsize 30typedef int datatype;typedef struct seqlist{datatype data[maxsize];int n;}seqlist;struct seqlist L;//顺序表初始化1-20void Stu() {printf("\n顺序表正在初始化...\n\n顺序表能储存的数据最多为30个\n\n\n");int temp=0,n=0;for(temp=0;temp<20;temp++){L.data[temp]=temp+1;n++;}//⾃定义1-20的数据⽅便检测程序L.n=n;//改变顺序表长度};//输出顺序表当前储存的数据void Show(){int temp;printf("\n\n顺序表当前储存的数据:\n ");for(temp=0;temp<L.n;temp++){//利⽤长度输出已储存的数据printf(" %d ",L.data[temp]);}printf("\n");}//在顺序表中输⼊数据void inList(){int newn,temp;reset1:printf("\n请输⼊需要储存的数据个数:\n");scanf("%d",&newn);if(newn>maxsize){printf("\n顺序表最多储存%d个数据!\n",maxsize);goto reset1;}printf("\n请输⼊你需要储存的数据:\n");for(temp=0;temp<newn;temp++){scanf("%d",&L.data[temp]);}//输⼊\更改数据for(temp=newn;temp<L.n;temp++){L.data[temp]=0;}//将不需要储存的数据置零L.n=newn;//更新顺序表长度printf("\n你插⼊的数据为:");for(temp=0;temp<newn;temp++){printf("%d\t",L.data[temp]);}}//在顺序表中查找某⼀个逻辑位置的数据并输出void search1(){int x;reset2://判断输⼊的逻辑位置printf("\n请输⼊你需要在顺序表中查找的逻辑位置:\n");scanf("%d",&x);if(x<1||x>maxsize){printf("\n逻辑位置最低为1,最⾼为30!\n");goto reset2;}int temp;for(temp=0;temp<L.n;temp++){if(x==(temp+1)){printf("\n顺序表中这个位置的数据为%d\n",L.data[temp]);return ;}}printf("顺序表中的这个逻辑位置未储存数据!\n");}//在顺序表中查找数据输⼊它的逻辑位置void search2(){int x;printf("\n请输⼊你需要在顺序表中查找的数据:\n");scanf("%d",&x);int temp;for(temp=0;temp<L.n;temp++){if(L.data[temp]==x){printf("\n查找成功!\n它在顺序表中的逻辑位置为%d\n",temp+1); return ;}}printf("在顺序表中未找到这个数据!");}//在顺序表中插⼊数据void insert(){if(L.n==maxsize){//表满则⽆法插⼊printf("当前顺序表已储存了30个数据,⽆法插⼊!\n");return;}if(L.n==0){//表空则⽆法插⼊printf("当前顺序表没有储存数据,⽆法插⼊!\n");return;}int p,x,temp1;reset3://判断输⼊的逻辑位置printf("\n请输⼊你在顺序表中需要插⼊数据的逻辑位置:\n");scanf("%d",&p);if(p<1||p>L.n){//插⼊的逻辑位置不能是顺序表的前驱和最后的后继 printf("\n插⼊的逻辑位置最⼩为1,最⾼为%d!\n",L.n);goto reset3;}printf("\n请输⼊该数据:\n");//提⽰输⼊并输⼊scanf("%d",&x);for(temp1=L.n;temp1>=p;temp1--){L.data[temp1+1]=L.data[temp1];}L.data[p]=x;L.n++;printf("\n插⼊数据后变为:");for(temp1=0;temp1<L.n;temp1++){printf("%d\t",L.data[temp1]);}}//删除顺序表中的某个位置的数据int deletel(){if(L.n==0){//表空⽆法删除printf("当前顺序表没有储存数据,⽆法删除!\n");return;}int p,temp;reset4:printf("\n请输⼊你在顺序表中需要删除的数据的逻辑位置:\n");scanf("%d",&p);if(p<1||p>L.n){printf("该逻辑位置没有储存数据!");goto reset4;}L.n--;for(temp=p;temp<=L.n;temp++){L.data[temp-1]=L.data[temp];}printf("删除数据后变为:");for(temp=0;temp<L.n;temp++){printf("%d\t",L.data[temp]);}}main(){Stu();//顺序表初始化1-20inList();//输出顺序表当前储存的数据search1();//在顺序表中查找某⼀个逻辑位置的数据并输出search2();//在顺序表中查找数据输⼊它的逻辑位置insert();//在顺序表中插⼊数据,并输出deletel();//删除顺序表中的某个位置的数据,并输出其他的元素return 0;}。

使用C语言编写程序,实现顺序表的基本运算——插入和删除

使用C语言编写程序,实现顺序表的基本运算——插入和删除
使用C语言编写程序,实现顺序表的基本运算???——插入和删除。:
1.编写一个程序,使用一维数组来表示线性表;
2.实现元素x的插入i位置操作。
3.实现元素ai元素的删除操作。
typedef struct
{
int *elem;
int length;
int listsize;
if(Create_sq(&L1,n)==1)
{
scanf("%d%d",&i,&e);
a=Listinsert_sq(&L1,i,e);
if(a==1)
printf("insert success\n");
else printf("insert false\n");
printf("the list elements are:\n");
for(i=1;i<=L1.length;i++)Fra bibliotek {
printf("%d\t",L1.elem[i-1]);
}
}
return 0;
}
{
newbase=(int*)realloc(L->elem,(L->listsize+10)*sizeof(int));
if(!newbase) exit(-2);
L->elem=newbase;
L->listsize+=10;
}
q=&(L->elem[i-1]);
for(p=&(L->elem[L->length-1]);p>=q;--p)

c语言顺序表的实现

c语言顺序表的实现

c语言顺序表的实现c语言顺序表是一种数据结构,它采用数组来存储元素,数组的下标表示元素的位置,可以方便地实现随机访问。

顺序表支持元素的插入、删除和查找等操作,是一种常用的数据结构。

在c语言中,可以使用结构体来定义顺序表,如下所示:```#define MAXSIZE 100 // 定义顺序表最大长度typedef struct {int data[MAXSIZE]; // 用数组存储元素int length; // 当前元素个数} SeqList;```其中,data数组用来存储元素,length表示当前元素个数。

顺序表的插入操作可以分为两种情况:在指定位置插入元素和在末尾插入元素。

具体实现如下:```// 在指定位置插入元素int insert(SeqList *L, int pos, int elem) {if (pos < 1 || pos > L->length + 1) { // 判断插入位置是否合法return 0;}if (L->length >= MAXSIZE) { // 判断顺序表是否已满return 0;}for (int i = L->length; i >= pos; i--) { // 将pos及其后面的元素后移L->data[i] = L->data[i-1];}L->data[pos-1] = elem; // 在pos位置插入元素L->length++; // 元素个数加1return 1;}// 在末尾插入元素int append(SeqList *L, int elem) {if (L->length >= MAXSIZE) { // 判断顺序表是否已满return 0;}L->data[L->length] = elem; // 在末尾插入元素L->length++; // 元素个数加1return 1;}```顺序表的删除操作也可以分为两种情况:删除指定位置的元素和删除末尾的元素。

c语言实现顺序表基本算法

c语言实现顺序表基本算法

c语言实现顺序表基本算法顺序表是一种常见的数据结构,它是一种线性表,其中的元素按照顺序存储。

在C语言中,我们可以使用数组来实现顺序表。

本文将介绍顺序表的基本算法,包括插入、删除、查找等操作。

1. 初始化顺序表在使用顺序表之前,需要先对其进行初始化。

初始化包括设置顺序表的容量和长度,并分配内存空间。

可以使用结构体来定义顺序表,其中包含一个存储元素的数组和一个记录长度的变量。

```c#define MAX_SIZE 100 // 定义顺序表的最大容量typedef struct {int data[MAX_SIZE]; // 存储元素的数组int length; // 顺序表的长度} SeqList;void init(SeqList *list) {list->length = 0; // 初始化长度为0}```2. 插入元素顺序表的插入操作是指将一个元素插入到指定位置。

插入操作需要将指定位置及其后面的元素依次后移,为新元素腾出空间。

插入元素时需要考虑边界情况,如插入位置超过顺序表的长度或超过最大容量等。

```cint insert(SeqList *list, int pos, int value) {if (pos < 0 || pos > list->length || list->length >= MAX_SIZE) {return 0; // 插入位置非法或顺序表已满,插入失败}for (int i = list->length; i > pos; i--) {list->data[i] = list->data[i - 1]; // 将插入位置后的元素依次后移}list->data[pos] = value; // 在指定位置插入新元素list->length++; // 长度加1return 1; // 插入成功}```3. 删除元素顺序表的删除操作是指将指定位置的元素删除。

顺序表的建立与基本算法代码

顺序表的建立与基本算法代码

顺序表的建立与基本算法代码顺序表是一种线性表的存储结构,它的特点是元素在内存中占据一块连续的地址空间。

顺序表的建立与基本算法涉及到顺序表的初始化、插入元素、删除元素、查找元素等操作。

下面我将详细介绍顺序表的建立与基本算法,并提供示例代码进行演示。

顺序表的建立首先需要定义一个存储结构,通常使用数组来表示,例如定义一个长度为n的数组来存储顺序表的元素。

顺序表的初始化操作就是为数组分配内存空间,并将数组中的元素初始化为默认值(通常是一个特殊标记,如0或者null)。

以下是顺序表的初始化代码示例:```cpp#define MAX_SIZE 100 // 定义顺序表的最大长度typedef int DataType; // 定义顺序表的元素类型为整数typedef structDataType data[MAX_SIZE]; // 存储顺序表元素的数组int length; // 当前顺序表的长度} SeqList;//初始化顺序表void InitList(SeqList* list)for (int i = 0; i < MAX_SIZE; i++)list->data[i] = 0; // 将数组元素初始化为0}list->length = 0; // 初始长度为0```初始化完毕后,可以进行元素的插入操作。

顺序表的插入操作通常有两种情况:在表尾插入元素和在表中间插入元素。

如果顺序表的长度没有达到最大长度,可以在表尾插入元素,需要注意的是插入后需要更新顺序表的长度。

以下是在表尾插入元素的代码示例:```cpp//在表尾插入元素void InsertElem(SeqList* list, DataType elem)if (list->length >= MAX_SIZE)printf("顺序表已满,无法插入新元素!\n");return;}list->data[list->length] = elem; // 将元素插入表尾list->length++; // 更新顺序表的长度```如果需要在表中间插入元素,则需要先将插入位置后的元素后移,腾出位置给新插入的元素。

顺序表的实现-包含插入-删除-查找等操作-完整源代码-有注释-包你喜欢复习过程

顺序表的实现-包含插入-删除-查找等操作-完整源代码-有注释-包你喜欢复习过程
creatsqlist(l);
initsqlist(l);
cout<<endl<<"**************************************************************************"<<endl;
cout<<"请输入要进行的操作序号:\n";
cout<<"1.插入字符"<<endl<<"2.查找数字"<<endl<<"3.删除第i位数字"<<endl<<"4.删除指定数字"<<endl<<"0.退出"<<endl<<endl;
顺序表的实现-包含插入-删除-查找等操作-完整源代码-有注释-包你喜欢
实验一顺序表的实现
实验目的:熟练掌握顺序表的基本操作(插入、删除、查找等)
置查找)
实验要求:以顺序表的动态分配存储结构来实现;所有基本操作均应该以函数的形式表示;要有运行结果并考虑到顺序表中所有情况。
if(list.data[i]==b)
{j=i+1;break;}
if(j)
cout<<"该数字的位置是:"<<j<<endl;
else
cout<<"很抱歉,表中没有这个数字,请重试!"<<endl;
}
5、插入函数insert(list)
void insert(sqlist &list)//插入函数
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
break;
case 7:
printf("请输入Lb的内容:\n");
InitList(Lb);
Build(Lb);
flag=Merger(L,Lb);
if(flag)
printf("合并成功!!\n\n");
ห้องสมุดไป่ตู้ break;
}
printf("元素不存在,删除失败!!\n\n");
break;
case 3:
printf("请输入要删除的位置i:\n");
scanf("%d",&x);
flag=ListDelete2(L,x-1); //第i个元素对应的下标为i-1
if(flag)
{
L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem) exit(OVERFLOW);
L.listsize=LIST_INIT_SIZE;
L.length=0;
return OK;
}
status Build(SqList &L) //建立表
printf("删除成功!!\n\n");
else
printf("元素不存在,删除失败!!\n\n");
break;
case 4:
Inverse(L);
break;
case 5:
Sort(L);
break;
case 6:
L.length++;
return OK;
}
status Merger(SqList &L,SqList &Lb) //合并两个线性表
{
int i,j,k;
SqList Lc;
InitList(Lc);
if(Lc.listsize<L.length+Lb.length)
printf("1 输出顺序表及顺序表的长度\n");
printf("2 删除值为x的结点\n");
printf("3 删除给定位置i的结点\n");
printf("4 将顺序表就地逆置\n");
printf("5 将顺序表按升序排序\n");
printf("6 将x插入到顺序表的适当位置上\n");
}
void Sort(SqList &L) //冒泡排序(按升序排列)
{
int i,j,t;
for(i=1;i<L.length;i++)
for(j=0;j<L.length-i;j++)
{
if(*(L.elem+j)>*(L.elem+j+1))
{
t=*(L.elem+j);
printf("7 将两个有序表合并\n");
printf("0 退出\n\n");
}
status ListDelete1(SqList &L,int x) //删除顺序表中值为x的结点
{
int i;
for(i=0;i<L.length;i++)
if(*(L.elem+i)==x)
L=Lc;
return OK;
}
int main()
{
int op,x,flag;
SqList L,Lb;
InitList(L);
Build(L);
Tips();
scanf("%d",&op);
while(op)
{
switch(op)
{
case 1:
{
int i,n;
printf("请输入元素个数n和这n个元素:\n");
scanf("%d",&n);
if(n>LIST_INIT_SIZE) //如果n的值大于当前空间
{
L.elem=(ElemType *)realloc(L.elem,(n+LISTINCREMENT)*sizeof(ElemType));
L.listsize+=LISTINCREMENT;
}
for(i=0;i<L.length;i++)
if(x<*(L.elem+i))
break;
k=i;
for(i=L.length;i>k;i--)
*(L.elem+i)=*(L.elem+i-1);
*(L.elem+k)=x;
{
Lc.elem=(ElemType *)realloc(Lc.elem,(L.length+Lb.length+LISTINCREMENT)*sizeof(ElemType));
if(!L.elem) exit(OVERFLOW);
Lc.listsize=L.length+Lb.length+LISTINCREMENT;
}
i=j=k=0;
while(i<L.length && j<Lb.length)
{
if(*(L.elem+i) < *(Lb.elem+j))
{
*(Lc.elem+k)=*(L.elem+i);
k++;i++;
}
else
{
*(Lc.elem+k)=*(Lb.elem+j);
{
int i;
if(x<0||x>=L.length)
return ERROR;
for(i=x+1;i<L.length;i++)
*(L.elem+i-1)=*(L.elem+i);
L.length--;
return OK;
}
void Inverse(SqList &L) //就地逆置函数
#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define LIST_INIT_SIZE 100
if(!L.elem) exit(OVERFLOW);
L.listsize=n+LISTINCREMENT;
}
for(i=0;i<n;i++)
scanf("%d",L.elem+i);
L.length=n;
return OK;
}
void Print(SqList &L) //输出表中元素和元素长度
{
int i;
for(i=0;i<L.length;i++)
printf("%d ",*(L.elem+i));
printf("\n长度为:%d\n\n",L.length);
}
void Tips() //选择函数,根据序号来提示操作
{
printf("请选择序号表示你要进行的操作:\n");
printf("请输入要插入的数据X:\n");
scanf("%d",&x);
flag=ListInsert(L,x);
if(flag)
printf("插入成功!!\n\n");
else
printf("插入失败!!\n\n");
*(L.elem+j)=*(L.elem+j+1);
*(L.elem+j+1)=t;
}
}
printf("已按升序排列\n\n");
}
status ListInsert(SqList &L,int x) //将x插入到顺序表的适当位置上,以保持该表的有序性。
Tips();
scanf("%d",&op);
}
return 0;
}
{
int i,t;
for(i=0;i<L.length/2;i++)
{
t=*(L.elem+i);
*(L.elem+i)=*(L.elem+L.length-i-1);
*(L.elem+L.length-i-1)=t;
}
printf("逆置成功!!!\n\n");
{
int i,k;
if(L.length>=L.listsize)
{
L.elem=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
相关文档
最新文档