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

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

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

数据结构顺序表代码很高兴回答这个问题。

关于数据结构的顺序表代码，我们需要先了解什么是顺序表以及其特点和常用操作。

顺序表是一种基于数组实现的线性数据结构，其特点是元素在内存中是连续存储的，可以支持快速随机访问，但插入和删除元素比较麻烦。

下面是一份简单的顺序表代码：```#define MAXSIZE 100 //定义顺序表的最大长度typedef struct {int data[MAXSIZE]; //用数组存储顺序表的元素int length; //顺序表的当前长度} SeqList;// 初始化顺序表void InitList(SeqList *L){memset(L->data, 0, sizeof(L->data)); //初始化所有元素为0L->length = 0; //长度为0}// 插入元素bool ListInsert(SeqList *L, int pos, int val){if(pos < 1 || pos > L->length + 1 || L->length == MAXSIZE) //判断是否越界或者表满return false;for(int i = L->length; i >= pos; i--) //从后向前移动元素L->data[i] = L->data[i - 1];L->data[pos - 1] = val; //插入新元素L->length++; //长度加1return true;}// 删除元素bool ListDelete(SeqList *L, int pos){if(pos < 1 || pos > L->length) //判断是否越界return false;for(int i = pos - 1; i < L->length - 1; i++) //从前向后移动元素 L->data[i] = L->data[i + 1];L->length--; //长度减1return true;}// 查找元素int LocateElem(SeqList L, int val){for(int i = 0; i < L.length; i++){ //遍历顺序表找到元素 if(L.data[i] == val)return i + 1;}return 0;}// 获取元素int GetElem(SeqList L, int pos){if(pos >= 1 && pos <= L.length) //判断是否越界 return L.data[pos - 1];elsereturn -1;}// 输出顺序表void PrintList(SeqList L){for(int i = 0; i < L.length; i++)printf("%d ", L.data[i]); //输出每个元素printf("\n");}```以上就是一个简单的顺序表代码实现，包括初始化、插入、删除、查找、获取和输出操作。

【数据结构】线性表的基本操作【数据结构】线性表的基本操作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 队列的应用附件：无法律名词及注释：- 线性表：根据某种规则排列的一组元素的有限序列。

- 初始化操作：创建一个空的线性表，或者创建一个已经包含一定元素的线性表。

- 插入操作：在线性表的指定位置或者表头、表尾插入一个新元素。

- 删除操作：从线性表中删除掉指定位置或者表头、表尾的元素。

- 查找操作：在线性表中按照指定的元素值或者位置查找元素。

- 修改操作：更改线性表中指定位置或者值的元素。

- 反转线性表：将线性表中的元素顺序颠倒。

- 合并线性表：将两个线性表合并成一个新的线性表。

- 排序线性表：按照某种规则对线性表中的元素进行排序。

- 删除重复元素：将线性表中重复的元素删除，只保留一个。

- 拆分线性表：将一个线性表分成多个不重叠的子线性表。

/* 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已存在。

/* 线性表的顺序表示：类型和界面定义*//* 线性表的顺序表示：函数实现*//* 线性表的单链表表示：类型和界面函数定义*//* 线性表的单链表表示：函数实现*//* 线性表的顺序表示：类型和界面定义*//* 线性表的顺序表示：函数实现*//* 用顺序表解决josephus问题的算法*//* 用循环单链表解决josephus问题的算法*//*字符串的顺序表示*//* 字符串的链接表示 *//* 顺序栈表示：类型和界面函数声明 *//* 顺序栈表示：函数定义 *//* 栈链接表示：类型和界面函数声明 *//*栈链接表示：函数定义*//* 简化背包问题的递归算法*//* 简化背包问题的非递归算法*//* 迷宫问题的递归算法*//* 迷宫问题的非递归算法(栈实现)*//* 队列的顺序表示：类型和函数声明 *//* 队列的顺序表示：函数定义 *//*队列链接表示：类型和界面函数声明*//*队列链接表示：函数定义*//* 用队列解决农夫过河问题的算法*//* 树的长子-兄弟表示法*//* 树的父指针表示法*//* 树的子表表示法*//* 树的后根周游的递归算法*//* 树的先根周游的非递归算法*//* 树的中根周游的递归算法*//* 树的后根周游的递归算法*//* 树的广度优先周游算法*//* 二叉树的链接表示*//* 二叉树的顺序表示*//* 线索二叉树的定义,构造算法和中根周游算法*//* 二叉树前根周游的递归算法*//* 二叉树对称根周游的递归算法*//* 二叉树后根周游的递归算法*//* 二叉树后根周游的非递归算法*//* 本程序提供了用顺序表实现字典的存储表示定义*//* 本程序是用开地址法解决碰撞的散列表示方法,提供了字典的一些基本操作*//* 字典的二叉排序树实现,本程序实现了二叉排序树的基本操作的算法*/ /* 字典的AVL树实现*//* 本程序提供了用顺序表实现字典的情况下的顺序检索算法*//* 本程序提供了用顺序表实现字典的情况下的二分法检索算法*//* 本程序是用开地址法实现散列的检索算法*//* 二叉排序树的检索算法*//* AVL树的检索算法*//* 最佳二叉排序树是具有最佳检索效率的二叉排序树, 本程序提供了最佳二叉排序树的构造方法*//* 直接插入排序的算法源程序*//* 二分法插入排序的算法源程序*//* 表插入排序的算法源程序*//* shell排序的算法源程序 *//* 直接选择排序的算法源程序*//* 堆排序的算法源程序*//* 起泡排序的算法源程序*//* 快速排序的算法源程序*//* 基数排序的算法源程序*//* 二路归并排序算法的源程序*//* 用图邻接矩阵表示实现的一些基本运算*//* 用图邻接表表示实现的一些基本运算*//* 用邻接矩阵表示的图的广度优先周游算法*//* 用邻接表表示的图的广度优先周游算法*//* 用邻接矩阵表示的图的深度优先周游的递归算法*/ /* 用邻接矩阵表示的图的深度优先周游的非递归算法*/ /* 用邻接表表示的图的深度优先周游的非递归算法*/ /* 用邻接矩阵表示的图的Kruskal算法的源程序*//* 用邻接矩阵表示的图的prim算法的源程序*//* 用邻接矩阵表示的图的Dijkstra算法的源程序*//* 用邻接矩阵表示的图的Floyd算法的源程序*//* 用邻接表表示图的拓扑排序算法*//* 用邻接矩阵表示图的拓扑排序算法*//* 图的关键路径问题的算法*//* 背包问题的贪心法算法*//* 用动态规划法求组和数的算法*//* 用回溯法解决骑士周游问题的算法*//* 0/1背包问题的回溯法算法*//* 0/1背包问题的动态规划法算法*//* 0/1背包问题的分支定界法算法*//* 线性表的顺序表示：类型和界面定义*/#define TRUE 1#define FALSE 0#define SPECIAL -1/* 定义顺序表的大小。

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

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

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

数据结构中的,线性表的c语言表示和插入,删除,查找操作程序#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; }。

【数据结构】线性表顺序表详解和代码实例线性表(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)。

(线性表顺序存储）#include"string.h"#include"ctype.h"#include"stdio.h"#include"stdlib.h"#include"io.h"#include"math.h"#include"time.h"#define OK1#define ERROR0#define TRUE1#define FALSE0#define MAXSIZE20/*存储空间初始分配量*/ typedef int Status;/*Status是函数的类型,其值是函数结果状态代码，如OK等*/typedef int ElemType;/*ElemType类型根据实际情况而定，这里假设为int*/Status visit(ElemType c){printf("%d",c);return OK;}typedef struct{ElemType data[MAXSIZE];/*数组，存储数据元素*/int length;/*线性表当前长度*/}SqList;/*初始化顺序线性表*/Status InitList(SqList*L){L->length=0;return OK;}/*初始条件：顺序线性表L已存在。

操作结果：若L为空表，则返回TRUE，否则返回FALSE*/Status ListEmpty(SqList L){if(L.length==0)return TRUE;elsereturn FALSE;}/*初始条件：顺序线性表L已存在。

操作结果：将L重置为空表*/Status ClearList(SqList*L){L->length=0;return OK;}/*初始条件：顺序线性表L已存在。

操作结果：返回L 中数据元素个数*/int ListLength(SqList L){return L.length;}/*初始条件：顺序线性表L已存在，1≤i≤ListLength(L)*/ /*操作结果：用e返回L中第i个数据元素的值,注意i 是指位置，第1个位置的数组是从0开始*/Status GetElem(SqList L,int i,ElemType*e){if(L.length==0||i<1||i>L.length)return ERROR;*e=L.data[i-1];return OK;}/*初始条件：顺序线性表L已存在*//*操作结果：返回L中第1个与e满足关系的数据元素的位序。

目录第一部分预备知识 (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.数组（Array）：●定义和初始化数组●插入、删除元素●查找元素●数组的遍历●数组排序算法（如冒泡排序、快速排序）2.链表（Linked List）：●单链表的定义和初始化●插入、删除节点●链表的遍历●双向链表的定义和初始化●插入、删除节点●双向链表的遍历●栈的定义和初始化●入栈、出栈操作●获取栈顶元素、判断栈是否为空●栈的应用（如括号匹配、逆波兰表达式求值）4.队列（Queue）：●队列的定义和初始化●入队、出队操作●获取队头元素、判断队列是否为空●队列的应用（如循环队列、优先级队列）二、非线性结构1.树（Tree）：●二叉树的定义和初始化●二叉树的遍历（前序、中序、后序）●二叉搜索树的实现和应用●平衡二叉树（AVL树）的实现和应用●哈夫曼树的实现和应用●图的存储结构（邻接矩阵、邻接表）●深度优先搜索（DFS）●广度优先搜索（BFS）●最小树算法（如Prim算法、Kruskal算法）●最短路径算法（如Dijkstra算法、Floyd算法）附件：本文档中所涉及的代码示例可以在附件中找到，包括各种数据结构的实现和相关算法。

法律名词及注释：1.数组：计算机科学中的一种数据结构，用于存储一系列相同类型的元素。

2.链表：一种动态数据结构，由一系列节点组成，每个节点包含一个数据元素和指向下一个节点的指针。

3.栈：一种特殊的线性数据结构，遵循先进后出（Last In First Out，LIFO）的原则。

4.队列：一种特殊的线性数据结构，遵循先进先出（First In First Out，FIFO）的原则。

5.二叉树：一种特殊的树形结构，每个节点最多有两个子节点。

6.图：由节点（顶点）和连接节点的边构成的数据结构，用于描述事物之间的关系。

数据结构实验报告全集实验一线性表基本操作和简单程序1．实验目的（1）掌握使用Visual C++ 6.0上机调试程序的基本方法；（2）掌握线性表的基本操作：初始化、插入、删除、取数据元素等运算在顺序存储结构和链表存储结构上的程序设计方法。

2．实验要求（1）认真阅读和掌握和本实验相关的教材内容。

（2）认真阅读和掌握本章相关内容的程序。

（3）上机运行程序。

（4）保存和打印出程序的运行结果，并结合程序进行分析。

（5）按照你对线性表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果实验代码：1）头文件模块#include iostream.h>//头文件#include<malloc.h>//库头文件-----动态分配内存空间typedef int elemtype;//定义数据域的类型typedef struct linknode//定义结点类型{elemtype data;//定义数据域struct linknode *next;//定义结点指针}nodetype;2）创建单链表nodetype *create()//建立单链表，由用户输入各结点data域之值，//以0表示输入结束{elemtype d;//定义数据元素dnodetype *h=NULL,*s,*t;//定义结点指针int i=1;cout<<"建立一个单链表"<<endl;while(1){cout <<" 输入第"<< i <<"结点data域值：";cin >> d;if(d==0) break;//以0表示输入结束if(i==1)//建立第一个结点{h=(nodetype*)malloc(sizeof(nodetype));//表示指针hh->data=d;h->next=NULL;t=h;//h是头指针}else//建立其余结点{s=(nodetype*) malloc(sizeof(nodetype));s->data=d;s->next=NULL;t->next=s;t=s;//t始终指向生成的单链表的最后一个节点}i++;}return h;}3）输出单链表中的元素void disp(nodetype*h)//输出由h指向的单链表的所有data域之值{nodetype *p=h;cout<<"输出一个单链表:"<<endl<<" ";if(p==NULL)cout<<"空表";while(p!=NULL){cout<<p->data<<" ";p=p->next;}cout<<endl;}4）计算单链表的长度int len(nodetype *h)//返回单链表的长度{int i=0;nodetype *p=h;while(p!=NULL){p=p->next;i++;}return i;}5）寻找第i个节点nodetype *find(nodetype *h,int i)//返回第i个节点的指针{nodetype *p=h;int j=1;if(i>len(h)||i<=0)return NULL;//i上溢或下溢celse{while (p!=NULL&&j<1)//查找第i个节点，并由p指向该节点{j++;p=p->next;}return p;} }6）单链表的插入操作nodetype *ins(nodetype *h,int i,elemtype x)//在单链表head中第i个节点//（i>=0）之后插入一个data域为x的节点{nodetype *p,*s;s=(nodetype*)malloc(sizeof(nodetype));//创建节点ss->data=x;s->next=NULL;if(i==0)//i=0:s作为该单链表的第一个节点{s->next=h;h=s;}else{p=find(h,i);//查找第i个节点，并由p指向该节点if(p!=NULL){s->next=p->next;p->next=s;}return h;}}7）单链表的删除操作nodetype *del(nodetype *h,int i)//删除第i个节点{nodetype *p=h, *s;int j=1;if(i==1)//删除第1个节点{h=h->next;free(p);}else{p=find(h,i-1);//查找第i-1个节点，并由p指向该节点 if(p!=NULL&&p->next!=NULL){s=p->next;//s指向要删除的节点p->next=s->next;free(s);}else cout<<"输入i的值不正确"<<endl;}return h;}8）释放节点空间void dispose(nodetype *h)//释放单链表的所有节点占用的空间{nodetype *pa=h,*pb;if(pa!=NULL){pb=pa->next;if(pb==NULL)//只有一个节点的情况free(pa);else{while (pb!=NULL)//有两个及以上节点的情况{free(pa);pa=pb;pb=pb->next;}free(pa);}}}9)主程序模块:#include"slink.h"//包含头文件slinkvoid main(){nodetype *head;//定义节点指针变量head=create();//创建一个单链表disp(head);//输出单链表cout<<"单链表长度:"<<len(head)<<endl;ins(head, 2,0);//在第二个节点之后插入以0为元素的节点 disp(head);//输出新链表del(head,2);//删除第二个节点disp(head);//输出新链表}5．实验结果建立一个单链表：输入第1结点data域值：1输入第2结点data域值：2输入第3结点data域值：3输入第4结点data域值：4输入第5结点data域值：5输入第6结点data域值：6输入第7结点data域值：7输入第8结点data域值：8输入第9结点data域值：9输入第10结点data域值0：输出一个单链表：1 2 3 4 5 6 7 8 9单链表长度：9输出一个单链表：1 02345678 9输出一个单链表：1 2 3 4 5 6 7 8实验二顺序栈的实现1.实验目的掌握顺序栈的基本操作：初始化栈、判栈空否、入栈、出栈、取栈顶数据元素等运算以及程序实现方法。

数据结构与算法--线性表⽬录线性结构特点唯⼀头元素唯⼀尾元素除头元素外，都有⼀个直接前驱除尾元素外，都有⼀个直接后继线性表定义语⾔定义线性表是n个数据元素的有限序列。

线性表中的数据元素可以由若⼲个数据项组成。

形式定义线性表可以表⽰成n个数据元素的有限序列（a1,a2,a3……a i-1,a i,……a n）其中a1是头元素，a n是尾元素，a i是第i个元素。

a i-1是a i的直接前驱，a i是a i-1的直接后继。

当2 $\leq$ i $\leq$ n时，a i只有⼀个直接前驱当1 $\leq$ i $\leq$ n-1时，a i只有⼀个直接基本操作InitList(&L)//构造空线性表LDestroyList(&L)//销毁已存在的线性表LClearList(&L)//将L重置为空表ListEmpty(L)//判断列表是否为空ListLength(L)//获取列表长度GetElem(L,i,&e)//返回L中的第i个元素到eLocateElem(L,e,compare())//查找元素e的位置PriorElem(L,cur_e,&pre_e)//查找前驱元素NextElem(L,cur_e,&next_e)//查找后继元素ListInsert(&L,i,e)//插⼊元素ListDelete(&L,i,&e)//删除元素ListTraverse(L,visit())//遍历元素线性表的实现顺序表⽰和实现线性表的顺序表⽰是指⽤⼀组地址连续的存储单元⼀次存储线性表的数据元素，⽤物理位置相邻来表⽰逻辑关系相邻，任意数据元素都可随意存取（故⼜称随机存取结构）readme顺序表中元素下标从0开始以下顺序表的实现可以直接运⾏#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define LIST_INIT_SIZE 100//顺序表初始化长度#define LIST_INCREMENT 10 //每次不⾜时新增长度#define OVERFLOW 0 //分配空间失败#define REFREE 0 //重复释放，释放空指针#define OK 1#define ERROR 0typedef int ElemType;//需要时进⾏修改typedef int Status;template <typename ElemType>//使⽤模板⽅便更多数据类型的使⽤//结构定义class List{public:typedef struct{ElemType *elem;//存储数据元素int length;//表长，初始为0int listsize;//表存储容量，也就是实际分配的存储空间}SqList;SqList L;//线性表List();//构造函数~List();//析构函数Status List_Init();//线性表初始化函数Status List_Insert(int i,ElemType e);//线性表插⼊元素Status List_Delete(int i,ElemType &e);//线性表删除元素Status List_Traverse();//线性表遍历Status List_Destroy();//线性表销毁Status List_Clear();//线性表清空};template <typename ElemType>List<ElemType>::List(){List_Init();//含有指针变量，构造时需要分配空间，不过我们可以直接利⽤线性表的初始化函数}template <typename ElemType>List<ElemType>::~List(){if(!L.elem)//避免我们之前调⽤过线性表的销毁函数，导致重复释放指针free(L.elem);}//线性表的初始化template <typename ElemType>Status List<ElemType>::List_Init(){L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));if(!L.elem)//指针为空时，说明分配失败，通常由于内存满了，但这种情况⼀般不会出现exit(OVERFLOW);L.length = 0;L.listsize = LIST_INIT_SIZE;return OK;}//插⼊元素e到顺序表i位置//可以插⼊第0个位置⼀直到第n个位置(第n个位置也就是附加在结尾)template <typename ElemType>Status List<ElemType>::List_Insert(int i, ElemType e){if(i<0||i>L.length)//插⼊位置错误return ERROR;if(L.length>=L.listsize)//空间不⾜时分配空间，相等时说明当前空间已满不能再插⼊元素了，所以也要分配空间{ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize+LIST_INCREMENT)*sizeof(ElemType));if(!newbase)exit(OVERFLOW);L.elem = newbase;//上述重新分配时，如果后续空间充⾜则会扩展并返回原指针，否则会寻找⼤⼩适合的空间，返回新指针(并⾃动释放原内存)，所以elem指针需要进⾏更改。

数据结构第一、二次上机：#include <stdio.h>#include <malloc.h>#include <stdlib.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define list_init_size 100 //线性表存储空间的初始分配量#define LISTINCREMENT 10 //线性表存储空间的分配增量typedef int Status;typedef int ElemType;typedef struct{ElemType *elem; //存储空间基址int length; //当前长度int listsize; //当前分配的存储容量（以sizeof(ElemType)为单位）}SqList;Status InitList_Sq(SqList &L){//构造一个空的线性表LL.elem =(ElemType * )malloc(list_init_size*sizeof(ElemType));if(!L.elem )exit(OVERFLOW);//存储分配失败L.length =0; //空表长度为0L.listsize =list_init_size;//初始存储容量return OK;}//Initlist_SqStatus ListInsert_Sq(SqList &L,int i,ElemType e){//在顺序线性表L中第i个位置之前插入新的元素e，//i的合法值为1<=i<=ListLength_Sq(L)+1ElemType *p,*q,*newbase; //定义指针if(i<1||i>L.length +1)return ERROR; //i值不合法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; //插入e++L.length ; //表长增1return OK;}//ListInsert_SqStatus ListDelete_Sq(SqList &L,int i,ElemType &e){//在顺序线性表L中删除第i个元素，并用e返回其值//i的合法值为1<=i<=ListLength_Sq(L)ElemType *p,*q; //定义指针if((i<1) || (i>L.length ))return ERROR; //i值不合法p=&(L.elem [i-1]); //p为被删除元素的位置e=*p; //被删除元素的值赋给eq=L.elem +L.length -1; //表尾元素的位置for(++p;p<=q;++p)*(p-1)=*p; //被删除元素之后的元素左移--L.length ; //表长减1return OK;}//ListDelete_sqvoid display(SqList L){ //定义for循环函数int i;for(i=0;i<=L.length -1;i++)printf("%d\n",L.elem [i]);}int LocateElem_Sq(SqList L,ElemType e){//在顺序线性表L中查找第1个值与e满足compare()的元素的位序//若找到，则返回其在L中的位序，否则返回0ElemType *p;int i=1; //i的初值为第一个元素的位序p=L.elem ; //p的初值为第一个元素的存储位置while(i<=L.length && *p++!=e) ++i;if(i<=L.length) return i;else return 0;}//LocateElem_Sqvoid MergeList_Sq(SqList La,SqList Lb,SqList &Lc ){//已知顺序线性表La和Lb的元素按值非递减排列//归并La和Lb得到新的顺序线性表Lc，Lc的元素也按非递减排列ElemType *pa,*pb,*pc,*pa_last,*pb_last;pa=La.elem ;pb=Lb.elem ;Lc.listsize =Lc.length =La.length +Lb.length ;pc=Lc.elem =(ElemType *)malloc(Lc.listsize *sizeof(ElemType));if(!Lc.elem )exit(OVERFLOW); //存储分配失败pa_last=La.elem +La.length -1;pb_last=Lb.elem +Lb.length -1;while(pa<=pa_last && pb<=pb_last){//归并if(*pa<=*pb)*pc++=*pa++;else*pc++=*pb++;}while(pa<=pa_last) *pc++=*pa++; //插入La的剩余元素while(pb<=pb_last) *pc++=*pb++; //插入Lb的剩余元素}//MergeList_Sqvoid main(){/*SqList L;//定义线性表InitList_Sq(L);//调用空表//插入数据ListInsert_Sq(L,1,10);ListInsert_Sq(L,2,20);ListInsert_Sq(L,1,30);ListInsert_Sq(L,3,40);printf("插入后：\n");display(L);//调用循环函数ListInsert_Sq(L,3,100);//在L表第三个位置插入100printf("插入后：\n");display(L);ElemType e;//定义eListDelete_Sq(L,3,e);//删除L表的第三个元素，用e表示printf("删除后：\n");display(L);printf("被删除元素：%d\n\n\n\n",e);*/SqList La,Lb,Lc;InitList_Sq(La);ListInsert_Sq(La,1,3);ListInsert_Sq(La,2,5);ListInsert_Sq(La,3,8);ListInsert_Sq(La,4,11);printf("La插入后：\n");display(La);InitList_Sq(Lb);ListInsert_Sq(Lb,1,2);ListInsert_Sq(Lb,2,6);ListInsert_Sq(Lb,3,8);ListInsert_Sq(Lb,4,9);ListInsert_Sq(Lb,5,11);。