数据结构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的工作环境及其基本操作,进一步掌握了基本函数的调用以及使用方法。
数据结构实验报告-线性表(顺序表实现)
实验1:线性表(顺序表的实现)一、实验项目名称顺序表基本操作的实现二、实验目的掌握线性表的基本操作在顺序存储结构上的实现。
三、实验基本原理顺序表是由地址连续的的向量实现的,便于实现随机访问。
顺序表进行插入和删除运算时,平均需要移动表中大约一半的数据元素,容量难以扩充四、主要仪器设备及耗材Window 11、Dev-C++5.11五、实验步骤1.导入库和一些预定义:2.定义顺序表:3.初始化:4.插入元素:5.查询元素:6.删除元素:7.销毁顺序表:8.清空顺序表:9.顺序表长度:10.判空:11.定位满足大小关系的元素(默认小于):12.查询前驱:13.查询后继:14.输出顺序表15.归并顺序表16.写测试程序以及主函数对顺序表的每一个操作写一个测试函数,然后在主函数用while+switch-case的方式实现一个带菜单的简易测试程序,代码见“实验完整代码”。
实验完整代码:#include <bits/stdc++.h>using namespace std;#define error 0#define overflow -2#define initSize 100#define addSize 10#define compareTo <=typedef int ElemType;struct List{ElemType *elem;int len;int listsize;}L;void init(List &L){L.elem = (ElemType *) malloc(initSize * sizeof(ElemType)); if(!L.elem){cout << "分配内存失败!";exit(overflow);}L.len = 0;L.listsize = initSize;}void destroy(List &L){free(L.elem);L.len = L.listsize = 0;}void clear(List &L){L.len = 0;}bool empty(List L){if(L.len == 0) return true;else return false;}int length(List L){return L.len;}ElemType getElem(List L,int i){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}return L.elem[i - 1];}bool compare(ElemType a,ElemType b) {return a compareTo b;}int locateElem(List L,ElemType e) {for(int i = 0;i < L.len;i++){if(compare(L.elem[i],e))return i;}return -1;}int check1(List L,ElemType e){int idx = -1;for(int i = 0;i < L.len;i++)if(L.elem[i] == e)idx = i;return idx;}bool check2(List L,ElemType e){int idx = -1;for(int i = L.len - 1;i >= 0;i--)if(L.elem[i] == e)idx = i;return idx;}int priorElem(List L,ElemType cur_e,ElemType pre_e[]) {int idx = check1(L,cur_e);if(idx == 0 || idx == -1){string str = "";str = idx == 0 ? "无前驱结点" : "不存在该元素";cout << str;exit(error);}int cnt = 0;for(int i = 1;i < L.len;i++){if(L.elem[i] == cur_e){pre_e[cnt ++] = L.elem[i - 1];}}return cnt;}int nextElem(List L,ElemType cur_e,ElemType next_e[]){int idx = check2(L,cur_e);if(idx == L.len - 1 || idx == - 1){string str = "";str = idx == -1 ? "不存在该元素" : "无后驱结点";cout << str;exit(error);}int cnt = 0;for(int i = 0;i < L.len - 1;i++){if(L.elem[i] == cur_e){next_e[cnt ++] = L.elem[i + 1];}}return cnt;}void insert(List &L,int i,ElemType e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}if(L.len >= L.listsize){ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize + addSize) * sizeof(ElemType));if(!newbase){cout << "内存分配失败!";exit(overflow);}L.elem = newbase;L.listsize += addSize;for(int j = L.len;j > i - 1;j--)L.elem[j] = L.elem[j - 1];L.elem[i - 1] = e;L.len ++;}void deleteList(List &L,int i,ElemType &e){if(i < 1 || i > L.len + 1){cout << "下标越界!";exit(error);}e = L.elem[i - 1];for(int j = i - 1;j < L.len;j++)L.elem[j] = L.elem[j + 1];L.len --;}void merge(List L,List L2,List &L3){L3.elem = (ElemType *)malloc((L.len + L2.len) * sizeof(ElemType)); L3.len = L.len + L2.len;L3.listsize = initSize;if(!L3.elem){cout << "内存分配异常";exit(overflow);}int i = 0,j = 0,k = 0;while(i < L.len && j < L2.len){if(L.elem[i] <= L2.elem[j])L3.elem[k ++] = L.elem[i ++];else L3.elem[k ++] = L2.elem[j ++];}while(i < L.len)L3.elem[k ++] = L.elem[i ++];while(j < L2.len)L3.elem[k ++] = L2.elem[j ++];}bool visit(List L){if(L.len == 0) return false;for(int i = 0;i < L.len;i++)cout << L.elem[i] << " ";cout << endl;return true;}void listTraverse(List L){if(!visit(L)) return;}void partion(List *L){int a[100000],b[100000],len3 = 0,len2 = 0; memset(a,0,sizeof a);memset(b,0,sizeof b);for(int i = 0;i < L->len;i++){if(L->elem[i] % 2 == 0)b[len2 ++] = L->elem[i];elsea[len3 ++] = L->elem[i];}for(int i = 0;i < len3;i++)L->elem[i] = a[i];for(int i = 0,j = len3;i < len2;i++,j++) L->elem[j] = b[i];cout << "输出顺序表:" << endl;for(int i = 0;i < L->len;i++)cout << L->elem[i] << " ";cout << endl;}//以下是测试函数------------------------------------void test1(List &list){init(list);cout << "初始化完成!" << endl;}void test2(List &list){if(list.listsize == 0)cout << "线性表不存在!" << endl;else{int len;ElemType num;cout << "选择插入的元素数量:" << endl;cin >> len;cout << "依次输入要插入的元素:" << endl;for(int i = 1;i <= len;i++){cin >> num;insert(list,i,num);}cout << "操作成功!" << endl;}}void test3(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "请输入要返回的元素的下标" << endl;int idx;cin >> idx;cout << "线性表中第" << idx << "个元素是:" << getElem(L,idx) << endl;}}void test4(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{int idx;ElemType num;cout << "请输入要删除的元素在线性表的位置" << endl;cin >> idx;deleteList(L,idx,num);cout << "操作成功!" << endl << "被删除的元素是:" << num << endl; }}void test5(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{destroy(L);cout << "线性表已被销毁" << endl;}}void test6(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{clear(L);cout << "线性表已被清空" << endl;}}void test7(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else cout << "线性表的长度现在是:" << length(L) << endl;}void test8(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else if(empty(L))cout << "线性表现在为空" << endl;else cout << "线性表现在非空" << endl;}void test9(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num;cout << "请输入待判定的元素:" << endl;cin >> num;cout << "第一个与目标元素满足大小关系的元素的位置:" << locateElem(L,num) << endl;}}void test10(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = priorElem(L,num,num2);cout << num << "的前驱为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test11(){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{ElemType num,num2[initSize / 2];cout << "请输入参照元素:" << endl;cin >> num;int len = nextElem(L,num,num2);cout << num << "的后继为:" << endl;for(int i = 0;i < len;i++)cout << num2[i] << " ";cout << endl;}}void test12(List list){if(L.listsize == 0)cout << "线性表不存在!" << endl;else{cout << "输出线性表所有元素:" << endl;listTraverse(list);}}void test13(){if(L.listsize == 0)cout << "初始线性表不存在!" << endl; else{List L2,L3;cout << "初始化一个新线性表" << endl;test1(L2);test2(L2);cout << "归并两个线性表" << endl;merge(L,L2,L3);cout << "归并成功!" << endl;cout << "输出合并后的线性表" << endl;listTraverse(L3);}}void test14(){partion(&L);cout << "奇偶数分区成功!" << endl;}int main(){std::ios::sync_with_stdio(false);cin.tie(0),cout.tie(0);int op = 0;while(op != 15){cout << "-----------------menu--------------------" << endl;cout << "--------------1:初始化------------------" << endl;cout << "--------------2:插入元素----------------" << endl;cout << "--------------3:查询元素----------------" << endl;cout << "--------------4:删除元素----------------" << endl;cout << "--------------5:销毁线性表--------------" << endl;cout << "--------------6:清空线性表--------------" << endl;cout << "--------------7:线性表长度--------------" << endl;cout << "--------------8:线性表是否为空----------" << endl;cout << "--------------9:定位满足大小关系的元素--" << endl;cout << "--------------10:查询前驱---------------" << endl;cout << "--------------11:查询后继---------------" << endl;cout << "--------------12:输出线性表-------------" << endl;cout << "--------------13:归并线性表-------------" << endl;cout << "--------------14:奇偶分区---------------" << endl;cout << "--------------15: 退出测试程序-----------" << endl;cout << "请输入指令编号:" << endl; if(!(cin >> op)){cin.clear();cin.ignore(INT_MAX,'\n');cout << "请输入整数!" << endl;continue;}switch(op){case 1:test1(L);break;case 2:test2(L);break;case 3:test3();break;case 4:test4();break;case 5:test5();break;case 6:test6();break;case 7:test7();break;case 8:test8();break;case 9:test9();break;case 10:test10();break;case 11:test11();break;case 12:test12(L);break;case 13:test13();break;case 14:test14();break;case 15:cout << "测试结束!" << endl;default:cout << "请输入正确的指令编号!" << endl;}}return 0;}六、实验数据及处理结果1.初始化:2.插入元素3.查询元素(返回的是数组下标,下标从0开始)4.删除元素(位置从1开始)5.销毁顺序表6.清空顺序表7.顺序表长度(销毁或清空操作前)8.判空(销毁或清空操作前)9.定位满足大小关系的元素(销毁或清空操作前)说明:这里默认找第一个小于目标元素的位置且下标从0开始,当前顺序表的数据为:1 4 2 510.前驱(销毁或清空操作前)11.后继(销毁或清空操作前)12.输出顺序表(销毁或清空操作前)13.归并顺序表(销毁或清空操作前)七、思考讨论题或体会或对改进实验的建议通过本次实验,我掌握了定义线性表的顺序存储类型,加深了对顺序存储结构的理解,进一步巩固和理解了顺序表的基本操作,如建立、查找、插入和删除等。
【数据结构】线性表的基本操作
【数据结构】线性表的基本操作【数据结构】线性表的基本操作1:定义1.1 线性表的概念1.2 线性表的特点2:基本操作2.1 初始化操作2.1.1 空表的创建2.1.2 非空表的创建2.2 插入操作2.2.1 在指定位置插入元素2.2.2 在表头插入元素2.2.3 在表尾插入元素2.3 删除操作2.3.1 删除指定位置的元素2.3.2 删除表头的元素2.3.3 删除表尾的元素2.4 查找操作2.4.1 按值查找元素2.4.2 按位置查找元素2.5 修改操作2.5.1 修改指定位置的元素 2.5.2 修改指定值的元素3:综合操作3.1 反转线性表3.2 合并两个线性表3.3 排序线性表3.4 删除重复元素3.5 拆分线性表4:线性表的应用场景4.1 数组的应用4.2 链表的应用4.3 栈的应用4.4 队列的应用附件:无法律名词及注释:- 线性表:根据某种规则排列的一组元素的有限序列。
- 初始化操作:创建一个空的线性表,或者创建一个已经包含一定元素的线性表。
- 插入操作:在线性表的指定位置或者表头、表尾插入一个新元素。
- 删除操作:从线性表中删除掉指定位置或者表头、表尾的元素。
- 查找操作:在线性表中按照指定的元素值或者位置查找元素。
- 修改操作:更改线性表中指定位置或者值的元素。
- 反转线性表:将线性表中的元素顺序颠倒。
- 合并线性表:将两个线性表合并成一个新的线性表。
- 排序线性表:按照某种规则对线性表中的元素进行排序。
- 删除重复元素:将线性表中重复的元素删除,只保留一个。
- 拆分线性表:将一个线性表分成多个不重叠的子线性表。
c语言单链表头插法实现链表逆置
c语言单链表头插法实现链表逆置链表是一种常用的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。
在C语言中,我们可以使用单链表来实现各种操作,如插入、删除和查找等。
本文将介绍如何使用头插法实现链表的逆置。
首先,我们需要定义一个链表节点的结构体,包含数据和指向下一个节点的指针。
代码如下:```ctypedef struct Node {int data;struct Node* next;} Node;```接下来,我们需要实现链表的创建和逆置函数。
首先,创建一个空链表,并将头节点指针指向NULL。
代码如下:```cNode* createList() {Node* head = NULL;return head;}```然后,我们可以实现链表的插入函数,使用头插法将新节点插入到链表的头部。
代码如下:```cNode* insertNode(Node* head, int data) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->data = data;newNode->next = head;head = newNode;return head;}```接下来,我们可以实现链表的逆置函数,通过遍历链表,将每个节点插入到头部,从而实现链表的逆置。
代码如下:```cNode* reverseList(Node* head) {Node* newHead = NULL;Node* temp = NULL;while (head != NULL) {temp = head->next;head->next = newHead;newHead = head;head = temp;}return newHead;}```最后,我们可以编写主函数,测试链表的逆置功能。
代码如下:```cint main() {Node* head = createList();head = insertNode(head, 1);head = insertNode(head, 2);head = insertNode(head, 3);head = insertNode(head, 4);head = insertNode(head, 5);printf("原链表:");Node* temp = head;while (temp != NULL) {printf("%d ", temp->data);temp = temp->next;}printf("\n");head = reverseList(head);printf("逆置后的链表:");temp = head;while (temp != NULL) {printf("%d ", temp->data);temp = temp->next;}printf("\n");return 0;}```运行以上代码,输出结果如下:```原链表:5 4 3 2 1逆置后的链表:1 2 3 4 5```通过以上代码,我们成功地使用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)点击运行,首先出现的是菜单界面,选择菜单选项进行操作,如图所示。
线性表的插入和删除(数据结构)
电子信息工程学系实验报告——适用于计算机课程课程名称:Array实验项目名称:线性表的插入和删除实验时间: 2012、3、班级:计应102 姓名:学号:实验目的:熟悉掌握线性表的基本操作在顺序存储结构和链式存储结构上的实现,并熟悉其各自的优缺点及适用性。
实验环境:C—Free5.0实验内容及过程:题目1:编写程序实现下列的要求:(1) 设数据元素为整数,实现这样的线性表的顺序存储表示。
(2) 键盘输入10个数据元素,利用顺序表的基本操作,建立该表。
(3) 利用顺序表的基本操作,找出表中的最大的和最小的数据元素(用于比较的数据元素为整数)。
(4) * 若数据元素为学生成绩(含姓名、成绩等字段),重新编程,实现上面的要求。
要求尽可能少地修改前面的程序来得到新程序。
(这里用于比较的字段为分数)题目2:编写程序实现下列的要求:(1) 设学生成绩表中的数据元素为学生成绩(含姓名、成绩字段),实现这样的线性表的链式存储表示。
(2) 键盘输入若干个数据元素(用特殊数据来标记输入数据的结束),利用链表的基本操作(前插或后插算法),建立学生成绩单链表。
(3) 键盘输入关键字值x,打印出表中所有关键字值<=x的结点数据。
(用于比较的关键字字段为分数)。
(4) 输入关键字值x,删除表中所有关键字值<=x的结点。
(用于比较的关键字字段为分数)。
实验结果及分析:题目一:(4):题目二:实验心得:通过这次的实验,对线性表和单链表的创建和修改有了初步的认识,和同学的讨论互相弥补了不足,相信在未来的学习中会有更大的收获。
附录:题目一代码:#include "stdio.h"#include "conio.h"typedef int datatype;struct seqlist{int maxnum;int n;datatype *element;};typedef struct seqlist *Pseqlist;Pseqlist creatnulllist_seq(int m) /* 建立空的顺序表*/{Pseqlist p=(Pseqlist)malloc(sizeof(struct seqlist));if(p!=NULL){p->element=(datatype *)malloc(sizeof(datatype)*m);if(p->element!=NULL){p->maxnum=m;p->n=0;}else free(p);}printf("out of space");return NULL;}Pseqlist init_seq(Pseqlist p,int n) /* 初始化空的顺序表,即填充数据,顺序表的实际元素个数n 由参数提供*/{int i;printf("input the element of seqlist:");for(i=0;i<n;i++)scanf("%d",&p->element[i]);p->n=n;return(p);}int insertpost_seq(Pseqlist p,int i,datatype x) /* 在i之后插入一个元素x */{int j;if(p->n>=p->maxnum){printf("overflow");return(0);}if(i<0 || i>p->n ){printf("not exist");return(0);}for(j=p->n-1; j>=i+1; j--)p->element[j+1]=p->element[j];p->element[i+1]=x;p->n++;return(1);}void print(Pseqlist p) /* 打印顺序表中的元素*/{int i;for(i=0;i<p->n;i++)int FinMax(Pseqlist p){int max=p->element[0];int i;for(i=1;i<p->n;++i){if(max<p->element[i])max=p->element[i];}return max;}int FinMin(Pseqlist p){int min=p->element[0];int i;for(i=1;i<p->n;++i){if(min>p->element[i])min=p->element[i];}return min;}main(){Pseqlist p;int m,n,i,x,k;printf("input the size of seqlist m:"); /* 输入顺序表的最大空间m,建立空的顺序表*/ scanf("%d",&m);p=creatnulllist_seq(m);printf("input the real number of seqlist n(n<m):"); /* 输入顺序表的实际长度n,初始化顺序表*/ scanf("%d",&n);p=init_seq(p,n);/* 输出插入之前顺序表的元素*/ print(p);printf("\n");printf("input i,x:");scanf("%d%d",&i,&x); /* k的值用来表示是否插入成功*/k=insertpost_seq(p,i,x);if(k==1) print(p); /* 如果插入成功,输出插入之后顺序表的元素*/ printf("\nmax:%d,min:%d\n",FinMax(p),FinMin(p));}题目一的(4)的代码:#include "stdio.h"#include "conio.h"//typedef int datatype;typedef struct student{int score;char name[30];}datatype;struct seqlist{int maxnum;int n;datatype *element;};typedef struct seqlist *Pseqlist;Pseqlist creatnulllist_seq(int m) /* 建立空的顺序表*/{Pseqlist p=(Pseqlist)malloc(sizeof(struct seqlist));if(p!=NULL){p->element=(datatype *)malloc(sizeof(datatype)*m);if(p->element!=NULL){p->maxnum=m;p->n=0;return(p);}else free(p);}printf("out of space");return NULL;}Pseqlist init_seq(Pseqlist p,int n) /* 初始化空的顺序表,即填充数据,顺序表的实际元素个数n 由参数提供*/{int i;printf("输入10个分数:输入10个名字:");for(i=0;i<n;i++)scanf("%d%s",&p->element[i].score,p->element[i].name);return(p);}int insertpost_seq(Pseqlist p,int i,datatype x) /* 在i之后插入一个元素x */ {int j;if(p->n>=p->maxnum){printf("overflow");return(0);}if(i<0 || i>p->n ){printf("not exist");return(0);}i-=2;for(j=p->n-1; j>=i+1; j--)p->element[j+1]=p->element[j];p->element[i+1]=x;p->n++;return(1);}int FinMax(Pseqlist p){int max=p->element[0].score;int i;for(i=1;i<p->n;++i){if(max<p->element[i].score)max=p->element[i].score;}return max;}int FinMin(Pseqlist p){int min=p->element[0].score;int i;for(i=1;i<p->n;++i){if(min>p->element[i].score)min=p->element[i].score;}return min;void print(Pseqlist p) /* 打印顺序表中的元素*/{int i;for(i=0;i<p->n;i++)printf("姓名:%s 分数:%d",p->element[i].name,p->element[i].score);}main(){Pseqlist p;int m,n,i,x,k;datatype aa;printf("input the size of seqlist m:"); /* 输入顺序表的最大空间m,建立空的顺序表*/scanf("%d",&m);p=creatnulllist_seq(m);printf("input the real number of seqlist n(n<m):"); /* 输入顺序表的实际长度n,初始化顺序表*/ scanf("%d",&n);p=init_seq(p,n);/* 输出插入之前顺序表的元素*/ print(p);printf("\n");printf("input i,x.score,:");scanf("%d%d%s",&i,&aa.score,); /* k的值用来表示是否插入成功*/ k=insertpost_seq(p,i,aa);if(k==1) print(p);/* 如果插入成功,输出插入之后顺序表的元素*/printf("\n%d %d",FinMax(p),FinMin(p));printf("分别是最大的和最小的数据");getch();}题目二代码:/* 线性表的单链表表示:类型和界面函数定义*/#include <stdio.h>/* 定义链接表元素类型。
c语言 数组倒序
c语言数组倒序摘要:1.引言2.数组倒序的概念3.数组倒序的实现方法3.1 利用指针3.2 利用交换法3.3 利用函数4.数组倒序的应用场景5.总结正文:C 语言是一种广泛应用于系统编程和嵌入式开发的编程语言。
在C 语言中,数组是经常被使用的一种数据结构。
数组倒序是C 语言中一个常见的问题,本文将详细介绍数组倒序的概念以及实现方法。
数组倒序是指将数组中的元素按照相反的顺序进行排列。
这种操作在处理一些特定问题时非常有用,例如洗牌、排序等。
要实现数组的倒序,有几种常见的方法。
首先,可以利用指针来实现。
这种方法通过交换指针所指向的值,来实现数组的倒序。
其基本思想是将数组的第一个元素与最后一个元素交换,第二个元素与倒数第二个元素交换,以此类推。
这样,数组的元素就实现了倒序。
其次,可以利用交换法来实现。
这种方法与利用指针的方法类似,也是通过交换数组中的元素来实现倒序。
不同之处在于,这种方法不需要使用指针,而是直接通过下标来访问数组的元素。
具体实现时,可以定义一个指向数组头部和尾部的指针,然后通过交换这两个指针所指向的值,来实现数组的倒序。
最后,还可以利用函数来实现。
这种方法将数组倒序的实现逻辑封装在一个函数中,调用这个函数即可实现数组的倒序。
这种方法的优点是代码的可读性和可维护性较高,但需要注意的是,函数的实现逻辑要正确。
数组倒序在许多实际应用场景中都有重要作用。
例如,在排序算法中,常常需要对数组进行倒序,以便于进行后续的排序操作。
此外,在洗牌算法中,也需要对数组进行倒序,以实现随机打乱数组元素的目的。
总之,C 语言中的数组倒序是一个十分有用的操作。
通过本文的介绍,读者应该已经掌握了数组倒序的概念以及实现方法。
数据结构c语言版耿国华课后习题答案
数据结构c语言版耿国华课后习题答案数据结构是计算机科学中非常重要的一门课程,它涉及到了计算机程序设计中的数据组织、存储和操作等方面。
而耿国华教授的《数据结构c语言版》是这门课程中的经典教材之一,它通过讲解各种数据结构的原理和实现方法,帮助学生更好地理解和掌握这门课程的知识。
本文将针对《数据结构c语言版》中的一些典型习题进行解答,帮助读者更好地理解和掌握这些知识点。
1. 线性表线性表是数据结构中最基本的一种数据结构,它包含了顺序表和链表两种实现方式。
在习题中,我们需要实现线性表的基本操作,如插入、删除、查找等。
通过编写代码,我们可以更好地理解这些操作的实现原理和思路。
2. 栈和队列栈和队列是线性表的特殊形式,它们分别具有“先进后出”和“先进先出”的特点。
在习题中,我们需要实现栈和队列的基本操作,如入栈、出栈、入队、出队等。
通过编写代码,我们可以更好地理解这些操作的实现方法和应用场景。
3. 树和二叉树树是一种非线性的数据结构,它具有层次关系。
二叉树是树的一种特殊形式,它每个节点最多只有两个子节点。
在习题中,我们需要实现树和二叉树的基本操作,如创建、插入、删除、遍历等。
通过编写代码,我们可以更好地理解这些操作的实现原理和应用场景。
4. 图图是一种非线性的数据结构,它由节点和边组成。
在习题中,我们需要实现图的基本操作,如创建、插入、删除、遍历等。
通过编写代码,我们可以更好地理解这些操作的实现方法和应用场景。
5. 查找和排序查找和排序是数据结构中非常重要的一部分,它们在实际应用中具有广泛的应用。
在习题中,我们需要实现各种查找和排序算法,如顺序查找、二分查找、冒泡排序、快速排序等。
通过编写代码,我们可以更好地理解这些算法的实现原理和性能特点。
通过以上习题的解答,我们可以更好地理解和掌握《数据结构c语言版》中的知识点。
同时,通过编写代码,我们可以锻炼自己的编程能力和解决问题的能力。
希望读者能够通过习题的解答,更好地理解和应用数据结构这门课程的知识。
数据结构线性表实验报告
数据结构线性表实验报告数据结构线性表实验报告实验目的:本次实验主要是为了学习和掌握线性表的基本操作和实现方式。
通过实验,我们可以加深对线性表的理解,并能够熟悉线性表的基本操作。
实验设备与环境:本次实验所需的设备包括计算机和编程环境。
我们选择使用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语言数组倒序 (1)
c语言数组倒序 (1)C语言数组倒序在C语言中,数组是一种用于存储相同类型数据元素的数据结构。
数组元素可以通过下标来访问,下标从0开始递增。
有时候,我们需要对数组进行倒序操作,即将数组中的元素顺序颠倒过来。
本文将介绍几种在C语言中实现数组倒序的方法。
方法一:使用临时变量交换元素位置这是一种比较常见的方法,通过使用一个临时变量,交换数组中的元素位置来实现倒序。
具体实现步骤如下:```c#include <stdio.h>void reverseArray(int arr[], int size) {int temp, start = 0, end = size - 1;while (start < end) {// 交换元素位置temp = arr[start];arr[start] = arr[end];arr[end] = temp;start++;end--;}}int main() {int arr[] = {1, 2, 3, 4, 5};int size = sizeof(arr) / sizeof(arr[0]); printf("原数组:");for (int i = 0; i < size; i++) {printf("%d ", arr[i]);}reverseArray(arr, size);printf("\n倒序数组:");for (int i = 0; i < size; i++) {printf("%d ", arr[i]);}return 0;}```方法二:利用指针交换元素位置除了使用临时变量交换元素位置外,我们还可以利用指针来交换数组元素。
利用指针交换元素位置的思路如下:```c#include <stdio.h>void reverseArray(int arr[], int size) {int *start = arr;int *end = arr + size - 1;while (start < end) {// 交换元素位置int temp = *start;*start = *end;*end = temp;start++;end--;}}int main() {int arr[] = {1, 2, 3, 4, 5};int size = sizeof(arr) / sizeof(arr[0]);printf("原数组:");for (int i = 0; i < size; i++) {printf("%d ", arr[i]);}reverseArray(arr, size);printf("\n倒序数组:");for (int i = 0; i < size; i++) {printf("%d ", arr[i]);}return 0;}```方法三:通过递归实现数组倒序除了使用循环,我们还可以使用递归的方式来实现数组倒序。
数据结构顺序表逆置
数据结构顺序表逆置顺序表是一种常见的数据结构,它由一组连续的存储单元组成,用于存储相同类型的数据。
顺序表的特点是元素之间的逻辑顺序与物理存储顺序一致,即元素按照其在内存中的物理位置依次存储。
然而,在某些场景下,我们需要将顺序表中的元素逆置,即改变它们的逻辑顺序。
本文将介绍如何实现顺序表的逆置操作。
我们需要明确逆置操作的定义。
逆置操作即将顺序表中的元素按照相对顺序进行颠倒,即原来在前面的元素变为后面的元素,原来在后面的元素变为前面的元素。
例如,对于顺序表[1, 2, 3, 4, 5],逆置后的结果为[5, 4, 3, 2, 1]。
接下来,我们需要考虑如何实现顺序表的逆置。
一种简单的方法是使用两个指针,分别指向顺序表的头部和尾部。
然后,交换这两个指针指向的元素,并向中间移动,继续交换直到两个指针相遇。
这样,就可以完成顺序表的逆置操作。
下面是使用C语言实现顺序表逆置的代码:```c#include <stdio.h>#define MAX_SIZE 100typedef struct {int data[MAX_SIZE];int length;} SqList;void Reverse(SqList *L) {int i, temp;for (i = 0; i < L->length / 2; i++) {temp = L->data[i];L->data[i] = L->data[L->length - i - 1]; L->data[L->length - i - 1] = temp;}}int main() {SqList L;int i;L.length = 5;L.data[0] = 1;L.data[1] = 2;L.data[2] = 3;L.data[3] = 4;L.data[4] = 5;printf("Before reverse: ");for (i = 0; i < L.length; i++) {printf("%d ", L.data[i]);}printf("\n");Reverse(&L);printf("After reverse: ");for (i = 0; i < L.length; i++) {printf("%d ", L.data[i]);}printf("\n");return 0;}```在上述代码中,我们首先定义了一个结构体SqList,用于表示顺序表。
数据结构(C语言版) 线性表 详细举例介绍
}
} // 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 也具有同样特性。
数据结构中的,线性表的c语言表示和插入,删除,查找操作程序
数据结构中的,线性表的c语言表示和插入,删除,查找操作程序#include#include#define MaxSize 100typedef struct {int data[MaxSize];int length;} SqList;void InitList(SqList *L) { // 传入的参数用指针L->length = 0;return;}int GetLength(SqList L) {return L.length;}int GetElem(SqList L, int i, int *e) {if (i < 1 || i > L.length){ /*无效的i值*/return 0;}else {*e = L.data[i - 1]; //改变指针的值前面用*return 1;}}int Locate(SqList L, int x) /*按值查找*/{int i = 0;while (L.data[i] != x){ /*查找值为x的第1个结点*/i++;}if (i > L.length){return (0); /*未找到*/}else{return (i+1);}}int InsElem(SqList *L, int x, int i) {int j;if (i < 1 || i > L->length +1){ /*无效的参数i*/return 0;}for (j = L->length; j >= i; j--) { /*将位置为i的结点及之后的结点后移*/ L->data[j] = L->data[j - 1];}L->data[i - 1] = x; /*在位置i处放入x*/L->length++; /*线性表长度增1*/return 1;}int DelElem(SqList *L, int i) {int j;if (i < 1 || i > L->length){ //删除时,i大于线性表的长度return 0;}for (j = i; j < L->length; j++){L->data[j - 1] = L->data[j];}L->length--;return 1;}void DispList(SqList L) {int i;for (i = 1; i <= L.length; i++){printf("%c", L.data[i - 1]);}printf("\n");}int main() {int i;int e;SqList L;InitList(&L); // 参数是指针时,实参应为地址int chr;memset(&L,0,sizeof(L));while ((chr = getchar())!= '\n'){InsElem(&L, chr, L.length+1); //连续插入元素} printf("线性表:");DispList(L);printf("长度:%d\n", GetLength(L));i = 3;GetElem(L, i, &e);printf("第%d个元素:%c\n", i, e);e = 'a';printf("元素%c是第%d个元素\n", e, Locate(L, e));i = 4;printf("删除第%d个元素\n", i);DelElem(&L, i);printf("线性表:");DispList(L);return 0; }。
数据结构——使用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)单链表中构成链表的结点只有一个指向直接后继结点的指针域 。其结构特点:逻辑上相邻的数据元素在物理上不一定相邻。
数据结构实验报告--
数据结构实验报告--实验一、线性表的实现线性表是常用的数据结构之一,其中最常用的是顺序存储结构。
本实验使用C语言实现了顺序存储结构的线性表。
首先,定义了一个结构体来表示线性表:```#define MAXSIZE 100 //线性表最大长度typedef struct {int data[MAXSIZE]; //存放线性表元素int length; //线性表当前长度} SqList; //线性表类型定义```其中,data数组存放线性表元素,length表示线性表当前长度。
接着,定义了三个基本操作:1. 初始化线性表```void InitList(SqList *L) {L->length = 0;}```2. 插入元素```bool ListInsert(SqList *L, int i, int e) {if (i < 1 || i > L->length + 1) { //插入位置不合法}if (L->length >= MAXSIZE) { //线性表已满return false;}for (int j = L->length; j >= i; j--) { //将第i个位置之后的所有元素后移一位L->data[j] = L->data[j - 1];}L->data[i - 1] = e; //将元素e插入到第i个位置L->length++; //线性表长度加1return true;}```3. 删除元素以上三个操作就是线性表的基本操作,通过这三个操作就能完成线性表的所有操作。
实验二、栈和队列的实现2.1 栈的实现栈是一种后进先出(Last In First Out)的数据结构。
我们可以用线性表来实现栈,只需要对线性表的插入和删除操作进行限制就行了。
具体实现如下:void InitStack(Stack *S) {S->top = -1; //初始化栈顶指针}bool Push(Stack *S, int e) {if (S->top == STACK_SIZE - 1) { //栈已满,无法插入元素}S->top++; //栈顶指针加1S->data[S->top] = e; //插入元素e到栈顶return true;}以上代码实现了栈的初始化、入栈和出栈操作。
数据结构实验 C语言版 线性表__C版
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
《数据结构》实验指导书(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。
《数据结构》的全部代码实现C语言
/* c1.h (程序名) */#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc()等*/#include<limits.h> /* INT_MAX等*/#include<stdio.h> /* EOF(=^Z或F6),NULL */#include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */#include<process.h> /* exit() *//* 函数结果状态代码*/#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行*/ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等*/ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE *//* algo2-1.c 实现算法2.1的程序*/#include"c1.h"typedef int ElemType;#include"c2-1.h"/*c2-1.h 线性表的动态分配顺序存储结构*/#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量*/#define LISTINCREMENT 2/* 线性表存储空间的分配增量*/typedef struct{ElemType*elem; /* 存储空间基址*/int length; /* 当前长度*/int listsize; /* 当前分配的存储容量(以sizeof(ElemType)为单位) */}SqList;#include"bo2-1.c"/* bo2-1.c 顺序表示的线性表(存储结构由c2-1.h定义)的基本操作(12个) */ Status InitList(SqList*L) /* 算法2.3 */{ /* 操作结果:构造一个空的顺序线性表*/(*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!(*L).elem)exit(OVERFLOW); /* 存储分配失败*/(*L).length=0; /* 空表长度为0 */(*L).listsize=LIST_INIT_SIZE; /* 初始存储容量*/return OK;}Status DestroyList(SqList*L){ /* 初始条件:顺序线性表L已存在。
【数据结构】线性表的基本操作
【数据结构】线性表的基本操作【数据结构】线性表的基本操作【一、概述】线性表是一种常见的数据结构,它是由一组具有相同特性的数据元素组成的有序序列。
线性表的基本操作包括插入、删除、查找和修改等操作,本文将对这些操作进行详细介绍。
【二、插入操作】插入操作是向线性表中某个位置插入一个新元素的操作。
插入操作包括头部插入、尾部插入和中间插入三种情况。
首先需要确定插入的位置,然后将插入位置后的元素依次向后移动一位,最后在插入位置处放入新元素。
1.头部插入:将新元素插入线性表的头部位置。
2.尾部插入:将新元素插入线性表的尾部位置。
3.中间插入:将新元素插入线性表的任意中间位置。
【三、删除操作】删除操作是从线性表中删除某个元素的操作。
删除操作包括删除头部元素、删除尾部元素和删除中间元素三种情况。
首先需要确定删除的位置,然后将删除位置后的元素依次向前移动一位,最后删除最后一个元素位置上的元素。
1.删除头部元素:删除线性表的头部元素。
2.删除尾部元素:删除线性表的尾部元素。
3.删除中间元素:删除线性表的任意中间位置的元素。
【四、查找操作】查找操作是在线性表中搜索某个元素的操作。
查找操作包括按值查找和按位置查找两种情况。
1.按值查找:根据给定的元素值,在线性表中搜索并返回该元素的位置。
2.按位置查找:根据给定的位置,返回该位置上的元素值。
【五、修改操作】修改操作是修改线性表中某个元素的值的操作。
需要先找到要修改的元素位置,然后将其值修改为新的值。
【附件】本文档涉及附件略。
【法律名词及注释】本文档所涉及的法律名词及注释略。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
while(p->next->num!=20)
p=p->next;
h=p->ext->next;
h->next=p->next->next;
p->next->next=h;
p->next->next->next=h->next;
//free(h);
//以下为链表的输出
p=L;
for(i=0;i<4;i++)
{while(p->next->next!=NULL)
p=p->next;
k=p->next;
k->next=p;
p->next=NULL;
p=L;
}
L->next=q;
//倒置后链表的输出
p=L->next;
printf("倒置后输出\n");
while(p!=NULL)
课题一的具体实验内容
1、构造元素类型为整型的线性表,将以下元素插入分别插入线性表:
<34 56 20 9 15 5>
2、查找表中是否存在元素20,实现元素20与元素9的交换;
3、按照课题要求编写函数,实现线性表元素<34 56 9 20 15 5>的倒置,即倒置后的表应为< 5 15 20 9 56 34 >。
//L->num=NULL;
p=L;
printf("请输入\n");
for(i=0;i<6;i++)
{
s=(node*)malloc(sizeof(struct node));
scanf("%d",&s->num);
p->next=s;
p=s;
}
p->next=NULL;
//以上为链表的建立和输入
//以下为元素的交换
{
printf("%d ",p->num);
p=p->next;
}
}
#include<stdio.h>
#include<stdlib.h>
#define NULL 0
struct node
{ int num;
struct node *next;
};
void main()
{ int i;
struct node *L,*s,*p,*h,*q,*k;
L=(node*)malloc(sizeof(struct node));
p=L->next;
printf("交换后输出\n");
while(p!=NULL)
{
printf("%d\n",p->num);
p=p->next;
}
//以下为链表的倒置
p=L;
while(p->next->next!=NULL)
p=p->next;
q=p->next;
q->next=p;
p->next=NULL;