数据结构中的,线性表的c语言表示和插入,删除,查找操作程序

合集下载

数据结构线性表的基本操作及应用实验报告

实验日期2010.4.19 教师签字成绩实验报告【实验名称】第二章线性表的基本操作及应用【实验目的】（1）熟练掌握线性表的基本操作的实现；（2）以线性表的各种操作（建立、插入、删除等）的实现为重点；（3）通过本次实验加深对C语言的使用（特别是函数的参数调用、指针类型的应用和链表的建立等各种基本操作）。

【实验内容】1.顺序表的基本操作（顺序表的插入、访问、删除操作）#include <stdio.h>#include <stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -1typedef int ElemType;typedef int Status;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct{ElemType *elem;int length;int listsize;}SqList;Status InitList_Sq(SqList *L){int i,n;L->elem = (ElemType * )malloc(LIST_INIT_SIZE*sizeof(ElemType));if (! L->elem) exit (OVERFLOW);printf("您希望您的顺序表有几个元素: ");scanf("%d",&n);printf("\n");printf("输入您的%d个元素，以构建顺序表: \n",n);for(i=1;i<=n;i++)scanf("%d",&L->elem[i-1]);L->length = n;L->listsize = LIST_INIT_SIZE;return OK;}//InitList_SqStatus PrintList_Sq(SqList L){int i;printf("顺序表中的元素为：");for (i=1;i<=L.length;i++)printf("%d ",L.elem[i-1]);printf("\n");return OK;}//PrintList_Sqint ListInsert_Sq(SqList* L,int i,ElemType x) //对顺序表进行插入操作{int j;if (L->length==L->listsize){printf("\t\t\t顺序表已满");return 0;}else{if (i<1||i>L->length){printf("\t\t\t位置不合法");return 0;}else{for(j=L->length-1;j>=i-1;--j)L->elem[j+1]=L->elem[j];L->elem[i-1]=x;L->length++;return 1;}}}int ListDelete_Sq(SqList* L,int i) //对顺序表进行删除操作{int j;if (i<1||i>L->length){printf("\t\t\t不存在第i个元素");return 0;}else{for (j=i-1;j<L->length;j++){L->elem[j]=L->elem[j+1];}L->length--;return 1;}}int LocateElem(SqList *L, int i) {if(i<1||i>L->length)return ERROR;else return L->elem[i-1];}int scan(){int choose;printf("选择要执行的基本操作:\n1.插入元素；2.删除元素；3.访问元素.\n");printf("输入其他值退出程序……\n");scanf("%d",&choose);return(choose);}void main(){SqList L;ElemType e;int i;int quit=0;if (InitList_Sq(&L)==OVERFLOW)printf("分配失败，退出程序！");printf("输出程序中的元素\n");PrintList_Sq(L);while(!quit)switch(scan()){case 1:printf("\n请输入你所需要插入的位置和你要插入的元素:");printf("\n请输入i和e的值:");scanf("%d%d",&i,&e);if (ListInsert_Sq(&L,i,e)==OK) PrintList_Sq(L);break;case 2:printf("\n请输入你所需要删除元素的位置:");scanf("%d",&i);if(ListDelete_Sq(&L,i)==OK) PrintList_Sq(L);break;case 3:printf("请输入所要查找元素的位置:\n");scanf("%d",&i);if(LocateElem(&L,i))printf("该位置元素的值为:%d!\n",LocateElem(&L,i));else printf("该位置的元素不存在!\n");break;default:quit=1;printf("操作结束!");printf("\n");}}2.单向链表的基本操作（单向链表的插入、删除、查找以及并表操作）#include<stdio.h>#include<malloc.h>typedef int ElemType;#define OK 1#define ERROR 0#define flag 0typedef struct LNode{ElemType data;struct LNode *next;} LNode,*LinkList;LinkList InitLinkList(){LinkList L;L=(LinkList)malloc(sizeof(LNode));L->next=NULL;return L;}LinkList LocateLinkList(LinkList L,int i){LinkList p;int j;p=L->next;j=1;while(p!=NULL&&j<i){p=p->next; j++;}if (j==i)return p;else return NULL;}void LinkListInsert(LinkList L, int i, ElemType e)//插入元素{LinkList p,s;int j;j=1;p=L;while(p&&j<i){p=p->next;j++;}if(p==NULL||j>i)printf("插入位置不正确\n");else {s=(LNode *)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;printf("%d已插入到链表中\n",e);}}void LinkListDelete(LinkList L,int i) //删除元素{LinkList p,q;int j;j=1;p=L;while(p->next&&j<i){p=p->next;j++;}if(p->next==NULL)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;free(q);printf("第%d个元素已从链表中删除\n",i);}}LinkList CreatLinkList( )//建立单向链表{LinkList L=InitLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n"); scanf("%d",&e);while (e!=flag){p=(LinkList)malloc(sizeof(LNode));p->data=e;r->next=p;r=p;scanf("%d",&e);}r->next=NULL;return L;}int LinkListLength(LinkList L){LinkList p;int j;p=L->next;j=0;while(p!=NULL){j++;p=p->next;}return j;}void LinkListPrint(LinkList L){LinkList p;p=L->next;if(p==NULL) printf("单链表为空表\n");else{printf("链表中的元素为:\n");while(p!=NULL){printf("%d ",p->data);p=p->next;}}printf("\n");}void Mergelist_L(LinkList La,LinkList Lb,LinkList Lc) {LNode *pa,*pb,*pc,*p;pa=La->next;pb=Lb->next;Lc=La;pc=Lc;while(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else {pc->next=pb;pc=pb;pb=pb->next;}}pc->next=pa?pa:pb;p=Lc->next;printf("合并结果:");while(p) {printf("%4d",p->data);p=p->next;}free(Lb);}int scan(){int d;printf("请选择你所要执行的单向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素;4.两个单向链表的合并.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){ LinkList La,Lb,Lc;int quit=0;int i,locate;ElemType e;LinkList L,p;L=CreatLinkList();while(!quit)switch(scan()){case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);LinkListInsert(L,i,e);LinkListPrint(L);break;case 2:if(LinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);LinkListDelete(L,i);}LinkListPrint(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;case 4:La=CreatLinkList();Lb=CreatLinkList();Mergelist_L( La, Lb, Lc);printf("\n");break;default:quit=1;printf("操作结束!");printf("\n");}}3.单向循环链表的基本操作（单向链表的插入、删除、查找操作）#include<stdio.h>#include<malloc.h>typedef int ElemType;#define OK 1#define ERROR 0#define flag 0typedef struct LNode{ElemType data;struct LNode *next;} LNode,*LinkList;LinkList InitLinkList(){LinkList L;L=(LinkList)malloc(sizeof(LNode));L->next=L;return L;}LinkList LocateLinkList(LinkList L,int i){LinkList p;int j;p=L->next;j=1;while(p!=L&&j<i){p=p->next; j++;}if (j==i)return p;else return NULL;}void LinkListInsert(LinkList L, int i, ElemType e)//插入元素{LinkList p,s;int j;j=1;p=L;while(p->next!=L&&j<i){p=p->next;j++;}if(p==L||j>i)printf("插入位置不正确\n");else {s=(LNode *)malloc(sizeof(LNode));s->data=e;s->next=p->next;p->next=s;printf("%d已插入到链表中\n",e);}}void LinkListDelete(LinkList L,int i) //删除元素{LinkList p,q;int j;j=1;p=L;while(p->next!=L&&j<i){p=p->next;j++;}if(p->next==L)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;free(q);printf("第%d个元素已从链表中删除\n",i);}}LinkList CreatLinkList( )//建立单向链表{LinkList L=InitLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n"); scanf("%d",&e);while (e!=flag){p=(LinkList)malloc(sizeof(LNode));p->data=e;r->next=p;r=p;scanf("%d",&e);}r->next=L;return L;}int LinkListLength(LinkList L){LinkList p;int j;p=L->next;j=0;while(p!=L){j++;p=p->next;}return j;}void LinkListPrint(LinkList L){LinkList p;p=L->next;printf("链表中的元素为:\n");while(p!=L){printf("%d ",p->data);p=p->next;}printf("\n");}int scan(){int d;printf("请选择你所要执行的单向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){int quit=0;int i;ElemType e;LinkList L,p;L=CreatLinkList();while(!quit)switch(scan()){case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);LinkListInsert(L,i,e);LinkListPrint(L);break;case 2:if(LinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);LinkListDelete(L,i);}LinkListPrint(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;default:quit=1;printf("操作结束!");printf("\n");}}4.双向链表的基本操作（双向链表的插入、删除、查找以及并表操作）#include<stdio.h>#include<malloc.h>#define flag 0typedef int status;typedef int ElemType;typedef struct DuLNode{ElemType data;struct DuLNode *prior;struct DuLNode *next;}DuLNode,*DuLinkList;DuLinkList InitDuLinkList(){DuLinkList L;L=(DuLinkList)malloc(sizeof(DuLNode));L->next=L->prior=NULL;return L;}DuLinkList CreatDuLinkList(){DuLinkList L=InitDuLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n");scanf("%d",&e);while (e!=flag){p=(DuLinkList)malloc(sizeof(DuLNode));p->data=e;r->next=p;p->prior=r->next;r=p;scanf("%d",&e);}r->next=NULL;return L;}void ListInsert_DuL(DuLinkList L, int i, ElemType e){ DuLinkList p,s;int j;j=1;p=L;while(p&&j<i){p=p->next;j++;}if(p==NULL||j>i)printf("插入位置不正确\n");else {s=(DuLinkList)malloc(sizeof(DuLNode));s->data=e;s->next=p->next; p->next->prior=s;s->prior=p; p->next=s;printf("%d已插入到双向链表中\n",e); }}void ListDelete_DuL(DuLinkList L,int i) //删除元素{DuLinkList p,q;int j;j=1;p=L;while(p->next&&j<i){p=p->next;j++;}if(p->next==NULL)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;q->next->prior=p;free(q);printf("第%d个元素已从链表中删除\n",i); }}void LinkListPrint_DuL(DuLinkList L){DuLinkList p;p=L->next;if(p==NULL) printf("双链表为空表\n");else{printf("链表中的元素为:\n");while(p!=NULL){printf("%d ",p->data);p=p->next;}}printf("\n");}int DuLinkListLength(DuLinkList L){DuLinkList p;int j;p=L->next;j=0;while(p!=NULL){j++;p=p->next;}return j;}DuLinkList LocateDuLinkList(DuLinkList L,int i) {DuLinkList p;int j;p=L->next;j=1;while(p!=NULL&&j<i)p=p->next; j++;}if (j==i)return p;else return NULL;}void Mergelist_L(DuLinkList La,DuLinkList Lb,DuLinkList Lc){DuLNode *pa,*pb,*pc,*p;pa=La->next;pb=Lb->next;Lc=La;pc=Lc;while(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else {pc->next=pb;pc=pb;pb=pb->next;}}pc->next=pa?pa:pb;p=Lc->next;printf("合并结果:");while(p) {printf("%4d",p->data);p=p->next;}free(Lb);}int scan(){int d;printf("请选择你所要执行的双向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素;4.两个双向链表的合并.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){int quit=0;int i;ElemType e;DuLinkList L,p;DuLinkList La,Lb,Lc;L=CreatDuLinkList();while(!quit){switch(scan())case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);ListInsert_DuL(L,i,e);LinkListPrint_DuL(L);break;case 2:if(DuLinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);ListDelete_DuL(L,i);}LinkListPrint_DuL(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateDuLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;case 4:La=CreatDuLinkList();Lb=CreatDuLinkList();Mergelist_L( La, Lb, Lc);printf("\n");break;default:quit=1;printf("操作结束!");printf("\n");}}5.双向循环链表的基本操作（双向循环链表的插入、删除以及访问操作）#include<stdio.h>#include<malloc.h>#define flag 0typedef int status;typedef int ElemType;typedef struct DuLNode{ElemType data;struct DuLNode *prior;struct DuLNode *next;}DuLNode,*DuLinkList;DuLinkList InitDuLinkList(){DuLinkList L;L=(DuLinkList)malloc(sizeof(DuLNode));L->next=L; L->prior=L;return L;}DuLinkList CreatDuLinkList(){DuLinkList L=InitDuLinkList(),p,r;ElemType e;r=L;printf("请依次输入链表中的元素,输入0结束\n"); scanf("%d",&e);while (e!=flag){p=(DuLinkList)malloc(sizeof(DuLNode));p->data=e;r->next=p;p->prior=r->next;r=p;scanf("%d",&e);}r->next=L; L->prior=r;return L;}void ListInsert_DuL(DuLinkList L, int i, ElemType e){ DuLinkList p,s;int j;j=1;p=L;while(j<i){p=p->next;j++;}if(j>i)printf("插入位置不正确\n");else {s=(DuLinkList)malloc(sizeof(DuLNode));s->data=e;s->next=p->next; p->next->prior=s;s->prior=p; p->next=s;printf("%d已插入到双向循环链表中\n",e); }}void ListDelete_DuL(DuLinkList L,int i) //删除元素{DuLinkList p,q;int j;j=1;p=L;while(p->next!=L&&j<i){p=p->next;j++;}if(p->next==L)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;q->next->prior=p;free(q);printf("第%d个元素已从双向循环链表中删除\n",i); }}void LinkListPrint_DuL(DuLinkList L){DuLinkList p;p=L->next;if(p->next==L) printf("双链表为空表\n");else{printf("链表中的元素为:\n");while(p!=L){printf("%d ",p->data);p=p->next;}}printf("\n");}int DuLinkListLength(DuLinkList L){DuLinkList p;int j;p=L->next;j=0;while(p->next!=L){j++;p=p->next;}return j;}DuLinkList LocateDuLinkList(DuLinkList L,int i){DuLinkList p;int j=1;p=L->next;while(p->next!=L&&j<i){p=p->next; j++;}if (j==i)return p;else return NULL;}int scan(){int d;printf("请选择你所要执行的双向链表的基本操作:\n1.插入元素;2.删除元素;3.访问元素.\n");printf("其他键退出程序……");printf("\n");scanf("%d",&d);return(d);}void main(){ int quit=0;int i,locate;ElemType e;DuLinkList L,p;L=CreatDuLinkList();while(!quit)switch(scan()){case 1:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);ListInsert_DuL(L,i,e);LinkListPrint_DuL(L);break;case 2:if(DuLinkListLength(L)==0)printf("链表已经为空,不能删除\n\n");else{printf("请输入待删除元素的位置:\n");scanf("%d",&i);ListDelete_DuL(L,i);}LinkListPrint_DuL(L);break;case 3:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LocateDuLinkList(L,i);if(p)printf("链表中第%d个元素的值为:%d\n",i,p->data);elseprintf("查询位置不正确\n\n");break;default:quit=1;printf("操作结束!");printf("\n");}}【小结讨论】1.通过实验，我加深了对C的工作环境及其基本操作，进一步掌握了基本函数的调用以及使用方法。

数据结构-线性表输入,输出,插入,删除,查找

创建一个线性表实现输入，输出，插入，删除，定位。

（注意：不论在调用哪个函数前，都要先使L.elem=a，就是使指针elem回到数组a的首地址。

）#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量#define LISTINCREMENT 10 //线性表存储空间的分配增量#define OK 1#define ERROR 0#define OVERFLOW -2typedef int ElemType; //接下来ElemType代表的就是inttypedef int Status; //Status也代表intint i,*p,*q; //p，q都是指针类型ElemType e;typedef struct{ElemType *elem; //定义成指针类型//存储空间基址int length; //当前长度int listsize; //当前分配的存储容量(以sizeof(ElemType)为单位) }SqList;//***********************构建空的线性表*************************// Status InitList_Sq(SqList &L) //构建一个空的线性表L{L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem) exit(OVERFLOW); //存储分配失败L.length=0; //空表长度为0L.listsize=LIST_INIT_SIZE; //初始存储容量return OK;}//**************************线性表输入函数*********************//void input(SqList &L) //输入函数{scanf("%d",L.elem); //要先输入一个，不然一开始就是0，无法进行循环while(*L.elem) // 加*是因为elem是指针，加之后才代表值{L.elem++; //输入后指针后移L.length++; //表长加1scanf("%d",L.elem); //循环中也要再输入}}//**************************线性表打印函数********************//void print(SqList &L) //输出函数{int n;for(n=0;n<L.length;n++){printf("%d\t",*L.elem);L.elem++; //输出后指针后移}}//***********线性表插入函数（在第i个位置插入一个数据e）*************// Status ListInsert_Sq(SqList &L,int i,ElemType e)//插入函数{//在顺序线性表L中第i个位置之前插入新的元素e//i的合法值为1<=i<=ListLength.Sq(L)+1Status *newbase;指针类型。

数据结构(C语言版)

比较
Prim算法适用于稠密图， Kruskal算法适用于稀疏图；
两者时间复杂度相近，但 Kruskal算法需额外处理并查
集数据结构。
最短路径算法设计思想及实现方法比较
1 2
Dijkstra算法
从源点出发，每次找到距离源点最近的顶点并更新距离值，直至所有顶点距离确定。适用于不含负权边的图。
Floyd算法
特殊二叉树
满二叉树、完全二叉树等。
二叉树的遍历与线索化
二叉树的遍历
前序遍历、中序遍历、后序遍历和层次遍历是二叉树的四种基本遍历方法。
线索化二叉树
为了方便查找二叉树节点的前驱和后继，可以对二叉树进行线索化处理，即在节点的空指针域中存放指向前驱或后继的指针。
树和森林的遍历与转换
树的遍历
01
串的顺序存储结构
01
02
03
串的顺序存储结构是用一组地址连续的存储单元来存储串中的字符序
列的。
按照预定义的大小，为每个定义的串变量分配一个固定长度的存储区，一般是用定长数组来
定义。
串值的存储：将实际串长度值保存在数组的0下标位置，串的字符序列依次存放在从1开始的数
组元素中。
串的链式存储结构
03
比较
DFS空间复杂度较低，适用于递归实现；BFS可找到最短路径，适用于非递归实现。
最小生成树算法设计思想及实现方法比较
Prim算法
从某一顶点开始，每次选择当前生成树与外界最近的边加入生成树中，直至所有顶点加入
。
Kruskal算法
按边权值从小到大排序，依次选择边加入生成树中，保证不
形成环路。
数据结构(C语言版)

数据结构c语言版耿国华课后习题答案

数据结构c语言版耿国华课后习题答案数据结构是计算机科学中非常重要的一门课程，它涉及到了计算机程序设计中的数据组织、存储和操作等方面。

而耿国华教授的《数据结构c语言版》是这门课程中的经典教材之一，它通过讲解各种数据结构的原理和实现方法，帮助学生更好地理解和掌握这门课程的知识。

本文将针对《数据结构c语言版》中的一些典型习题进行解答，帮助读者更好地理解和掌握这些知识点。

1. 线性表线性表是数据结构中最基本的一种数据结构，它包含了顺序表和链表两种实现方式。

在习题中，我们需要实现线性表的基本操作，如插入、删除、查找等。

通过编写代码，我们可以更好地理解这些操作的实现原理和思路。

2. 栈和队列栈和队列是线性表的特殊形式，它们分别具有“先进后出”和“先进先出”的特点。

在习题中，我们需要实现栈和队列的基本操作，如入栈、出栈、入队、出队等。

通过编写代码，我们可以更好地理解这些操作的实现方法和应用场景。

3. 树和二叉树树是一种非线性的数据结构，它具有层次关系。

二叉树是树的一种特殊形式，它每个节点最多只有两个子节点。

在习题中，我们需要实现树和二叉树的基本操作，如创建、插入、删除、遍历等。

通过编写代码，我们可以更好地理解这些操作的实现原理和应用场景。

4. 图图是一种非线性的数据结构，它由节点和边组成。

在习题中，我们需要实现图的基本操作，如创建、插入、删除、遍历等。

通过编写代码，我们可以更好地理解这些操作的实现方法和应用场景。

5. 查找和排序查找和排序是数据结构中非常重要的一部分，它们在实际应用中具有广泛的应用。

在习题中，我们需要实现各种查找和排序算法，如顺序查找、二分查找、冒泡排序、快速排序等。

通过编写代码，我们可以更好地理解这些算法的实现原理和性能特点。

通过以上习题的解答，我们可以更好地理解和掌握《数据结构c语言版》中的知识点。

同时，通过编写代码，我们可以锻炼自己的编程能力和解决问题的能力。

希望读者能够通过习题的解答，更好地理解和应用数据结构这门课程的知识。

902数据结构与C语言程序设计考研大纲

902数据结构与C语言程序设计考研大纲902 数据结构与C语言程序设计考研大纲一、考试内容（一）数据结构1.线性表1）线性表的定义2）线性表的顺序存储和基本运算（查找、插入和删除）的实现3）线性表的链式存储和基本运算（查找、插入和删除）的实现4）线性表的应用2.栈、队列和矩阵1）栈和队列的定义2）栈和队列的实现（1）栈的顺序存储和基本操作（入栈、出栈和判栈空、栈满）的实现（2）栈的链式存储和基本操作（入栈、出栈和判栈空）的实现（3）队列的链式存储和基本操作（入队、出队和判队空）的实现（4）循环队列的定义和基本操作（入队、出队和判队空、队满）的实现3）栈和队列的应用4）矩阵的压缩存储（1）特殊矩阵（对称矩阵、三角矩阵、对角矩阵）的压缩存储（2）稀疏矩阵的压缩存储3.树与二叉树1）树的基本概念2）二叉树（1）二叉树的定义及性质（2）二叉树的顺序存储和链式存储（3）二叉树的先序、中序、后序遍历和层序遍历运算（4）线索二叉树的定义3）树和森林（1）树的存储结构（2）树（森林）与二叉树的相互转换（3）树和森林的遍历4）树与二叉树的应用（1）二叉查找树（Binary Search Tree）（2）平衡二叉树（Balanced Binary Tree 或Height-Balanced Tree或A VL Tree）（3）哈夫曼（Huffman）树和哈夫曼编码4.图1）图的基本概念2）图的存储（1）数组表示法（邻接矩阵表示法）（2）邻接表表示法3）图的遍历（1）深度优先搜索（DFS）算法（2）广度优先搜索（BFS）算法4）图的应用（1）最小（代价）生成树求解方法（Prim算法和Kruskal算法）（2）最短路径求解方法（Dijkstra算法和Floyd算法）（3）AOV-网和拓扑排序方法（4）AOE-网和关键路径求解方法5.查找1）查找的基本概念2）顺序查找法（1）顺序查找算法（2）平均查找长度计算3）折半查找法（1）折半查找算法（2）折半查找判定树的构造（3）平均查找长度计算4）动态查找表（1）二叉查找树（也称为二叉排序树）的构造及查找、插入和删除运算（2）平衡二叉树的构造及查找运算（3）B-树的特点及查找运算（4）平均查找长度计算5）哈希表（1）哈希表的构造及查找运算（2）平均查找长度计算6）字符串的模式匹配（1）基本的模式匹配算法（2）KMP模式匹配算法（模式串的next函数计算）6.内部排序1）简单排序方法（1）直接插入排序算法（2）冒泡排序算法（3）简单选择排序算法（4）简单排序算法的时间复杂度、空间复杂度及稳定性分析2）快速排序（1）划分过程及分析（2）快速排序算法及其时间复杂度、空间复杂度及稳定性分析3）堆排序（1）堆的定义及初始堆的建立（2）堆排序算法及其时间复杂度、空间复杂度及稳定性分析4）归并排序（1）归并过程及分析（2）二路归并排序算法的时间复杂度、空间复杂度及稳定性分析5）基数排序（1）多关键排序方法（2）链式基数排序方法及特点6）内部排序方法的比较和应用（二）C语言程序设计1. C语言基础（1）数据类型（基本类型和复合类型），常量与变量，运算符与表达式，类型转换；（2）关键字（保留字），用户定义标识符；（3）typedef，sizeof，static，extern，const。

数据结构线性表实验报告

数据结构线性表实验报告数据结构线性表实验报告实验目的：本次实验主要是为了学习和掌握线性表的基本操作和实现方式。

通过实验，我们可以加深对线性表的理解，并能够熟悉线性表的基本操作。

实验设备与环境：本次实验所需的设备包括计算机和编程环境。

我们选择使用C语言来实现线性表的操作，并在Visual Studio Code编程软件中进行编写和调试。

实验内容：1.线性表的定义和基本操作1.1 线性表的定义：线性表是一种有序的数据结构，其中的元素按照一定的顺序存储，可以插入、删除和访问元素。

1.2 线性表的基本操作：1.2.1 初始化线性表：创建一个空的线性表。

1.2.2 判断线性表是否为空：判断线性表是否不含有任何元素。

1.2.3 获取线性表的长度：返回线性表中元素的个数。

1.2.4 在线性表的指定位置插入元素：在线性表的第i个位置插入元素x，原第i个及其之后的元素依次后移。

1.2.5 删除线性表中指定位置的元素：删除线性表中第i个位置的元素，原第i+1个及其之后的元素依次前移。

1.2.6 获取线性表中指定位置的元素：返回线性表中第i个位置的元素的值。

1.2.7 清空线性表：将线性表中的元素全部删除，使其变为空表。

2.线性表的顺序存储结构实现2.1 线性表的顺序存储结构：使用数组来实现线性表的存储方式。

2.2 线性表的顺序存储结构的基本操作：2.2.1 初始化线性表：创建一个指定长度的数组，并将数组中的每个元素初始化为空值。

2.2.2 判断线性表是否为空：判断线性表的长度是否为0。

2.2.3 获取线性表的长度：返回线性表数组的长度。

2.2.4 在线性表的指定位置插入元素：将要插入的元素放入指定位置，并将原位置及其之后的元素依次后移。

2.2.5 删除线性表中指定位置的元素：将指定位置的元素删除，并将原位置之后的元素依次前移。

2.2.6 获取线性表中指定位置的元素：返回指定位置的元素的值。

2.2.7 清空线性表：将线性表数组中的每个元素赋空值。

《数据结构》学习指导

《数据结构》学习指导说明：本指导以《数据结构》(C语言版)(严蔚敏等编著,清华大学出版社1997年出版，国家级优秀教材特等奖)和《数据结构题集》(严蔚敏等编著,清华大学出版社1999年出版)为教学主要参考书。

一、绪论1、学习目的：明确数据结构课程在本专业知识结构中的地位，作用。

课程的特点，教学的要求，方法。

明确数据结构所研究的问题以及有关基本概念。

初步掌握抽象数据类型的表示与实现，初步明确算法分析的作用与分析的重点，初步掌握算法分析的方法。

2、学习重点：数据的逻辑结构、存储结构及其算法，数据结构的有关概念，抽象数据类型及其表示与实现，算法，算法设计的要求，算法的时间复杂度和算法的空间复杂度。

3、学习难点：数据结构的有关概念，抽象数据类型的表示与实现；算法的时间复杂度分析。

4、课程内容与基本要求(一) 数据结构的引入(1) 三个世界：现实世界，信息世界，机器世界。

数据结构要解决的就是实现从现实世界到信息世界，再由信息世界到机器世界的转换，从而实现用计算机来解决问题的目的。

(2) 非数值问题(结合三个世界讲)：控制，管理，数据处理(3) 数值问题：数值计算(4)数据结构：从学科角度讲，数据结构是一门研究非数值计算的程序设计问题中计算机操作对象以及他们之间的关系和操作等等的学科。

(二) 课程的地位，性质，作用。

(1) 地位: 计算机专业的核心课程之一。

(2) 性质: 算法理论基础和软件设计的技术基础课。

(3) 作用: 程序设计的基础，编译程序，操作系统，数据库系统及软件系统和应用程序的基础(三) 数据结构的产生和发展(四) 课程的特点，学习的要求教材：《数据结构》(C语言版)严蔚敏等编著北京清华大学出版社1997年参考书：《数据结构》许卓群等编著北京高等教育出版社1987年数据结构实用教程》（C/C++描述）徐孝凯北京清华大学出版社1999年《数据结构题集》严蔚敏等编著北京清华大学出版社1999年《数据结构导学》苏光奎等编著北京清华大学出版社20XX年《数据结构》(C语言篇)－习题与解析李春葆编著北京清华大学出版社20XX年《数据结构》实验指导书唐开山自编讲义20XX年(五) 基本概念和术语数据数据元素数据对象(4)数据结构:按某种逻辑关系组织起来的一批数据，按一定的存储表示方式把它存储到计算机的存储器中，并在这些数据上定义了一个运算的集合，叫做一个数据结构。

数据结构--实验报告线性表的基本操作

数据结构--实验报告线性表的基本操作线性表的基本操作实验报告1.引言线性表是最基本的数据结构之一，它可以用来存储一系列具有相同数据类型的元素。

本实验旨在通过实践掌握线性表的基本操作，包括插入、删除、查找和修改元素等。

本文档将详细介绍实验所需的步骤和操作方法。

2.实验目的1.掌握线性表的插入和删除操作。

2.理解线性表的查找和修改元素的方法。

3.熟悉线性表的基本操作在算法中的应用。

3.实验环境本实验使用编程语言/软件名称作为开发环境，具体要求如下：________●操作系统：________操作系统名称和版本●编程语言：________编程语言名称和版本4.实验步骤4.1 初始化线性表在程序中创建一个空的线性表，用于存储元素。

实现方法：________具体的初始化方法和代码示例 4.2 插入元素在线性表中指定位置插入一个新元素。

实现方法：________具体的插入元素方法和代码示例 4.3 删除元素删除线性表中指定位置的元素。

实现方法：________具体的删除元素方法和代码示例 4.4 查找元素在线性表中查找指定元素的位置。

实现方法：________具体的查找元素方法和代码示例 4.5 修改元素修改线性表中指定位置的元素值。

实现方法：________具体的修改元素方法和代码示例5.实验结果在完成上述步骤后，我们得到了一个可以进行插入、删除、查找和修改元素的线性表。

具体操作结果如下：________●插入元素操作结果：________插入元素的具体操作结果●删除元素操作结果：________删除元素的具体操作结果●查找元素操作结果：________查找元素的具体操作结果●修改元素操作结果：________修改元素的具体操作结果6.实验总结通过本次实验，我们深入理解了线性表的基本操作，并且掌握了这些操作的实现方法。

线性表在实际应用中十分常见，熟练掌握线性表的操作对于开发高效的算法和数据结构具有重要意义。

数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树

2.上机输入、调试实验程序；
{ int i,j,k,x1,x2,m1,m2;
for(i=1;i<(2*n);i++)
{ t[i].pa=t[i].lc=t[i].rc=0;
if(i<=n)
t[i].data=w[i];
else
t[i].data=0;
}
for(i=1;i<n;i++)
{ m1=m2=MAX;
x1=x2=0;
for(j=1;j<(n+i);j++)
ListCount=0;
int nOperateState;
while(TRUE)
{
printf( "选择你要操作的方法，1为插入，2为删除，3为查询！4为退出\r\n ");
scanf("%d",&nOperateState);
switch(nOperateState)
{
case 1:
InsertInfo();
{
printf("请不要重复插入相同学号的信息\r\n");
LocalFree(Info);
return;
}
ptemp=ptemp->pNext;
}
}
if (ListHead)
{
if (ListCount==1)
{
ListTail=Info;
ListTail->pNext=NULL;
ListHead->pNext=ListTail;
temp->stu_num,temp->stu_age,temp->stu_english_grade);

c语言顺序表实验报告

c语言顺序表实验报告C语言顺序表实验报告引言：C语言是一种广泛应用于软件开发领域的编程语言，其灵活性和高效性备受开发者青睐。

在本次实验中，我们将探索C语言中的一种数据结构——顺序表。

顺序表是一种线性表的存储结构，通过数组实现，具有快速访问元素的特点。

本实验将通过实际操作，深入了解顺序表的创建、插入、删除和查找等基本操作，并对其性能进行评估。

实验目的：1. 掌握顺序表的创建和初始化方法；2. 熟悉顺序表的插入、删除和查找等基本操作；3. 评估顺序表在不同操作下的性能。

实验步骤：1. 创建顺序表在C语言中，可以通过定义一个结构体来表示顺序表，其中包含一个数组和一个记录当前元素个数的变量。

通过动态内存分配，可以根据需要调整顺序表的大小。

```ctypedef struct {int* data; // 数组指针int length; // 当前元素个数int capacity; // 顺序表的容量} SeqList;```在主函数中，可以通过调用malloc函数为顺序表分配内存空间，并对其进行初始化。

```cSeqList* createSeqList(int capacity) {SeqList* list = (SeqList*)malloc(sizeof(SeqList));list->data = (int*)malloc(capacity * sizeof(int));list->length = 0;list->capacity = capacity;return list;}```2. 插入元素顺序表的插入操作需要考虑插入位置的合法性以及顺序表是否已满的情况。

在插入元素时，需要将插入位置之后的元素后移一位，为新元素腾出空间。

```cvoid insert(SeqList* list, int position, int element) {if (position < 0 || position > list->length) {printf("插入位置非法！");return;}if (list->length >= list->capacity) {printf("顺序表已满，无法插入！");return;}for (int i = list->length - 1; i >= position; i--) {list->data[i + 1] = list->data[i];}list->data[position] = element;list->length++;}```3. 删除元素顺序表的删除操作需要考虑删除位置的合法性以及顺序表是否为空的情况。

《数据结构C语言版》----第02章

int ListLength(SLNode *head) { SLNode *p = head; int size = 0; while(p->next != NULL) { p = p->next; size ++; } return size; }
p size=0
head
a0
a1
(a)
...
a n 1 ∧
3.顺序表操作的效率分析
时间效率分析: 算法时间主要耗费在移动元素的操作上，因此计算时间复杂度的基本操作(最深层语句频度) T(n)= O(移动元素次数) 而移动元素的个数取决于插入或删除元素的位置i. 若i=size，则根本无需移动（特别快）；若i=0，则表中元素全部要后移（特别慢）；应当考虑在各种位置插入（共n+1种可能）的平均移动次数才合理。
(3)带头结点单链表和不带头结点单链表的比较
1).在带头结点单链表第一个数据元素前插入结点
p head s p head data next a0 x
∧
a1
…
an-1
∧
(a) 插入前
data next a0
∧
a1
…
an-1
∧
s
x
(b) 插入后
2).删除带头结点单链表第一个数据元素结点
p data next head
（5）取数据元素ListGet(L,
i, x)
int ListGet(SeqList L, int i, DataType *x) { if(i < 0 || i > L.size-1) { printf("参数i不合法! \n"); return 0; } else { *x = L.list[i]; return 1; } }

数据结构实验报告-线性表

1 线性表1. 实验题目与环境1.1实验题目及要求（1）顺序表的操作利用顺序存储方式实现下列功能：根据键盘输入数据建立一个线性表，并输出该线性表；对该线性表进行数据的插入、删除、查找操作，并在插入和删除数据后，再输出线性表。

（2）单链表的操作利用链式存储方式实现下列功能：根据键盘输入数据建立一个线性表，并输出该线性表；对该线性表进行数据的插入、删除、查找操作，并在插入和删除数据后，再输出线性表。

（3）线性表的应用约瑟夫环问题。

有n个人围坐一圈，现从某个人开始报数，数到M的人出列，接着从出列的下一个人开始重新报数，数到M的人又出列，如此下去，直到所有人都出列为止。

要求依次输出出列人的编码。

2.问题分析（1）顺序表的操作利用一位数组来描述顺序表，即将所有元素一词储存在数组的连续单元中，要在表头或中间插入一个新元素时，需要将其后的所有元素都向后移动一个位置来为新元素腾出空间。

同理，删除开头或中间的元素时，则将其后的所有元素向前移动一个位置以填补空位。

查找元素时，则需要利用循环语句，一一判断直到找出所要查找的元素（或元素的位置），输出相关内容即可（2）单链表的操作利用若干个结点建立一个链表，每个节点有两个域，即存放元素的数据域和存放指向下一个结点的指针域。

设定一个头指针。

在带头结点的单链表中的第i个元素之前插入一新元素，需要计数找到第i-1个结点并由一指针p指向它，再造一个由一指针s指向的结点，数据为x，并使x的指针域指向第i个结点，最后修改第i-1个结点的指针域，指向x结点。

删除第i个元素时，需要计数寻找到第i个结点，并使指针p指向其前驱结点，然后删除第i个结点并释放被删除结点的空间。

查找第i个元素，需从第一个结点开始计数找到第i个结点，然后输出该结点的数据元素。

（3）线性表的应用程序运行之后，首先要求用户指定初始报数的上限值，可以n<=30,此题中循环链表可不设头结点，而且必须注意空表和"非空表"的界限。

数据结构实验报告顺序表

数据结构实验报告顺序表数据结构实验报告：顺序表一、引言数据结构是计算机科学的重要基础，它研究数据的组织方式和操作方法。

顺序表是一种常见的数据结构，它以数组的形式存储数据元素，具有随机访问和插入删除方便的特点。

本实验旨在深入理解顺序表的实现原理和操作方法，并通过实验验证其性能。

二、实验目的1. 掌握顺序表的基本概念和实现原理；2. 熟悉顺序表的插入、删除、查找等操作；3. 分析顺序表的时间复杂度，并进行性能测试。

三、实验过程1. 顺序表的定义和初始化顺序表是一种线性表，它以一组连续的存储单元来存储数据元素。

在实验中，我们使用数组来实现顺序表。

首先，定义一个结构体来表示顺序表，包括数据元素和当前长度等信息。

然后，通过动态分配内存来初始化顺序表。

2. 插入元素顺序表的插入操作是将一个新元素插入到指定位置，同时移动后面的元素。

在实验中，我们可以通过循环将后面的元素依次向后移动，然后将新元素放入指定位置。

3. 删除元素顺序表的删除操作是将指定位置的元素删除，并将后面的元素依次向前移动。

在实验中，我们可以通过循环将后面的元素依次向前移动，然后将最后一个元素置为空。

4. 查找元素顺序表的查找操作是根据指定的值查找元素所在的位置。

在实验中，我们可以通过循环遍历顺序表，逐个比较元素的值，找到匹配的位置。

五、实验结果与分析在实验中，我们通过插入、删除、查找等操作对顺序表进行了测试，并记录了操作所需的时间。

通过分析实验结果，我们可以得出以下结论：1. 顺序表的插入操作的时间复杂度为O(n)，其中n为元素的个数。

因为插入操作需要移动后面的元素，所以时间复杂度与元素个数成正比。

2. 顺序表的删除操作的时间复杂度也为O(n)，与插入操作相同，需要移动后面的元素。

3. 顺序表的查找操作的时间复杂度为O(n)，需要逐个比较元素的值。

六、结论通过本次实验，我们深入理解了顺序表的实现原理和操作方法。

顺序表以数组的形式存储数据，具有随机访问和插入删除方便的特点。

《数据结构》实验指导书(C语言版)(浦江学院)

实验1: 顺序表的操作实验一、实验名称和性质二、实验目的1．掌握线性表的顺序存储结构的表示和实现方法。

2．掌握顺序表基本操作的算法实现。

3．了解顺序表的应用。

三、实验内容1．建立顺序表。

2．在顺序表上实现插入、删除和查找操作（验证性内容）。

3．删除有序顺序表中的重复元素（设计性内容）。

四、实验的软硬件环境要求硬件环境要求：PC机（单机）使用的软件名称、版本号：Windows环境下的VC++6.0五、知识准备前期要求熟练掌握了C语言的编程规则、方法和顺序表的基本操作算法。

六、验证性实验1．实验要求编程实现如下功能：（1）根据输入顺序表的长度n和各个数据元素值建立一个顺序表，并输出顺序表中各元素值，观察输入的内容与输出的内容是否一致。

（2）在顺序表的第i个元素之前插入一个值为x的元素，并输出插入后的顺序表中各元素值。

（3）删除顺序表中第i个元素，并输出删除后的顺序表中各元素值。

（4）在顺序表中查找值为e的数据元素，如果查找成功，则显示“查找成功”和该元素在顺序表中的位置，否则显示“查找失败”。

2. 实验相关原理线性表的顺序存储结构称为顺序表，顺序表的存储结构描述为：#define MAXLEN 30 /*线性表的最大长度*/typedef struct{Elemtype elem[MAXLEN]; /*顺序表中存放元素的数组，其中elemtype为抽象数据类型，在程序具体实现时可以用任意类型代替*/int length; /*顺序表的长度，即元素个数*/}Sqlist; /*顺序表的类型*/【核心算法提示】（1）顺序表插入操作的基本步骤：要在顺序表中的第i个数据元素之前插入一个数据元素x,首先要判断插入位置i是否合法，假设线性表的表长为n，则i的合法值范围：1≤i ≤n+1，若是合法位置，就再判断顺序表是否满，如果满，则增加空间或结束操作，如果不满，则将第i个数据元素及其之后的所有数据元素都后移一个位置，此时第i个位置已经腾空，再将待插入的数据元素x插入到该位置上，最后将线性表的表长增加1。

数据结构实验课教案

数据结构实验课教案数据结构教案实验一：线性表的顺序表示与实现实验学时：2学时一．实验目的：1．掌握线性表的顺序存储结构；2．掌握在顺序表上进行的插入、删除、查找、修改等操作。

二．实验内容：1．分别建立顺序表，并输入初始数据；2．对顺序表分别编写插入、删除、查找、修改等函数。

三．实验重点：顺序表的建立及操作。

四．实验要求：1．用C语言编写程序源代码；2．要分别完成建立、插入、删除、查找、修改五种功能。

3．源程序必须编译调试成功，独立完成。

五．实验器材：一个装有C语言编译环境的计算机。

六．实验步骤：顺序表：1．定义头文件和顺序表的存储结构类型等 #define ok 1 #define error 0 #define overflow 0 #define null 0 #include #include #define list_init_size 100 #define listincrement 10 typedef int elemtype; typedef int status; typedef struct{ elemtype *elem; int length; int listsize; }sqlist;1 2．编写构造空顺序表的函数status listinit(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; }3．编写对顺序表进行插入操作的函数： status listinsert(sqlist *l,int i,elemtype e) { elemtype *newbase,*q,*p; if(ilistlength(*l)+1)return error; if(l->length==l->listsize){ newbase=(elemtype *)realloc(l->elem,(l->listsize+listincrement)*sizeof(elemtype));if(!newbase)return overflow;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; return ok; }4．编写对顺序表进行删除操作的函数：status listdelete(sqlist *l,int i,elemtype *e) { elemtype *p,*q; if(il->length)return error; p=&(l->elem[i-1]); *e=*p; q=l->elem+l->length-1; for(++p;p*(p-1)=*p; --l->length;2 return ok; }5．编写对顺序表进行查找操作的函数： status getelem(sqlist l,int i,elemtype *e) { if(ilistlength(l)) return error; *e=[i-1]; return ok; }6．编写对顺序表进行修改操作的函数： status locateelem(sqlist l,elemtype e) { int i; for(i=0;iif([i]==e)return i+1; return 0; } 7．编写实现两个线性表的归并操作的函数 void mergelist(sqlist la,sqlist lb,sqlist *lc) { int i,j,k; intla_len,lb_len; elemtype ai,bj; i=j=1; k=0; listinit(lc); la_len=listlength(la); lb_len=listlength(lb); while(i{listinsert(lc,++k,ai);++i;} else{listinsert(lc,++k,bj);++j;} } while(iwhile(j{ getelem(lb,j++,&bj); listinsert(lc,++k,bj);} }8．销毁线性表、清空线性表、判空、求表长等 status destroylist(sqlist *l) { if(l->elem) free(l->elem),l->elem=null; return ok; }status clearlist(sqlist *l) { l->length=0; return ok; }status listempty(sqlist l) { return(==0); }status listlength(sqlist l) { return ; }9．打印线性表4 void print(sqlist l) { int i; printf(\”\\nlist: \”); for(i=0;i10．编写主函数 void main() { int i; int n; elemtype a; sqlist l,la,lb,lc; clrscr(); listinit(&l); listinit(&la); listinit(&lb);printf(\”please input list number\”); scanf(\”%d\”,&n); printf(\”\\n\”); for(i=0;iscanf(\”%d\”,&a);listinsert(&l,i+1,a); } print(l); printf(\”\\nlist length:%d\”,listlength(l));getelem(l,4,&a); printf(\”\\ngetelem(l,4,&a),%d\”,a);listdelete(&l,3,&a); printf(\”\\nlistdelete(&l,3,&a),%d\”,a); print(l);printf(\”\\ninput list la\”);for(i=0;iscanf(\”%d\”,&a);listinsert(&la,i+1,a); } printf(\”\\ninput list lb\”);5 for(i=0;iscanf(\”%d\”,&a);listinsert(&lb,i+1,a); } mergelist(la,lb,&lc); print(la);print(lb);print(lc); }6实验二：链表实验学时：2学时一．实验目的：11．掌握单、双向链表的存储结构；12．掌握在单、双向链表上进行的插入、删除、查找、修改等操作。

实验一数据结构顺序表的插入和删除

实验一顺序表的操作1.实验题目：顺序表的操作2.实验目的和要求：1）了解顺序表的基本概念、顺序表结构的定义及在顺序表上的基本操作(插入、删除、查找以及线性表合并)。

2) 通过在Turbo C（WinTc，或visual stdio6）实现以上操作的C语言代码。

3）提前了解实验相关的知识（尤其是C语言）。

3.实验内容：(二选一)1) 顺序表的插入算法,删除算法,顺序表的合并算法2) 与线性表应用相关的实例(自己选择具体实例)4.部分参考实验代码：⑴顺序表结构的定义：#include <stdio.h>#define MAXLEN 255typedef int ElemType;typedef struct{ ElemType elem[MAXLEN];int length;}sqList;⑵顺序表前插（在第i号元素前插入一个新的元素）int ListInsert(sqList *la,int i,int x){ int j;if(i<0||i>la-> length +1){ printf(“\n the value of i is wrong!”);return 0;}if(la-> length +1>=MAXLEN){ printf(“\n overflow!”);return 0;}. for(j=la-> length;j>=i;j--)la->list[j+1]=la->list[j];la->list[i]=x;la-> length ++;return 1;}⑶顺序表删除int ListDelete(sqList *la,int i){ if(i<0||i>la-> length){ printf(“\n the position is wrong!\n”);return 0;}for(i;i<la-> length;i++)la->list[i-1]=la->list[i];la-> length --;return 1;}5.附录：实验预备知识：⑴复习C语言中数组的用法。

数据结构实验报告_单链表

数据结构实验报告_单链表【实验目的】1、顺序表的基本操作及c语言实现【实验要求】1、用c语言建立自己的线性表结构的程序库，实现顺序表的基本操作。

2、对线性表表示的集合，集合数据由用户从键盘输入（数据类型为整型），建立相应的顺序表，且使得数据按从小到大的顺序存放，将两个集合的并的结果存储在一个新的线性表集合中，并输出。

【实验内容】1、根据教材定义的顺序表机构，用c语言实现顺序表结构的创建、插入、删除、查找等操作；2、利用上述顺序表操作实现如下程序：建立两个顺序表表示的集合（集合中无重复的元素），并求这样的两个集合的并。

【实验结果】[实验数据、结果、遇到的问题及解决]一．statusinsertorderlist(sqlist&va,elemtypex){}二．statusdeletek(sqlist&a,inti,intk){//在非递减的顺序表va中插入元素x并使其仍成为顺序表的算法inti;if(v==ze)return(overflow);for(i=v;i>0,x }//注意i的编号从0开始intj;if(i<0||i>-1||k<0||k>-i)returninfeasible;for(j=0;j<=k;j++)[j+i]=[j+i+k];=-k;returnok;三．//将合并逆置后的结果放在c表中，并删除b表statuslistmergeoppose_l(linklist&a,linklist&b,linklist& c){linklistpa,pb,qa,qb;pa=a;pb=b;qa=pa;qb=pb;//保存pa的前驱指针//保存pb的前驱指针pa=pa->next;pb=pb->next;a->next=null;c=a;while(pa&&pb){}whi le(pa){}qa=pa;pa=pa->next;qa->next=a->next;a->next=qa;if(pa ->datadata){}else{}qb=pb;pb=pb->next;qb->next=a->next;//将当前最小结点插入a表表头a->next=qb;qa=pa;pa=pa->next;qa->next=a->next;//将当前最小结点插入a表表头a->next=qa;}}pb=b;free(pb);returnok;qb=pb;pb=pb->next;qb->next=a->n ext;a->next=qb;顺序表就是把线性表的元素存储在数组中，元素之间的关系直接通过相邻元素的位置来表达。