01：请实现选择排序，并分析它的时间复杂度，空间复杂度和稳定性

void selection_sort(int arr[], int n);

解答：

稳定性：稳定，   不稳定的，会发生长距离的交换  4         9 9 4 1    ，把第一个4换掉了

时间复杂度：比较（n-1）+(n-1)+(n-3)+……+1=n*(n/2)=O(n^2)

交换：最好情况，不交换，最坏情况O(n^2)==比较

一般情况：O(n^2)

空间复杂度：O(1)

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define SIZE(a) (sizeof(a)/sizeof(a[0]))void selection_sort(int arr[], int n) {int max;for (int i = 0; i < n-1; i++) {//和后面的LEN-1个比较max = i;for (int j = i + 1; j < n; j++) {//max=arr[j]   arr[i]<arr[j]  swapif (arr[max] < arr[j]) {     //相等的元素不发生交换，稳定max = j;}}//swap(arr[i], arr[max]);int temp = arr[i];arr[i] = arr[max];arr[max] = temp;}
}
void print_arr(int arr[], int n) {for (int i = 0; i < n; i++) {printf("%d  ", arr[i]);}printf("\n");
}int main(void) {int arr[] = { 2,34,12,12,34,56,78,90,899,100 };print_arr(arr, SIZE(arr));selection_sort(arr, SIZE(arr));print_arr(arr, SIZE(arr));return 0;
}

答案：

#define SWAP(arr, i, j) {	\int tmp = arr[i];		\arr[i] = arr[j];		\arr[j] = tmp;			\
}void selection_sort(int arr[], int n) {for (int i = 0; i < n - 1; i++) {int minIdx = i;// 找到最小元素的索引for (int j = i + 1; j < n; j++) {if (arr[j] < arr[minIdx]) {minIdx = j;}}// 交换arr[i]和arr[j]SWAP(arr, i, minIdx);// print_array(arr, n);}
}分析：
1. 时间复杂度：O(n^2)比较次数: (n-1) + (n-2) + ... + 1 = n(n-1)/2交换次数：n-1
2. 空间复杂度：O(1)不需要申请而外的数组
3. 稳定性: 不稳定会发生长距离的交换

02：请实现冒泡排序，并分析它的时间复杂度，空间复杂度和稳定性

void bubble_sort(int arr[], int n);

解答：

稳定性：稳定，

时间复杂度：比较（n-1）+(n-1)+(n-3)+……+1=n*(n/2)=O(n^2)

交换：最好情况，不交换，最坏情况O(n^2)==比较

一般情况：O(n^2)

空间复杂度：O(1)

void bubble_sort(int arr[], int n) {for (int i = 0; i < n - 1; i++) {for (int j = i + 1; j < n; j++) {     //相等的元素不发生交换，稳定//如果 arr[i]<arr[j]  swapif (arr[i] < arr[j]) {int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}}
}

答案：

void bubble_sort(int arr[], int n) {for (int i = 1; i < n; i++) { // i表示第几次冒泡bool isSorted = true;  // 比较arr[j]和arr[j+1]for (int j = 0; j < n - i; j++) {if (arr[j] > arr[j + 1]) {SWAP(arr, j, j + 1);isSorted = false;	// 发生交换，说明数组还未排好序}}if (isSorted) break;}
}
分析：1. 时间复杂度：最好情况：原数组有序, O(n)比较次数：n-1交换次数：0最坏情况：原数组逆序, O(n^2)比较次数：(n-1) + (n-2) + ... + 1交换次数：(n-1) + (n-2) + ... + 1平均情况：O(n^2) (和插入排序的分析方法一致)比较次数：大于等于交换的次数，小于等于 n(n-1)/2交换次数：n(n-1)/4 (等于逆序度)2. 空间复杂度：O(1)不需要申请额外的数组3. 稳定性：稳定交换的是相邻两个元素，而且只交换逆序对。

03：请实现插入排序，并分析它的时间复杂度，空间复杂度和稳定性

void insertion_sort(int arr[], int n);

解答：

稳定性：稳定，

时间复杂度：比较（n-1）

交换：最好情况，不交换，最坏情况+(n-1)+(n-3)+……+1=n*(n/2)=O(n^2)

一般情况：O(n^2)

空间复杂度：O(1)

void insertion_sort(int arr[], int n) {//第一个元素看作有序数列，从第二个元素开始插入for (int i = 1; i < n; i++) {//保留要插入的值int val = arr[i];int j = i - 1;while (j >= 0 && arr[j] > val) {  //遇到相等的元素，插在后面，不进入循环arr[j + 1] = arr[j];j--;}//arr[j]<=val||j==-1arr[j + 1] = val;}
}

答案：

void insertion_sort(int arr[], int n) {for (int i = 1; i < n; i++) { // i:待插入元素的索引// 保存待插入的元素int value = arr[i];int j = i - 1;while (j >= 0 && arr[j] > value) {arr[j + 1] = arr[j]; // 逻辑上的交换操作j--;}// j == -1 || arr[j] <= valuearr[j + 1] = value;}
}

04：请实现归并排序，并分析它的时间复杂度，空间复杂度和稳定性

void merge_sort(int arr[], int n);

解答：

稳定性：稳定，

时间复杂度：O(n)

空间复杂度：O(n)

int temp[N];
void m_sort(int arr[], int left, int right, int mid) {//比较左边和右边区间，小的加入数组int i = left;int i_left = left; int i_right = mid+1;while (i_left <= mid && i_right <= right) {if (arr[i_left] <= arr[i_right]) {  //两边相等，插左边区间进数组temp[i++] = arr[i_left++];}else{temp[i++] = arr[i_right++];}}//i_left>mid ||  i_right>rightwhile (i_left <= mid) {temp[i++] = arr[i_left++];}while (i_right <= right) {temp[i++] = arr[i_right++];}//i==Nfor (int j = right; j>=left; j--) {arr[j] = temp[j];}}
void merge_sort_help(int arr[], int left, int right) {if (left>=right)  //1个0个，有序return;//排序左边区间//排序右边区间//归并//int mid = left + (right-left >> 1);int mid = (left + right) / 2;merge_sort_help(arr, left, mid);//[0,mid]   merge_sort_help(arr, mid+1, right);//[mid+1,right]m_sort(arr, left, right, mid);
}
void merge_sort(int arr[], int n) {//外包merge_sort_help(arr, 0, n - 1);
}

答案：

int tmp[10];void merge(int arr[], int left, int mid, int right) {int i = left, j = left, k = mid + 1;// 两个区间都有元素while (j <= mid && k <= right) {if (arr[j] <= arr[k]) {		// Caution: 不能写成 arr[j] < arr[k], 就不稳定了tmp[i++] = arr[j++];} else {tmp[i++] = arr[k++];}} // j > mid || k > right// 左边区间有元素while (j <= mid) {tmp[i++] = arr[j++];}// 右边区间有元素while (k <= right) {tmp[i++] = arr[k++];}// 将tmp数组中的元素，复制到原数组的对应区间for (int i = left; i <= right; i++) {arr[i] = tmp[i];}
}void m_sort(int arr[], int left, int right) {// [left, right] 归并排序// 边界条件if (left >= right) return;// 递归公式int mid = left + (right - left >> 1);m_sort(arr, left, mid);m_sort(arr, mid + 1, right);merge(arr, left, mid, right);print_array(arr, 10);
}void merge_sort(int arr[], int n) {// 委托m_sort(arr, 0, n - 1);  // [0, n-1]
}

05：请实现快速排序，并分析它的时间复杂度，空间复杂度和稳定性

void quick_sort(int arr[], int n);

解答：

稳定性：不稳定，

时间复杂度：最坏，O(n^2)  可以避免，
最好O（nlogn) 平均O（nlogn)

空间复杂度：栈的使用空间，O(nlogn)

int partition(int arr[], int left, int right) {int pivot = arr[left];int i = left, j = right;//i下一个小于基准值的树，J下一个大于基准值的数while (j>i) {//j，J找到小于基准值的数，覆盖I的位置while (j>i&&arr[j] >= pivot) {j--;}arr[i] = arr[j];//i，i找到da于基准值的数，覆盖j的位置while (j > i && arr[i]<=pivot) {i++;}arr[j] = arr[i];}//i==jarr[i] = pivot;return i;
}
void q_sort(int arr[], int left, int right) {if (left >= right)return;//基准值最终位置int idx = partition(arr, left, right);//排序左边[left,idx-1]q_sort(arr, left, idx - 1);//排序右边[idx+1,right]q_sort(arr,  idx + 1,right);
}
void quick_sort(int arr[], int n) {//外包q_sort(arr, 0, n - 1);
}

答案：

int partition(int arr[], int left, int right) {// 选取基准值int pivot = arr[left];// 双向分区int i = left, j = right;while (i < j) {// 移动j, 找第一个比pivot小的元素while (i < j && arr[j] >= pivot) {j--;} // i == j || arr[j] < pivotarr[i] = arr[j];// 移动i，找第一个比pivot大的元素while (i < j && arr[i] <= pivot) {i++;} // i == j || arr[i] > pivotarr[j] = arr[i];} // i == jarr[i] = pivot;return i;
}void q_sort(int arr[], int left, int right) {// [left, right]// 边界条件if (left >= right) return;// 递归公式// 对[left, right]区间分区, idx是分区后基准值所在的位置int idx = partition(arr, left, right);print_array(arr, 10);q_sort(arr, left, idx - 1);q_sort(arr, idx + 1, right);
}void quick_sort(int arr[], int n) {q_sort(arr, 0, n - 1);	// [0, n-1]
}

06：给定一个排好序的数组，请设计一个算法将数组随机打乱。

void shuffle(int arr[], int n)

解答：

void shuffle(int arr[], int n) {srand(time(NULL));int j;for (int i = 0; i < n; i++) {j = rand() % (n - 1);  //0-n-1int temp=arr[i];arr[i] = arr[j];arr[j] = temp;}
}

答案：

好好好，和AI是一样的貌似

#include <stdio.h>
#include <stdlib.h>
#include <time.h>#define SWAP(arr, i, j) {	\int tmp = arr[i];		\arr[i] = arr[j];		\arr[j] = tmp;			\
}#define SIZE(a) (sizeof(a) / sizeof(a[0]))void shuffle(int arr[], int n) {srand(time(NULL));for (int i = 0; i < n - 1; i++) {// [i, n-1]int j = rand() % (n - i) + i;SWAP(arr, i, j);}
}void print_array(int arr[], int n) {for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}printf("\n");
}int main(void) {int arr[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };shuffle(arr, SIZE(arr));print_array(arr, SIZE(arr));return 0;
}

———————————————————————————————————————————

01：请实现堆排序，并分析它的时间复杂度，空间复杂度和稳定性

void heap_sort(int arr[], int n);

解答：

void heapify(int arr[], int i ,int len) {while (i < len) { //len--int lchild = 2 * i + 1;int rchild = 2 * i + 2;int maxIdx = i;if (lchild<len && arr[lchild]>arr[maxIdx]) {maxIdx = lchild;}if (rchild<len && arr[rchild]>arr[maxIdx]) {maxIdx = rchild;}if (maxIdx == i) { break; } //调整完成SWAP(arr, i, maxIdx);//maxIdx=lchild || rchild   比原来大捏i = maxIdx;}//i>=len,maxIdx==i
}
void heap_build(int arr[], int n) {//2*i+1<=n-1  n>i-2>>1    挨个for (int i = n - 2 >> 1; i >= 0; i--) {heapify(arr, i, n);}//i<0
}
void heap_sort(int arr[], int n) {//构建大顶堆heap_build(arr, n);int len = n;while (len > 1) {//交换第一个元素和 无序区最后一个元素SWAP(arr, 0, len - 1);len--;heapify(arr, 0, len);  //重新调整无序区}//len==1;
}

答案：

// i: 可能违反大顶堆规则的结点，并且它的左右子树都是大顶堆
// n: 逻辑上堆的长度
// 时间复杂度：O(logn)
void heapify(int arr[], int i, int n) {while (i < n) {int lchild = 2 * i + 1;int rchild = 2 * i + 2;// 求i, lchild, rchild的最大值int maxIdx = i;if (lchild < n && arr[lchild] > arr[maxIdx]) {maxIdx = lchild;}if (rchild < n && arr[rchild] > arr[maxIdx]) {maxIdx = rchild;}if (maxIdx == i) break;SWAP(arr, i, maxIdx);i = maxIdx;}
}void build_heap(int arr[], int n) {// 从后往前构建, 找第一个非叶子结点// lchild(i) = 2i+1 <= n-1// i <= (n-2)/2for (int i = n - 2 >> 1 ; i >= 0; i--) {heapify(arr, i, n);}
}void heap_sort(int arr[], int n) {build_heap(arr, n);		// O(n)print_array(arr, n);int len = n;	// 无序区的长度while (len > 1) {// 交换堆顶元素和无序区的最后一个元素SWAP(arr, 0, len - 1);len--;heapify(arr, 0, len); // 0: 可能违反堆规则的结点，这个结点的左右子树都是大顶堆// len: 逻辑上堆的大小print_array(arr, n);} // len == 1
}

02：给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

• 节点的左子树只包含 小于 当前节点的数。
• 节点的右子树只包含 大于 当前节点的数。
• 所有左子树和右子树自身必须也是二叉搜索树。

/*** Definition for a binary tree node.* struct TreeNode {*     int val;*     struct TreeNode *left;*     struct TreeNode *right;* };*/
bool isValidBST(struct TreeNode* root) {}

解答：

答案：

struct TreeNode* max; // 记录遍历结点中的最大结点bool validate(struct TreeNode* root) {// 边界条件if (root == NULL) return true;// 验证左子树if (!validate(root->left)) return false;// 验证根结点if (max != NULL && max->val >= root->val) return false; max = root;  // 将根结点设为最大结点return validate(root->right); // 验证右子树
}bool isValidBST(struct TreeNode* root) {max = NULL;return validate(root);
}

03：请实现下列二分查找的变种：

// 查找最后一个与 key 相等的元素
int binary_search1(int arr[], int n, int key);
// 查找最后一个小于等于 key 值的元素
int binary_search2(int arr[], int n, int key);

解答：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define SIZE(arr) (sizeof(arr)/sizeof(arr[0]))// 查找最后一个与 key 相等的元素
int binary_search1(int arr[], int n, int key) {int left = 0;int right = n - 1;//比较，小于KEY，rigth动，大于,LEFTdong1while (left <= right) {int mid = left + (right - left >> 1);int cmp = key - arr[mid];if (cmp < 0) {right = mid - 1;}else if (cmp > 0) {left = mid + 1;}else {   //后一个元素大于key,可能没有后一个元素||最后一个元素大于等于while (mid < right && arr[mid + 1] <= key) {right = mid - 1;}//mid==right || arr[mid+1]>keyif (mid == right) { return mid; }else { return mid + 1; }}}return -1;
}
// 查找最后一个小于等于 key 值的元素
int binary_search2(int arr[], int n, int key) {int left = 0;int right = n - 1;//都比key小，返回N-1，都比KEY大，-1.while (left <= right) {int mid = left + (right - left >> 1);int cmp = key - arr[mid];   //   left  mid    right  if (cmp < 0) {right = mid - 1;}else if (cmp > 0) {if (arr[left + 1] > key) { return left; }left = mid + 1;}else {   //mid向right靠近while (mid <= right && arr[mid + 1] <= key) {   //mid<=right  arr[right]也要进行比较mid++;}//mid==right|| arr[mid+1]>keyreturn mid;}}return -1;
}int main(void) {int arr[] = { 10,20,20,20,30,30,40,50,50,50,50,60,70,100,100,100,1001,1001,1200 };//int y01=binary_search1(arr,SIZE(arr),12);  int y01 = binary_search2(arr, SIZE(arr), 30);return 0;
}

答案：

// 查找最后一个与 key 相等的元素
int binary_search1(int arr[], int n, int key) {int left = 0, right = n - 1;while (left <= right) {int mid = left + (right - left >> 1);int cmp = key - arr[mid];if (cmp < 0) {right = mid - 1;} else if (cmp > 0) {left = mid + 1;} else {if (mid == right || arr[mid + 1] > key) {return mid;}left = mid + 1;}}return -1;
}// 查找最后一个小于等于 key 值的元素
int binary_search2(int arr[], int n, int key) {int left = 0, right = n - 1;while (left <= right) {int mid = left + (right - left >> 1);int cmp = arr[mid] - key;if (cmp <= 0) {if (mid == right || arr[mid + 1] > key) {return mid;}left = mid + 1;} else {right = mid - 1;}}return -1;
}

04：用 fread/fwrite 实现文件的复制。

// copyFile.c
int main(int argc, char* argv[]);​

解答：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#define SIZE(a) (sizeof(a)/sizeof(a[0]))int main(int argc, char* argv[]) {if (argc != 3) {printf("error,\n");exit(1);}//打开源文件FILE* mam = fopen(argv[1], "rb");if (!mam) {printf("error,\n");exit(1);}//打开目标文件FILE* son = fopen(argv[2], "wb");if (!son) {printf("error,\n");fclose(mam);exit(1);}//复制char buffer[75000];int n;while ((n=fread(buffer, 1, SIZE(buffer), mam)) != 0) {fwrite(buffer, 1, n, son);}fclose(mam);fclose(son);return 0;
}/*
用 fread/fwrite 实现文件的复制。
// copyFile.c
int main(int argc, char* argv[]);​*/

答案：

int main(int argc, char* argv[]) {// 打开文件流FILE* src = fopen(argv[1], "rb");if (!src) {fprintf(stderr, "Open %s failed.\n", argv[1]);exit(1);}FILE* dst = fopen(argv[2], "wb");if (!dst) {fclose(src);fprintf(stderr, "Open %s failed.\n", argv[2]);exit(1);}char buffer[4096];  // 4k, buffer的就是块的大小int n;while ((n = fread(buffer, 1, 4096, src)) > 0) {	// 实际读取了n个元素fwrite(buffer, 1, n, dst);}// 关闭文件流fclose(src);fclose(dst);return 0;
}

———————————————————————————————————————————

001：将一个文件读入程序，将其中的大小写字母右旋13个位置后，写入另一个文件。

[A-Ma-m] 转换成 [N-Zn-z]

[N-Zn-z] 转换成 [A-Ma-m]

其余字符不变

int main(int argc, char* argv[]) {}

解答：

//请实现下面功能将一个文件读入程序，将其中的大小写字母右旋13个位置后，写入另一个文件。
void right_handed(FILE* str1, FILE* str2) {//打开文件FILE* source = fopen(str1,"rb");if (!source) {perror("source\n");exit(1);}FILE* right = fopen(str2, "wb");if (!right) {perror("right\n");exit(1);}//逐字符读入，字符判断，右旋。写入目标文件int a;while ((a = fgetc(source)) != EOF) {if ((a <= 'M' && a >= 'A') || (a <= 'm' && a >= 'a')) {fputc(a+13, right);}else if ((a <= 'Z' && a >= 'N') || (a <= 'z' && a >= 'n')) {fputc(a - 13, right);}else {fputc(a, right);}}fclose(source);fclose(right);
}

002：将一个文件读入程序，在每一行前面添加序号，然后写入另一个文件。如：

Allen
Beyonce
Cindy
Dianna

变成

1. Allen
2. Beyonce
3. Cindy
4. Dianna

解答：

void add_num(FILE* str1, FILE* str2) {FILE* source = fopen(str1, "r");if (!source) {perror("source\n");exit(1);}FILE* add_num = fopen(str2, "w");if (!add_num) {perror("add_num\n");exit(1);}//行读取  s输出char massage1[MAXLINE];int line = 0;while (fgets(massage1, MAXLINE, source) != NULL) {line++;fprintf(add_num,"%d.%s",line,massage1);//写入字符串数组}fclose(source);fclose(add_num);
}

003：然后将规范化处理的学生信息，写入新的文件 students.dat.

1 Allen f 100 100 100
2 Beyonce f 90 90 90
3 Cindy f 95 95 95
4 Dianna f 98 98 98

字段的含义分别是：学号、姓名、性别、语文、数学、英语。现在需要对分数进行规范化处理，每个同学的语文成绩需要乘以 0.85，数学成绩乘以 0.9，英语成绩乘以 0.8。然后将规范化处理的学生信息，写入新的文件 students.dat.

解答：

void stu_information(FILE* str1, FILE* str2) {FILE* before = fopen(str1, "r");if (!before) {perror("before\n");exit(1);}FILE* after = fopen(str2, "w");if (!after) {perror("after\n");exit(1);}//标准化输入Stu s;while (1) {  //返回转换说明的个数int n = fscanf(before, "%d%s %c%d%d%d",&s.id,s.name,&s.gender,&s.chinese,&s.math,&s.english);if (n != 6) { break; }n++;s.chinese *= 0.8;s.math *= 0.9;s.english *= 0.7;fprintf(after,"%3d %10s %2c %3d %3d %3d\n",s.id,s.name,s.gender,s.chinese,s.math,s.english);}fclose(before);fclose(after);
}