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

Posted 2023-05-15

使用C语言编写程序，实现顺序表的基本运算¬¬¬——插入和删除。：
1．编写一个程序，使用一维数组来表示线性表；
2．实现元素x的插入i位置操作。
3．实现元素ai元素的删除操作。

typedef struct

int *elem;
int length;
int listsize;
Sqlist;
status Create_sq(Sqlist *L,int n)

int i;
L->elem=(int*)malloc(100*sizeof(int));
if(!L->elem) return 0;
for(i=0;i<n;i++)
scanf("%d",&(L->elem[i]));
L->length=n;
L->listsize=100;
return 1;

status Listinsert_sq(Sqlist *L,int i,int e)

int *q,*p,*newbase;
if(i<1||i>L->length+1) return 0;
if(L->length>=L->listsize)

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)
*(p+1)=*p;
*q=e;
++L->length;
return 1;

int main()

Sqlist L1;
int n,a;
int i,e;
printf("\n please input the number of data:\n");
scanf("%d",&n);
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++)

printf("%d\t",L1.elem[i-1]);



return 0;
参考技术A #include <stdio.h>
#include <malloc.h>

#define MaxSize 50

typedef char ElemType;

typedef struct

ElemType elem[MaxSize];
int length;
SqList;

void InitList(SqList *L) /* 初始化顺序表 */

L=(SqList *)malloc(sizeof(SqList));
L->length=0;


void CreateListR(SqList *L,ElemType a[],int n) /*创建顺序表 */


int i;
for(i=0;i<n;i++)
L=(SqList *)malloc(sizeof(SqList));
L->elem[i]=a[i];
L->length++;


void DispList(SqList *L) /* 输出顺序表 */

int i;
if(ListEmpty(L)) return;
for(i=0;i<L->length;i++)
printf("%c",L->elem[i]);
printf("\n");


int ListLength(SqList *L) /* 求顺序表的长度 */

return(L->length);


int ListEmpty(SqList *L) /* 求顺序表是否为空 */

return(L->length==0);


int GetElem(SqList *L,int i,ElemType e) /*求顺序表中某个数据的元素值 */

if(i<1||i>L->length)
return 0;
else
e=L->elem[i-1];
return 1;


int LocateElem(SqList *L,ElemType e) /*按值查找元素*/

int i=0;
while(i<L->length&&L->elem[i]!=e) i++;
if(i>=L->length)
return 0;
else
return i+1;


int ListInsert(SqList *L,int i,ElemType e) /*按i位置插入元素*/

int j;
if(i<1||i>L->length+1)
return 0;
i--;
for (j=L->length;j>i;j--)
L->elem[j]=L->elem[j-1];
L->elem[i]=e;
L->length++;
return 1;


int ListDelete(SqList *L,int i,ElemType e) /*删除某个位置的元素*/

int j;
if (i<1||i>L->length)
return 0;
i--;
e=L->elem[i]; /*e中的放elem[i]有何用..以后没用到*/
for(j=i;j<L->length-1;j++)
L->elem[j]=L->elem[j+1];
L->length--;
return 1;


void DestroyList(SqList *L) /*销毁链表*/

free(L);


void main()

SqList L;
ElemType a[]='a','b','c','d';
int c;
int e;
while(1)

printf("Please Choose the step you want ?\n\n");
scanf("%d",&c);
if(c==0) break;
switch(c)

case 1: InitList(&L);break;
case 2: CreateListR(&L,a,4);break;
case 3: DispList(&L);break;
case 4: printf("long %d", ListLength(&L));break;
case 5: printf("%d",ListEmpty(&L));break;
case 6: GetElem(&L,3,e);break;
case 7: LocateElem(&L,'a');break;
case 8: ListInsert(&L,4,'f');break;
case 9: DispList(&L);break;
case 10: ListDelete(&L,3,e);break;
case 11: DispList(&L);break;
case 12: DestroyList(&L);break;
default: printf("error data");break;




参考技术B 学习了

顺序表和链表的基本操作，用C语言实现！

1、顺序表的应用
(1)．输入一组整型元素序列，建立顺序表。
(2)．实现该顺序表的遍历。
(3)．在该顺序表中顺序查找某一元素,查找成功返回1,否则返回0。
(4)．判断该顺序表中元素是否对称,对称返回1,否则返回0。
(5)．实现把该表中所有奇数排在偶数之前,即表的前面为奇数,后面为偶数。
(6)．输入整型元素序列利用有序表插入算法建立一个有序表。
(7)．利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。
(8)．编写一个主函数,调试上述算法。
2、链表的应用
(1)．键盘输入一组元素，建立一个无头结点的单向链表（无序）。
(2)．遍历（打印）单向链表。
(3)．把单向链表中元素逆置（不允许申请新的结点空间）。
(4)．在单向链表中删除所有的偶数元素结点。
(5)．对链表排序，排序后链表元素按照非递减方式排列（注意：排序时如果要交换两个结点的顺序，不得通过交换结点的内容，而需要使用改变指针的方式交换结点的位置。建议使用直接插入排序算法）。
(6)．利用算法5建立两个非递减有序单向链表，然后合并成一个非递减链表。
(7)．利用算法1建立的链表，删除链表中的重复元素。
(8)．利用算法1建立的链表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为偶数（尽量利用已知的存储空间）。
(9)．判断算法1和算法5生成单链表所表示的集合是否相等。
(10)．在主函数中设计一个简单的菜单，分别调试上述算法。

顺序存储的线性表的算法
#include "stdio.h"
#include "stdlib.h"
#define Status int
#define OVERFLOW 0
#define TRUE 1
#define FALSE 0
#define OK 1
#define MAXSIZE 100
typedef int ElemType;
typedef struct list
ElemType elem[MAXSIZE];
int length;
SqList;
void InitList(SqList &L)
L.length=0;

/*建立顺序表*/
void CreateList(SqList &L)

int i;
printf("input the length");
scanf("%d",&L.length);//输入表长
for(i=1;i<=L.length;i++)
scanf("%d",&L.elem[i-1]);//输入元素

//顺序表的遍历
void printdata(ElemType e)
printf("%4d",e);

void Traverse(SqList L,void (*visit)(ElemType e))
int i;
printf("The elements of the lists are:\n");
for(i=1;i<=L.length;i++)
if (i%10==0)printf("\n");//每行显示10个元素
visit(L.elem[i-1]);//输出表中元素

printf("\n");


//有序顺序表L中插入元素e使序列仍有序
void Insert(SqList &L,ElemType e)
int i,j;
if (L.length==MAXSIZE)exit(OVERFLOW);//表满,不能插入
for(i=1;i<=L.length&&L.elem[i-1]<=e;i++);//向后查找
for(j=L.length;j>=i;j--)
L.elem[j]=L.elem[j-1];//元素后移
L.elem[i-1]=e;//插入e
L.length=L.length+1;//表长加1

//建立递增有序的顺序表
void CreateList_Sorted(SqList &L)
int i,num;
ElemType e;
L.length=0;
printf("Create a sorted list,Input the length of the list\n");
scanf("%d",&num);
printf("Input the data %d numbers\n",num);
for(i=1;i<=num;i++)
scanf("%d",&e);
Insert(L,e);


/*Merge two sorted lists*/
void MergeList(SqList La,SqList Lb,SqList &Lc)
int *pa,*pb,*pc;
if (La.length+Lb.length>MAXSIZE) exit(OVERFLOW);
else
pa=La.elem;pb=Lb.elem;pc=Lc.elem;
while (pa<La.elem+La.length&&pb<Lb.elem+Lb.length)
*pc++=(*pa<=*pb)?*pa++:*pb++;/*公共部分合并*/
while (pa<La.elem+La.length) *pc++=*pa++;
/*R1表的剩余部分放到R的后部*/
while (pb<Lb.elem+Lb.length) *pc++=*pb++;
/*R2表的剩余部分放到R的后部*/
Lc.length=La.length+Lb.length;/*R表长*/


//判断元素是否对称，对称返回TRUE 否则返回FALSE
Status Symmetric(SqList L)
int low,high;
low=0;
high=L.length-1;
while(low<high)
if (L.elem[low]==L.elem[high])low++;high--;
else return(FALSE); return(TRUE);
//顺序表的主函数部分
//#include "seqlist.h"
void main()
SqList L1,L2,L;
int select;
ElemType e;
doprintf("\n1 insert 2 merge");
printf("\n3 symmetric 0 exit \n");
printf("Please select(0--3)\n");
scanf("%d",&select);
switch(select)
case 1:
InitList(L);
CreateList_Sorted(L);
Traverse(L,printdata);
printf("\nInput the element of inserted\n");
scanf("%d",&e);
Insert(L,e);
Traverse(L,printdata);
break;
case 2:
InitList(L1);
CreateList_Sorted(L1);
Traverse(L1,printdata);
InitList(L2);
CreateList_Sorted(L2);
Traverse(L2,printdata);
InitList(L);
MergeList(L1,L2,L);
Traverse(L,printdata);
break;
case 3:
InitList(L);
CreateList(L);
Traverse(L,printdata);
if (Symmetric(L)) printf("Yes!\n"); else printf("Not\n");
break;
case 0:break;
default:printf("Error! Try again!\n");

while(select);


/*单向链表的有关操作示例*/
/*类型定义及头文件部分,文件名为sllink.h*/
#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;//元素实际类型
typedef struct LNode
ElemType data;
struct LNode *next;
LNode,*LinkList; //定义结点、指针类型名
//头插法建立无序链表
void CreateList(LinkList &L)
LinkList p;
ElemType e;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
printf("头插法建立链表，以0结束\n");
scanf("%d",&e);
while(e)
p=(LinkList)malloc(sizeof(LNode));
p->data=e;
p->next=L->next;
L->next=p;
scanf("%d",&e);


/*非递减有序单向链表L插入元素e序列仍有序*/
void Insert_Sort(LinkList &L,ElemType e)
LinkList p,s;
s=(LinkList)malloc(sizeof(LNode));
s->data=e;
p=L;
while(p->next&&p->next->data<=e)
p=p->next;/*查找插入位置*/
s->next=p->next; /*插入语句*p结点后插入*s结点*/
p->next=s;

/*建立递增有序的单向链表*/
void Create_Sort(LinkList &L)
ElemType e;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
printf("建立有序表，输入任意个整型数据以0结束\n");
scanf("%d",&e);
while(e)
Insert_Sort(L,e);
scanf("%d",&e);


/*单向链表的遍历*/
void Traverse(LinkList L)
LinkList p;
printf("遍历链表");
for(p=L->next;p;p=p->next)
printf("%5d",p->data);
printf("\n");

/*在单向链表删除元素e*/
void Delete(LinkList &L,ElemType e)
LinkList p,q;
p=L;
q=L->next;
while(q&& q->data!=e)//查找元素的删除位置
p=q;
q=q->next;

if(!q) printf("\nnot deleted");/*未找到元素e*/
else p->next=q->next;/*找到删除*/
free(q);

/*单向链表的逆置*/
void exch(LinkList &L)
LinkList p,s;
p=L->next;
L->next=NULL;
while(p)
s=p;
p=p->next;
s->next=L->next;
L->next=s;


/*两个非递减有序单向链表合并后仍为非递减序列*/
void MergeIncrease(LinkList La,LinkList Lb,LinkList &Lc)
LinkList p,q,s,rear;
p=La->next;
q=Lb->next;
Lc=rear=La;
free(Lb);
while(p&&q)
if (p->data<q->data) s=p;p=p->next;
else s=q;q=q->next;
rear->next=s;/*较小元素插入表尾*/
rear=rear->next;

if (p) rear->next=p; else rear->next=q;


/*主函数部分,文件名为sllink.c*/
//#include "sllink.h"
void main()
LinkList La,Lb,Lc;
ElemType e;
int select;
do
printf(" 1 建立无序表，再删除指定元素\n");
printf(" 2 建立递增有序表，再逆置\n");
printf(" 3 建立两个递增有序表，将它们和并为一个仍递增表\n");
printf(" 0 退出，请输入选项(0-3)\n");
scanf("%d",&select);
switch(select)
case 0:
break;
case 1:
CreateList(La);
Traverse(La);
printf("输入需删除的元素\n");
scanf("%d",&e);
Delete(La,e);
Traverse(La);
break;
case 2:
Create_Sort(La);
Traverse(La);
exch(La);
printf("The list that is exchaged\n");
Traverse(La);
break;
case 3:
Create_Sort(La);Traverse(La);
Create_Sort(Lb);Traverse(Lb);
MergeIncrease(La,Lb,Lc);Traverse(Lc);
break;
default:
printf("输入选项错误，请重新输入！\n");


while(select);

这些内容不知道能不能帮助到你。 参考技术A 你照下面的这个 去写。下面的这个是顺序表的基本操作，链表和这个差不多。
#include"1.h"
void main()

char a[5]='a','b','c','d','e';
int n=5;
char f='f',b='a',e;
SqList sq;

InitList(sq); //初始化表

CreateList(sq,a,n); //传入数据

DispList(sq); //输出表

printf("sq.length=%d\n",ListLength(sq)); //输出表长

if(ListEmpty(sq)) //判断是否为空表
printf("sq是空表\n");
else
printf("sq不是空表\n");

printf("a在第%d位\n",LocateElem(sq,b)); //按元素值查找

ListInsElem(sq,f,4); //在第4个位置上插入f元素
DispList(sq); //输出表
printf("\n");
DelElem(sq,3,e); //删除第三个元素
DispList(sq); //输出表


这是头文件
1.h

#include<stdio.h>
const MaxSize=100;
typedef struct SqList

char elem[MaxSize];
int length;
SqList,*PSqList;
SqList sq;
void InitList(SqList &sq) //初始化线性表

sq.length=0;

void CreateList(SqList &sq,char a[],int n) //建立表

int i;
for(i=0;i<n;i++)
sq.elem[i]=a[i];
sq.length=n;


int ListLength(SqList sq) //求表长

return(sq.length);

char GetElem(SqList sq,int i) //求第i个元素

if(i<1||i>sq.length)
return 0;
return sq.elem[i-1];

int LocateElem(SqList sq,char x) //按元素值查找

int i=0;
while(i<sq.length&&sq.elem[i]!=x)
i++;
if(i>sq.length)
return 0;
else return i+1;

int ListInsElem(SqList &sq,char x,int i) //插入元素在第i个位置

int j;
if(i<1||i>sq.length+1)return 0;
for(j=sq.length;j>=i;j--)
sq.elem[j]=sq.elem[j-1];
sq.elem[i-1]=x;
sq.length++;
return 1;

int DelElem(SqList &sq,int i,char &e) //删除第i个元素

int j;
if (i<1||i>sq.length)return 0;
e=sq.elem[i];
for(j=i;j<sq.length;j++)
sq.elem[j-1]=sq.elem[j];
sq.length--;
return 1;

int ListEmpty(SqList &sq) //判断表是否为空

return(sq.length==0);

void DispList(SqList sq) //输出表

int i;
if(ListEmpty(sq))return;
for(i=0;i<sq.length;i++)
printf("%c\t",sq.elem[i]);
本回答被提问者采纳 参考技术B 其实这些算法并不复杂。具体操作比较繁琐而已，有兴趣可以参考下面的程序。有什么其他想法，帮你修改下就是。
参考技术C 做任务，打扰勿怪 参考技术D 删除和查找基本操作问题补充：需要详细源码！ 其实这些算法并不复杂。具体操作比较繁琐而已，有兴趣可以参考下面的程序。有什么其他想法，帮你修改下就是追问

详细代码！