数据结构C
数据结构
表
线性表
线性表是 具有相同数据类型的 n个数据元素 的有限序列（有次序），其中n为表长，当n=0时 线性表是一个空表。
若用L命名线性表，则其一般表示为
L = {a1,a2,…,ai,ai+1,…,an}
几个概念：
ai是线性表中的“第i个”元素线性表中的位序。（位序从1开始，数组下标从0开始）
a1是 表头元素，an是表尾元素。
除了第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继。
什么时候要传入参数的引用“&”–对参数的修改结果需要“带回来”
“&”指向的是对象本身，不占用对象的存储空间，而指针本身是一个变量，是需要分配存储空间的，里面存储对象的地址，通过对象地址就能访问，操作对象。所以引用和指针都可以访问对象，作用是类似的。
顺序表
顺序表–用顺序表存储的方式实现线性表顺序存储。
存储结构：把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。
typedef struct{
int num;//号数
int people;//人数
} Customer;
如何知道一个数据元素大小？
sizeof(ElemType)
顺序表的静态分配
流程：
①在内存中分配 存储顺序表L各个数据元素 的连续存储空间。包括：MaxSize*sizeof（ElemType）和存储length的空间
②把各个数据元素的值设为默认值
③将Length的值设为0
#include//不初始化数据元素，内存不刷0
#include顺序表的静态分配过程中，如果“数组”存满了怎么办？
可以放弃治疗，顺序表的表长刚开始确定后就无法更改（存储空间是静态的）
顺序表的动态分配
key：动态申请和释放内存空间
c —— malloc、free函数
#includec++ —— new、delete关键字
#include顺序表的特点
①随机访问，即可以在O(1)时间内找到第i个元素。代码实现：data[i-1];静态分配、动态分配都一样。
②存储密度高，每个节点只存储数据元素。
③拓展容量不方便（即便采用动态分配的方式实现，拓展长度的时间复杂度也比较高）
④插入、删除操作不方便，需要移动大量元素。
顺序表的插入
ListInsert(&L, i, e): 插入操作。在表L中的第i个位置上插入指定元素e。
void ListInsert(SqList &L, int i, int e){
for(int j=L.length; j>=i; j--)//将第i个元素及之后的元素后移
L.data[j]=L.data[j-1];
L.data[i-1]=e;//在位置i处放入e，数组是从0开始，注意位序
L.length++; //长度加1
}
好的算法，应该具有“健壮性”。能处理异常情况，并给使用者反馈。
#include顺序表的删除
ListDelete(&L, i, &e): 删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。
#include顺序表的查找
按位查找
//GetElem(L,i): 按位查找操作。获取表L中第i个位置的元素值。
#include按值查找
//LocateElem(L,e):按值查找操作。在表L中，从第一个元素开始依次往后检索，查找第一个元素值等于e的元素，并返回其位序。
#include基本数据类型：int、char、double、float等可以直接用运算符”==“比较。
结构类型的比较
typedef struct{
int num;
int people;
} Customer;
//注意：c语言中，结构体的比较不能直接用”==“，需要依次对比各个分量来判断两个结构体是否相等。
bool isCustomerEqual(Customer a, Customer b){
if(a.num == b.num && a.people == b.people)
return true;
else
return false;
}
单链表
顺序表：每个结点中只存放数据元素
优点：可以随机存取，存储密度高。
缺点：要求大片连续空间，改变容量不方便。
单链表：每个结点除了存放数据元素外，还要存放指向下一个结点的指针。
优点：不要求大片连续空间，改变容量方便。
缺点：不可以随机存取，要耗费一定空间存放指针。
struct LNode{ //定义单链表节点类型(结点)
ElemType data; //每个节点存放下一数据元素(数据域)
struct LNode *next; //指针指向下一个结点(指针域)
};
struct LNode *p=(struct LNode *)malloc(sizeof(struct LNode));//增加一个新的节点：在内存中申请一个结点所需空间，并用指针p指向这个结点。
//typedef关键字--数据类型重命名
typedef<数据类型><别名>
typedef struct LNode LNode;
LNode* p = (LNode *)malloc(sizeof(LNode));
用代码定义一个单链表
typedef struct LNode{ //定义单链表结点类型
ElemType data; //每个结点存放一个数据元素
struct LNode *next; //指针指向下一个结点
}LNode, *LinkList;//结点，单链表（结点指针）
struct LNode{ // 定义单链表结点类型
ElemType data; // 每个结点存放一个数据元素
struct LNode *next; // 指针指向下一个结点
};
LNode *GetElem(Linklist L, int i){
int j=1;
LNode *p = L->next;
if(i==0)
return L;
if(i<1)
return NULL;
while(p!=NULL && j<i){
p=p->next;
j++;
}
return p;
}
typedef struct LNode LNode;
typedef struct LNode *LinkList;
//要表示一个单链表时，只需要声明一个头指针L，指向单链表的第一个结点
LNode *L; //声明一个指向单链表第一个结点的指针。强调这是一个结点。
或：
LinkList L;//声明一个指向单链表第一个结点的指针。强调这是一个单链表。
头插法建立单链表的算法如下：
LinkList List_HeadInsert(LinkList &L){//逆向建立单链表
LNode *s;
int x;
L=(LinkList)malloc(sizeof(LNode));//创建头节点
L->next=NULL; //初始为空链表
scanf("%d",&x); //输入结点的值
while(x!=9999){ //输入9999表示结束
s=(LNode*)malloc(sizeof(LNode));//创建新结点
s->data = x;
s->next = L->next;
L->next = s; //将新节点插入表中，L为头指针
scanf("%d",&x);
}
return L;
}
不带头节点的和带头节点的单链表
#include不带头节点V.S.带头结点：
不带头节点，写代码更麻烦，对第一个数据结点和后续数据点的处理需要用不同的代码逻辑，对空表和非空表的处理需要用不同的代码逻辑。
头结点是链表里面第一个结点，他的数据域可以不存放任何信息（有时候也会存放链表的长度等等信息），他的指针区域存放的是链表中第一个数据元素的结点（就是传说中的首元结点）存放的地址。
带头结点，写代码更方便，用过都说好。
单链表的查找
单链表的查找分为按位查找和按值查找。
注意：由于带头结点的方便写代码，我们统一使用”双链表“。
GetElem(L, i):按位查找操作。获取表L中第i个位置的元素的值。
LocateElem(L,e):按值查找操作。在表L中查找具有给定关键字值的元素。
按位查找
LNode * GetElem(LinkList L, int i){
if(i<0)
return NULL;
LNode *p;//指针p指向当前扫描到的结点
int j=0; //当前p指向的是第几个结点
p=L; //L指向头结点，头结点是第0个结点（不存数据）
while(p!=NULL && j<i){
p=p->next;
j++;
}
return p;
}
//时间复杂度：O（n）
按值查找
//找到数据域==e的结点
LNode *LocateElem(LinkList L,ElemType e){
LNode *p = L->next;
//从第一个结点开始查找数据域为e的结点
while(p != NULL && p->data !=e)
p=p->next;
return p; //找到后返回该结点的指针，否则返回NULL
}
//时间复杂度：O（n）
求表长度
int length(LinkList L){
int len = 0; //统计表长
LNode *p= L;
while(p->next != NULL){
p = p->next;
len++;
}
return len;
}
//时间复杂度：O（n）
注意：单链表不具备”随机访问“的特性，只能依次扫描。
单链表的插入
按位序插入（带头结点）
ListInsert(&L,i,e): 插入操作。在表L中的第i个位置（从1开始）上插入指定元素e。找到第i-1个结点，将新节点插入其后。
//在第i个位置插入元素e（带头结点）
//在表L中的第i个位置（从1开始）上插入指定元素e。找到第i-1个结点，将新节点插入其后。
//即找到第i-1个结点，放在其后面
//边界情况：①i<1,即在头结点位置插入，显然不满足；②i=1，即在结点后面插入，即i-1，第0个结点插入（头结点），可行；③i为最后一个位置，即找到i-1的位置插入
typydef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
//在第i个位置插入元素e（带头结点）
bool ListInsert(LinkList &L, int i, ElemType e){
if(i<1)
return false;
LNode *p; //指针p指向当前扫描到的结点
int j=0;//当前p指向的第几个结点,(注意：若要插入到表尾，则p指向最后一个结点，当p==NULL时，报错)
p = L;//L指向头结点，头结点是第0个结点(不存数据)
while(p!=NULL && j<i-1){//循环找到第i-1个结点
p=p->next;
j++;
}
if(p==NULL) //i值不合法
return false;
LNode *s = (LNode *)malloc(sizeof(LNode));
s->data = e;
s->next = p->next;
p->next = s; //将结点s连到p之后
return true; //插入成功
}
按位序插入（不带头结点）
不存在第0个结点，因此i=1时需要特殊处理。
typydef struct LNode{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
//在第i个位置插入元素e（不带头结点）
bool ListInsert(LinkList &L, int i, ElemType e){
if(i<1)
return false;
if(i==1){ //插入第1个结点的操作与其他结点操作不同【不带头结点与带头结点的主要区别】
LNode * s =(LNode *)malloc(sizeof(LNode));
s->data = e;
s->next = L;
L=s; //头指针指向新结点。
}
LNode *p; //指针p指向当前扫描到的结点
int j=0;//当前p指向的第几个结点,(注意：若要插入到表尾，则p指向最后一个结点，当p==NULL时，报错)
p = L;//L指向头结点，头结点是第0个结点(不存数据)
while(p!=NULL && j<i-1){//循环找到第i-1个结点
p=p->next;
j++;
}
if(p==NULL) //i值不合法
return false;
LNode *s = (LNode *)malloc(sizeof(LNode));
s->data = e;
s->next = p->next;
p->next = s; //将结点s连到p之后
return true; //插入成功
}
结论：不带头结点写代码更不方便，推荐用带头结点。
指定结点的后插操作
#include指定结点的前插操作
#include按位序删除（带头结点）
ListDelete(&L, i, &e): 删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。
头结点可以看成是”第0个“结点。
找到第i-1个结点，将其指针指向第i+1个结点，并释放第i个结点。
bool ListDelete(LinkList &L, int i, ElemType &e){
if(i<1)
return false;
LNode *p;//指针p指向当前扫描到的结点
int j=0; //当前p指向的是第几个结点
p=L; //L指向头结点，头结点是第0个结点(不存数据)
while(p!=NULL && j<i-1){// 循环找到第i-1个结点
p = p -> next;
j++;
}
if(p==NULL) //i值不合法
return false;
if(p->next == NULL) //第i-1个结点之后已无其他结点
return false;
LNode *q = p->next;//令q指向被删除结点
e = q->data; //用e返回元素的值
p->next=q->next; //将*q结点从链中“断开”
free(q);
return true; //删除成功
}
单链表
#define _crt_secure_no_warnings
#include 双链表
/**********************双链表*********************************/
typedef struct DNode { //定义双链表结点类型
int data; //数据域
struct DNode* prior, * next; //前驱和后继指针
}DNode, * DLinkList;
//初始化双链表
bool InitDLinkList(DLinkList& L) {
L = (DNode*)malloc(sizeof(DNode)); //分配一个头结点
if (L == NULL) //内存不足，分配失败
return false;
L->prior = NULL;//头结点的prior永远指向NULL
L->next = NULL;//头结点之后暂时还没有结点
return true;
}
//判断双链表是否为空（带头结点）
bool Empty(DLinkList L) {
if (L->next == NULL)
return true;
else
return false;
}
//在p结点之后插入s结点
bool InsertNextDNode(DNode* p, DNode* s) {
if (p == NULL || s == NULL)//非法参数
return false;
s->next = p->next;//将结点*s插入到结点*p之后
if (p->next != NULL)//如果p结点有后继结点
p->next->prior = s;
s->prior = p;
p->next = s;
return true;
}
//删除p结点的后继节点
bool DeleteNextDNode(DNode* p) {
if (p == NULL)
return false;
DNode* q;
q = p->next; //找到p的后继节点q
if (q == NULL)
return false; //p没有后继节点
p->next = q->next;
if (q->next != NULL) //q结点不是最后一个结点
q->next->prior = p;
free(q); //释放结点空间
return true;
}
void DestoryList(DLinkList& L) {
//循环释放各个数据点
while (L->next != NULL)
DeleteNextDNode(L);
free(L); //释放头结点
L = NULL; //头指针指向NULL
}
void testDLinkList() {
//初始链表
DLinkList L;
InitDLinkList(L);
//后续代码
}
循环单链表
#define _crt_secure_no_warnings
#include 循环双链表
/*************************2、循环双链表**********************************************/
typedef struct DNode { //定义双链表结点类型
int data; //数据域
struct DNode* prior, * next; //前驱和后继指针
}DNode, * DLinkList;
//初始化空的循环双链表
bool InitDLinkList(DLinkList& L) {
L = (DNode*)malloc(sizeof(DNode)); //分配一个头结点
if (L == NULL) //内存不足，分配失败
return false;
L->prior = L; //头结点的prior指向头结点
L->next = L; //头结点的next指向头结点
return true;
}
//判断结点p是否为循环单链表的表尾结点
bool isTail(DLinkList L, DNode* p) {
if (p->next == L)
return true;
else
return false;
}
//在p结点之后插入s结点
bool InsertNextDNode(DNode* p, DNode* s) {
if (p == NULL || s == NULL)
return false;
s->next = p->next;
p->next->prior = s;
s->prior = p;
p->next = s;
return true;
}
//删除p的后继结点q
bool DeleteNextDNode(DLinkList L, DNode* p) {
DNode *q;
q = p->next;
if (q == L)
return false;
p->next = q->next;
q->next->prior = p;
free(q);
return true;
}
栈
只允许在一端进行插入或删除操作的线性表；一种操作受限的线性表，只能在栈顶插入、删除；
特点：先进后出；
术语：栈顶、栈底、空栈；
注意：初始化栈，需要分配内存空间；销毁栈，需要设防栈的内存空间。
队列
/*
* 栈Stack：是只允许在一端进行插入或删除操作的线性表
* 队列Queue：是只允许在一端进行插入，在另一端删除的线性表
* 特点：先进先出
*/
#include队列的链式实现
#include