数据结构编程之c语言线性表

合集下载

数据结构经典题目及c语言代码

数据结构经典题目及c语言代码

数据结构经典题目及c语言代码一、线性表1. 顺序表顺序表是一种利用连续存储空间存储元素的线性表。

以下是一个顺序表的经典题目及C语言代码实现:```c#define MaxSize 50typedef struct {int data[MaxSize]; // 存储元素的数组int length; // 顺序表的当前长度} SeqList;// 初始化顺序表void initList(SeqList *L) {L->length = 0;}// 插入元素到指定位置void insert(SeqList *L, int pos, int elem) {if (pos < 1 || pos > L->length + 1) {printf("插入位置无效\n");return;}if (L->length == MaxSize) {printf("顺序表已满,无法插入\n"); return;}for (int i = L->length; i >= pos; i--) { L->data[i] = L->data[i - 1];}L->data[pos - 1] = elem;L->length++;}// 删除指定位置的元素void delete(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("删除位置无效\n");return;}for (int i = pos - 1; i < L->length - 1; i++) {L->data[i] = L->data[i + 1];}L->length--;}// 获取指定位置的元素值int getElement(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("位置无效\n");return -1;}return L->data[pos - 1];}```2. 链表链表是一种利用非连续存储空间存储元素的线性表。

《数据结构与算法(C++语言版)》第2章 线性表

《数据结构与算法(C++语言版)》第2章 线性表
• 以下是一个使用类LinearList的C++程序,它假定之前的程 序均存储在LinearList.h之中,且异常类定义位于文件 exception.h之中。该示例完成以下操作:创建一个大小为5 的整数线性表L;输出该表的长度(为0);在第0个元素之 后插入2;在第一个元素之后插入6和8(至此,线性表为2, 6,8);寻找并输出第一个元素(为2);输出当前表的长 度(为3);删除并输出第一个元素。
数据结构与算法 (C++语言版)
第2章 线性表
线性表的类型定义
• 基本概念 • 线性表是由n(n≥0)个类型相同的数据元素组成的有限序 列,通常表示为L=(a1, …, ai–1, ai, ai+1, …, an)。其中,L为线 性表名称,ai为组成该线性表的数据元素,ai–1领先于ai,ai 领先于ai+1,称ai–1是ai的直接前驱元素,ai+1是ai的直接后继 元素。当i=1, 2, …, n–1时,ai有且仅有一个直接后继;当 i=2, 3, …, n时,ai有且仅有一个直接前驱。 • 线性表的长度就是线性表中元素的个数n(n≥0)。当n=0时, 称为空表。在非空表中的每个数据元素都有一个确定的位 置,如a1是第一个数据元素,an是最后一个数据元素,ai是 第i个数据元素。称i为数据元素ai在线性表中的位序。
线性表的类型定义
Prev_Elem(L, cur_e, &pre_e) //返回当前元素的前一个元素值 输入:线性表L。 输出:若cur_e是线性表L的数据元素,且不是第一个,则用 pre_e返回它的直接前驱元 素;否则操作失败,pre_e无定义。 Next_Elem(L, cur_e, &next_e) //返回当前元素的后一个元素值 输入:线性表L。 输出:若cur_e是线性表L的数据元素,且不是最后一个,则用 next_e返回它的直接后继元素;否则操作失败,next_e无定 义。

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

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

实验一线性表的基本操作一、实验目的与基本要求1.掌握数据结构中的一些基本概念。

数据、数据项、数据元素、数据类型和数据结构,以及它们之间的关系。

2.了解数据的逻辑结构和数据的存储结构之间的区别与联系;数据的运算与数据的逻辑结构的关系。

3.掌握顺序表和链表的基本操作:插入、删除、查找以及表的合并等运算。

4.掌握运用C语言上机调试线性表的基本方法。

二、实验条件1.硬件:一台微机2.软件:操作系统和C语言系统三、实验方法确定存储结构后,上机调试实现线性表的基本运算。

四、实验内容1.建立顺序表,基本操作包括:初始化,建立一个顺序存储的链表,输出顺序表,判断是否为空,取表中第i个元素,定位函数(返回第一个与x相等的元素位置),插入,删除。

2.建立单链表,基本操作包括:初始化,建立一个链式存储的链表,输出顺序表,判断是否为空,取表中第i个元素,定位函数(返回第一个与x相等的元素位置),插入,删除。

3.假设有两个按数据元素值非递减有序排列的线性表A和B,均以顺序表作为存储结构。

编写算法将A表和B表归并成一个按元素值非递增有序(允许值相同)排列的线性表C。

(可以利用将B中元素插入A中,或新建C表)4.假设有两个按数据元素值非递减有序排列的线性表A和B,均以单链表作为存储结构。

编写算法将A表和B表归并成一个按元素值递减有序(即非递增有序,允许值相同)排列的线性表C。

五、附源程序及算法程序流程图1.源程序(1)源程序(实验要求1和3)#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct arr{int * elem;int length;int listsize;}Sqlist;void menu(); //菜单void InitList(Sqlist *p); // 创建线性表void ShowList(Sqlist *p); // 输出顺序线性表void ListDelete(Sqlist *p,int i,int &e); // 在顺序线性表中删除第i个元素,并用e返回其值void ListInsert(Sqlist *p); // 在顺序线性表中第i个元素前插入新元素evoid ListEmpty(Sqlist *p); // 判断L是否为空表void GetList(Sqlist *p,int i,int &e); // 用e返回L中第i个数据元素的值void ListInsert(Sqlist *p,int i,int e);bool compare(int a,int b);void LocateElem(Sqlist *L,int e); // 在顺序线性表L中查找第1个值与e满足compare()d元素的位序void MergeList_L(Sqlist *La,Sqlist *Lb); // 归并void main(){Sqlist La;Sqlist Lb;int n,m,x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:InitList(&La);break;case 2:ListEmpty(&La);break;case 3:printf("请输入插入的位序:\n");scanf("%d",&m);printf("请出入要插入的数:\n");scanf("%d",&x);ListInsert(&La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(&La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(&La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(&La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(&La);break;case 8:InitList(&Lb);break;case 9:MergeList_L(&La,&Lb);printf("归并成功!");break;}menu();scanf("%d",&n);}}/*菜单*/void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断La是否为空表\n\n");printf(" 3.插入元素(La)\n\n");printf(" 4.删除元素(La)\n\n");printf(" 5.定位元素(La)\n\n");printf(" 6.取元素(La)\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并为一个线性表La\n\n");printf("********************\n\n");}/*创建顺序线性表L*/void InitList(Sqlist *L){int n;int i=0;L->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));if(NULL==L->elem)printf("储存分配失败!\n");else{L->length=0;L->listsize=LIST_INIT_SIZE;printf("输入顺序表a:\n");scanf("%d",&n);while(n){L->elem[i]=n;i++;L->length++;L->listsize=L->listsize-4;scanf("%d",&n);}}}/*输出顺序线性表*/void ShowList(Sqlist *p){int i;if(0==p->length)printf("数组为空!\n");elsefor(i=0;i<p->length;i++)printf("%d ",p->elem[i]);printf("\n");}/*判断L是否为空表*/void ListEmpty(Sqlist *p)if(0==p->length)printf("L是空表!\n");elseprintf("L不是空表!\n");}/*在顺序线性表中第i个元素前插入新元素e */void ListInsert(Sqlist *p,int i,int e){int *newbase;int *q1;int *q2;while(i<1||i>p->length+1){printf("您输入的i超出范围!\n请重新输入要插入的位置\n:");scanf("%d",&i);}if(p->length>=p->listsize){newbase=(int *)realloc(p->elem,(p->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);else{p->elem=newbase;p->listsize+=LISTINCREMENT;}}q1=&(p->elem[i-1]);for(q2=&(p->elem[p->length-1]);q2>=q1;--q2)*(q2+1)=*q2;*q1=e;++p->length;}/*/在顺序线性表中删除第i个元素,并用e返回其值*/void ListDelete(Sqlist *p,int i,int &e){int *q1,*q2;while(i<1||i>p->length){printf("您输入的i超出范围!请重新输入:");scanf("%d",&i);}q1=&(p->elem[i-1]);e=*q1;q2=p->elem+p->length-1;for(++q1;q1<=q2;++q1)*(q1-1)=*q1;--p->length;}/*对比a与b相等*/bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}/*在顺序线性表L中查找第1个值与e满足compare()d元素的位序*/ void LocateElem(Sqlist *L,int e){int i=1;int *p;p=L->elem;while(i<=L->length && !compare(*p++,e))++i;if(i<=L->length)printf("第1个与e相等的元素的位序为%d\n",i);elseprintf("没有该元素!\n");}/*用e返回L中第i个数据元素的值*/void GetList(Sqlist *p,int i,int &e){Sqlist *p1;p1=p;e=p1->elem[i-1];}/* 已知顺序线性表La和Lb是元素按值非递减排列*//* 把La和Lb归并到La上,La的元素也是按值非递减*/void MergeList_L(Sqlist *La,Sqlist *Lb){int i=0,j=0,k,t;int *newbase;Sqlist *pa,*pb;pa=La;pb=Lb;while(i<pa->length && j<pb->length){if(pa->elem[i] >= pb->elem[j]){if(pa->listsize==0){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(k=pa->length-1; k>=i; k--)pa->elem[k+1]=pa->elem[k];pa->length++;pa->elem[i]=pb->elem[j];i++;j++;}elsei++;}while(j<pb->length){if( pa->listsize < pb->length-j ){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(j;j<pb->length;j++,i++){pa->elem[i]=pb->elem[j];pa->length++;}}for(i=0;i<pa->length/2;i++){t=pa->elem[i];pa->elem[i]=pa->elem[pa->length-i-1];pa->elem[pa->length-i-1]=t;}}(2)源程序(实验要求2和4)#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct LNode{int data;struct LNode *next;}LNode, *LinkList;void menu();LinkList InitList();void ShowList(LinkList L);void ListDelete(LinkList L,int i,int &e);void ListEmpty(LinkList L);void GetList(LinkList L,int i,int &e);void ListInsert(LinkList L,int i,int e);bool compare(int a,int b);void LocateElem(LinkList L,int e);LinkList MergeList_L(LinkList La,LinkList Lb);int total=0;void main(){LinkList La;LinkList Lb;La=(LinkList)malloc(sizeof(struct LNode));La->next=NULL;Lb=(LinkList)malloc(sizeof(struct LNode));Lb->next=NULL;int n;int m;int x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:La->next=InitList();break;case 2:ListEmpty(La);break;case 3:printf("请输入要插入到第几个节点前:\n");scanf("%d",&m);printf("请输入插入的数据:\n");scanf("%d",&x);ListInsert(La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(La);break;case 8:Lb->next=InitList();break;case 9:La=MergeList_L(La,Lb);printf("归并成功\n");break;}menu();scanf("%d",&n);}}void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断是否为空表\n\n");printf(" 3.插入元素\n\n");printf(" 4.删除元素\n\n");printf(" 5.定位元素\n\n");printf(" 6.取元素\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并两线性表\n\n");printf("********************\n\n");}// 创建链式线性表LLinkList InitList(){int count=0;LinkList pHead=NULL;LinkList pEnd,pNew;pEnd=pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);while(pNew->data){count++;if(count==1){pNew->next=pHead;pEnd=pNew;pHead=pNew;}else{pNew->next=NULL;pEnd->next=pNew;pEnd=pNew;}pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);}free(pNew);total=total+count;return pHead;}// 判断L是否为空表void ListEmpty(LinkList L){if(NULL==L->next)printf("此表为空表!\n");elseprintf("此表不为空表!\n");}// 在链式线性表中第i个元素前插入新元素e void ListInsert(LinkList L,int i,int e){LinkList p;LinkList s;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("不存在您要找的节点!\n");else{s=(LinkList)malloc(sizeof(int));s->data=e;s->next=p->next;p->next=s;printf("插入节点成功!\n");}}// 输出链式线性表void ShowList(LinkList L){LinkList p;p=L->next;if(p==NULL)printf("此表为空表!\n");elsewhile(p){printf("%d ",p->data);p=p->next;}printf("\n");}// 在链式线性表中删除第i个元素,并用e返回其值void ListDelete(LinkList L,int i,int &e){LinkList p;LinkList q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1)printf("没有找到要删除的位置!");else{q=p->next;p->next=q->next;e=q->data;free(q);}}// 用e返回L中第i个数据元素的值void GetList(LinkList L,int i,int &e){LinkList p;p=L->next;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p)||j>i-1)printf("没有找到要查找的位置!");elsee=p->data;}// 对比a与b相等bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}// 在链式线性表L中查找第1个值与e满足compare()d元素的位序void LocateElem(LinkList L,int e){int i=0;LinkList p;p=L;while(p->next && !compare(p->data,e)){p=p->next;i++;}if(NULL==p->next){if(0==compare(p->data,e))printf("没有该元素!\n");elseprintf("第1个与e相等的元素的位序为%d\n",i);}elseif(compare(p->data,e))printf("没有该元素!\n");}LinkList MergeList_L(LinkList La,LinkList Lb){int i,j,k;LinkList pa_1,pb_1,pa_2,pb_2,pc,pd;pa_1=La->next;pc=pa_2=La;pb_1=pb_2=Lb->next;if(pa_1->data > pb_1->data){pc=pa_2=Lb;pa_1=Lb->next;pb_1=pb_2=La->next;}while(pa_1 && pb_1){if(pa_1->data >= pb_1->data){pa_2->next=pb_1;pb_2=pb_1->next;pb_1->next=pa_1;pb_1=pb_2;pa_2=pa_2->next;}else{pa_1=pa_1->next;pa_2=pa_2->next;}}if(pb_1)pa_2->next=pb_1;pd=(LinkList)malloc(sizeof(struct LNode));pd->next=NULL;pa_2=pd;k=total;for(i=0;i<total;i++){pa_1=pc->next;for(j=1;j<k;j++)pa_1=pa_1->next;pb_1=(LinkList)malloc(sizeof(struct LNode));pa_2->next=pb_1;pa_2=pa_2->next;pa_2->data=pa_1->data;k--;}pa_2->next=NULL;return pd;}2.流程图(实验要求1和3)图1 主函数流程图图2创建线性表La流程图图3判断La是否为空表流程图图4 插入元素(La)流程图图5删除元素(La)流程图图6定位元素(La)流程图图7取元素(La)流程图图8输出线性表流程图图9输出线性表流程图流程图(实验要求2和4)图10主函数流程图图11创建线性表La流程图图12判断是否为空表流程图图13插入元素流程图图14删除元素流程图图15定位元素流程图图图16取元素流程图图17创建Lb流程图图18归并两表流程图六、运行结果1. (实验要求1和3)点击运行,首先出现的是菜单界面,选择菜单选项进行操作,如图所示。

数据结构c语言PPT 2

数据结构c语言PPT  2

5. 线性表的特点
同一性:线性表由同类数据元素组成,每一个ai 必
须属于同一数据对象。
有穷性:线性表由有限个数据元素组成, 表长度就
是表中数据元素的个数。
有序性:线性表中相邻数据元素之间存在着序偶关
系<ai, ai+1>。
线性表的抽象数据类型定义:
ADT List { 数据对象:D={ ai | ai ElemSet, i=1,2,…n, n0 } 数据关系: R={<ai-1,ai> | ai-1,ai D, i=1,2,…n} 基本运算: InitList(&L); DestroyList(&L); Length(L); GetElem(L,i,&e); LocateElem(L,e,compare()); InsertElem(&L,i,e); DeleteElem(&L,i,&e); …… } ADT List
补充内容:
int *s;
s = new int;
或 s = (int *)malloc(sizeof(int)); *s = 5; free(s); int *s, *p;
void main() { int *s, *p;
s = new int; *s = 5; delete s; p = new int[10]; p[0] = 0; p[1] = 1; *(p+8) = 8; *(p+9) = 9; delete [] p }
Loc(ai) = Loc(a1) + (i - 1) * d
其中Loc(a1)称为基地址
(1≤i≤n)
3. 顺序表的描述(顺序表存储的C语言实现):

数据结构C语言版 线性表的单链表存储结构表示和实现

数据结构C语言版 线性表的单链表存储结构表示和实现

#include 〈stdio.h>#include <malloc。

h>#include 〈stdlib.h>/*数据结构C语言版线性表的单链表存储结构表示和实现P28—31编译环境:Dev-C++ 4。

9。

9。

2日期:2011年2月10日*/typedef int ElemType;// 线性表的单链表存储结构typedef struct LNode{ElemType data; //数据域struct LNode *next;//指针域}LNode, *LinkList;// typedef struct LNode *LinkList;// 另一种定义LinkList的方法// 构造一个空的线性表Lint InitList(LinkList *L){/*产生头结点L,并使L指向此头结点,头节点的数据域为空,不放数据的。

void *malloc(size_t)这里对返回值进行强制类型转换了,返回值是指向空类型的指针类型.*/(*L)= (LinkList)malloc(sizeof(struct LNode) );if( !(*L))exit(0);// 存储分配失败(*L)-〉next = NULL;// 指针域为空return 1;}// 销毁线性表L,将包括头结点在内的所有元素释放其存储空间。

int DestroyList(LinkList *L){LinkList q;// 由于单链表的每一个元素是单独分配的,所以要一个一个的进行释放while(*L ){q = (*L)—〉next;free(*L );//释放*L = q;}return 1;}/*将L重置为空表,即将链表中除头结点外的所有元素释放其存储空间,但是将头结点指针域置空,这和销毁有区别哦。

不改变L,所以不需要用指针。

*/int ClearList( LinkList L ){LinkList p,q;p = L—〉next;// p指向第一个结点while( p ) // 没到表尾则继续循环{q = p—>next;free( p );//释放空间p = q;}L—>next = NULL; // 头结点指针域为空,链表成了一个空表return 1;}// 若L为空表(根据头结点L—〉next来判断,为空则是空表),则返回1,// 否则返回0.int ListEmpty(LinkList L){if(L—>next ) // 非空return 0;elsereturn 1;}// 返回L中数据元素个数。

严蔚敏数据结构C语言版——线性表(初始化、插入、删除、遍历)

严蔚敏数据结构C语言版——线性表(初始化、插入、删除、遍历)

严蔚敏数据结构C语⾔版——线性表(初始化、插⼊、删除、遍历)1 #include<stdio.h>2 #include<malloc.h>3 #include<stdlib.h>45#define TRUE 16#define FALSE 07#define OK 18#define ERROR 09#define INFEASIBLE -110#define OVERFLOW -21112#define LIST_INIT_SIZE 100 //存储空间初始分配量13#define LISTINCREMENT 10 //存储空间不够时,动态增加的分配量1415 typedef int ElemType;16 typedef int Status;1718 typedef struct {19 ElemType *elem; //存储空间基地址20int length; //当前长度21int listsize; //当前分配的存储容量,即有多少个ElemType空间22 }SqList;2324 Status InitList_Sq(SqList *L); //初始化线性表25 Status ListInsert_Sq(SqList *L,int i,ElemType e); //插⼊操作26 Status ListDelete_Sq(SqList *L,int i,ElemType *e); //删除操作27void TraverseList_Sq(SqList L); //遍历线性表2829int main()30 {31 SqList L;32 ElemType e;33int i,n = 10;34 InitList_Sq(&L);35for(i= 1; i <= n; i++)36 {37 ListInsert_Sq(&L,i,i); //插⼊10个元素,1,2,3,...,1038 }39 TraverseList_Sq(L);4041 printf("输⼊要删除的位置:");42 scanf("%d",&i);43 ListDelete_Sq(&L,i,&e);44 TraverseList_Sq(L);45 printf("e=%d\n",e);4647 printf("输⼊要插⼊的位置和数值:");48 scanf("%d %d",&i,&e);49 ListInsert_Sq(&L,i,e);50 TraverseList_Sq(L);51return0;52 }5354 Status InitList_Sq(SqList *L)55 {56//分配存储空间100*sizeof(ElmeType),并把存储空间基地址返回给L->elem57 L->elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));58if(!L->elem) exit(OVERFLOW);59 L->length = 0;60//初始化存储空间容量为10061 L->listsize = LIST_INIT_SIZE;62return OK;63 }6465//在第i个位置前,插⼊新元素,i是从1开始变化的66 Status ListInsert_Sq(SqList *L,int i,ElemType e)67 {68//插⼊位置不合理69if(i < 1 || i> L->length+1) return ERROR;70//存储空间不⾜,增加分配71if(L->length >= L->listsize )72 {73 ElemType *newbase = (ElemType *) realloc (L->elem,74 (L->listsize + LISTINCREMENT)*sizeof(ElemType)); 75if(!newbase) exit(OVERFLOW);76 L->elem = newbase;77 L->listsize += LISTINCREMENT;78 }79 ElemType *q = &(L->elem[i-1]);80 ElemType *p;81for(p = &(L->elem[L->length-1]); p >= q; --p)82 {83 *(p+1)=*p;84 }85 *q = e;86 (L->length)++;87return OK;88 }8990 Status ListDelete_Sq(SqList *L,int i,ElemType *e)91 {92//删除位置不合理93if(i < 1 || i > L->length) return ERROR;94 ElemType *p = &(L->elem[i-1]);95 *e = *p;96 ElemType *q = &(L->elem[L->length-1]);97for(++p; p <= q; p++)98 {99 *(p-1) = *p;100 }101 (L->length)--;102return OK;103 }104105void TraverseList_Sq(SqList L)106 {107int i;108 printf("线性表元素为:");109for(i = 0; i <= L.length-1; i++)110 {111 printf("%d,",L.elem[i]);112 }113 printf("\n");114 }。

数据结构之线性表

数据结构之线性表
什么是线性表
线性表是最简单、最基本、最常用的数据结构。线性表是线性结构的抽象(Abstract),线性 结构的特点是结构中的数据元素之间存在一对一的线性关系。这种一对一的关系指的是数据 元素之间的位置关系,即:( 1)除第一个位置的数据元素外,其它数据元素位置的前面都 只有一个数据元素;( 2)除最后一个位置的数据元素外,其它数据元素位置的后面都只有 一个元素。也就是说,数据元素是一个接一个的排列。因此,可以把线性表想象为一种数据 元素序列的数据结构。
单链表的存储
链表是用一组任意的存储单元来存储线性表中的数据元素(这组存储单元可以是连续的,也 可以是不连续的)。那么,怎么表示两个数据元素逻辑上的相邻关系呢?即如何表示数据元 素之间的线性关系呢?为此,在存储数据元素时,除了存储数据元素本身的信息外,还要存 储与它相邻的数据元素的存储地址信息。这两部分信息组成该数据元素的存储映像(Image), 称为结点(Node)。把存储据元素本身信息的域叫结点的数据域(Data Domain),把存储与它 相邻的数据元素的存储地址信息的域叫结点的引用域(Reference Domain)。因此,线性表 通过每个结点的引用域形成了一根“链条”,这就是“链表”名称的由来。 如果结点的引用域只存储该结点直接后继结点的存储地址,则该链表叫单链表(Singly Linked List)。把该引用域叫 next。单链表结点的结构如图所示,图中 data 表示结点的数 据域。
data = val; next = p; }
//构造器
public DbNode(DbNode<T> p) {
next = p; }
//构造器 public DbNode(T val) { data = val; next = null; }

C语言数据结构-线性表SqList

C语言数据结构-线性表SqList

C语⾔数据结构-线性表SqList #ifndef __SQLLIST_H__#define __SQLLIST_H__#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLF -1#define OVERFLOW -2#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef int Status;typedef int ElemType;typedef struct {ElemType *elem;ElemType length;ElemType listsize;}SqList;#endif#include"SeqList.h"#include<stdlib.h>#include<stdio.h>Status initList_Sq(SqList &L) {L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));if(!L.elem) {exit(OVERFLOW);}L.length = 0;L.listsize = LIST_INIT_SIZE;return OK;}Status listInsert(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));if(!newbase) {exit(OVERFLOW);}L.elem = newbase;L.listsize += LISTINCREMENT;}ElemType *q = &(L.elem[i - 1]);for(ElemType *p = &(L.elem[L.length - 1]); p >= q; --p) {*(p + 1) = *p;}*q = e;++L.length;return OK;}void pShow(SqList L){printf("======= SqList ======\n");if(L.length != 0) {ElemType *t = L.elem;for(int i = 0; i < L.length; i++) {printf("L.elem[%d] = %d\n", i, t[i]);}} else {}printf("L.length = %d\n", L.length);printf("L.listsize = %d\n", L.listsize);}Status GetElem(SqList &L, int i, ElemType &e) {if(i > L.length || i < 1) {exit(OVERFLOW);}e = L.elem[i - 1];return OK;}Status LocateElem_Sq(SqList L, ElemType e) {ElemType i = 1;ElemType *p = L.elem;while(i <= L.length && *p++ != e) {++i;}if(i <= L.length) {return i;} else{return 0;}}Status ListLength(SqList L) {return L.length;}void Union(SqList &a, SqList b) {ElemType a_len = ListLength(a);ElemType b_len = ListLength(b);ElemType e;for (int i = 1; i <= b_len; ++i){/* code */GetElem(b, i, e);if(!LocateElem_Sq(a, e)) {listInsert(a, ++a_len, e);}}}void MergeList(SqList la, SqList lb, SqList &Lc) {initList_Sq(Lc);ElemType i = 1;ElemType j = 1;ElemType k = 0;ElemType La_len = ListLength(la);ElemType Lb_len = ListLength(lb);ElemType ai, bj;while((i <= La_len) && (j <= Lb_len)) {GetElem(la, i, ai);GetElem(lb, j, bj);if(ai <= bj) {listInsert(Lc, ++k, ai);++i;} else{listInsert(Lc, ++k, bj);++j;}}while(i <= La_len) {GetElem(la, i++, ai);listInsert(Lc, ++k, ai);}while(j <= Lb_len) {GetElem(lb, j++, bj);listInsert(Lc, ++k, bj);}}Status ListDelete_Sq(SqList &L, int i, ElemType &e) { if(i < 1 || (i > L.length)) {return ERROR;}ElemType *p = &(L.elem[i - 1]);e = *p;ElemType *q = L.elem + L.length - 1;for(++p; p <= q; ++p) {*(p -1) = *p;}--L.length;return OK;}int main() {ElemType e;SqList L;initList_Sq(L);for (int i = 0; i < 10; ++i){/* code */listInsert(L, i + 1, i);}SqList t;initList_Sq(t);for (int i = 0; i < 10; ++i){/* code */listInsert(t, i + 1, i + 10);}GetElem(L, 5, e);printf("l5 = %d\n", e);ElemType index = 6;ElemType value = LocateElem_Sq(L, index);printf("index = %d, value = %d\n", index, value); SqList r;MergeList(L, t, r);pShow(r);SqList a;initList_Sq(a);listInsert(a, 1, 3);listInsert(a, 2, 5);listInsert(a, 3, 8);listInsert(a, 4, 11);SqList b;initList_Sq(b);listInsert(b, 1, 2);listInsert(b, 2, 6);listInsert(b, 3, 8);listInsert(b, 4, 9);listInsert(b, 5, 11);listInsert(b, 6, 15);listInsert(b, 7, 20);SqList c;MergeList(a, b, c);pShow(c);Union(a, b);pShow(a);ListDelete_Sq(b, 6, e);pShow(b);return 0;}。

数据结构线性表

数据结构线性表

数据结构---线性表线性表代码主要参考严蔚敏《数据结构(c语言版)》,有部分改动线性表的定义定义•线性表是具有相同的数据类型的n(n >= 0)个数据元素的有限序列,当n=0时线性表为一个空表•用L表示线性表则L = (a1,a2,a3,…,ano a1为表头元素,an为表尾元素o a1无直接前驱,an无直接后继特点•表中元素个数有限•表中元素具有逻辑上的顺序,表中元素有先后次序•表中元素都是数据元素•表中元素的数据类型都相同,每个元素占的空间大小一致要点数据项、数据元素、线性表的关系线性表由若干个数据元素组成,而数据元素又由若干个数据项组成,数据项是数据的不可分割的最小单位。

其中姓名,学号等就是数据项线性表的顺序表示顺序表的定义顺序表是指用一组地址连续的存储单元依次存储信息表中的数据元素,从而使得逻辑相邻的两个元素在物理位置上也相邻预先定义(为了代码可以运行)#define True 1#define False 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;第n个元素的内存地址表示为LOC(A) + (n-1)*sizeof(ElemType)假定线性表的元素类型为ElemType,则线性表的顺序存储类型描述为typedef int ElemType ;#define MaxSize 50typedef struct{ElemType data[MaxSize];int length;}SqList;一维数组可以是静态分配的,也可以是动态分配的。

静态分配后大小和空间都固定了,下面使用动态分配的形式typedef int ElemType ;#define InitSize 100 //表长度的初始大小定义#define ListIncreasement 10 //线性表存储空间的分配增量typedef struct{ElemType *data;int MaxSize,length;}SeqList;顺序表的初始化顺序表的初始化,&是C++的引用,可以使用指针代替Status InitList(SeqList &L){L.data = (ElemType *) malloc(InitSize * sizeof(ElemType));if(! L.data) exit(OVERFLOW);//存储分配失败L.length = 0;L.MaxSize = InitSize;return OK;}顺序表的插入在顺序表L的第i(1<= i <= L.length +1)个位置插入新元素e,需要将第n 个至第i (共n-i+1)个元素向后移动一个位置【最后一个到倒数第n-i+i个元素向后移动一位】。

通过C语言调用函数的方式来实现线性表的基本操作

通过C语言调用函数的方式来实现线性表的基本操作
if(L->length>=L->listlize)
{
L->elem=(ElemType*)realloc(L->elem,(L->listlize+ Listincrement)*sizeof(ElemType));
if(!L->elem)exit(OVERFLOW);
L->listlize+=Listincrement;
scanf("%d",&e);
l=LocateElemList(&a,e);
if(l==0)
printf("the element %d does not in the list.\n",e);
else
printf("the element %d is the %dth in the list\n",e,l);
}
void print(node *p)
{
while(p->next!=NULL)
{
p=p->next;
printf(" %d*x^%d",p->coef,p->exp);
}
}
void polyadd(node *ha, node *hb)
{
node *p,*q,*pre,*temp;
int sum;







#include<stdlib.h>
#include<stdio.h>
#define List_Init_Size 100
#define Listincrement 10

数据结构(C语言版) 线性表 详细举例介绍

数据结构(C语言版) 线性表 详细举例介绍
// La中不存在和 e 相同的数据元素,则插入之
}
} // union
O(ListLength2(Lb))
算法2.1’’
试改变结构, 选用有序表表示集合。
有序表: 其数据元素依值从小 到大(非递减)有序排列的 线性表。
例如: (2,3,3,5,6,6,6,8,12)
void purge(List &La, List Lb) {
(求数据元素的后继)
初始条件: 线性表L已存在。
若cur_e是L的元素,但不是 操作结果:
最后一个,则用next_e返回它 的后继,否则操作失败, next_e无定义。
GetElem( L, i, &e ) (求线性表中某个数据元素)
线性表L已存在, 初始条件: 且 1≤i≤LengthList(L)
算法2.1’’
InitList(LA); La_len = ListLength(La); Lb_len =ListLength(Lb); // 求线性表的长度
for (i = 1; i <= Lb_len; i++) { GetElem(Lb, i, e);
// 取Lb中第i个数据元素赋给e
if (ListEmpty(La) || !equal (en, e)) { ListInsert(La, ++La_len, e); 算法2.1’ en = e;
} // La中不存在和 e 相同的数据元素,则插入之
}
}
O(ListLength(Lb))
例2-2 (教材P.20)
归并两个“其数据元素按值非递减有 序排列”的线性表 LA 和 LB,求得线性 表 LC 也具有同样特性。

数据结构_线性表实例4-6

数据结构_线性表实例4-6

/*------数据结构之线性表---------------名称:线性表的链式存储实例语言:C语言敲者:C.ROOKIE邮箱:MG_TCCX@Q Q:2424488418日期:2012.11.09 (13:24)目的:再次复习数据结构心情:终于白天写一次程序喽..实例:已知单链表L,写一算法将其逆置。

--------------------------------------*//*算法思路:当链表为空或者只有一个节点时,逆置的结果是本身。

当链表含两个以上的节点时,可将处理成只含开始节点的带头节点链表(表1)和一个无头节点的包含该链表剩余节点的链表(表2)。

将表2中所有节点顺着链表指针,由前往后将每个节点依次摘下,作为第一节点插入到表1中。

*/#include<stdio.h>#include<malloc.h>/*单链表的链式存储结构类型*/typedef char DataType;typedef struct node{DataType data;struct node *next;}ListNode;typedef ListNode *LinkList; //LinkList是指针类型../*创建L函数声明*/LinkList CreateList();/*输出L函数声明*/void PrintList(LinkList L);/*逆置实现算法声明*/LinkList ReverseList(LinkList L);/*主函数*/int main(){LinkList L;L=CreateList();printf("没有逆置之前的L:");PrintList(L);L=ReverseList(L);printf("逆置后的L:");PrintList(L);return 0;}/*创建L的函数*/LinkList CreateList(){LinkList L;DataType ch;ListNode *p;L=(LinkList)malloc(sizeof(ListNode));L->next=NULL; //附加头结点..printf("请输入L表的内容:");ch=getchar();while(ch!='\n'){p=(LinkList)malloc(sizeof(ListNode));p->data=ch;p->next=L->next;L->next=p;ch=getchar();}printf("创建L成功,按任意键继续!\n");getchar();return L;}/*输出L函数*/void PrintList(LinkList L){LinkList p;p=L;p=p->next;while(p!=NULL){printf("%c",p->data);p=p->next;}printf("\n");}/*逆置实现算法*/LinkList ReverseList(LinkList L){ListNode *q,*p;if(L->next&&L->next->next) //当L不是空表且不是单节点时..{p=L->next;//p指向第一个节点..q=p->next;//q指向第二个节点..p->next=NULL;//这样L是表1,q是表2了,L现在只有一个元素(第一个节点)..while(q) //判断q是不是到了尾节点..{p=q;q=q->next;p->next=L->next;L->next=p;}return L;}return L;}/*------数据结构之线性表---------------名称:线性表的链式存储实例语言:C语言敲者:C.ROOKIE邮箱:MG_TCCX@Q Q:2424488418日期:2012.11.10 (05:34)目的:再次复习数据结构心情:今天是我的生日..实例:已知单链表L,编写算法,将单链表中值重复的节点删除,使得的表中各节点的值都不同。

线性表的排序与合并(C语言)

线性表的排序与合并(C语言)

线性表的排序与合并(C语言)#include "stdio.h"#include "malloc.h"#include "stdlib.h"#define maxsize 1024typedef int datatype;typedef struct{datatype data[maxsize];int last;} sequenlist;void creatlist (sequenlist *L){ int n,i;int tmp;printf("请输入表数据的个数:\n"); scanf("%d",&n);printf("请输入数据:\n");for(i=0;i<n;i++){ fflush(stdin);scanf("%d",&tmp);L->data[i]=tmp;}L->last=n-1;printf("\n");}void creatlistmerge (sequenlist *L) { int n,i;printf("请输入表数据的个数:\n"); scanf("%d",&n);for(i=0;i<n;i++){fflush(stdin);L->data[i]=0;}L->last=n-1;}void printout (sequenlist *L){ int i;for(i=0;i<=L->last;i++){ printf("data[%d]=",i);printf("%d\n",L->data[i]);}}void sort(sequenlist *L){int i, j;datatype a;for(i=0;i<L->last;i++)for(j=0;j<L->last-i;j++)if(L->data[j]>L->data[j+1]){a=L->data[j];L->data[j]=L->data[j+1];L->data[j+1]=a;}}void merge(sequenlist *L1,sequenlist *L2,sequenlist *L3) {int i;for(i=0;i<=L1->last;i++)L3->data[i]=L1->data[i];for(i=0;i<=L2->last;i++)L3->data[i+(L1->last)+1]=L2->data[i];}void main(){sequenlist *L1,*L2,*L3;int i;L1=(sequenlist*)malloc(sizeof(sequenlist));L2=(sequenlist*)malloc(sizeof(sequenlist));L3=(sequenlist*)malloc(sizeof(sequenlist));printf("第一张表:\n");creatlist(L1);printf("第二张表:\n");creatlist(L2);printf("第一张表为:\n");printout(L1);printf("\n");printf("第二张表为:\n");printout(L2);printf("\n");creatlistmerge(L3);sort(L1);sort(L2);printf("排序后的第一张表为:\n");printout(L1);printf("排序后的第二张表为:\n");printout(L2);printf("\n");merge(L1,L2,L3);printf("合并表为:\n"); printout(L3);sort(L3);printf("排序后的总表为:\n"); printout(L3);}。

数据结构——使用C语言版(朱战立)线性表

数据结构——使用C语言版(朱战立)线性表
结点结构如下图示:
数据域 指针域 或
data next
数据域:存储元 素数值数据
指针域:存储直接后继的存
储位置
第二十一页,编辑于星期三:三点 分。
(2)头指针、头结点和首元结点的区别
示意图如下:
hea d
头指针
a0
a1
头结点
首元结点

an ^
第二十二页,编辑于星期三:三点 分。
头指针是指向链表中第一个结点(或为头结点、或为首元结点 )的指针;
struct Node *next;
} SLNode
(1)初始化ListInitiate(head)
void ListInitiate(SLNode **head)
{ *head = (SLNode *)malloc(sizeof(SLNode));
(*head)->next = NULL;
}
第三十页,编辑于星期三:三点 分。
L->list[j] = L->list[j-1];
L->list[i] = x;
L->size ++;
return 1;
}
}
第八页,编辑于星期三:三点 分。
0
1
2
3
4
5
list
10
11
12
14
15
16
6
7
... MaxSize-1
i=3
size=6
0
1
2
3
4
5
6
7
list
10
11 i=3 12
13
(1)单链表中构成链表的结点只有一个指向直接后继结点的指针域 。其结构特点:逻辑上相邻的数据元素在物理上不一定相邻。

【数据结构】线性表的基本操作

【数据结构】线性表的基本操作

【数据结构】线性表的基本操作线性表的基本操作⒈创建线性表⑴静态创建静态创建是指在编译或运行前确定线性表的大小并分配相应的内存空间。

可以使用数组来实现静态创建。

⑵动态创建动态创建是指在运行时根据需要动态分配内存空间。

可以使用链表来实现动态创建。

⒉插入元素⑴头部插入在线性表的头部插入一个元素,即将现有的元素全部后移一位。

⑵中间插入在线性表的指定位置插入一个元素,需要将指定位置之后的元素全部后移一位。

⑶尾部插入在线性表的尾部插入一个元素,即在现有元素的后面新增一个元素。

⒊删除元素⑴头部删除删除线性表的头部元素,即将头部元素后面的元素全部前移一位。

⑵中间删除删除线性表的指定位置元素,需要将指定位置之后的元素全部前移一位。

⑶尾部删除删除线性表的尾部元素。

⒋查找元素⑴按值查找按给定的值,在线性表中查找相应的元素,并返回其位置。

⑵按索引查找按给定的索引,直接在线性表中查找相应的元素。

⒌修改元素⑴按索引修改按给定的索引,直接修改线性表中相应位置的元素。

⑵按值修改按给定的值,在线性表中查找相应的元素,并修改其值。

⒍获取元素个数获取线性表中元素的个数。

⒎判断线性表是否为空判断线性表中是否没有任何元素。

⒏清空线性表将线性表中的元素全部删除,使线性表为空。

⒐销毁线性表释放线性表所占用的内存空间,销毁线性表。

附件:●暂无附件法律名词及注释:暂无相关法律名词及注释。

数据结构之线性表详细解答

数据结构之线性表详细解答

二章线性表线性表是最简单、最基本、也是最常用的一种线性结构。

它有两种存储方法:顺序存储和链式存储,它的主要基本操作是插入、删除和检索等。

2.1 线性表的逻辑结构2.1.1 线性表的定义线性表是一种线性结构。

线性结构的特点是数据元素之间是一种线性关系,数据元素“一个接一个的排列”。

在一个线性表中数据元素的类型是相同的,或者说线性表是由同一类型的数据元素构成的线性结构。

在实际问题中线性表的例子是很多的,如学生情况信息表是一个线性表:表中数据元素的类型为学生类型; 一个字符串也是一个线性表:表中数据元素的类型为字符型,等等。

综上所述,线性表定义如下:线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列,通常记为:(a1,a2,… a i-1,a i,a i+1,…a n)其中n为表长,n=0 时称为空表。

表中相邻元素之间存在着顺序关系。

将a i-1 称为a i 的直接前趋,a i+1 称为a i 的直接后继。

就是说:对于a i,当i=2,...,n 时,有且仅有一个直接前趋a i-1.,当i=1,2,...,n-1 时,有且仅有一个直接后继a i+1,而a1 是表中第一个元素,它没有前趋,a n 是最后一个元素无后继。

需要说明的是:a i为序号为i 的数据元素(i=1,2,…,n),通常我们将它的数据类型抽象为datatype,datatype根据具体问题而定,如在学生情况信息表中,它是用户自定义的学生类型; 在字符串中,它是字符型; 等等。

2.1.2 线性表的基本操作在第一章中提到,数据结构的运算是定义在逻辑结构层次上的,而运算的具体实现是建立在存储结构上的,因此下面定义的线性表的基本运算作为逻辑结构的一部分,每一个操作的具体实现只有在确定了线性表的存储结构之后才能完成。

线性表上的基本操作有:⑴线性表初始化:Init_List(L)初始条件:表L不存在操作结果:构造一个空的线性表⑵求线性表的长度:Length_List(L)初始条件:表L存在操作结果:返回线性表中的所含元素的个数⑶取表元:Get_List(L,i)初始条件:表L存在且1<=i<=Length_List(L)操作结果:返回线性表L中的第i个元素的值或地址⑷按值查找:Locate_List(L,x),x是给定的一个数据元素。

数据结构实验 C语言版 线性表__C版

数据结构实验 C语言版 线性表__C版
17
2. 求表长
L.length
3. 取第i个元素
L.elem[i-1]
(0<i<L.length+1)
18
4. 元素定位操作
分析:依次取出每个元素和给定值进行比较 int LocateElem_Sq (SqList L, ElemType e, Status (*compare)(ElemType, ElemType))
6. 删除操作
线性表的删除运算是指将表的第i(1≦i≦n)个元 素删除,使长度为n的线性表: (a1,…a i-1,ai,a i+1…,an) 变成长度为n-1的线性表 (a1,…a i-1,a i+1,…,an)
操作步骤: ① 判断线性表是否为空 ② 判断i值是否合法:1≦i≦n ③ 元素前移 ④ 表长减1
2
线性结构:数据元素之间存在1对1的关系。 四个特征: ① 存在惟一的一个“第一元素” ② 存在惟一的一个“最后元素” ③ 除最后元素外,其它元素均有惟一的“后继” ④ 除第一元素外,其它元素均有惟一的“前驱”
3
2.1 线性表的类型定义
一.定义
线性表(Linear List) :由n(n≧0)个数据元素组成的 有限序列。记作: (a1,a2,…an) 其中数据元素的个数n定义为表的长度。当n=0时称 为空表 这里的数据元素ai(1≦i≦n)只是一个抽象的符号, 其具体含义在不同的情况下可以不同。 例1、26个英文字母组成的字母表 (A,B,C、…、Z) 例2、某校从1978年到1983年各种型号的计算机拥 有量的变化情况。 4 (6,17,28,50,92,188)
思考:若要直接查相等的呢?
19
5. 插入操作
线性表的插入运算是指在表的第i(1≦i≦n+1)个位置上,插 入一个新元素e,使长度为n的线性表(a1,…a i-1,ai,…,an) 变成长度为n+1的线性表 (a1,…a i-1,e,ai,…,an) 操作步骤: ① 判断i是否符合要求:1≦i≦n+1 ② 判断表长是否溢出 ③ 元素右移 ④ 插入 ⑤ 表长增1
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
la.len=strlen(la.str);lb.len=strlen(lb.str);
mergelist(la,lb,&lc);
PRINT(lc);break;
case 'h':
printf("退出系统:\n");
printf("Are you sure to Quit?(y/n)");
{ char ai,bj;
int la_len,lb_len;
int i=1,j=1,k=0;
initiate(lc);
la_len=length(la); lb_len=length(lb);
while((i<=la_len)&&(j<=lb_len))
if(ss==lis.str[i])
break;
if(i<lis.len)
printf("你要找的字母的下标是:%d\n",i+1);
else printf("你要找的字母不存在\n");
return;
}
void insert(STU *lis,int n,char ss)//线性表插入函数//
void del();//线性表删除函数//
void empty();//线性表判空函数//
void PRINT();//线性表输出函数//
char MenuSelect();//目录函数//
void mergelist();//线性表归并函数//
int main()//主函数//
{ char c,ss;
printf("\n 请选择(a-i):\n\n");
c=getchar();
}
while(c<'a'||c>'h');
return(c);
}
void mergelist(STU la,STU lb,STU *lc)//线性表归并函数//
case 'e':
PRINT(la);
break;
case 'f':
length(la);break;
case 'g':
printf("请输入两个有序字母数列:");
scanf("%s%s",la.str,lb.str);
insert(&la,n,ss);
break;
case 'c':
del(&la);
break;
case 'd':
empty(la);
break;
int i=0;
printf("请输入你需要删除的字母的下标:");
scanf("%d",&n);
if(n>lis->len||n<1){printf("你要操作的列表不合法\n");return ;}
for(i=n-1;i<lis->len;i++)
lis->str[i]=lis->str[i+1];
{
case 'a':
locate(la);
break;
case 'b':
printf("请输入你需插入的字母的位置和字母:");
scanf("%d %c",&n,&ss);
{ ai=get(la,i++); insert(lc,++k,ai);}
while(j<=lb_len)
{bj=get(lb,j++); insert(lc,++k,bj);}
}
{ int i;
for(i=0;i<L.len;i++)
printf("%c",L.str[i]);
printf("\n");
return;
}
char MenuSelect()//目录函数//
{
char c;
do
{
system("cls");
initiate(STU *lis)
{
lis->len=0;
printf("初始化成功\n");
}
int length();//线性表求长度函数//
char get();//线性表获取函数//
void locate();//线性表查找函数//
void insert();//线性表插入函数//
int n;
STU la,lb,lc;
int i=0;
initiate(&la);
printf("请输入一个线性表");
scanf("%s",la.str);
la.len=strlen(la.str);
while(1)
{
switch(MenuSelect())//调用显示主目录函数//
--(lis->len);
return;
}
void empty(STU L)//线性表判空函数//
{
if(L.len==0)
printf("列表为空\n");
else printf("列表不为空\n");
return;
}
void PRINT(STU L)
{
int i=0;
for(i=lis->len;i>=n;i--)
lis->str[i]=lis->str[i-1];
lis->str[n-1]=ss;
++(lis->len);
return;
}
void del(STU *lis)//线性表删除函数//
{
int n;
#include <stdlib.h>
#include<stdio.h>
#include <conio.h>
#include<string.h>
#define N 100
typedef struct
{
char str[100];
int len;
}STU;
STU la,lb;
printf(" \n\n\n\t\t\t\ta查找字母\n\n");
printf(" \t\t\t\tb插入字母\n\n");
printf(" \t\t\t\tc删除字母\n\n");
printf(" \t\t\t\td判断线性表是否为空\n\n");
}
return 0;
}
int length(STU lis)//线性表求长度函数//
{
printf("线性表的长度是%d\n",lis.len);
return lis.len;
}
char get(STU lis,int n)//线性表获取函数//
{
if((n<1)||(n>lis.len)) {printf("你要找的不合法\n");return 0;}
printf(" \t\t\t\te查看线性表\n\n");
printf(" \t\t\t\tf求线性表长度\n\n");
printf(" \t\t\t\tg归并线性表\n\n");
printf(" \t\t\t\th退出系统\n\n");
else
return lis.str[n-1];
}
void locate(STU lis)//线性表查找函数//
{ char ss;
int i=0;
printf("请输入你需要知道的字母:");
getchar();
scanf("%c",&ss);
for(i=0;i<lis.len;i++)
{ ai=get(la,i);
bj=get(lb,j);
if(ai<bj)
{ insert(lc,++k,ai); ++i;}
else { insert(lc,++k,bj);++j;}
}
while(i<=la_len)
getchar();
c=getchar();
if(c=='n')break;
if(c=='y')
exit(0);
}
system("pause");
相关文档
最新文档