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

🐛 fix SQlist

Browse Source
This commit is contained in:
Kim Yang
2020-08-15 22:57:22 +08:00
parent 7793374ac6
commit 3c7a3c17f4
3 changed files with 129 additions and 105 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;
}

160
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 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,82 @@ 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;
}

11
DataStructure/DS_1_LinearList/DS_1_1_SqList.cpp
View File

@@ -17,6 +17,17 @@ typedef struct {
int length;//顺序表当前的长度
}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);//销毁
/**定义模块**/