[扩展阅读] 各种各这样的排序算法：冒泡排序（*）
冒泡排序的执行效果是这样的：
#include <stdio.h>
void bubble_sort(int array[], int length);
void bubble_sort(int array[], int length)
{
int i, j, temp;
for (i = 0; i < length - 1; i++)
{
for (j = 0; j < length - 1 - i; j++)
{
if (array[j] > array[j+1])
{
temp = array[j];
array[j] = array[j + 1];
array[j+1] = temp;
}
}
}
}
int main(void)
{
int array[] = {73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109};
int i, length;
length = sizeof(array) / sizeof(array[0]);
bubble_sort(array, length);
printf("排序后的结果是：");
for (i = 0; i < length; i++)
{
printf("%d ", array[i]);
}
putchar('\n');
return 0;
}
[扩展阅读] 各种各这样的排序算法：鸡尾酒排序（*）
鸡尾酒排序的执行效果是这样的：
#include <stdio.h>
void cocktail_sort(int array[], int length);
void cocktail_sort(int array[], int length)
{
int i, left = 0, right = length - 1;
int temp;
while (left < right)
{
for (i = left; i < right; i++)
{
if (array[i] > array[i+1])
{
temp = array[i];
array[i] = array[i+1];
array[i+1] = temp;
}
}
right--;
for (i = right; i > left; i--)
{
if (array[i-1] > array[i])
{
temp = array[i];
array[i] = array[i-1];
array[i-1] = temp;
}
}
left++;
}
}
int main(void)
{
int array[] = {73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109};
int i, length;
length = sizeof(array) / sizeof(array[0]);
cocktail_sort(array, length);
printf("排序后的结果是：");
for (i = 0; i < length; i++)
{
printf("%d ", array[i]);
}
putchar('\n');
return 0;
}
[扩展阅读] 各种各这样的排序算法：插入排序（*）
插入排序的执行效果是这样的：
算法实现：
#include <stdio.h>
void insertion_sort(int array[], int length);
void insertion_sort(int array[], int length)
{
int i, j, temp;
for (i = 1; i < length; i++)
{
temp = array[i];
j = i - 1;
for ( ; j >= 0 && array[j] > temp; j--)
{
array[j+1] = array[j];
}
array[j+1] = temp;
}
}
int main(void)
{
int array[] = {73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109};
int i, length;
length = sizeof(array) / sizeof(array[0]);
insertion_sort(array, length);
printf("排序后的结果是：");
for (i = 0; i < length; i++)
{
printf("%d ", array[i]);
}
putchar('\n');
return 0;
}
[扩展阅读] 各种各这样的排序算法：选择排序（*）
选择排序的执行效果是这样的：
算法实现：
#include <stdio.h>
void selection_sort(int array[], int length);
void selection_sort(int array[], int length)
{
int i, j, min, temp;
for (i = 0; i < length - 1; i++)
{
min = i;
for (j = i + 1; j < length; j++)
{
if (array[min] > array[j])
{
min = j;
}
}
temp = array[min];
array[min] = array[i];
array[i] = temp;
}
}
int main(void)
{
int array[] = {73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109};
int i, length;
length = sizeof(array) / sizeof(array[0]);
selection_sort(array, length);
printf("排序后的结果是：");
for (i = 0; i < length; i++)
{
printf("%d ", array[i]);
}
putchar('\n');
return 0;
}
[扩展阅读] 各种各这样的排序算法：希尔排序（*）
希尔排序的执行效果是这样的：
#include <stdio.h>
void shell_sort(int array[], int length);
void shell_sort(int array[], int length)
{
int i, j, step, temp;
for (step = length / 2; step > 0; step /= 2)
{
for (i = step; i < length; i++)
{
temp = array[i];
for (j = i - step; j >= 0 && array[j] > temp; j -= step)
{
array[j+step] = array[j];
}
array[j+step] = temp;
}
}
}
int main(void)
{
int array[] = {73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109};
int i, length;
length = sizeof(array) / sizeof(array[0]);
shell_sort(array, length);
printf("排序后的结果是：");
for (i = 0; i < length; i++)
{
printf("%d ", array[i]);
}
putchar('\n');
return 0;
}
[扩展阅读] 各种各这样的排序算法：快速排序
快速排序的执行效果是这样的：
#include <stdio.h>
void quick_sort(int array[], int left, int right);
void quick_sort(int array[], int left, int right)
{
int i = left, j = right;
int temp;
int pivot;
// 基准点设置为中间元素，你也可以选择其它元素作为基准点
pivot = array[(left + right) / 2];
while (i <= j)
{
// 找到左边大于等于基准点的元素
while (array[i] < pivot)
{
i++;
}
// 找到右边小于等于基准点的元素
while (array[j] > pivot)
{
j--;
}
// 如果左边下标小于右边，则互换元素
if (i <= j)
{
temp = array[i];
array[i] = array[j];
array[j] = temp;
i++;
j--;
}
}
if (left < j)
{
quick_sort(array, left, j);
}
if (i < right)
{
quick_sort(array, i, right);
}
}
int main(void)
{
int array[] = {73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109};
int i, length;
length = sizeof(array) / sizeof(array[0]);
quick_sort(array, 0, length-1);
printf("排序后的结果是：");
for (i = 0; i < length; i++)
{
printf("%d ", array[i]);
}
putchar('\n');
return 0;
}
[扩展阅读] 各种各这样的排序算法：归并排序（*）
归并排序的执行效果是这样的：
算法实现：
#include <stdio.h>
void merge_sort(int array[], int length);
void merge_sort_recursive(int array[], int reg[], int start, int end);
void merge_sort_recursive(int array[], int reg[], int start, int end)
{
if (start >= end)
{
return;
}
int k = start;
int length = end - start;
int mid = (length / 2) + start;
int start1 = start, end1 = mid;
int start2 = mid + 1, end2 = end;
merge_sort_recursive(array, reg, start1, end1);
merge_sort_recursive(array, reg, start2, end2);
while (start1 <= end1 && start2 <= end2)
{
reg[k++] = array[start1] < array[start2] ? array[start1++] : array[start2++];
}
while (start1 <= end1)
{
reg[k++] = array[start1++];
}
while (start2 <= end2)
{
reg[k++] = array[start2++];
}
for (k = start; k <= end; k++)
{
array[k] = reg[k];
}
}
void merge_sort(int array[], int length)
{
int reg[length];
merge_sort_recursive(array, reg, 0, length-1);
}
int main(void)
{
int array[] = {73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109};
int i, length;
length = sizeof(array) / sizeof(array[0]);
merge_sort(array, length);
printf("排序后的结果是：");
for (i = 0; i < length; i++)
{
printf("%d ", array[i]);
}
putchar('\n');
return 0;
}
[扩展阅读] 各种各这样的排序算法：计数排序（*）
#include <stdio.h>
#include <stdlib.h>
void counting_sort(int array[], int length);
void counting_sort(int array[], int length)
{
int i, max;
int *buffer = NULL;
int *sorted = NULL;
max = array[0];
for (i = 1; i < length; i++)
{
if (array[i] > max)
{
max = array[i];
}
}
buffer = (int *)malloc((max + 1) * sizeof(int));
for (i = 0; i < max + 1; i++)
{
buffer[i] = 0;
}
for (i = 0; i < length; i++)
{
buffer[array[i]]++;
}
for (i = 1; i < max+1; i++)
{
buffer[i] += buffer[i-1];
}
sorted = (int *)malloc(length * sizeof(int));
for (i = length; i > 0; i--)
{
sorted[--buffer[array[i-1]]] = array[i-1];
}
for (i = 0; i < length; i++)
{
array[i] = sorted[i];
}
free(buffer);
free(sorted);
}
int main(void)
{
int array[] = {73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109};
int i, length;
length = sizeof(array) / sizeof(array[0]);
counting_sort(array, length);
printf("排序后的结果是：");
for (i = 0; i < length; i++)
{
printf("%d ", array[i]);
}
putchar('\n');
return 0;
}
[扩展阅读] 各种各这样的排序算法：桶排序（*）
#include <stdio.h>
#include <stdlib.h>
int *add_item(int *array, int count, int item);
void bucket_sort(int array[], int length);
struct Bucket
{
int *data;
int count;
};
int *add_item(int *array, int count, int item)
{
int *newArray = (int *)malloc(sizeof(int) * (count + 1));
int i;
for (i = 0; i < count; i++)
{
newArray[i] = array[i];
}
newArray[count] = item;
return newArray;
}
void bucket_sort(int array[], int length)
{
int min = array[0];
int max = array[0];
int i, j, k, cap, size;
struct Bucket *bucket = NULL;
struct Bucket b;
for (i = 1; i < length; i++)
{
if (array[i] > max)
{
max = array[i];
}
if (array[i] < min)
{
min = array[i];
}
}
cap = max - min + 1;
bucket = (struct Bucket *)malloc(sizeof(struct Bucket) * cap);
for (i = 0; i < cap; i++)
{
bucket[i] = *(struct Bucket *)malloc(sizeof(struct Bucket));
}
for (i = 0; i < length; i++)
{
b = bucket[array[i] - min];
if (b.count < 0)
{
b.count = 0;
}
bucket[array[i] - min].data = add_item(b.data, b.count++, array[i]);
bucket[array[i] - min].count = b.count;
}
for (i = 0, k = 0; i < cap; i++)
{
size = bucket[i].count;
if (size > 0)
{
for (j = 0; j < size; j++)
{
array[k] = bucket[i].data[j];
k++;
}
}
}
}
int main(void)
{
int array[] = {73, 108, 111, 118, 101, 70, 105, 115, 104, 67, 46, 99, 111, 109};
int i, length;
length = sizeof(array) / sizeof(array[0]);
bucket_sort(array, length);
printf("排序后的结果是：");
for (i = 0; i < length; i++)
{
printf("%d ", array[i]);
}
putchar('\n');
return 0;
}
[知识点备忘] S1E36：快速排序
[课后作业] S1E36：快速排序 | 课后测试题及答案
代码清单：
#include <stdio.h>
int count = 0;
int check(int i, int j, int (*queen)[4]);
void setQueen(int i, int (*queen)[4]);
int check(int i, int j, int (*queen)[4])
{
int s, t;
// 判断行
for (s = i, t = 0; t < 4; t++)
{
if (queen[s][t] == 1 && t != j)
{
return 0;
}
}
// 判断列
for (t = j, s = 0; s < 4; s++)
{
if (queen[s][t] == 1 && s != i)
{
return 0;
}
}
// 判断左上方
for (s = i-1, t = j-1; s >= 0 && t >= 0; s--, t--)
{
if (queen[s][t] == 1)
{
return 0;
}
}
// 判断右上方
for (s = i+1, t = j+1; s < 4 && t < 4; s++, t++)
{
if (queen[s][t] == 1)
{
return 0;
}
}
// 经过上面层层关卡还能存活，那么说明符合条件,返回1
return 1;
}
void setQueen(int col, int (*queen)[4])
{
int i, j, row;
// 所有皇后放置完毕
if (col == 4)
{
for (i = 0; i < 4; i++)
{
for (j = 0; j < 4; j++)
{
if (queen[i][j] != 0)
{
printf("Q ");
}
else
{
printf("* ");
}
}
putchar('\n');
}
putchar('\n');
count++;
return;
}
// 迭代每一行
for (row = 0; row < 4; row++)
{
// 检查每一行中对应的每一列能否放置皇后
if (check(row, col, queen))
{
// 如果queen[row][col]符合条件，则放置皇后
queen[row][col] = 1;
// col+1，进入下一层递归
setQueen(col+1, queen);
// 只有两种情况会执行下面语句
// 1. col+1遇到所有的row都不合适
// 2. 完成整个二维数组的放置
// 无论哪种情况，
queen[row][col] = 0;
}
}
}
int main(void)
{
int queen[4][4];
int i, j;
// 初始化二维数组，1表示已放置皇后，0表示没有
for (i = 0; i < 4; i++)
{
for (j = 0; j < 4; j++)
{
queen[i][j] = 0;
}
}
setQueen(0, queen);
return 0;
}
题目：编写代码，实现马踏棋盘的操作，要求使用 1~64 来标注“马”移动的轨迹。
#include <stdio.h>
#define X 8
#define Y 8
int chess[X][Y];
// 找到下一个可走的位置
int next(int *px, int *py, int count)
{
int x = *px;
int y = *py;
switch(count)
{
case 0:
if (x+2<=X-1 && y-1>=0 && chess[x+2][y-1] == 0)
{
*px = x + 2;
*py = y - 1;
return 1;
}
break;
case 1:
if (x+2<=X-1 && y+1<=Y-1 && chess[x+2][y+1] == 0)
{
*px = x + 2;
*py = y + 1;
return 1;
}
break;
case 2:
if (x+1<=X-1 && y-2>=0 && chess[x+1][y-2] == 0)
{
*px = x + 1;
*py = y - 2;
return 1;
}
break;
case 3:
if (x+1<=X-1 && y+2<=Y-1 && chess[x+1][y+2] == 0)
{
*px = x + 1;
*py = y + 2;
return 1;
}
break;
case 4:
if (x-2>=0 && y-1>=0 && chess[x-2][y-1] == 0)
{
*px = x - 2;
*py = y - 1;
return 1;
}
break;
case 5:
if (x-2>=0 && y+1<=Y-1 && chess[x-2][y+1] == 0)
{
*px = x - 2;
*py = y + 1;
return 1;
}
break;
case 6:
if (x-1>=0 && y-2>=0 && chess[x-1][y-2] == 0)
{
*px = x - 1;
*py = y - 2;
return 1;
}
break;
case 7:
if (x-1>=0 && y+2<=Y-1 && chess[x-1][y+2] == 0)
{
*px = x - 1;
*py = y + 2;
return 1;
}
break;
}
return 0;
}
int setHorse(int x, int y, int tag)
{
int x1 = x, y1 = y, flag = 0, count = 0;
// tag记录轨迹
chess[x][y] = tag;
// 如果tag等于64退出程序
if (tag == X*Y)
{
return 1;
}
// 如果可以走，那么flag为1
flag = next(&x1, &y1, count);
// 否则尝试其他路径
while (flag == 0 && count < 7)
{
count += 1;
flag = next(&x1, &y1, count);
}
// 递归进入下一个坐标
while (flag)
{
// 返回1表示成功找到落脚点
if (setHorse(x1, y1, tag+1))
{
return 1;
}
// 否则从上一步重新尝试
x1 = x;
y1 = y;
count += 1;
flag = next(&x1, &y1, count);
while (flag == 0 && count < 7)
{
count += 1;
flag = next(&x1, &y1, count);
}
}
if (flag == 0)
{
chess[x][y] = 0;
}
return 0;
}
int main(void)
{
int i, j;
for (i = 0; i < X; i++)
{
for (j = 0; j < Y; j++)
{
chess[i][j] = 0;
}
}
// 讲道理，从 (2, 0) 坐标开始计算是比较容易出结果的
// 如果你比较有耐心，或 CPU 特别强劲，可以尝试计算其它坐标
if (setHorse(2, 0, 1))
{
for (i = 0; i < X; i++)
{
for (j = 0; j < Y; j++)
{
printf("%02d ", chess[i][j]);
}
putchar('\n');
}
}
else
{
printf("可惜无解！\n");
}
return 0;
}
[知识点备忘] S1E37：动态内存管理
[课后作业] S1E37：动态内存管理 | 课后测试题及答案
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int *ptr = NULL;
int num, i;
printf("请输入待录入整数的个数：");
scanf("%d", &num);
ptr = (int *)malloc(num * sizeof(int));
for (i = 0; i < num; i++)
{
printf("请录入第%d个整数：", i+1);
scanf("%d", &ptr[i]);
}
printf("你录入的整数是：");
for (i = 0; i < num; i++)
{
printf("%d ", ptr[i]);
}
putchar('\n');
return 0;
}
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
void *block;
int i, count;
size_t maximum = 0;
size_t blocksize[] = {1024 * 1024, 1024, 1};
// 下面从大到小依次尝试
// 先尝试以1024 * 1024为扩大粒度去申请内存空间
// 当malloc返回NULL时，将扩大的粒度缩小为1024继续尝试
// 最终精确到1个字节的粒度扩大maximum的尺寸
for (i = 0; i < 3; i++)
{
for (count = 1; ;count++)
{
block = malloc(maximum + blocksize[i] * count);
if (block)
{
maximum += blocksize[i] * count;
free(block);
}
else
{
break;
}
}
}
printf("malloc在当前环境下申请到的最大空间是：%.2fGB\n", maximum * 1.0 / 1024 / 1024 / 1024);
return 0;
}
[知识点备忘] S1E38：动态内存管理2
1. malloc 可以申请一块任意尺寸的内存空间
malloc 不仅可以申请存储基本数据类型的空间，事实上它还可以申请一块任意尺寸的内存空间。对于后者，由于申请得到的空间是连续的，所以我们经常用数组来进行索引即可：
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int *ptr = NULL;
int num, i;
printf("请输入待录入整数的个数：");
scanf("%d", &num);
ptr = (int *)malloc(num * sizeof(int));
for (i = 0; i < num; i++)
{
printf("请录入第%d个整数：", i+1);
scanf("%d", &ptr[i]);
}
printf("你录入的整数是：");
for (i = 0; i < num; i++)
{
printf("%d ", ptr[i]);
}
putchar('\n');
free(ptr);
return 0;
}
[课后作业] S1E38：动态内存管理2 | 课后测试题及答案
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#define HUMANWIN 0
#define COMPUTERWIN 1
int get_computer(void)
{
int computer;
srand((unsigned)time(NULL));
computer = rand() % 3 + 1;
return computer;
}
int get_human(void)
{
int human;
printf("请出拳（1剪刀/2石头/3布/0退出）-> ");
scanf("%d", &human);
while (human < 0 || human > 3)
{
printf("出拳错误，请重新出拳（只需要输入数字即可）-> ");
scanf("%d", &human);
}
return human * 3;
}
void welcome(void)
{
printf("\n########################\n");
printf("# 欢迎来到猜拳小游戏！ #\n");
printf("########################\n\n");
}
void gameover(int winner)
{
if (winner)
{
printf("\n#########################################################################\n");
printf("# #\n");
printf("# ## ## #### ## ## ## #### ###### ######## #\n");
printf("# ## ## ## ## ## ## ## ## ## ## ## #\n");
printf("# #### ## ## ## ## ## ## ## ## ## #\n");
printf("# ## ## ## ## ## ## ## ## ###### ####### #\n");
printf("# ## ## ## ## ## ## ## ## ## ## #\n");
printf("# ## ## ## ## ## ## ## ## ## ## #\n");
printf("# ## #### ##### ####### #### ###### ######## #\n");
printf("# #\n");
printf("#########################################################################\n");
}
else
{
printf("\n##########################################################################\n");
printf("# #\n");
printf("# ## ## #### ## ## ## ## ###### ## ## #\n");
printf("# ## ## ## ## ## ## ## ## ## ## ### ## #\n");
printf("# #### ## ## ## ## ## #### ## ## ## # ## #\n");
printf("# ## ## ## ## ## ## ## ## ## ## ## # ## #\n");
printf("# ## ## ## ## ## ## ## ## ## ## ## # ## #\n");
printf("# ## ## ## ## ## ### ### ## ## ### #\n");
printf("# ## #### ##### # # ###### ## ## #\n");
printf("# #\n");
printf("##########################################################################\n");
}
}
int main(void)
{
int human, computer; // 1、2、3分别代表剪刀石头和布
int result;
int human_win = 0;
int computer_win = 0;
welcome();
while (1)
{
human = get_human();
computer = get_computer();
// 用户输入0表示退出游戏
if (human == 0)
{
break;
}
printf("你出");
switch (human)
{
case 3: printf("剪刀，"); break;
case 6: printf("石头，"); break;
case 9: printf("布，"); break;
}
printf("我出");
switch (computer)
{
case 1: printf("剪刀，"); break;
case 2: printf("石头，"); break;
case 3: printf("布，"); break;
}
result = human + computer;
// 你出剪刀，电脑出布：3 + 3 == 6
// 你出石头，电脑出剪刀：6 + 1 == 7
// 你出布，电脑出石头：9 + 2 == 11
// 以上三种情况算你赢～
if (result == 6 || result == 7 || result == 11)
{
printf("你赢了！\n\n");
human_win++;
}
else if (result == 5 || result == 9 || result == 10)
{
printf("我赢了！\n\n");
computer_win++;
}
else
{
printf("咱打平！\n\n");
}
}
// 打平也算人类赢
if (human_win >= computer_win)
{
gameover(HUMANWIN);
}
else
{
gameover(COMPUTERWIN);
}
}
#include <stdio.h>
#include <stdlib.h>
#define MAX_LIMIT_MATRIX 100
void welcome(void);
int get_ins(void);
int *create_matrix(void);
void init_matrix(int *ptr);
void print_matrix(int *ptr);
void write_matrix(int *ptr);
void read_matrix(int *ptr);
void welcome(void)
{
printf("\n============================\n");
printf("* 欢迎使用该程序，指令如下 *\n");
printf("* 1.生成一个 M*N 的矩阵 *\n");
printf("* 2.初始化矩阵 *\n");
printf("* 3.给矩阵中某个元素赋值 *\n");
printf("* 4.读取矩阵中某个元素 *\n");
printf("* 5.打印整个矩阵 *\n");
printf("* 6.结束程序 *\n");
printf("============================\n");
}
int get_ins(void)
{
int ins;
printf("\n请输入指令：");
scanf("%d", &ins);
while (ins < 1 || ins > 6)
{
printf("\n指令错误，请重新输入：");
scanf("%d", &ins);
}
return ins;
}
int *create_matrix(void)
{
int m, n;
static int created = 0; // 用于判断是否已经创建过矩阵
static int *ptr = NULL;
if (created)
{
printf("矩阵已存在，是否需要重新创建？（Y/N）-> ");
getchar(); // 清除缓冲区残留的换行符
while (getchar() == 'N')
{
return ptr;
}
}
printf("请输入新矩阵的规模（M*N）-> ");
scanf("%d*%d", &m, &n);
while (m < 1 || n < 1)
{
printf("规模太小，请重新输入：");
scanf("%d*%d", &m, &n);
}
while (m > MAX_LIMIT_MATRIX || n > MAX_LIMIT_MATRIX)
{
printf("规模太大，请重新输入：");
scanf("%d*%d", &m, &n);
}
// 虽然说是矩阵是二维数组，但在C语言中它的存放形式是“平铺”的
// 这里用realloc，支持重新创建二维数组
// 这里多申请了两个整形空间，用于存放矩阵的长和宽
ptr = (int *)realloc(ptr, (m * n + 2)* sizeof(int));
if (ptr == NULL)
{
printf("内存申请失败！\n");
exit(1);
}
printf("%d*%d 的矩阵创建成功！\n", m, n);
created = 1;
// 将长和宽放在前两个元素中
ptr[0] = m;
ptr[1] = n;
return ptr;
}
void init_matrix(int *ptr)
{
int m = ptr[0];
int n = ptr[1];
int *matrix = ptr + 2;
int num, i, j;
if (ptr == NULL)
{
printf("未检测到矩阵，请先生成矩阵！\n");
return ;
}
printf("请输入一个数字：");
scanf("%d", &num);
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
{
matrix[i * n + j] = num;
}
}
}
void print_matrix(int *ptr)
{
int m = ptr[0];
int n = ptr[1];
int *matrix = ptr + 2;
int i, j;
if (ptr == NULL)
{
printf("未检测到矩阵，请先生成矩阵！\n");
return ;
}
for (i = 0; i < m; i++)
{
for (j = 0; j < n; j++)
{
printf("%d ", matrix[i * n + j]);
}
putchar('\n');
}
}
void write_matrix(int *ptr)
{
int m = ptr[0];
int n = ptr[1];
int *matrix = ptr + 2;
int num, x, y;
if (ptr == NULL)
{
printf("未检测到矩阵，请先生成矩阵！\n");
return ;
}
printf("请输入要修改的位置（行,列）-> ");
scanf("%d,%d", &x, &y);
if (x > m || y > n || x < 1 || y < 1)
{
printf("坐标输入有误！\n");
return ;
}
printf("请输入一个数字：");
scanf("%d", &num);
matrix[(x - 1) * n + (y - 1)] = num;
}
void read_matrix(int *ptr)
{
int m = ptr[0];
int n = ptr[1];
int *matrix = ptr + 2;
int num, x, y;
if (ptr == NULL)
{
printf("未检测到矩阵，请先生成矩阵！\n");
return ;
}
printf("请输入要读取的位置（行,列）-> ");
scanf("%d,%d", &x, &y);
if (x > m || y > n || x < 1 || y < 1)
{
printf("坐标输入有误！\n");
return ;
}
printf("第%d行，第%d列的数字是：%d\n", x, y, matrix[(x - 1) * n + (y - 1)]);
}
int main(void)
{
int ins;
int *ptr = NULL;
welcome();
while((ins = get_ins()) != 6)
{
switch(ins)
{
case 1: ptr = create_matrix(); break;
case 2: init_matrix(ptr); break;
case 3: write_matrix(ptr); break;
case 4: read_matrix(ptr); break;
case 5: print_matrix(ptr); break;
}
}
printf("\n感谢使用本程序^_^\n\n");
free(ptr);
return 0;
}
[知识点备忘] S1E39：C语言的内存布局
[课后作业] S1E39：C语言的内存布局 | 课后测试题及答案
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char *use_malloc(int n)
{
char *array;
array = (char *)malloc(n);
strcpy(array, "I love FishC.com!");
return array;
}
char *use_VLA(int n)
{
char array[n];
strcpy(array, "I love FishC.com!");
return array;
}
int main(void)
{
printf("use_malloc: %s\n", use_malloc(18));
printf("use_VLA: %s\n", use_VLA(18));
return 0;
}
0. malloc 和 realloc 函数创建一个可以存放任意长度整数的容器（数字以字符的形式存储）。
#include <stdio.h>
#include <stdlib.h>
#define INCREMENT 10
#define INIT_SIZE INCREMENT
int main(void)
{
char ch;
char *num; // 存储整个数据的首地址
char *last; // 最近一次迭代的起始地址
int limit = 0; // 每次迭代的限制值
long times = 1; // 记录重新申请多少次内存
num = (char *)malloc(INIT_SIZE);
if (num == NULL)
{
exit(1);
}
last = num;
printf("请输入一个整数：");
while ((ch=getchar()) != '\n')
{
last[limit++] = ch;
if (limit >= INCREMENT)
{
int offset = last - num;
num = (char *)realloc(num, INIT_SIZE + INCREMENT * times++);
last = num;
last += offset;
last += INCREMENT;
limit = 0;
}
}
last[limit] = '\0';
printf("你输入的整数是：%s\n", num);
return 0;
}
1. 编写一个函数，功能是将传入的字符串前后翻转。
#include <stdio.h>
#include <stdlib.h>
#define INCREMENT 10
#define INIT_SIZE INCREMENT
char *get_str(void)
{
char ch;
char *str; // 存储整个数据的首地址
char *last; // 最近一次迭代的起始地址
int limit = 0; // 每次迭代的限制值
long times = 1; // 记录重新申请多少次内存
str = (char *)malloc(INIT_SIZE);
if (str == NULL)
{
exit(1);
}
last = str;
printf("请输入一个字符串：");
while ((ch=getchar()) != '\n')
{
last[limit++] = ch;
if (limit >= INCREMENT)
{
int offset = last - num;
num = (char *)realloc(num, INIT_SIZE + INCREMENT * times++);
last = num;
last += offset;
last += INCREMENT;
limit = 0;
}
}
last[limit] = '\0';
return str;
}
char *reverse_str(char *str)
{
char *start = str;
char *left = str;
char ch;
if (str != NULL)
{
// 定位到字符串的最后一个字符
while (*str++)
;
str -= 2;
while (left < str)
{
ch = *left;
*left++ = *str;
*str-- = ch;
}
}
return start;
}
int main(void)
{
char *str;
str = get_str(); // 这个get_str函数也就是上一题的答案
str = reverse_str(str);
printf("前后翻转后的结果：%s\n", str);
return 0;
}
2. 有了上面两道题的“经验”，好戏正式开始：请编写一个程序，实现任意长度的整数加法运算。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define INCREMENT 10
#define INIT_SIZE INCREMENT
char *get_num(void);
char *reverse_str(char *str);
char *add_two_strs(char *str1, char *str2);
char *append_result(char *result, char ch);
// 获取用户输入的整数
char *get_num(void)
{
char ch;
char *num; // 存储整个数据的首地址
char *last; // 最近一次迭代的起始地址
int limit = 0; // 每次迭代的限制值
long times = 1; // 记录重新申请多少次内存
num = (char *)malloc(INIT_SIZE);
if(num == NULL)
{
exit(1);
}
last = num;
printf("请输入一个整数：");
while((ch = getchar()) != '\n')
{
last[limit++] = ch;
if(limit >= INCREMENT)
{
int offset = last - num;
num = (char *)realloc(num, INIT_SIZE + INCREMENT * times++);
last = num;
last += offset;
last += INCREMENT;
limit = 0;
}
}
last[limit] = '\0';
return num;
}
// 前后翻转字符串
char *reverse_str(char *str)
{
char *start = str;
char *left = str;
char ch;
if(str != NULL)
{
// 定位到字符串的最后一个字符
while(*str++)
;
str -= 2;
while(left < str)
{
ch = *left;
*left++ = *str;
*str-- = ch;
}
}
return start;
}
char *append_result(char *result, char ch)
{
char *last = result;
int limit = 0;
int times = 1;
// 定位到字符串的末尾
while(last[limit++] != '\0')
{
if(limit >= INCREMENT)
{
limit = 0;
times++;
last += INCREMENT;
}
}
last[limit - 1] = ch;
if(limit >= INCREMENT)
{
int offset = last - result;
result = (char *)realloc(result, INIT_SIZE + INCREMENT * times);
last = result;
last += offset;
last += INCREMENT;
limit = 0; // reset
}
last[limit] = '\0';
return result;
}
// 将两个字符串对应的数值相加
char *add_two_strs(char *str1, char *str2)
{
int carry = 0; // 存放进位
int num1, num2, num3;
char *result;
result = (char *)malloc(INIT_SIZE);
if(result == NULL)
{
exit(1);
}
result[0] = '\0'; // 需要 '\0'
// 字符串的存放顺序跟加法规则相反
// 需要先反转字符串
str1 = reverse_str(str1);
str2 = reverse_str(str2);
// 两个字符串按位相加
while(*str1 != '\0' || *str2 != '\0')
{
num1 = *str1 - '0';
num2 = *str2 - '0';
if(*str1 == '\0')
{
num1 = 0;
}
else
{
str1++;
}
if(*str2 == '\0')
{
num2 = 0;
}
else
{
str2++;
}
num3 = num1 + num2 + carry;
if(num3 > 9)
{
result = append_result(result, num3 - 10 + '0');
carry = 1;
}
else
{
result = append_result(result, num3 + '0');
carry = 0;
}
}
if(carry)
{
append_result(result, carry + '0');
}
result = reverse_str(result);
return result;
}
int main(void)
{
char *num1;
char *num2;
char *result;
num1 = get_num();
num2 = get_num();
result = add_two_strs(num1, num2);
printf("计算结果是：%s\n", result);
return 0;
}
[扩展阅读] 有关密码的一些事儿
MD5 算法的源代码（C 语言）
需要头文件（md5.h）：
#ifndef MD5_H
#define MD5_H
typedef struct
{
unsigned int count[2];
unsigned int state[4];
unsigned char buffer[64];
}MD5_CTX;
#define F(x,y,z) ((x & y) | (~x & z))
#define G(x,y,z) ((x & z) | (y & ~z))
#define H(x,y,z) (x^y^z)
#define I(x,y,z) (y ^ (x | ~z))
#define ROTATE_LEFT(x,n) ((x << n) | (x >> (32-n)))
#define FF(a,b,c,d,x,s,ac) \
{ \
a += F(b,c,d) + x + ac; \
a = ROTATE_LEFT(a,s); \
a += b; \
}
#define GG(a,b,c,d,x,s,ac) \
{ \
a += G(b,c,d) + x + ac; \
a = ROTATE_LEFT(a,s); \
a += b; \
}
#define HH(a,b,c,d,x,s,ac) \
{ \
a += H(b,c,d) + x + ac; \
a = ROTATE_LEFT(a,s); \
a += b; \
}
#define II(a,b,c,d,x,s,ac) \
{ \
a += I(b,c,d) + x + ac; \
a = ROTATE_LEFT(a,s); \
a += b; \
}
void MD5Init(MD5_CTX *context);
void MD5Update(MD5_CTX *context,unsigned char *input,unsigned int inputlen);
void MD5Final(MD5_CTX *context,unsigned char digest[16]);
void MD5Transform(unsigned int state[4],unsigned char block[64]);
void MD5Encode(unsigned char *output,unsigned int *input,unsigned int len);
void MD5Decode(unsigned int *output,unsigned char *input,unsigned int len);
#endif
MD5 算法源文件（md5.c）：
#include <memory.h>
#include "md5.h"
unsigned char PADDING[]={0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
void MD5Init(MD5_CTX *context)
{
context->count[0] = 0;
context->count[1] = 0;
context->state[0] = 0x67452301;
context->state[1] = 0xEFCDAB89;
context->state[2] = 0x98BADCFE;
context->state[3] = 0x10325476;
}
void MD5Update(MD5_CTX *context,unsigned char *input,unsigned int inputlen)
{
unsigned int i = 0,index = 0,partlen = 0;
index = (context->count[0] >> 3) & 0x3F;
partlen = 64 - index;
context->count[0] += inputlen << 3;
if(context->count[0] < (inputlen << 3))
context->count[1]++;
context->count[1] += inputlen >> 29;
if(inputlen >= partlen)
{
memcpy(&context->buffer[index],input,partlen);
MD5Transform(context->state,context->buffer);
for(i = partlen;i+64 <= inputlen;i+=64)
MD5Transform(context->state,&input[i]);
index = 0;
}
else
{
i = 0;
}
memcpy(&context->buffer[index],&input[i],inputlen-i);
}
void MD5Final(MD5_CTX *context,unsigned char digest[16])
{
unsigned int index = 0,padlen = 0;
unsigned char bits[8];
index = (context->count[0] >> 3) & 0x3F;
padlen = (index < 56)?(56-index):(120-index);
MD5Encode(bits,context->count,8);
MD5Update(context,PADDING,padlen);
MD5Update(context,bits,8);
MD5Encode(digest,context->state,16);
}
void MD5Encode(unsigned char *output,unsigned int *input,unsigned int len)
{
unsigned int i = 0,j = 0;
while(j < len)
{
output[j] = input[i] & 0xFF;
output[j+1] = (input[i] >> 8) & 0xFF;
output[j+2] = (input[i] >> 16) & 0xFF;
output[j+3] = (input[i] >> 24) & 0xFF;
i++;
j+=4;
}
}
void MD5Decode(unsigned int *output,unsigned char *input,unsigned int len)
{
unsigned int i = 0,j = 0;
while(j < len)
{
output[i] = (input[j]) |
(input[j+1] << 8) |
(input[j+2] << 16) |
(input[j+3] << 24);
i++;
j+=4;
}
}
void MD5Transform(unsigned int state[4],unsigned char block[64])
{
unsigned int a = state[0];
unsigned int b = state[1];
unsigned int c = state[2];
unsigned int d = state[3];
unsigned int x[64];
MD5Decode(x,block,64);
FF(a, b, c, d, x[ 0], 7, 0xd76aa478); /* 1 */
FF(d, a, b, c, x[ 1], 12, 0xe8c7b756); /* 2 */
FF(c, d, a, b, x[ 2], 17, 0x242070db); /* 3 */
FF(b, c, d, a, x[ 3], 22, 0xc1bdceee); /* 4 */
FF(a, b, c, d, x[ 4], 7, 0xf57c0faf); /* 5 */
FF(d, a, b, c, x[ 5], 12, 0x4787c62a); /* 6 */
FF(c, d, a, b, x[ 6], 17, 0xa8304613); /* 7 */
FF(b, c, d, a, x[ 7], 22, 0xfd469501); /* 8 */
FF(a, b, c, d, x[ 8], 7, 0x698098d8); /* 9 */
FF(d, a, b, c, x[ 9], 12, 0x8b44f7af); /* 10 */
FF(c, d, a, b, x[10], 17, 0xffff5bb1); /* 11 */
FF(b, c, d, a, x[11], 22, 0x895cd7be); /* 12 */
FF(a, b, c, d, x[12], 7, 0x6b901122); /* 13 */
FF(d, a, b, c, x[13], 12, 0xfd987193); /* 14 */
FF(c, d, a, b, x[14], 17, 0xa679438e); /* 15 */
FF(b, c, d, a, x[15], 22, 0x49b40821); /* 16 */
/* Round 2 */
GG(a, b, c, d, x[ 1], 5, 0xf61e2562); /* 17 */
GG(d, a, b, c, x[ 6], 9, 0xc040b340); /* 18 */
GG(c, d, a, b, x[11], 14, 0x265e5a51); /* 19 */
GG(b, c, d, a, x[ 0], 20, 0xe9b6c7aa); /* 20 */
GG(a, b, c, d, x[ 5], 5, 0xd62f105d); /* 21 */
GG(d, a, b, c, x[10], 9, 0x2441453); /* 22 */
GG(c, d, a, b, x[15], 14, 0xd8a1e681); /* 23 */
GG(b, c, d, a, x[ 4], 20, 0xe7d3fbc8); /* 24 */
GG(a, b, c, d, x[ 9], 5, 0x21e1cde6); /* 25 */
GG(d, a, b, c, x[14], 9, 0xc33707d6); /* 26 */
GG(c, d, a, b, x[ 3], 14, 0xf4d50d87); /* 27 */
GG(b, c, d, a, x[ 8], 20, 0x455a14ed); /* 28 */
GG(a, b, c, d, x[13], 5, 0xa9e3e905); /* 29 */
GG(d, a, b, c, x[ 2], 9, 0xfcefa3f8); /* 30 */
GG(c, d, a, b, x[ 7], 14, 0x676f02d9); /* 31 */
GG(b, c, d, a, x[12], 20, 0x8d2a4c8a); /* 32 */
/* Round 3 */
HH(a, b, c, d, x[ 5], 4, 0xfffa3942); /* 33 */
HH(d, a, b, c, x[ 8], 11, 0x8771f681); /* 34 */
HH(c, d, a, b, x[11], 16, 0x6d9d6122); /* 35 */
HH(b, c, d, a, x[14], 23, 0xfde5380c); /* 36 */
HH(a, b, c, d, x[ 1], 4, 0xa4beea44); /* 37 */
HH(d, a, b, c, x[ 4], 11, 0x4bdecfa9); /* 38 */
HH(c, d, a, b, x[ 7], 16, 0xf6bb4b60); /* 39 */
HH(b, c, d, a, x[10], 23, 0xbebfbc70); /* 40 */
HH(a, b, c, d, x[13], 4, 0x289b7ec6); /* 41 */
HH(d, a, b, c, x[ 0], 11, 0xeaa127fa); /* 42 */
HH(c, d, a, b, x[ 3], 16, 0xd4ef3085); /* 43 */
HH(b, c, d, a, x[ 6], 23, 0x4881d05); /* 44 */
HH(a, b, c, d, x[ 9], 4, 0xd9d4d039); /* 45 */
HH(d, a, b, c, x[12], 11, 0xe6db99e5); /* 46 */
HH(c, d, a, b, x[15], 16, 0x1fa27cf8); /* 47 */
HH(b, c, d, a, x[ 2], 23, 0xc4ac5665); /* 48 */
/* Round 4 */
II(a, b, c, d, x[ 0], 6, 0xf4292244); /* 49 */
II(d, a, b, c, x[ 7], 10, 0x432aff97); /* 50 */
II(c, d, a, b, x[14], 15, 0xab9423a7); /* 51 */
II(b, c, d, a, x[ 5], 21, 0xfc93a039); /* 52 */
II(a, b, c, d, x[12], 6, 0x655b59c3); /* 53 */
II(d, a, b, c, x[ 3], 10, 0x8f0ccc92); /* 54 */
II(c, d, a, b, x[10], 15, 0xffeff47d); /* 55 */
II(b, c, d, a, x[ 1], 21, 0x85845dd1); /* 56 */
II(a, b, c, d, x[ 8], 6, 0x6fa87e4f); /* 57 */
II(d, a, b, c, x[15], 10, 0xfe2ce6e0); /* 58 */
II(c, d, a, b, x[ 6], 15, 0xa3014314); /* 59 */
II(b, c, d, a, x[13], 21, 0x4e0811a1); /* 60 */
II(a, b, c, d, x[ 4], 6, 0xf7537e82); /* 61 */
II(d, a, b, c, x[11], 10, 0xbd3af235); /* 62 */
II(c, d, a, b, x[ 2], 15, 0x2ad7d2bb); /* 63 */
II(b, c, d, a, x[ 9], 21, 0xeb86d391); /* 64 */
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
}
测试文件（test.c）：
#include <stdio.h>
#include <string.h>
#include "md5.h"
int main(void)
{
int i;
unsigned char encrypt[] = "FishC";
unsigned char decrypt[16];
MD5_CTX md5;
// 初始化
MD5Init(&md5);
// 传入明文字符串及其长度
MD5Update(&md5, encrypt, strlen((char *)encrypt));
// 得到加密后的字符串
MD5Final(&md5, decrypt);
for (i = 0; i < 16; i++)
{
printf("%02x", decrypt[i]);
}
putchar('\n');
return 0;
}
[知识点备忘] S1E40：高级宏定义
[课后作业] S1E40：高级宏定义 | 课后测试题及答案
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define MAXVAL 100 // 栈val的最大深度
void push(double); // 将f压入到值栈中
double pop(void); // 弹出并返回栈顶的值
int getch(void); // 从输入缓冲区取出一个字符
void ungetch(int); // 将字符送回缓冲区中
int getop(char s[]);
int sp = 0; // 栈指针，指向下一个空闲位置
double val[MAXVAL]; // 值栈
void push(double f)
{
if (sp < MAXVAL)
val[sp++] = f;
else
printf("错误：栈已满！\n", f);
}
double pop(void)
{
if (sp > 0)
return val[--sp];
else
{
printf("错误：栈已空！\n");
return 0.0;
}
}
#define BUFSIZE 100 // 缓冲区的最大尺寸
#define NUMBER '0'
char buf[BUFSIZE]; // 缓冲区
int bufp = 0; // 缓冲区指针，指向下一个空闲位置
int getch(void)
{
// 从从标准输入流中获取一个字符
// 如果buf缓冲区中有存在字符，先从buf中获取
return (bufp > 0) ? buf[--bufp] : getchar();
}
void ungetch(int c)
{
if (bufp >= BUFSIZE)
printf("错误：缓冲区已满！\n");
else
buf[bufp++] = c;
}
int getop(char s[])
{
int i, c;
while ((s[0] = c = getch()) == ' ' || c == '\t')
;
s[1] = '\0';
// 不是数，将其直接返回
if (!isdigit(c) && c != '.')
return c;
// 收集整数部分
i = 0;
if (isdigit(c))
while (isdigit(s[++i] = c = getch()))
;
// 收集小数部分
if (c == '.')
while (isdigit(s[++i] = c = getch()))
;
s[i] = '\0';
if (c != EOF)
ungetch(c);
return NUMBER;
}
#define MAXOP 100
int main(void)
{
int type;
double op2;
char s[MAXOP];
while ((type = getop(s)) != EOF)
{
switch (type)
{
case NUMBER:
push(atof(s));
break;
case '+':
push(pop() + pop());
break;
case '*':
push(pop() * pop());
break;
case '-':
op2 = pop();
push(pop() - op2);
break;
case '/':
op2 = pop();
if (op2 != 0.0)
push(pop() / op2);
else
printf("error: zero divisor\n");
break;
case '\n':
printf("\t%.8g\n", pop());
break;
default:
printf("error: unknown comand %s\n", s);
break;
}
}
return 0;
}
[知识点备忘] S1E41：内联函数和一些鲜为人知的技巧
286
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
