├── README.md
├── 作业1 绪论
    ├── 代码及报告
    │   ├── 数据截图，分析.pdf
    │   └── 源代码
    │   │   ├── 冒泡排序.cpp
    │   │   ├── 冒泡排序（递归）.cpp
    │   │   ├── 实验比较汉诺塔时间复杂度.cpp
    │   │   ├── 插入排序.cpp
    │   │   ├── 插入排序（递归）.cpp
    │   │   ├── 汉诺塔（递归）.cpp
    │   │   ├── 汉诺塔（非递归）.cpp
    │   │   ├── 角谷猜想.cpp
    │   │   ├── 选择排序.cpp
    │   │   └── 选择排序（递归）.cpp
    └── 作业1 第1章.pdf
├── 作业2 线性结构的存储结构与应用
    ├── 代码及报告
    │   ├── LinkList.cpp
    │   ├── SeqList.cpp
    │   ├── StaticList.cpp
    │   └── 作业2 测试数据.pdf
    └── 作业2 线性结构的存储结构与应用.pdf
├── 作业3 树形结构及其应用
    ├── 代码及报告
    │   ├── work.cpp
    │   └── 测试数据和结果数据.docx
    └── 作业3 树形结构及其应用.pdf
├── 作业4 图形结构及其应用
    ├── 代码及报告
    │   ├── Graph.cpp
    │   └── 测试数据与结果数据及分析.pdf
    └── 作业4 图型结构及其应用.pdf
├── 作业5 查找结构与排序方法
    ├── 代码及报告
    │   ├── BST.cpp
    │   ├── BinarySearch.cpp
    │   ├── inputdata1.txt
    │   ├── inputdata2.txt
    │   ├── 测试数据及结果数据.docx
    │   └── 生成测试数据.cpp
    └── 作业5 查找结构与排序方法.pdf
├── 实验1 线性结构及其应用
    ├── 代码及报告
    │   ├── calculator.cpp
    │   ├── calculator.exe
    │   ├── calculator.o
    │   ├── in1.txt
    │   ├── in2.txt
    │   ├── out.txt
    │   ├── 实验报告.doc
    │   └── 实验测试数据和结果数据.docx
    └── 实验1 线性结构及其应用.pdf
├── 实验2 树形结构及其应用
    ├── 代码及报告
    │   ├── 1.cpp
    │   ├── CompressedFile.huffman
    │   ├── DeCompress_Char.cpp
    │   ├── Huffman_Char.cpp
    │   ├── Huffman_Word.cpp
    │   ├── InputText.txt
    │   ├── K_Huffman.cpp
    │   ├── OutputText.txt
    │   ├── test.in
    │   ├── 实验报告.doc
    │   ├── 测试数据和结果数据.docx
    │   └── 测试文本集.txt
    └── 实验2 树形结构及其应用.pdf
└── 实验3 图形结构及其应用
    ├── 代码及报告
        ├── Graph.txt
        ├── 实验报告.doc
        ├── 最短路径算法.cpp
        ├── 测试数据与结果数据.docx
        └── 测试数据图.jpg
    └── 实验3 图型结构及其应用.pdf


/README.md:
--------------------------------------------------------------------------------
1 | # 2021-HIT-course-Datastructure
2 | 哈尔滨工业大学《数据结构与算法》课程作业及实验
3 | 


--------------------------------------------------------------------------------
/作业1 绪论/代码及报告/数据截图，分析.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/作业1 绪论/代码及报告/数据截图，分析.pdf


--------------------------------------------------------------------------------
/作业1 绪论/代码及报告/源代码/冒泡排序.cpp:
--------------------------------------------------------------------------------
 1 | //直接冒泡排序，升序
 2 | #include<iostream> 
 3 | 
 4 | using namespace std; 
 5 | int main() 
 6 | { 
 7 | 	int array[1000]; 
 8 | 	/*读入数据*/
 9 | 	int n;
10 | 	int temp;
11 | 	cin >> n; 
12 | 	for (int i = 0; i<n; i++) 
13 | 		cin >> array[i]; 
14 | 	/*排序*/
15 | 	for (int i = 0; i<n - 1; i++) { 
16 | 		for (int j = 0; j<n - 1 - i; j++){
17 | 			if (array[j]>array[j + 1]){ 
18 | 				temp = array[j]; 
19 | 				array[j] = array[j + 1];
20 | 				array[j + 1] = temp;
21 | 			}
22 | 		}
23 | 	}
24 | 	/*输出数据*/
25 | 	for (int i = 0; i<n; i++) 
26 | 	{ 
27 | 		cout << array[i] << " "; 
28 | 	}
29 | 	cout << '\n'; 
30 | 	return 0; 
31 | }


--------------------------------------------------------------------------------
/作业1 绪论/代码及报告/源代码/冒泡排序（递归）.cpp:
--------------------------------------------------------------------------------
 1 | //直接冒泡排序(递归)，升序
 2 | #include<iostream>
 3 | using namespace std;
 4 | #define swap(a,b)   (a=a+b,b=a-b,a=a-b)
 5 | void Inpute(int array[], int n);
 6 | void BubbleSort(int array[], int n);
 7 | void Print(int array[], int n);
 8 | int main(void)
 9 | {
10 | 	int array[1000];
11 | 	int n;
12 | 	cin >> n;
13 | 	Inpute(array, n);
14 | 	BubbleSort(array, n);
15 | 	Print(array, n);
16 | 	return 0;
17 | }
18 | void Inpute(int array[], int n)
19 | {
20 | 	for (int i = 0; i < n; i++)
21 | 		cin >> array[i];
22 | }
23 | void BubbleSort(int array[], int n)
24 | {
25 | 	if (n == 1)
26 | 		return;
27 | 	for (int i = 0; i < n - 1; i++)
28 | 	{
29 | 		if (array[i] > array[i + 1])
30 | 		{
31 | 			swap(array[i], array[i + 1]);
32 | 		}
33 | 	}
34 | 	n--;
35 | 	BubbleSort(array, n);
36 | }
37 | void Print(int array[], int n)
38 | {
39 | 	for (int i = 0; i<n; i++) 
40 | 	{ 
41 | 		cout << array[i] << " "; 
42 | 	}
43 | 	cout << '\n'; 
44 | }


--------------------------------------------------------------------------------
/作业1 绪论/代码及报告/源代码/实验比较汉诺塔时间复杂度.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<stdio.h>
 3 | #include<time.h>
 4 | using namespace std;
 5 | #define Num 5
 6 | //计算15个圆盘的汉诺塔
 7 | 
 8 | void Hanoi(int n, char A, char B, char C);//递归
 9 | void Hanoi_N(int n);//非递归
10 | 
11 | clock_t start, stop;
12 | double duration;//递归算法耗费时间
13 | double duration_N;//非递归算法耗费时间
14 | int main(void)
15 | {
16 |     start=clock();
17 |     Hanoi(Num,'A','B','C');
18 |     stop=clock();
19 |     duration=(double)(stop-start)/CLK_TCK; //CLK_TCK为clock()函数的时间单位，即时钟打点
20 |     
21 |     start=clock();
22 |     Hanoi_N(Num);
23 |     stop=clock();
24 |     duration_N=(double)(stop-start)/CLK_TCK;
25 |     cout<<"The time of Hanoi:"<<duration<<endl;
26 |     cout<<"The time of Hanoi_N:"<<duration_N<<endl;
27 |     return 0;
28 | }
29 | void Hanoi(int n, char A, char B, char C)/*A通过C移动到B*/
30 | {
31 |     if (n == 1)
32 |         cout << "move " << n << " from " << A << " to " << C << endl;
33 |     else
34 |     {
35 |         Hanoi(n - 1, A, C, B);
36 |         cout << "move " << n << " from " << A << " to " << C << endl;
37 |         Hanoi(n - 1, B, A, C);
38 |     }
39 | }
40 | void Hanoi_N(int n)
41 | {
42 |     int i, res, t, k;
43 |     int s;
44 |     res = (1 << n) - 1;
45 |     for ( i = 1; i <= res; i++ ) {
46 |         for ( t = 2, s = 1; s <= n; s++, t *= 2)
47 |             if ( i % t == t / 2 ) 
48 |                 break; 
49 |         k = i / t; 
50 |         if ( n % 2 == s % 2 ) { 
51 |             if ( (k + 1) % 3 == 0 ) 
52 |                 cout << "move " << s << " from " << "B" << " to " << "A" << endl;
53 |             if ( (k + 1) % 3 == 1 )
54 |                 cout << "move " << s << " from " << "A" << " to " << "C" << endl;
55 |             if ( (k + 1) % 3 == 2 ) 
56 |                 cout << "move " << s << " from " << "C" << " to " << "B" << endl;
57 |         }
58 |         else { 
59 |             if ( (k + 1) % 3 == 0 )
60 |                 cout << "move " << s << " from " << "C" << " to " << "A" << endl;
61 |             if ( (k + 1) % 3 == 1 )
62 |                 cout << "move " << s << " from " << "A" << " to " << "B" << endl;
63 |             if ( (k + 1) % 3 == 2 ) 
64 |                 cout << "move " << s << " from " << "B" << " to " << "C" << endl;
65 |         }
66 |     }
67 | }


--------------------------------------------------------------------------------
/作业1 绪论/代码及报告/源代码/插入排序.cpp:
--------------------------------------------------------------------------------
 1 | //直接选择排序，升序
 2 | #include<iostream>
 3 | 
 4 | using namespace std;
 5 | int main()
 6 | {
 7 |     int array[1000];
 8 |     /*读入数据*/
 9 |     int n;
10 |     int temp;
11 |     cin >> n;
12 |     for (int i = 0; i < n; i++)
13 |         cin >> array[i];
14 |     /*排序*/
15 |     for (int i = 1; i < n; i++) {
16 |         for (int j = i; j > 0 && array[j - 1] > array[j]; --j) {
17 |             temp = array[j];
18 |             array[j] = array[j - 1];
19 |             array[j - 1] = temp;
20 |         }
21 |     }
22 |     /*输出数据*/
23 |     for (int i = 0; i < n; i++)
24 |     {
25 |         cout << array[i] << " ";
26 |     }
27 |     cout << '\n';
28 |     return 0;
29 | }
30 | 


--------------------------------------------------------------------------------
/作业1 绪论/代码及报告/源代码/插入排序（递归）.cpp:
--------------------------------------------------------------------------------
 1 | //直接插入排序(递归)，升序
 2 | #include<iostream>
 3 | using namespace std;
 4 | #define swap(a,b)   (a=a+b,b=a-b,a=a-b)
 5 | void Inpute(int array[], int n);
 6 | void InsertSort(int array[], int n);
 7 | void Print(int array[], int n);
 8 | int main(void)
 9 | {
10 | 	int array[1000];
11 | 	int n;
12 | 	cin >> n;
13 | 	Inpute(array, n);
14 | 	InsertSort(array, n);
15 | 	Print(array, n);
16 | 	return 0;
17 | }
18 | void Inpute(int array[], int n)
19 | {
20 | 	for (int i = 0; i < n; i++)
21 | 		cin >> array[i];
22 | }
23 | void InsertSort(int array[], int n)
24 | {
25 |    int i;
26 | 
27 |     if(n == 1)
28 |         return;
29 |     InsertSort(array, n-1);
30 |     int temp = array[n - 1];
31 |     for (i = n - 2; i >= 0 && temp < array[i]; i--)
32 |     {
33 |         array[i+1] = array[i];
34 |     }
35 |     array[i+1] = temp;
36 | }
37 | void Print(int array[], int n)
38 | {
39 | 	for (int i = 0; i < n; i++)
40 | 	{
41 | 		cout << array[i] << " ";
42 | 	}
43 | 	cout << '\n';
44 | }


--------------------------------------------------------------------------------
/作业1 绪论/代码及报告/源代码/汉诺塔（递归）.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | void Hanoi(int n, char A, char B, char C);
 4 | int main(void)
 5 | {
 6 | 	int n;
 7 | 	cout<<"How many?"<<endl;
 8 | 	cin>>n;
 9 | 	Hanoi(n,'A','B','C');
10 | 	return 0;
11 | }
12 | void Hanoi(int n, char A, char B, char C)/*A通过C移动到B*/
13 | {
14 | 	if (n == 1)
15 | 		cout << "move " << n << " from " << A << " to " << C << endl;
16 | 	else
17 | 	{
18 | 		Hanoi(n - 1, A, C, B);
19 | 		cout << "move " << n << " from " << A << " to " << C << endl;
20 | 		Hanoi(n - 1, B, A, C);
21 | 	}
22 | }
23 | 


--------------------------------------------------------------------------------
/作业1 绪论/代码及报告/源代码/汉诺塔（非递归）.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<stdio.h>
 3 | using namespace std;
 4 | void Hanoi(int n);
 5 | int main(void)
 6 | {
 7 |     int n;
 8 |     cout<<"How many?"<<endl;
 9 |     cin >> n;
10 |     Hanoi(n);
11 |     return 0;
12 | }
13 | void Hanoi(int n)
14 | {
15 |     int i, res, t, k;
16 |     int s;
17 |     res = (1 << n) - 1;
18 |     for ( i = 1; i <= res; i++ ) {
19 |         for ( t = 2, s = 1; s <= n; s++, t *= 2)
20 |             if ( i % t == t / 2 ) 
21 |                 break; 
22 |         k = i / t; 
23 |         if ( n % 2 == s % 2 ) { 
24 |             if ( (k + 1) % 3 == 0 ) 
25 |                 cout << "move " << s << " from " << "B" << " to " << "A" << endl;
26 |             if ( (k + 1) % 3 == 1 )
27 |                 cout << "move " << s << " from " << "A" << " to " << "C" << endl;
28 |             if ( (k + 1) % 3 == 2 ) 
29 |                 cout << "move " << s << " from " << "C" << " to " << "B" << endl;
30 |         }
31 |         else { 
32 |             if ( (k + 1) % 3 == 0 )
33 |                 cout << "move " << s << " from " << "C" << " to " << "A" << endl;
34 |             if ( (k + 1) % 3 == 1 )
35 |                 cout << "move " << s << " from " << "A" << " to " << "B" << endl;
36 |             if ( (k + 1) % 3 == 2 ) 
37 |                 cout << "move " << s << " from " << "B" << " to " << "C" << endl;
38 |         }
39 |     }
40 | }


--------------------------------------------------------------------------------
/作业1 绪论/代码及报告/源代码/角谷猜想.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main(void)
 4 | {
 5 | 	int i = 0;//记录操作次数
 6 | 	int MaxTimes = 1;//记录最大操作次数
 7 | 	int MaxTimes_n = 2;//记录最大操作次数的
 8 | 	for (int n = 1; n <= 100; n++)
 9 | 	{
10 | 		int n_pre = n;
11 | 		cout << n;
12 | 		while (n > 1) {
13 | 			if (n % 2) {
14 | 				n = 3 * n + 1;
15 | 				i++;
16 | 				cout << "->" << n;
17 | 			}
18 | 			else {
19 | 				n = n / 2;
20 | 				i++;
21 | 				cout << "->" << n;
22 | 			}
23 | 		}
24 | 		n = n_pre;
25 | 		if (MaxTimes < i) {
26 | 			MaxTimes = i;
27 | 			MaxTimes_n = n;
28 | 		}
29 | 		cout << '\n' << "Times:" << i << '\n' << endl;
30 | 		i = 0;
31 | 	}
32 | 	cout << "最长序列的数为：" << MaxTimes_n << endl;
33 | 	cout << "最长操作次数为：" << MaxTimes << endl;
34 | 	return 0;
35 | }


--------------------------------------------------------------------------------
/作业1 绪论/代码及报告/源代码/选择排序.cpp:
--------------------------------------------------------------------------------
 1 | //直接选择排序，升序
 2 | #include<iostream>
 3 | 
 4 | using namespace std;
 5 | int main()
 6 | {
 7 | 	int array[1000];
 8 | 	/*读入数据*/
 9 | 	int n;
10 | 	int m;
11 | 	int temp;
12 | 	cin >> n;
13 | 	for (int i = 0; i < n; i++)
14 | 		cin >> array[i];
15 | 	/*排序*/
16 | 	for (int i = 0; i < n-1; i++) {
17 | 		m = i;
18 | 		for (int j = i + 1; j < n; j++) {
19 | 			if (array[j] < array[m]) {
20 | 				m = j;
21 | 			}
22 | 		}
23 | 		if (m != i) {
24 | 			temp = array[i];
25 | 			array[i] = array[m];
26 | 			array[m] = temp;
27 | 		}
28 | 	}
29 | 	/*输出数据*/
30 | 	for (int i = 0; i < n; i++)
31 | 	{
32 | 		cout << array[i] << " ";
33 | 	}
34 | 	cout << '\n';
35 | 	return 0;
36 | }


--------------------------------------------------------------------------------
/作业1 绪论/代码及报告/源代码/选择排序（递归）.cpp:
--------------------------------------------------------------------------------
 1 | //直接选择排序(递归)，升序
 2 | #include<iostream>
 3 | using namespace std;
 4 | #define swap(a,b)   (a=a+b,b=a-b,a=a-b)
 5 | void Inpute(int array[], int n);
 6 | void ChioceSort(int array[], int n);
 7 | void Print(int array[], int n);
 8 | int main(void)
 9 | {
10 | 	int array[1000];
11 | 	int n;
12 | 	cin >> n;
13 | 	Inpute(array, n);
14 | 	ChioceSort(array, n);
15 | 	Print(array, n);
16 | 	return 0;
17 | }
18 | void Inpute(int array[], int n)
19 | {
20 | 	for (int i = 0; i < n; i++)
21 | 		cin >> array[i];
22 | }
23 | void ChioceSort(int array[], int n)
24 | {
25 | 	if (n == 1)
26 | 		return;
27 | 	int temp=0;
28 | 	int i;
29 | 	for (i = 0; i < n; i++)
30 | 	{
31 | 		if (array[i] < array[0])
32 | 			temp = i;
33 | 	}
34 | 	if (temp != 0)
35 | 	{
36 | 		swap(array[0], array[temp]);
37 | 	}
38 | 	array++;
39 | 	n--;
40 | 	ChioceSort(array, n);
41 | }
42 | void Print(int array[], int n)
43 | {
44 | 	for (int i = 0; i < n; i++)
45 | 	{
46 | 		cout << array[i] << " ";
47 | 	}
48 | 	cout << '\n';
49 | }


--------------------------------------------------------------------------------
/作业1 绪论/作业1 第1章.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/作业1 绪论/作业1 第1章.pdf


--------------------------------------------------------------------------------
/作业2 线性结构的存储结构与应用/代码及报告/LinkList.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | 
  4 | typedef struct LNode *LIST;
  5 | typedef int ElemType;
  6 | struct LNode{
  7 |     ElemType data;
  8 |     LIST next;
  9 | };
 10 | typedef LIST Position;
 11 | 
 12 | LIST Input();                        //输入数据
 13 | void Delete(int p, LIST L);          //删除给定元素
 14 | void DeleteSame(LIST L);             //对于已排好序的线性表，删除所有重复元素的算法
 15 | LIST reverse(LIST L);                     //将线性表逆置
 16 | LIST DataMove(int k, LIST L);             //线性表循环左移/右移 k 位
 17 | LIST Merge(LIST L1, LIST L2);             //合并两个非递减的线性表
 18 | void Print(LIST L);                       //打印线性表
 19 | void Attach(int data, LIST &Rear);  //尾插
 20 | LIST Input()
 21 | {
 22 |     LIST p, Rear,t;
 23 |     int N;
 24 |     cout << "有多少数据？" << endl;
 25 |     cin >> N;
 26 |     cout << "请输入数据：" << endl;
 27 |     p = new LNode;
 28 |     p->next = NULL;
 29 |     Rear = p;
 30 |     for (int i = 0; i < N; ++i)
 31 |     {
 32 |         int data;
 33 |         cin >> data;
 34 |         Attach(data, Rear);
 35 |     }
 36 |     t = p;
 37 |     p = p->next;
 38 |     delete t;
 39 |     return p;
 40 | }
 41 | void Delete(int p, LIST L)
 42 | {
 43 |     Position tmp, pre;
 44 |     int cnt = 0;
 45 |     pre = L;
 46 |     while (pre && cnt < p -2)
 47 |     {
 48 |         pre = pre->next;
 49 |         cnt++;
 50 |     }
 51 |     if (pre == NULL || cnt != p -2 || pre->next == NULL)
 52 |     {
 53 |         cout << "参数错误!" << endl;
 54 |     }
 55 |     else
 56 |     {
 57 |         tmp = pre->next;
 58 |         pre->next = tmp->next;
 59 |         delete tmp;
 60 |     }
 61 | }
 62 | void Print(LIST L)
 63 | {
 64 |     LIST p = L;
 65 |     while (p)
 66 |     {
 67 |         cout << p->data << ' ';
 68 |         p = p->next;
 69 |     }
 70 | }
 71 | void DeleteSame(LIST L)
 72 | {
 73 |     LIST cur = L;
 74 |     while (cur->next)
 75 |     {
 76 |         if (cur->data == cur->next->data)
 77 |         {
 78 |             cur->next = cur->next->next;
 79 |         }
 80 |         else
 81 |         {
 82 |             cur = cur->next;
 83 |         }
 84 |     }
 85 | }
 86 | LIST reverse(LIST L)
 87 | {
 88 |     LIST p;
 89 |     p = NULL;
 90 |     while(L != NULL){
 91 |         LNode *tmp = L->next;	
 92 |         L->next = p;
 93 |         p = L;
 94 |         L = tmp;
 95 |     }
 96 |     return p;
 97 | }
 98 | LIST DataMove(int k, LIST L)
 99 | {
100 |     LIST tail = L;
101 |     int len =1;
102 |     while(tail->next){
103 |         tail = tail->next;
104 |         len++;
105 |     }
106 |     tail ->next =L;
107 |     k = k%len;
108 |     for(int i = 0;i<len-k;i++){
109 |         tail = tail->next;
110 |     }
111 |     L=tail->next;
112 |     tail->next =NULL;
113 |     return L;
114 | }
115 | LIST Merge(LIST L1, LIST L2)
116 | {
117 |     if(L1==NULL)
118 |         return L2;
119 |     else if(L2==NULL)
120 |         return L1;
121 |     else if(L1->data < L2->data){
122 |             L1->next = Merge(L1->next, L2);
123 |             return L1;
124 |         }
125 |         else{
126 |             L2->next = Merge(L2->next, L1);
127 |             return L2;
128 |         }
129 |        
130 | }
131 | void Attach(int data, LIST &Rear){
132 |     LIST p = new LNode;
133 |     p->data = data;
134 |     p->next = NULL;
135 |     Rear->next = p;
136 |     Rear = p;
137 | }
138 | int main()
139 | {
140 |     while (1)
141 |     {
142 |         cout << "1、删除给定元素" << endl;
143 |         cout << "2、删除排好序的线性表中的重复数据" << endl;
144 |         cout << "3、将线性表逆置" << endl;
145 |         cout << "4、将线性表循环右移K位" << endl;
146 |         cout << "5、合并两个线性表" << endl;
147 |         cout << "6、退出" << endl;
148 |         cout << "请输入对应功能的序号：" << endl;
149 |         int n;
150 |         cin >> n;
151 |         if(n==6)
152 |             return 0;
153 |         LIST L = Input();
154 |         if(n==5){
155 |             LIST L2 = Input();
156 |             cout << "合并后的线性表为：" << endl;
157 |             Print(Merge(L, L2));
158 |             getchar();
159 |             getchar();
160 |         }
161 |         switch (n)
162 |         {
163 |         case 1:
164 |             int p;
165 |             cout << "要删除的元素位置为：" << endl;
166 |             cin >> p;
167 |             Delete(p, L);
168 |             cout << "删除后的线性表为：" << endl;
169 |             Print(L);
170 |             getchar();
171 |             getchar();
172 |             break;
173 |         case 2:
174 |             
175 |             DeleteSame(L);
176 |             cout << "删除后的线性表为：" << endl;
177 |             Print(L);
178 |             getchar();
179 |             getchar();
180 |             break;
181 |         case 3:
182 |             cout << "逆置后的线性表为：" << endl;
183 |             Print(reverse(L));
184 |             getchar();
185 |             getchar();
186 |             break;
187 |         case 4:
188 |             int k;
189 |             cout << "移动多少位？" << endl;
190 |             cin >> k;
191 |             cout << "移动后的线性表为：" << endl;
192 |             Print(DataMove(k, L));
193 |             getchar();
194 |             getchar();
195 |             break;
196 |         case 5:
197 |             return 0;
198 |         }
199 |     }
200 | }
201 | 


--------------------------------------------------------------------------------
/作业2 线性结构的存储结构与应用/代码及报告/SeqList.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | #define max 1000
  4 | typedef int ElemType;
  5 | typedef int Position;
  6 | struct LIST
  7 | {
  8 | 	ElemType elements[max];
  9 | 	Position last;
 10 | };
 11 | void Initial(LIST &L);		  //初始化
 12 | void Input(LIST &L);			  //输入数据
 13 | void Delete(Position p, LIST &L); //删除给定元素
 14 | void DeleteSame(LIST &L);		  //对于已排好序的线性表，删除所有重复元素的算法
 15 | void reverse(LIST &L, int start, int end); //将线性表逆置
 16 | void DataMove(int k, LIST &L);	  //线性表循环左移/右移 k 位
 17 | void Merge(LIST &L1, LIST &L2);//合并两个非递减的线性表
 18 | void Print(LIST L);				  //打印线性表
 19 | 
 20 | void Initial(LIST &L)
 21 | {
 22 | 	L.last = 0;
 23 | }
 24 | void Input(LIST &L)
 25 | {
 26 | 	int N;
 27 | 	cout << "有多少数据？" << endl;
 28 | 	cin >> N;
 29 | 	while (N > max - 1)
 30 | 	{
 31 | 		cout << "溢出了！" << endl;
 32 | 		cout << "有多少数据？" << endl;
 33 | 		cin >> N;
 34 | 	}
 35 | 	cout << "请输入数据：" << endl;
 36 | 	for (int i = 1; i < N + 1; ++i)
 37 | 	{
 38 | 		cin >> L.elements[i];
 39 | 		L.last++;
 40 | 	}
 41 | }
 42 | void Delete(Position p, LIST &L)
 43 | {
 44 | 	Position q;
 45 | 	if (p > L.last || p < 1)
 46 | 		cout << "指定位置不存在"<<endl;
 47 | 	else
 48 | 	{
 49 | 		L.last = L.last - 1;
 50 | 		for (q = p; q <= L.last; q++)
 51 | 			L.elements[q] = L.elements[q + 1];
 52 | 	}
 53 | }
 54 | void Print(LIST L)
 55 | {
 56 | 	for (int i = 1; i <= L.last; ++i)
 57 | 	{
 58 | 		cout << L.elements[i] << ' ';
 59 | 	}
 60 | }
 61 | void DeleteSame(LIST &L)
 62 | {
 63 | 	int i = 1;
 64 | 	for(int j=i+1;j<=L.last;j++)
 65 | 	{
 66 | 		if(L.elements[j]!=L.elements[i])
 67 | 		{
 68 |            L.elements[++i]=L.elements[j];
 69 | 		}
 70 | 	}
 71 | 	L.last=i;
 72 | }
 73 | void reverse(LIST &L, int start, int end){
 74 | 	while (start < end)
 75 | 	{
 76 | 		swap(L.elements[start], L.elements[end]);
 77 | 		start++;
 78 | 		end--;
 79 | 	}
 80 | }
 81 | void DataMove(int k, LIST &L){
 82 | 	k = k % L.last;
 83 | 	int start = 1;
 84 | 	int end = L.last;
 85 | 	reverse(L,start,end);
 86 | 	reverse(L, start, k);
 87 | 	reverse(L, k+1, end);
 88 | }
 89 | void Merge(LIST &L1, LIST &L2){
 90 | 	int p1 = L1.last;
 91 | 	int p2 = L2.last;
 92 | 	int last = L1.last + L2.last;
 93 | 	L1.last = last;
 94 | 	int cur;
 95 | 	while(p1||p2){
 96 | 		if(!p1){
 97 | 			cur = L1.elements[p2];
 98 | 			p2--;
 99 | 		}
100 | 		else if(!p2){
101 | 			cur = L1.elements[p1];
102 | 			p1--;
103 | 		}
104 | 		else if(L1.elements[p1]>L2.elements[p2]){
105 | 			cur = L1.elements[p1];
106 | 			p1--;
107 | 		}
108 | 		else{
109 | 			cur = L2.elements[p2];
110 | 			p2--;
111 | 		}
112 | 		L1.elements[last] = cur;
113 | 		last--;
114 | 	}
115 | }
116 | int main()
117 | {
118 | 	while (1)
119 | 	{
120 | 		cout << "1、删除给定元素" << endl;
121 | 		cout << "2、删除排好序的线性表中的重复数据" << endl;
122 | 		cout << "3、将线性表逆置" << endl;
123 | 		cout << "4、将线性表循环右移K位" << endl;
124 | 		cout << "5、合并两个线性表" << endl;
125 | 		cout << "6、退出" << endl;
126 | 		cout << "请输入对应功能的序号：" << endl;
127 | 		LIST L;
128 | 		int n;
129 | 		cin >> n;
130 | 		switch (n)
131 | 		{
132 | 		case 1:
133 | 			Initial(L);
134 | 			Input(L);
135 | 			int p;
136 | 			cout << "要删除的元素位置为：" << endl;
137 | 			cin >> p;
138 | 			Delete(p, L);
139 | 			cout << "删除后的线性表为：" << endl;
140 | 			Print(L);
141 | 			getchar();
142 | 			getchar();
143 | 			break;
144 | 		case 2:
145 | 			Initial(L);
146 | 			Input(L);
147 | 			DeleteSame(L);
148 | 			cout << "删除后的线性表为：" << endl;
149 | 			Print(L);
150 | 			getchar();
151 | 			getchar();
152 | 			break;
153 | 		case 3:
154 | 			Initial(L);
155 | 			Input(L);
156 | 			reverse(L,1,L.last);
157 | 			cout << "逆置后的线性表为：" << endl;
158 | 			Print(L);
159 | 			getchar();
160 | 			getchar();
161 | 			break;
162 | 		case 4:
163 | 			Initial(L);
164 | 			Input(L);
165 | 			int k;
166 | 			cout << "移动多少位？" << endl;
167 | 			cin >> k;
168 | 			DataMove(k, L);
169 | 			cout << "移动后的线性表为：" << endl;
170 | 			Print(L);
171 | 			getchar();
172 | 			getchar();
173 | 			break;
174 | 		case 5:
175 | 			LIST L2;
176 | 			Initial(L);
177 | 			Initial(L2);
178 | 			Input(L);
179 | 			Input(L2);
180 | 			Merge(L, L2);
181 | 			cout << "合并后的线性表为：" << endl;
182 | 			Print(L);
183 | 			getchar();
184 | 			getchar();
185 | 			break;
186 | 		case 6:
187 | 			return 0;
188 | 		}
189 | 	}
190 | }
191 | 


--------------------------------------------------------------------------------
/作业2 线性结构的存储结构与应用/代码及报告/StaticList.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | #define MaxSize 10
 4 | #define ElemType int
 5 | typedef struct{
 6 | 	ElemType data;
 7 | 	int next;
 8 | }spacestr;
 9 | spacestr SPACE[MaxSize];
10 | int av;
11 | //初始化
12 | void Initialize(){
13 | 	int j;
14 | 	for(j=0;j<MaxSize-1;j++)
15 | 		SPACE[j].next = j+1;
16 | 	SPACE[j].next = -1;
17 | 	av = 0;
18 | }
19 | //打印
20 | void Input(){
21 | 	cout<<"Inpute 10 numbers:"<<endl;
22 | 	int p = av;
23 | 	int i = 0;
24 | 	while(p!=-1){
25 | 		cin>>SPACE[p].data;
26 | 		p = SPACE[p].next;
27 | 		i++;
28 | 	}
29 | }
30 | void Print(){
31 | 	int p = av;
32 | 	while(p!=-1){
33 | 		cout<<SPACE[p].data<<' ';
34 | 		p = SPACE[p].next;
35 | 	}
36 | 	cout<<endl;
37 | }
38 | //逆置
39 | int revearse(){
40 | 	int pre = -1;
41 | 	int p = av;
42 | 	while(p!=-1){
43 | 		p = SPACE[av].next;
44 | 		SPACE[av].next = pre;
45 | 		pre = av;
46 | 		av = p;
47 | 	}
48 | 	return pre;
49 | }
50 | int main(){
51 | 	Initialize();
52 | 	Input();
53 | 	Print();
54 | 	av = revearse();
55 | 	cout<<"逆置后的数据为："<<endl;
56 | 	Print();
57 | 	return 0;
58 | }


--------------------------------------------------------------------------------
/作业2 线性结构的存储结构与应用/代码及报告/作业2 测试数据.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/作业2 线性结构的存储结构与应用/代码及报告/作业2 测试数据.pdf


--------------------------------------------------------------------------------
/作业2 线性结构的存储结构与应用/作业2 线性结构的存储结构与应用.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/作业2 线性结构的存储结构与应用/作业2 线性结构的存储结构与应用.pdf


--------------------------------------------------------------------------------
/作业3 树形结构及其应用/代码及报告/work.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <vector>
  3 | using namespace std;
  4 | 
  5 | #define Max 1000
  6 | #define datatype char
  7 | #define ElemType BTREE
  8 | //输出
  9 | int x;
 10 | char pre[Max];
 11 | //二叉树宽度递归
 12 | int MAX = 0;
 13 | int count[100];
 14 | 
 15 | typedef struct BT_node *BTREE;
 16 | struct BT_node{
 17 |     BTREE lchild;
 18 |     BTREE rchild;
 19 |     datatype data;
 20 | };
 21 | typedef struct stack{
 22 |     ElemType d[Max];
 23 |     int top;
 24 | }Stack;
 25 | 
 26 | typedef struct queue{
 27 |     int front;
 28 |     int rear;
 29 |     ElemType d[Max];
 30 | }Queue;
 31 | 
 32 | //栈操作
 33 | void InitStack(Stack &S);
 34 | bool StackEmpty(Stack S);
 35 | void SPush(Stack &S,ElemType x);
 36 | void SPop(Stack &S,ElemType &x);
 37 | void STop(Stack S,ElemType &x);
 38 | 
 39 | //队列操作
 40 | void InitQueue(Queue &Q);
 41 | bool isEmpty(Queue Q);
 42 | void EnQueue(Queue &Q,ElemType x);
 43 | void DeQueue(Queue &Q,ElemType &x);
 44 | 
 45 | //二叉树操作(1 2题)
 46 | void CreatBTre(BTREE &T);//先序序列保存二叉树
 47 | void PrintBT(BTREE BT);//打印二叉树
 48 | void PreOrderre(BTREE T);//先序遍历，递归
 49 | void InOrderre(BTREE T);//中序遍历，递归
 50 | void PostOrderre(BTREE T);//后序遍历，递归
 51 | void PreOrder(BTREE T);//先序遍历，非递归
 52 | void InOrder(BTREE T);//中序遍历，非递归
 53 | void PostOrder(BTREE T);//后序遍历，非递归
 54 | void LevelOrder(BTREE T);//层次遍历
 55 | void Visit(BTREE T);//访问节点
 56 | //二叉树算法(3 4题)
 57 | bool CheckTree(BTREE T);//判断是否为完全二叉树
 58 | int TreeMaxWidthre(BTREE T);//计算二叉树宽度,递归
 59 | int TreeMaxWidth(BTREE T);//计算二叉树宽度，非递归
 60 | 
 61 | //
 62 | void InitStack(Stack &S){
 63 |     S.top = -1;
 64 | }
 65 | //栈功能
 66 | bool StackEmpty(Stack S){
 67 |     if(S.top==-1)
 68 |         return true;
 69 |     else
 70 |         return false;
 71 | }
 72 | void SPush(Stack &S,ElemType x){
 73 |     if(S.top==Max-1)
 74 |         return;
 75 |     S.d[++S.top] = x;
 76 | }
 77 | void SPop(Stack &S,ElemType &x){
 78 |     if(S.top==-1)
 79 |         return;
 80 |     x = S.d[S.top--];
 81 | }
 82 | void STop(Stack S,ElemType &x){
 83 |     if(S.top==-1)
 84 |         return;
 85 |     x = S.d[S.top];
 86 | }
 87 | //队列功能
 88 | void InitQueue(Queue &Q){
 89 |     Q.rear = Q.front = 0;
 90 |     
 91 | }
 92 | bool isEmpty(Queue Q){
 93 |     if(Q.front==Q.rear)
 94 |         return true;
 95 |     else
 96 |         return false;
 97 | }
 98 | void EnQueue(Queue &Q,ElemType x){
 99 |     if((Q.rear+1)%Max==Q.front)
100 |         return;
101 |     Q.d[Q.rear] = x;
102 |     Q.rear = (Q.rear+1)%Max;
103 | }
104 | void DeQueue(Queue &Q,ElemType &x){
105 |     if(Q.rear==Q.front)
106 |         return;
107 |     x = Q.d[Q.front];
108 |     Q.front = (Q.front+1)%Max;
109 | }
110 | //树操作
111 | //先序序列建立二叉树、递归
112 | void CreatBTre(BTREE &T){
113 |     datatype ch;
114 |     cin>>ch;
115 | 
116 |     if(ch=='#')T=NULL;
117 |     else{
118 |         T = new BT_node;
119 |         T->data=ch;
120 |         CreatBTre(T->lchild);
121 |         CreatBTre(T->rchild);
122 |     }
123 | }
124 | void printd(){
125 |     cout<<pre[x];
126 |     if(pre[x]=='#') return;
127 |     cout<<"(";
128 |     x++;
129 |     printd();
130 |     cout<<",";
131 |     x++;
132 |     printd();
133 |     cout<<")";
134 | }
135 | void PrintBT(BTREE BT){
136 |     Stack S;
137 |     for(int i=0;i<Max;i++){
138 |         pre[i] = ' ';
139 |     }
140 |     x = 0;
141 |     InitStack(S);
142 |     BTREE p = BT;
143 |     while(p||!StackEmpty(S)){
144 |         if(p){
145 |             pre[x++]=p->data;
146 |             SPush(S,p);
147 |             p = p->lchild;
148 |         }
149 |         else{
150 |             pre[x++]='#';
151 |             SPop(S,p);
152 |             p=p->rchild;
153 |         }
154 |     }
155 |     pre[x++]='#';
156 |     x=0;
157 |     printd();
158 |     cout<<endl;
159 | }
160 | void Visit(BTREE T){
161 |     cout<<T->data<<' ';
162 | }
163 | void PreOrderre(BTREE T){
164 |     if(T!=NULL){
165 |         Visit(T);
166 |         PreOrderre(T->lchild);
167 |         PreOrderre(T->rchild);
168 |     }
169 | }
170 | void InOrderre(BTREE T){
171 |     if(T!=NULL){
172 |         InOrderre(T->lchild);
173 |         Visit(T);
174 |         InOrderre(T->rchild);
175 |     }
176 | }
177 | void PostOrderre(BTREE T){
178 |     if(T!=NULL){
179 |         PostOrderre(T->lchild);
180 |         PostOrderre(T->rchild);
181 |         Visit(T);
182 |     }
183 | }
184 | void PreOrder(BTREE T){
185 |     BTREE p = T;
186 |     Stack S;
187 |     InitStack(S);
188 |     while(p||!StackEmpty(S)){
189 |         if(p){
190 |             Visit(p);
191 |             SPush(S,p);
192 |             p = p->lchild;
193 |         }
194 |         else{
195 |             SPop(S,p);
196 |             p = p->rchild;
197 |         }
198 |     }
199 | }
200 | void InOrder(BTREE T){
201 |     BTREE p = T;
202 |     Stack S;
203 |     InitStack(S);
204 |     while(p||!StackEmpty(S)){
205 |         if(p){
206 |             SPush(S,p);
207 |             p = p->lchild;
208 |         }
209 |         else{
210 |             SPop(S,p);
211 |             Visit(p);
212 |             p = p->rchild;
213 |         }
214 |     }
215 | }
216 | void PostOrder(BTREE T){
217 |     Stack S;
218 |     InitStack(S);
219 |     BTREE p = T;
220 |     BTREE tag = NULL;//记录是否从右子节点返回
221 |     while(p||!StackEmpty(S)){
222 |         if(p){
223 |             SPush(S,p);
224 |             p = p->lchild;
225 |         }
226 |         else{
227 |             STop(S,p);
228 |             if(p->rchild&&p->rchild!=tag)
229 |                 p = p->rchild;
230 |             else{
231 |                 SPop(S,p);
232 |                 Visit(p);
233 |                 tag = p;
234 |                 p = NULL;//节点弹出，p指针重置
235 |             }
236 |         }
237 |     }
238 | }
239 | void LevelOrder(BTREE T){
240 |     Queue Q;
241 |     InitQueue(Q);
242 |     BTREE p;
243 |     EnQueue(Q,T);
244 |     while(!isEmpty(Q)){
245 |         DeQueue(Q,p);
246 |         Visit(p);
247 |         if(p->lchild)
248 |             EnQueue(Q,p->lchild);
249 |         if(p->rchild)
250 |             EnQueue(Q,p->rchild);
251 |     }
252 | }
253 | bool CheckTree(BTREE T){
254 |     Queue Q;
255 |     InitQueue(Q);
256 |     if(T==NULL)
257 |         return true;
258 |     EnQueue(Q,T);
259 |     BTREE p;
260 |     while(!isEmpty(Q)){
261 |         DeQueue(Q,p);
262 |         if(p->lchild&&p->rchild){
263 |             EnQueue(Q,p->lchild);
264 |             EnQueue(Q,p->rchild);
265 |         }
266 |         else if(p->rchild&&!p->lchild)
267 |             return false;
268 |         else{
269 |             if(p->lchild&&!p->rchild)
270 |                 EnQueue(Q,p->lchild);
271 |             while(!isEmpty(Q)){
272 |                 DeQueue(Q,p);
273 |                 if(p->lchild||p->rchild)
274 |                     return false;
275 |             }
276 |         }
277 |     }
278 |     return true;
279 | }
280 | void find(BTREE T,int k)
281 | {
282 |     if(T==NULL)  return;
283 |     count[k]++;
284 |     if(MAX<count[k]) 
285 |         MAX=count[k];
286 |     find(T->lchild,k+1);
287 |     find(T->rchild,k+1);
288 | }
289 | int TreeMaxWidthre(BTREE T){
290 |     find(T,0);
291 |     return MAX;
292 | }
293 | int TreeMaxWidth(BTREE T){
294 |     BTREE p;
295 |     int level[Max];//保存层次节点
296 |     Queue Q;
297 |     InitQueue(Q);
298 |     EnQueue(Q,T);
299 |     level[Q.rear] = 1;//根节点层次
300 |     int max = 0;
301 |     while(!isEmpty(Q)){
302 |         DeQueue(Q,p);
303 |         int k = level[Q.front];
304 |         if(p->lchild){
305 |             EnQueue(Q,p->lchild);
306 |             level[Q.rear] = k+1;//新一层
307 |         }
308 |         if(p->rchild){
309 |             EnQueue(Q,p->rchild);
310 |             level[Q.rear] = k+1;//新一层
311 |         }
312 |         int i=0;
313 |         k = 1;
314 |         while(i<=Q.rear){
315 |             int n = 0;
316 |             while(i<=Q.rear&&level[i] == k){
317 |                 n++;
318 |                 i++;
319 |             }
320 |             k = level[i];
321 |             if(n>max){
322 |                 max = n;
323 |             }
324 |         }
325 |     }
326 |     return max;
327 | }
328 | int main() {
329 |     BTREE T;
330 |     cout<<"input a tree:"<<endl;
331 |     CreatBTre(T);
332 |     cout<<"your tree is:"<<endl;
333 |     PrintBT(T);
334 |     cout<<"pre order(recurrence):"<<endl;
335 |     PreOrderre(T);
336 |     cout<<endl;
337 |     cout<<"pre order:"<<endl;
338 |     PreOrder(T);
339 |     cout<<endl;
340 |     cout<<"in order(recurrence):"<<endl;
341 |     InOrderre(T);
342 |     cout<<endl;
343 |     cout<<"in order:"<<endl;
344 |     InOrder(T);
345 |     cout<<endl;
346 |     cout<<"post order(recurrence):"<<endl;
347 |     PostOrderre(T);
348 |     cout<<endl;
349 |     cout<<"post order:"<<endl;
350 |     PostOrder(T);
351 |     cout<<endl;
352 |     cout<<"level order:"<<endl;
353 |     LevelOrder(T);
354 |     cout<<endl;
355 |     cout<<endl;
356 |     if(CheckTree(T))
357 |         cout<<"it is a complete binary tree!"<<endl;
358 |     else
359 |         cout<<"it is NOT a complete binary tree!"<<endl;
360 |     cout<<"the max wideth is:"<<endl;
361 |     cout<<TreeMaxWidthre(T)<<endl;
362 |     return 0;
363 | }
364 | 


--------------------------------------------------------------------------------
/作业3 树形结构及其应用/代码及报告/测试数据和结果数据.docx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/作业3 树形结构及其应用/代码及报告/测试数据和结果数据.docx


--------------------------------------------------------------------------------
/作业3 树形结构及其应用/作业3 树形结构及其应用.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/作业3 树形结构及其应用/作业3 树形结构及其应用.pdf


--------------------------------------------------------------------------------
/作业4 图形结构及其应用/代码及报告/Graph.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/作业4 图形结构及其应用/代码及报告/Graph.cpp


--------------------------------------------------------------------------------
/作业4 图形结构及其应用/代码及报告/测试数据与结果数据及分析.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/作业4 图形结构及其应用/代码及报告/测试数据与结果数据及分析.pdf


--------------------------------------------------------------------------------
/作业4 图形结构及其应用/作业4 图型结构及其应用.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/作业4 图形结构及其应用/作业4 图型结构及其应用.pdf


--------------------------------------------------------------------------------
/作业5 查找结构与排序方法/代码及报告/BST.cpp:
--------------------------------------------------------------------------------
  1 | #include<iostream>
  2 | #include<fstream>
  3 | using namespace std;
  4 | const int Max = 100000;
  5 | typedef struct BSTNode *BSTree;
  6 | struct BSTNode{
  7 | 	int key;
  8 | 	BSTree lchild;
  9 | 	BSTree rchild;
 10 | };
 11 | //BST的插入
 12 | int BST_insert(BSTree &T,int k){
 13 | 	if(T==NULL){//第一次插入，创建根节点
 14 | 		T = new BSTNode;
 15 | 		T->key = k;
 16 | 		T->lchild = NULL;
 17 | 		T->rchild = NULL;
 18 | 		return 1;//创建成功，返回1
 19 | 	}
 20 | 	else if(k==T->key)
 21 | 		return 0;//存在相同关键字，插入失败
 22 | 	else if(k<T->key)
 23 | 		return BST_insert(T->lchild,k);
 24 | 	else
 25 | 		return BST_insert(T->rchild,k);
 26 | 
 27 | }
 28 | //BST的查找
 29 | BSTree BST_search(BSTree &T,int k,int &count){
 30 | 	BSTree p = T;
 31 | 	while(p){
 32 | 		count++;
 33 | 		if(k==p->key)
 34 | 			return p;
 35 | 		if(k>p->key)
 36 | 			p = p->rchild;
 37 | 		else
 38 | 			p = p->lchild;
 39 | 	}
 40 | 	return p;//查找不到，返回空
 41 | }
 42 | //BST的删除
 43 | //该函数用于待删除节点既有左子树又有右子树的情况
 44 | //返回直接后继的关键字并删除直接后继
 45 | int deletemin(BSTree &T){
 46 | 	int tmp;
 47 | 	BSTree p;
 48 | 	if(T->lchild==NULL){
 49 | 		p = T;
 50 | 		tmp = T->key;
 51 | 		T = T->rchild;
 52 | 		delete p;
 53 | 		return tmp;	
 54 | 	}//T就是最小
 55 | 	else return deletemin(T->lchild);//最小结点一定在左子树上
 56 | }
 57 | void BST_delete(BSTree &T,int k){
 58 | 	if(T!=NULL){
 59 | 		if(k<T->key)
 60 | 			BST_delete(T->lchild,k);
 61 | 		else if(k>T->key)
 62 | 			BST_delete(T->rchild,k);
 63 | 		else//等于了
 64 | 			if(T->rchild==NULL)//右子树为空
 65 | 				T=T->lchild;
 66 | 			else if(T->lchild==NULL)//左子树为空
 67 | 				T=T->rchild;
 68 | 			else
 69 | 				T->key = deletemin(T->rchild);
 70 | 	}
 71 | }
 72 | //BST的排序
 73 | void visit(BSTree T){
 74 | 	cout<<T->key<<" ";
 75 | }
 76 | //中序遍历
 77 | void BST_sort(BSTree &T){
 78 | 	if(T!=NULL){
 79 | 		BST_sort(T->lchild);
 80 | 		visit(T);
 81 | 		BST_sort(T->rchild);
 82 | 	}
 83 | }
 84 | //BST的建立
 85 | void BST_creat(BSTree &T,int data[],int n){
 86 | 	T=NULL;
 87 | 	for(int i = 0;i<n;i++){
 88 | 		BST_insert(T,data[i]);
 89 | 	}
 90 | }
 91 | // void test01(){
 92 | // 	BSTree T;
 93 | // 	ifstream infile; 
 94 | //     infile.open("inputdata1.txt");
 95 | //     int in; //临时存放单个数据
 96 | //     int data[Max];
 97 | //     int i = 0;//记录数据数量
 98 | //     while(infile>>in){
 99 | //     	data[i++] = in;
100 | //   	}	
101 | //   	BST_creat(T,data,i);
102 | //   	int k;
103 | //   	cout<<"Insert a number:"<<endl;
104 | //   	cin>>k;
105 | //   	BST_insert(T,k);
106 | //   	BST_sort(T);
107 | //   	cout<<endl;
108 | //   	cout<<"Delete a number:"<<endl;
109 | //   	cin>>k;
110 | //   	BST_delete(T,k);
111 | //   	BST_sort(T);
112 | // }
113 | // void test02(){
114 | // 	BSTree T;
115 | // 	ifstream infile; 
116 | //     infile.open("inputdata1.txt");
117 | //     int in; //临时存放单个数据
118 | //     int data[Max];
119 | //     int i = 0;//记录数据数量
120 | //     while(infile>>in){
121 | //     	data[i++] = in;
122 | //   	}	
123 | //   	BST_creat(T,data,i);
124 | //   	int k;
125 | //   	cout<<"Search a number:"<<endl;
126 | //   	cin>>k;
127 | //   	BSTree p = BST_search(T,k);
128 | //   	cout<<p->key;
129 | // }
130 | void TimesOfSearch(BSTree &T,int data[],int i){
131 |   	BST_creat(T,data,i);
132 |   	int counts = 0;
133 |   	int j = 0;//查找成功的数的个数
134 |   	int countf = 0;
135 |   	int k = 0;//查找失败的数的个数
136 |   	for (int i = 0; i <= 2048; ++i){
137 |   		if(i%2){//这是能查找成功的
138 |   			j++;
139 |   			BST_search(T,i,counts);
140 |   		}
141 |   		else{//这是不能查找成功的
142 |   			k++;
143 |   			BST_search(T,i,countf);
144 |   		}
145 |   	}
146 |   	double ASLs = (double)counts/j;
147 |   	double ASLf = (double)countf/k;
148 |   	cout<<"查找成功的平均查找长度为："<<ASLs<<endl;
149 |   	cout<<"查找失败的平均查找长度为："<<ASLf<<endl;
150 | }
151 | int main(){
152 | 	//test01();
153 | 	//test02();
154 | 	BSTree T;
155 | 	ifstream infile; 
156 |     infile.open("inputdata1.txt");
157 |     int in; //临时存放单个数据
158 |     int data[Max];
159 |     int i = 0;//记录数据数量
160 |     while(infile>>in){
161 |     	data[i++] = in;
162 |   	}
163 |   	infile.close();	
164 | 	TimesOfSearch(T,data,i);
165 | 
166 | 	BSTree S;
167 | 	ifstream infile2; 
168 |     infile2.open("inputdata2.txt");
169 |     int in2; //临时存放单个数据
170 |     int data2[Max];
171 |     int j = 0;//记录数据数量
172 |     while(infile2>>in2){
173 |     	data2[j++] = in2;
174 |   	}
175 |   	infile.close();
176 |   	TimesOfSearch(S,data2,j);	
177 |   	BST_sort(S);
178 | }


--------------------------------------------------------------------------------
/作业5 查找结构与排序方法/代码及报告/BinarySearch.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<fstream>
 3 | const int Max = 10000;
 4 | using namespace std;
 5 | int Binary_Search(int a[],int n,int key,int& count){
 6 | 	int low = 0,high = n,mid;
 7 | 	while(low<=high){
 8 | 		mid = (low+high)>>1;
 9 | 		count++;
10 | 		if(a[mid] == key)
11 | 			return mid;
12 | 		else if(a[mid]>key)
13 | 			high = mid-1;
14 | 		else
15 | 			low = mid+1;
16 | 	}
17 | 	return -1;
18 | }
19 | int main(){
20 | 	ifstream infile;
21 | 	infile.open("inputdata1.txt");
22 | 	int in;
23 | 	int data[Max];
24 | 	int count = 0;
25 | 	while(infile>>in){
26 | 		data[count++] = in;
27 | 	}
28 | 	int counts = 0;
29 |   	int j = 0;//查找成功的数的个数
30 |   	int countf = 0;
31 |   	int k = 0;//查找失败的数的个数
32 |   	for (int i = 0; i <= 2048; ++i){
33 |   		if(i%2){//这是能查找成功的
34 |   			j++;
35 |   			Binary_Search(data,count,i,counts);
36 |   		}
37 |   		else{//这是不能查找成功的
38 |   			k++;
39 |   			Binary_Search(data,count,i,countf);
40 |   		}
41 |   	}
42 |   	double ASLs = (double)counts/j;
43 |   	double ASLf = (double)countf/k;
44 |   	cout<<"查找成功的平均查找长度为："<<ASLs<<endl;
45 |   	cout<<"查找失败的平均查找长度为："<<ASLf<<endl;
46 | }


--------------------------------------------------------------------------------
/作业5 查找结构与排序方法/代码及报告/inputdata1.txt:
--------------------------------------------------------------------------------
   1 | 1
   2 | 3
   3 | 5
   4 | 7
   5 | 9
   6 | 11
   7 | 13
   8 | 15
   9 | 17
  10 | 19
  11 | 21
  12 | 23
  13 | 25
  14 | 27
  15 | 29
  16 | 31
  17 | 33
  18 | 35
  19 | 37
  20 | 39
  21 | 41
  22 | 43
  23 | 45
  24 | 47
  25 | 49
  26 | 51
  27 | 53
  28 | 55
  29 | 57
  30 | 59
  31 | 61
  32 | 63
  33 | 65
  34 | 67
  35 | 69
  36 | 71
  37 | 73
  38 | 75
  39 | 77
  40 | 79
  41 | 81
  42 | 83
  43 | 85
  44 | 87
  45 | 89
  46 | 91
  47 | 93
  48 | 95
  49 | 97
  50 | 99
  51 | 101
  52 | 103
  53 | 105
  54 | 107
  55 | 109
  56 | 111
  57 | 113
  58 | 115
  59 | 117
  60 | 119
  61 | 121
  62 | 123
  63 | 125
  64 | 127
  65 | 129
  66 | 131
  67 | 133
  68 | 135
  69 | 137
  70 | 139
  71 | 141
  72 | 143
  73 | 145
  74 | 147
  75 | 149
  76 | 151
  77 | 153
  78 | 155
  79 | 157
  80 | 159
  81 | 161
  82 | 163
  83 | 165
  84 | 167
  85 | 169
  86 | 171
  87 | 173
  88 | 175
  89 | 177
  90 | 179
  91 | 181
  92 | 183
  93 | 185
  94 | 187
  95 | 189
  96 | 191
  97 | 193
  98 | 195
  99 | 197
 100 | 199
 101 | 201
 102 | 203
 103 | 205
 104 | 207
 105 | 209
 106 | 211
 107 | 213
 108 | 215
 109 | 217
 110 | 219
 111 | 221
 112 | 223
 113 | 225
 114 | 227
 115 | 229
 116 | 231
 117 | 233
 118 | 235
 119 | 237
 120 | 239
 121 | 241
 122 | 243
 123 | 245
 124 | 247
 125 | 249
 126 | 251
 127 | 253
 128 | 255
 129 | 257
 130 | 259
 131 | 261
 132 | 263
 133 | 265
 134 | 267
 135 | 269
 136 | 271
 137 | 273
 138 | 275
 139 | 277
 140 | 279
 141 | 281
 142 | 283
 143 | 285
 144 | 287
 145 | 289
 146 | 291
 147 | 293
 148 | 295
 149 | 297
 150 | 299
 151 | 301
 152 | 303
 153 | 305
 154 | 307
 155 | 309
 156 | 311
 157 | 313
 158 | 315
 159 | 317
 160 | 319
 161 | 321
 162 | 323
 163 | 325
 164 | 327
 165 | 329
 166 | 331
 167 | 333
 168 | 335
 169 | 337
 170 | 339
 171 | 341
 172 | 343
 173 | 345
 174 | 347
 175 | 349
 176 | 351
 177 | 353
 178 | 355
 179 | 357
 180 | 359
 181 | 361
 182 | 363
 183 | 365
 184 | 367
 185 | 369
 186 | 371
 187 | 373
 188 | 375
 189 | 377
 190 | 379
 191 | 381
 192 | 383
 193 | 385
 194 | 387
 195 | 389
 196 | 391
 197 | 393
 198 | 395
 199 | 397
 200 | 399
 201 | 401
 202 | 403
 203 | 405
 204 | 407
 205 | 409
 206 | 411
 207 | 413
 208 | 415
 209 | 417
 210 | 419
 211 | 421
 212 | 423
 213 | 425
 214 | 427
 215 | 429
 216 | 431
 217 | 433
 218 | 435
 219 | 437
 220 | 439
 221 | 441
 222 | 443
 223 | 445
 224 | 447
 225 | 449
 226 | 451
 227 | 453
 228 | 455
 229 | 457
 230 | 459
 231 | 461
 232 | 463
 233 | 465
 234 | 467
 235 | 469
 236 | 471
 237 | 473
 238 | 475
 239 | 477
 240 | 479
 241 | 481
 242 | 483
 243 | 485
 244 | 487
 245 | 489
 246 | 491
 247 | 493
 248 | 495
 249 | 497
 250 | 499
 251 | 501
 252 | 503
 253 | 505
 254 | 507
 255 | 509
 256 | 511
 257 | 513
 258 | 515
 259 | 517
 260 | 519
 261 | 521
 262 | 523
 263 | 525
 264 | 527
 265 | 529
 266 | 531
 267 | 533
 268 | 535
 269 | 537
 270 | 539
 271 | 541
 272 | 543
 273 | 545
 274 | 547
 275 | 549
 276 | 551
 277 | 553
 278 | 555
 279 | 557
 280 | 559
 281 | 561
 282 | 563
 283 | 565
 284 | 567
 285 | 569
 286 | 571
 287 | 573
 288 | 575
 289 | 577
 290 | 579
 291 | 581
 292 | 583
 293 | 585
 294 | 587
 295 | 589
 296 | 591
 297 | 593
 298 | 595
 299 | 597
 300 | 599
 301 | 601
 302 | 603
 303 | 605
 304 | 607
 305 | 609
 306 | 611
 307 | 613
 308 | 615
 309 | 617
 310 | 619
 311 | 621
 312 | 623
 313 | 625
 314 | 627
 315 | 629
 316 | 631
 317 | 633
 318 | 635
 319 | 637
 320 | 639
 321 | 641
 322 | 643
 323 | 645
 324 | 647
 325 | 649
 326 | 651
 327 | 653
 328 | 655
 329 | 657
 330 | 659
 331 | 661
 332 | 663
 333 | 665
 334 | 667
 335 | 669
 336 | 671
 337 | 673
 338 | 675
 339 | 677
 340 | 679
 341 | 681
 342 | 683
 343 | 685
 344 | 687
 345 | 689
 346 | 691
 347 | 693
 348 | 695
 349 | 697
 350 | 699
 351 | 701
 352 | 703
 353 | 705
 354 | 707
 355 | 709
 356 | 711
 357 | 713
 358 | 715
 359 | 717
 360 | 719
 361 | 721
 362 | 723
 363 | 725
 364 | 727
 365 | 729
 366 | 731
 367 | 733
 368 | 735
 369 | 737
 370 | 739
 371 | 741
 372 | 743
 373 | 745
 374 | 747
 375 | 749
 376 | 751
 377 | 753
 378 | 755
 379 | 757
 380 | 759
 381 | 761
 382 | 763
 383 | 765
 384 | 767
 385 | 769
 386 | 771
 387 | 773
 388 | 775
 389 | 777
 390 | 779
 391 | 781
 392 | 783
 393 | 785
 394 | 787
 395 | 789
 396 | 791
 397 | 793
 398 | 795
 399 | 797
 400 | 799
 401 | 801
 402 | 803
 403 | 805
 404 | 807
 405 | 809
 406 | 811
 407 | 813
 408 | 815
 409 | 817
 410 | 819
 411 | 821
 412 | 823
 413 | 825
 414 | 827
 415 | 829
 416 | 831
 417 | 833
 418 | 835
 419 | 837
 420 | 839
 421 | 841
 422 | 843
 423 | 845
 424 | 847
 425 | 849
 426 | 851
 427 | 853
 428 | 855
 429 | 857
 430 | 859
 431 | 861
 432 | 863
 433 | 865
 434 | 867
 435 | 869
 436 | 871
 437 | 873
 438 | 875
 439 | 877
 440 | 879
 441 | 881
 442 | 883
 443 | 885
 444 | 887
 445 | 889
 446 | 891
 447 | 893
 448 | 895
 449 | 897
 450 | 899
 451 | 901
 452 | 903
 453 | 905
 454 | 907
 455 | 909
 456 | 911
 457 | 913
 458 | 915
 459 | 917
 460 | 919
 461 | 921
 462 | 923
 463 | 925
 464 | 927
 465 | 929
 466 | 931
 467 | 933
 468 | 935
 469 | 937
 470 | 939
 471 | 941
 472 | 943
 473 | 945
 474 | 947
 475 | 949
 476 | 951
 477 | 953
 478 | 955
 479 | 957
 480 | 959
 481 | 961
 482 | 963
 483 | 965
 484 | 967
 485 | 969
 486 | 971
 487 | 973
 488 | 975
 489 | 977
 490 | 979
 491 | 981
 492 | 983
 493 | 985
 494 | 987
 495 | 989
 496 | 991
 497 | 993
 498 | 995
 499 | 997
 500 | 999
 501 | 1001
 502 | 1003
 503 | 1005
 504 | 1007
 505 | 1009
 506 | 1011
 507 | 1013
 508 | 1015
 509 | 1017
 510 | 1019
 511 | 1021
 512 | 1023
 513 | 1025
 514 | 1027
 515 | 1029
 516 | 1031
 517 | 1033
 518 | 1035
 519 | 1037
 520 | 1039
 521 | 1041
 522 | 1043
 523 | 1045
 524 | 1047
 525 | 1049
 526 | 1051
 527 | 1053
 528 | 1055
 529 | 1057
 530 | 1059
 531 | 1061
 532 | 1063
 533 | 1065
 534 | 1067
 535 | 1069
 536 | 1071
 537 | 1073
 538 | 1075
 539 | 1077
 540 | 1079
 541 | 1081
 542 | 1083
 543 | 1085
 544 | 1087
 545 | 1089
 546 | 1091
 547 | 1093
 548 | 1095
 549 | 1097
 550 | 1099
 551 | 1101
 552 | 1103
 553 | 1105
 554 | 1107
 555 | 1109
 556 | 1111
 557 | 1113
 558 | 1115
 559 | 1117
 560 | 1119
 561 | 1121
 562 | 1123
 563 | 1125
 564 | 1127
 565 | 1129
 566 | 1131
 567 | 1133
 568 | 1135
 569 | 1137
 570 | 1139
 571 | 1141
 572 | 1143
 573 | 1145
 574 | 1147
 575 | 1149
 576 | 1151
 577 | 1153
 578 | 1155
 579 | 1157
 580 | 1159
 581 | 1161
 582 | 1163
 583 | 1165
 584 | 1167
 585 | 1169
 586 | 1171
 587 | 1173
 588 | 1175
 589 | 1177
 590 | 1179
 591 | 1181
 592 | 1183
 593 | 1185
 594 | 1187
 595 | 1189
 596 | 1191
 597 | 1193
 598 | 1195
 599 | 1197
 600 | 1199
 601 | 1201
 602 | 1203
 603 | 1205
 604 | 1207
 605 | 1209
 606 | 1211
 607 | 1213
 608 | 1215
 609 | 1217
 610 | 1219
 611 | 1221
 612 | 1223
 613 | 1225
 614 | 1227
 615 | 1229
 616 | 1231
 617 | 1233
 618 | 1235
 619 | 1237
 620 | 1239
 621 | 1241
 622 | 1243
 623 | 1245
 624 | 1247
 625 | 1249
 626 | 1251
 627 | 1253
 628 | 1255
 629 | 1257
 630 | 1259
 631 | 1261
 632 | 1263
 633 | 1265
 634 | 1267
 635 | 1269
 636 | 1271
 637 | 1273
 638 | 1275
 639 | 1277
 640 | 1279
 641 | 1281
 642 | 1283
 643 | 1285
 644 | 1287
 645 | 1289
 646 | 1291
 647 | 1293
 648 | 1295
 649 | 1297
 650 | 1299
 651 | 1301
 652 | 1303
 653 | 1305
 654 | 1307
 655 | 1309
 656 | 1311
 657 | 1313
 658 | 1315
 659 | 1317
 660 | 1319
 661 | 1321
 662 | 1323
 663 | 1325
 664 | 1327
 665 | 1329
 666 | 1331
 667 | 1333
 668 | 1335
 669 | 1337
 670 | 1339
 671 | 1341
 672 | 1343
 673 | 1345
 674 | 1347
 675 | 1349
 676 | 1351
 677 | 1353
 678 | 1355
 679 | 1357
 680 | 1359
 681 | 1361
 682 | 1363
 683 | 1365
 684 | 1367
 685 | 1369
 686 | 1371
 687 | 1373
 688 | 1375
 689 | 1377
 690 | 1379
 691 | 1381
 692 | 1383
 693 | 1385
 694 | 1387
 695 | 1389
 696 | 1391
 697 | 1393
 698 | 1395
 699 | 1397
 700 | 1399
 701 | 1401
 702 | 1403
 703 | 1405
 704 | 1407
 705 | 1409
 706 | 1411
 707 | 1413
 708 | 1415
 709 | 1417
 710 | 1419
 711 | 1421
 712 | 1423
 713 | 1425
 714 | 1427
 715 | 1429
 716 | 1431
 717 | 1433
 718 | 1435
 719 | 1437
 720 | 1439
 721 | 1441
 722 | 1443
 723 | 1445
 724 | 1447
 725 | 1449
 726 | 1451
 727 | 1453
 728 | 1455
 729 | 1457
 730 | 1459
 731 | 1461
 732 | 1463
 733 | 1465
 734 | 1467
 735 | 1469
 736 | 1471
 737 | 1473
 738 | 1475
 739 | 1477
 740 | 1479
 741 | 1481
 742 | 1483
 743 | 1485
 744 | 1487
 745 | 1489
 746 | 1491
 747 | 1493
 748 | 1495
 749 | 1497
 750 | 1499
 751 | 1501
 752 | 1503
 753 | 1505
 754 | 1507
 755 | 1509
 756 | 1511
 757 | 1513
 758 | 1515
 759 | 1517
 760 | 1519
 761 | 1521
 762 | 1523
 763 | 1525
 764 | 1527
 765 | 1529
 766 | 1531
 767 | 1533
 768 | 1535
 769 | 1537
 770 | 1539
 771 | 1541
 772 | 1543
 773 | 1545
 774 | 1547
 775 | 1549
 776 | 1551
 777 | 1553
 778 | 1555
 779 | 1557
 780 | 1559
 781 | 1561
 782 | 1563
 783 | 1565
 784 | 1567
 785 | 1569
 786 | 1571
 787 | 1573
 788 | 1575
 789 | 1577
 790 | 1579
 791 | 1581
 792 | 1583
 793 | 1585
 794 | 1587
 795 | 1589
 796 | 1591
 797 | 1593
 798 | 1595
 799 | 1597
 800 | 1599
 801 | 1601
 802 | 1603
 803 | 1605
 804 | 1607
 805 | 1609
 806 | 1611
 807 | 1613
 808 | 1615
 809 | 1617
 810 | 1619
 811 | 1621
 812 | 1623
 813 | 1625
 814 | 1627
 815 | 1629
 816 | 1631
 817 | 1633
 818 | 1635
 819 | 1637
 820 | 1639
 821 | 1641
 822 | 1643
 823 | 1645
 824 | 1647
 825 | 1649
 826 | 1651
 827 | 1653
 828 | 1655
 829 | 1657
 830 | 1659
 831 | 1661
 832 | 1663
 833 | 1665
 834 | 1667
 835 | 1669
 836 | 1671
 837 | 1673
 838 | 1675
 839 | 1677
 840 | 1679
 841 | 1681
 842 | 1683
 843 | 1685
 844 | 1687
 845 | 1689
 846 | 1691
 847 | 1693
 848 | 1695
 849 | 1697
 850 | 1699
 851 | 1701
 852 | 1703
 853 | 1705
 854 | 1707
 855 | 1709
 856 | 1711
 857 | 1713
 858 | 1715
 859 | 1717
 860 | 1719
 861 | 1721
 862 | 1723
 863 | 1725
 864 | 1727
 865 | 1729
 866 | 1731
 867 | 1733
 868 | 1735
 869 | 1737
 870 | 1739
 871 | 1741
 872 | 1743
 873 | 1745
 874 | 1747
 875 | 1749
 876 | 1751
 877 | 1753
 878 | 1755
 879 | 1757
 880 | 1759
 881 | 1761
 882 | 1763
 883 | 1765
 884 | 1767
 885 | 1769
 886 | 1771
 887 | 1773
 888 | 1775
 889 | 1777
 890 | 1779
 891 | 1781
 892 | 1783
 893 | 1785
 894 | 1787
 895 | 1789
 896 | 1791
 897 | 1793
 898 | 1795
 899 | 1797
 900 | 1799
 901 | 1801
 902 | 1803
 903 | 1805
 904 | 1807
 905 | 1809
 906 | 1811
 907 | 1813
 908 | 1815
 909 | 1817
 910 | 1819
 911 | 1821
 912 | 1823
 913 | 1825
 914 | 1827
 915 | 1829
 916 | 1831
 917 | 1833
 918 | 1835
 919 | 1837
 920 | 1839
 921 | 1841
 922 | 1843
 923 | 1845
 924 | 1847
 925 | 1849
 926 | 1851
 927 | 1853
 928 | 1855
 929 | 1857
 930 | 1859
 931 | 1861
 932 | 1863
 933 | 1865
 934 | 1867
 935 | 1869
 936 | 1871
 937 | 1873
 938 | 1875
 939 | 1877
 940 | 1879
 941 | 1881
 942 | 1883
 943 | 1885
 944 | 1887
 945 | 1889
 946 | 1891
 947 | 1893
 948 | 1895
 949 | 1897
 950 | 1899
 951 | 1901
 952 | 1903
 953 | 1905
 954 | 1907
 955 | 1909
 956 | 1911
 957 | 1913
 958 | 1915
 959 | 1917
 960 | 1919
 961 | 1921
 962 | 1923
 963 | 1925
 964 | 1927
 965 | 1929
 966 | 1931
 967 | 1933
 968 | 1935
 969 | 1937
 970 | 1939
 971 | 1941
 972 | 1943
 973 | 1945
 974 | 1947
 975 | 1949
 976 | 1951
 977 | 1953
 978 | 1955
 979 | 1957
 980 | 1959
 981 | 1961
 982 | 1963
 983 | 1965
 984 | 1967
 985 | 1969
 986 | 1971
 987 | 1973
 988 | 1975
 989 | 1977
 990 | 1979
 991 | 1981
 992 | 1983
 993 | 1985
 994 | 1987
 995 | 1989
 996 | 1991
 997 | 1993
 998 | 1995
 999 | 1997
1000 | 1999
1001 | 2001
1002 | 2003
1003 | 2005
1004 | 2007
1005 | 2009
1006 | 2011
1007 | 2013
1008 | 2015
1009 | 2017
1010 | 2019
1011 | 2021
1012 | 2023
1013 | 2025
1014 | 2027
1015 | 2029
1016 | 2031
1017 | 2033
1018 | 2035
1019 | 2037
1020 | 2039
1021 | 2041
1022 | 2043
1023 | 2045
1024 | 2047
1025 | 


--------------------------------------------------------------------------------
/作业5 查找结构与排序方法/代码及报告/inputdata2.txt:
--------------------------------------------------------------------------------
   1 | 15
   2 | 153
   3 | 1997
   4 | 1967
   5 | 3
   6 | 2037
   7 | 1947
   8 | 1933
   9 | 105
  10 | 1975
  11 | 2043
  12 | 1925
  13 | 37
  14 | 1869
  15 | 2021
  16 | 71
  17 | 23
  18 | 1987
  19 | 2029
  20 | 39
  21 | 1993
  22 | 63
  23 | 21
  24 | 1991
  25 | 2015
  26 | 85
  27 | 2007
  28 | 5
  29 | 1927
  30 | 173
  31 | 1953
  32 | 61
  33 | 1845
  34 | 1945
  35 | 145
  36 | 1929
  37 | 349
  38 | 1949
  39 | 1891
  40 | 111
  41 | 2001
  42 | 1973
  43 | 29
  44 | 51
  45 | 2011
  46 | 147
  47 | 1873
  48 | 101
  49 | 2003
  50 | 57
  51 | 1859
  52 | 2017
  53 | 59
  54 | 9
  55 | 2005
  56 | 1885
  57 | 1793
  58 | 87
  59 | 65
  60 | 131
  61 | 1963
  62 | 1943
  63 | 1995
  64 | 1961
  65 | 11
  66 | 55
  67 | 95
  68 | 165
  69 | 1981
  70 | 1811
  71 | 221
  72 | 1805
  73 | 1839
  74 | 117
  75 | 207
  76 | 149
  77 | 2025
  78 | 159
  79 | 127
  80 | 1893
  81 | 1911
  82 | 1849
  83 | 1803
  84 | 177
  85 | 201
  86 | 1819
  87 | 1745
  88 | 195
  89 | 1855
  90 | 249
  91 | 49
  92 | 1921
  93 | 1733
  94 | 89
  95 | 197
  96 | 83
  97 | 1877
  98 | 1879
  99 | 1823
 100 | 215
 101 | 1731
 102 | 217
 103 | 191
 104 | 1843
 105 | 269
 106 | 211
 107 | 1983
 108 | 123
 109 | 347
 110 | 179
 111 | 1863
 112 | 1831
 113 | 181
 114 | 1699
 115 | 251
 116 | 1857
 117 | 163
 118 | 137
 119 | 1711
 120 | 1937
 121 | 1729
 122 | 255
 123 | 1889
 124 | 161
 125 | 27
 126 | 1887
 127 | 309
 128 | 1787
 129 | 265
 130 | 1783
 131 | 331
 132 | 1751
 133 | 1777
 134 | 169
 135 | 377
 136 | 1779
 137 | 303
 138 | 209
 139 | 1707
 140 | 223
 141 | 1735
 142 | 1895
 143 | 1913
 144 | 239
 145 | 1907
 146 | 259
 147 | 295
 148 | 351
 149 | 297
 150 | 1639
 151 | 2019
 152 | 373
 153 | 1763
 154 | 157
 155 | 171
 156 | 1743
 157 | 1689
 158 | 263
 159 | 1677
 160 | 1817
 161 | 335
 162 | 273
 163 | 1747
 164 | 1663
 165 | 1667
 166 | 1693
 167 | 1665
 168 | 317
 169 | 409
 170 | 389
 171 | 291
 172 | 1703
 173 | 1591
 174 | 225
 175 | 243
 176 | 257
 177 | 391
 178 | 1725
 179 | 453
 180 | 429
 181 | 1565
 182 | 1655
 183 | 1581
 184 | 1695
 185 | 1641
 186 | 1633
 187 | 1607
 188 | 1691
 189 | 1647
 190 | 1795
 191 | 475
 192 | 1597
 193 | 1749
 194 | 411
 195 | 1573
 196 | 203
 197 | 323
 198 | 419
 199 | 1603
 200 | 1781
 201 | 271
 202 | 325
 203 | 1721
 204 | 1621
 205 | 575
 206 | 337
 207 | 1759
 208 | 501
 209 | 507
 210 | 283
 211 | 1517
 212 | 1637
 213 | 431
 214 | 1549
 215 | 1473
 216 | 1685
 217 | 1585
 218 | 1547
 219 | 1477
 220 | 469
 221 | 493
 222 | 423
 223 | 1595
 224 | 401
 225 | 1513
 226 | 533
 227 | 1557
 228 | 1521
 229 | 321
 230 | 437
 231 | 649
 232 | 1429
 233 | 247
 234 | 417
 235 | 615
 236 | 523
 237 | 467
 238 | 513
 239 | 1523
 240 | 1623
 241 | 1491
 242 | 677
 243 | 399
 244 | 487
 245 | 531
 246 | 407
 247 | 629
 248 | 1443
 249 | 473
 250 | 1617
 251 | 1381
 252 | 563
 253 | 427
 254 | 529
 255 | 1459
 256 | 1511
 257 | 1527
 258 | 1509
 259 | 1571
 260 | 1609
 261 | 471
 262 | 1567
 263 | 1551
 264 | 607
 265 | 1535
 266 | 741
 267 | 1391
 268 | 565
 269 | 709
 270 | 1631
 271 | 1423
 272 | 1483
 273 | 1533
 274 | 1529
 275 | 577
 276 | 635
 277 | 1453
 278 | 1569
 279 | 481
 280 | 1415
 281 | 527
 282 | 1427
 283 | 561
 284 | 1383
 285 | 1461
 286 | 405
 287 | 537
 288 | 1553
 289 | 645
 290 | 555
 291 | 603
 292 | 557
 293 | 515
 294 | 1319
 295 | 1301
 296 | 659
 297 | 1563
 298 | 633
 299 | 1373
 300 | 343
 301 | 1659
 302 | 1277
 303 | 589
 304 | 631
 305 | 581
 306 | 663
 307 | 613
 308 | 639
 309 | 545
 310 | 1371
 311 | 1613
 312 | 1543
 313 | 605
 314 | 1309
 315 | 511
 316 | 567
 317 | 573
 318 | 681
 319 | 773
 320 | 671
 321 | 571
 322 | 1505
 323 | 1431
 324 | 593
 325 | 625
 326 | 661
 327 | 1299
 328 | 801
 329 | 643
 330 | 803
 331 | 1375
 332 | 1439
 333 | 1251
 334 | 1419
 335 | 1323
 336 | 1403
 337 | 601
 338 | 1463
 339 | 1263
 340 | 685
 341 | 1365
 342 | 1499
 343 | 813
 344 | 1455
 345 | 1435
 346 | 805
 347 | 1219
 348 | 669
 349 | 1397
 350 | 1233
 351 | 647
 352 | 1199
 353 | 841
 354 | 1425
 355 | 1229
 356 | 1295
 357 | 691
 358 | 1321
 359 | 1389
 360 | 1467
 361 | 1137
 362 | 1351
 363 | 1239
 364 | 1413
 365 | 1221
 366 | 595
 367 | 739
 368 | 731
 369 | 1479
 370 | 1307
 371 | 1355
 372 | 1349
 373 | 1305
 374 | 1215
 375 | 1285
 376 | 743
 377 | 961
 378 | 1211
 379 | 779
 380 | 765
 381 | 559
 382 | 717
 383 | 795
 384 | 1223
 385 | 1287
 386 | 1159
 387 | 699
 388 | 695
 389 | 727
 390 | 1243
 391 | 1235
 392 | 859
 393 | 1335
 394 | 845
 395 | 735
 396 | 675
 397 | 1275
 398 | 1255
 399 | 719
 400 | 1325
 401 | 1153
 402 | 967
 403 | 807
 404 | 793
 405 | 1019
 406 | 1273
 407 | 1073
 408 | 855
 409 | 863
 410 | 787
 411 | 1177
 412 | 627
 413 | 1217
 414 | 1329
 415 | 811
 416 | 829
 417 | 893
 418 | 1115
 419 | 1093
 420 | 891
 421 | 759
 422 | 687
 423 | 775
 424 | 839
 425 | 1131
 426 | 1311
 427 | 943
 428 | 1101
 429 | 869
 430 | 945
 431 | 1067
 432 | 1281
 433 | 905
 434 | 1025
 435 | 865
 436 | 753
 437 | 1041
 438 | 873
 439 | 955
 440 | 1125
 441 | 857
 442 | 927
 443 | 1317
 444 | 737
 445 | 789
 446 | 1149
 447 | 935
 448 | 771
 449 | 1119
 450 | 1237
 451 | 1059
 452 | 1043
 453 | 1089
 454 | 1175
 455 | 1269
 456 | 1033
 457 | 871
 458 | 1135
 459 | 1065
 460 | 1057
 461 | 1189
 462 | 1185
 463 | 973
 464 | 1257
 465 | 867
 466 | 1015
 467 | 875
 468 | 1127
 469 | 1103
 470 | 989
 471 | 1133
 472 | 1037
 473 | 915
 474 | 1045
 475 | 847
 476 | 1201
 477 | 1167
 478 | 979
 479 | 1087
 480 | 1023
 481 | 1083
 482 | 1171
 483 | 991
 484 | 1039
 485 | 931
 486 | 1121
 487 | 1213
 488 | 1049
 489 | 1063
 490 | 1035
 491 | 923
 492 | 1179
 493 | 919
 494 | 1051
 495 | 953
 496 | 1081
 497 | 1077
 498 | 1027
 499 | 911
 500 | 933
 501 | 1107
 502 | 995
 503 | 1029
 504 | 1267
 505 | 975
 506 | 831
 507 | 937
 508 | 1071
 509 | 949
 510 | 997
 511 | 917
 512 | 977
 513 | 993
 514 | 969
 515 | 1209
 516 | 987
 517 | 1095
 518 | 1129
 519 | 1017
 520 | 939
 521 | 1047
 522 | 1053
 523 | 947
 524 | 825
 525 | 1085
 526 | 1001
 527 | 1113
 528 | 1117
 529 | 941
 530 | 749
 531 | 1031
 532 | 1105
 533 | 1123
 534 | 1021
 535 | 1091
 536 | 1099
 537 | 899
 538 | 1009
 539 | 1155
 540 | 921
 541 | 889
 542 | 1061
 543 | 1013
 544 | 885
 545 | 1007
 546 | 1109
 547 | 1195
 548 | 903
 549 | 821
 550 | 1075
 551 | 981
 552 | 1313
 553 | 1253
 554 | 1079
 555 | 1111
 556 | 1011
 557 | 769
 558 | 985
 559 | 909
 560 | 1205
 561 | 1147
 562 | 879
 563 | 999
 564 | 1055
 565 | 965
 566 | 849
 567 | 983
 568 | 1005
 569 | 1331
 570 | 883
 571 | 835
 572 | 959
 573 | 819
 574 | 827
 575 | 1161
 576 | 887
 577 | 799
 578 | 957
 579 | 1169
 580 | 1227
 581 | 1003
 582 | 1231
 583 | 1139
 584 | 823
 585 | 1193
 586 | 1157
 587 | 1141
 588 | 951
 589 | 971
 590 | 1173
 591 | 1097
 592 | 861
 593 | 785
 594 | 729
 595 | 851
 596 | 1259
 597 | 1069
 598 | 1289
 599 | 797
 600 | 1165
 601 | 1261
 602 | 877
 603 | 901
 604 | 1151
 605 | 1327
 606 | 1345
 607 | 1265
 608 | 1143
 609 | 907
 610 | 843
 611 | 1247
 612 | 815
 613 | 963
 614 | 1181
 615 | 1225
 616 | 1207
 617 | 897
 618 | 1187
 619 | 721
 620 | 1145
 621 | 733
 622 | 881
 623 | 791
 624 | 1343
 625 | 723
 626 | 895
 627 | 925
 628 | 777
 629 | 783
 630 | 1283
 631 | 833
 632 | 853
 633 | 1363
 634 | 713
 635 | 1191
 636 | 763
 637 | 1163
 638 | 929
 639 | 1183
 640 | 1197
 641 | 585
 642 | 619
 643 | 1303
 644 | 609
 645 | 1447
 646 | 767
 647 | 1203
 648 | 817
 649 | 757
 650 | 913
 651 | 809
 652 | 1249
 653 | 1379
 654 | 651
 655 | 751
 656 | 689
 657 | 1271
 658 | 715
 659 | 703
 660 | 1341
 661 | 781
 662 | 1315
 663 | 1245
 664 | 1493
 665 | 621
 666 | 1339
 667 | 761
 668 | 1369
 669 | 1377
 670 | 1357
 671 | 1297
 672 | 697
 673 | 597
 674 | 1489
 675 | 653
 676 | 655
 677 | 599
 678 | 1279
 679 | 725
 680 | 1293
 681 | 837
 682 | 1359
 683 | 667
 684 | 463
 685 | 611
 686 | 1485
 687 | 665
 688 | 1457
 689 | 1469
 690 | 641
 691 | 1401
 692 | 583
 693 | 551
 694 | 693
 695 | 1409
 696 | 747
 697 | 1433
 698 | 1241
 699 | 1445
 700 | 1449
 701 | 1353
 702 | 1387
 703 | 1347
 704 | 705
 705 | 657
 706 | 701
 707 | 465
 708 | 1497
 709 | 569
 710 | 1333
 711 | 707
 712 | 1291
 713 | 1395
 714 | 1405
 715 | 1399
 716 | 1411
 717 | 1421
 718 | 1541
 719 | 623
 720 | 679
 721 | 711
 722 | 745
 723 | 1361
 724 | 541
 725 | 1393
 726 | 1507
 727 | 1475
 728 | 673
 729 | 539
 730 | 397
 731 | 489
 732 | 755
 733 | 491
 734 | 1559
 735 | 617
 736 | 485
 737 | 1367
 738 | 1525
 739 | 1605
 740 | 1407
 741 | 1561
 742 | 1645
 743 | 553
 744 | 1599
 745 | 1437
 746 | 519
 747 | 1417
 748 | 683
 749 | 1587
 750 | 637
 751 | 1615
 752 | 1337
 753 | 547
 754 | 483
 755 | 1555
 756 | 517
 757 | 355
 758 | 1451
 759 | 455
 760 | 319
 761 | 505
 762 | 395
 763 | 415
 764 | 1465
 765 | 499
 766 | 1515
 767 | 381
 768 | 509
 769 | 1673
 770 | 1385
 771 | 421
 772 | 1537
 773 | 587
 774 | 457
 775 | 1501
 776 | 535
 777 | 413
 778 | 1629
 779 | 1675
 780 | 1649
 781 | 461
 782 | 1577
 783 | 1487
 784 | 1481
 785 | 591
 786 | 1495
 787 | 357
 788 | 1471
 789 | 451
 790 | 379
 791 | 183
 792 | 1671
 793 | 521
 794 | 1697
 795 | 1539
 796 | 1611
 797 | 383
 798 | 549
 799 | 1575
 800 | 1545
 801 | 543
 802 | 1503
 803 | 367
 804 | 1867
 805 | 1727
 806 | 497
 807 | 1519
 808 | 579
 809 | 361
 810 | 1593
 811 | 1619
 812 | 387
 813 | 1441
 814 | 393
 815 | 365
 816 | 447
 817 | 293
 818 | 363
 819 | 311
 820 | 525
 821 | 503
 822 | 369
 823 | 441
 824 | 425
 825 | 1635
 826 | 1775
 827 | 443
 828 | 1767
 829 | 281
 830 | 1627
 831 | 1723
 832 | 1579
 833 | 371
 834 | 1719
 835 | 353
 836 | 1681
 837 | 403
 838 | 279
 839 | 1643
 840 | 459
 841 | 445
 842 | 1801
 843 | 1789
 844 | 235
 845 | 285
 846 | 449
 847 | 1657
 848 | 1625
 849 | 1583
 850 | 439
 851 | 307
 852 | 477
 853 | 1769
 854 | 1753
 855 | 1653
 856 | 1669
 857 | 339
 858 | 1683
 859 | 1809
 860 | 1797
 861 | 1701
 862 | 435
 863 | 1815
 864 | 433
 865 | 333
 866 | 1601
 867 | 1709
 868 | 287
 869 | 1531
 870 | 1589
 871 | 1853
 872 | 1687
 873 | 1851
 874 | 359
 875 | 1739
 876 | 479
 877 | 1651
 878 | 193
 879 | 1807
 880 | 301
 881 | 1757
 882 | 329
 883 | 1679
 884 | 1833
 885 | 375
 886 | 231
 887 | 213
 888 | 495
 889 | 1705
 890 | 1799
 891 | 277
 892 | 385
 893 | 345
 894 | 1715
 895 | 313
 896 | 1871
 897 | 1661
 898 | 1771
 899 | 1917
 900 | 79
 901 | 327
 902 | 1835
 903 | 1919
 904 | 305
 905 | 1813
 906 | 241
 907 | 1713
 908 | 1909
 909 | 289
 910 | 253
 911 | 1861
 912 | 1755
 913 | 1837
 914 | 141
 915 | 1741
 916 | 155
 917 | 1847
 918 | 1737
 919 | 267
 920 | 109
 921 | 2045
 922 | 1915
 923 | 1765
 924 | 341
 925 | 1903
 926 | 93
 927 | 1717
 928 | 139
 929 | 91
 930 | 185
 931 | 99
 932 | 1761
 933 | 1841
 934 | 315
 935 | 1901
 936 | 229
 937 | 43
 938 | 1785
 939 | 121
 940 | 167
 941 | 299
 942 | 129
 943 | 275
 944 | 1905
 945 | 107
 946 | 261
 947 | 115
 948 | 1881
 949 | 151
 950 | 1951
 951 | 199
 952 | 1825
 953 | 1821
 954 | 1791
 955 | 1977
 956 | 97
 957 | 47
 958 | 219
 959 | 17
 960 | 227
 961 | 1829
 962 | 1865
 963 | 2009
 964 | 45
 965 | 2027
 966 | 77
 967 | 41
 968 | 1959
 969 | 233
 970 | 245
 971 | 205
 972 | 1965
 973 | 1773
 974 | 125
 975 | 1899
 976 | 2023
 977 | 1883
 978 | 175
 979 | 1955
 980 | 2033
 981 | 135
 982 | 143
 983 | 19
 984 | 1939
 985 | 113
 986 | 1971
 987 | 13
 988 | 189
 989 | 75
 990 | 103
 991 | 1875
 992 | 69
 993 | 133
 994 | 2013
 995 | 2039
 996 | 31
 997 | 237
 998 | 25
 999 | 1931
1000 | 73
1001 | 2041
1002 | 53
1003 | 1941
1004 | 1985
1005 | 7
1006 | 1969
1007 | 1935
1008 | 33
1009 | 0
1010 | 81
1011 | 2047
1012 | 2031
1013 | 119
1014 | 1827
1015 | 67
1016 | 1897
1017 | 187
1018 | 1
1019 | 1989
1020 | 1979
1021 | 1999
1022 | 35
1023 | 2035
1024 | 1923
1025 | 


--------------------------------------------------------------------------------
/作业5 查找结构与排序方法/代码及报告/测试数据及结果数据.docx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/作业5 查找结构与排序方法/代码及报告/测试数据及结果数据.docx


--------------------------------------------------------------------------------
/作业5 查找结构与排序方法/代码及报告/生成测试数据.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<fstream>
 3 | #include<cstdlib>
 4 | #include <time.h>
 5 | using namespace std;
 6 | const int Max = 2048;
 7 | int main() {
 8 | 	ofstream outfile("inputdata1.txt");
 9 | 	int data[Max];
10 | 	int j = 0;
11 | 	for (int i = 0; i <= Max; ++i) {
12 | 		if (i % 2) {
13 | 			data[j++] = i;
14 | 			outfile << i << endl;
15 | 		}
16 | 	}
17 | 	outfile.close();
18 | 	ofstream outfile1("inputdata2.txt");
19 | 	srand((int)time(NULL));
20 | 	for (int i = 0; i < 1000000; i++)
21 | 	{
22 | 		int pose = rand() % j;
23 | 		swap(data[pose],data[j-pose-1]);//随即交换
24 | 		swap(data[pose+1],data[j-pose-1]);
25 | 	}
26 | 	while(j--){
27 | 		outfile1<<data[j]<<endl;
28 | 	}
29 | 	outfile1.close();
30 | }


--------------------------------------------------------------------------------
/作业5 查找结构与排序方法/作业5 查找结构与排序方法.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/作业5 查找结构与排序方法/作业5 查找结构与排序方法.pdf


--------------------------------------------------------------------------------
/实验1 线性结构及其应用/代码及报告/calculator.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验1 线性结构及其应用/代码及报告/calculator.cpp


--------------------------------------------------------------------------------
/实验1 线性结构及其应用/代码及报告/calculator.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验1 线性结构及其应用/代码及报告/calculator.exe


--------------------------------------------------------------------------------
/实验1 线性结构及其应用/代码及报告/calculator.o:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验1 线性结构及其应用/代码及报告/calculator.o


--------------------------------------------------------------------------------
/实验1 线性结构及其应用/代码及报告/in1.txt:
--------------------------------------------------------------------------------
1 | 1x^4+2x^3+20x^2+15x^5


--------------------------------------------------------------------------------
/实验1 线性结构及其应用/代码及报告/in2.txt:
--------------------------------------------------------------------------------
1 | 1x^2+2x^3+15x^5+2x^3+15x^5


--------------------------------------------------------------------------------
/实验1 线性结构及其应用/代码及报告/out.txt:
--------------------------------------------------------------------------------
 1 | 5.000x^20--7.000x^4+3.000x^2+3.000x^1+3.000x^0
 2 | 5.000x^20--7.000x^4+3.000x^2+3.000x^1+3.000x^0
 3 | 15.000x^22+15.000x^20--21.000x^6--21.000x^4+9.000x^3+9.000x^1
 4 | 5.000x^20--7.000x^4+3.000x^2+3.000x^1+3.000x^0
 5 | 5.000x^20+3.000x^8+15.000x^7--7.000x^4+5.000x^2+3.000x^1+3.000x^0
 6 | 5.000x^20+3.000x^8+15.000x^7--7.000x^4+5.000x^2+3.000x^1+3.000x^0
 7 | 15.000x^28+75.000x^27+25.000x^22+15.000x^20--21.000x^12--105.000x^11+9.000x^9+45.000x^8--35.000x^6--21.000x^4+15.000x^3+9.000x^1
 8 | 5.000x^20+3.000x^8+15.000x^7--7.000x^4+5.000x^2+3.000x^1+3.000x^0
 9 | 0.000x^0+5.000x^20--7.000x^4+3.000x^1
10 | 0.000x^0
11 | 4.000x^0
12 | 1.000x^4+1.000x^2
13 | 1.000x^6
14 | 1.000x^4--1.000x^-2
15 | 1.000x^4--1.000x^-2
16 | 1.000x^6
17 | 1.000x^4--1.000x^2
18 | 1.000x^6
19 | 1.000x^4+1.000x^2
20 | 1.000x^6
21 | 1.000x^4--1.000x^2
22 | 1.000x^6
23 | 30.000x^5+15.000x^5+1.000x^4+4.000x^3+2.000x^3+21.000x^2+20.000x^2+20.000x^2
24 | 30.000x^5+15.000x^5+1.000x^4+4.000x^3+2.000x^3+21.000x^2
25 | 225.000x^10+225.000x^10+15.000x^9+15.000x^9+90.000x^8+30.000x^8+619.000x^7+9.000x^6+82.000x^5+20.000x^4
26 | 225.000x^10+225.000x^10+15.000x^9+15.000x^9+90.000x^8+30.000x^8+619.000x^7+9.000x^6+82.000x^5+20.000x^4
27 | 


--------------------------------------------------------------------------------
/实验1 线性结构及其应用/代码及报告/实验报告.doc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验1 线性结构及其应用/代码及报告/实验报告.doc


--------------------------------------------------------------------------------
/实验1 线性结构及其应用/代码及报告/实验测试数据和结果数据.docx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验1 线性结构及其应用/代码及报告/实验测试数据和结果数据.docx


--------------------------------------------------------------------------------
/实验1 线性结构及其应用/实验1 线性结构及其应用.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验1 线性结构及其应用/实验1 线性结构及其应用.pdf


--------------------------------------------------------------------------------
/实验2 树形结构及其应用/代码及报告/1.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | int main(){
 4 | 	freopen("test.in","r",stdin);
 5 | 	string s;
 6 | 	cin>>s;
 7 | 	int ans = 0;
 8 | 	for(int i = 0;i<(int)s.length()-2;i++)
 9 | 		for(int j = i+1;j<(int)s.length()-1;j++)
10 | 			for(int k = j+1;k<(int)s.length();k++)
11 | 				if(s[i]=='Q'&&s[j]=='A'&&s[k]=='Q')
12 | 					ans++;
13 | 	cout<<ans<<endl;
14 | 	return 0;
15 | }


--------------------------------------------------------------------------------
/实验2 树形结构及其应用/代码及报告/CompressedFile.huffman:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验2 树形结构及其应用/代码及报告/CompressedFile.huffman


--------------------------------------------------------------------------------
/实验2 树形结构及其应用/代码及报告/DeCompress_Char.cpp:
--------------------------------------------------------------------------------
 1 | //译码器
 2 | #include <iostream>
 3 | #include <fstream>
 4 | #include <string>
 5 | #include <string.h>
 6 | 
 7 | using namespace std;
 8 | #define ASC 128
 9 | #define m 2*ASC-1//2n-1个节点
10 | //第一位，编码总数total(char型)
11 | //下total位，字符(char型)
12 | //下total-1位，哈夫曼树(int型)
13 | int total;
14 | long long count;
15 | typedef struct {
16 | 	double weight;
17 | 	int lchild;
18 | 	int rchild;
19 | 	int parent;
20 | } HTNode;
21 | typedef struct {
22 | 	char ch;//字符
23 | 	double freq;//字符频率
24 | 	char code[ASC];//哈夫曼编码
25 | } Orchar;
26 | HTNode HTree[m];
27 | Orchar Or[ASC];
28 | int main(){
29 | 	ifstream bfile("CompressedFile.huffman",ios::binary);
30 | 	ofstream file("OutputText.txt");
31 | 	if(!bfile){
32 | 		cout<<"Failed To Open The Compressed File!"<<endl;
33 | 		return 0;
34 | 	}
35 | 	//字符种类数
36 | 	bfile>>total;
37 | 	bfile>>noskipws;//设置读取空白符
38 | 	//各字符
39 | 	for (int i = 0; i < total; ++i){
40 | 		bfile>>Or[i].ch;
41 | 	}
42 | 	//哈夫曼树节点
43 | 	for (int i = total; i < 2 * total - 1; ++i)//0-n-1为字符
44 | 	{
45 | 		unsigned char p1,p2;
46 | 		bfile>>p1>>p2;
47 | 		HTree[i].lchild = (int)p1;
48 | 		HTree[i].rchild = (int)p2;
49 | 	}
50 | 	//字符数
51 | 	bfile>>count;
52 | 	cout<<"读入成功！"<<endl;
53 | 	cout<<"这篇文章有"<<" "<<count<<" 个字符,共"<<" "<<total<<" 种字符种类数。"<<endl;
54 | 	unsigned char b1;
55 | 	bfile >> b1;
56 | 	int i = 0;
57 | 	int j = 2*total-2;
58 | 	int ccount = 0;
59 | 	while(ccount<count){
60 | 		if (((b1 >> (7 - i)) & 1))
61 | 			j = HTree[j].rchild;
62 | 		else
63 | 			j = HTree[j].lchild;
64 | 		++i;
65 | 		if (j < total)
66 | 		{
67 | 			file << Or[j].ch;
68 | 			ccount++;
69 | 			j = 2 * total - 2;
70 | 		}
71 | 		if (i == 8)
72 | 		{
73 | 			i = 0;
74 | 			bfile>>b1;
75 | 		}
76 | 	}
77 | 	bfile.close();
78 | 	file.close();
79 | 	cout << "解压成功！" << endl;
80 | }


--------------------------------------------------------------------------------
/实验2 树形结构及其应用/代码及报告/Huffman_Char.cpp:
--------------------------------------------------------------------------------
  1 | //基于字符编码
  2 | #include <iostream>
  3 | #include <fstream>
  4 | #include <string>
  5 | #include <string.h>
  6 | #include <sys/stat.h>
  7 | #include <iomanip>
  8 | 
  9 | using namespace std;
 10 | #define ASC 128
 11 | #define m 2*ASC-1//2n-1个节点
 12 | 
 13 | int totalch;//字符种类数
 14 | long long countch;//总字符数
 15 | 
 16 | typedef struct {
 17 | 	double weight;
 18 | 	int lchild;
 19 | 	int rchild;
 20 | 	int parent;
 21 | } HTNode;
 22 | 
 23 | typedef struct {
 24 | 	char ch;//字符
 25 | 	double freq;//字符频率
 26 | 	char code[m];//哈夫曼编码
 27 | } Orchar;
 28 | 
 29 | 
 30 | HTNode HTree[m];
 31 | Orchar Or[ASC];//记录各字符信息
 32 | 
 33 | //分字符读文件，返回总字符数
 34 | long long ReadFile(string &text) {
 35 | 	ifstream file("InputText.txt");
 36 | 	if (!file) {
 37 | 		cout << "Failed To Open The File!" << endl;
 38 | 		return 0;
 39 | 	}
 40 | 	int List[ASC] = {0};//频数
 41 | 	char ch;
 42 | 	long long i = 0;//总字符数
 43 | 	int total = 0;//字符种类数
 44 | 	while (file.get(ch)) {
 45 | 		text += ch;//测试
 46 | 		List[(int)ch]++;
 47 | 		i++;
 48 | 	}
 49 | 	file.close();
 50 | 	int p = 0;
 51 | 	for (int k = 0; k < ASC; ++k) {
 52 | 		if (List[k]) {
 53 | 			total++;
 54 | 			Or[p].ch = k;
 55 | 			Or[p].freq = (double)List[k] / i;
 56 | 			p++;
 57 | 		}
 58 | 	}
 59 | 	totalch = total;//字符种类数
 60 | 	return i;
 61 | }
 62 | //初始化结点值
 63 | void InitHTree() {
 64 | 	for (int i = 0; i < totalch; ++i)
 65 | 		HTree[i].weight = Or[i].freq;
 66 | 	for (int i = 0; i < m; ++i)
 67 | 	{
 68 | 		HTree[i].parent = -1;
 69 | 		HTree[i].lchild = -1;
 70 | 		HTree[i].rchild = -1;
 71 | 	}
 72 | }
 73 | //选取两个最小数
 74 | void SelectMin(int n, int& p1, int& p2) {
 75 | 	int i, j;
 76 | 	for (i = 0; i < n; ++i) {
 77 | 		if (HTree[i].parent == -1) {
 78 | 			p1 = i;
 79 | 			break;
 80 | 		}
 81 | 	}
 82 | 	for (j = i + 1; j < n; ++j) {
 83 | 		if (HTree[j].parent == -1) {
 84 | 			p2 = j;
 85 | 			break;
 86 | 		}
 87 | 	}
 88 | 	for (i = p1; i < n; ++i) {
 89 | 		if ((HTree[p1].weight > HTree[i].weight) && (HTree[i].parent == -1) && (p2 != i))
 90 | 			p1 = i;
 91 | 	}
 92 | 	for (j = p2; j < n; ++j) {
 93 | 		if ((HTree[p2].weight > HTree[j].weight) && (HTree[j].parent == -1) && (p1 != j))
 94 | 			p2 = j;
 95 | 	}
 96 | }
 97 | //创建数
 98 | void CreatHT() {
 99 | 	int i, p1, p2;
100 | 	InitHTree();
101 | 	int n = totalch;
102 | 	for (i = n; i < 2 * n - 1; ++i)//0-n-1为字符
103 | 	{
104 | 		SelectMin(i, p1, p2);
105 | 		HTree[p1].parent = HTree[p2].parent = i;
106 | 		HTree[i].lchild = p1;
107 | 		HTree[i].rchild = p2;
108 | 		HTree[i].weight = HTree[p1].weight + HTree[p2].weight;
109 | 	}
110 | 
111 | }
112 | //编码
113 | void CharSetHuffmanEncoding() {
114 | 	int c, p, i; //cp分别为孩子和双亲的位置
115 | 	char cd[ASC + 1]; //临时存放编码
116 | 	cd[totalch] = '\0';
117 | 	int start;//编码在cd中的位置
118 | 	for (i = 0; i < totalch; ++i) {
119 | 		start = totalch;
120 | 		c = i;
121 | 		while ((p = HTree[c].parent) >= 0) {
122 | 			cd[--start] = (HTree[p].lchild == c) ? '0' : '1'; //左0右1
123 | 			c = p;//上溯
124 | 		}
125 | 		strcpy(Or[i].code, &cd[start]);
126 | 	}
127 | }
128 | //输出二进制文件
129 | void HuffmanConpress() {
130 | 	ifstream file("InputText.txt");
131 | 	char ch;
132 | 	if (!file) {
133 | 		cout << "Failed To Open The Original Text!" << endl;
134 | 	}
135 | 	ofstream bfile;
136 | 	bfile.open("CompressedFile.huffman", ios::binary);
137 | 	if (!bfile) {
138 | 		cout << "Failed To Open The Compressed Text!" << endl;
139 | 	}
140 | 	//解释数据
141 | 	bfile << totalch;
142 | 	for (int i = 0; i < totalch; i++)
143 | 		bfile << Or[i].ch;
144 | 	for (int i = totalch; i < 2 * totalch - 1; ++i)
145 | 		bfile << (unsigned char)HTree[i].lchild << (unsigned char)HTree[i].rchild; //左右结点
146 | 	bfile << countch;
147 | 	int t;//查找
148 | 	unsigned char bin = 0;//1字节
149 | 	int index;
150 | 	int bitindex = 0;
151 | 	while (file.get(ch)) {
152 | 		for (t = 0; t < totalch; t++) {
153 | 			if (Or[t].ch == ch) //查码
154 | 				break;
155 | 		}
156 | 		for (index = 0; Or[t].code[index]; ++index) {
157 | 			if (Or[t].code[index] == '0')
158 | 				bin = bin << 1;
159 | 			else
160 | 				bin = (bin << 1) + 1;
161 | 
162 | 			bitindex++;
163 | 			if (bitindex == 8) {
164 | 				bfile << bin;
165 | 				bitindex = 0;
166 | 				bin = 0;
167 | 			}
168 | 
169 | 		}
170 | 	}
171 | 	if (bitindex) { //最后不足8位
172 | 		bin = bin << (8 - bitindex);
173 | 		bfile << bin << (unsigned char)bitindex;
174 | 	}
175 | 	file.close();
176 | 	bfile.close();
177 | 
178 | }
179 | //输出压缩信息
180 | void CompressInformantion(string text) {
181 | 	double Inbits  = 8 * countch;
182 | 	double Outbits = 0;
183 | 	for (int i = 0; i < countch; i++) {
184 | 		int t;
185 | 		int j;
186 | 		for (t = 0; t < totalch; t++) {
187 | 			if (Or[t].ch == text[i]) //查码
188 | 				break;
189 | 		}
190 | 		for (j = 0; Or[t].code[j]; j++);
191 | 		Outbits += j;
192 | 	}
193 | 	cout << "理论压缩率为：" << (double)Outbits / Inbits * 100 << "%" << endl;
194 | 	struct _stat In, Out;
195 | 	_stat("InputText.txt", &In);
196 | 	_stat("CompressedFile.huffman", &Out);
197 | 	double Inbitst = In.st_size;
198 | 	double Outbitst = Out.st_size;
199 | 	cout << "实际压缩率为：" << (double)Outbitst / Inbitst * 100 << "%" << endl;
200 | }
201 | 
202 | void test1() {
203 | 	string text;//文件读入字符串中
204 | 	countch = ReadFile(text);
205 | 	CreatHT();
206 | 	CharSetHuffmanEncoding();
207 | 	cout<<"--------------------基于字符的压缩--------------------"<<endl;
208 | 	cout << "这篇文章有" << " " << countch << " 个字符,共" << " " << totalch << " 种字符种类数。" << endl;
209 | 	cout << "各字符频率及其对应的哈夫曼编码为：" << endl;
210 | 	for (int i = 0; i < totalch; ++i) {
211 | 		cout << Or[i].ch << ":" << endl;
212 | 		cout << "频率：" << Or[i].freq << "   " << "编码：" << Or[i].code << endl;
213 | 	}
214 | 	HuffmanConpress();
215 | 	cout<<endl;
216 | 	CompressInformantion(text);
217 | 	cout<<"------------------------------------------------"<<endl;
218 | }
219 | 
220 | int main() {
221 | 	test1();
222 | 	return 0;
223 | }
224 | 


--------------------------------------------------------------------------------
/实验2 树形结构及其应用/代码及报告/Huffman_Word.cpp:
--------------------------------------------------------------------------------
  1 | //基于单词编码
  2 | //堆优化
  3 | #include <iostream>
  4 | #include <fstream>
  5 | #include <string>
  6 | #include <string.h>
  7 | #include <sys/stat.h>
  8 | #include <iomanip>
  9 | using namespace std;
 10 | 
 11 | #define MaxWord 10000//最大单词种类数
 12 | #define mw 2*MaxWord-1
 13 | 
 14 | int totalword;//单词种类数
 15 | long long countword;//总单词数
 16 | 
 17 | typedef struct {
 18 | 	double weight;
 19 | 	int lchild;
 20 | 	int rchild;
 21 | 	int parent;
 22 | } HTNode;
 23 | 
 24 | typedef struct {
 25 | 	string word;//单词
 26 | 	double freq;//单词频率
 27 | 	char code[MaxWord];//哈夫曼编码
 28 | } Orword;
 29 | 
 30 | HTNode HTreew[mw];
 31 | Orword Ow[MaxWord];
 32 | 
 33 | //堆结构
 34 | //最小堆
 35 | typedef struct {
 36 | 	int num;//与Orword对应
 37 | 	double weight;
 38 | } ElemType;
 39 | typedef struct{
 40 | 	ElemType data[mw];
 41 | 	int n;
 42 | }heap;
 43 | //堆功能
 44 | void InitHeap(heap& heap);//初始化
 45 | bool isHeapEmpty(heap heap);//判空
 46 | bool HeapFull(heap heap);//判满
 47 | void HeapInsert(heap& heap, ElemType m);//插入
 48 | ElemType HeapDeleteMin(heap& heap, int&num);//删除最小
 49 | 
 50 | void Initheap(heap& heap){
 51 | 	heap.n = 0;
 52 | }
 53 | bool isHeapEmpty(heap heap){
 54 | 	return (!heap.n);
 55 | }
 56 | bool HeapFull(heap heap){
 57 | 	return (heap.n == MaxWord - 1);
 58 | }
 59 | 
 60 | void HeapInsert(heap& heap, ElemType m){
 61 | 	int i;
 62 | 	if (!HeapFull(heap))
 63 | 	{
 64 | 		i = ++heap.n;
 65 | 		while ((i != 1) && (m.weight < heap.data[i / 2].weight))
 66 | 		{
 67 | 			heap.data[i] = heap.data[i / 2];
 68 | 			i /= 2;
 69 | 		}
 70 | 	}
 71 | 	heap.data[i].num = m.num;
 72 | 	heap.data[i].weight = m.weight;
 73 | }
 74 | ElemType HeapDeleteMin(heap& heap){
 75 | 	int parent = 1, child = 2;
 76 | 	ElemType tmp,elem;
 77 | 	if (!isHeapEmpty(heap))
 78 | 	{
 79 | 		elem = heap.data[1];
 80 | 		tmp = heap.data[heap.n--];
 81 | 		while (child <= heap.n)
 82 | 		{
 83 | 			if ((child < heap.n) && (heap.data[child].weight > heap.data[child + 1].weight))
 84 | 				++child;
 85 | 			if (tmp.weight <= heap.data[child].weight)
 86 | 				break;
 87 | 			heap.data[parent] = heap.data[child];
 88 | 			parent = child;
 89 | 			child *= 2;
 90 | 		}
 91 | 	}
 92 | 	heap.data[parent] = tmp;
 93 | 	return elem;
 94 | }
 95 | void CreatHeap(heap& heap){
 96 | 	Initheap(heap);
 97 | 	for(int i = 0;i<totalword;i++){
 98 | 		ElemType m;
 99 | 		m.num = i;
100 | 		m.weight = Ow[i].freq;
101 | 		HeapInsert(heap,m);
102 | 	}
103 | }
104 | 
105 | //单词操作，返回总单词数
106 | long long ReadFileWord() {
107 | 	string t;//将文本保存到字符串
108 | 	string w;//读取单词
109 | 	ifstream file("InputText.txt");
110 | 	if (!file) {
111 | 		cout << "Failed To Open The File!" << endl;
112 | 		return 0;
113 | 	}
114 | 	long long j = 0;//总字符与单词数
115 | 	char ch;
116 | 	while (file.get(ch)) {
117 | 		t += ch;
118 | 	}
119 | 	w = "";
120 | 	int i = 0;
121 | 	while (t[i]) {
122 | 		w = "";
123 | 		if (t[i] >= 'A' && t[i] <= 'z') {//如果这个字符为字母，开始记录
124 | 			while (t[i] >= 'A' && t[i] <= 'z') {
125 | 				w = w + t[i];
126 | 				i++;
127 | 			}
128 | 			j++;
129 | 		}
130 | 		else {
131 | 			w = t[i];//标点，直接记录
132 | 			i++;
133 | 			j++;
134 | 		}
135 | 		int index = 0;
136 | 		int flag = 0;
137 | 		while (Ow[index].word != "") {
138 | 			if (Ow[index].word == w) {
139 | 				Ow[index].freq++;//freq在这里为频数
140 | 				flag = 1;
141 | 				break;
142 | 			}
143 | 			else {
144 | 				index++;
145 | 			}
146 | 		}
147 | 		if (flag == 0) {
148 | 			totalword++;
149 | 			Ow[index].word = w;
150 | 			Ow[index].freq++;
151 | 		}
152 | 	}
153 | 	file.close();
154 | 	return j;
155 | }
156 | //利用堆找两个最小值
157 | void SelectMinword(heap& heap,int& p1, int& p2) {
158 | 	p1 = HeapDeleteMin(heap).num;
159 | 	p2 = HeapDeleteMin(heap).num;
160 | }
161 | // void SelectMinword(int n, int& p1, int& p2) {
162 | // 	int i, j;
163 | // 	for (i = 0; i < n; ++i) {
164 | // 		if (HTreew[i].parent == -1) {
165 | // 			p1 = i;
166 | // 			break;
167 | // 		}
168 | // 	}
169 | // 	for (j = i + 1; j < n; ++j) {
170 | // 		if (HTreew[j].parent == -1) {
171 | // 			p2 = j;
172 | // 			break;
173 | // 		}
174 | // 	}
175 | // 	for (i = p1; i < n; ++i) {
176 | // 		if ((HTreew[p1].weight > HTreew[i].weight) && (HTreew[i].parent == -1) && (p2 != i))
177 | // 			p1 = i;
178 | // 	}
179 | // 	for (j = p2; j < n; ++j) {
180 | // 		if ((HTreew[p2].weight > HTreew[j].weight) && (HTreew[j].parent == -1) && (p1 != j))
181 | // 			p2 = j;
182 | // 	}
183 | // }
184 | 
185 | //初始化结点值
186 | void InitHTreeword() {
187 | 	for (int i = 0; i < totalword; ++i)
188 | 		HTreew[i].weight = Ow[i].freq;
189 | 	for (int i = 0; i < mw; ++i)
190 | 	{
191 | 		HTreew[i].parent = -1;
192 | 		HTreew[i].lchild = -1;
193 | 		HTreew[i].rchild = -1;
194 | 	}
195 | }
196 | //创建树
197 | void CreatHTword() {
198 | 	int i, p1, p2;
199 | 	InitHTreeword();
200 | 	heap heap;
201 | 	CreatHeap(heap);
202 | 	int n = totalword;
203 | 	for (i = n; i < 2 * n - 1; ++i)//0-n-1为字符
204 | 	{
205 | 		SelectMinword(heap,p1, p2);
206 | 		HTreew[p1].parent = HTreew[p2].parent = i;
207 | 		HTreew[i].lchild = p1;
208 | 		HTreew[i].rchild = p2;
209 | 		HTreew[i].weight = HTreew[p1].weight + HTreew[p2].weight;
210 | 		ElemType m;
211 | 		m.num = i;
212 | 		m.weight = HTreew[i].weight;
213 | 		HeapInsert(heap,m);
214 | 	}
215 | }
216 | //编码
217 | void WordSetHuffmanEncoding() {
218 | 	int c, p, i; //cp分别为孩子和双亲的位置
219 | 	char cd[MaxWord + 1]; //临时存放编码
220 | 	cd[totalword] = '\0';
221 | 	int start;//编码在cd中的位置
222 | 	for (i = 0; i < totalword; ++i) {
223 | 		start = totalword;
224 | 		c = i;
225 | 		while ((p = HTreew[c].parent) >= 0) {
226 | 			cd[--start] = (HTreew[p].lchild == c) ? '0' : '1'; //左0右1
227 | 			c = p;//上溯
228 | 		}
229 | 		strcpy(Ow[i].code, &cd[start]);
230 | 	}
231 | }
232 | //计算频率
233 | void ConvertFreq(){
234 | 	for(int i = 0;Ow[i].word!="";i++){
235 | 		Ow[i].freq = (double)Ow[i].freq/countword;
236 | 	}
237 | }
238 | void wordHuffmanConpress(){
239 | 	ifstream file("InputText.txt");
240 | 	char ch;
241 | 	if (!file) {
242 | 		cout << "Failed To Open The Original Text!" << endl;
243 | 	}
244 | 	ofstream bfile;
245 | 	bfile.open("CompressedFile.huffman", ios::binary);
246 | 	if (!bfile) {
247 | 		cout << "Failed To Open The Compressed Text!" << endl;
248 | 	}
249 | 	//无解释数据
250 | 	int t;//查找
251 | 	unsigned char bin = 0;//1字节
252 | 	int index;
253 | 	int bitindex = 0;
254 | 	string s;
255 | 	while (file.get(ch)) {
256 | 		s += ch;
257 | 	}
258 | 	string w = "";
259 | 	int i = 0;
260 | 	while (s[i]) {
261 | 		w = "";
262 | 		if (s[i] >= 'A' && s[i] <= 'z') {//如果这个字符为字母，开始记录
263 | 			while (s[i] >= 'A' && s[i] <= 'z') {
264 | 				w = w + s[i];
265 | 				i++;
266 | 			}
267 | 		}
268 | 		else {
269 | 			w = s[i];//标点，直接记录
270 | 			i++;
271 | 		}
272 | 		for (t = 0; t < totalword; t++) {
273 | 			if (Ow[t].word == w) //查码
274 | 				break;
275 | 		}
276 | 		for (index = 0; Ow[t].code[index]; ++index) {
277 | 			if (Ow[t].code[index] == '0')
278 | 				bin = bin << 1;
279 | 			else
280 | 				bin = (bin << 1) + 1;
281 | 
282 | 			bitindex++;
283 | 			if (bitindex == 8) {
284 | 				bfile << bin;
285 | 				bitindex = 0;
286 | 				bin = 0;
287 | 			}
288 | 
289 | 		}
290 | 	}
291 | 	if (bitindex) { //最后不足8位
292 | 		bin = bin << (8 - bitindex);
293 | 		bfile << bin << (unsigned char)bitindex;
294 | 	}
295 | 	file.close();
296 | 	bfile.close();
297 | }
298 | void CompressInformantionword(){
299 | 	struct _stat In, Out;
300 | 	_stat("InputText.txt", &In);
301 | 	_stat("CompressedFile.huffman", &Out);
302 | 	double Inbitst = In.st_size;
303 | 	double Outbitst = Out.st_size;
304 | 	cout << "实际压缩率为：" << (double)Outbitst / Inbitst * 100 << "%" << endl;
305 | }
306 | void test2() {
307 | 	countword = ReadFileWord();
308 | 	ConvertFreq();
309 | 	CreatHTword();
310 | 	WordSetHuffmanEncoding();
311 | 	cout<<"--------------------基于单词的压缩--------------------"<<endl;
312 | 	cout << "这篇文章有" << " " << countword << " 个单词(含标点),共" << " " << totalword << " 种单词(含标点)种类数。" << endl;
313 | 	cout << "各单词(含标点)频率及其对应的哈夫曼编码为：" << endl;
314 | 	for (int i = 0; i < totalword; ++i) {
315 | 		cout << Ow[i].word << ":" << endl;
316 | 		cout << "频率：" << Ow[i].freq << "   " << "编码：" << Ow[i].code << endl;
317 | 	}
318 | 	wordHuffmanConpress();
319 | 	cout<<endl;
320 | 	CompressInformantionword();
321 | 	cout<<"------------------------------------------------"<<endl;
322 | 	//测试
323 | 	// double sum = 0;
324 | 	// for(int i = 0;Ow[i].word!="";i++){
325 | 	// 	cout<<Ow[i].word<<":"<<Ow[i].freq<<endl;
326 | 	// 	sum +=Ow[i].freq;
327 | 	// }
328 | 	// cout<<sum;
329 | }
330 | void DeCompressWord(){
331 | 	ifstream bfile("CompressedFile.huffman",ios::binary);
332 | 	ofstream file("OutputText.txt");
333 | 	if(!bfile){
334 | 		cout<<"Failed To Open The Compressed File!"<<endl;
335 | 		return;
336 | 	}
337 | 	bfile>>noskipws;//设置读取空白符
338 | 	unsigned char b1;
339 | 	bfile >> b1;
340 | 	int i = 0;
341 | 	int j = 2*totalword-2;
342 | 	int ccount = 0;
343 | 	while(ccount<countword){
344 | 		if (((b1 >> (7 - i)) & 1))
345 | 			j = HTreew[j].rchild;
346 | 		else
347 | 			j = HTreew[j].lchild;
348 | 		++i;
349 | 		if (j < totalword)
350 | 		{
351 | 			file << Ow[j].word;
352 | 			ccount++;
353 | 			j = 2 * totalword - 2;
354 | 		}
355 | 		if (i == 8)
356 | 		{
357 | 			i = 0;
358 | 			bfile>>b1;
359 | 		}
360 | 	}
361 | 	bfile.close();
362 | 	file.close();
363 | 	cout << "解压成功！" << endl;
364 | }
365 | int main() {
366 | 	test2();
367 | 	DeCompressWord();
368 | 	return 0;
369 | }
370 | 


--------------------------------------------------------------------------------
/实验2 树形结构及其应用/代码及报告/InputText.txt:
--------------------------------------------------------------------------------
 1 | Assistant director Dave Halls did not know the prop contained live ammunition and indicated it was unloaded by shouting "cold gun!", the records say.
 2 | 
 3 | Cinematographer Halyna Hutchins was fatally shot in the chest in Thursday's incident on the set of the film Rust.
 4 | 
 5 | Director Joel Souza, who was standing behind her, was wounded.
 6 | 
 7 | The 48-year-old received emergency treatment for a shoulder injury and was later released from hospital.
 8 | 
 9 | I have a dream
10 | I am happy to join with you today in what will go down in history as the greatest demonstration for freedom in the history of our nation. 
11 | 
12 | Five score years ago, a great American, in whose symbolic shadow we stand today, signed the Emancipation Proclamation. This momentous decree came as a great beacon light of hope to millions of Negro slaves who had been seared in the flames of withering injustice. It came as a joyous daybreak to end the long night of bad captivity. 
13 | But one hundred years later, the Negro still is not free. One hundred years later, the life of the Negro is still sadly crippled by the manacles of segregation and the chains of discrimination. 
14 | 
15 | Further details of the police investigation were released on Friday when a search warrant was filed at a court in Santa Fe, New Mexico.
16 | 
17 | It noted that Baldwin's blood-stained outfit was taken as evidence along with the gun. Ammunition and other prop weapons were also taken from the set by police.
18 | 
19 | The 63-year-old actor was questioned by law enforcement, but no-one has been charged over the incident.
20 | 
21 | Earlier on Friday, Baldwin - who was the star and producer of the film - said he was "fully co-operating" with the Santa Fe County Sheriff's Office.
22 | 
23 | "My heart is broken for her husband, their son, and all who knew and loved Halyna," he wrote on Twitter.
24 | 
25 | "There are no words to convey my shock and sadness regarding the tragic accident that took the life of Halyna Hutchins, a wife, mother and deeply admired colleague of ours."
26 | 
27 | Ms Hutchins, 42, was from Ukraine and grew up on a Soviet military base in the Arctic Circle. She studied journalism in Kyiv, and film in Los Angeles, and was named a "rising star" by the American Cinematographer magazine in 2019.
28 | 
29 | She was the director of photography for the 2020 action film Archenemy, directed by Adam Egypt Mortimer.
30 | 
31 | According to the Los Angeles Times, about half a dozen members of the camera crew on Rust walked out hours before the tragedy after protesting over working conditions on the set at the Bonanza Creek Ranch near Santa Fe.
32 | 
33 | The union members had reportedly complained that they were promised hotel rooms in Santa Fe, but once filming of the Western began they were required to drive 50 miles (80km) from Albuquerque every morning.
34 | 


--------------------------------------------------------------------------------
/实验2 树形结构及其应用/代码及报告/K_Huffman.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验2 树形结构及其应用/代码及报告/K_Huffman.cpp


--------------------------------------------------------------------------------
/实验2 树形结构及其应用/代码及报告/OutputText.txt:
--------------------------------------------------------------------------------
 1 | Assistant director Dave Halls did not know the prop contained live ammunition and indicated it was unloaded by shouting "cold gun!", the records say.
 2 | 
 3 | Cinematographer Halyna Hutchins was fatally shot in the chest in Thursday's incident on the set of the film Rust.
 4 | 
 5 | Director Joel Souza, who was standing behind her, was wounded.
 6 | 
 7 | The 48-year-old received emergency treatment for a shoulder injury and was later released from hospital.
 8 | 
 9 | I have a dream
10 | I am happy to join with you today in what will go down in history as the greatest demonstration for freedom in the history of our nation. 
11 | 
12 | Five score years ago, a great American, in whose symbolic shadow we stand today, signed the Emancipation Proclamation. This momentous decree came as a great beacon light of hope to millions of Negro slaves who had been seared in the flames of withering injustice. It came as a joyous daybreak to end the long night of bad captivity. 
13 | But one hundred years later, the Negro still is not free. One hundred years later, the life of the Negro is still sadly crippled by the manacles of segregation and the chains of discrimination. 
14 | 
15 | Further details of the police investigation were released on Friday when a search warrant was filed at a court in Santa Fe, New Mexico.
16 | 
17 | It noted that Baldwin's blood-stained outfit was taken as evidence along with the gun. Ammunition and other prop weapons were also taken from the set by police.
18 | 
19 | The 63-year-old actor was questioned by law enforcement, but no-one has been charged over the incident.
20 | 
21 | Earlier on Friday, Baldwin - who was the star and producer of the film - said he was "fully co-operating" with the Santa Fe County Sheriff's Office.
22 | 
23 | "My heart is broken for her husband, their son, and all who knew and loved Halyna," he wrote on Twitter.
24 | 
25 | "There are no words to convey my shock and sadness regarding the tragic accident that took the life of Halyna Hutchins, a wife, mother and deeply admired colleague of ours."
26 | 
27 | Ms Hutchins, 42, was from Ukraine and grew up on a Soviet military base in the Arctic Circle. She studied journalism in Kyiv, and film in Los Angeles, and was named a "rising star" by the American Cinematographer magazine in 2019.
28 | 
29 | She was the director of photography for the 2020 action film Archenemy, directed by Adam Egypt Mortimer.
30 | 
31 | According to the Los Angeles Times, about half a dozen members of the camera crew on Rust walked out hours before the tragedy after protesting over working conditions on the set at the Bonanza Creek Ranch near Santa Fe.
32 | 
33 | The union members had reportedly complained that they were promised hotel rooms in Santa Fe, but once filming of the Western began they were required to drive 50 miles (80km) from Albuquerque every morning.
34 | 


--------------------------------------------------------------------------------
/实验2 树形结构及其应用/代码及报告/test.in:
--------------------------------------------------------------------------------
1 | QAQAQYSYIOIWIN


--------------------------------------------------------------------------------
/实验2 树形结构及其应用/代码及报告/实验报告.doc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验2 树形结构及其应用/代码及报告/实验报告.doc


--------------------------------------------------------------------------------
/实验2 树形结构及其应用/代码及报告/测试数据和结果数据.docx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验2 树形结构及其应用/代码及报告/测试数据和结果数据.docx


--------------------------------------------------------------------------------
/实验2 树形结构及其应用/代码及报告/测试文本集.txt:
--------------------------------------------------------------------------------
 1 | Assistant director Dave Halls did not know the prop contained live ammunition and indicated it was unloaded by shouting "cold gun!", the records say.
 2 | 
 3 | Cinematographer Halyna Hutchins was fatally shot in the chest in Thursday's incident on the set of the film Rust.
 4 | 
 5 | Director Joel Souza, who was standing behind her, was wounded.
 6 | 
 7 | The 48-year-old received emergency treatment for a shoulder injury and was later released from hospital.
 8 | 
 9 | I have a dream
10 | I am happy to join with you today in what will go down in history as the greatest demonstration for freedom in the history of our nation. 
11 | 
12 | Five score years ago, a great American, in whose symbolic shadow we stand today, signed the Emancipation Proclamation. This momentous decree came as a great beacon light of hope to millions of Negro slaves who had been seared in the flames of withering injustice. It came as a joyous daybreak to end the long night of bad captivity. 
13 | But one hundred years later, the Negro still is not free. One hundred years later, the life of the Negro is still sadly crippled by the manacles of segregation and the chains of discrimination. 
14 | 
15 | Further details of the police investigation were released on Friday when a search warrant was filed at a court in Santa Fe, New Mexico.
16 | 
17 | It noted that Baldwin's blood-stained outfit was taken as evidence along with the gun. Ammunition and other prop weapons were also taken from the set by police.
18 | 
19 | The 63-year-old actor was questioned by law enforcement, but no-one has been charged over the incident.
20 | 
21 | Earlier on Friday, Baldwin - who was the star and producer of the film - said he was "fully co-operating" with the Santa Fe County Sheriff's Office.
22 | 
23 | "My heart is broken for her husband, their son, and all who knew and loved Halyna," he wrote on Twitter.
24 | 
25 | "There are no words to convey my shock and sadness regarding the tragic accident that took the life of Halyna Hutchins, a wife, mother and deeply admired colleague of ours."
26 | 
27 | Ms Hutchins, 42, was from Ukraine and grew up on a Soviet military base in the Arctic Circle. She studied journalism in Kyiv, and film in Los Angeles, and was named a "rising star" by the American Cinematographer magazine in 2019.
28 | 
29 | She was the director of photography for the 2020 action film Archenemy, directed by Adam Egypt Mortimer.
30 | 
31 | According to the Los Angeles Times, about half a dozen members of the camera crew on Rust walked out hours before the tragedy after protesting over working conditions on the set at the Bonanza Creek Ranch near Santa Fe.
32 | 
33 | The union members had reportedly complained that they were promised hotel rooms in Santa Fe, but once filming of the Western began they were required to drive 50 miles (80km) from Albuquerque every morning.
34 | 
35 | I am happy to join with you today in what will go down in history as the greatest demonstration for freedom in the history of our nation. Five score years ago, a great American, in whose symbolic shadow we stand today, signed the Emancipation Proclamation. This momentous decree came as a great beacon light of hope to millions of Negro slaves who had been seared in the flames of withering injustice. It came as a joyous daybreak to end the long night of bad captivity. But one hundred years later, the Negro still is not free. One hundred years later, the life of the Negro is still sadly crippled by the manacles of segregation and the chains of discrimination. One hundred years later, the Negro lives on a lonely island of poverty in the midst of a vast ocean of material prosperity. One hundred years later, the Negro is still languished in the corners of American society and finds himself an exile in his own land. And so we've come here today to dramatize a shameful condition. In a sense we've come to our nation's capital to cash a check. When the architects of our republic wrote the magnificent words of the Constitution and the Declaration of Independence, they were signing a promissory note to which every American was to fall heir. This note was a promise that all men, yes, black men as well as white men, would be guaranteed the "unalienable Rights" of "Life, Liberty and the pursuit of Happiness." It is obvious today that America has defaulted on this promissory note, insofar as her citizens of color are concerned. Instead of honoring this sacred obligation, America has given the Negro people a bad check, a check which has come back marked "insufficient funds." But we refuse to believe that the bank of justice is bankrupt. We refuse to believe that there are insufficient funds in the great vaults of opportunity of this nation. And so, we've come to cash this check, a check that will give us upon demand the riches of freedom and the security of justice. We have also come to this hallowed spot to remind America of the fierce urgency of Now. This is no time to engage in the luxury of cooling off or to take the tranquilizing drug of gradualism. Now is the time to make real the promises of democracy. Now is the time to rise from the dark and desolate valley of segregation to the sunlit path of racial justice. Now is the time to lift our nation from the quicksands of racial injustice to the solid rock of brotherhood. Now is the time to make justice a reality for all of God's children. It would be fatal for the nation to overlook the urgency of the moment. This sweltering summer of the Negro's legitimate discontent will not pass until there is an invigorating autumn of freedom and equality. Nineteen sixty-three is not an end, but a beginning. And those who hope that the Negro needed to blow off steam and will now be content will have a rude awakening if the nation returns to business as usual. And there will be neither rest nor tranquility in America until the Negro is granted his citizenship rights. The whirlwinds of revolt will continue to shake the foundations of our nation until the bright day of justice emerges. But there is something that I must say to my people, who stand on the warm threshold which leads into the palace of justice: In the process of gaining our rightful place, we must not be guilty of wrongful deeds. Let us not seek to satisfy our thirst for freedom by drinking from the cup of bitterness and hatred. We must forever conduct our struggle on the high plane of dignity and discipline. We must not allow our creative protest to degenerate into physical violence. Again and again, we must rise to the majestic heights of meeting physical force with soul force. The marvelous new militancy which has engulfed the Negro community must not lead us to a distrust of all white people, for many of our white brothers, as evidenced by their presence here today, have come to realize that their destiny is tied up with our destiny. And they have come to realize that their freedom is inextricably bound to our freedom. We cannot walk alone. And as we walk, we must make the pledge that we shall always march ahead. We cannot turn back. There are those who are asking the devotees of civil rights, "When will you be satisfied?" We can never be satisfied as long as the Negro is the victim of the unspeakable horrors of police brutality. We can never be satisfied as long as our bodies, heavy with the fatigue of travel, cannot gain lodging in the motels of the highways and the hotels of the cities. We cannot be satisfied as long as the Negro's basic mobility is from a smaller ghetto to a larger one. We can never be satisfied as long as our children are stripped of their selfhood and robbed of their dignity by signs stating "for whites only." We cannot be satisfied as long as a Negro in Mississippi cannot vote and a Negro in New York believes he has nothing for which to vote. No, no, we are not satisfied, and we will not be satisfied until "justice rolls down like waters, and righteousness like a mighty stream." I am not unmindful that some of you have come here out of great trials and tribulations. Some of you have come fresh from narrow jail cells. And some of you have come from areas where your quest -- quest for freedom left you battered by the storms of persecution and staggered by the winds of police brutality. You have been the veterans of creative suffering. Continue to work with the faith that unearned suffering is redemptive. Go back to Mississippi, go back to Alabama, go back to South Carolina, go back to Georgia, go back to Louisiana, go back to the slums and ghettos of our northern cities, knowing that somehow this situation can and will be changed. Let us not wallow in the valley of despair, I say to you today, my friends. And so even though we face the difficulties of today and tomorrow, I still have a dream. It is a dream deeply rooted in the American dream. I have a dream that one day this nation will rise up and live out the true meaning of its creed: "We hold these truths to be self-evident, that all men are created equal." I have a dream that one day on the red hills of Georgia, the sons of former slaves and the sons of former slave owners will be able to sit down together at the table of brotherhood. I have a dream that one day even the state of Mississippi, a state sweltering with the heat of injustice, sweltering with the heat of oppression, will be transformed into an oasis of freedom and justice. I have a dream that my four little children will one day live in a nation where they will not be judged by the color of their skin but by the content of their character. I have a dream today! I have a dream that one day, down in Alabama, with its vicious racists, with its governor having his lips dripping with the words of "interposition" and "nullification" -- one day right there in Alabama little black boys and black girls will be able to join hands with little white boys and white girls as sisters and brothers. I have a dream today! I have a dream that one day every valley shall be exalted, and every hill and mountain shall be made low, the rough places will be made plain, and the crooked places will be made straight; "and the glory of the Lord shall be revealed and all flesh shall see it together." This is our hope, and this is the faith that I go back to the South with. With this faith, we will be able to hew out of the mountain of despair a stone of hope. With this faith, we will be able to transform the jangling discords of our nation into a beautiful symphony of brotherhood. With this faith, we will be able to work together, to pray together, to struggle together, to go to jail together, to stand up for freedom together, knowing that we will be free one day. And this will be the day -- this will be the day when all of God's children will be able to sing with new meaning: My country 'tis of thee, sweet land of liberty, of thee I sing. Land where my fathers died, land of the Pilgrim's pride, From every mountainside, let freedom ring! And if America is to be a great nation, this must become true. And so let freedom ring from the prodigious hilltops of New Hampshire. Let freedom ring from the mighty mountains of New York. Let freedom ring from the heightening Alleghenies of Pennsylvania. Let freedom ring from the snow-capped Rockies of Colorado. Let freedom ring from the curvaceous slopes of California. But not only that: Let freedom ring from Stone Mountain of Georgia. Let freedom ring from Lookout Mountain of Tennessee. Let freedom ring from every hill and molehill of Mississippi. From every mountainside, let freedom ring. And when this happens, when we allow freedom ring, when we let it ring from every village and every hamlet, from every state and every city, we will be able to speed up that day when all of God's children, black men and white men, Jews and Gentiles, Protestants and Catholics, will be able to join hands and sing in the words of the old Negro spiritual: Free at last! Free at last! Thank God Almighty, we are free at last!
36 | 
37 | Meanwhile, the BBC has obtained a document showing which crew members were listed as scheduled to be on set that day.
38 | 
39 | It names a head armourer, the crew member responsible for checking firearms. Hannah Gutierrez Reed is in her twenties and, according to the LA Times, had recently worked in this role for the first time.
40 | 
41 | It is one of the dirtiest countries per head of population and a massive global supplier of fossil fuels. Unusually for a rich nation, it also still burns coal for most of its electricity.
42 | 
43 | Australia's 2030 emissions target - a 26% cut on 2005 levels - is half the US and UK benchmarks.
44 | 
45 | Canberra has also resisted joining the two-thirds of countries who have pledged net zero emissions by 2050.
46 | 
47 | And instead of phasing out coal - the worst fossil fuel - it's committed to digging for more.
48 | 
49 | So it's no surprise that Australia is being viewed as a "bad guy" going into the COP26 global climate talks in Glasgow, analysts say.
50 | 
51 | Prime Minister Scott Morrison's government is under huge pressure to do more.
52 | 
53 | Mining has helped drive Australia's economy for decades, and coal remains the country's second-biggest export.
54 | 
55 | Only Indonesia sells more coal than Australia globally.
56 | 
57 | The government often credits coal for much of the country's wealth, but many analysts argue this is overblown.
58 | 
59 | Coal exports totalled A$55bn (29bn; $40bn) last year, but most of this wealth was kept by mining companies. Less than a tenth went to Australia directly - that's about 1% of national revenue.
60 | 
61 | The coal workforce of 40,000 is about half the size of McDonald's in Australia. But coal jobs do sustain some rural communities.


--------------------------------------------------------------------------------
/实验2 树形结构及其应用/实验2 树形结构及其应用.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验2 树形结构及其应用/实验2 树形结构及其应用.pdf


--------------------------------------------------------------------------------
/实验3 图形结构及其应用/代码及报告/Graph.txt:
--------------------------------------------------------------------------------
 1 | 11 22
 2 | 0 1 2 3 4 5 6 7 8 9 10
 3 | 0 1 2
 4 | 0 2 5
 5 | 1 0 3
 6 | 1 2 1
 7 | 1 3 3
 8 | 2 3 3
 9 | 2 4 4
10 | 3 4 1
11 | 3 5 7
12 | 3 6 4
13 | 4 5 1
14 | 4 7 4
15 | 4 8 6
16 | 5 1 10
17 | 5 9 2
18 | 6 5 2
19 | 6 9 1
20 | 7 8 1
21 | 7 9 2
22 | 8 5 7
23 | 9 8 1
24 | 10 8 3


--------------------------------------------------------------------------------
/实验3 图形结构及其应用/代码及报告/实验报告.doc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验3 图形结构及其应用/代码及报告/实验报告.doc


--------------------------------------------------------------------------------
/实验3 图形结构及其应用/代码及报告/最短路径算法.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验3 图形结构及其应用/代码及报告/最短路径算法.cpp


--------------------------------------------------------------------------------
/实验3 图形结构及其应用/代码及报告/测试数据与结果数据.docx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验3 图形结构及其应用/代码及报告/测试数据与结果数据.docx


--------------------------------------------------------------------------------
/实验3 图形结构及其应用/代码及报告/测试数据图.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验3 图形结构及其应用/代码及报告/测试数据图.jpg


--------------------------------------------------------------------------------
/实验3 图形结构及其应用/实验3 图型结构及其应用.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kcxain/HIT-Data-Structure/b808d64628b33cb5b59d6a622fd3537fa2b4ac62/实验3 图形结构及其应用/实验3 图型结构及其应用.pdf


--------------------------------------------------------------------------------