数据结构线性表的主要程序代码

合集下载

南邮数据结构上机实验一线性表的基本运算和多项式的基本运算资料

南邮数据结构上机实验一线性表的基本运算和多项式的基本运算资料

实验报告(2015 / 2016学年第二学期)课程名称数据结构A实验名称线性表的基本运算和多项式的基本运算实验时间2016 年 3 月10 日指导单位计算机科学与技术系指导教师骆健学生姓名班级学号学院(系) 管理学院专业信息管理与信息系统实习题名:线性表的基本运算班级姓名学号日期2016.03.10一、问题描述深入理解线性表数据结构,熟练掌握顺序表的各种基本操作。

在顺序表类SeqList 中增加成员函数void Reverse(),实现顺序表的逆置;在顺序表类SeqList中增加成员函数bool DeleteX(const T &x),删除表中所有元素值等于x元素。

若表中存在这样的元素,则删除之,且函数返回true,否则函数返回false。

二、概要设计文件Inverse.cpp中定义了Linearlist类, SeqList类继承Linearlist类。

在顺序表类SeqList中通过函数void Reverse()实现顺序表的逆置,通过函数boolDeleteX(const T &x),删除表中所有元素值等于x元素。

三、详细设计1.类和类的层次设计程序使用了两个类, 线性表Linearlist类和顺序表SeqList类和一个主函数mian。

Linearlist类里包括常见的线性表运算,在类SeqList里面新增成员函数void Reverse()和bool DeleteX(const T &x)。

TLinearlist#int n+virtual bool IsEmpty() const = 0;+virtual int Length() const = 0;+virtual bool Find(int i,T& x) const = 0;+virtual int Search(T x) const = 0;+virtual bool Insert(int i,T x) = 0;+virtual bool Delete(int i) = 0;+virtual bool Update(int i,T x) = 0;+virtual void Output(ostream& out) const = 0;TSeqList-int maxLength;-T *elements;+IsEmpty() const;+Length() const;+Find(int i,T& x) const;+Search(T x) const;+Insert(int i,T x);+Delete(int i);+Update(int i,T x);+Output(ostream& out) const;+Reverse();+DeleteX(const T& x);2.核心算法顺序表SeqList类中,私有段封装了两个私有数据成员maxLength和elements,公有段封装了构造、析构、查找、删除、逆置等函数。

数据结构实验报告-线性表(顺序表实现)

数据结构实验报告-线性表(顺序表实现)

实验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.归并顺序表(销毁或清空操作前)七、思考讨论题或体会或对改进实验的建议通过本次实验,我掌握了定义线性表的顺序存储类型,加深了对顺序存储结构的理解,进一步巩固和理解了顺序表的基本操作,如建立、查找、插入和删除等。

哈工大 数据结构 实验一 线性表的实验

哈工大 数据结构 实验一 线性表的实验
n.push(w*y);
}
else if(input[i]=='/'){
y=n.pop();w=n.pop();
n.push(w/y);
}
}
cout<<n.pop()<<endl;
}
int main(){
int i,j;
double a[64];
char input[512],o;
stack<char> s;
printf("do you want to try again?(Y/N) ");
o=getchar();
if(o=='n'||o=='N') break;
getchar();printf("\n");
}
printf("thanks for using it...\n");
}
stack<double> n;
while(true){
i=0;j=0;s.null();n.null();
printf("please input the expression: ");
change(i,j,a,input,s);
printf("the answer is: ");
compute(i,j,a,input,n);
哈尔滨工业大学计算机科学与技术学院
实验报告
课程名称:数据结构与算法
课程类型:必修
实验项目名称:线性表实验
实验题目:算术表达式求值
班级:0903201
学号:1090320110
姓名:王岳

(完整版)数据结构线性表的主要程序代码

(完整版)数据结构线性表的主要程序代码

数据结构顺序表的主要代码(LIZHULIN)1./***有头结点的单链表的初始化、建立(表头插入、表尾插入)、求长度、插入、删除、输出***//***********单链表的初始化、建立、输出*****************/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/****************单链表的初始化*************************/Initlist(LinkList *L){ /*动态申请存储空间*/L = (LinkList *)malloc(sizeof(struct Lnode));/*建立头结点*/L->next = NULL;}/*************建立一个带头结点的单链表,在表尾插入***************/Create_L(LinkList *L,int n){LinkList *p,*q; int i;Initlist(L); /*单链表初始化*/q=L;printf("input the value\n");for(i = n;i>0;--i){p = (LinkList*)malloc(sizeof(struct Lnode));scanf("%d",&p->data); /*输入元素值*/q->next = p;p->next = NULL;q=p;/*插入到表尾*/}} /* Create_L *//*************建立一个带头结点的单链表,在表头插入**************Create_L(LinkList *L,int n){LinkList *p; int i;Initlist(L); /*单链表初始化/*需要注意第一个数据插入时的情况/*Insert the Firset nodep = (LinkList*)malloc(sizeof(struct Lnode));printf("input the value\n");scanf("%d",&p->data); /*输入元素值L->next = p;p->next = NULL;/*将第二个及后面的数据插入for(i = n-1;i>0;--i){p = (LinkList*)malloc(sizeof(struct Lnode));printf("input a value\n");scanf("%d",&p->data); /*输入元素值p->next = L->next;L->next = p;/*插入到表头}} /* Create_L *//*************************求单链表的长度***********************/int Length_LinkList(LinkList *L){LinkList *p;int i=0;p=L->next;while(p!=NULL){i++;p=p->next;}return i;}/*Length_LinkList*//*************************在第i个结点前插入数据x *********************/ Insert_LinkList(LinkList *L, int i, int x){LinkList *p,*s;int j=0;p=L;/*寻找第i个结点*/while(j<i-1 && p!=NULL){++j;p=p->next;}if (!p) return 0;/*如果表长小于i,则无意义*//*插入元素x */s=(LinkList *)malloc(sizeof(struct Lnode));s->data=x;s->next=p->next;p->next=s;}/*********************删除第i个元素,并用y将其值返回************************/ int Delete_LinkList(LinkList *L, int i){LinkList *p,*q;int y;int j=0;p=L;/*寻找第i个结点*/while(j<i-1 && p!=NULL){++j;p=p->next;}if (!p) return 0;/*如果表长小于i,则无意义*/q=p->next;y=q->data;p->next=q->next;free(q) ;return y;} /*Delete_LinkList*//*******************单链表值的输出****************/void display(LinkList *L) /*字母链表的输出*/{LinkList *p;p=L->next;while (p!=NULL){printf("%d ",p->data);p=p->next;}}/*************主程序**********************/ main(){LinkList *L;int len;int n=0;int x=15;int y;int i=4;L = (LinkList*)malloc(sizeof(struct Lnode));/*L->data = 0;*/L->next =NULL;printf("input the length of L ,n\n");scanf("%d",&n);printf("\n");Create_L(L,n);Insert_LinkList(L, i, x);/* y=Delete_LinkList(L,i);printf("the delete elment is y=%d\n",y);len=Length_LinkList(L);printf("the length of L is %d",len);*/display(L);getch();}2./***无头结点的单链表建立、插入、求长度、插入、删除、输出*****/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/*************Create ***************/Link_Creat(LinkList *L,int n){LinkList *q,*p;int i;printf("input the data\n");scanf("%d",&L->data);p=L;for(i=2; i<=n;i++){q=(LinkList *)malloc(sizeof(struct Lnode));scanf("%d",&q->data);p->next=q;q->next=NULL;p=q;}}/**************OutPut*********************/Link_Display(LinkList *L){LinkList *p;p=L;while(p!=NULL){printf("%d ",p->data);p=p->next;}}/***************Main()**************************/main(){LinkList *L;int n;L=(LinkList *)malloc(sizeof(struct Lnode));L->data=0;L->next=NULL;printf("Please input the length of LinkList, n\n");scanf("%d",&n);Link_Creat(L,n);Link_Display(L);getch();}3./*********顺序表的建立、查找、插入运算********/#include <stdio.h>#include <stdlib.h>typedef int datatype;#define list_maxsize 20/********* define for node struct ************/typedef struct{datatype data[list_maxsize];int length;}SqList;/********** InitList ************/void InitList(SqList *L){L->length = 0;}/*******Creat SqList********/void Create_SqList(SqList *L){int i=0;InitList(L);printf("input SqList.data\n");scanf("%d",&L->data[0]);while(L->data[i]!=-1){++i;scanf("%d",&(L->data[i]));}L->length = i;}/********* the length of SqList****************/int ListLength(SqList *L){return L->length;}/************ GetElem L->data[i]************/int GetElem(SqList *L, int i){if(i<1 || i>L->length){ printf("Position Error");return;}elsereturn L->data[i-1];}/**************** Output the SqList**************/ void Display_SqList(SqList *L){int i,n;n=ListLength(L);printf("the length is %d ",n);for(i=0;i<n;i++)printf("%d ", L->data[i]);}/****************Main()**************************/ main(){SqList *L;/*printf("input the length of SqList\n");scanf("%d",&len);*/Create_SqList(L);Display_SqList(L);getch();}4./*********顺序表的归并运算********/#include <stdio.h>#include <stdlib.h>typedef int datatype;#define list_maxsize 20/********* define for node struct ************/typedef struct{datatype data[list_maxsize];int length;}SqList;/********** InitList ************/void InitList(SqList *L){L->length = 0;}/************ Creat SqList*************/void Create_SqList(SqList *L){int i=0;InitList(L);printf("input the data of SqList\n");scanf("%d",&L->data[0]);while(L->data[i]!=-1){++i;scanf("%d",&(L->data[i]));}L->length = i;}/********* the length of SqList****************/int ListLength(SqList *L){return L->length;}/************ GetElem L->data[i]************/int GetElem(SqList *L, int i){if(i<1 || i>L->length){ printf("Getelem Position Error");return;}return L->data[i-1];}/************ Insert Operation *********/void ListInsert(SqList *L,int i, int x){SqList *q, *p;if(i<1 || i>L->length){printf("the insert position error");return ;}q = &(L->data[i-1]); /*q为插入位置*/for(p=&(L->data[L->length-1]); p>=q; --p)*(p+1) = *p;L->data[i-1] = x;++L->length;}/********* LA and LB Merged LC ***************/ void MergeList(SqList *LA,SqList *LB,SqList *LC) {int La_len,Lb_len,ai,bj;int i,j;int k;i=j=1;InitList(LC);La_len = ListLength(LA);Lb_len = ListLength(LB);LC->length = La_len+Lb_len;/*for(k=0;k<LC->length;k++)LC->data[k] = 0; */k=0;while((i<=La_len)&&(j<=Lb_len)){ai= GetElem(LA, i);bj= GetElem(LB, j);if(ai<bj){++k;ListInsert(LC,k,ai);++i;}elseif(ai==bj){++k;ListInsert(LC,k,ai);++k;ListInsert(LC,k,bj);++i;++j;}else{++k;ListInsert(LC,k,bj);++j;}}while(i<=La_len){/*Append the residual node into LA */ai= GetElem(LA, i);++i;++k;ListInsert(LC,k,ai);}while(j<=Lb_len){/*Append the residual node into LA */bj= GetElem(LB, j);++j;++k;ListInsert(LC,k,bj);}LC->length = La_len+Lb_len;}/**************** Output the SqList**************/ void Display_SqList(SqList *L){int i,n;n=ListLength(L);printf("the length is %d ",n);for(i=0;i<n;i++)printf("%d ", L->data[i]);}/****************Main()**************************/ main(){SqList *LA , *LB, *LC;Create_SqList(LA);Create_SqList(LB);MergeList(LA,LB,LC);Display_SqList(LC);getch();}5./**** 用带头结点的循环单链表解决约瑟夫问题***********/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/****************单链表的初始化*************************/Initlist(LinkList *L){ /*动态申请存储空间*/L = (LinkList *)malloc(sizeof(struct Lnode));/*建立头结点*/L->next = L;}/*************建立一个带头结点的循环单链表,数据值为1,2,3,...n,在表尾插入***************/Create_L(LinkList *L,int n){LinkList *p; int i;Initlist(L); /*单链表初始化p=L;for(i = n;i>0;--i){q = (LinkList*)malloc(sizeof(struct Lnode));q->data = i; /*输入元素值p->next =qq->next = L;/*插入到表尾}} /* Create_L *//*******************单链表值的输出****************/void display(LinkList *L) /*字母链表的输出*/{LinkList *p;p=L->next;while (p->next!=L){printf("%d ",p->data);p=p->next;}}/*************主程序**********************/ main(){LinkList *L;int n;L = (LinkList*)malloc(sizeof(struct Lnode));/*L->data = 0;*/L->next =L;printf("input the length of L ,n\n");scanf("%d",&n);printf("\n");Create_L(L,n);display(L);getch();}6./******** 无头结点的循环单链表的建立**************/#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ /*定义线性表的单链表存储结构*/int data;struct Lnode *next;}LinkList;/*************Create ***************/Link_Creat(LinkList *L,int n){LinkList *q,*p;int i;printf("input the data\n");scanf("%d",&L->data);p=L;for(i=2; i<=n;i++){q=(LinkList *)malloc(sizeof(struct Lnode));scanf("%d",&q->data);p->next=q;q->next=NULL;p=q;}p->next = L;/*尾结点指向第一个结点*/}/**************OutPut*********************/Link_Display(LinkList *L){LinkList *p;p=L;printf("%d ",p->data);p=p->next;while(p->next !=L){printf("%d ",p->data);p=p->next;}}/***************Main()**************************/ main(){LinkList *L;int n;L=(LinkList *)malloc(sizeof(struct Lnode));L->data=0;L->next=NULL;printf("Please input the length of LinkList, n\n");scanf("%d",&n);Link_Creat(L,n);Link_Display(L);getch();}。

《数据结构与算法(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无定 义。

数据结构与算法实验源代码

数据结构与算法实验源代码

数据结构与算法实验源代码数据结构与算法实验源代码1.实验目的本实验旨在通过实践,加深对数据结构与算法的理解与应用能力,掌握数据结构和算法的基本概念与原理,并能够运用所学知识解决实际问题。

2.实验材料●一台已安装好编译器的计算机●数据结构与算法实验源代码文件3.实验环境配置在实验开始之前,必须确保计算机上已安装好以下环境:●编译器(可以是C++、Java等)●数据结构与算法实验源代码文件4.实验内容及步骤4.1 实验一:线性表4.1.1 实验目的通过实现线性表的相关操作,加深对线性表及其操作的理解,并能够灵活应用。

4.1.2 实验步骤1.实现线性表的初始化函数2.实现线性表的插入操作3.实现线性表的删除操作4.实现线性表的查找操作5.实现线性表的排序操作6.实现线性表的输出操作7.编写测试代码,对线性表进行测试4.1.3 实验结果与分析进行若干测试用例,验证线性表的正确性,并分析算法的时间复杂度与空间复杂度。

4.2 实验二:栈与队列4.2.1 实验目的通过实现栈与队列的相关操作,加深对栈与队列的理解,并掌握栈与队列的应用场景。

4.2.2 实验步骤1.实现栈的初始化函数2.实现栈的入栈操作3.实现栈的出栈操作4.实现栈的查看栈顶元素操作5.实现队列的初始化函数6.实现队列的入队操作7.实现队列的出队操作8.实现队列的查看队首元素操作4.2.3 实验结果与分析进行若干测试用例,验证栈与队列的正确性,并分析算法的时间复杂度与空间复杂度。

(继续添加实验内容及步骤,具体根据实验项目和教学要求进行详细分析)5.实验附件本文档所涉及的实验源代码文件作为附件随文档提供。

6.法律名词及注释6.1 版权:著作权法所规定的权利,保护作品的完整性和原创性。

6.2 开源:指软件可以被任何人免费使用、分发和修改的一种软件授权模式。

(继续添加法律名词及注释)。

数据结构(一)——线性表、栈和队列

数据结构(一)——线性表、栈和队列

数据结构(⼀)——线性表、栈和队列数据结构是编程的起点,理解数据结构可以从三⽅⾯⼊⼿:1. 逻辑结构。

逻辑结构是指数据元素之间的逻辑关系,可分为线性结构和⾮线性结构,线性表是典型的线性结构,⾮线性结构包括集合、树和图。

2. 存储结构。

存储结构是指数据在计算机中的物理表⽰,可分为顺序存储、链式存储、索引存储和散列存储。

数组是典型的顺序存储结构;链表采⽤链式存储;索引存储的优点是检索速度快,但需要增加附加的索引表,会占⽤较多的存储空间;散列存储使得检索、增加和删除结点的操作都很快,缺点是解决散列冲突会增加时间和空间开销。

3. 数据运算。

施加在数据上的运算包括运算的定义和实现。

运算的定义是针对逻辑结构的,指出运算的功能;运算的实现是针对存储结构的,指出运算的具体操作步骤。

因此,本章将以逻辑结构(线性表、树、散列、优先队列和图)为纵轴,以存储结构和运算为横轴,分析常见数据结构的定义和实现。

在Java中谈到数据结构时,⾸先想到的便是下⾯这张Java集合框架图:从图中可以看出,Java集合类⼤致可分为List、Set、Queue和Map四种体系,其中:List代表有序、重复的集合;Set代表⽆序、不可重复的集合;Queue代表⼀种队列集合实现;Map代表具有映射关系的集合。

在实现上,List、Set和Queue均继承⾃Collection,因此,Java集合框架主要由Collection和Map两个根接⼝及其⼦接⼝、实现类组成。

本⽂将重点探讨线性表的定义和实现,⾸先梳理Collection接⼝及其⼦接⼝的关系,其次从存储结构(顺序表和链表)维度分析线性表的实现,最后通过线性表结构导出栈、队列的模型与实现原理。

主要内容如下:1. Iterator、Collection及List接⼝2. ArrayList / LinkedList实现原理3. Stack / Queue模型与实现⼀、Iterator、Collection及List接⼝Collection接⼝是List、Set和Queue的根接⼝,抽象了集合类所能提供的公共⽅法,包含size()、isEmpty()、add(E e)、remove(Object o)、contains(Object o)等,iterator()返回集合类迭代器。

常用数据结构代码示例

常用数据结构代码示例

常⽤数据结构代码⽰例⼀、线性表 1、线性表顺序存储1 #include "stdio.h"23 #include "stdlib.h"4 #include "io.h"5 #include "math.h"6 #include "time.h"78#define OK 19#define ERROR 010#define TRUE 111#define FALSE 01213#define MAXSIZE 20 /* 存储空间初始分配量 */1415 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码,如OK等 */16 typedef int ElemType; /* ElemType类型根据实际情况⽽定,这⾥假设为int */171819 Status visit(ElemType c)20 {21 printf("%d ",c);22return OK;23 }2425 typedef struct26 {27 ElemType data[MAXSIZE]; /* 数组,存储数据元素 */28int length; /* 线性表当前长度 */29 }SqList;3031/* 初始化顺序线性表 */32 Status InitList(SqList *L)33 {34 L->length=0;35return OK;36 }3738/* 初始条件:顺序线性表L已存在。

操作结果:若L为空表,则返回TRUE,否则返回FALSE */39 Status ListEmpty(SqList L)40 {41if(L.length==0)42return TRUE;43else44return FALSE;45 }4647/* 初始条件:顺序线性表L已存在。

考研数据结构代码

考研数据结构代码

考研数据结构代码考研数据结构代码一、简介1·1 数据结构概述1·2 考研数据结构重要性1·3 考研数据结构的基本知识点二、线性表2·1 定义与特点2·2 顺序表2·2·1 顺序表的基本操作2·2·2 顺序表的存储结构2·3 链表2·3·1 单链表2·3·2 双链表2·3·3 循环链表三、栈与队列3·1 栈的定义与基本操作3·2 栈的应用举例3·3 队列的定义与基本操作 3·4 队列的应用举例四、树与二叉树4·1 树的基本概念4·2 树的存储结构4·2·1 双亲表示法4·2·2 孩子表示法4·2·3 孩子兄弟表示法 4·3 二叉树的定义与基本性质 4·4 二叉树的遍历4·4·1 先序遍历4·4·2 中序遍历4·4·3 后序遍历4·5 线索二叉树五、图5·1 图的基本概念5·2 图的存储结构5·2·1 邻接矩阵5·2·2 邻接表5·3 图的遍历算法5·3·1 深度优先搜索 5·3·2 广度优先搜索 5·4 最小树5·4·1 Prim算法5·4·2 Kruskal算法 5·5 最短路径5·5·1 Dijkstra算法 5·5·2 Floyd算法六、排序6·1 内部排序与外部排序 6·2 插入排序6·2·1 直接插入排序6·2·2 希尔排序6·3 交换排序6·3·1 冒泡排序6·3·2 快速排序6·4 选择排序6·4·1 简单选择排序 6·4·2 堆排序6·5 归并排序6·6 基数排序七、查找7·1 顺序查找7·2 折半查找7·3 哈希表查找八、附件8·1 相关代码实例8·2 数据结构参考书籍九、法律名词及注释9·1 著作权法:保护文学、艺术作品的权益。

数据结构源代码(清华大学+严蔚敏)

数据结构源代码(清华大学+严蔚敏)

void Union(List &La, List Lb) { // 算法2.1// 将所有在线性表Lb中但不在La中的数据元素插入到La中int La_len,Lb_len,i;ElemType e;La_len = ListLength(La); // 求线性表的长度Lb_len = ListLength(Lb);for (i=1; i<=Lb_len; i++) {GetElem(Lb, i, e); // 取Lb中第i个数据元素赋给e if (!LocateElem(La, e, equal)) // La中不存在和e相同的数据元素ListInsert(La, ++La_len, e); // 插入}} // unionvoid MergeList(List La, List Lb, List &Lc) { // 算法2.2// 已知线性表La和Lb中的元素按值非递减排列。

// 归并La和Lb得到新的线性表Lc,Lc的元素也按值非递减排列。

int La_len, Lb_len;ElemType ai, bj;int i=1, j=1, k=0;InitList(Lc);La_len = ListLength(La);Lb_len = ListLength(Lb);while ((i <= La_len) && (j <= Lb_len)) { // La和Lb均非空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);}} // MergeListStatus InitList_Sq(SqList &L) { // 算法2.3// 构造一个空的线性表L。

数据结构线性表

数据结构线性表

数据结构---线性表线性表代码主要参考严蔚敏《数据结构(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个元素向后移动一位】。

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

数据结构实验,线性表的插入和删除,单链表操作,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);

【数据结构】线性表顺序表详解和代码实例

【数据结构】线性表顺序表详解和代码实例

【数据结构】线性表顺序表详解和代码实例线性表(List)是零个或者多个数据元素的有限序列.⾸先它是⼀个序列.⾥⾯的元素是有顺序的,如果有多个元素,除开头和结尾以外的元素都有⼀个前驱和⼀个后继.⽽开头元素只有后继,结尾元素只有前驱.其次线性表是有限的,也就是⾥⾯的元素个数是有限的。

1ADT 线性表(List)2Data3线性表的数据对象集合为{a1, a2, a3, ......, an},每个元素类型为DataType。

4Operation5InitList(L); //初始化线性表6 IsEmptyList(L); //判断线性表是否为空7 ClearList(L); //清空线性表8 GetElemList(L, i, *e); //获取第i个位置的数据9 SearchList(L, e); //查找与数据e相等的元素10 InsertNodeList(L, i, e);//在第i个位置插⼊元素11 DeleteNodeList(L, i, *e);//删除第i个位置的元素,e获取删除元素12 GetLengthList(L); //获取线性表的长度13endADT关于线性表的基本操作就上⾯⼏种,还有⼏个例如线性表的排序,合并,逆序等等操作。

为了⽂章篇幅,就下次再介绍了。

线性表的顺序存储结构,就是指 ⽤⼀段地址连续的存储单元⼀次存储线性表的数据元素。

学过⾼级语⾔的朋友,相信对数组这玩意⼉都不会陌⽣吧。

数组就是⼀种顺序存储结构。

链式存储结构就是可以⽤⼀组任意的内存单元存储线性表中的元素。

与顺序存储不同的是,这组内存单元可以是连续的,也可以是不连续的。

这就意味着,元素可以存储在内存的任意位置。

正因为如此,在链式结构中,每个元素不仅要存它的信息,还需要存储它后继元素的存储地址。

我们把存储元素信息的域称为数据域,⽽把存储后继元素地址的域称为指针域。

由这两部分共同组成的数据元素ai,则可以称之为节点(Node)。

考研数据结构代码简版

考研数据结构代码简版

考研数据结构代码考研数据结构代码1. Introduction数据结构是计算机科学中的重要概念,它关注如何组织和存储数据以便有效地使用。

在计算机科学的学习和应用中,数据结构常常被用于解决各种复杂的问题。

考研数据结构代码是为了帮助考生更好地理解和掌握数据结构概念而编写的一部分代码。

本文档将介绍考研数据结构代码的相关内容。

2. 考研数据结构代码的主要内容考研数据结构代码主要包含以下几个方面的内容:2.1 基本数据结构基本数据结构是数据结构中最常见和基础的部分,它包括:- 数组(Array):顺序存储结构,可以存储相同类型的数据元素。

- 链表(Linked List):动态存储结构,由一系列节点组成,节点之间通过指针连接。

- 栈(Stack):一种特殊的线性表,只能在表的一端进行插入和删除操作。

- 队列(Queue):一种特殊的线性表,只能在表的一端进行插入操作,在另一端进行删除操作。

- 树(Tree):由节点和边组成的集合,节点之间存在着层次关系。

- 图(Graph):由顶点和边组成的集合,顶点之间可以存在着多种关系。

2.2 常见数据结构算法除了基本数据结构外,考研数据结构代码还包含一些常见的数据结构算法,如:- 排序算法:包括冒泡排序、插入排序、选择排序、快速排序等。

- 查找算法:包括线性查找、二分查找等。

- 图算法:包括深度优先搜索(DFS)、广度优先搜索(BFS)等。

- 树算法:包括二叉树的遍历、平衡二叉树等。

2.3 相关数据结构应用考研数据结构代码还将涉及一些与数据结构相关的实际应用,如:- 图的最短路径算法在地图导航系统中的应用。

- 树的遍历算法在文件系统中的应用。

- 栈和队列在计算机程序调用栈中的应用。

3. 如何使用考研数据结构代码考研数据结构代码可以作为学习和练习数据结构的参考和工具。

考生可以通过以下几个步骤来使用考研数据结构代码:1. 了解基本数据结构的特点和操作。

2. 阅读考研数据结构代码的实现,理解其中的算法和数据结构设计。

数据结构--线性表的基本运算及多项式的算术运算

数据结构--线性表的基本运算及多项式的算术运算

数据结构:线性表的基本运算及多项式的算术运算一、实验目的和要求实现顺序表和单链表的基本运算,多项式的加法和乘法算术运算。

要求:能够正确演示线性表的查找、插入、删除运算。

实现多项式的加法和乘法运算操作。

二、实验环境(实验设备)X64架构计算机一台,Windows 7操作系统,IDE: Dev C++ 5.11编译器: gcc 4.9.2 64bit二、实验原理及内容程序一:实现顺序表和单链表的实现本程序包含了四个文件,分别是LinearListMain.cpp,linearlist.h,seqlist.h,singlelist.h。

分别是主程序,线性表抽象类,顺序储存线性表的实现,链表储存顺序表的实现。

文件之间的关系图:本程序一共包含了三个类:分别是LinearList(线性表抽象类),SeqList(顺序储存的线性表),SingleList(链表储存的线性表)。

类与类之间的关系图如下:其实,抽象类LinearList规定了公共接口。

分别派生了SeqList类和SingleList。

SingleList类与SingleList类分别实现了LinearList类中的所有接口。

程序代码以及分析:Linearlist类:#include <iostream>using namespace std;template <class T>class LinearList{protected:int n; //线性表的长度public:virtual bool IsEmpty() const=0; //判读是否是空线性表virtual int Length() const=0; //返回长度virtual bool Find(int i,T& x) const=0; //将下标为i的元素储存在x中,成功返回true,否则返回falsevirtual int Search(T x) const=0; //寻找值是x的元素,找到返回true,否则返回falsevirtual bool Insert(int i,T x)=0; //在下标为i的元素后面插入xvirtual bool Delete(int i)=0; //删除下标为i的元素virtual bool Update(int i,T x)=0;//将下标为i的元素更新为x virtual void Output(ostream& out)const=0; //将线性表送至输出流};包含了一个保护数据成员n,和8种运算,具体说明见注释。

数据结构实验与实训教程第4版程序代码

数据结构实验与实训教程第4版程序代码

目录第一部分预备知识 (1)预备知识 (1)预备知识实验 (2)第二部分基础实验 (4)实验1 线性表的基本操作 (4)实验2 链表的基本操作 (9)实验3 栈的基本操作 (15)实验4 队列的基本操作 (22)实验5 数组的基本操作 (32)实验6 字符串的基本操作 (36)实验7 二叉树的基本操作 (41)实验8 树的遍历和哈夫曼树 (46)实验9 图的基本操作 (53)实验10 排序 (59)实验11 查找 (64)第三部分课程设计实验 (69)实验1 航空客运订票系统 (69)实验2 汉诺塔游戏程序 (75)实验3 全屏幕编辑程序设计 (79)实验4 旅游路线安排模拟系统 (90)实验6 最小生成树kruskal算法 (93)第一部分预备知识预备知识例1.1#include <stdio.h>int sumabc(int a, int b, int c) /* 求三个整数之和*/{ int s;a=b+c;s=a+b+c;return s;}void displayLine(void){ printf(”----------------------\n“);}void main( ){ int x,y, z ,sabc;x=y=z=8;display(); /* 画一条线*/printf(“\n sum=%d”,sumabc(x,y,z)); /* 在输出语句中直接调用函数sumabc( ) */ printf(“\n %6d%6d%6d”,x,y,z);display();/* 画一条线*/x=2; y=4; z=6;sabc =sumabc(x, y, z); /* 在赋值语句中调用函数sumabc( ) */printf(“\n “ sum=%d”, sabc);printf(“\n %6d%6d%6d”,x,y,z);display();/* 画一条线*/}例1.2int sumabc(int *a, int b, int c){int s;*a=b+c;s=*a+b+c;return s;}预备知识实验int main(){ //在main函数中调用上述声明的函数int n; //记录个数STUDENT stu[MAXSIZE;// 顺序存储结构,方法一静态一维数组。

数据结构实验源代码

数据结构实验源代码

数据结构实验源代码【附】数据结构实验源代码范本一、实验背景与目的1.1 实验背景在计算机科学中,数据结构是指数据元素之间的关系,以及为操作这些数据元素所提供的方法。

数据结构对于程序的设计和性能优化具有重要影响。

1.2 实验目的本实验旨在通过编写和实现不同的数据结构,加深学生对数据结构的理解,掌握基本的数据结构操作方法。

二、实验内容2.1 线性表2.1.1 顺序表2.1.1.1 初始化顺序表2.1.1.2 插入元素到顺序表2.1.1.3 删除顺序表中的元素2.1.1.4 遍历顺序表2.1.1.5 查找指定元素在顺序表中的位置2.1.2 链表2.1.2.1 初始化链表2.1.2.2 插入元素到链表2.1.2.3 删除链表中的元素2.1.2.4 遍历链表2.1.2.5 查找指定元素在链表中的位置2.2 栈2.2.1 初始化栈2.2.2 进栈操作2.2.3 出栈操作2.2.4 获取栈顶元素2.2.5 判断栈是否为空2.3 队列2.3.1 初始化队列2.3.2 入队操作2.3.3 出队操作2.3.4 获取队首元素2.3.5 判断队列是否为空三、实验步骤3.1 线性表实现在实现顺序表和链表时,首先需要定义数据结构和所需的操作函数。

然后进行初始化、添加元素、删除元素等操作。

最后进行遍历和查找操作,并检验实验结果是否符合预期。

3.2 栈实现栈的实现过程与线性表类似,需要定义栈的数据结构和所需的函数,然后进行初始化、进栈、出栈等操作。

3.3 队列实现队列的实现也与线性表类似,需要定义队列的数据结构和函数,进行初始化、入队、出队等操作。

四、数据结构实验源代码以下是实验代码的源代码范本,包括线性表、栈和队列的实现。

(代码略,如需获取,请查看附件)五、附件本文档附带的附件为数据结构实验源代码。

六、法律名词及注释6.1 数据结构:计算机科学中,数据结构是指数据元素之间的关系,以及为操作这些数据元素所提供的方法。

6.2 顺序表:一种物理上相邻的存储结构,元素按照顺序依次存放。

数据结构(第二章 线性表)

数据结构(第二章 线性表)

2.2 线性表的顺序存储和实现
顺序表-顺序表定义

由上可知,数据的存储逻辑位置由数组的下标决定。 所以相邻的元素之间地址的计算公式为(假设每个数 据元素占有d个存储单元): LOC(ai)=LOC(ai-1)+d 对线性表的所有数据元素,假设已知第一个数据元 素a0的地址为LOC(a0) ,每个结点占有d个存储 单元, 则第i个数据元素ai的地址为: LOC(ai)=LOC(a0)+i*d 线性表的第一个数据元素的位置通常称做起始位置 或基地址。 在使用一维数组时,数组的下标起始位置根据给定 的问题确定,或者根据实际的高级语言的规定确定。
2.1 线性表抽象数据类型
线性表的分类
顺序存储结构 (元素连续存储、 随机存取结构) 线性表 ADT 链式存储结构 (元素分散存储) 继承 顺序表类 排序顺序表类 继承 单链表类 循环单链表 双链表 继承 排序循环双链表类 排序单链表类

单链表
双链表

循环双链表类
线性表的存储结构
2.2 线性表的顺序存储和实现
线性表的基本操作 求长度:求线性表的数据元素个数。 访问:对线性表中指定位置的数据元素进行存取、替 换等操作。 插入:在线性表指定位置上,插入一个新的数据元素, 插入后仍为一个线性表。 删除:删除线性表指定位置的数据元素,同时保证更 改后的线性表仍然具有线性表的连续性。 复制:重新复制一个线性表。 合并:将两个或两个以上的线性表合并起来,形成一 个新的线性表。 查找:在线性表中查找满足某种条件的数据元素。 排序:对线性表中的数据元素按关键字值,以递增或 递减的次序进行排列。 遍历:按次序访问线性表中的所有数据元素,并且每 个数据元素恰好访问一次。
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
}
}
/*************主程序**********************/
main()
{
LinkList *L;
int len;
int n=0;
int x=15;
int y;
int i=4;
L = (LinkList*)malloc(sizeof(struct Lnode));
/*L->data = 0;*/
{
L->length = 0;
}
/*******Creat SqList********/
void Create_SqList(SqList *L)
{
int i=0;
InitList(L);
printf("input SqList.data\n");
scanf("%d",&L->data[0]);
while(L->data[i]!=-1)
{ /*定义线性表的单链表存储结构*/
int data;
struct Lnode *next;
}LinkList;
/****************单链表的初始化*************************/
Initlist(LinkList *L)
{ /*动态申请存储空间*/
L = (LinkList *)malloc(sizeof(struct Lnode));/*建立头结点*/
{
p = (LinkList*)malloc(sizeof(struct Lnode));
printf("input a value\n");
scanf("%d",&p->data); /*输入元素值
p->next = L->next;
L->next = p;
/*插入到表头
}
} /* Create_L */
L->next = NULL;
}
/*************建立一个带头结点的单链表,在表尾插入***************/
Create_L(LinkList *L,int n)
{
LinkList *p,*q; int i;
Initlist(L); /*单链表初始化*/
q=L;
printf("input the value\n");
数据结构顺序表的主要代码(LIZHULIN)
1./***有头结点的单链表的初始化、建立(表头插入、表尾插入)、求长度、插入、删除、输出***/
/***********单链表的初始化、建立、输出*****************/
#include<stdio.h>
#include<stdlib.h>
typedef struct Lnode
/********* the length of SqList****************/
int ListLength(SqList *L)
{
return L->length;
}
/************ GetElem L->data[i]************/
int length;
}SqList;
/********** InitList ************/
void InitList(SqList *L)
{
L->length = 0;
}
/************ Creat SqList*************/
void Create_SqList(SqList *L)
len=Length_LinkList(L);
printf("the length of L is %d",len);*/
display(L);
getch();
}
2./***无头结点的单链表建立、插入、求长度、插入、删除、输出*****/
#include<stdio.h>
#include<stdlib.h>
return i;
}/*Length_LinkList*/
/*************************在第i个结点前插入数据x *********************/
Insert_LinkList(LinkList *L, int i, int x)
{
LinkList *p,*s;
int j=0;
s->next=p->next;
p->next=s;
}
/*********************删除第i个元素,并用y将其值返回************************/
int Delete_LinkList(LinkList *L, int i)
{
LinkList *p,*q;
int y;
/*******************单链表值的输出****************/
void display(LinkList *L) /*字母链表的输出*/
{
LinkList *p;
p=L->next;
while (p!=NULL)
{
printf("%d ",p->data);
p=p->next;
void Display_SqList(SqList *L)
{
int i,n;
n=ListLength(L);
printf("the length is %d ",n);
for(i=0;i<n;i++)
printf("%d ", L->data[i]);
}
/****************Main()**************************/
typedef struct Lnode
{ /*定义线性表的单链表存储结构*/
int data;
struct Lnode *next;
}LinkList;
/*************Create ***************/
Link_Creat(LinkList *L,int n)
{
LinkList *q,*p;
p = (LinkList*)malloc(sizeof(struct Lnode));
printf("input the value\n");
scanf("%d",&p->data); /*输入元素值
L->next = p;
p->next = NULL;
/*将第二个及后面的数据插入
for(i = n-1;i>0;--i)
L->next =NULL;
printf("input the length of L ,n\n");
scanf("%d",&n);
printf("\n");
Create_L(L,n);
Insert_LinkList(L, i, x);
/* y=Delete_LinkList(L,i);
printf("the delete elment is y=%d\n",y);
int j=0;
p=L;
/*寻找第i个结点*/
while(j<i-1 && p!=NULL)
{
++j;
p=p->next;
}
if (!p) return 0;/*如果表长小于i,则无意义*/
q=p->next;
y=q->data;
p->next=q->next;
free(q) ;
return y;
} /*Delete_LinkList*/
/*************************求单链表的长度***********************/
int Length_LinkList(LinkList *L)
{
LinkList *p;
int i=0;
p=L->next;
while(p!=NULL)
{
i++;
p=p->next;
}
for(i = n;i>0;--i)
{
p = (LinkList*)malloc(sizeof(struct Lnode));
scanf("%d",&p->data); /*输入元素值*/
q->next = p;
p->next = NULL;
q=p;
/*插入到表尾*/
}
} /* Create_L */
{
++i;
scanf("%d",&(L->data[i]));
}
L->length = i;
}
/********* the length of SqList****************/
int ListLength(SqList *L)
{
return L->length;
}
/************ GetElem L->data[i]************/
main()
{
SqList *L;
相关文档
最新文档