数据结构线性表的顺序表示和实现(C语言)概论

合集下载

线性表的类型定义、顺序表示和实现

线性表的类型定义、顺序表示和实现
– ①ai-1 和 ai逻辑关系发生变化 – ②需移动元素:
i=n 只删 an即可 1≤i≤n -1 将ai+1 ~an前移
23
bool deleteElem(SqList& L,int pos)
typedef int ElemType;
typedef char ElemType;
等;
②同一线性表中的数据元素必须具有相同的特性,属同一类 型;
③a2,关…系, ra是i-1,一a个i, a有i+1序, …偶,对an的)集,合a,i-1即领对先于于非ai,空表的示线了性数表据(元a1,素 之间的相邻关系,称ai-1是ai的直接前驱,ai是ai-1的直接后继 ;
6
2.1.3 操作举例
例:假设利用两个线性表La和Lb分别表示两 个集合A和B,求一个新的集合A=A∪B。
算法:
– ①取得Lb中的1个元素; – ②在La中查找这个元素; – ③若不存在:插入La中;若存在,取Lb中下一个
元素,重复 ①、②、③,直到取完Lb的每个元素 。
7
void unionList(SqList &la,SqList lb)
10
线性表的顺序存储结构示意图
存储地址
loc(a1) loc(a1)+ k
内存空间状态 逻辑地址
a1
1
a2
2



loc(a1)+ (i- 1)k
ai
i



loc(a1)+ (n- 1)k
an
n 空闲
顺序存储结构可以借助于高级程序设计语言中的一维数组来表示。
11
用C++语言描述的顺序表类型如下所示: sqlist.h

数据结构(c语言版)课后习题答案完整版

数据结构(c语言版)课后习题答案完整版

数据结构(c语言版)课后习题答案完整版数据结构(C语言版)课后习题答案完整版一、数据结构概述数据结构是计算机科学中一个重要的概念,用来组织和存储数据,使之可以高效地访问和操作。

在C语言中,我们可以使用不同的数据结构来解决各种问题。

本文将提供完整版本的C语言数据结构的课后习题答案。

二、顺序表1. 顺序表的定义和基本操作顺序表是一种线性表,其中的元素在物理内存中连续地存储。

在C 语言中,我们可以通过定义结构体和使用指针来实现顺序表。

以下是顺序表的一些基本操作的答案:(1)初始化顺序表```ctypedef struct{int data[MAX_SIZE];int length;} SeqList;void InitList(SeqList *L){L->length = 0;}```(2)插入元素到顺序表中```cbool Insert(SeqList *L, int pos, int elem){if(L->length == MAX_SIZE){return false; // 顺序表已满}if(pos < 1 || pos > L->length + 1){return false; // 位置不合法}for(int i = L->length; i >= pos; i--){L->data[i] = L->data[i-1]; // 向后移动元素 }L->data[pos-1] = elem;L->length++;return true;}```(3)删除顺序表中的元素```cbool Delete(SeqList *L, int pos){if(pos < 1 || pos > L->length){return false; // 位置不合法}for(int i = pos; i < L->length; i++){L->data[i-1] = L->data[i]; // 向前移动元素 }L->length--;return true;}```(4)查找顺序表中的元素```cint Search(SeqList L, int elem){for(int i = 0; i < L.length; i++){if(L.data[i] == elem){return i + 1; // 找到元素,返回位置 }}return -1; // 未找到元素}```2. 顺序表习题解答(1)逆置顺序表```cvoid Reverse(SeqList *L){for(int i = 0; i < L->length / 2; i++){int temp = L->data[i];L->data[i] = L->data[L->length - 1 - i]; L->data[L->length - 1 - i] = temp;}}```(2)顺序表元素去重```cvoid RemoveDuplicates(SeqList *L){for(int i = 0; i < L->length; i++){for(int j = i + 1; j < L->length; j++){if(L->data[i] == L->data[j]){Delete(L, j + 1);j--;}}}}```三、链表1. 单链表单链表是一种常见的链式存储结构,每个节点包含数据和指向下一个节点的指针。

数据结构线性表

数据结构线性表

数据结构线性表一、引言数据结构是计算机存储、组织数据的方式,它决定了数据访问的效率和灵活性。

在数据结构中,线性表是一种最基本、最常用的数据结构。

线性表是由零个或多个数据元素组成的有限序列,其中数据元素之间的关系是一对一的关系。

本文将对线性表的概念、分类、基本操作及其应用进行详细阐述。

二、线性表的概念1.数据元素之间具有一对一的关系,即除了第一个和一个数据元素外,其他数据元素都是首尾相连的。

2.线性表具有唯一的第一个元素和一个元素,分别称为表头和表尾。

3.线性表的长度是指表中数据元素的个数,长度为零的线性表称为空表。

三、线性表的分类根据线性表的存储方式,可以将线性表分为顺序存储结构和链式存储结构两大类。

1.顺序存储结构:顺序存储结构是将线性表中的数据元素按照逻辑顺序依次存放在一组地质连续的存储单元中。

顺序存储结构具有随机访问的特点,可以通过下标快速访问表中的任意一个元素。

顺序存储结构的线性表又可以分为静态顺序表和动态顺序表两种。

2.链式存储结构:链式存储结构是通过指针将线性表中的数据元素连接起来,形成一个链表。

链表中的每个节点包含一个数据元素和一个或多个指针,指向下一个或前一个节点。

链式存储结构具有动态性,可以根据需要动态地分配和释放节点空间。

链式存储结构的线性表又可以分为单向链表、双向链表和循环链表等。

四、线性表的基本操作线性表作为一种数据结构,具有一系列基本操作,包括:1.初始化:创建一个空的线性表。

2.插入:在线性表的指定位置插入一个数据元素。

3.删除:删除线性表中指定位置的数据元素。

4.查找:在线性表中查找具有给定关键字的数据元素。

5.更新:更新线性表中指定位置的数据元素。

6.销毁:释放线性表所占用的空间。

7.遍历:遍历线性表中的所有数据元素,进行相应的操作。

8.排序:对线性表中的数据元素进行排序。

9.合并:将两个线性表合并为一个线性表。

五、线性表的应用1.程序语言中的数组:数组是一种典型的顺序存储结构的线性表,常用于存储具有相同类型的数据元素。

数据结构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语言)数据组织(数据、数据元素、数据项)的三个层次:数据可由若干个数据元素构成,而数据元素又可以由一个或若干个数据项组成。

四种基本的数据结构:集合、线性结构、树形结构、图状结构。

顺序存储的特点是在内存中开辟一组连续的空间来存放数据,数据元素之间的逻辑关系通过元素在内存中存放的相对位置来确定。

链式存储的特点是通过指针反映数据元素之间的逻辑关系。

数据类型:原子类型、结构类型。

线性表定义:线性表是n个数据元素的有限序列。

线性表的顺序存储结构:表中相邻的元素a和b所对应的存储地址A和B 也是相邻的。

(也就是数据都是按照表中情况进行连续存储的情况)线性表的链式存储结构:该线性表中的数据元素可以用任意的存储单元来存储。

表中的各个相邻的数据(元素)是通过一个指针地址来进行链接的,以找到下一个数据(元素)在哪。

其形式一般为:数据地址线性表的顺序和链式存储结构的比较:在线性表的长度变化比较大,预先难以确定的情况下,最好采用动态链表作为存储结构。

当线性表的长度变化不大时,采用顺序存储结构比较节省存储空间。

在顺序表结构的线性表上主要进行查找、读取而很少做插入和删除的操作。

链式结构的线性表中比较适应做插入和删除的操作。

一元多项式的加减法运算可先将一元多项式进行了改变存储之后再进行运算比较适宜,将一元多项式转换为用在内存中的前一项表示阶数,后一项表示对应该阶数的系数。

然后利用这种形式进行加减运算。

栈和队列栈是限定在表的同一端进行插入或删除操作的线性表,即进栈、出栈。

(特殊的线性表)栈的顺序存储结构:利用一组地址连续的存储单元依次从栈底到栈顶存放数据元素,栈底位置固定不变,可将栈底设在向量低下标的一端。

栈的链式存储结构:用单链表作为存储结构的栈称为链栈,链表的最后一个结点表示栈底,第一个结点表示栈顶。

队列也是一种特殊的线性表。

它所有的插入操作均限定在表的一端进行,而所有的删除操作则限定在表的另一端进行。

允许删除元素的一端称为队头,允许插入元素的一端称为队尾,删除元素称为出队,插入元素称为进队。

数据结构线性表ppt课件

数据结构线性表ppt课件

01
02
03
04
插入操作
在链表的指定位置插入一个新 节点,需要修改相邻节点的指
针。
删除操作
删除链表的指定节点,需要修 改相邻节点的指针。
查找操作
从链表的头节点开始,顺序遍 历链表,直到找到目标元素或
遍历到链表末尾。
遍历操作
从链表的头节点开始,顺序访 问每个节点,直到遍历到链表
末尾。
04 线性表应用举例 与问题分析
多项式表示与计算问题
01
02
03
多项式表示方法
数组表示法和链表表示法 。
数组表示法
将多项式的系数按次序存 放在一个数组中,通过下 标表示对应的幂次。
链表表示法
每个节点包含系数和指数 两个数据域,以及一个指 向下一个节点的指针域。
一元多项式相加算法设计
• 算法思想:将两个多项式中的同类项系数相加,得到新的 多项式。
删除操作
删除指定位置i的元素,需要将i之后的元素都向前移动 一个位置。
03 链式存储结构及 其实现
链式存储结构原理及特点
链式存储结构原理
使用一组任意的存储单元存储线 性表的数据元素(这组存储单元 可以是连续的,也可以是不连续 的)。
链式存储结构特点
逻辑上相邻的元素在物理位置上 不一定相邻,元素之间的逻辑关 系是通过指针链接来表示的。
...,an组成的有序序列。
性质
集合中必存在唯一的一个“第一元素 ”。
集合中必存在唯一的一个“最后元素 ”。
除最后元素之外,均有唯一的后继。
除第一元素之外,均有唯一的前驱。
线性表与数组关系
数组是线性表的一种表现和实现形式。
线性表更侧重于逻辑概念,而数组则是这种逻辑概念在计算机中的一种存储方式。

C语言实现顺序表的基本操作(从键盘输入生成线性表,读txt文件生成线性表和数组生成线性表-。。。

C语言实现顺序表的基本操作(从键盘输入生成线性表,读txt文件生成线性表和数组生成线性表-。。。

C语⾔实现顺序表的基本操作(从键盘输⼊⽣成线性表,读txt⽂件⽣成线性表和数组⽣成线性表-。

经过三天的时间终于把顺序表的操作实现搞定了。

(主要是在测试部分停留了太长时间)1. 线性表顺序存储的概念:指的是在内存中⽤⼀段地址连续的存储单元依次存储线性表中的元素。

2. 采⽤的实现⽅式:⼀段地址连续的存储单元可以⽤固定数组或者动态存储结构来实现,这⾥采⽤动态分配存储结构。

3. 顺序表结构体⽰意图三种写法完整代码:第⼀种写法. 从键盘输⼊⽣成线性表--完整代码如下,取值操作实际上就是删除操作的部分实现,这⾥就不写了#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define TRUE 1#define FALSE 0typedef int Status;typedef int ElemType;typedef struct SqList{ElemType *elem;int length;int listsize;}SqList;Status InitList(SqList &L){L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));if (!L.elem){printf("ERROR\n");return ERROR;}L.length = 0;L.listsize = LIST_INIT_SIZE;return OK;}Status ListEmpty(SqList L) //判空{if (L.length = 0) return TRUE;else return FALSE;}Status ListInsert(SqList &L, int i, ElemType e) //插⼊{ElemType *p, *q;ElemType *newbase;int j;if (i < 1 || i > L.length + 1) return ERROR;if (L.length >= L.listsize){newbase = (ElemType *)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));if (newbase == NULL){printf("realloc failed!\n");return ERROR;//exit(-1);}L.elem = newbase;L.listsize += LISTINCREMENT;}p = L.elem+i-1;for( q = L.elem + L.length - 1; q>= p; --q ){*(q+1) = *q;}*p = e;++L.length;return OK;}Status CrtList(SqList &L) // 从键盘输⼊数据⽣成线性表{printf("输⼊整数,以0结束:\n");ElemType e;int i = 1;scanf("%d", &e);while (e != 0){if (!ListInsert(L, i, e)) return ERROR;i++;scanf("%d", &e);}return OK;}Status CrtList2(SqList &L, ElemType d[], int n) // 从数组⽣成线性表{int i;for (i = 0; i < n; ++i){if (!ListInsert(L, i + 1, d[i])) return ERROR;}return OK;}Status ListDelet(SqList &L, int i, ElemType &e) //删除{if ((i<1) || (i>L.length)) return ERROR;ElemType *p, *q;p = &(L.elem[i - 1]);e = *p;q = L.elem + L.length - 1;for (++p; p <= q; ++p) *(p - 1) = *(p);--L.length;return OK;}Status GetElem(SqList &L, int i, ElemType &e) //取值{if ((i <= 0) || (i>L.length)) return ERROR;else{e = L.elem[i - 1];return OK;}}Status compare(ElemType a, ElemType b) //⽐较{if (a == b) return TRUE;else return FALSE;}int LocateElem(SqList L, ElemType e) //定位{Status compare(ElemType a, ElemType b);int i;for (i = 0; i<L.length; i++){if (compare(L.elem[i], e))return ++i;}if (i == L.length) return0;}Status PriorElem(SqList L, ElemType cur_e, ElemType &pre_e) //求直接前驱{int LocateElem(SqList L, ElemType e);int i = LocateElem(L, cur_e);if ((i == 0) || (i == 1)) return ERROR;pre_e = L.elem[i - 2];return OK;}int ListLength(SqList L) //求长度{int length = L.length;return length;}void MergeList(SqList La, SqList Lb, SqList &Lc) //归并{Lc.length = La.length + Lb.length;Lc.listsize = Lc.length;Lc.elem = (ElemType*)malloc(Lc.length*sizeof(ElemType));if (Lc.elem == NULL) exit(OVERFLOW);int i, j, k;for (i = 0, j = 0, k = 0; (i<La.length) && (j<Lb.length); k++){if (La.elem[i]<Lb.elem[j]){Lc.elem[k] = La.elem[i];i++;}else{Lc.elem[k] = La.elem[j];j++;}}while (i<La.length){Lc.elem[k] = La.elem[i];i++;k++;}while (j<Lb.length){Lc.elem[k] = Lb.elem[j];j++;k++;}}void vist(ElemType e){printf("%d ", e);}Status ListTraverse(SqList L) //遍历{int i;if (L.length == 0) printf("⽆元素");for (i = 0; i<L.length; i++){vist(L.elem[i]);}if (i == L.length){printf("\n");return OK;}else return ERROR;}Status ListClear(SqList L) //清空{if (L.elem == NULL) return ERROR;int i;for (i = 0; i<L.length; i++) L.elem[i] = 0;L.length = 0;return OK;}Status DestroyList(SqList &L) //销毁{if (L.elem == NULL) return ERROR;free(L.elem);L.length = 0;L.listsize = 0;return OK;}void PrnList(SqList L) //打印{int i;for (i = 0; i < L.length; ++i){printf("%5d", L.elem[i]);}printf("\n");}int main(){int j, l;ElemType e, e1;SqList La;if (InitList(La)) printf("OK\n");else exit(INFEASIBLE);CrtList(La);PrnList(La);int k;printf("1:判空\n2:插⼊\n3:删除\n4:定位\n5:求长度\n6:直接前驱\n");printf("7:归并\n8:遍历\n9:清空\n10:销毁\n\n0:退出\n");scanf("%d", &k);while (k != 0){switch (k){case1:if (ListEmpty(La)) printf("empty\n");else printf("non-empty\n");break;case2:printf("在第⼏个位置插⼊何数:");scanf("%d%d", &j, &e);if (ListInsert(La, j, e)) printf("OK\n");else printf("ERROR\n");break;case3:printf("删除第⼏个数:");scanf("%d", &j);if (ListDelet(La, j, e))PrnList(La);printf("删除数为:%d\n", e);break;case4:printf("定位数字:");scanf("%d", &e);if (LocateElem(La, e) != 0) printf("OK,位序为:%d\n", LocateElem(La, e));else printf("ERROR\n");break;case5:l = ListLength(La);printf("ListLength=%d\n", l);break;case6:printf("寻找何数直接前驱:");scanf("%d", &e);if (PriorElem(La, e, e1)) printf("前驱为:%d\n", e1);else printf("ERROR\n");break;case7:SqList Lb, Lc;if (InitList(Lb)) printf("OK\n");else printf("ERROR\n");CrtList(Lb);MergeList(La, Lb, Lc);printf("有序归并后:\n");PrnList(Lc);break;case8:if (ListTraverse(La)) printf("遍历成功\n");else printf("遍历失败\n");break;case9:if (ListClear(La)) printf("清空成功\n");else printf("清空失败\n");break;case10:if (DestroyList(La)) printf("销毁完成\n");else printf("销毁失败\n");return0;default:printf("ERROR\n");}scanf("%d", &k);}return0;}View Code第⼆种写法. 从txt⽂件读⼊⽣成线性表--完整代码如下:#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -1#define TRUE 1#define FALSE 0#define INIT_LIST_SIZE 100#define LISTINCREMENT 10typedef int Status;typedef int ElemType;typedef struct{ElemType *elem;int length;int listsize;}SqList;Status InitList(SqList *L){L->elem = (ElemType*)malloc(INIT_LIST_SIZE*sizeof(ElemType));if (!L->elem) exit(OVERFLOW);L->length = 0;L->listsize = INIT_LIST_SIZE;return OK;}Status ListEmpty(SqList L) //判空{if (L.length = 0) return TRUE;else return FALSE;}Status ListInsert(SqList *L, int i, ElemType e) //插⼊{ElemType *newbase, *q, *p;if (i<1 || i>L->length + 1) return ERROR;if (L->length>L->listsize){newbase = (ElemType*)realloc(L->elem, (L->listsize + LISTINCREMENT)*sizeof(ElemType));if (!newbase) exit(OVERFLOW);L->elem = newbase;L->listsize += LISTINCREMENT;}q = L->elem + i - 1; //q为插⼊位置for (p = L->elem + L->length - 1; p >= q; p--){*(p + 1) = *p;}*q = e;++L->length;return OK;}Status ListDelete(SqList *L, int i, ElemType * e) //删除{ElemType * p, *q;if (i<1 || i>L->length) return ERROR;p = L->elem + i - 1; //p为被删除元素位置*e = *p; //被删除元素的值赋值给eq = L->elem + L->length - 1; //表尾元素位置for (++p; p <= q; ++p){*(p - 1) = *p;}L->length--;return OK;}Status GetElem(SqList *L, int i, ElemType * e) //取值{if (i<1 || i>L->length) return ERROR;*e = *(L->elem + i - 1); //获取第i个元素的地址return OK;}int LocateElem(SqList L, ElemType e) //定位{int i;for (i = 0; i<L.length; i++){if (L.elem[i]==e)return ++i;}if (i == L.length) return0;}Status PriorElem(SqList L, ElemType e, ElemType &pre_e) //求直接前驱{int LocateElem(SqList L, ElemType e);int i = LocateElem(L, e);if ((i == 0) || (i == 1)) return ERROR;pre_e = L.elem[i - 2];return OK;}Status GetLength(SqList *L) //求长度{return L->length;}void PrnList(SqList *L) //遍历{int i;for (i = 0; i<(*L).length; i++){if (i == 0)printf("(");printf(" %d ", L->elem[i]);if (i == (*L).length - 1)printf(")\n");}}Status ClearList(SqList *L) //清空{L->length = 0;return OK;}Status Destroy(SqList *L) //销毁{free(L->elem);L->elem = NULL;L->length = 0;L->listsize = 0;return OK;}int main(){int n = 0, rc;int a, i;int e, e1;SqList L;if (InitList(&L)) printf("OK\n");FILE *fp = fopen("D:/1.txt", "r");if (fp == NULL){printf("打开⽂件失败");}printf("从1.txt⽂件读⼊⼏个数:");scanf("%d", &n);for (i = 0; i< n; i++){fscanf(fp, "%d", &a);ListInsert(&L, i+1, a);}fclose(fp);PrnList(&L);char k;printf("\n1.插⼊\n2.删除\n3.取值\n4.定位\n5.直接前驱\n6.求长度\n7.遍历\n8.清空\n9.销毁\n"); while (1){k = getchar();switch (k){case'1':printf("在第⼏个位置插⼊何数:");scanf("%d%d", &i, &e);if (ListInsert(&L, i, e))printf("i=%d,e=%d 已经插⼊\n", i, e);else printf("插⼊失败\n");break;case'2':printf("删除第⼏个数:\n");scanf("%d", &i);if (ListDelete(&L, i, &e))printf("i=%d,e=%d 已经删除\n", i, e);else printf("删除失败\n");break;case'3':printf("取第⼏个数:\n");scanf("%d", &i);if (GetElem(&L, i, &e))printf("第i=%d号,e=%d 被取出!\n", i, e);else printf("取值失败\n");break;case'4':printf("定位数字:");scanf("%d", &e);if (LocateElem(L, e) != 0) printf("OK,位序为:%d\n", LocateElem(L, e));else printf("ERROR\n");break;case'5':printf("寻找何数直接前驱:");scanf("%d", &e);if (PriorElem(L, e, e1)) printf("前驱为:%d\n", e1);else printf("ERROR\n");break;case'6':printf("表长为%d\n", GetLength(&L));break;case'7':printf("遍历:\n");PrnList(&L);break;case'8':if (ClearList(&L)) printf("清空成功\n");else printf("清空失败\n");break;case'9':printf("销毁\n");Destroy(&L);printf("销毁成功\n");exit(0);return0;}}return0;}View Code第三种写法:读数组⽣成线性表--完整代码如下:#include<stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -1#define TRUE 1#define FALSE 0#define INIT_LIST_SIZE 100#define LISTINCREMENT 10typedef int Status;typedef int ElemType;typedef struct{ElemType *elem;int length;int listsize;}Sqlist;Status InitList(Sqlist *L){L->elem = (ElemType *)malloc(INIT_LIST_SIZE *sizeof(ElemType));if (!L->elem)exit(OVERFLOW);L->length = 0;L->listsize = INIT_LIST_SIZE;return OK;}Status ListEmpty(Sqlist L){if (L.length = 0)return ERROR;else return FALSE;}Status ListInsert(Sqlist *L, int i, ElemType e){ElemType *newbase, *p, *q;if (i<1 || i>L->length + 1)return ERROR;if (L->length > L->listsize){newbase = (ElemType *)realloc(L, (L->listsize + LISTINCREMENT)*sizeof(ElemType));if (!newbase)exit(OVERFLOW);L->elem = newbase;L->listsize += LISTINCREMENT;}p = L->elem + i - 1;for (q = L->elem + L->length - 1; q >= p; q--){*(q + 1) = *q;}*p = e;L->length++;return OK;}Status CreateList(Sqlist *L, ElemType element[], int n) // 从数组⽣成线性表{int i;for (i = 0; i < n; ++i){if (!ListInsert(L, i + 1, element[i])) return ERROR;}return OK;}Status ListDelete(Sqlist *L, int i, ElemType *e){ElemType *p, *q;if (i<1 || i>L->length)return ERROR;p = L->elem + i - 1;q = L->elem + L->length - 1;*e = *p;for (p++; q >= p; p++){*(p - 1) = *p;}L->length--;return OK;}Status GetElem(Sqlist *L, int i, ElemType *e){if (i<1 || i>L->length)return ERROR;return OK;}int LocateElem(Sqlist L, ElemType e){int i;for (i = 0; i < L.length; i++)if (L.elem[i] == e)return i + 1;}Status PriorElem(Sqlist L, ElemType e, ElemType &pr_e){int LocateElem(Sqlist L, ElemType e);int i = LocateElem(L, e);if (i<1 || i>L.length)return ERROR;pr_e = L.elem[i - 2];return OK;}Status GetLength(Sqlist *L){return L->length;}void PrnList(Sqlist *L){int i;for (i = 0; i < L->length; i++)printf("%d ", L->elem[i]);printf("\n");}Status ClearList(Sqlist *L){L->length = 0;return OK;}Status Destroy(Sqlist *L){free(L->elem);L->elem = NULL;L->length = 0;L->listsize = 0;return OK;}int main(){int i;int a, n = 0;int e, e1;Sqlist L;ElemType element[] = { 15, 3, 59, 27, 8, 11, 32 };if (InitList(&L))printf("OK\n");CreateList(&L, element, 7);PrnList(&L);char k;printf("\n1.插⼊\n2.删除\n3.取值\n4.定位\n5.直接前驱\n6.求长度\n7.遍历\n8.清空\n9.销毁\n"); while (1){k = getchar();switch (k){case'1':printf("在第⼏个位置插⼊何数:");scanf("%d%d", &i, &e);if (ListInsert(&L, i, e))printf("i=%d e=%d已经插⼊\n", i, e);break;case'2':printf("删除第⼏个数:");scanf("%d", &i);if (ListDelete(&L, i, &e))printf("i=%d e=%d已经删除\n", i, e);break;case'3':printf("取第⼏个数:");scanf("%d", &i);if (GetElem(&L, i, &e))printf("第i=%d e=%d已经取出\n", i, e);break;case'4':printf("定位何数:");scanf("%d", &e);if (LocateElem(L, e))printf("位序为:%d\n", LocateElem(L, e));break;case'5':printf("寻找何数的直接前驱:");scanf("%d", &e);if (PriorElem(L, e, e1))printf("前驱为:%d\n", e1);break;case'6':printf("表长为:%d\n", GetLength(&L));break;case'7':printf("遍历:\n");PrnList(&L);break;case'8':if (ClearList(&L))printf("清空成功!\n");break;case'9':if (Destroy(&L))printf("销毁成功!\n");exit(0);return0;}}return0;}View Code看懂了左⼿给你个栗⼦,给我关注点赞;看不懂右⼿给你个锤⼦,砸开脑壳看看有没有带脑⼦。

实验报告.线性表的顺序表示和实现

实验报告.线性表的顺序表示和实现
--L.length;//表长减1
return OK;
}
void main()
{Sqlist L; int i; InitList_Sq(L); //构造一个空的线性表L
for (i=0;i<L.listsize;i++)
{scanf("%d",&L.elem[i]);
++L.length;}//输入数据
if(!L.elem) exit(OVERFLOW); //存储分配失败
L.length=0; //空表长度为0
L.listsize=LIST_INIT_SIZE; //初始存储容量
return OK;
}
Status ListInsert_Sq(Sqlist &L,int i, ElemType e){
for(i=0;i<L.listsize;i++)printf("%d ",*(L.elem+i));
//输出表中的数据
printf("\n");
ElemType e;scanf("%d""%d",&i,&e);
ListInsert_Sq(L,i,e);
//在线性表L中第i个元素之前插入元素e
for(i=0;i<L.length;i++)
要不然就会出现很多错误,得不到自己想要的结果。
第二点:要熟练的掌握有关C语言的知识,要充分明白算法与程序的区别,在
编写程序的过程中要保持清醒的头脑,时刻注意那些容易出错的地
方。
第三点:每次进行删除算法之后表长都要减一。否则会造成数据冗余,浪费
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
bool delete_arr(struct Arr * pArr, int pos, int * val); //删除数组中的一个元素
int get(struct Arr * pArr, int pos); //获取某个元素的值
bool is_empty(struct Arr * pArr); //判断数组是否为空
{
printf("%d ", pArr->pBase[i]);
}
printf("\n");
}
}
/*
判断数组是否为空数组
@param struct Arr * pArr结构体变量指针
return Boolean
*/
bool is_empty(struct Arr * pArr)
{
if( 0 == pArr->cnt )
{
return true;
}
else
{
return false;
}
}
/*
追加一个元素
@param struct Arr * pArr结构体变量指针
@param int val追加的元素的值
return Boolean
*/
bool append_arr(struct Arr * pArr, int val)
//判断动态内存是否创建成功
if( NULL == pArr->pBase)
{
printf("动态内存常见失败\n");
eHale Waihona Puke it(-1);}//为其他元素赋值
pArr->len = length;
pArr->cnt = 0;
return;//标识此函数结束
}
/*
将数组展示出来
@param struct Arr * pArr结构体变量指针
return void
*/
void show_arr(struct Arr * pArr)
{
int i;
//首先判断这个数组是否有有效值
if( is_empty(pArr) )
{
printf("这个数组为空\n");
exit(-1);
}
else
{
for(i = 0; i < pArr->cnt; ++i)
*/
bool is_full(struct Arr * pArr)
/*
创建一个数组,实现对这个数组的操作
1,追加一个元素
2,插入一个元素
3,对数组排序
4,反转数组元素
*/
int main(void)
{
//定义一个结构体变量
struct Arr array;
//获取一个被删除的元素的值
int val;
//使用函数init_arr()初始化数组
init_arr(&array, 5);
return 0;
}
/*
初始化数组
@param struct Arr * pArr结构体变量指针
@param int length定义数组的长度
return void
*/
void init_arr(struct Arr * pArr,int length)
{
pArr->pBase = (int *)malloc(sizeof(int) * length);
int cnt; //数组元素的有效个数
};
//前置函数声明
void init_arr(struct Arr * pArr,int length); //初始化
bool append_arr(struct Arr * pArr,int val); //追加一个元素
bool insert_arr(struct Arr * pArr, int pos, int val); //插入一个元素
//追加一个元素
append_arr(&array, 5);
append_arr(&array, 3);
append_arr(&array, 7);
append_arr(&array, 1);
printf("初始化的数组为:\n");
show_arr(&array);
//使用函数insert_arr()插入一个元素
show_arr(&array);
//使用函数sort_arr()对数组进行排序
printf("将数组进行排序:\n");
sort_arr(&array);
show_arr(&array);
//使用函数delete_arr()删除一个元素
printf("删除数组中第三个元素:\n");
delete_arr(&array, 3, &val);
{
if(is_full(pArr))
{
printf("该数组已满\n");
return false;
}
pArr->pBase[pArr->cnt] = val;
pArr->cnt++;
return true;
}
/*
判断数组是否已经爆满
@param struct Arr * pArr结构体变量指针
return Boolean
show_arr(&array);
//使用函数append_arr()追加一个元素
printf("在数组的最后追加一个数值50:\n");
append_arr(&array,50);
show_arr(&array);
//使用函数get()获得一个元素
printf("得到数组中第三个元素:\n%d\n",get(&array,3));
bool is_full(struct Arr * pArr); //判断数组是否已满
void sort_arr(struct Arr * pArr); //为数组进行从小到大排序
void show_arr(struct Arr * pArr); //显示数组内容
void inversion_arr(struct Arr * pArr); //反转数组中的所有值
printf("在第三个元素前插入一个数值99:\n");
insert_arr(&array, 3, 99); //在第三个元素前,插入一个元素
show_arr(&array);
//使用函数inversion_arr()对数组中的元素进行翻转
printf("反转数组中的所有值:\n");
inversion_arr(&array);
/*
线性结构,线性表的顺序表示和实现
*/
# include <stdio.h>
# include <malloc.h>
# include <stdlib.h> //包含了exit()函数
//定义一个数组结构体
struct Arr
{
int * pBase; //保存数组的指针
int len; //保存数组的长度
相关文档
最新文档