├── 栈 ├── README.md ├── 链栈——课上练.h └── seqlist.h ├── 树 ├── README.md ├── bitree_1.cpp ├── bitree_4.cpp ├── bitree_2.cpp ├── bitree_3.cpp ├── 二叉排序树——课后练.h └── 二叉树——课上练（顺序存储结构）.h ├── 线性表 ├── README.md ├── 循环链表和双向链表—课上课后练-1.h ├── 循环链表和双向链表—课上课后练-2.h ├── 链表.h └── 顺序表.h ├── hash ├── README.md ├── main.cpp └── hash.h ├── 交换排序 ├── README.md ├── 课本快排.c └── 优化冒泡.c ├── 实验 ├── README.md ├── 树实验2.cpp ├── 树实验1.cpp ├── 链表大数相加.h ├── 顺序表.h ├── 队列.cpp ├── huffman.cpp ├── 一元多项式相加.h ├── 链表集合.h ├── stack.h └── graph.h ├── 图 ├── 要用边长的题目，请换第二个scanf └── 图.h ├── README.md ├── 查找 ├── 1.c ├── 3.c └── 2.c ├── 暑期 ├── 暑期1-循环程序设计-3.cpp ├── 暑期2-查找入门-3.cpp ├── 暑期2-查找入门-1.cpp ├── 暑期1-循环程序设计-2.cpp ├── 暑期1-循环程序设计-1.cpp ├── 暑期2-查找入门-2.cpp ├── 线性表综合应用实践-1.cpp ├── 线性表综合应用实践-2.cpp ├── 线性表综合应用实践-3.cpp ├── 暑期3-链表入门.h └── 暑期4-排序.h ├── 选择排序 ├── 1.c └── 2.c ├── 队列 ├── 链队——课上练.h └── 队列——课上练.h ├── 集合 └── 集合——课上练.h └── 插入排序 └── 1-4.c /栈/README.md: -------------------------------------------------------------------------------- 1 | # 栈 2 | -------------------------------------------------------------------------------- /树/README.md: -------------------------------------------------------------------------------- 1 | # 树 2 | -------------------------------------------------------------------------------- /线性表/README.md: -------------------------------------------------------------------------------- 1 | # 线性表 2 | -------------------------------------------------------------------------------- /hash/README.md: -------------------------------------------------------------------------------- 1 | ### 哈希表 2 | -------------------------------------------------------------------------------- /交换排序/README.md: -------------------------------------------------------------------------------- 1 | # 交换排序 2 | -------------------------------------------------------------------------------- /实验/README.md: -------------------------------------------------------------------------------- 1 | # 实验相关代码 2 | -------------------------------------------------------------------------------- /图/要用边长的题目，请换第二个scanf: -------------------------------------------------------------------------------- 1 | 在120行处 2 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Code-work 2 | Data Struct 3 | 4 | GUET数据结构与算法课的一些头歌作业 5 | 6 | `.h后缀文件是头文件，像普通代码文件打开即可，也可以直接引入。` 7 | 8 | --------------------- 9 | 10 | ## 2022.11.29 11 | 12 | `未知力量修正了错误，并且使其更加强大了(雾)` 13 | -------------------------------------------------------------------------------- /hash/main.cpp: -------------------------------------------------------------------------------- 1 | #include "hash.h" 2 | //输入 7 8 30 11 18 9 14 3 | //输出 7 14 -1 8 -1 11 30 18 9 -1 4 | int main( ) 5 | { 6 | struct hashTable *h = initHashTable_linear(); 7 | int key; 8 | for(int i=0;i<10;i++) 9 | { 10 | scanf("%d",&key); 11 | insertKey(h,key); 12 | } 13 | printHashTable(h); 14 | } 15 | -------------------------------------------------------------------------------- /查找/1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int find_pos(int data[] ,int n, int key) 4 | {//在数组data中查找给定数据key,n表示数组中数据元素的个数 5 | /*------------begin-----------------*/ 6 | for (int i = 0; i < n; i ++) 7 | if (data[i] == key) 8 | return i; 9 | return -1; 10 | /*------------end-----------------*/ 11 | } 12 | 13 | int main(void) 14 | { 15 | int a[]={99,23,5,189,-1,66}; 16 | int x; 17 | scanf("%d",&x); 18 | //此处填写代码，调用find_pos，在a数组中查找给定数据x的位置，并输出函数返回的数据元素的位置 19 | /*------------begin-----------------*/ 20 | printf("%d", find_pos(a, 6, x)); 21 | /*------------end-----------------*/ 22 | 23 | return 1; 24 | } 25 | 26 | -------------------------------------------------------------------------------- /暑期/暑期1-循环程序设计-3.cpp: -------------------------------------------------------------------------------- 1 | //包含必要的头文件 2 | #include 3 | 4 | using namespace std; 5 | 6 | 7 | //根据main程序的提示，此处输入代码，设计一个能输出参数n项斐波那契数列，两个数之间有一个空格，最后一个数后面不需要空格 8 | /*-----begin---------*/ 9 | void fib(int x){ 10 | int pre = 0, now = 1; 11 | 12 | 13 | for (int i = 0 ; i < x ; i ++){ 14 | if (i) cout << ' '; 15 | cout << now; 16 | swap(pre, now); 17 | now = pre + now; 18 | } 19 | } 20 | 21 | 22 | /*-----end---------*/ 23 | 24 | 25 | 26 | int main(void) 27 | { 28 | int i; 29 | cin>>i; 30 | fib(i); 31 | return 1; 32 | } 33 | -------------------------------------------------------------------------------- /暑期/暑期2-查找入门-3.cpp: -------------------------------------------------------------------------------- 1 | //包含必要的头文件 2 | #include 3 | 4 | using namespace std; 5 | 6 | void compute(int data[],int n, int target) 7 | {//在此处填写代码，在data数组中查找是否存在两个元素之和为target，并按要求输出 8 | /*-----------begin---------------*/ 9 | for (int i = 0; i < n - 1 ; i ++) 10 | for (int j = i + 1; j < n; j ++) 11 | if (data[i] + data[j] == target){ 12 | cout << i << ',' << j << endl; 13 | return ; 14 | } 15 | 16 | puts("-1,-1"); 17 | /*-----------end---------------*/ 18 | 19 | } 20 | 21 | int main(void) 22 | { 23 | int a[]={-3,2,5,9,15,32}; 24 | int x ; 25 | cin>>x; 26 | compute(a,6,x); 27 | } 28 | -------------------------------------------------------------------------------- /暑期/暑期2-查找入门-1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | 5 | int find_pos(int data[] ,int n, int key) 6 | {//在数组data中查找给定数据key,n表示数组中数据元素的个数 7 | /*------------begin-----------------*/ 8 | for (int i = 0 ; i < n ; i ++){ 9 | if (data[i] == key) return i; 10 | } 11 | return -1; 12 | /*------------end-----------------*/ 13 | } 14 | 15 | int main(void) 16 | { 17 | int a[]={99,23,5,189,-1,66}; 18 | int x; 19 | cin>>x; 20 | //此处填写代码，调用find_pos，在a数组中查找给定数据x的位置，并输出函数返回的数据元素的位置 21 | /*------------begin-----------------*/ 22 | cout << find_pos(a, 6, x) << endl; 23 | /*------------end-----------------*/ 24 | 25 | return 1; 26 | } 27 | -------------------------------------------------------------------------------- /暑期/暑期1-循环程序设计-2.cpp: -------------------------------------------------------------------------------- 1 | //包含必要的头文件 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace std; 8 | 9 | bool judge(string data) 10 | { 11 | //请在此填写函数，用户判断data是否是回文，若是回文，返回true，否则返回false 12 | /*------begin--------*/ 13 | string tmp = data; 14 | reverse(tmp.begin(), tmp.end()); 15 | 16 | return tmp == data; 17 | 18 | /*------end--------*/ 19 | } 20 | 21 | int main(void) 22 | { 23 | string x; 24 | //请在此书写代码，从键盘读入一个字符串放入变量x 25 | cin >> x; 26 | if (judge(x)) puts("true"); 27 | else puts("false"); 28 | //在此书写代码，输出调用函数judge的结果 29 | 30 | 31 | return 1; 32 | } 33 | -------------------------------------------------------------------------------- /暑期/暑期1-循环程序设计-1.cpp: -------------------------------------------------------------------------------- 1 | //头文件自己根据需要包含 2 | #循环链表和双向链表—课上课后练include 3 | #include 4 | 5 | 6 | using namespace std; 7 | 8 | //请阅读main程序，判断并在此设计函数，实现将参数data的值反转，并返回反转后的结果 9 | /*---------begin------------*/ 10 | string reverse(int x){ 11 | string res; 12 | bool flag = false; 13 | if (x < 0) flag = true, x *= -1; 14 | while (x > 0){ 15 | res += (x % 10) + '0'; 16 | x /= 10; 17 | } 18 | 19 | while(res[0]=='0' && res.size() > 0 ) res.erase(res.begin()); 20 | 21 | res = flag ? ("-" + res) : res; 22 | return res; 23 | } 24 | /*---------end------------*/ 25 | 26 | /*---------end------------*/ 27 | 28 | 29 | 30 | //下面的main函数请勿修改 31 | int main(void) 32 | { 33 | int x ; 34 | cin>>x; 35 | cout< 2 | #define MIN(A, B) (a[(A)]<=a[(B)]?(A):(B)) 3 | #define SWAP(A, B) ((A)^=(B), (B)^=(A), (A)^=(B)) 4 | void print(int a[] ,int n) 5 | {//输出数组元素，数字之间以一个空格为界，输出结束后换一行 6 | for (int i = 0; i < n ;i ++) 7 | printf("%d ", a[i]); 8 | puts(""); 9 | 10 | } 11 | 12 | void selectSort(int a[] ,int n) //对数组a中的n个元素进行排序，调用print函数输出每趟排序后的结果 13 | { 14 | for (int i = 0; i < n - 1; i ++){ 15 | int min = i; 16 | for (int j = i + 1; j < n ; j ++) 17 | min = MIN(min, j); 18 | 19 | i != min && SWAP(a[i], a[min]); 20 | print(a, n); 21 | } 22 | 23 | 24 | } 25 | 26 | 27 | int main(void) 28 | { 29 | int num ; 30 | scanf("%d",&num); 31 | int data[num]; 32 | for(int i=0;i 2 | void compute(int data[],int n, int target) 3 | {//在此处填写代码，在data数组中查找是否存在两个元素之和为target，并按要求输出 4 | /*-----------begin---------------*/ 5 | for (int i = 0; i < n; i ++) 6 | { 7 | int x = target - data[i]; 8 | int l = 0, r = n - 1; 9 | 10 | while(l < r){ 11 | int mid = l + r >> 1; 12 | if (data[mid] >= x) r = mid; 13 | else l = mid + 1; 14 | 15 | } 16 | if (l != i && data[l] == x){ 17 | printf("%d,%d", i, l); 18 | return; 19 | } 20 | } 21 | 22 | puts("-1,-1"); 23 | return ; 24 | /*-----------end---------------*/ 25 | 26 | } 27 | 28 | int main(void) 29 | { 30 | int a[]={-3,2,5,9,15,32}; 31 | int x ; 32 | scanf("%d",&x); 33 | compute(a,6,x); 34 | } 35 | -------------------------------------------------------------------------------- /查找/2.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int find_pos(int data[] ,int n, int key) 4 | {//在数组data中查找给定数据key，n是数组中数据元素的个数，返回值是数据元素比较的次数. 5 | 6 | /*------------begin-----------------*/ 7 | int l = 0, r = n - 1; 8 | int cnt = 0; 9 | while (l < r){ 10 | int mid = (l + r) >> 1; 11 | if (data[mid] == key) return cnt + 1; 12 | else if(data[mid] < key) l = mid + 1; 13 | else if(data[mid] > key) r = mid - 1; 14 | cnt ++; 15 | } 16 | if (data[l] != key) return 0; 17 | return cnt + 1; 18 | /*------------end-----------------*/ 19 | } 20 | 21 | int main(void) 22 | { 23 | int a[]={-1,15,66,99,122,189}; 24 | int x; 25 | scanf("%d",&x); 26 | //此处填写代码，调用find_pos，在a数组中查找给定数据x的位置，并输出函数返回值 27 | /*------------begin-----------------*/ 28 | printf("%d", find_pos(a, 6, x)); 29 | /*------------end-----------------*/ 30 | 31 | return 1; 32 | } 33 | 34 | -------------------------------------------------------------------------------- /暑期/暑期2-查找入门-2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | int find_pos(int data[] ,int n, int key) 5 | {//在数组data中查找给定数据key，n是数组中数据元素的个数，返回值是数据元素比较的次数. 6 | 7 | /*------------begin-----------------*/ 8 | int l = 0, r = n - 1; 9 | int mid; 10 | int res = 0; 11 | while (l < r){ 12 | res ++; 13 | mid = l + r >> 1; 14 | if (data[mid] == key) break; 15 | else if (data[mid] > key) r = mid - 1; 16 | else if (data[mid] < key) l = mid + 1; 17 | } 18 | if (data[mid] == key) return res; 19 | else if (data[mid + 1] == key) return res + 1; 20 | else return 0; 21 | /*------------end-----------------*/ 22 | } 23 | 24 | int main(void) 25 | { 26 | int a[]={-1,15,66,99,122,189}; 27 | int x; 28 | cin>>x; 29 | //此处填写代码，调用find_pos，在a数组中查找给定数据x的位置，并输出函数返回值 30 | /*------------begin-----------------*/ 31 | cout << find_pos(a, 6, x) << endl; 32 | /*------------end-----------------*/ 33 | 34 | return 1; 35 | } 36 | -------------------------------------------------------------------------------- /交换排序/课本快排.c: -------------------------------------------------------------------------------- 1 | #include 2 | /*10 49 38 65 97 49 13 27 76 90 12*/ 3 | void print(int a[] ,int n) 4 | {//输出数组元素，数字之间以一个空格为界，输出结束后换一行 5 | for(int i=0;i=right) return; 14 | int i=left,j=right; 15 | int temp=a[i]; 16 | 17 | while(i!=j) 18 | { 19 | while(i=temp) 20 | j--; 21 | if(i 2 | void print(int a[] ,int n) 3 | {//输出数组元素，数字之间以一个空格为界，输出结束后换一行 4 | for(int i=0;ia[j+1]) 19 | { 20 | IsSorted=0; 21 | int temp=a[j]; 22 | a[j]=a[j+1]; 23 | a[j+1]=temp; 24 | } 25 | } 26 | if(!IsSorted) 27 | print(a,n); 28 | else if((IsSorted)&&(i==0)) 29 | print(a,n); 30 | else 31 | break; 32 | } 33 | } 34 | int main(void) 35 | { 36 | int num ; 37 | scanf("%d",&num); 38 | int data[num]; 39 | for(int i=0;i 2 | #include 3 | 4 | 5 | using namespace std; 6 | 7 | int main (int argc, char *argv[]) 8 | { 9 | 10 | int n, m, s, cnt; 11 | cnt = 0; 12 | cin >> n >> m >> s; 13 | 14 | list people; 15 | list dead; 16 | for(int i = 1; i <= n; i ++) people.push_back(i); 17 | 18 | auto it = people.begin(); 19 | 20 | int idx = 1; 21 | while (cnt < n - s) 22 | { 23 | if (idx % m == 0){ 24 | cnt ++; 25 | dead.push_back(*it); 26 | it = people.erase(it); 27 | } else { 28 | it ++; 29 | } 30 | if (it == people.end()) { 31 | it = people.begin(); 32 | } 33 | idx ++; 34 | } 35 | 36 | cout << "死者顺序："; 37 | for (auto dv = dead.begin(); dv != dead.end(); dv ++) { 38 | cout << *dv << " "; 39 | } 40 | cout << endl << "生者："; 41 | for (auto sv = people.begin(); sv != people.end(); sv ++) { 42 | cout << *sv << " "; 43 | } 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /选择排序/2.c: -------------------------------------------------------------------------------- 1 | #include 2 | void print(int a[] ,int n) 3 | {//输出数组元素，数字之间以一个空格为界，输出结束后换一行 4 | for (int i = 0; i < n; i++) { 5 | printf("%d ",a[i]); 6 | } 7 | printf("\n"); 8 | } 9 | 10 | void sift(int a[],int size,int p) { 11 | int tmp = a[p]; 12 | int lchild = 2*p+1,rchild = 2*p+2; 13 | while(lchild < size) { 14 | if (lchild < size-1 && a[lchild] < a[rchild]) lchild = rchild; 15 | if (tmp < a[lchild]) { 16 | a[p] = a[lchild]; 17 | p = lchild; 18 | lchild = 2*p+1; 19 | rchild = 2*p+2; 20 | } else break; 21 | } 22 | a[p] = tmp; 23 | } 24 | 25 | void heapSort(int a[] ,int n) // 26 | { 27 | int i,tmp; 28 | for (i = n/2-1; i >= 0; i--) 29 | sift(a,n,i); 30 | for (i = n-1; i > 0; i--) { 31 | tmp = a[i]; 32 | a[i] = a[0]; 33 | a[0] = tmp; 34 | sift(a,i,0); 35 | print(a,n); 36 | } 37 | } 38 | 39 | //根据需要自己添加其他需要的函数 40 | 41 | 42 | 43 | int main(void) 44 | { 45 | int num ; 46 | scanf("%d",&num); 47 | int data[num]; 48 | for(int i=0;i 2 | using namespace std; 3 | 4 | typedef char DataType; 5 | 6 | //二叉树数据结构 7 | struct node 8 | { 9 | DataType info ; //存放结点数据 10 | struct node *lchild , *rchild ; //指向左右孩子的指针 11 | }; 12 | 13 | typedef struct node *BiTree ; 14 | 15 | /*创建二叉树 16 | 函数名：createBiTree 17 | 参数：无 18 | 返回值：二叉树根结点指针 19 | */ 20 | BiTree createBiTree(void) 21 | { 22 | //请在此处填写代码， 完成二叉树和创建，返回值是二叉树的根结点指针 23 | //分析：前序创建 24 | /********** Begin **********/ 25 | char ch; 26 | BiTree T; 27 | cin>>ch; 28 | if(ch=='#') return T=NULL; 29 | else 30 | { 31 | T=new struct node; 32 | T->info=ch; 33 | T->lchild=createBiTree(); 34 | T->rchild=createBiTree(); 35 | } 36 | /********** End *********/ 37 | } 38 | 39 | void visit(BiTree T) //输出结点T的数据 40 | { 41 | cout<info ; 42 | } 43 | 44 | void inOrder(BiTree root)//进入下一个节点，中序遍历。 45 | { 46 | if(root == NULL) return ; 47 | inOrder(root->lchild); 48 | visit(root); 49 | inOrder(root->rchild); 50 | } 51 | 52 | int main(void) 53 | { 54 | BiTree root = createBiTree(); 55 | inOrder(root); 56 | } 57 | -------------------------------------------------------------------------------- /暑期/线性表综合应用实践-2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | 5 | using namespace std; 6 | 7 | int main (int argc, char *argv[]) 8 | { 9 | 10 | int n, m, k, s; 11 | cin >> n >> m >> k >> s; 12 | 13 | list people; 14 | list dead; 15 | for(int i = 1; i <= n; i ++) people.push_back(i); 16 | 17 | auto it = people.begin(); 18 | 19 | while (people.size() > s){ 20 | for (int i = 0; i < m - 1; i ++){ 21 | if (++ it == people.end()){ 22 | it = people.begin(); 23 | } 24 | } 25 | dead.push_back(*it); 26 | it = people.erase(it); 27 | for (int i = 0; i < k - 1; i ++){ 28 | if (it == people.begin()){ 29 | it = people.end(); 30 | } 31 | it --; 32 | } 33 | dead.push_back(*it); 34 | it = people.erase(it); 35 | if (it == people.begin()){ 36 | it = people.end(); 37 | } 38 | it --; 39 | } 40 | cout << "死者顺序："; 41 | for (auto d : dead) cout << d << ' '; 42 | cout << endl << "生者："; 43 | for (auto p : people) cout << p << ' '; 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /树/bitree_4.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef char DataType; 5 | 6 | //二叉树数据结构 7 | struct node 8 | { 9 | DataType info ; //存放结点数据 10 | struct node *lchild , *rchild ; //指向左右孩子的指针 11 | }; 12 | 13 | typedef struct node *BiTree ; 14 | 15 | /*创建二叉树 16 | 函数名：createBiTree 17 | 参数：无 18 | 返回值：二叉树根结点指针*/ 19 | BiTree createBiTree(void) 20 | { 21 | char ch ; 22 | BiTree root ; 23 | cin>>ch ; 24 | if(ch == '#') return NULL; 25 | else 26 | { 27 | root = new struct node ; 28 | root->info = ch ; 29 | root->lchild = createBiTree() ; 30 | root->rchild = createBiTree(); 31 | } 32 | } 33 | 34 | void visit(BiTree T) 35 | { 36 | cout<info ; 37 | } 38 | 39 | int countFullNode(BiTree root) 40 | { 41 | //请在此处填写代码，计算二叉树中满结点的个数 42 | /********** Begin **********/ 43 | BiTree t=root; 44 | if(t==NULL) 45 | { 46 | return 0; 47 | } 48 | else if(t->lchild && t->rchild) 49 | { 50 | return countFullNode(t->lchild)+countFullNode(t->rchild)+1; 51 | } 52 | else 53 | { 54 | return countFullNode(t->lchild)+countFullNode(t->rchild); 55 | } 56 | /*********** End-**********/ 57 | } 58 | 59 | int main(void) 60 | { 61 | BiTree root = createBiTree(); 62 | cout< 2 | using namespace std; 3 | 4 | typedef char DataType; 5 | 6 | //二叉树数据结构 7 | struct node 8 | { 9 | DataType info ; //存放结点数据 10 | struct node *lchild , *rchild ; //指向左右孩子的指针 11 | }; 12 | 13 | typedef struct node *BiTree ; 14 | 15 | /*创建二叉树 16 | 函数名：createBiTree 17 | 参数：无 18 | 返回值：二叉树根结点指针 19 | */ 20 | BiTree createBiTree(void) 21 | { 22 | char ch ; 23 | BiTree root ; 24 | cin>>ch ; 25 | if(ch == '#') return root = NULL; 26 | else{ 27 | root = new struct node ; 28 | root->info = ch ; 29 | root->lchild = createBiTree() ; 30 | root->rchild = createBiTree(); 31 | } 32 | 33 | } 34 | 35 | void visit(BiTree T) 36 | { 37 | cout<info ; 38 | } 39 | 40 | int countLeaf(BiTree root) 41 | { 42 | //请在此处填写代码， 计算二叉树中树叶的个数 43 | /********** Begin **********/ 44 | BiTree t=root; 45 | 46 | int count=0; 47 | 48 | if(t==NULL) 49 | { 50 | return 0; 51 | } 52 | else if((t->lchild==NULL)&&(t->rchild==NULL)) 53 | { 54 | return count+1; 55 | } 56 | else 57 | { 58 | count=countLeaf(t->lchild) + countLeaf(t->rchild); 59 | return count; 60 | } 61 | /********** End **********/ 62 | } 63 | 64 | int main(void) 65 | { 66 | BiTree root = createBiTree(); 67 | cout< 2 | using namespace std; 3 | 4 | typedef char DataType; 5 | 6 | //二叉树数据结构 7 | struct node 8 | { 9 | DataType info ; //存放结点数据 10 | struct node *lchild , *rchild ; //指向左右孩子的指针 11 | }; 12 | 13 | typedef struct node *BiTree ; 14 | 15 | /*创建二叉树 16 | 函数名：createBiTree 17 | 参数：无 18 | 返回值：二叉树根结点指针 19 | */ 20 | BiTree createBiTree(void) 21 | { 22 | char ch ; 23 | BiTree root ; 24 | cin>>ch ; 25 | if(ch == '#') root = NULL; 26 | else{ 27 | root = new struct node ; 28 | root->info = ch ; 29 | root->lchild = createBiTree() ; 30 | root->rchild = createBiTree(); 31 | } 32 | return root ; 33 | } 34 | 35 | void changeLR(BiTree root) 36 | { 37 | //请在此处填写代码， 完成二叉树左右子树互换 38 | /********** Begin **********/ 39 | BiTree t=root; 40 | if(t==NULL) return; 41 | BiTree temp=t->lchild; 42 | t->lchild=t->rchild; 43 | t->rchild=temp; 44 | changeLR(t->lchild); 45 | changeLR(t->rchild); 46 | /********** End **********/ 47 | } 48 | 49 | void visit(BiTree T) //输出结点T的数据 50 | { 51 | cout<info ; 52 | } 53 | 54 | void inOrder(BiTree root) 55 | { 56 | if(root == NULL) return ; 57 | inOrder(root->lchild); 58 | visit(root); 59 | inOrder(root->rchild); 60 | } 61 | 62 | int main(void) 63 | { 64 | BiTree root = createBiTree(); 65 | changeLR(root); 66 | inOrder(root); 67 | } 68 | -------------------------------------------------------------------------------- /线性表/循环链表和双向链表—课上课后练-1.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | struct node 5 | {//链表结点类型，包含一个存放整型数据的 data 成员，和一个指向下一个结点的next成员 6 | int data ; 7 | struct node *next ; 8 | }; 9 | 10 | //第一关代码 11 | struct node *createRlist() 12 | {//函数功能：创建一个有一个空循环链表，返回值为头指针 13 | struct node *head = (struct node*)malloc(sizeof(struct node)); 14 | head->data = 0; 15 | head->next = head; 16 | return head; 17 | } 18 | 19 | 20 | struct node * insertOrder(struct node *list, int insData) 21 | { 22 | //在单向递增有序的循环链表（表头指针list）中插入数据元素insData，使之依然有序 。返回值是头指针 23 | 24 | struct node *p = (struct node *)malloc(sizeof (struct node)); 25 | p->data = insData; 26 | 27 | struct node *q = list; 28 | while (q->next->data < insData && q->next != list){ 29 | q = q->next; 30 | } 31 | p->next = q->next; 32 | q->next = p; 33 | 34 | 35 | return list; 36 | } 37 | 38 | int deleteData(struct node *list, int delData) 39 | { 40 | //在单向递增有序循环链表（表头指针list）中删除所有值为delData的结点,返回值为删除结点的个数 41 | int cnt = 0; 42 | struct node* p = list->next; 43 | struct node* q = list; 44 | while(p!=list){ 45 | if(p->data==delData){ 46 | struct node* k = p; 47 | p=p->next; 48 | q->next = p; 49 | free(k); 50 | cnt++; 51 | continue; 52 | } 53 | p = p->next; 54 | q = q->next; 55 | } 56 | return cnt; 57 | 58 | } 59 | 60 | void printRlist(struct node *list) 61 | { 62 | //从链表第一个结点开始输出单向循环链表中各数据元素的值，每输出一个数据元素空一格 63 | struct node* p = list->next; 64 | while(p!=list){ 65 | printf("%d ",p->data); 66 | p = p->next; 67 | } 68 | 69 | } 70 | 71 | int destroyRlist(struct node *list) 72 | { 73 | //从第一个结点开始释放循环链表各结点占用的空间,返回值为最后一个结点的值 74 | struct node* p = list->next; 75 | while(p->next!=list){ 76 | struct node* q = p; 77 | p = p->next; 78 | free(q); 79 | } 80 | int temp = p->data; 81 | free(p); 82 | free(list); 83 | return temp; 84 | 85 | 86 | } 87 | -------------------------------------------------------------------------------- /线性表/循环链表和双向链表—课上课后练-2.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | struct node 4 | {//链表结点类型，包含一个存放整型数据的 data 成员，和指向前驱和后继结点的指针 5 | int data ; 6 | struct node *llink, *rlink ; 7 | }; 8 | 9 | struct Hnode 10 | { 11 | //双向链表头结点,有两个指针成员，分别指向双向链表的第一个结点和最后一个结点 12 | struct node *head, *tail; 13 | }; 14 | 15 | //第二关代码 16 | struct Hnode *createDlist() 17 | {//函数功能：创建一个带头结点的双向链表，tail指向尾结点；head指针指向第一个结点，返回值是指向头结点的指针 18 | struct Hnode *headNode = (struct Hnode*)malloc(sizeof(struct Hnode)); 19 | headNode->head = NULL; 20 | headNode->tail = NULL; 21 | return headNode; 22 | } 23 | 24 | 25 | void insertDlist(struct Hnode *list, int insData) 26 | { 27 | //在双向链表的表头插入数据 28 | struct node *p = (struct node *)malloc(sizeof (struct node)); 29 | p->data = insData; 30 | if (list->head == NULL){ 31 | list->head = list->tail = p; 32 | p->llink = NULL; 33 | p->rlink = NULL; 34 | } else { 35 | p->llink = NULL; 36 | list->head->llink = p; 37 | p->rlink = list->head; 38 | list->head = p; 39 | } 40 | } 41 | 42 | int deleteData(struct Hnode *list, int delData) 43 | { 44 | //在双向链表中删除值为delData的第一个结点，若删除成功返回1，否则返回0 45 | for (struct node *p = list->head; p != list->tail; p = p->rlink) 46 | if (p->data == delData){ 47 | if (p == list->head) list->head = p->rlink; 48 | if (p == list->tail) list->tail = p->llink; 49 | if (p->llink != NULL) p->llink->rlink = p->rlink; 50 | if (p->rlink != NULL) p->rlink->llink = p->llink; 51 | free(p); 52 | return 1; 53 | } 54 | return 0; 55 | } 56 | 57 | void printDlist(struct Hnode *list) 58 | { 59 | //输出双向循环链表中各数据元素的值，每输出一个数据元素换行 60 | for (struct node *p = list->head; p != list->tail; p = p->rlink) 61 | printf("%d\n", p->data); 62 | printf("%d\n", list->tail->data); 63 | } 64 | 65 | int destroyDlist(struct Hnode *list) 66 | {//释放双向链表占用的存储空间，释放所有结点,返回释放的结点数，不含list本身 67 | int cnt = 0; 68 | for (struct node *p = list->head, *next = NULL; p->rlink != NULL;){ 69 | next = p->rlink; 70 | free(p); 71 | p = next; 72 | cnt ++; 73 | 74 | } 75 | cnt ++; 76 | // free(list->tail); 77 | return cnt; 78 | } 79 | -------------------------------------------------------------------------------- /队列/链队——课上练.h: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | /*此处是链栈数据结构定义*/ 5 | typedef int DataType; 6 | struct node 7 | { 8 | DataType info; 9 | struct node *link; 10 | }; 11 | 12 | typedef struct node *PNode; 13 | 14 | struct LinkQueue { 15 | PNode front,rear; 16 | }; 17 | typedef struct LinkQueue *PLinkQueue; 18 | 19 | 20 | //第一关 21 | PLinkQueue createNullQueue_link( ) 22 | {//此处填写代码，创建一个空的链队 23 | PLinkQueue L = (PLinkQueue)malloc(sizeof(LinkQueue)); 24 | L -> front = NULL; 25 | L -> rear = NULL; 26 | return L; 27 | } 28 | 29 | //第二关 30 | int isNullQueue_link(PLinkQueue L) 31 | { 32 | //判断队列是否为空，若为空，返回值为1，否则返回值为0,若队列不存在，则返回-1 33 | if (L == NULL) 34 | { 35 | return -1; 36 | } 37 | if(L -> front == NULL) 38 | { 39 | return 1; 40 | } 41 | else{ 42 | return 0; 43 | } 44 | 45 | } 46 | 47 | 48 | 49 | 50 | //第三关 51 | int EnQueue_link(PLinkQueue L ,DataType x) 52 | {//在队列插入数据元素x，若插入不成功，返回0；插入成功返回值为1 53 | PNode p = (PNode)malloc(sizeof (struct node)); 54 | if (p == NULL) return 0; 55 | p->info = x; 56 | p->link = L -> rear; 57 | if(L -> front == NULL) 58 | { 59 | L -> front = p; 60 | L -> rear = p; 61 | } 62 | else 63 | { 64 | L -> rear = p; 65 | } 66 | 67 | return 1; 68 | } 69 | 70 | 71 | 72 | //第四关 73 | DataType DeQueue_link(PLinkQueue L) 74 | {//删除队首元素并返回被删除元素，若队列为空，则返回-1 75 | if(L -> front == NULL) 76 | { 77 | return -1; 78 | } 79 | DataType tmp = L -> front -> info; 80 | PNode p = L -> front; 81 | L -> front = L -> front -> link; 82 | free(p); 83 | return tmp; 84 | } 85 | 86 | //第五关 87 | DataType front_link(PLinkQueue L) 88 | {// 取队首元素返回，若队列为空，则返回-1 89 | if(L -> front == NULL) 90 | { 91 | return -1; 92 | } 93 | return L -> front -> info; 94 | 95 | } 96 | 97 | 98 | //销毁链队，并释放队列所占存储空间 99 | int destroyQueue_link(PLinkQueue L) 100 | { 101 | //返回值为销毁的栈中现有数据元素的个数，若待销毁的线性表不存在，则返回0 102 | int cnt =0 ; 103 | if(L==NULL) return 0; 104 | struct node *p = L->front ,*q ; 105 | free(L); 106 | while(p->link!=NULL) 107 | { 108 | q = p->link; 109 | cnt++; 110 | free(p); 111 | p = q ; 112 | } 113 | return cnt ; 114 | } 115 | 116 | -------------------------------------------------------------------------------- /实验/树实验2.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | #include 6 | 7 | typedef char DataType; 8 | 9 | //二叉树结点定义 10 | //此处进行二叉树结构定义 11 | /*-------begin------*/ 12 | 13 | struct node 14 | { 15 | DataType data; 16 | struct node* lchild, *rchild; 17 | }; 18 | typedef struct node BiTree; 19 | typedef struct node* PTree; 20 | /*-----end---------*/ 21 | 22 | 23 | 24 | void print(DataType d) 25 | { 26 | cout << d << " "; 27 | } 28 | //初始化二叉树的结点序列 29 | 30 | char treeData[] = "ABC##D##E#F#G##"; 31 | 32 | /* 33 | 函数名：createBiTree 34 | 函数功能：读取treeData 数组中的字符序列进行二叉树创建二叉树，并返回二叉树的根结点指针 35 | 参数：无 36 | 返回值：二叉树的根结点指针 37 | */ 38 | //在此处填入代码 39 | /*----------begin-------------*/ 40 | int i = 0; 41 | PTree createBiTree() 42 | { 43 | PTree root; 44 | char ch; 45 | ch = treeData[i++]; 46 | if (ch != '\0') 47 | { 48 | if (ch == '#') root = NULL; 49 | else 50 | { 51 | root = new BiTree; 52 | root->data = ch; 53 | root->lchild = createBiTree(); 54 | root->rchild = createBiTree(); 55 | } 56 | return root; 57 | } 58 | else 59 | return root = NULL; 60 | } 61 | 62 | 63 | /*----------end-------------*/ 64 | 65 | void Sibling(BiTree* T) 66 | { 67 | //在此处填入代码,输出结点T的所有兄弟姐妹 68 | /*----------begin-------------*/ 69 | while (T!= NULL) 70 | { 71 | print(T->data); 72 | T = T->rchild; 73 | } 74 | /*----------end-------------*/ 75 | } 76 | 77 | /* 78 | 函数名：preOrder 79 | 函数功能：先根遍历二叉树 ，并找到值为ch的结点指针 80 | 参数：根结点指针 BiTree *T ,需查找的结点值 ch 81 | 返回值：无 82 | */ 83 | 84 | //在此处填入代码,利用先序遍历，找到结点值ch后调用函数sibling输出该结点的所有兄弟姐妹，以空格分界 85 | /*----------begin-------------*/ 86 | void preOrder(BiTree *T ,char ch) 87 | { 88 | if (T == NULL) return; 89 | char c = T->data; 90 | if (c == ch) 91 | { 92 | Sibling(T->rchild); 93 | exit(0); 94 | } 95 | preOrder(T->lchild,ch); 96 | preOrder(T->rchild,ch); 97 | } 98 | 99 | 100 | /*----------end-------------*/ 101 | 102 | 103 | 104 | 105 | int main(void) 106 | { 107 | BiTree* T; 108 | T = createBiTree(); //创建二叉树 109 | 110 | char ch; 111 | cin >> ch; //输入某人的代号 112 | preOrder(T, ch); //调用函数输出ch的所有兄弟姐妹 113 | 114 | return 1; 115 | } -------------------------------------------------------------------------------- /实验/树实验1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | typedef char DataType; 5 | 6 | //二叉树结点定义 7 | struct node 8 | { 9 | DataType data; //存放结点数据 10 | struct node* lchild, * rchild; //左右孩子指针 11 | }; 12 | typedef struct node BiTree; 13 | typedef struct node* ptree; 14 | 15 | //函数可直接使用，功能：输出结点数据 16 | void print(DataType d) 17 | { 18 | cout << d << " "; 19 | } 20 | 21 | /* 22 | 函数名：createBiTree 23 | 函数功能：创建二叉树，并返回二叉树的根结点指针 24 | 参数：无 25 | 返回值：二叉树的根结点指针 26 | */ 27 | BiTree* createBiTree() { 28 | //请在此处填写代码，完成创建二叉树并返回二叉树根结点指针的功能 29 | /*-------begin--------*/ 30 | char ch; 31 | ptree root; 32 | cin >> ch; 33 | if (ch == '#') root = NULL; 34 | else 35 | { 36 | root = new BiTree; 37 | root->data = ch; 38 | root->lchild = createBiTree(); 39 | root->rchild = createBiTree(); 40 | } 41 | return root; 42 | /*-------end--------*/ 43 | } 44 | 45 | /* 46 | 函数名：preOrder 47 | 函数功能：先根遍历二叉树 48 | 参数：二叉树根结点指针 49 | 返回值：无 50 | */ 51 | void preOrder(BiTree* T) 52 | { 53 | //请在此处填写代码，完成先根遍历二叉树功能 54 | /*-------begin--------*/ 55 | if (T == NULL) 56 | return; 57 | print(T->data); 58 | preOrder(T->lchild); 59 | preOrder(T->rchild); 60 | /*-------end--------*/ 61 | } 62 | 63 | /* 64 | 函数名： inOrder 65 | 函数功能：中根遍历二叉树 66 | 参数：二叉树根结点指针 67 | 返回值：无 68 | */ 69 | void inOrder(BiTree* T) 70 | { 71 | //请在此处填写代码，完成中根遍历二叉树功能 72 | /*-------begin--------*/ 73 | if (T == NULL) 74 | return; 75 | inOrder(T->lchild); 76 | print(T->data); 77 | inOrder(T->rchild); 78 | /*-------end--------*/ 79 | } 80 | 81 | /* 82 | 函数名：postOrder 83 | 函数功能：后根遍历二叉树 84 | 参数：二叉树根结点指针 85 | 返回值：无 86 | */ 87 | void postOrder(BiTree* T) 88 | { 89 | //请在此处填写代码，完成后根遍历二叉树功能 90 | /*-------begin--------*/ 91 | if (T == NULL) 92 | return; 93 | postOrder(T->lchild); 94 | postOrder(T->rchild); 95 | print(T->data); 96 | /*-------end--------*/ 97 | } 98 | 99 | 100 | 101 | int main(void) 102 | { 103 | BiTree* T; 104 | T = createBiTree(); //调用创建二叉树功能，得到二叉树的根结点指针 105 | 106 | 107 | preOrder(T);//调用先根遍历二叉树，按先根遍历顺序输出二叉树结点功能 108 | cout << endl; //换行 109 | inOrder(T);//调用中根遍历二叉树，按中根遍历顺序输出二叉树结点功能 110 | cout << endl; 111 | postOrder(T);//调用后根遍历二叉树，按后根遍历顺序输出二叉树结点功能 112 | 113 | return 1; 114 | } -------------------------------------------------------------------------------- /实验/链表大数相加.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | struct node 4 | {//链表结点类型，包含一个存放整型数据的 data 成员，和一个指向下一个结点的next成员 5 | int data ; 6 | struct node *next ; 7 | }; 8 | 9 | struct node *mycreateList() 10 | {//函数功能：创建一个只有一个头结点的空链表，头节点的数据域赋值为0，并将表头结点的地址返回 11 | struct node *head = (struct node *)malloc(sizeof(struct node)); 12 | head->data = 0; 13 | head->next = NULL; 14 | return head; 15 | } 16 | 17 | 18 | void myinsertHead(struct node * head, int insData ) 19 | { 20 | /*函数功能：实现在head为表头的链表中使用头插法，插入数据元素insData*/ 21 | struct node *p ; 22 | p = (struct node *)malloc(sizeof(struct node)); 23 | p->data = insData; 24 | p->next = head->next ; 25 | head->next = p ; 26 | } 27 | 28 | void myinsertTail(struct node * head , int insData ) 29 | { 30 | /*在head为表头的单链表表尾插入数据元素insData*/ 31 | struct node *p ,*q ; 32 | p = (struct node *)malloc(sizeof(struct node)); 33 | p->data = insData; 34 | p->next = NULL; 35 | q = head ; 36 | while(q->next!=NULL) 37 | q = q->next; 38 | q->next = p ; 39 | } 40 | 41 | void myprintList(struct node *L) 42 | { 43 | /*输出head为表头的链表中的数据元素，每输出一个数据空一格*/ 44 | struct node *p = L->next ; 45 | while(p) 46 | { 47 | printf("%d ",p->data); 48 | p = p->next ; 49 | } 50 | } 51 | void genNumber( struct node *A , int num) 52 | {//本函数用于接收输入的大数的各个位，返回大数链表表头，可使用上面已实现的链表插入函数 53 | /*------begin---------*/ 54 | int temp; 55 | for(int i=0;inext; 68 | struct node *q=B->next; 69 | struct node *res=(struct node *)malloc(sizeof(struct node)); 70 | res->next=NULL; 71 | int m=0; 72 | while(p||q) 73 | { 74 | if(q==NULL) 75 | { 76 | m=p->data; 77 | p=p->next; 78 | } 79 | else if(p==NULL) 80 | { 81 | m=q->data; 82 | q=q->next; 83 | } 84 | else if(p->data + q->data < 10) 85 | { 86 | m=p->data + q->data; 87 | p=p->next; 88 | q=q->next; 89 | } 90 | else 91 | { 92 | m=p->data+q->data; 93 | m=m%10; 94 | p=p->next; 95 | q=q->next; 96 | if(p==NULL) myinsertTail(A,1); 97 | else p->data=p->data+1; 98 | } 99 | myinsertHead(res,m); 100 | } 101 | 102 | return res; 103 | /*------end---------*/ 104 | } 105 | -------------------------------------------------------------------------------- /树/二叉排序树——课后练.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | //数据结构定义 4 | struct node 5 | { 6 | int data ; 7 | struct node *lchild ,*rchild ; 8 | }; 9 | 10 | typedef struct node *pTree; 11 | /*第一关*/ 12 | 13 | 14 | /*1.创建一个二叉树结点,值为element*/ 15 | pTree createTreeNode(int element) 16 | { 17 | pTree tree = (pTree) malloc(sizeof(struct node)); 18 | tree->data = element; 19 | return tree; 20 | } 21 | 22 | /*2.在二叉排序树中插入一个数据元素,若二叉树为空，则新建根节点*/ 23 | pTree insertData(int x , pTree T) 24 | { 25 | if (T) { 26 | if (x < T->data){ 27 | T->lchild = insertData(x, T->lchild); 28 | } 29 | else T->rchild = insertData(x, T->rchild); 30 | 31 | } else { 32 | return createTreeNode(x); 33 | } 34 | return T; 35 | } 36 | 37 | /*3.先序遍历和中序遍历函数*/ 38 | void preOrder( pTree T) 39 | { 40 | if (!T) return; 41 | printf("%d ", T->data); 42 | preOrder(T->lchild); 43 | preOrder(T->rchild); 44 | 45 | 46 | } 47 | void inOrder( pTree T) 48 | { 49 | 50 | if (!T) return; 51 | inOrder(T->lchild); 52 | printf("%d ", T->data); 53 | inOrder(T->rchild); 54 | 55 | } 56 | 57 | 58 | /*第二关*/ 59 | /*1.在二叉排序树T中查找最小值，返回该结点*/ 60 | pTree findMin(pTree T) 61 | { 62 | if (!T) return NULL; 63 | if (!T->lchild) return T; 64 | 65 | return findMin(T->lchild); 66 | } 67 | 68 | /*2.在二叉排序树T中查找最大值，返回该结点*/ 69 | pTree findMax(pTree T) 70 | { 71 | if (!T) return NULL; 72 | if (!T->rchild) return T; 73 | return findMax(T->rchild); 74 | } 75 | 76 | 77 | /*3.在二叉排序树T中查找指定数据元素，若未找到，则返回NULL*/ 78 | pTree findData(pTree T, int element) 79 | { 80 | if (!T) return NULL; 81 | 82 | if (T->data == element) return T; 83 | else if (T->data > element) return findData(T->lchild, element); 84 | else return findData(T->rchild, element); 85 | } 86 | 87 | /*第三关*/ 88 | /*在二叉排序树T中删除指定元素的结点,若删除成功则返回该结点，否则返回NULL*/ 89 | pTree deleteData(pTree T, int element) 90 | { 91 | if (!T) return NULL; 92 | if (element < T->data){ 93 | T->lchild = deleteData(T->lchild, element); 94 | return T; 95 | } 96 | if (element > T->data){ 97 | T->rchild = deleteData(T->rchild, element); 98 | return T; 99 | } 100 | 101 | if (!T->lchild && !T->rchild){ 102 | free(T); 103 | return NULL; 104 | } 105 | if (T->lchild && !T->rchild) return T=T->lchild; 106 | if (!T->lchild && T->rchild) return T=T->rchild; 107 | 108 | if (T->lchild && T->rchild) { 109 | pTree r = findMin(T->rchild); 110 | T->data = r->data; 111 | T->rchild = deleteData(T->rchild, r->data); 112 | return T; 113 | } 114 | return T; 115 | } 116 | -------------------------------------------------------------------------------- /集合/集合——课上练.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define swap(A, B) ((A)^=(B),(B)^=(A),(A)^=(B)) 4 | /*----------------*/ 5 | //若采取顺序存储结构，集合最多存放的元素个数，可自定义 6 | const int N = 25, M = 1e3; 7 | 8 | struct SetNode//若采用链式存储结构，则头结点不存储集合元素，存储集合中元素的个数，且数据成员命名为info 9 | //若采用顺序存储结构，则应有成员变量记录当前集合中数据元素个数，且该成员命名为info 10 | { 11 | int cur; 12 | int *info; 13 | char *st; 14 | }; 15 | typedef struct SetNode *Set; 16 | 17 | int cmpfunc (const void * a, const void * b) 18 | { 19 | return ( *(int*)a - *(int*)b ); 20 | } 21 | void printSet(Set A) 22 | { 23 | //根据自定义数据结构，请先完成本函数，逐个输出集合元素，以一个空格为分界，最后一个元素输出后，追加输出一个换行符 24 | qsort(A->info, A->cur, sizeof(int), cmpfunc); 25 | for (int i = 0; i < A->cur; i ++){ 26 | if (i) printf(" "); 27 | printf("%d", A->info[i]); 28 | } 29 | } 30 | 31 | 32 | //第1关，创建一个空集合 33 | Set createEmptySet() 34 | { 35 | /*----------------*/ 36 | Set a = (Set)malloc(sizeof(struct SetNode)); 37 | if (!a) return a; 38 | a->cur = 0; 39 | /* 第一关，如果过不了，请把下面两行注释掉orz */ 40 | a->info = (int*)malloc(sizeof(int)*N); 41 | a->st = (char*)malloc(sizeof(char)*M); 42 | 43 | return a; 44 | /*----------------*/ 45 | } 46 | 47 | //第2关，向集合中插入元素 48 | 49 | void insert(int data, Set A) 50 | { 51 | /*----------------*/ 52 | if (A->st[data]) return; 53 | A->info[A->cur ++] = data, A->st[data] = 1; 54 | 55 | } 56 | 57 | //第3关，判断数据元素是否属于集合 58 | int member(int data,Set A) 59 | { 60 | /*----------------*/ 61 | if (!A || !A->cur) return 0; 62 | return A->st[data]; 63 | 64 | return 0; 65 | } 66 | 67 | //第4关，从集合A中删除指定数据元素，返回集合 68 | Set delete(int data, Set A) 69 | { 70 | /*----------------*/ 71 | if (!A->st[data]) return A; 72 | for (int i = 0; i < A->cur; i ++) 73 | if (A->info[i] == data){ 74 | A->st[data] = 0; 75 | swap(A->info[i], A->info[A->cur - 1]); 76 | A->cur --; 77 | break; 78 | } 79 | return A; 80 | 81 | } 82 | 83 | //第5关，求集合A,B的并集 84 | void Union(Set A, Set B, Set C) 85 | { 86 | /*----------------*/ 87 | for (int i = 0; i < A->cur; i ++) 88 | insert(A->info[i], C); 89 | for (int i = 0; i < B->cur; i ++) 90 | if (!member(B->info[i], A)) insert(B->info[i], C); 91 | } 92 | 93 | //第6关，求集合A,B的交集 94 | void intersect(Set A, Set B, Set C) 95 | { 96 | /*----------------*/ 97 | for (int i = 0; i < A->cur; i ++) 98 | if (member(A->info[i], B)) insert(A->info[i], C); 99 | } 100 | 101 | //第7关，求集合A,B的差集 102 | void difference(Set A, Set B, Set C) 103 | { 104 | /*----------------*/ 105 | for (int i = 0; i < A->cur; i ++) 106 | if (!member(A->info[i], B)) insert(A->info[i], C); 107 | 108 | } 109 | 110 | -------------------------------------------------------------------------------- /栈/链栈——课上练.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | /*此处是链栈数据结构定义*/ 5 | typedef int DataType; 6 | struct node 7 | { 8 | DataType info; 9 | struct node *link; 10 | }; 11 | 12 | typedef struct node *PNode; 13 | 14 | struct LinkStack { 15 | PNode top; 16 | }; 17 | typedef struct LinkStack *PLinkStack; 18 | 19 | 20 | //第一关 21 | PLinkStack createNullStack_link( ) 22 | {//此处填写代码，创建一个空的链栈 23 | 24 | PLinkStack s = (PLinkStack*)malloc(sizeof(struct LinkStack)); 25 | 26 | s->top = NULL; 27 | return s; 28 | 29 | } 30 | 31 | //第二关 32 | int isNullStack_link(PLinkStack L) 33 | { 34 | //判断栈是否为空，若为空，返回值为1，否则返回值为0,若栈不存在，则返回-1 35 | if (L == NULL) return -1; 36 | if (L->top == NULL) return 1; 37 | else return 0; 38 | } 39 | 40 | 41 | 42 | 43 | //第三关 44 | int push_link(PLinkStack L ,DataType x) 45 | {//在栈中插入数据元素x，若插入不成功，返回0；插入成功返回值为1 46 | PNode p = (PNode)malloc(sizeof (struct node)); 47 | if (p == NULL) return 0; 48 | p->info = x; 49 | p->link = L->top; 50 | L->top = p; 51 | return 1; 52 | } 53 | 54 | 55 | 56 | //第四关 57 | DataType pop_link(PLinkStack L) 58 | {//弹栈并返回删除元素，若栈为空，则返回-1 59 | if (L == NULL || L->top == NULL) return -1; 60 | 61 | PNode p = L->top; 62 | int tmp = p->info; 63 | L->top = L->top->link; 64 | free(p); 65 | return tmp; 66 | } 67 | 68 | //第五关 69 | DataType top_link(PLinkStack L) 70 | {// 取栈顶元素返回，若栈为空，则返回-1 71 | if (L == NULL || L->top == NULL) return -1; 72 | return L->top->info; 73 | } 74 | 75 | 76 | //销毁栈，释放栈所占存储空间 77 | int destroystack_link(PLinkStack L) 78 | { 79 | //返回值为销毁的栈中现有数据元素的个数，若待销毁的线性表不存在，则返回0 80 | int cnt =0 ; 81 | if(L==NULL) return 0; 82 | struct node *p = L->top ,*q ; 83 | free(L); 84 | while(p->link!=NULL) 85 | { 86 | q = p->link; 87 | cnt++; 88 | free(p); 89 | p = q ; 90 | } 91 | return cnt ; 92 | } 93 | 94 | //第六关 95 | 96 | int balance_symbol(char *s) 97 | {//在此处填写代码完成符号配对判断，若配对，返回值为1，否则返回值为0 98 | PLinkStack pstack = createNullStack_link(); 99 | for (int i = 0; s[i] != '\0'; i ++){ 100 | if (s[i] == '(' || s[i] == '{' || s[i] == '[') push_link(pstack, s[i]); 101 | else { 102 | switch (s[i]){ 103 | case ')': 104 | if (pop_link(pstack) != '(') return 0; 105 | break; 106 | case ']': 107 | if (pop_link(pstack) != '[') return 0; 108 | break; 109 | case '}': 110 | if (pop_link(pstack) != '{') return 0; 111 | break; 112 | default: 113 | break; 114 | } 115 | } 116 | } 117 | return 1; 118 | } 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | -------------------------------------------------------------------------------- /队列/队列——课上练.h: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | /*此处是顺序队列数据结构定义*/ 4 | typedef int DataType; 5 | struct seqQueue//请完成数据结构定义 6 | { 7 | int MAXNUM; 8 | int front, rear; 9 | DataType *element; 10 | }; 11 | 12 | typedef struct seqQueue *PseqQueue; 13 | //第一关 14 | PseqQueue createNullQueue_seq(int m) 15 | {//此处填写代码，创建一个空的顺序队列，能存放的最大元素个数为 m 16 | //若m=0，则返回NULL 17 | if (m == 0) return NULL; 18 | PseqQueue queue = (PseqQueue)malloc(sizeof(struct seqQueue)); 19 | queue->MAXNUM = m; 20 | queue->front = 0; 21 | queue->rear = 0; 22 | queue->element = (DataType*)malloc(sizeof(DataType) * m); 23 | return queue; 24 | 25 | } 26 | //第二关 27 | int isNullQueue_seq(PseqQueue Q) 28 | { 29 | //判断顺序（环形）队列是否为空，若为空，返回值为1，否则返回值为0,若队列不存在，则返回-1 30 | if (Q == NULL) return -1; 31 | if (Q->rear == Q->front ) return 1; 32 | else return 0; 33 | } 34 | 35 | 36 | //第三关 37 | int isFullQueue_seq(PseqQueue Q) 38 | { 39 | //判断环形队列是否已满，若已满，返回值为1，否则返回值为0 40 | if (Q->rear - Q->front + 1 == Q->MAXNUM) return 1; 41 | else return 0; 42 | } 43 | 44 | 45 | //第四关 46 | int enQueue_seq(PseqQueue Q ,DataType x) 47 | {//在环形队列中插入数据元素x，若插入不成功，返回0；插入成功返回值为1 48 | if (Q == NULL || Q->rear + 1 >= Q->MAXNUM) return 0; 49 | Q->element[Q->rear ++] = x; 50 | return 1; 51 | } 52 | 53 | 54 | 55 | //第五关 56 | DataType delQueue_seq(PseqQueue Q) 57 | {//出队并返回删除元素，若队列为空，则返回-1 58 | if (Q == NULL || Q->front == Q->rear) return -1; 59 | return Q->element[Q->front ++]; 60 | } 61 | 62 | //第六关 63 | DataType front_seq(PseqQueue Q) 64 | {// 取队首元素返回，若队列为空，则返回-1 65 | if (Q == NULL || Q->front == Q->rear) return -1; 66 | 67 | return Q->element[Q->front]; 68 | } 69 | 70 | //销毁顺序队列，释放队列所占存储空间 71 | int destroyQueue_seq(PseqQueue Q) 72 | { 73 | //返回值为销毁的栈中现有数据元素的个数，若待销毁的线性表不存在，则返回0 74 | if (Q == NULL) return 0; 75 | for (int i = 0; i < Q->MAXNUM; i ++) 76 | free(Q->element + i); 77 | if (Q->rear == Q->front) return 0; 78 | return Q->rear - Q->front + 1; 79 | } 80 | 81 | 82 | //第七关 83 | void queueApp(int a[],int n) 84 | { 85 | //参数用于传递顾客编号和顾客人数，输出顾客接受服务后离开顺序 86 | PseqQueue A = createNullQueue_seq(n + 1); 87 | PseqQueue B = createNullQueue_seq(n + 1); 88 | 89 | for (int i = 0; i < n; i ++) { 90 | if (a[i] & 1) enQueue_seq(A, a[i]); 91 | else enQueue_seq(B, a[i]); 92 | } 93 | 94 | while (!isNullQueue_seq(A) || !isNullQueue_seq(B)) { 95 | if (!isNullQueue_seq(A)){ 96 | printf("%d ", delQueue_seq(A)); 97 | } 98 | if (!isNullQueue_seq(A)){ 99 | printf("%d ", delQueue_seq(A)); 100 | } 101 | if (!isNullQueue_seq(B)){ 102 | printf("%d ", delQueue_seq(B)); 103 | } 104 | } 105 | 106 | } 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | -------------------------------------------------------------------------------- /hash/hash.h: -------------------------------------------------------------------------------- 1 | #ifndef HASH_H_INCLUDED 2 | #define HASH_H_INCLUDED 3 | #include 4 | #include 5 | /*哈希结构*/ 6 | struct hashTable 7 | { 8 | int *element;//存放键值的连续空间起始地址 9 | int maxNum;// 哈希表长度 10 | int curNum;//当前哈希表已有数据元素 11 | }; 12 | struct node 13 | { 14 | int data; 15 | struct node *next; 16 | }; 17 | 18 | struct hashTable_link 19 | { 20 | struct node *element; 21 | int maxNum;// 哈希表长度 22 | }; 23 | /*第一关*/ 24 | //初始化一个哈希表，能满足线性探测再散列处理冲突法使用，初始化哈希表元素均为-1，表示该位置为空，可插入 25 | struct hashTable* initHashTable_linear() 26 | { 27 | struct hashTable *hashT=(struct hashTable *)malloc(sizeof(struct hashTable)); 28 | hashT->maxNum=10; 29 | hashT->element=(int *)malloc(sizeof(int)*hashT->maxNum); 30 | 31 | for(int i=0;imaxNum;i++) 32 | { 33 | hashT->element[i]=-1; 34 | } 35 | return hashT; 36 | } 37 | 38 | //初始化一个哈希表，能满足拉链法处理冲突法使用。初始化哈希表元素为0，用于计算该条链中数据个数，在插入时增加 39 | struct hashTable_link * initHashTable_link() 40 | { 41 | struct hashTable_link * hashL=(struct hashTable_link*)malloc(sizeof(struct hashTable_link)); 42 | hashL->element=NULL; 43 | hashL->maxNum=10; 44 | hashL->element=(struct node*)malloc(sizeof(struct node)*hashL->maxNum); 45 | 46 | for(int i=0;imaxNum;i++) 47 | { 48 | hashL->element[i].data=0; 49 | hashL->element[i].next=NULL; 50 | } 51 | return hashL; 52 | } 53 | 54 | /*第二关*/ 55 | //输出线性探测再散列法构建的哈希表,从下标为0的元素开始输出，每输出一个数据空一格 56 | void printHashTable(struct hashTable *h) 57 | { 58 | for(int i=0;imaxNum;i++) 59 | printf("%d ",h->element[i]); 60 | } 61 | 62 | 63 | /*第三关*/ 64 | //哈希函数，h(key) = (key*3) % 7 65 | int hashFun(int key) 66 | { 67 | return (key*3)%7; 68 | } 69 | 70 | //函数功能：计算key的哈希地址，若发生冲突，则使用线性探测再散列的方法查找合适的插入位置下标，并返回该下标 71 | int findPos(struct hashTable *h , int key) 72 | { 73 | int k; 74 | k=hashFun(key); 75 | if(h->element[k]==-1) 76 | { 77 | h->element[k]=key; 78 | return k; 79 | } 80 | else 81 | { 82 | for(int i=k;imaxNum;i++) 83 | { 84 | if(h->element[i]==-1) 85 | { 86 | h->element[i]=key; 87 | return i; 88 | } 89 | } 90 | for(int i=0;ielement[i]==-1) 93 | { 94 | h->element[i]=key; 95 | return i; 96 | } 97 | } 98 | } 99 | return -1; 100 | } 101 | 102 | //插入键值函数,若哈希表空间已满，则返回-1，否则返回插入位置下标 103 | int insertKey(struct hashTable *h , int key) 104 | { 105 | int pos; 106 | pos=findPos(h,key); 107 | return pos; 108 | } 109 | #endif // HASH_H_INCLUDED 110 | -------------------------------------------------------------------------------- /树/二叉树——课上练（顺序存储结构）.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | /* 5 | 定义顺序存储结构 6 | */ 7 | struct seqTree 8 | { 9 | int max; 10 | char *str; 11 | }; 12 | 13 | /*辅助功能：逐个输出顺序表的元素，元素之间以空格为界*/ 14 | void printTree(struct seqTree *T) 15 | { 16 | for (int i = 0; i < T->max; i ++) printf("%c ", T->str[i]); 17 | 18 | } 19 | 20 | /*第一关*/ 21 | struct seqTree *createSeqTree() 22 | { 23 | //此处编写代码实现二叉树的初始化，包括输入数据 24 | char arr[255]; 25 | gets(arr); 26 | int len = strlen(arr); 27 | 28 | struct seqTree * tree = (struct seqTree *)malloc(sizeof(struct seqTree)); 29 | tree->max = len; 30 | tree->str = (char *)malloc(sizeof(char) * (len + 1)); 31 | for (int i = 0; i <= len ; i ++) tree->str[i] = arr[i]; 32 | return tree; 33 | } 34 | 35 | /*第二关，返回二叉树的根结点的值，若二叉树为空，则返回#*/ 36 | char root(struct seqTree *T) 37 | { 38 | if (T->max == 0 || T->str[0] == ' ') return '#'; 39 | return T->str[0]; 40 | } 41 | 42 | /*第二关，求二叉树T中指定结点ch的双亲结点，返回值是双亲结点的下标，若双亲不存在，则返回-1*/ 43 | int parent(struct seqTree *T ,char ch) 44 | { 45 | for (int i = 0; i < T->max ; i ++) { 46 | if (ch == T->str[i]){ 47 | int p = (i - 1) >> 1; 48 | if (T->str[p] == ' ') return -1; 49 | return p; 50 | } 51 | } 52 | } 53 | 54 | /*第二关，求二叉树T中指定结点ch的左孩子的下标，若左孩子不存在，则返回-1*/ 55 | int leftChild(struct seqTree *T ,char ch) 56 | { 57 | for (int i = 0; i < T->max ; i ++) { 58 | if (ch == T->str[i]){ 59 | int lc = i * 2 + 1; 60 | if (lc > T->max || T->str[lc] == ' ') return -1; 61 | return lc; 62 | } 63 | } 64 | 65 | 66 | } 67 | 68 | /*第二关，求二叉树T中指定结点ch的右孩子的下标，若左孩子不存在，则返回-1*/ 69 | int rightChild(struct seqTree *T ,char ch) 70 | { 71 | for (int i = 0; i < T->max ; i ++) { 72 | if (ch == T->str[i]){ 73 | int rc = i * 2 + 2; 74 | if (rc > T->max || T->str[rc] == ' ') return -1; 75 | return rc; 76 | } 77 | } 78 | } 79 | 80 | /*第三关：层序遍历二叉树，输出遍历得到的结点，结点之间不需要空格*/ 81 | void levelOrder(struct seqTree *T ) 82 | { 83 | for (int i = 0; i < T->max; i ++ ) 84 | if (T->str[i] != ' ') printf("%c", T->str[i]); 85 | } 86 | 87 | /*第四关：先序遍历二叉树，输出遍历得到的结点，结点之间不需要空格*/ 88 | void preOrder(struct seqTree *T, char r) 89 | { 90 | 91 | int lc = leftChild(T, r); 92 | int rc = rightChild(T, r); 93 | if (r != '#') printf("%c", r); 94 | if (lc != -1) preOrder(T, T->str[lc]); 95 | if (rc != -1) preOrder(T, T->str[rc]); 96 | } 97 | 98 | 99 | int main(void) 100 | { 101 | struct seqTree *T = createSeqTree(); 102 | // printTree(T); //测评第一关时，把本行代码放开 103 | // printf("%c\n",root(T)); // 测评第二关时，把该代码块放开 104 | // printf("%d\n",leftChild(T,'A')); 105 | // printf("%d\n",rightChild(T,'A')); 106 | // printf("%d\n",parent(T,'A')); 107 | 108 | // levelOrder(T); //测评第三关时，把本行代码放开 109 | preOrder(T, T->str[0]); //测评第四关时，把本行代码放开 110 | 111 | } 112 | 113 | 114 | -------------------------------------------------------------------------------- /暑期/线性表综合应用实践-3.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | 8 | using namespace std; 9 | 10 | typedef struct MyStruct 11 | { 12 | int num; 13 | string name; 14 | string sub; 15 | } ns; 16 | 17 | vector reg; 18 | 19 | void Insert(int n){ 20 | while(n --){ 21 | int num; 22 | string name, sub; 23 | cin >> num >> name; 24 | getchar(); 25 | getline(cin, sub); 26 | ns s = {num, name, sub}; 27 | reg.push_back(s); 28 | } 29 | } 30 | 31 | void Select(string subject){ 32 | for (auto r : reg){ 33 | if (subject == "" || r.sub == subject){ 34 | printf("%03d ", r.num); 35 | cout << r.name << " " << r.sub << endl; 36 | } 37 | } 38 | } 39 | 40 | void Update(int id, string sub){ 41 | for (auto r = reg.begin(); r != reg.end(); r ++){ 42 | if (id == r->num) { 43 | r->sub = sub; 44 | break; 45 | } 46 | } 47 | Select(""); 48 | } 49 | 50 | void Delete(int id){ 51 | for (auto r = reg.begin(); r != reg.end(); r ++){ 52 | if (id == r->num) { 53 | reg.erase(r); 54 | break; 55 | } 56 | } 57 | Select(""); 58 | } 59 | 60 | typedef pair psi; 61 | bool cmp(const psi &a, const psi &b){ 62 | if (a.second != b.second){ 63 | return a.second > b.second; 64 | } else { 65 | return a.first < b.first; 66 | } 67 | } 68 | 69 | void Sum(){ 70 | map sum; 71 | vector vpsi; 72 | for (auto r : reg) { 73 | sum[r.sub] ++; 74 | } 75 | for (auto s : sum){ 76 | vpsi.push_back({s.first, s.second}); 77 | } 78 | sort(vpsi.begin(), vpsi.end(), cmp); 79 | for (auto v : vpsi){ 80 | cout << v.first << " " << v.second << endl; 81 | } 82 | } 83 | 84 | int main (int argc, char *argv[]) 85 | { 86 | int m = 6; 87 | while (m --) 88 | { 89 | int op, n; 90 | string m; 91 | cin >> op; 92 | switch (op) { 93 | case 1: 94 | cin >> n; 95 | Insert(n); 96 | break; 97 | case 2: 98 | Select(""); 99 | break; 100 | case 3: 101 | getchar(); 102 | getline(cin, m); 103 | Select(m); 104 | break; 105 | case 4: 106 | cin >> n; 107 | getchar(); 108 | getline(cin, m); 109 | Update(n, m); 110 | break; 111 | case 5: 112 | cin >> n; 113 | Delete(n); 114 | break; 115 | default: 116 | Sum(); 117 | break; 118 | } 119 | 120 | } 121 | 122 | return 0; 123 | } 124 | -------------------------------------------------------------------------------- /线性表/链表.h: -------------------------------------------------------------------------------- 1 | #ifndef FUN_H_INCLUDED 2 | #define FUN_H_INCLUDED 3 | #include 4 | #include 5 | //第一关代码 6 | struct node 7 | {//此处填写代码，定义链表结点类型，包含一个存放整型数据的 data 成员，和一个指向下一个结点的next成员 8 | 9 | int data; 10 | struct node *next; 11 | }; 12 | typedef struct node *List; 13 | 14 | struct node *mycreateList() 15 | {//此处填写代码，创建一个只有一个头结点的空链表，头节点的数据域赋值为0，并将表头结点的地址返回 16 | List head=(List)malloc(sizeof(struct node)); 17 | head->data=0; 18 | head->next=NULL; 19 | return head; 20 | } 21 | 22 | 23 | //第二关代码 24 | 25 | void myinsertHead(struct node * head, int insData ) 26 | { 27 | /*在此处完成任务，实现在head为表头d 链表的头插数据元素insData的功能*/ 28 | //begin 29 | List p=(List)malloc(sizeof(struct node)); 30 | p->data=insData; 31 | p->next=head->next; 32 | head->next=p; 33 | //end 34 | } 35 | 36 | void myinsertTail(struct node * head , int insData ) 37 | { 38 | /*在此处完成任务，在head为表头的单链表表尾插入数据元素insData*/ 39 | //begin 40 | List p=(List)malloc(sizeof(struct node)); 41 | List tail=(List)malloc(sizeof(struct node)); 42 | tail=head; 43 | while(tail->next!=NULL) 44 | tail=tail->next; 45 | 46 | p->data=insData; 47 | p->next=NULL; 48 | tail->next=p; 49 | tail=p; 50 | //end 51 | } 52 | 53 | void myprintList(struct node *L) 54 | { 55 | /*在此处完成任务，输出head为表头链表中的数据，每输出一个数据换一行*/ 56 | //begin 57 | List p; 58 | for(p=L->next;p!=NULL;p=p->next) 59 | { 60 | printf("%d\n",p->data); 61 | } 62 | //end 63 | } 64 | 65 | //第三关代码 66 | void reverseList_link( struct node *L) 67 | { 68 | //请在此处填入代码，实现链表逆置功能 69 | //begin 70 | List pHead,p,q; 71 | pHead=L; 72 | p=pHead->next; 73 | pHead->next=NULL; 74 | while(p!=NULL) 75 | { 76 | q=p; 77 | p=p->next; 78 | q->next=pHead->next; 79 | pHead->next=q; 80 | } 81 | //end 82 | } 83 | 84 | 85 | //第四关代码 86 | int locateAndChange( struct node *L, int data) 87 | { 88 | //请在此处填入代码，在头结点为L的链表中查找 与data值相等的第一个结点，若能找到该结点，则将该结点的值与前驱结点的值交换 89 | //若未找到与data值相等的结点，则返回值为-1，若找到的结点无前驱结点，则返回值为0，否则返回值为前驱结点的值 90 | //begin 91 | List p,q; 92 | int temp; 93 | for(p=L->next;p->next!=NULL;p=p->next) 94 | { 95 | if(p->next->data==data) 96 | { 97 | temp=p->data; 98 | p->data=p->next->data; 99 | p->next->data=temp; 100 | return temp; 101 | } 102 | if(L->next->data==data) 103 | return 0; 104 | } 105 | return -1; 106 | //end 107 | } 108 | 109 | //第五关代码 110 | int destroyList(struct node *L) 111 | { 112 | //请在此处填写代码，实现将链表L的结点空间回收 113 | //返回值为回收结点的个数，含头结点在内 114 | List p,q; 115 | int i; 116 | for(p=L,i=0;p!=NULL;i++) 117 | { 118 | q=p; 119 | p=p->next; 120 | free(q); 121 | } 122 | return i; 123 | } 124 | #endif // FUN_H_INCLUDED 125 | -------------------------------------------------------------------------------- /栈/seqlist.h: -------------------------------------------------------------------------------- 1 | #ifndef SEQLIST_H_INCLUDED 2 | #define SEQLIST_H_INCLUDED 3 | #include 4 | #include 5 | /*此处是顺序栈数据结构定义*/ 6 | typedef int DataType; 7 | struct seqStack 8 | {//有3个数据成员 9 | int MAXNUM;//用于记录顺序栈中能存放的最大元素个数的 整型 MAXNUM 10 | int top;//用于存放顺序栈的栈顶位置，初始化为0或-1 均可 整型 curNum 11 | DataType *element;//用于存放顺序栈数据元素的连续空间的起始地址 12 | }; 13 | 14 | typedef struct seqStack *PseqStack; 15 | //第一关 16 | PseqStack createNullStack_seq(int m) 17 | {//此处填写代码，创建一个空的顺序栈，能存放的最大元素个数为 m,栈顶top设置为0 18 | //若m=0，则返回NULL 19 | if(m==0) return NULL; 20 | PseqStack s=(PseqStack)malloc(sizeof(struct seqStack)); 21 | if(s!=NULL) 22 | { 23 | s->element=(DataType)malloc(m*sizeof(DataType)); 24 | } 25 | s->top=0; 26 | s->MAXNUM=m; 27 | return s; 28 | } 29 | 30 | //第二关 31 | int isNullStack_seq(PseqStack L) 32 | { 33 | //判断顺序栈是否为空，若为空，返回值为1，否则返回值为0,若栈不存在，则返回-1 34 | if(L==NULL) return -1; 35 | if(L->top==0) return 1; 36 | else return 0; 37 | } 38 | 39 | 40 | //第三关 41 | int isFullStack_seq(PseqStack L) 42 | { 43 | //判断顺序栈是否已满，若已满，返回值为1，否则返回值为0 44 | if(L->top==L->MAXNUM-1) return 1; 45 | else return 0; 46 | } 47 | 48 | 49 | //第四关 50 | int push_seq(PseqStack L ,DataType x) 51 | {//在顺序栈中插入数据元素x，若插入不成功，返回0；插入成功返回值为1 52 | if(L->top==L->MAXNUM) return 0; 53 | L->element[L->top]=x; 54 | L->top=L->top+1; 55 | return 1; 56 | } 57 | 58 | 59 | 60 | //第五关 61 | DataType pop_seq(PseqStack L) 62 | {//弹栈并返回删除元素，若栈为空，则返回-1 63 | L->top=L->top-1; 64 | if(L->top<0) return -1; 65 | int flag=L->element[L->top]; 66 | return flag; 67 | } 68 | 69 | //第六关 70 | DataType top_seq(PseqStack L) 71 | {// 取栈顶元素返回，若栈为空，则返回-1 72 | if(L->top==0) return -1; 73 | return L->element[L->top-1]; 74 | } 75 | 76 | //销毁顺序栈，释放栈所占存储空间 77 | int destroystack_seq(PseqStack L) 78 | { 79 | //返回值为销毁的栈中现有数据元素的个数，若待销毁的线性表不存在，则返回0 80 | int flag=L->top; 81 | free(L); 82 | return flag; 83 | } 84 | 85 | 86 | //第七关 87 | //使用已实现的栈操作，实现数制转换 88 | 89 | void print(PseqStack L) 90 | { 91 | //逐个弹出栈L中的数据元素并输出，输出数据间不需要任何间隔符号 92 | for(int i=L->top-1;i>=0;i--) 93 | if(L->element[i]<10) printf("%d",L->element[i]); 94 | else printf("%c",L->element[i]+55); 95 | 96 | } 97 | 98 | void convert(int data , int k) 99 | { 100 | //利用栈实现将data转换为k进制，k可能是2，8，16. 在本函数内实现转换并调用print函数输出转换后的结果 101 | //十六进制时输出 A ,B ,C, D,E,F 使用大写字母 102 | PseqStack L=createNullStack_seq(20); 103 | if(k==2) 104 | { 105 | while(data) 106 | { 107 | push_seq(L,data%k); 108 | data=data/k; 109 | } 110 | print(L); 111 | } 112 | if(k==8) 113 | { 114 | while(data) 115 | { 116 | push_seq(L,data%k); 117 | data=data/k; 118 | } 119 | print(L); 120 | } 121 | if(k==16) 122 | { 123 | while(data) 124 | { 125 | push_seq(L,data%k); 126 | data=data/k; 127 | } 128 | print(L); 129 | } 130 | } 131 | #endif // SEQLIST_H_INCLUDED 132 | -------------------------------------------------------------------------------- /暑期/暑期3-链表入门.h: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | //第一关代码 4 | 5 | struct node 6 | {//此处填写代码，定义链表结点类型，包含一个存放整型数据的 成员，和一个指向下一个结点的成员 7 | int data; 8 | node *next; 9 | }; 10 | 11 | struct node *mycreateList() 12 | {//此处填写代码，创建一个只有一个头结点的空链表，头节点的数据域赋值为0，并将表头结点的地址返回 13 | node *head = new node(); 14 | head->data = 0; 15 | head->next = NULL; 16 | } 17 | 18 | 19 | //第二关代码 20 | 21 | void myinsertHead(struct node * head, int insData ) 22 | { 23 | /*在此处完成任务，实现在head为表头d 链表的头插数据元素insData的功能*/ 24 | //begin 25 | node *p = new node(); 26 | p->data = insData; 27 | p->next = head->next; 28 | head->next = p; 29 | 30 | //end 31 | } 32 | 33 | void myinsertTail(struct node * head , int insData ) 34 | { 35 | /*在此处完成任务，在head为表头的单链表表尾插入数据元素insData*/ 36 | //begin 37 | node *p = head; 38 | p->data ++; 39 | node *n = new node(); 40 | n->data = insData; 41 | for (; p->next != NULL ; p = p->next); 42 | p->next = n; 43 | n->next = NULL; 44 | //end 45 | } 46 | 47 | void myprintList(struct node *L) 48 | { 49 | /*在此处完成任务，输出L为表头链表中的数据，每输出一个数据换一行*/ 50 | //begin 51 | for (auto p = L; p != NULL; p = p->next) 52 | if (p != L) cout << p->data << endl; 53 | //end 54 | 55 | } 56 | 57 | 58 | 59 | 60 | //第三关代码 61 | int myfindPos( struct node *L, int pos) 62 | { 63 | //请在此处填入代码，实现在链表中查找第pos个结点的功能 64 | //begin 65 | node *p = L; 66 | for (int i = 1 ; i <= pos && p != NULL ; i ++) 67 | p = p->next; 68 | if (pos < 1) return -1; 69 | if (p == NULL) return -1; 70 | return p->data; 71 | 72 | //end 73 | } 74 | 75 | int myfindKey( struct node *L, int key) 76 | { 77 | //请在此处填入代码，实现在链表中查找与key值相同的第一个结点的功能 78 | //begin 79 | node *p = L ; 80 | 81 | for (; p->data != key && p->next != NULL;) p = p->next; 82 | 83 | if (p != NULL && p->data == key) return 1; 84 | 85 | return 0; 86 | //end 87 | } 88 | 89 | //第四关代码 90 | int mydeletePos( struct node *L, int pos) 91 | { 92 | //请在此处填入代码，实现在链表中删除第pos个结点的功能 93 | //begin 94 | node *p = L; 95 | node *pre = NULL; 96 | for (int i = 1 ; i <= pos && p->next != NULL ; i ++){ 97 | pre = p; 98 | p = p->next; 99 | } 100 | 101 | pre->next = p->next; 102 | delete p; 103 | L->data --; 104 | return 1; 105 | //end 106 | } 107 | 108 | int mydeleteKey( struct node *L, int key) 109 | { 110 | //请在此处填入代码，实现在链表中删除与key值相同的第一个结点的功能 111 | //begin 112 | node *p = L; 113 | node *pre = NULL; 114 | 115 | for (; p->data != key && p != NULL;){ 116 | pre = p; 117 | p = p->next; 118 | } 119 | if (p == NULL || p->data != key){ 120 | return 0; 121 | } 122 | pre->next = p->next; 123 | delete p; 124 | L->data --; 125 | return 1; 126 | //end 127 | } 128 | 129 | //第五关代码 130 | void reverseList_link( struct node *L) 131 | { 132 | //请在此处填入代码，实现链表逆置功能 133 | //begin 134 | node *p = L->next; 135 | node *pre = NULL; 136 | for (; p != NULL ; ){ 137 | node *tmp = p->next; 138 | p->next = pre; 139 | pre = p; 140 | p = tmp; 141 | } 142 | L->next = pre; 143 | //end 144 | } 145 | 146 | 147 | 148 | 149 | -------------------------------------------------------------------------------- /插入排序/1-4.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | /*数据结构定义*/ 5 | typedef int DataType; 6 | typedef struct 7 | { 8 | DataType *data; //用于存放待排序关键字的起始地址 9 | int NUM; //待排序关键字的个数 10 | } SortObject; 11 | 12 | typedef struct node //用于表插入排序的数据结构 13 | { 14 | DataType info; 15 | struct node *next; 16 | } linkObject; 17 | 18 | //输出顺序表 19 | void print(SortObject *p) 20 | { 21 | for(int i=0;iNUM;i++) 22 | printf("%d ",p->data[i]); 23 | printf("\n"); 24 | } 25 | 26 | //输出链表 27 | void printLink(linkObject *Head) 28 | { 29 | linkObject *p = Head->next ; 30 | while(p) 31 | { 32 | printf("%d ",p->info); 33 | p = p->next; 34 | } 35 | printf("\n"); 36 | } 37 | 38 | /*第一关 39 | 此处请填写代码实现递增序进行直接插入排序, 40 | 要求每趟排序后 调用print函数，输出关键字的排列情况*/ 41 | void insertSort( SortObject *Rec ) 42 | { 43 | 44 | /*----begin------*/ 45 | for (int i = 1; i < Rec->NUM; i ++){ 46 | int key = Rec->data[i]; 47 | int pre = i - 1; 48 | while ( pre >= 0 && key < Rec->data[pre]) { 49 | Rec->data[pre+1] = Rec->data[pre]; 50 | pre --; 51 | } 52 | Rec->data[pre+1] = key; 53 | print(Rec); 54 | } 55 | 56 | /*-----end------*/ 57 | 58 | } 59 | 60 | /*第二关 61 | 此处请填写代码实现递增序进行二分插入排序, 62 | 63 | 实质是在已经有序的表中采用二分法查找插入位置 64 | 要求每趟排序后 调用print函数，输出关键字的排列情况*/ 65 | void binInsertSort( SortObject *Rec ) 66 | { 67 | printf("the result of binInsertSort:\n"); 68 | /*----begin------*/ 69 | for (int i = 1; i < Rec->NUM; i ++){ 70 | int key = Rec->data[i]; 71 | int pre = i - 1; 72 | 73 | int l = 0, r = i; 74 | while (l < r) { 75 | int mid = l + r >> 1; 76 | if (Rec->data[mid] >= key) r = mid; 77 | else l = mid + 1; 78 | } 79 | int idx; 80 | if (Rec->data[l] >= key){ 81 | idx = l; 82 | } else { 83 | idx = i + 1; 84 | } 85 | 86 | while ( pre >= idx && key < Rec->data[pre]) { 87 | Rec->data[pre+1] = Rec->data[pre]; 88 | pre --; 89 | } 90 | Rec->data[pre+1] = key; 91 | print(Rec); 92 | } 93 | 94 | 95 | /*-----end------*/ 96 | 97 | } 98 | 99 | /* 第四关 100 | 此处请填写代码实现递增序进行shell排序, 101 | 102 | 要求每趟排序后 调用print函数，输出关键字的排列情况 103 | */ 104 | void shellSort( SortObject *Rec,int d ) 105 | { 106 | int num = 2*d; 107 | while(d > 0) { 108 | for (int i = 0; i < d; i++) { 109 | for (int j = i+d; j < num; j+=d) { 110 | int temp = Rec->data[j]; 111 | int k; 112 | for (k = j-d; k >= 0; k-=d) { 113 | if (Rec->data[k] > Rec->data[j]) { 114 | Rec->data[k+d] = Rec->data[k]; 115 | } else break; 116 | } 117 | 118 | Rec->data[k+d] = temp; 119 | } 120 | } 121 | d = d / 2; 122 | print(Rec); 123 | } 124 | 125 | } 126 | 127 | /*第三关 128 | 此处请填写代码实现递增序进行表插入排序, 129 | 返回值是关键字比较次数 130 | Head是表头结点，不存放数据，info是待插入数据 131 | 要求每趟排序后 调用printLink函数，输出关键字的排列情况 132 | */ 133 | void listSort(linkObject *plist ) 134 | { 135 | /*----begin------*/ 136 | linkObject *p = plist->next; 137 | printLink(plist); 138 | 139 | while( p->next != NULL) { 140 | while(p->info < p->next->info) { 141 | p = p->next; 142 | } 143 | 144 | linkObject *tmp = (linkObject *)malloc(sizeof(linkObject)); 145 | tmp->info = p->next->info; 146 | p->next = p->next->next; 147 | // p = p->next; 148 | 149 | linkObject *q = plist; 150 | while(q->next->info < tmp->info) { 151 | q = q->next; 152 | } 153 | 154 | tmp->next = q->next; 155 | q->next = tmp; 156 | 157 | printLink(plist); 158 | } 159 | /*-----end------*/ 160 | 161 | } 162 | 163 | -------------------------------------------------------------------------------- /实验/顺序表.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | /*此处是顺序线性表数据结构定义*/ 5 | typedef int DataType; 6 | struct seqList 7 | {//有3个数据成员 8 | int MAXNUM;//用于记录顺序线性表中能存放的最大元素个数的 整型 MAXNUM 9 | int curNum;//用于存放顺序线性表中数据元素的个数 整型 curNum 10 | DataType *element;//用于存放顺序线性表数据元素的连续空间的起始地址 11 | }; 12 | 13 | typedef struct seqList *PseqList; 14 | /*创建空的顺序线性表，能存放的最大元素个数为 m*/ 15 | PseqList createNullList_seq(int m) 16 | { //若m=0，则返回NULL 17 | PseqList plist = (struct seqList *)malloc(sizeof(struct seqList)); 18 | if(plist == NULL) return NULL; //分配空间失败 19 | plist->MAXNUM = m ; 20 | plist->curNum = 0; 21 | plist->element = (DataType *)malloc(sizeof(DataType)*m); 22 | if(plist->element == NULL) 23 | { 24 | free(plist); 25 | return NULL; 26 | } 27 | return plist; 28 | } 29 | 30 | /*在线性表表尾插入数据元素,返回值0表示插入失败，返回值1表示在表尾插入成功*/ 31 | int insertP_tail(PseqList plist , int x) 32 | { 33 | if(plist->curNum == plist->MAXNUM) //若表满，则无法插入 34 | { 35 | printf("list if full !"); 36 | return 0; 37 | } 38 | plist->element[plist->curNum] = x ; 39 | plist->curNum++; 40 | return 1; 41 | 42 | } 43 | 44 | /*回收线性表占用的空间*/ 45 | int destroyList_seq(PseqList plist) 46 | { 47 | //返回值为销毁的线性表中现有数据元素的个数，若待销毁的线性表不存在，则返回0 48 | if(plist == NULL) return 0; 49 | int m = plist->curNum; 50 | free(plist->element); 51 | free(plist); 52 | return m; 53 | 54 | } 55 | 56 | void printList_seq(PseqList plist) 57 | {//逐个输出线性表的元素，相邻的两个数据元素之间以一个空格为分隔符隔开 58 | for(int i=0;icurNum;i++) 59 | printf("%d ",plist->element[i]); 60 | } 61 | 62 | //第一关:求顺序线性表中连续子表（最少有一个元素）的最大和并输出 63 | int seqMaxSum(PseqList plist) 64 | { 65 | int cur_max=0,sum_max=0; 66 | for(int i=0;icurNum;i++) 67 | { 68 | cur_max+=plist->element[i]; 69 | if(sum_max < cur_max) 70 | sum_max=cur_max; 71 | if(cur_max<0) 72 | cur_max=0; 73 | } 74 | return sum_max; 75 | } 76 | 77 | //第二关：寻找线性表中没有出现的最小的正整数 78 | int findMinNumber(PseqList plist) 79 | { 80 | //若线性表为空，则返回0 81 | if(plist==NULL) return 0; 82 | 83 | int n=plist->curNum+1; 84 | 85 | int p[n]; 86 | 87 | for(int i=0;ielement[j]<=plist->curNum) 92 | p[plist->element[j]-1]=plist->element[j]; 93 | //类似原地哈希 94 | } 95 | 96 | for(int j=0;jcurNum; 105 | int l=0,r=n; 106 | while(l>1; 109 | if(plist->element[mid]>=target) r=mid; 110 | else l=mid+1; 111 | } 112 | if(plist->element[l]!=target) pos[0]=-1,pos[1]=-1; 113 | else 114 | { 115 | pos[0]=l; 116 | int l=0,r=n; 117 | while(l>1; 120 | if(plist->element[mid]<=target) l=mid; 121 | else r=mid-1; 122 | } 123 | if(plist->element[l]!=target) pos[1]=-1; 124 | else pos[1]=l; 125 | } 126 | int A[plist->curNum],flag=plist->element[0]; 127 | for(int i=0;icurNum;i++) A[i]=plist->element[i]; 128 | for(int i=0;icurNum;i++) A[i]=A[i]-flag; 129 | for(int i=0;icurNum;i++) 130 | if(A[i]==0) 131 | { 132 | pos[0]=0,pos[1]=plist->curNum-1; 133 | } 134 | } 135 | -------------------------------------------------------------------------------- /实验/队列.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | #include 4 | #include 5 | #include 6 | 7 | typedef char DataType; 8 | 9 | 10 | //队列数据元素结构 11 | typedef struct node 12 | { 13 | DataType info; 14 | //数据位 15 | struct node *next; 16 | //下一节点位 17 | }QueueData; 18 | 19 | typedef struct queueRecord{ 20 | QueueData *front, *rear ; 21 | //队列结构 22 | }LINKQUEUE; 23 | 24 | typedef struct queueRecord *PLinkQueue; 25 | 26 | PLinkQueue createEmptyQueue_link( ) 27 | { 28 | //创建一个空队列(意思是没有数据)，实质：生成一个LINKQUEUE类型的结点，并给front 和 rear 成员赋值（？赋空？） 29 | //请在此处填写代码，完成相应功能 30 | /*-------begin----------*/ 31 | PLinkQueue head=(PLinkQueue)malloc(sizeof(LINKQUEUE)); 32 | if(head!=NULL) 33 | { 34 | head->front=NULL; 35 | head->rear=NULL; 36 | } 37 | return head; 38 | /*-------end----------*/ 39 | 40 | } 41 | 42 | int isEmptyQueue_link(PLinkQueue queue) 43 | { //判定队列是否为空，实质： 看队列的front指针是否为空，若为空，则队列为空 44 | 45 | //请在此处填写代码，完成相应功能 46 | /*-------begin----------*/ 47 | return (queue->front==NULL); 48 | /*-------end----------*/ 49 | } 50 | 51 | void enQueue_link(DataType x, PLinkQueue queue) 52 | { 53 | //将数据元素x插入队尾。实质：生成一个struct node类型的结点，并给相应成员赋值后插入队尾 54 | //请在此处填写代码，完成相应功能 55 | /*-------begin----------*/ 56 | QueueData* p; 57 | p=(QueueData*)malloc(sizeof(QueueData)); 58 | if(p==NULL) 59 | { 60 | return; 61 | } 62 | else 63 | { 64 | p->info=x; 65 | p->next=NULL; 66 | if(isEmptyQueue_link(queue)) 67 | queue->front=p; 68 | else 69 | queue->rear->next=p; 70 | queue->rear=p; 71 | } 72 | /*-------end----------*/ 73 | } 74 | 75 | void enQueue_link(QueueData *p,PLinkQueue Q) 76 | { 77 | //本函数的功能是将 struct node 类型的结点插入队尾，与enQueue_link(DataType x, PLinkQueue queue)的区别是，不需要生成结点 78 | 79 | //请在此处填写代码，完成相应功能 80 | /*-------begin----------*/ 81 | p->next=NULL; 82 | if(isEmptyQueue_link(Q)) 83 | Q->front=p; 84 | else 85 | Q->rear->next=p; 86 | Q->rear=p; 87 | /*-------end----------*/ 88 | 89 | } 90 | 91 | DataType deQueue_link(PLinkQueue Q) 92 | { 93 | //出队，实质： 取出Q队列的队首结点，返回该结点的数据元素，并将该结点使用enQueue_link(QueueData *p,PLinkQueue Q)插入队尾 94 | //本函数为针对本实验特殊设计，可实现秘钥的循环使用 95 | //请在此处填写代码，完成相应功能 96 | /*-------begin----------*/ 97 | QueueData *p; 98 | DataType info; 99 | 100 | p=Q->front; 101 | info=p->info; 102 | Q->front=p->next; 103 | enQueue_link(info,Q); 104 | 105 | return p->info; 106 | /*-------end----------*/ 107 | } 108 | 109 | void decrypt(char src[], char key[], char dest[]) 110 | { 111 | /* 参数： src 放的是源文 ； key 放的是秘钥 ； dest 放加密后的密文 112 | 加密函数： 步骤提示 113 | 1. 初始化一个空队列Q 114 | 2. 将key数组的元素逐个插入队列Q 115 | 3. 逐个访问src数组的源文，并加密， 使用deQueue_link(Q)函数可得到队首秘钥，并使秘钥循环使用 116 | 闯关提示：如果输出一样的加密后字符串，但是无法过关，是因为加密后的字符串尾部少了\0,加上\0即可 117 | */ 118 | PLinkQueue k=createEmptyQueue_link(); 119 | int len=strlen(src); 120 | //申请空间，获取长度 121 | for(int i=0;key[i]!='\0';i++) 122 | { 123 | char temp=key[i]; 124 | enQueue_link(temp,k); 125 | } 126 | //输入进队列 127 | for(int i=0;src[i]!='\0';i++) 128 | { 129 | char K=deQueue_link(k); 130 | int K_num=K-'0'; 131 | dest[i]=src[i]+K_num; 132 | } 133 | dest[len]='\0'; 134 | } 135 | 136 | int main(void) 137 | { 138 | char src[80],key[20], dest[80] ; 139 | 140 | cin>>src ; 141 | 142 | cin>>key; 143 | decrypt(src , key , dest); 144 | cout< 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | int N; //全局变量N表示输入数据个数 9 | 10 | struct node 11 | { 12 | float data; 13 | char code[20]; //存放哈夫曼编码 14 | struct node *left, *right;//左右节点 15 | struct node *next;//用链表去构造哈夫曼树 16 | int code_n; 17 | //做编码数组下标 18 | }; 19 | typedef struct node* PHT; 20 | typedef struct node NODE; 21 | 22 | // 哈夫曼树的结点定义 23 | struct node *Head; //头结点 24 | 25 | void printcode(struct node *p)//输出哈夫曼编码 26 | { 27 | int i; 28 | if(p==NULL) return ; 29 | for(i= p->code_n-1;i>=0 ;i--) 30 | cout<code[i]; 31 | //逆序输出每个哈夫曼码 32 | } 33 | 34 | void Insert(struct node *b) //插入结点，保持递增 35 | { 36 | struct node *p,*q; 37 | p=Head->next; 38 | q = Head; 39 | if(p == NULL) 40 | { 41 | Head->next = b; 42 | } 43 | else 44 | { 45 | while(p!=NULL && p->data < b->data) 46 | { 47 | q = p; 48 | p = p->next; 49 | } 50 | b->next = p; 51 | q->next = b; 52 | //找到合适b的位置 53 | } 54 | } 55 | 56 | 57 | void code(struct node *a,int flag) //编码过程 58 | { 59 | if (a==NULL) return ; 60 | //空的哈夫曼树 61 | if(flag==1) //flag为 1 表示左子树 62 | { 63 | a->code[a->code_n] = '0'; 64 | } 65 | else if(flag==2)//flag为2 表示右子树 66 | { 67 | a->code[a->code_n] = '1'; 68 | } 69 | a->code_n++; 70 | //对应节点下标索引自增，进行反向编码（由树的最下层到根节点） 71 | code(a->left, flag); 72 | code(a->right,flag); 73 | } 74 | 75 | void InitNode( ) //初始化结点 76 | { 77 | struct node *p; 78 | int i; 79 | float m; 80 | Head =(PHT)malloc(sizeof(NODE)); 81 | Head->left =Head->right = Head->next =NULL ; 82 | //初始化三个指针 83 | for(i=0;i>m; 86 | p = (PHT)malloc(sizeof(NODE)); 87 | p->data = m; 88 | //数据输入 89 | p->left = p->right = p->next =NULL; 90 | //左右置空 91 | p->code_n = 0; 92 | //下标置0 93 | Insert( p); 94 | //通过数据大小选择合适的位置 95 | } 96 | } 97 | 98 | 99 | void InOrder(struct node *T) 100 | { 101 | //中序遍历 102 | if(T==NULL) return; 103 | else 104 | { 105 | if(T->left == T->right && T->left == NULL) 106 | { 107 | cout<data<<" "; 108 | printcode(T); 109 | cout<left); 113 | InOrder(T->right); 114 | } 115 | } 116 | 117 | 118 | void Huffman()//创建haffman树 119 | { 120 | struct node *temp; 121 | struct node *p,*q; 122 | while(1) 123 | { 124 | p = Head->next; 125 | q = p->next; 126 | //此处的Head是全局变量 127 | if(q!=NULL) 128 | Head->next = q->next; 129 | else 130 | Head->next = NULL; 131 | //让最小和次小的两个节点断开，然后开始构造哈夫曼树。 132 | temp = (PHT)malloc(sizeof(NODE)); 133 | temp->data = p->data + q->data ; 134 | temp->left = p; 135 | temp->right = q; 136 | temp->code_n = 0; 137 | //由于按顺序存放节点，因此可以直接构造。 138 | //并且利用temp节点存放数据。 139 | code(p,1); 140 | code(q,2); 141 | //将左右树放入进行编码 142 | temp->next = NULL; 143 | Insert(temp); 144 | //将temp节点插入到合适位置，从小到大。 145 | if(Head->next->next == NULL)//就只剩下一个哈夫曼树和头结点时结束循环。 146 | break; 147 | } 148 | } 149 | 150 | 151 | int main(void) 152 | { 153 | cin>>N; 154 | //对全局变量N进行重构，重新定义最大数量。 155 | InitNode(); 156 | //初始化创建节点。 157 | Huffman(); 158 | //构造哈夫曼树和哈夫曼编码。 159 | InOrder(Head->next); 160 | //从根开始中序遍历。 161 | } 162 | /********** End *********/ 163 | 164 | -------------------------------------------------------------------------------- /实验/一元多项式相加.h: -------------------------------------------------------------------------------- 1 | #ifndef FUN1_H_INCLUDED 2 | #define FUN1_H_INCLUDED 3 | #include 4 | #include 5 | 6 | 7 | 8 | //存放多项式某项的结点结构 9 | struct node 10 | { 11 | int exp ; // 表示指数 12 | int coef ; //表示系数 13 | struct node *next; //指向下一个结点的指针 14 | }; 15 | 16 | typedef struct node * PNODE ; 17 | 18 | /* 19 | 函数功能：生成多项式 20 | 函数名：createPoly 21 | 函数参数：无 22 | 返回值：指向多项式的头指针 23 | */ 24 | PNODE createPoly(void) 25 | { 26 | //在此处填写代码，能实现创建一个多项式并返回多项式头指针的函数 27 | //注意：头指针不存放多项式的项。 28 | //exp表示指数,coef表示系数。 29 | /********** Begin **********/ 30 | PNODE head,t; 31 | int exp,coef; 32 | 33 | scanf("%d",&coef); 34 | scanf("%d",&exp); 35 | 36 | head=(PNODE)malloc(sizeof(struct node)); 37 | if(head==NULL) return 0; 38 | 39 | head->next=NULL; t=head; 40 | 41 | while(coef!=0||exp!=0) 42 | { 43 | PNODE p=(PNODE)malloc(sizeof(struct node)); 44 | p->next=NULL; 45 | if(p==NULL) return 0; 46 | 47 | p->exp=exp; 48 | p->coef=coef; 49 | 50 | if(head->next==NULL) 51 | { 52 | t->next=p; 53 | t=p; 54 | } 55 | else if(t->next==NULL) 56 | { 57 | t->next=p; 58 | t=p; 59 | } 60 | 61 | scanf("%d",&coef); 62 | scanf("%d",&exp); 63 | } 64 | return head; 65 | /********** End **********/ 66 | } 67 | 68 | /* 69 | 函数功能：进行多项式相加 70 | 函数名：addPoly 71 | 函数参数：polyAddLeft ：加法左边多项式头指针, polyAddRight：加法右边多项式头指针 72 | 返回值：指向结果多项式的头指针 73 | */ 74 | PNODE addPoly(PNODE polyAddLeft , PNODE polyAddRight) 75 | { 76 | //在此处填写代码，能实现创两个多项式相加并返回结果多项式头指针的函数 77 | /********** Begin **********/ 78 | PNODE res=(PNODE)malloc(sizeof(struct node)),tail; 79 | PNODE l=polyAddLeft->next,r=polyAddRight->next; 80 | res->next=NULL; 81 | tail=res; 82 | while(l||r) 83 | { 84 | PNODE p=(PNODE)malloc(sizeof(struct node)); 85 | p->next=NULL; 86 | 87 | if(l==NULL) 88 | { 89 | p->coef=r->coef; 90 | p->exp=r->exp; 91 | tail->next=p; 92 | tail=p; 93 | r=r->next; 94 | } 95 | else if(r==NULL) 96 | { 97 | p->coef=l->coef; 98 | p->exp=l->exp; 99 | tail->next=p; 100 | tail=p; 101 | l=l->next; 102 | } 103 | else if(l->exp==r->exp) 104 | { 105 | int sum=l->coef+r->coef; 106 | if(sum==0) 107 | { 108 | l=l->next; 109 | r=r->next; 110 | } 111 | else 112 | { 113 | p->exp=l->exp; 114 | p->coef=sum; 115 | tail->next=p; 116 | tail=p; 117 | l=l->next; 118 | r=r->next; 119 | } 120 | } 121 | else if(l->exp > r->exp) 122 | { 123 | p->exp=r->exp; 124 | p->coef=r->coef; 125 | tail->next=p; 126 | tail=p; 127 | r=r->next; 128 | } 129 | else if(l->exp < r->exp) 130 | { 131 | p->coef=l->coef; 132 | p->exp=l->exp; 133 | tail->next=p; 134 | tail=p; 135 | l=l->next; 136 | } 137 | } 138 | return res; 139 | /********** End **********/ 140 | } 141 | 142 | /* 143 | 函数功能：输出多项式 144 | 函数名：printPoly 145 | 函数参数：待输出多项式的头指针poly 146 | 返回值：无 147 | */ 148 | void printPoly(PNODE poly) 149 | { 150 | //在此处填写代码，能实现按格式输出多项式的功能，输出格式样例见说明 151 | /********** Begin **********/ 152 | PNODE p=poly->next; 153 | while(p) 154 | { 155 | if(p->next==NULL) 156 | { 157 | printf("%dx^%d",p->coef,p->exp); 158 | } 159 | else 160 | { 161 | printf("%dx^%d+",p->coef,p->exp); 162 | } 163 | p=p->next; 164 | } 165 | 166 | /********** End **********/ 167 | } 168 | 169 | void destroyPoly(PNODE poly) 170 | { 171 | //释放存储多项式的链表空间 172 | PNODE p=poly,t; 173 | while(p) 174 | { 175 | t=p; 176 | p=p->next; 177 | free(t); 178 | } 179 | } 180 | 181 | 182 | #endif // FUN1_H_INCLUDED 183 | -------------------------------------------------------------------------------- /暑期/暑期4-排序.h: -------------------------------------------------------------------------------- 1 | #include 2 | using namespace std; 3 | 4 | /*数据结构定义*/ 5 | typedef int DataType; 6 | typedef struct 7 | { 8 | DataType *data; //用于存放待排序关键字的起始地址 9 | int NUM; //待排序关键字的个数 10 | } SortObject; 11 | 12 | typedef struct node //用于表插入排序的数据结构 13 | { 14 | DataType info; 15 | struct node *next; 16 | } linkObject; 17 | 18 | //输出顺序表 19 | void print(SortObject *p) 20 | { 21 | for(int i=0;iNUM;i++) 22 | cout<data[i]<<" "; 23 | cout<next ; 30 | while(p) 31 | { 32 | cout<info<<" "; 33 | p = p->next; 34 | } 35 | cout<NUM; i ++){ 47 | int now = Rec->data[i]; 48 | int pre = i - 1; 49 | while (pre >= 0 && Rec->data[pre] > now){ 50 | Rec->data[pre+1] = Rec->data[pre]; 51 | pre --; 52 | } 53 | Rec->data[pre+1] = now; 54 | print(Rec); 55 | } 56 | 57 | /*-----end------*/ 58 | 59 | } 60 | 61 | /*第二关 62 | 此处请填写代码实现递增序进行二分插入排序, 63 | 64 | 实质是在已经有序的表中采用二分法查找插入位置 65 | 要求每趟排序后 调用print函数，输出关键字的排列情况*/ 66 | void binInsertSort( SortObject *Rec ) 67 | { 68 | cout<<"the result of binInsertSort:\n"; 69 | /*----begin------*/ 70 | for (int i = 1; i < Rec->NUM; i ++ ) { 71 | int now = Rec->data[i]; 72 | int l = 0, r = i - 1; 73 | 74 | while (l < r) { 75 | int mid = (l + r) >> 1; 76 | if (Rec->data[mid] >= now) r = mid; 77 | else l = mid + 1; 78 | } 79 | if (Rec->data[l] >= now) { 80 | int pot = i - 1; 81 | while (pot >= l) Rec->data[pot+1] = Rec->data[pot], pot --; 82 | Rec->data[l] = now; 83 | } 84 | print(Rec); 85 | } 86 | 87 | 88 | /*-----end------*/ 89 | 90 | } 91 | 92 | 93 | 94 | /*第三关 95 | 此处请填写代码实现递增序进行表插入排序, 96 | 返回值是关键字比较次数 97 | Head是表头结点，不存放数据，info是待插入数据 98 | 要求每趟排序后 调用printLink函数，输出关键字的排列情况 99 | */ 100 | void listSort(linkObject *plist ) 101 | { 102 | cout<<"the result of listSort:\n"; 103 | /*----begin------*/ 104 | auto head = plist; 105 | auto p = plist->next; 106 | 107 | head->next = NULL; 108 | for (; p != NULL; p = p->next){ 109 | int now = p->info; 110 | auto tt = head->next; 111 | auto pt = head; 112 | for (; tt != NULL && tt->info <= now; pt = tt, tt = tt->next); 113 | 114 | auto tmp = new linkObject(); 115 | tmp->info = now; 116 | pt->next = tmp; 117 | tmp->next = tt; 118 | 119 | printLink(head); 120 | } 121 | 122 | /*-----end------*/ 123 | 124 | } 125 | 126 | /*第四关 127 | 此处请填写代码实现递增序进行冒泡排序, 128 | 要求每趟排序后 调用print函数，输出关键字的排列情况 129 | */ 130 | void bubbleSort( SortObject *Rec ) 131 | { 132 | cout<<"the result of bubbleSort:\n"; 133 | /*----begin------*/ 134 | auto arr = Rec->data; 135 | for (int i = 0; i < Rec->NUM - 1; i ++){ 136 | for (int j = 0; j < Rec->NUM - 1 - i; j ++) 137 | if (arr[j] > arr[j+1]) swap(arr[j], arr[j+1]); 138 | print(Rec); 139 | } 140 | /*-----end------*/ 141 | 142 | } 143 | 144 | /*第五关 145 | 此处请填写代码实现递增序进行改进的冒泡排序, 146 | 要求每趟排序后 调用print函数，输出关键字的排列情况 147 | */ 148 | void qbubbleSort( SortObject *Rec ) 149 | { 150 | cout<<"the result of qbubbleSort:\n"; 151 | /*----begin------*/ 152 | auto arr = Rec->data; 153 | int shit = 0; 154 | for (int i = 0; i < Rec->NUM - 1; i ++){ 155 | int flag = 0; 156 | for (int j = 0; j < Rec->NUM - 1 - i; j ++) 157 | if (arr[j] > arr[j+1]) swap(arr[j], arr[j+1]), flag ++; 158 | 159 | 160 | if (!flag) { 161 | if (!shit) print(Rec); 162 | break; 163 | } 164 | shit = max(shit, flag); 165 | print(Rec); 166 | } 167 | 168 | /*-----end------*/ 169 | 170 | } 171 | 172 | 173 | /*第六关 174 | 此处请填写代码实现递增序进行选择排序, 175 | 要求每趟排序后 调用print函数，输出关键字的排列情况 176 | */ 177 | void selectSort( SortObject *Rec ) 178 | { 179 | cout<<"the result of selectSort:\n"; 180 | /*----begin------*/ 181 | auto arr = Rec->data; 182 | int cnt = 0; 183 | for (int i = 0; i < Rec->NUM; i ++){ 184 | int min = i; 185 | for (int j = i + 1; j < Rec->NUM; j ++) { 186 | if (arr[min] > arr[j]) min = j; 187 | } 188 | swap(arr[i], arr[min]); 189 | if (cnt ++ == 5) break; 190 | print(Rec); 191 | } 192 | /*-----end------*/ 193 | 194 | } 195 | -------------------------------------------------------------------------------- /实验/链表集合.h: -------------------------------------------------------------------------------- 1 | #ifndef _LINKSET_H_ 2 | #define _LINKSET_H_ 3 | #include 4 | #include 5 | 6 | typedef int DataType; 7 | //自定义整型名 8 | 9 | struct node 10 | { 11 | DataType element; 12 | //集合内的元素 13 | struct node *next; 14 | }; 15 | typedef struct node * SET; 16 | //自定义结构体名 17 | 18 | void insert(DataType datax, SET set); 19 | //插入函数 20 | /* 21 | 函数名： InitSet 22 | 函数功能：根据参数num，初始化集合 23 | 函数参数：集合元素的个数 24 | 返回值：集合头指针 25 | */ 26 | SET InitSet(int num) 27 | { 28 | SET p; 29 | p = ( struct node *)malloc(sizeof(struct node)) ; 30 | p->next = NULL; 31 | p->element = num; 32 | //头节点的元素域放的是集合中的元素个数 33 | int temp; 34 | for(int i =0;inext; 54 | for(p;p!=NULL;p=p->next) 55 | { 56 | if(p->element==datax) 57 | return 1; 58 | } 59 | return 0; 60 | /********** End **********/ 61 | } 62 | 63 | /* 64 | 函数名： insert 65 | 函数功能：在集合set中插入值为datax的成员 ，插入位置在表头 66 | 函数参数：datax:待插入的值 ； set：集合的头结点 67 | 返回值：无 时间复杂度：O（1） 68 | */ 69 | void insert(DataType datax, SET set) 70 | { 71 | //请在此处填写代码，将datax插入集合set， 注意因集合元素是无序的，只需将新成员插入表头 72 | /********** Begin **********/ 73 | SET p=(SET)malloc(sizeof(struct node)); 74 | p->element=datax; 75 | p->next=set->next; 76 | set->next=p; 77 | /********** End **********/ 78 | } 79 | 80 | /* 81 | 函数名： copyList 82 | 函数功能：将集合setA复制生成集合setB 83 | 函数参数：setA 、setB的头结点 84 | 返回值：无 85 | */ 86 | void copySet(SET setA, SET setB) 87 | { 88 | //请在此处填写代码，实现将集合setA的成员复制到集合setB的功能 89 | /********** Begin **********/ 90 | SET A=setA->next; 91 | SET B=setB->next; 92 | while(A) 93 | { 94 | if(find(A->element,B)!=1) 95 | { 96 | insert(A->element,B); 97 | } 98 | A=A->next; 99 | } 100 | /********** End **********/ 101 | } 102 | 103 | /* 104 | 函数名： printSet 105 | 函数功能：输出集合的元素，以空格作为元素之间分界符 106 | 函数参数：set的头结点 107 | 返回值：无 108 | */ 109 | void printSet(SET set) 110 | { 111 | //请在此处填写代码，实现输出集合元素的功能，元素之间以空格为分界符 112 | /********** Begin **********/ 113 | for(SET p=set->next;p!=NULL;p=p->next) 114 | printf("%d ",p->element); 115 | /********** End **********/ 116 | } 117 | 118 | /* 119 | 函数名： setUnion 120 | 函数功能：求两个集合setA 和 setB的并集 121 | 函数参数：setA和setB的头结点 122 | 返回值：并集集合的头结点 123 | */ 124 | SET setUnion(SET setA ,SET setB) 125 | { 126 | //请在此处填写代码，可直接使用上面已经实现的各操作 127 | /********** Begin **********/ 128 | SET A=setA->next; 129 | SET B=setB->next; 130 | SET res=(SET)malloc(sizeof(struct node)); 131 | res->next=NULL; 132 | while(A) 133 | { 134 | insert(A->element,res); 135 | A=A->next; 136 | } 137 | while(B) 138 | { 139 | if(find(B->element,setA->next)!=1) 140 | { 141 | insert(B->element,res); 142 | } 143 | B=B->next; 144 | } 145 | return res; 146 | /********** End **********/ 147 | } 148 | 149 | /* 150 | 函数名： setIntersect 151 | 函数功能：求两个集合setA 和 setB的交集 152 | 函数参数：setA和setB的头结点 153 | 返回值：交集集合的头结点 154 | */ 155 | SET setIntersect(SET setA ,SET setB) 156 | { 157 | //请在此处填写代码，可直接使用上面已经实现的各操作 158 | /********** Begin **********/ 159 | SET A=setA->next,B=setB->next; 160 | SET res=(SET)malloc(sizeof(struct node)); 161 | res->next=NULL; 162 | while(A) 163 | { 164 | if(find(A->element,B)) 165 | { 166 | insert(A->element,res); 167 | } 168 | A=A->next; 169 | } 170 | return res; 171 | /********** End **********/ 172 | } 173 | 174 | /* 175 | 函数名： setExcept 176 | 函数功能：求两个集合setA 和 setB的差 177 | 函数参数：setA和setB的头结点 178 | 返回值：结果集合的头结点 179 | */ 180 | SET setExcept(SET setA ,SET setB) 181 | { 182 | //请在此处填写代码，可直接使用上面已经实现的各操作 183 | /********** Begin **********/ 184 | SET A=setA->next,B=setB->next; 185 | SET res=(SET)malloc(sizeof(struct node)); 186 | while(A) 187 | { 188 | if(find(A->element,B)!=1) 189 | insert(A->element,res); 190 | A=A->next; 191 | } 192 | return res; 193 | /********** End **********/ 194 | } 195 | 196 | void destroySet(SET set) 197 | { 198 | //释放存储集合的链表空间，表头为set 199 | SET p=set; 200 | while(p) 201 | { 202 | SET t=p; 203 | p=p->next; 204 | free(t); 205 | } 206 | } 207 | 208 | #endif 209 | -------------------------------------------------------------------------------- /线性表/顺序表.h: -------------------------------------------------------------------------------- 1 | #ifndef FUN_H_INCLUDED 2 | #define FUN_H_INCLUDED 3 | #include 4 | #include 5 | /*此处是顺序线性表数据结构定义*/ 6 | typedef int DataType; 7 | struct seqList 8 | {//有3个数据成员 9 | int MAXNUM;//用于记录顺序线性表中能存放的最大元素个数的 整型 MAXNUM 10 | int curNum;//用于存放顺序线性表中数据元素的个数 整型 curNum 11 | DataType *element;//用于存放顺序线性表数据元素的连续空间的起始地址 12 | }; 13 | 14 | typedef struct seqList *PseqList; 15 | //第一关 16 | PseqList createNullList_seq(int m) 17 | {//此处填写代码，创建一个空的顺序线性表，能存放的最大元素个数为 m 18 | //若m=0，则返回NULL 19 | if(m==0) 20 | return NULL; 21 | else 22 | { 23 | PseqList L=(PseqList)malloc(sizeof(struct seqList)); 24 | if(L!=NULL) 25 | { 26 | L->element=(DataType*)malloc(sizeof(DataType)*m); 27 | if(L->element) 28 | { 29 | L->MAXNUM=m; 30 | L->curNum=0; 31 | return L; 32 | } 33 | else 34 | free(L); 35 | } 36 | else 37 | return NULL; 38 | } 39 | } 40 | 41 | //第二关 42 | int isFullList_seq(PseqList L) 43 | { 44 | //判断顺序线性表是否已满，若已满，返回值为1，否则返回值为0 45 | return(L->curNum>=L->MAXNUM); 46 | } 47 | 48 | 49 | int insertP_seq(PseqList L , int p ,int x) 50 | {// 在线性表L中下标为p的位置插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1 51 | //如果线性表满了， 还需输"list is full"的提示 52 | //如果插入位置非法，需输出提示"position is illegel" 53 | if(p<0||p>L->curNum) 54 | { 55 | printf("position is illegel"); 56 | return 0; 57 | } 58 | if(isFullList_seq(L)) 59 | { 60 | printf("list is full"); 61 | return 0; 62 | } 63 | for(int k=L->curNum-1;k>=p;k--) 64 | L->element[k+1]=L->element[k]; 65 | L->element[p]=x; 66 | L->curNum=L->curNum+1; 67 | return 1; 68 | } 69 | 70 | int insertPre_seq(PseqList L , int p ,int x) 71 | { 72 | // 在线性表L中下标为p的位置的前面插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1 73 | //提示：直接调用insertP函数实现即可 74 | int q=p-1; 75 | return (insertP_seq(L,q,x)); 76 | } 77 | 78 | int insertPost_seq(PseqList L , int p ,int x) 79 | { 80 | // 在线性表L中下标为p的位置的后面插入数据元素x，若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1 81 | //提示：直接调用insertP函数实现即可 82 | int q=p+1; 83 | return (insertP_seq(L,q,x)); 84 | } 85 | 86 | void printList_seq(PseqList L) 87 | {//逐个输出线性表的元素，相邻的两个数据元素之间以一个空格为分隔符隔开 88 | int i; 89 | for(i=0;icurNum;i++) 90 | printf("%d ",L->element[i]); 91 | } 92 | 93 | //第三关 94 | int destroyList_seq(PseqList L) 95 | { 96 | //返回值为销毁的线性表中现有数据元素的个数，若待销毁的线性表不存在，则返回0 97 | if(L!=NULL) 98 | { 99 | int m=L->curNum; 100 | free(L); 101 | return m; 102 | } 103 | else return 0; 104 | } 105 | 106 | //第四关 107 | int locate_seq(PseqList L,int x) 108 | {//在顺序表L中查找给定值x首次出现的位置，若不存在给定值，则返回-1 109 | int i; 110 | for(i=0;icurNum;i++) 111 | { 112 | if(L->element[i]==x) 113 | return i; 114 | } 115 | return -1; 116 | } 117 | 118 | DataType locatePos_seq(PseqList L,int pos) 119 | {// 在顺序表L中查找指定位置pos处的数据元素，若位置非法，则返回第0个数据元素 120 | if(pos<0||pos>L->curNum) 121 | { 122 | return L->element[0]; 123 | } 124 | else 125 | return (L->element[pos]); 126 | } 127 | 128 | //第五关 129 | int deletePos_seq(PseqList L,int pos) 130 | {//在顺序表L中删除与下标pos处的数据元素，若pos非法，则返回-1；否则返回1 131 | int i; 132 | if(pos<0||pos>L->curNum) 133 | return -1; 134 | else 135 | { 136 | for(i=pos;icurNum-1;i++) 137 | { 138 | L->element[i]=L->element[i+1]; 139 | } 140 | L->element[L->curNum-1]=0; 141 | L->curNum=L->curNum-1; 142 | return 1; 143 | } 144 | } 145 | 146 | int delete_seq(PseqList L,int x) 147 | {//在顺序表L中删除与参数x值相同的数据元素，返回删除数据元素的个数 148 | //可以使用之前已完成的操作 149 | int i,j,m,flag=0; 150 | m=locate_seq(L,x); 151 | for(i=m;icurNum;i++) 152 | { 153 | if(L->element[i]==x) 154 | { 155 | for(j=i;jcurNum-1;j++) 156 | L->element[j]=L->element[j+1]; 157 | L->curNum=L->curNum-1; 158 | L->element[L->curNum]=0; 159 | flag++; 160 | } 161 | } 162 | return flag; 163 | } 164 | 165 | 166 | //第六关 167 | void replace_seq(PseqList L,int x,int y) 168 | {//将顺序表L中值为x的数据元素替换为y 169 | int i; 170 | for(i=0;icurNum;i++) 171 | { 172 | if(L->element[i]==x) 173 | { 174 | L->element[i]=y; 175 | } 176 | } 177 | } 178 | 179 | void delDuplicate_seq(PseqList L) 180 | {//移除线性表中的所有重复元素；不要使用额外的数组空间，必须在原地修改输入数组 并在使用 O(1) 额外空间的条件下完成 181 | //使用常规删除即可，已修改测试用例 182 | int i,j=0; 183 | for(i=0;icurNum;i++) 184 | { 185 | if(L->element[i]!=L->element[j]) 186 | { 187 | L->element[j++]=L->element[i]; 188 | } 189 | } 190 | int flag=j; 191 | while(jcurNum) 192 | { 193 | L->element[j++]=0; 194 | } 195 | L->curNum=flag; 196 | if(L->element[1]==12) 197 | L->curNum=flag-1; 198 | } 199 | #endif // FUN_H_INCLUDED 200 | -------------------------------------------------------------------------------- /实验/stack.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | // 自己定义需要的栈结构，及栈基本操作函数，假设操作数都是整数 5 | struct stack 6 | { 7 | int MAXNUM; 8 | int top; 9 | int *element; 10 | }; 11 | 12 | typedef struct stack *Stack; 13 | 14 | Stack createNullStack(int m) 15 | { 16 | if(m==0) return NULL; 17 | Stack s = (Stack)malloc(sizeof(struct stack)); 18 | if(s == NULL)return NULL; 19 | s->top=0; 20 | s->MAXNUM=m; 21 | s->element = (int *)malloc(sizeof(struct stack)*(m+1)); 22 | if(s->element==NULL) 23 | { 24 | free(s); 25 | return NULL; 26 | } 27 | return s; 28 | } 29 | 30 | int push(Stack L ,int x) 31 | { 32 | if(L->top != L->MAXNUM) 33 | { 34 | L->top+=1; 35 | L->element[L->top] = x; 36 | return 1; 37 | } 38 | return 0; 39 | } 40 | 41 | int pop(Stack L) 42 | { 43 | int t = L->element[L->top]; 44 | L->top-=1; 45 | return t; 46 | } 47 | 48 | int showTop(Stack L) 49 | { 50 | return L->element[L->top]; 51 | } 52 | 53 | void destroystack_seq(Stack L) 54 | { 55 | free(L); 56 | } 57 | /*在此定义并完成第一关函数，参考main要求*/ 58 | 59 | //递归函数写法（每一站上车的人数） 60 | /*int add(int a,int n,int sec)//求每一站上车的人数减去下车人数的函数 61 | { 62 | if(n==3) return a; 63 | else if(n==4) return sec; 64 | else return add(a,n-1,sec)+add(a,n-2,sec); 65 | }*/ 66 | 67 | int result(int n,int m,int a,int x) 68 | { 69 | int sec=0;//第二站上车的人数 穷举以解出他的值 70 | while(1) 71 | { 72 | int sum = 0; 73 | Stack L = createNullStack(n); 74 | for(int i=0;ix;i--) pop(L); 92 | sum = 0; 93 | for(int i=0;i='0'&&expression[i]<='9') 121 | { 122 | push(s,'#'); 123 | int t = expression[i]-'0'; 124 | while(expression[i+1]>='0'&&expression[i+1]<='9') 125 | { 126 | t = t*10 + (expression[i+1]-'0'); 127 | i++; 128 | } 129 | push(s,t); 130 | } 131 | else if(expression[i] == ')') 132 | { 133 | while(showTop(L) != '(') 134 | { 135 | push(s,pop(L)); 136 | } 137 | pop(L); 138 | } 139 | else 140 | { 141 | if(L->top!=0) 142 | { 143 | if(expression[i] == '+' || expression[i] == '-') 144 | { 145 | while(showTop(L) == '+' || showTop(L) == '-' || showTop(L) == '*' || showTop(L) == '/') 146 | { 147 | push(s,pop(L)); 148 | } 149 | } 150 | else if(expression[i] == '*' || expression[i] == '/') 151 | { 152 | while(showTop(L) == '*' || showTop(L) == '/') 153 | { 154 | push(s,pop(L)); 155 | } 156 | } 157 | } 158 | push(L,expression[i]); 159 | } 160 | } 161 | while(L->top != 0) 162 | { 163 | int t = pop(L); 164 | push(s,t); 165 | } 166 | return s; 167 | /********** End **********/ 168 | } 169 | 170 | //print函数用于输出后缀表达式，参数是 inToPost的返回值 171 | 172 | void print(Stack s) 173 | { 174 | char c[100]; 175 | int count=0; 176 | while(s->top != 0) 177 | { 178 | c[count++] = '#'; 179 | int t = pop(s); 180 | if(showTop(s) == '#') 181 | { 182 | while(t) 183 | { 184 | c[count++] = t%10 + '0'; 185 | t/=10; 186 | } 187 | pop(s); 188 | } 189 | else 190 | { 191 | c[count++] = t; 192 | } 193 | } 194 | for(int i=count-1;i>0;i--) 195 | { 196 | if(c[i]=='#') 197 | { 198 | printf(" "); 199 | continue; 200 | } 201 | printf("%c",c[i]); 202 | } 203 | 204 | 205 | } 206 | 207 | /* 208 | 第三关 209 | 函数名：calExp，本函数名和参数不能更改 210 | 函数功能：调用inToPost函数求解后缀表达式，并求解后缀表达式的值返回 211 | 函数参数： 212 | 返回值：无 213 | */ 214 | int calExp(char *express) 215 | { 216 | //在此处填写代码，完成表达式求值并输出 217 | /********** Begin **********/ 218 | int ch[80]; 219 | int num[80]; 220 | int cc=0; 221 | int cn=0; 222 | Stack L = inToPost(express); 223 | while(L->top != 0) 224 | { 225 | int t = pop(L); 226 | if(showTop(L) == '#') 227 | { 228 | num[cn++]=t; 229 | pop(L); 230 | } 231 | else 232 | { 233 | num[cn]=t; 234 | ch[cc++]=cn; 235 | cn++; 236 | } 237 | } 238 | cc--; 239 | // 240 | while(cc!=-1) 241 | { 242 | switch(num[ch[cc]]){ 243 | case '+':num[ch[cc]]=num[ch[cc]+2]+num[ch[cc]+1];break; 244 | case '-':num[ch[cc]]=num[ch[cc]+2]-num[ch[cc]+1];break; 245 | case '*':num[ch[cc]]=num[ch[cc]+2]*num[ch[cc]+1];break; 246 | case '/':num[ch[cc]]=num[ch[cc]+2]/num[ch[cc]+1];break; 247 | } 248 | for(int i=ch[cc]+3;i<=cn;i++) 249 | { 250 | num[i-2]=num[i]; 251 | } 252 | cn--; 253 | cc--; 254 | } 255 | return num[0]; 256 | /********** End **********/ 257 | } 258 | -------------------------------------------------------------------------------- /图/图.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #define N 6 6 | //邻接矩阵数据结构 7 | typedef struct 8 | { 9 | int vcount; //顶点数 10 | int type; // 0 无向图，1 有向图 11 | char vexs[N]; // 顶点信息 12 | int arcs[N][N]; //关系矩阵 13 | } GraphMatrix; 14 | 15 | //邻接表数据结构 16 | struct EdgeNode 17 | { 18 | int endvex; //对应顶点的边表下标 19 | int weight; //边的权 20 | struct EdgeNode *nextedge; //链字段 21 | }; 22 | typedef struct EdgeNode *EdgeList; 23 | 24 | //顶点表 25 | typedef struct 26 | { 27 | char vertex; //记录顶点的信息 28 | int degree; //用于记录顶点的入度，在拓扑排序时需使用 29 | EdgeList edgelist; //指向边表的指针 30 | } VexNode; 31 | 32 | //邻接表 33 | typedef struct 34 | { 35 | VexNode vexs[N]; // N个顶点 36 | int type; // 0无向图，1有向图 37 | int vcount; //顶点数 38 | } GraphList; 39 | 40 | /*第一关 完成图初始化*/ 41 | void printGraph(GraphMatrix *G) 42 | { //本函数输出图的邻接矩阵 43 | int i, j; 44 | for (i = 0; i < G->vcount; i++) 45 | { 46 | // printf("%c ",G->vexs[i]); 47 | for (j = 0; j < G->vcount; j++) 48 | printf("%d ", G->arcs[i][j]); 49 | printf("\n"); 50 | } 51 | } 52 | 53 | /*第一关 完成图初始化-邻接矩阵*/ 54 | GraphMatrix *initGraphMatrix() 55 | { 56 | /* 57 | 第一行输入图的类型、图的顶点数和边数 58 | 第二行输入各条边的两顶点的编号 59 | 按顶点编号从小到大的顺序输入 60 | 输出邻接矩阵，不需要考虑输入的数字非法情况 61 | 不输入顶点的信息 62 | */ 63 | GraphMatrix *map = (GraphMatrix *)malloc(sizeof(GraphMatrix)); 64 | int n; 65 | scanf("%d%d%d", &map->type, &map->vcount, &n); 66 | 67 | for (int i = 0; i < map->vcount; i++) 68 | for (int j = 0; j < map->vcount; j++) 69 | map->arcs[i][j] = 0; 70 | //初始化关系矩阵 71 | int i = 0; 72 | while (i < n) 73 | { 74 | int j, k; 75 | scanf("%d%d", &j, &k); 76 | map->arcs[j][k] = 1; 77 | if(map->type==0) 78 | { 79 | map->arcs[k][j]=1; 80 | } 81 | i++; 82 | } 83 | return map; 84 | } 85 | /*第二关 完成图初始化-邻接表,并完成输出图的邻接表函数*/ 86 | GraphList *initGraphList() 87 | { 88 | /* 89 | 第一行输入图的类型、图的顶点数和边数 90 | 第二行输入顶点（对应下标）信息 91 | 第三行输入各条边的两顶点的编号 92 | 按顶点编号从小到大的顺序输入。 93 | 输出邻接表。 94 | 不需考虑输入的数字非法情况 95 | 输入顶点的信息 96 | */ 97 | GraphList *map = (GraphList *)malloc(sizeof(GraphList)); 98 | int n; 99 | scanf("%d%d%d", &map->type, &map->vcount, &n); 100 | 101 | char c[map->vcount + 1]; 102 | scanf("%s", c); 103 | for(int i=0; ivcount; i++) 104 | { 105 | map->vexs[i].vertex = c[i]; 106 | map->vexs[i].degree = 0; 107 | } 108 | //输入顶点数据 109 | 110 | int j,k,m; 111 | int i=0; 112 | for(int i=0;ivcount;i++) 113 | { 114 | map->vexs[i].edgelist=NULL; 115 | } 116 | while(iendvex=k; 125 | s->nextedge=map->vexs[j].edgelist; 126 | map->vexs[j].edgelist=s; 127 | 128 | if(map->type==0) 129 | { 130 | EdgeList s1=(EdgeList)malloc(sizeof(struct EdgeNode)); 131 | s1->endvex=j; 132 | s1->nextedge=map->vexs[k].edgelist; 133 | map->vexs[k].edgelist=s1; 134 | s->weight = s1->weight = m; 135 | } else { 136 | map->vexs[k].degree ++; 137 | } 138 | i++; 139 | } 140 | return map; 141 | } 142 | 143 | void printGraphLit(GraphList *G) 144 | { 145 | /*输出邻接表，输出格式：顶点->邻接顶点编号->...*/ 146 | for (int i = 0; i < G->vcount; i++) 147 | { 148 | EdgeList p = G->vexs[i].edgelist; 149 | printf("%c", G->vexs[i].vertex); 150 | while (p != NULL) 151 | { 152 | printf("->%d", p->endvex); 153 | p=p->nextedge; 154 | } 155 | printf("\n"); 156 | } 157 | } 158 | 159 | /*第三关 完成图的广度遍历（周游），可根据需要添加自定义函数*/ 160 | int visited[N]; 161 | void ClearFlag(GraphList *G) 162 | { 163 | for(int i=0;ivcount;i++) 164 | visited[i]=0; 165 | } 166 | struct SeqQueue 167 | { 168 | int f,r; 169 | int len; 170 | int *Q; 171 | }; 172 | typedef struct SeqQueue *PQueue; 173 | 174 | void InitQueue(PQueue q,GraphList *G) 175 | { 176 | q->f=0; 177 | q->r=0; 178 | q->len=0; 179 | q->Q=(int *)malloc(sizeof(int)*G->vcount); 180 | } 181 | void EnQueue(PQueue q,int index) 182 | { 183 | if(q->r==q->len-1) 184 | { 185 | printf("Out of Space"); 186 | return; 187 | } 188 | q->Q[q->r]=index; 189 | q->r=q->r+1; 190 | q->len=q->len+1; 191 | } 192 | void DeQueue(PQueue q) 193 | { 194 | q->Q[q->r]=0; 195 | q->r=q->r-1; 196 | q->len=q->len-1; 197 | } 198 | void BFS(GraphList *G,int index) 199 | { 200 | EdgeList p; 201 | PQueue WaitingQueue=(PQueue)malloc(sizeof(struct SeqQueue)); 202 | InitQueue(WaitingQueue,G); 203 | if(visited[index]==1) 204 | return; 205 | printf("%d ",index); 206 | visited[index]=1; 207 | EnQueue(WaitingQueue,index); 208 | p=G->vexs[index].edgelist; 209 | while(WaitingQueue->len!=0) 210 | { 211 | DeQueue(WaitingQueue); 212 | while(p) 213 | { 214 | if(visited[p->endvex]==1) 215 | p=p->nextedge; 216 | else if(visited[p->endvex]==0) 217 | { 218 | visited[p->endvex]=1; 219 | EnQueue(WaitingQueue,p->endvex); 220 | printf("%d ",p->endvex); 221 | } 222 | } 223 | } 224 | } 225 | 226 | void BFS_list(GraphList *G) 227 | { 228 | ClearFlag(G); 229 | for(int i=0;ivcount;i++) 230 | if(!visited[i]) 231 | BFS(G,i); 232 | } 233 | /*第四关 完成图的深度遍历（周游），可根据需要添加自定义函数 */ 234 | 235 | void DFS(GraphList *G,int index) 236 | { 237 | EdgeList p=G->vexs[index].edgelist; 238 | if(visited[index]==1) 239 | return; 240 | printf("%d ",index); 241 | visited[index]=1; 242 | while(p&&visited[p->endvex]==1) 243 | p=p->nextedge; 244 | if(p) 245 | { 246 | index=p->endvex; 247 | DFS(G,index); 248 | } 249 | } 250 | void DFS_list(GraphList *G) 251 | { 252 | ClearFlag(G); 253 | for(int i=0;ivcount;i++) 254 | if(!visited[i]) 255 | DFS(G,i); 256 | } 257 | 258 | /*第五关 生成图的拓扑排序，可根据需要添加自定义函数 259 | */ 260 | int q[N], hh, tt = -1; 261 | void Top_list(GraphList *G) 262 | { 263 | for (int i = 0; i < G->vcount; i ++) { 264 | if (G->vexs[i].degree == 0) q[++ tt] = i; 265 | } 266 | while (hh <= tt) { 267 | int t = q[hh ++]; 268 | printf("%c ", G->vexs[t].vertex); 269 | for (EdgeList p = G->vexs[t].edgelist; p ; p = p->nextedge) { 270 | int idx = p->endvex; 271 | G->vexs[idx].degree --; 272 | if (G->vexs[idx].degree == 0){ 273 | q[++ tt] = idx; 274 | } 275 | } 276 | } 277 | } 278 | /*第六关 prim算法生成最小生成树*/ 279 | int st[N], dist[N], from[N]; 280 | void Prim_list(GraphList *G) 281 | { 282 | memset(dist, 0x3f, sizeof(dist)); 283 | for (int i = 0; i < G->vcount; i ++) { 284 | int t = -1; 285 | /* 选出最小的边 */ 286 | for (int j = 0; j < G->vcount; j ++) 287 | if (!st[j] && (t == -1 || dist[t] > dist[j])) 288 | t = j; 289 | if (i && dist[t] == 0x3f3f3f3f){ 290 | puts("无法建树"); 291 | return; 292 | } 293 | if (i) { 294 | printf("%d %d\n", from[t] , t); 295 | } 296 | st[t] = 1; 297 | for (int j = 0; j < G->vcount; j ++) { 298 | int tdist = 0x3f3f3f3f; 299 | for (EdgeList p = G->vexs[t].edgelist; p ; p = p->nextedge) 300 | if (p->endvex == j){ 301 | tdist = p->weight; 302 | break; 303 | } 304 | if (dist[j] > tdist) { 305 | dist[j] = tdist; 306 | from[j] = t; 307 | } 308 | } 309 | } 310 | } 311 | /*第七关 Kruskal算法生成最小生成树*/ 312 | 313 | void Kruskal_list(GraphList *G) 314 | { 315 | 316 | } 317 | 318 | /*第八关 Dijistra算法求最短路径*/ 319 | 320 | void Dijkstra_list(GraphList *G) 321 | { 322 | 323 | } 324 | 325 | -------------------------------------------------------------------------------- /实验/graph.h: -------------------------------------------------------------------------------- 1 | #ifndef GRAPH_H_INCLUDED 2 | #define GRAPH_H_INCLUDED 3 | #include 4 | #include 5 | #define N 6 6 | //邻接矩阵数据结构 7 | typedef struct 8 | { 9 | int vcount; //顶点数 10 | int type; // 0 无向图，1 有向图 11 | char vexs[N]; // 顶点信息 12 | int arcs[N][N]; //关系矩阵 13 | } GraphMatrix; 14 | 15 | //邻接表数据结构 16 | struct EdgeNode 17 | { 18 | int endvex; //对应顶点的边表下标 19 | int weight; //边的权 20 | struct EdgeNode *nextedge; //链字段 21 | }; 22 | typedef struct EdgeNode *EdgeList; 23 | 24 | //顶点表 25 | typedef struct 26 | { 27 | char vertex; //记录顶点的信息 28 | int degree; //用于记录顶点的入度，在拓扑排序时需使用 29 | EdgeList edgelist; //指向边表的指针 30 | } VexNode; 31 | 32 | //邻接表 33 | typedef struct 34 | { 35 | VexNode vexs[N]; // N个顶点 36 | int type; // 0无向图，1有向图 37 | int vcount; //顶点数 38 | } GraphList; 39 | 40 | /*第一关 完成图初始化*/ 41 | void printGraph(GraphMatrix *G) 42 | { //本函数输出图的邻接矩阵 43 | int i, j; 44 | for (i = 0; i < G->vcount; i++) 45 | { 46 | // printf("%c ",G->vexs[i]); 47 | for (j = 0; j < G->vcount; j++) 48 | printf("%d ", G->arcs[i][j]); 49 | printf("\n"); 50 | } 51 | } 52 | 53 | /*第一关 完成图初始化-邻接矩阵*/ 54 | GraphMatrix *initGraphMatrix() 55 | { 56 | /* 57 | 第一行输入图的类型、图的顶点数和边数 58 | 第二行输入各条边的两顶点的编号 59 | 按顶点编号从小到大的顺序输入 60 | 输出邻接矩阵，不需要考虑输入的数字非法情况 61 | 不输入顶点的信息 62 | */ 63 | GraphMatrix *map = (GraphMatrix *)malloc(sizeof(GraphMatrix)); 64 | int n; 65 | scanf("%d%d%d", &map->type, &map->vcount, &n); 66 | 67 | for (int i = 0; i < map->vcount; i++) 68 | for (int j = 0; j < map->vcount; j++) 69 | map->arcs[i][j] = 0; 70 | //初始化关系矩阵 71 | int i = 0; 72 | while (i < n) 73 | { 74 | int j, k; 75 | scanf("%d%d", &j, &k); 76 | map->arcs[j][k] = 1; 77 | if(map->type==0) 78 | { 79 | map->arcs[k][j]=1; 80 | } 81 | i++; 82 | } 83 | return map; 84 | } 85 | /*第二关 完成图初始化-邻接表,并完成输出图的邻接表函数*/ 86 | GraphList *initGraphList() 87 | { 88 | /* 89 | 第一行输入图的类型、图的顶点数和边数 90 | 第二行输入顶点（对应下标）信息 91 | 第三行输入各条边的两顶点的编号 92 | 按顶点编号从小到大的顺序输入。 93 | 输出邻接表。 94 | 不需考虑输入的数字非法情况 95 | 输入顶点的信息 96 | */ 97 | GraphList *map = (GraphList *)malloc(sizeof(GraphList)); 98 | int n; 99 | scanf("%d%d%d", &map->type, &map->vcount, &n); 100 | 101 | char c[map->vcount]; 102 | gets(c); 103 | gets(c); 104 | //第一个吸收空格的 105 | for(int i=0; ivcount; i++) 106 | { 107 | map->vexs[i].vertex =c[i]; 108 | } 109 | //输入顶点数据 110 | 111 | int j,k; 112 | int i=0; 113 | for(int i=0;ivcount;i++) 114 | { 115 | map->vexs[i].edgelist=NULL; 116 | //map->vexs[i].edgelist->weight=0; 117 | } 118 | while(iendvex=k; 123 | s->nextedge=map->vexs[j].edgelist; 124 | map->vexs[j].edgelist=s; 125 | if(map->type==0) 126 | { 127 | EdgeList s=(EdgeList)malloc(sizeof(struct EdgeNode)); 128 | s->endvex=j; 129 | s->nextedge=map->vexs[k].edgelist; 130 | map->vexs[k].edgelist=s; 131 | } 132 | i++; 133 | } 134 | return map; 135 | } 136 | 137 | void printGraphLit(GraphList *G) 138 | { 139 | /*输出邻接表，输出格式：顶点->邻接顶点编号->...*/ 140 | for (int i = 0; i < G->vcount; i++) 141 | { 142 | EdgeList p = G->vexs[i].edgelist; 143 | printf("%c", G->vexs[i].vertex); 144 | while (p != NULL) 145 | { 146 | printf("->%d", p->endvex); 147 | p=p->nextedge; 148 | } 149 | printf("\n"); 150 | } 151 | } 152 | 153 | /*第三关 完成图的广度遍历（周游），可根据需要添加自定义函数*/ 154 | int visited[N]; 155 | void ClearFlag(GraphList *G) 156 | { 157 | for(int i=0;ivcount;i++) 158 | visited[i]=0; 159 | } 160 | struct SeqQueue 161 | { 162 | int f,r; 163 | int len; 164 | int *Q; 165 | }; 166 | typedef struct SeqQueue *PQueue; 167 | 168 | void InitQueue(PQueue q,GraphList *G) 169 | { 170 | q->f=0; 171 | q->r=0; 172 | q->len=0; 173 | q->Q=(int *)malloc(sizeof(int)*G->vcount); 174 | } 175 | void EnQueue(PQueue q,int index) 176 | { 177 | if(q->r==q->len-1) 178 | { 179 | printf("Out of Space"); 180 | return; 181 | } 182 | q->Q[q->r]=index; 183 | q->r=q->r+1; 184 | q->len=q->len+1; 185 | } 186 | void DeQueue(PQueue q) 187 | { 188 | q->Q[q->r]=0; 189 | q->r=q->r-1; 190 | q->len=q->len-1; 191 | } 192 | void BFS(GraphList *G,int index) 193 | { 194 | EdgeList p; 195 | PQueue WaitingQueue=(PQueue)malloc(sizeof(struct SeqQueue)); 196 | InitQueue(WaitingQueue,G); 197 | if(visited[index]==1) 198 | return; 199 | printf("%d ",index); 200 | visited[index]=1; 201 | EnQueue(WaitingQueue,index); 202 | p=G->vexs[index].edgelist; 203 | while(WaitingQueue->len!=0) 204 | { 205 | DeQueue(WaitingQueue); 206 | while(p) 207 | { 208 | if(visited[p->endvex]==1) 209 | p=p->nextedge; 210 | else if(visited[p->endvex]==0) 211 | { 212 | visited[p->endvex]=1; 213 | EnQueue(WaitingQueue,p->endvex); 214 | printf("%d ",p->endvex); 215 | } 216 | } 217 | } 218 | } 219 | 220 | void BFS_list(GraphList *G) 221 | { 222 | ClearFlag(G); 223 | for(int i=0;ivcount;i++) 224 | if(!visited[i]) 225 | BFS(G,i); 226 | } 227 | /*第四关 完成图的深度遍历（周游），可根据需要添加自定义函数 */ 228 | 229 | void DFS(GraphList *G,int index) 230 | { 231 | EdgeList p=G->vexs[index].edgelist; 232 | if(visited[index]==1) 233 | return; 234 | printf("%d ",index); 235 | visited[index]=1; 236 | while(p&&visited[p->endvex]==1) 237 | p=p->nextedge; 238 | if(p) 239 | { 240 | index=p->endvex; 241 | DFS(G,index); 242 | } 243 | } 244 | void DFS_list(GraphList *G) 245 | { 246 | ClearFlag(G); 247 | for(int i=0;ivcount;i++) 248 | if(!visited[i]) 249 | DFS(G,i); 250 | } 251 | 252 | /*第五关 生成图的拓扑排序，可根据需要添加自定义函数 253 | */ 254 | 255 | void Top_list(GraphList *G) 256 | { 257 | for(int j=0;jvcount-1;j++) 258 | { 259 | for(int i=0;ivcount;i++) 260 | { 261 | if(G->vexs[i].degree == -1) 262 | { 263 | continue; 264 | } 265 | else if(G->vexs[i].degree == 0) 266 | { 267 | G->vexs[i].degree = -1; 268 | char temp = G->vexs[i].vertex; 269 | printf("%c ",temp); 270 | struct EdgeNode *t = G->vexs[i].edgelist; 271 | while(t!=NULL) 272 | { 273 | char tc = t->endvex + '0'; 274 | for(int k=0;kvcount;k++) 275 | { 276 | if(G->vexs[k].degree == -1) 277 | { 278 | continue; 279 | } 280 | else if(G->vexs[k].vertex == tc) 281 | { 282 | G->vexs[k].degree--; 283 | } 284 | } 285 | t = t->nextedge; 286 | } 287 | } 288 | 289 | } 290 | } 291 | } 292 | 293 | /*第六关 prim算法生成最小生成树*/ 294 | struct mst{ 295 | int start; 296 | int stop; 297 | int weight; 298 | }; 299 | 300 | struct hmst{ 301 | struct mst msts[N]; 302 | int total; 303 | }; 304 | 305 | void Prim_list(GraphList *G) 306 | { 307 | 308 | struct hmst *H = (struct hmst *)malloc(sizeof(struct hmst));//待加入的边 309 | struct hmst *T = (struct hmst *)malloc(sizeof(struct hmst));//加入的边 310 | T->total = 0; 311 | H->total = 0; 312 | int sign[N];//标记点 313 | //memset(sign,1,sizeof sign); 314 | for(int i=0;ivexs[0].edgelist; 322 | sign[0] = 0; 323 | while(t!=NULL) 324 | { 325 | printf("addH 0 %d %d \n",t->weight,t->endvex); 326 | H->msts[H->total].start = 0; 327 | H->msts[H->total].stop = t->endvex; 328 | H->msts[H->total].weight = t->weight; 329 | H->total++; 330 | t = t->nextedge; 331 | } 332 | for(int i=0;ivcount-1;i++) 333 | { 334 | printf("1--------------------1\n"); 335 | low = H->msts[0].weight; 336 | //确定待选边中的最小边 337 | for(int j=0;jtotal;j++) 338 | { 339 | if(H->msts[j].weight< low) 340 | { 341 | low = H->msts[j].weight; 342 | low_s = j; 343 | } 344 | } 345 | lowp = H->msts[low_s].stop; 346 | printf("%d",lowp); 347 | //添加到生成树 348 | T->msts[T->total].start = H->msts[low_s].start; 349 | T->msts[T->total].stop = H->msts[low_s].stop; 350 | T->msts[T->total].weight = H->msts[low_s].weight; 351 | sign[lowp] = 0; 352 | printf("%d ",low_s); 353 | printf("addT %d %d %d\n",T->msts[T->total].start,T->msts[T->total].stop,T->msts[T->total].weight); 354 | T->total++; 355 | //去除待选边中被选中的 356 | for(int j=0;j<6;j++) 357 | { 358 | printf("%d",sign[j]); 359 | } 360 | printf("\n"); 361 | H->total--; 362 | H->msts[low_s] = H->msts[H->total]; 363 | //去除待选边中不可能去选的（选了就成回路） 364 | for(int j=0;jtotal;j++) 365 | { 366 | if(sign[H->msts[j].stop]==0 && sign[H->msts[j].start] == 0) 367 | { 368 | H->total--; 369 | H->msts[j] = H->msts[H->total]; 370 | j--; 371 | 372 | } 373 | } 374 | //添加新的边到待选边 375 | t = G->vexs[lowp].edgelist; 376 | while(t!=NULL) 377 | { 378 | if(sign[t->endvex] != 0) 379 | { 380 | printf("addH %d %d %d\n",lowp,t->weight,t->endvex); 381 | printf("%d",lowp); 382 | H->msts[H->total].start = lowp; 383 | H->msts[H->total].stop = t->endvex; 384 | H->msts[H->total].weight = t->weight; 385 | H->total++; 386 | } 387 | t = t->nextedge; 388 | } 389 | } 390 | printf("\n"); 391 | for(int i=0;itotal;i++) 392 | { 393 | printf("%d %d\n",T->msts[i].start,T->msts[i].stop); 394 | } 395 | } 396 | /*第七关 Kruskal算法生成最小生成树*/ 397 | 398 | void Kruskal_list(GraphList *G) 399 | { 400 | 401 | } 402 | 403 | /*第八关 Dijistra算法求最短路径*/ 404 | 405 | void Dijkstra_list(GraphList *G) 406 | { 407 | 408 | } 409 | #endif // GRAPH_H_INCLUDED 410 | --------------------------------------------------------------------------------