408/CSPostgraduate-408
1
0
Fork 0
mirror of https://github.com/CodePanda66/CSPostgraduate-408.git synced 2023-05-21 21:49:33 +08:00
Code Issues Projects Releases Wiki Activity

Merge pull request #1 from KimYangOfCat/dev

Browse Source 
Dev update
This commit is contained in:
kimYang
2020-08-16 14:17:32 +08:00
committed by GitHub
parent 7793374ac6 f8d4e36746
commit 9133afe014
19 changed files with 489 additions and 383 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
DataStructure/DS_0_Introduction/DS_0_0_love.cpp
View File

@@ -10,55 +10,57 @@
//下面四种函数的时间复杂度值得分析一二
//逐步递增型爱你
void LoveYou0(int n){
int i=1;
while (i<=n){
printf("I love you %d \n",i);
void LoveYou0(int n) {
int i = 1;
while (i <= n) {
printf("I love you %d \n", i);
i++;
}
printf("I love you more than %d\n",n);
printf("I love you more than %d\n", n);
}
//嵌套循环型爱你
void loveYou1(int n){
int i=1;
while (i<=n){
void loveYou1(int n) {
int i = 1;
while (i <= n) {
i++;
printf("I love you %d\n",i);
for (int j = 1; j <n ; j++) {
printf("I love you %d\n", i);
for (int j = 1; j < n; j++) {
printf("I love you too\n");
}
}
printf("I love you more than %d\n",n);
printf("I love you more than %d\n", n);
}
//指数递增型爱你
void loveYou2(int n){
int i=1;
while (i<=n){
printf("I love you %d\n",i);
i=i*2;
void loveYou2(int n) {
int i = 1;
while (i <= n) {
printf("I love you %d\n", i);
i = i * 2;
}
printf("I love you more than %d\n ",n);
printf("I love you more than %d\n ", n);
}
//搜索数字型爱你
void loveYou3(int flag[],int n){
void loveYou3(int flag[], int n) {
printf("I Am kim\n");
for (int i = 0; i < n; i++) {
//我觉这里应该是数组长度
if (flag[i]==n){
printf("I love you %d\n",n);
if (flag[i] == n) {
printf("I love you %d\n", n);
break;//找到之后就跳出循环
}
}
}
//递归型爱你
void loveYou4(int n){
int a,b,c;
if (n>1){
loveYou4(n-1);
void loveYou4(int n) {
int a, b, c;
if (n > 1) {
loveYou4(n - 1);
}
printf("I love you %d\n",n);
printf("I love you %d\n", n);
}//递归调用会带来多余的内存开销
/**实现模块**/
@@ -66,21 +68,20 @@ void loveYou4(int n){
/**测试模块**/
//测试函数
void Test(){
void testModule() {
LoveYou0(30);
loveYou1(30);
loveYou2(30);
int array[5]={2,10,100,1000,10000};
int array[5] = {2, 10, 100, 1000, 10000};
//声明一个数组并初始化
loveYou3(array,10);
loveYou3(array, 10);
loveYou4(4);
}
/**测试模块**/
int main(){
Test();
int main() {
testModule();
return 0;
}

163
DataStructure/DS_1_LinearList/DS_1_0_SqList.cpp
View File

@@ -8,63 +8,75 @@
/**定义模块**/
#include <stdio.h>
#define MaxSize 10
typedef struct {
int data[MaxSize];
int length;
}SqList;
} SqList;
//函数声明
void PrintSqList(SqList L);
void InitList(SqList &L); //初始化
bool Empty(SqList L); //判空
bool ListInsert(SqList &L, int i, int e); //插入
bool ListDelete(SqList &L, int i, int &e); //删除
int GetElem(SqList L, int i); //按位查找
int LocateElem(SqList L, int e); //按值查找
bool LocateChangeElem(SqList &L, int e, int em); //按值修改
bool getChangeElem(SqList &L, int i, int em); //按位修改
void PrintSqList(SqList L); //打印函数
void testModule(); //测试模块
/**定义模块**/
/**实现模块**/
//初始化
void InitList(SqList &L){
void InitList(SqList &L) {
for (int i = 0; i < MaxSize; i++) {
L.data[i]=0;//将所有元素的初始值默认设置为0
L.data[i] = 0;//将所有元素的初始值默认设置为0
//这一步其实可以省略，但是省略之后，有可能受到内存中"脏数据"的影响
}
L.length=0;
L.length = 0;
}
//判空
bool Empty(SqList L){
return (L.length==0);
bool Empty(SqList L) {
return (L.length == 0);
}
//插入
bool ListInsert(SqList &L,int i,int e){
bool ListInsert(SqList &L, int i, int e) {
//判断插入的位置是否合法，
if (i<1||i>L.length+1)
if (i < 1 || i > L.length + 1)
return false;
//判断表是否存满了
if (L.length>=MaxSize)
if (L.length >= MaxSize)
return false;
//后面的元素后移
for (int j = L.length; j >=i ; j--) {
L.data[j]=L.data[j-1];
for (int j = L.length; j >= i; j--) {
L.data[j] = L.data[j - 1];
}
L.data[i-1]=e;
L.data[i - 1] = e;
L.length++;
return true;
}
//删除
bool ListDelete(SqList &L,int i,int &e){
bool ListDelete(SqList &L, int i, int &e) {
//判断i的位置是否合法
if(i<0||i>L.length){
if (i < 0 || i > L.length) {
return false;
}
//取出将要被删除的数
e=L.data[i-1];
e = L.data[i - 1];
//将其后的数据前移
for (int j = i; j <=L.length ; j++) {
L.data[j-1]=L.data[j];
for (int j = i; j <= L.length; j++) {
L.data[j - 1] = L.data[j];
}
//线性表长度减一
L.length--;
@@ -73,19 +85,19 @@ bool ListDelete(SqList &L,int i,int &e){
//查找
//按位查找
int GetElem(SqList L,int i){
int GetElem(SqList L, int i) {
//判断是否越界
if (i<0||i>L.length)
if (i < 0 || i > L.length)
return -1;
return L.data[i-1];
return L.data[i - 1];
}
//按值查找
int LocateElem(SqList L,int e){
int LocateElem(SqList L, int e) {
//循环出查找
for (int i = 0; i <L.length ; i++) {
if (L.data[i]==e)
return i+1; //返回位序
for (int i = 0; i < L.length; i++) {
if (L.data[i] == e)
return i + 1; //返回位序
}
return -1;
}
@@ -94,50 +106,30 @@ int LocateElem(SqList L,int e){
//先查找后改值
//由此分为两种方式，先按位查找后改值；或先按值查找后改值
//先按值查找后改值
bool LocateChangeElem(SqList &L,int e,int em){
bool LocateChangeElem(SqList &L, int e, int em) {
//按值查找得到位序
int bitOrder =LocateElem(L,e);
int bitOrder = LocateElem(L, e);
//改值
if (bitOrder !=-1){
L.data[bitOrder]=em;
if (bitOrder != -1) {
L.data[bitOrder] = em;
return true;
} else{
} else {
return false;
}
}
//先按位序查找后改值
bool getChangeElem(SqList &L,int i,int em){
bool getChangeElem(SqList &L, int i, int em) {
//注意由于是改值涉及修改原数据，所以需要用引用传递的方式
//给的位序,首先判断i是否合法
if(i<0||i>=L.length)return false;
if (i < 0 || i >= L.length)return false;
//由于是用数组实现的方式，可以直接利用i查找
L.data[i]=em;
L.data[i] = em;
return true;
}
//Change Test
void ChangeTest(SqList &L,int e,int em1,int i, int em2){
//change 修改元数据用引用的方式
printf("开始测试【改】\n"
"第一种方式先按值查找后改值\n");
if (LocateChangeElem(L,e,em1)){
printf("第一种先按值查找后改值成功啦，改变后的值如下：\n");
PrintSqList(L);
} else{
printf("第一种先按值查找后改值失败了，再检查一下吧！\n");
}
printf("第二种先按位序查找后改值\n");
if (getChangeElem(L,i,em2)){
printf("第二种先按位序查找后改值的方式成功啦，改变后的值如下：\n");
PrintSqList(L);
} else{
printf("第二种先按位序查找后改值的方式失败了，再检查一下吧！\n");
}
}
//销毁
//由于静态分配方式是通过声明数组的方式实现的，故不需要手动销毁SqList表，在使用完成之后，系统会自动删除数据并回收数据空间
@@ -148,62 +140,85 @@ void ChangeTest(SqList &L,int e,int em1,int i, int em2){
//测试
//打印整个顺序表
void PrintSqList(SqList L){
void PrintSqList(SqList L) {
//循环打印
printf("开始打印顺序表\n");
for (int i = 0; i < L.length ; i++) {
printf("Data[%d]==%d\n",i,L.data[i]);
for (int i = 0; i < L.length; i++) {
printf("Data[%d]==%d\n", i, L.data[i]);
}
printf("打印结束！\n");
}
//测试函数
void Test(){
void testModule() {
SqList L;
InitList(L);
// 初试化一些值
L.data[0]=1;
L.data[1]=2;
L.data[2]=3;
L.length=3;
L.data[0] = 1;
L.data[1] = 2;
L.data[2] = 3;
L.length = 3;
//插入操作
if (ListInsert(L,2,3)){
if (ListInsert(L, 2, 3)) {
printf("插入成功了\n");
} else{
} else {
printf("插入失败了，i的位置不合法，请检查\n");
}
//删除操作
int e=-1;
if (ListDelete(L,2,e)){
printf("删除成功！删除的值是：%d\n",e);
} else{
int e = -1;
if (ListDelete(L, 2, e)) {
printf("删除成功！删除的值是：%d\n", e);
} else {
printf("删除失败，请检查位序是否正确\n");
}
//数组当前长度
printf("数组当前长度是多少？%d\n",L.length);
printf("数组当前长度是多少？%d\n", L.length);
//查找第一个元素是什么？
printf("第一个元素是什么？\n %d\n",GetElem(L,1));
printf("第一个元素是什么？\n %d\n", GetElem(L, 1));
//查找值为3的元素在什么位置
printf("第一个值为3的元素在什么位置？\n %d \n",LocateElem(L,3));
printf("第一个值为3的元素在什么位置？\n %d \n", LocateElem(L, 3));
//打印输出
PrintSqList(L);
//测试改模块功能是否正常
ChangeTest(L,2,6,1,7);
int e1 = 2;
int em1 = 6;
int i = 1;
int em2 = 7;
printf("开始测试【改】\n"
"第一种方式先按值查找后改值\n");
if (LocateChangeElem(L, e1, em1)) {
printf("第一种先按值查找后改值成功啦，改变后的值如下：\n");
PrintSqList(L);
} else {
printf("第一种先按值查找后改值失败了，再检查一下吧！\n");
}
printf("第二种先按位序查找后改值\n");
if (getChangeElem(L, i, em2)) {
printf("第二种先按位序查找后改值的方式成功啦，改变后的值如下：\n");
PrintSqList(L);
} else {
printf("第二种先按位序查找后改值的方式失败了，再检查一下吧！\n");
}
if (Empty(L)) {
printf("顺序表为空！\n");
} else {
printf("顺序表非空！\n");
}
//打印输出
PrintSqList(L);
}
/**测试模块**/
//主函数
int main(){
Test();
int main() {
testModule();
return 0;
}

131
DataStructure/DS_1_LinearList/DS_1_1_SqList.cpp
View File

@@ -15,7 +15,18 @@ typedef struct {
int *data; //指示动态分配数组的指针
int MaxSize;//顺序表的最大容量
int length;//顺序表当前的长度
}SeqList;
} SeqList;
//函数声明
bool InitList(SeqList &L); //初始化
bool Empty(SeqList L); //判空
bool Full(SeqList L); //判满
void IncreaseSize(SeqList &L, int len); //动态扩展空间
bool ListInsert(SeqList &L, int i, int e); //插入
int GetElem(SeqList L, int i); //按位查找
int LocateElem(SeqList L, int e); //按值查找
bool ListDelete(SeqList &L, int i, int &e); //删除
void DestroySqList(SeqList &L); //销毁
/**定义模块**/
@@ -23,47 +34,48 @@ typedef struct {
/**实现模块**/
//初始化
bool InitList(SeqList &L){
bool InitList(SeqList &L) {
//用 malloc 函数申请一片连续的存储空间
L.data=(int *)malloc(InitSize*sizeof(int));
if (L.data==NULL)
L.data = (int *) malloc(InitSize * sizeof(int));
if (L.data == NULL)
//要细心呀，这里不小心写成了赋值语句，但是没有报错，找了半天错误！
return false;
//(int *) 是指针的强制类型转换
L.length=0;
L.MaxSize=InitSize;
L.length = 0;
L.MaxSize = InitSize;
return true;
}
//判空
bool Empty(SeqList L){
return (L.length==0);
bool Empty(SeqList L) {
return (L.length == 0);
}
//判满
bool Full(SeqList L){
return (L.length>=L.MaxSize);
bool Full(SeqList L) {
return (L.length >= L.MaxSize);
}
//扩展空间
void IncreaseSize(SeqList &L,int len){
void IncreaseSize(SeqList &L, int len) {
printf("开始扩展表存储空间。。。\n");
int *p=L.data;
L.data=(int *)malloc((InitSize+len)*sizeof(int ));
int *p = L.data;
L.data = (int *) malloc((InitSize + len) * sizeof(int));
printf("开始复制转移数据。。。\n");
for (int i = 0; i < L.length; i++) {
L.data[i]=p[i];
L.data[i] = p[i];
}
printf("之前内存空间的长度是：%d\n",L.MaxSize);
L.MaxSize=L.MaxSize+len;
printf("之前内存空间的长度是：%d\n", L.MaxSize);
L.MaxSize = L.MaxSize + len;
free(p);
//malloc 函数用于申请内存空间；free 函数用于释放内存空间；
printf("现在的内存空间长度是%d\n",L.MaxSize);
printf("现在的内存空间长度是%d\n", L.MaxSize);
}
//插入
bool ListInsert(SeqList &L,int i,int e){
bool ListInsert(SeqList &L, int i, int e) {
//判断插入的位置是否合法，
if (i<1||i>L.length+1)
if (i < 1 || i > L.length + 1)
return false;
//判断表是否存满了
// if (L.length>=L.MaxSize)
@@ -72,43 +84,44 @@ bool ListInsert(SeqList &L,int i,int e){
return false;
//后面的元素后移
for (int j = L.length; j >=i ; j--) {
L.data[j]=L.data[j-1];
for (int j = L.length; j >= i; j--) {
L.data[j] = L.data[j - 1];
}
L.data[i-1]=e;
L.data[i - 1] = e;
L.length++;
return true;
}
//按位查找
int GetElem(SeqList L,int i){
int GetElem(SeqList L, int i) {
//判断是否越界
if (i<0||i>L.length)
if (i < 0 || i > L.length)
return -1;
return L.data[i-1];
return L.data[i - 1];
}
//按值查找
int LocateElem(SeqList L,int e){
int LocateElem(SeqList L, int e) {
//循环出查找
for (int i = 0; i <L.length ; i++) {
if (L.data[i]==e)
return i+1; //返回位序
for (int i = 0; i < L.length; i++) {
if (L.data[i] == e)
return i + 1; //返回位序
}
return -1;
}
//删除
bool ListDelete(SeqList &L,int i,int &e){
bool ListDelete(SeqList &L, int i, int &e) {
//判断i的位置是否合法
if(i<0||i>L.length){
if (i < 0 || i > L.length) {
return false;
}
//取出将要被删除的数
e=L.data[i-1];
e = L.data[i - 1];
//将其后的数据前移
for (int j = i; j <=L.length ; j++) {
L.data[j-1]=L.data[j];
for (int j = i; j <= L.length; j++) {
L.data[j - 1] = L.data[j];
}
//线性表长度减一
L.length--;
@@ -117,10 +130,10 @@ bool ListDelete(SeqList &L,int i,int &e){
//销毁
//由于动态分配方式使用malloc申请的内存空间，故需要使用free函数手动释放空间！
void DestroySqList(SeqList &L){
void DestroySqList(SeqList &L) {
free(L.data);
L.data=NULL;
L.length=0;
L.data = NULL;
L.length = 0;
}
/**实现模块**/
@@ -130,8 +143,8 @@ void DestroySqList(SeqList &L){
//测试
//打印整个顺序表
void PrintSqList(SeqList L){
if (L.data==NULL||L.length==0)
void PrintSqList(SeqList L) {
if (L.data == NULL || L.length == 0)
printf("这是一个空表！");
else {
//循环打印
@@ -144,29 +157,29 @@ void PrintSqList(SeqList L){
}
//测试输出
void TestPrint(bool test,char message[]){
if(test)
printf("%s成功啦!\n",message);
void TestPrint(bool test, char message[]) {
if (test)
printf("%s成功啦!\n", message);
else
printf("%s失败啦！\n",message);
printf("%s失败啦！\n", message);
}
void testModule(){
void testModule() {
SeqList L;
TestPrint(InitList(L),"初始化");
TestPrint(InitList(L), "初始化");
// 初试化一些值
L.data[0]=1;
L.data[1]=2;
L.data[2]=3;
L.length=3;
L.data[0] = 1;
L.data[1] = 2;
L.data[2] = 3;
L.length = 3;
PrintSqList(L);
//循环插入直到表满
int i=4;
int InsertValue=4;
while(L.length<L.MaxSize) {
int i = 4;
int InsertValue = 4;
while (L.length < L.MaxSize) {
TestPrint(ListInsert(L, i, InsertValue), "插入");
i++;
InsertValue++;
@@ -174,29 +187,29 @@ void testModule(){
PrintSqList(L);
//表满则扩展空间
if (Full(L))IncreaseSize(L,5);
if (Full(L))IncreaseSize(L, 5);
//按位查找
printf("第5个元素是%d\n",GetElem(L,5));
printf("第5个元素是%d\n", GetElem(L, 5));
//按值查找
printf("值为6的元素的位序是%d\n",LocateElem(L,6));
printf("值为6的元素的位序是%d\n", LocateElem(L, 6));
//删除
int e;
TestPrint(ListDelete(L,4,e),"删除");
printf("删除的元素是%d\n",e);
TestPrint(ListDelete(L, 4, e), "删除");
printf("删除的元素是%d\n", e);
PrintSqList(L);
//销毁
DestroySqList(L);
TestPrint(Empty(L),"删除");
TestPrint(Empty(L), "删除");
PrintSqList(L);
}
/**测试模块**/
int main(){
int main() {
testModule();
return 0;
}

132
DataStructure/DS_1_LinearList/DS_1_2_LinkList1.cpp
View File

@@ -10,98 +10,107 @@
/**定义模块**/
typedef struct LNode{
typedef struct LNode {
int data;
LNode *next;
}LNode,*LinkList;
} LNode, *LinkList;
//函数定义
bool InitList(LinkList &L); //初始化
bool Empty(LinkList L); //盘空
bool ListInsert(LinkList &L, int i, int e);//按位插入
bool InsertNextNode(LNode *p, int e);//指定节点的后插操作
bool InsertPriorNode(LNode *p, int e);//指定节点的前插操作————先完成后插，再交换数据以实现前插
bool ListDelete(LinkList &L, int i, int &e);//按指定位序删除节点并返回其值
bool DeleteNode(LNode *p);//删除指定节点
/**定义模块**/
/**实现模块**/
//初试化(带有头节点)
bool InitList(LinkList &L){
L=(LNode *)malloc(sizeof(LNode));//分配一个头节点
if (L==NULL)
bool InitList(LinkList &L) {
L = (LNode *) malloc(sizeof(LNode));//分配一个头节点
if (L == NULL)
return false;//头节点分配失败，可能是内存不足
L->next=NULL;//头节点之后暂时没有节点，头节点也不存放数据
L->next = NULL;//头节点之后暂时没有节点，头节点也不存放数据
return true;
}
//判空
bool Empty(LinkList L){
bool Empty(LinkList L) {
// if(L->next==NULL)
// return true;
// else
// return false;
return (L->next==NULL);
return (L->next == NULL);
}
//按位插入
bool ListInsert(LinkList &L,int i, int e){
if (i<1)return false;//判断位序i是否合法
bool ListInsert(LinkList &L, int i, int e) {
if (i < 1)return false;//判断位序i是否合法
LNode *p;//指针指向当前扫面到的节点
int j=0;//记录p指向的节点的位序
p=L;//L指向头节点，从头开始
while (p!=NULL&&j<i-1){
int j = 0;//记录p指向的节点的位序
p = L;//L指向头节点，从头开始
while (p != NULL && j < i - 1) {
//循环扫描
p=p->next;
p = p->next;
j++;
}
if (p==NULL) //i值超过来表长，不合法
if (p == NULL) //i值超过来表长，不合法
return false;
LNode *s=(LNode *)malloc(sizeof(LNode));
s->data=e;
LNode *s = (LNode *) malloc(sizeof(LNode));
s->data = e;
//下面的顺序不可交换
s->next=p->next;
p->next=s;
s->next = p->next;
p->next = s;
return true;
}
//指定节点的后插操作
bool InsertNextNode(LNode *p,int e){
if (p==NULL)
bool InsertNextNode(LNode *p, int e) {
if (p == NULL)
return false;//判断指定节点是否存在
LNode *s=(LNode *)malloc(sizeof(LNode));
if (s==NULL)return false;//分配内存失败
s->data=e;
s->next=p->next;
p->next=s;
LNode *s = (LNode *) malloc(sizeof(LNode));
if (s == NULL)return false;//分配内存失败
s->data = e;
s->next = p->next;
p->next = s;
return true;
}
//指定节点的前插操作
//先完成后插，再交换数据以实现前插
bool InsertPriorNode(LNode *p,int e){
if (p==NULL)return false;
LNode *s=(LNode *)malloc(sizeof(LNode));
if (s==NULL)return false;
s->next=p->next;
p->next=s;
s->data=p->data;
p->data=e;
bool InsertPriorNode(LNode *p, int e) {
if (p == NULL)return false;
LNode *s = (LNode *) malloc(sizeof(LNode));
if (s == NULL)return false;
s->next = p->next;
p->next = s;
s->data = p->data;
p->data = e;
return true;
}
//按指定位序删除节点并返回其值
bool ListDelete(LinkList &L,int i,int &e){
if (i<1)return false;
bool ListDelete(LinkList &L, int i, int &e) {
if (i < 1)return false;
LNode *p;
int j=0;
p=L;
while (p!=NULL&&j<i-1){
p=p->next;
int j = 0;
p = L;
while (p != NULL && j < i - 1) {
p = p->next;
j++;
}
LNode *q=p->next;
LNode *q = p->next;
e = q->data;
p->next=q->next;
p->next = q->next;
free(q);
return true;
}
//删除指定节点
bool DeleteNode(LNode *p){
bool DeleteNode(LNode *p) {
}
@@ -109,36 +118,41 @@ bool DeleteNode(LNode *p){
/**测试模块**/
//Test
void TestPrint(bool test,char about[]){
void TestPrint(bool test, char about[]) {
if (test)
printf("%s成功\n",about);
printf("%s成功\n", about);
else
printf("%s失败\n",about);
printf("%s失败\n", about);
}
void PrintList(LinkList L){
void PrintList(LinkList L) {
//循环打印整个链表
LNode *p=L->next;//扫描指针
int j=0;
if (p==NULL)printf("这是一个空表\n");
while (p!=NULL){
printf("LinkList[%d]=%d\n",j,p->data);
p=p->next;
LNode *p = L->next;//扫描指针
int j = 0;
if (p == NULL)printf("这是一个空表\n");
while (p != NULL) {
printf("LinkList[%d]=%d\n", j, p->data);
p = p->next;
j++;
}
}
/**测试模块**/
int main(){
void TestModule() {
LinkList L;
TestPrint(InitList(L),"初始化");
TestPrint(InitList(L), "初始化");
PrintList(L);
TestPrint(ListInsert(L,1,3),"按位插入");
TestPrint(ListInsert(L, 1, 3), "按位插入");
PrintList(L);
int e;
TestPrint(ListDelete(L,1,e),"删除");
TestPrint(ListDelete(L, 1, e), "删除");
PrintList(L);
printf("被删除的数据是：%d\n",e);
printf("被删除的数据是：%d\n", e);
}
/**测试模块**/
int main() {
TestModule();
return 0;
}

89
DataStructure/DS_1_LinearList/DS_1_3_LinkList.cpp
View File

@@ -9,10 +9,10 @@
#include <stdlib.h>
/**定义模块**/
typedef struct LNode{
typedef struct LNode {
int data;
struct LNode *next;
}LNode,*LinkList;
} LNode, *LinkList;
//等价于
//struct LNode{
// int data;
@@ -22,20 +22,25 @@ typedef struct LNode{
//typedef struct LNode LNode;
//typedef struct LNode *LinkList;
//函数声明
bool InitList(LinkList &L);//初始化
bool Empty(LinkList L);//判断是否为空
bool ListInsert(LinkList &L, int i, int e);//插入
/**定义模块**/
/**实现模块**/
//初始化
bool InitList(LinkList &L){
L=NULL;//空表暂时没有任何数据
bool InitList(LinkList &L) {
L = NULL;//空表暂时没有任何数据
return true;
}
//判断是否为空
bool Empty(LinkList L){
return (L==NULL);
bool Empty(LinkList L) {
return (L == NULL);
}
//等价于
//bool Empty1(LinkList L){
@@ -45,30 +50,31 @@ bool Empty(LinkList L){
// return false;
//}
bool ListInsert(LinkList &L,int i, int e){
if (i<1)return false;//判断位序i是否合法
bool ListInsert(LinkList &L, int i, int e) {
if (i < 1)return false;//判断位序i是否合法
//不带头节点时，插入位置正好为表头时，得单独处理
if (i=1){
LNode *s =(LNode *)malloc(sizeof(LNode));
s->data=e;
s->next=L;
L=s;
return true;}
if (i = 1) {
LNode *s = (LNode *) malloc(sizeof(LNode));
s->data = e;
s->next = L;
L = s;
return true;
}
LNode *p;//指针指向当前扫面到的节点
int j=0;//记录p指向的节点的位序
p=L;//L指向头节点，从头开始
while (p!=NULL&&j<i-1){
int j = 0;//记录p指向的节点的位序
p = L;//L指向头节点，从头开始
while (p != NULL && j < i - 1) {
//循环扫描
p=p->next;
p = p->next;
j++;
}
if (p==NULL) //i值超过来表长，不合法
if (p == NULL) //i值超过来表长，不合法
return false;
LNode *s=(LNode *)malloc(sizeof(LNode));
s->data=e;
LNode *s = (LNode *) malloc(sizeof(LNode));
s->data = e;
//下面的顺序不可交换
s->next=p->next;
p->next=s;
s->next = p->next;
p->next = s;
return true;
}
@@ -78,34 +84,37 @@ bool ListInsert(LinkList &L,int i, int e){
/**测试模块**/
//Test
void TestPrint(bool test,char about[]){
void TestPrint(bool test, char about[]) {
if (test)
printf("%s成功\n",about);
printf("%s成功\n", about);
else
printf("%s失败\n",about);
printf("%s失败\n", about);
}
void PrintList(LinkList L){
void PrintList(LinkList L) {
//循环打印整个链表
LNode *p=L;//扫描指针
int j=0;
if (p==NULL)printf("这是一个空表\n");
while (p!=NULL){
printf("LinkList[%d]=%d",j,p->data);
p=p->next;
LNode *p = L;//扫描指针
int j = 0;
if (p == NULL)printf("这是一个空表\n");
while (p != NULL) {
printf("LinkList[%d]=%d", j, p->data);
p = p->next;
j++;
}
}
void TestModule() {
LinkList L;
TestPrint(InitList(L), "初始化");
PrintList(L);
TestPrint(ListInsert(L, 1, 2), "按位插入");
PrintList(L);
}
/**测试模块**/
int main(){
LinkList L;
TestPrint(InitList(L),"初始化");
PrintList(L);
TestPrint(ListInsert(L,1,2),"按位插入");
PrintList(L);
int main() {
TestModule();
return 0;
}

108
DataStructure/DS_1_LinearList/DS_1_4_DLinkList.cpp
View File

@@ -10,88 +10,97 @@
/**定义模块**/
typedef struct DNode{
typedef struct DNode {
int data;//数据域
struct DNode *prior,*next;//前指针和后指针
}DNode,*DLinkList;
struct DNode *prior, *next;//前指针和后指针
} DNode, *DLinkList;
//函数声明
bool InitDLinkList(DLinkList &L);//初始化
bool Empty(DLinkList L);//判空
bool InsertNextElem(DNode *p, DNode *s);//指定节点的后插操作
bool DeleteNextNode(DNode *p);//删除P节点的后继节点
bool DestroyList(DLinkList &L);//销毁整个表
bool PrintNextElems(DNode *p);//从P点向后遍历
bool PrintPriorElems(DNode *p);//从P点向前遍历
bool PrintPriorElemsOverHead(DNode *p);//从P点向前遍历（跳过头节点）
/**定义模块**/
/**实现模块**/
//初始化
bool InitDLinkList(DLinkList &L){
L = (DNode *)malloc(sizeof(DNode));//分配一个头节点
if (L==NULL)
bool InitDLinkList(DLinkList &L) {
L = (DNode *) malloc(sizeof(DNode));//分配一个头节点
if (L == NULL)
return false;
L->prior==NULL;//头节点前后指针都指向空
L->next==NULL;
L->prior == NULL;//头节点前后指针都指向空
L->next == NULL;
return true;
}
//判空
bool Empty(DLinkList L){
return (L->next==NULL);
bool Empty(DLinkList L) {
return (L->next == NULL);
}
//指定节点的后插操作
bool InsertNextElem(DNode *p,DNode *s){
bool InsertNextElem(DNode *p, DNode *s) {
//注意顺序不可交换
s->next=p->next;
p->next->prior=s;
s->prior=p;
p->next=s;
s->next = p->next;
p->next->prior = s;
s->prior = p;
p->next = s;
}
//删除P节点的后继节点
bool DeletNextNode(DNode *p){
if(p == NULL)return false;//p节点为空
DNode *q=p->next;
if (q==NULL)return false;//P节点没有后继
p->next=q->next;
if (q->next!=NULL)//q不是最后一个节点
q->next->prior=p;
bool DeleteNextNode(DNode *p) {
if (p == NULL)return false;//p节点为空
DNode *q = p->next;
if (q == NULL)return false;//P节点没有后继
p->next = q->next;
if (q->next != NULL)//q不是最后一个节点
q->next->prior = p;
free(q);//手动释放内存空间
return true;
}
//销毁整个表
bool DestoryList(DLinkList &L){
bool DestroyList(DLinkList &L) {
//循环删除并释放每个节点
while (L->next!=NULL)
DeletNextNode(L);
while (L->next != NULL)
DeleteNextNode(L);
free(L);//释放头节点
L=NULL;//头指针指向NULL
L = NULL;//头指针指向NULL
}
//从P点向后遍历
bool PrintNextElems(DNode *p){
if (p==NULL)return false;//
while (p!=NULL){
printf("当前节点的值是:%d",p->data);
p=p->next;
bool PrintNextElems(DNode *p) {
if (p == NULL)return false;//
while (p != NULL) {
printf("当前节点的值是:%d", p->data);
p = p->next;
}
return true;
}
//从P点向前遍历
bool PrintPriorElems(DNode *p){
if (p==NULL)return false;//
while (p!=NULL){
printf("当前节点的值是:%d",p->data);
p=p->prior;
bool PrintPriorElems(DNode *p) {
if (p == NULL)return false;//
while (p != NULL) {
printf("当前节点的值是:%d", p->data);
p = p->prior;
}
return true;
}
//从P点向前遍历（跳过头节点）
bool PrintPriorElemsOverHead(DNode *p){
if (p==NULL)return false;//
while (p->prior!=NULL){
printf("当前节点的值是:%d",p->data);
p=p->prior;
bool PrintPriorElemsOverHead(DNode *p) {
if (p == NULL)return false;//
while (p->prior != NULL) {
printf("当前节点的值是:%d", p->data);
p = p->prior;
}
return true;
}
@@ -102,18 +111,21 @@ bool PrintPriorElemsOverHead(DNode *p){
/**测试模块**/
//测试函数
void TestPrint(bool test,char message[]){
void TestPrint(bool test, char message[]) {
if (test)
printf("%s成功啦！\n",message);
printf("%s成功啦！\n", message);
else
printf("%s失败啦！\n",message);
printf("%s失败啦！\n", message);
}
void TestModule() {
DLinkList L;
TestPrint(InitDLinkList(L), "初始化");
}
/**测试模块**/
int main(){
DLinkList L;
TestPrint(InitDLinkList(L),"初始化");
int main() {
TestModule();
return 0;
}

8
DataStructure/DS_1_LinearList/DS_1_5_RLinkList.cpp
View File

@@ -14,6 +14,10 @@ typedef struct LNode{
struct LNode *next;
}LNode,*LinkList;
//函数声明
bool InitRLinkList(LinkList &L);//初始化
bool IsTail(LinkList L,LNode *p);//判断P是不是表尾指针
/**定义模块**/
/**实现模块**/
@@ -35,11 +39,13 @@ bool IsTail(LinkList L,LNode *p){
/**实现模块**/
/**测试模块**/
void TestModule(){
}
/**测试模块**/
int main(){
TestModule();
return 0;
}

11
DataStructure/DS_1_LinearList/DS_1_6_RDLinkList.cpp
View File

@@ -14,6 +14,12 @@ typedef struct DNode{
struct DNode *prior,*next;
}DNode,*DLinkList;
//函数声明
bool InitRDLinkList(DLinkList &L);//初始化
bool iTail(DLinkList L,DNode *p);//判断节点p是不是循环双链表的表尾节点
bool InsertNextDNode(DNode *p,DNode *s);//在p节点之后插入s节点
bool DeleteNextDNode(DLinkList &L,DNode *p);//删除操作
/**定义模块**/
/**实现模块**/
@@ -52,12 +58,13 @@ bool DeleteNextDNode(DLinkList &L,DNode *p){
/**实现模块**/
/**测试模块**/
void TestModule(){
}
/**测试模块**/
int main(){
TestModule();
return 0;
}

6
DataStructure/DS_1_LinearList/DS_1_7_SLinkList.cpp
View File

@@ -23,6 +23,8 @@ typedef struct Node{
}SLinkList[MaxSize];
//相比之下，第二种方法可读性更强！，推荐
//函数声明
/**定义模块**/
/**实现模块**/
@@ -39,13 +41,15 @@ void TestSLinkList(){
/**实现模块**/
/**测试模块**/
void TestModule(){
}
/**测试模块**/
int main(){
//后续来填坑吧！！
TestModule();
return 0;
}

17
DataStructure/DS_1_LinearList/README_SMMS.md
View File

@@ -1,17 +0,0 @@
# 线性表
## 笔记目录
* [线性表](Doc_1_0_线性表.md)
* [顺序表](Doc_1_1_顺序表.md)
* [单链表](Doc_1_2_单链表.md)
* [双链表](Doc_1_3_双链表.md)
* [循环链表](Doc_1_4_循环链表.md)
* [静态链表](Doc_1_5_静态链表.md)
* [章节总结](Doc_1_6_章节总结.md)
* [错题总结](Doc_1_7错题总结.md)
## 课件目录

12
DataStructure/DS_2_StackAndQueue/DS_2_0_SqStack.cpp
View File

@@ -14,6 +14,18 @@ typedef struct {
int top;
} SqStack;
//函数声明
void InitStack(SqStack &S);//初始化
bool Push(SqStack &S, int t);//入栈
bool Pop(SqStack &S, int &x);//出栈,并打印出栈顶元素
bool GetTop(SqStack S, int &x);//读取栈顶元素
int GetTopOther(SqStack S);//读取栈顶元素的第二种实现方式
void InitStack1(SqStack &S);//初始化1
bool Push1(SqStack &S, int t);//入栈，初始化1
bool Pop1(SqStack &S, int &x);//出栈,并打印出栈顶元素，初始化1
bool GetTop1(SqStack S, int &x);//读取栈顶元素，初始化1
int GetTopOther1(SqStack S);//读取栈顶元素的第二种实现方式
/**定义模块**/
/**实现模块**/

9
DataStructure/DS_2_StackAndQueue/DS_2_1_ShStack.cpp
View File

@@ -15,6 +15,15 @@ typedef struct {
int top1;
} ShStack;
//从结构体的定义就可以看出来，两个共享栈的根源就在于定义两个指针
//函数声明
void InitStack(ShStack &S);//初始化
bool Push0(ShStack &S, int t);//入栈0
bool Push1(ShStack &S, int t);//入栈1
bool Pop0(ShStack &S, int &x);//出栈,并打印出栈顶元素
bool Pop1(ShStack &S, int &x);//出栈1
bool GetTop0(ShStack S, int &x);//读取栈顶元素，栈0
bool GetTop1(ShStack S, int &x);//栈1
/**定义模块**/
/**实现模块**/

16
DataStructure/DS_2_StackAndQueue/DS_2_2_LiStack.cpp
View File

@@ -13,11 +13,17 @@ typedef struct LinkNode {
int data;
struct LinkNode *next;
} *LinkStack;
//从结构体的定义就可以看出来，两个共享栈的根源就在于定义两个指针
//函数声明
bool InitStack(LinkStack &LS);//初始化
bool Push(LinkStack &LS, int t);//入栈 参考头插法建立单链表
bool Pop(LinkStack &LS, int &x);//出栈,并打印出栈顶元素
bool GetTop(LinkStack LS, int &x);//读取栈顶元素，栈
/**定义模块**/
/**实现模块**/
//初始化
bool InitStack(LinkStack &LS) {
LS = (LinkNode *) malloc(sizeof(LinkNode));//分配一个头节点
if (LS == NULL) {
@@ -27,7 +33,6 @@ bool InitStack(LinkStack &LS) {
return true;
}
//入栈 参考头插法建立单链表
bool Push(LinkStack &LS, int t) {
//入站不需要检查
LinkNode *s = (LinkNode *) malloc(sizeof(LinkNode));
@@ -38,8 +43,6 @@ bool Push(LinkStack &LS, int t) {
return true;
}
//出栈,并打印出栈顶元素
bool Pop(LinkStack &LS, int &x) {
//判断
if (LS->next == NULL)return false;//栈空,这里的条件
@@ -51,13 +54,12 @@ bool Pop(LinkStack &LS, int &x) {
return true;
}
//读取栈顶元素，栈
bool GetTop(LinkStack LS, int &x) {
if (LS == NULL)return false;
x = LS->next->data;
return true;
}
/**实现模块**/
/**测试模块**/

16
DataStructure/DS_2_StackAndQueue/DS_2_3_SqQueue0.cpp
View File

@@ -14,15 +14,23 @@ typedef struct {
int data[MaxSize];//
int front, rear;//对头指针和队尾指针
} SqQueue;
//函数声明
void InitQueue(SqQueue &Q);//初始化
bool QueueEmpty(SqQueue Q);//判空
bool EnQueue(SqQueue &Q, int t);//入队操作
bool DeQueue(SqQueue &Q, int &x);//出队操作
bool GetHead(SqQueue Q, int &x);//获取队头元素,用x返回
/**定义模块**/
/**实现模块**/
//初始化
void InitQueue(SqQueue &Q) {
Q.rear = Q.front = 0;//初始化时，队头队尾都指向0
}
//判空
bool QueueEmpty(SqQueue Q) {
if (Q.front == Q.rear)
return true;
@@ -30,7 +38,6 @@ bool QueueEmpty(SqQueue Q) {
return true;
}
//入队操作
bool EnQueue(SqQueue &Q, int t) {
if ((Q.rear + 1) % MaxSize == Q.front)return false;//队满，注意这里的判满条件
//这里的判满条件会造成浪费一个存储空间的问题
@@ -39,7 +46,6 @@ bool EnQueue(SqQueue &Q, int t) {
return true;
}
//出队操作
bool DeQueue(SqQueue &Q, int &x) {
if (Q.rear == Q.front)return false;//队空
x = Q.data[Q.front];
@@ -47,12 +53,12 @@ bool DeQueue(SqQueue &Q, int &x) {
return true;
}
//获取队头元素,用x返回
bool GetHead(SqQueue Q, int &x) {
if (Q.front == Q.rear)return false;
x = Q.data[Q.front];
return true;
}
/**实现模块**/
/**测试模块**/

12
DataStructure/DS_2_StackAndQueue/DS_2_4_SqQueue1.cpp
View File

@@ -15,16 +15,21 @@ typedef struct {
int front, rear;//对头指针和队尾指针
int size;//利用size变量记录队列长度，并用作判满的条件！有了size就不会浪费一个存储空间
} SqQueue;
//函数声明
void InitQueue(SqQueue &Q);//初始化
bool QueueEmpty(SqQueue Q);//判空
bool EnQueue(SqQueue &Q, int t);//入队操作
bool DeQueue(SqQueue &Q, int &x);//出队操作
bool GetHead(SqQueue Q, int &x);//获取队头元素,用x返回
/**定义模块**/
/**实现模块**/
//初始化
void InitQueue(SqQueue &Q) {
Q.rear = Q.front = 0;//初始化时，队头队尾都指向0
Q.size = 0;//初试长度
}
//判空
bool QueueEmpty(SqQueue Q) {
if (Q.size == 0)//有了size，条件不一样了
return true;
@@ -32,7 +37,6 @@ bool QueueEmpty(SqQueue Q) {
return true;
}
//入队操作
bool EnQueue(SqQueue &Q, int t) {
if (Q.size == MaxSize)return false;//队满，注意这里的判满条件
Q.data[Q.rear] = t;
@@ -41,7 +45,6 @@ bool EnQueue(SqQueue &Q, int t) {
return true;
}
//出队操作
bool DeQueue(SqQueue &Q, int &x) {
if (Q.size == 0)return false;//队空
x = Q.data[Q.front];
@@ -50,7 +53,6 @@ bool DeQueue(SqQueue &Q, int &x) {
return true;
}
//获取队头元素,用x返回
bool GetHead(SqQueue Q, int &x) {
if (Q.size == 0)return false;
x = Q.data[Q.front];

25
DataStructure/DS_2_StackAndQueue/DS_2_5_SqQueue2.cpp
View File

@@ -15,25 +15,31 @@ typedef struct {
int front,rear;//对头指针和队尾指针
int tag;//利用tag变量记录最后一次操作是什么，0为删除，1为插入,并用作判满的条件！有了tag就不会浪费一个存储空间
}SqQueue;
//函数声明
void InitQueue(SqQueue &Q);//初始化
bool QueueEmpty(SqQueue Q);//判空
bool EnQueue(SqQueue &Q,int t);//入队操作
bool DeQueue(SqQueue &Q,int &x);//出队操作
bool GetHead(SqQueue Q,int &x);//获取队头元素,用x返回
/**定义模块**/
/**实现模块**/
//初始化
void InitQueue(SqQueue &Q){
void InitQueue(SqQueue &Q) {
Q.rear=Q.front=0;//初始化时，队头队尾都指向0
Q.tag=0;//初始化最后一次的操作状态
}
//判空
bool QueueEmpty(SqQueue Q){
bool QueueEmpty(SqQueue Q) {
if(Q.front==Q.rear&&Q.tag==0)//有了tag，条件不一样了
return true;
else
return true;
}
//入队操作
bool EnQueue(SqQueue &Q,int t){
bool EnQueue(SqQueue &Q, int t) {
if(Q.front==Q.rear&&Q.tag==1)return false;//队满，注意这里的判满条件
Q.data[Q.rear]=t;
Q.rear=(Q.rear+1)%MaxSize;//通过取余操作让整个队列循环起来
@@ -41,16 +47,15 @@ bool EnQueue(SqQueue &Q,int t){
return true;
}
//出队操作
bool DeQueue(SqQueue &Q,int &x){
bool DeQueue(SqQueue &Q, int &x) {
if(Q.rear==Q.front&&Q.tag==0)return false;//队空
x=Q.data[Q.front];
Q.front=(Q.front+1)%MaxSize;
Q.tag==0;
return true;
}
//获取队头元素,用x返回
bool GetHead(SqQueue Q,int &x){
bool GetHead(SqQueue Q, int &x) {
if (Q.rear==Q.front&&Q.tag==0)return false;
x=Q.data[Q.front];
return true;

12
DataStructure/DS_2_StackAndQueue/DS_2_6_LiQueue0.cpp
View File

@@ -17,6 +17,13 @@ typedef struct LinkNode {
typedef struct {
LinkNode *front, *rear;
} LinkQueue;
//函数声明
void InitQueue(LinkQueue &Q);//初始化
bool EnQueue(LinkQueue &Q, int x);//入队操作
bool DeQueue(LinkQueue &Q, int &x);//出队
bool GetHead(LinkQueue Q, int &x);//获取头元素
bool QueueEmpty(LinkQueue Q);//判空
/**定义模块**/
/**实现模块**/
@@ -26,7 +33,6 @@ void InitQueue(LinkQueue &Q) {
Q.front->next = NULL;
}
//入队操作
bool EnQueue(LinkQueue &Q, int x) {
//判满？链式存储一般不需要判满，除非内存不足
LinkNode *s = (LinkNode *) malloc(sizeof(LinkNode));
@@ -38,7 +44,6 @@ bool EnQueue(LinkQueue &Q, int x) {
return true;
}
//出队
bool DeQueue(LinkQueue &Q, int &x) {
if (Q.front == Q.rear)return false;//队空
LinkNode *p = Q.front->next;//用指针p记录队头元素
@@ -55,7 +60,8 @@ bool GetHead(LinkQueue Q, int &x) {
x = Q.front->next->data;//用x变量返回队头元素
return true;
}
bool QueueEmpty(LinkQueue Q){
bool QueueEmpty(LinkQueue Q) {
return Q.front==Q.rear? true: false;
}
/**实现模块**/

17
DataStructure/DS_2_StackAndQueue/DS_2_7_LiQueue1.cpp
View File

@@ -18,6 +18,13 @@ typedef struct LinkNode {
typedef struct {
LinkNode *front, *rear;
} LinkQueue;
//函数声明
void InitQueue(LinkQueue &Q);//初始化
bool EnQueue(LinkQueue &Q, int x);//入队操作
bool DeQueue(LinkQueue &Q, int &x);//出队
bool GetHead(LinkQueue Q, int &x);//获取队头元素
bool QueueEmpty(LinkQueue Q);//判空
/**定义模块**/
/**实现模块**/
@@ -26,15 +33,6 @@ void InitQueue(LinkQueue &Q) {
//不带头点，初始化时，front 、rear 指向NULL
}
//判空
bool IsEmpty(LinkQueue Q) {
if (Q.front == Q.rear)
return true;
else
return false;
}
//入队操作
bool EnQueue(LinkQueue &Q, int x) {
//判满？链式存储一般不需要判满，除非内存不足
LinkNode *s = (LinkNode *) malloc(sizeof(LinkNode));
@@ -52,7 +50,6 @@ bool EnQueue(LinkQueue &Q, int x) {
return true;
}
//出队
bool DeQueue(LinkQueue &Q, int &x) {
if (Q.front == NULL&&Q.rear==NULL)return false;//队空
LinkNode *p = Q.front;//用指针p记录队头元素

25
DataStructure/DS_2_StackAndQueue/DS_2_8_QueueApplication.cpp
View File

@@ -3,7 +3,7 @@
// Copyright (c) Kim Yang All rights reserved.
//
//栈的应用
//栈的应用——扩号匹配问题
#include <stdio.h>
@@ -13,16 +13,23 @@ typedef struct {
char data[MaxSize];
int top;
} SqStack;
//函数声明
//以下都是基础操作定义以及实现的方式和前面一样
void InitStack(SqStack &S);//初始化
bool Push(SqStack &S, char t);//入栈
bool Pop(SqStack &S, char &x);//出栈,并打印出栈顶元素
bool StackEmpty (SqStack S);//判栈空
//以上都是基础操作定义以及实现的方式和前面一样
//括号匹配问题
bool bracketCheck(char str[],int length);
/**定义模块**/
/**实现模块**/
/**以下都是基础操作定义以及实现的方式和前面一样**/
//初始化
void InitStack(SqStack &S) {
S.top = -1;//这种初始化的方式，栈顶指针始终指向栈顶元素
}
//入栈
bool Push(SqStack &S, char t) {
if (S.top == MaxSize - 1)return false;//栈满
S.data[++S.top] = t;
@@ -32,7 +39,6 @@ bool Push(SqStack &S, char t) {
return true;
}
//出栈,并打印出栈顶元素
bool Pop(SqStack &S, char &x) {
//判断
if (S.top == -1)return false;//栈空报错
@@ -43,15 +49,11 @@ bool Pop(SqStack &S, char &x) {
return true;
}
//读取栈顶元素
bool StackEmpty (SqStack S) {
bool StackEmpty(SqStack S) {
return S.top==-1;
}
/**以上都是基础操作定义以及实现的方式和前面一样**/
bool bracketCheck(char str[],int length){
bool bracketCheck(char *str, int length) {
SqStack S;
InitStack(S);
for (int i = 0; i <length ; i++) {
@@ -72,6 +74,7 @@ bool bracketCheck(char str[],int length){
}
return StackEmpty(S);//最后检查栈，若空匹配成功，非空匹配失败
}
/**实现模块**/
/**测试模块**/