在其中指针使用的较少，能用数组都用数组，个人感觉数组可读性更高

数组输入

C99后才支持可变数组定义，虽然Matrix支持但是不便调试
需要动态分配数组

1
2
3
int *a=(int *)malloc(n*sizeof(int));//malloc不初始化数组
int *a=(int *)calloc(n,sizeof(int));//calloc初始化数组
double *a=(double *)calloc(n,sizeof(double));

一般输入不必封装为函数

交换函数

1
2
3
4
5
void Swap(int *x,int *y){
	int temp=*x;
	*x=*y;
	*y=*temp;
}

交换操作在排序中很常用
除了matrix中的头文件题用不了函数封装。。

最小最大函数

仅返回最值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int Min(int* a, int size) {
    int min = a[0];
    for (int i = 1; i < size; i++) {
        if (min > a[i]) {
            min = a[i];    
        }
    }
    return min;
}
int Max(int* a, int size) {
    int max = a[0];
    for (int i = 1; i < size; i++) {
        if (max > a[i]) {
            max= a[i];
        }
    }
    return max;
}

冒泡排序

时间复杂度：O(n^2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void BubbleSort(int* a,int size){
	int swap=0;
	do {
    swap = 0;
    for (int i = 0; i < n - 1; i++) {
        if (a[i] > a[i + 1]) {
            int temp = a[i + 1];
            a[i + 1] = a[i];
            a[i] = temp;
            swap = 1;
        }
        
    }
   
} while (swap == 1);
}

或者封装好（

1
2
3
4
5
6
7
8
9
10
11
12
13
void BubbleSort(int* a,int size){
	int swap=0;
	do {
    swap = 0;
    for (int i = 0; i < n - 1; i++) {
        if (a[i] > a[i + 1]) {
           Swap(&a[i],&a[i+1]);
        }
        
    }
   
} while (swap == 1);
}

如无特别需要，以后都用封装好的Swap函数

选择排序

时间复杂度：O(n^2)
不稳定的排序*

1
2
3
4
5
6
7
8
9
10
11
12
void SelectionSort(int* a, int n) {
    
    for (int k = 0; k < n-1; k++) {
        int p = k;
        for (int i = k+1; i < n; i++) {
            if (a[p] > a[i]) {
                p=i;   //仅更新索引，最后再换
            }
        }
        Swap(&a[p], &a[k]);
    }
}