//冒泡 每次会确定一个数字的最终位置
void sort_bubble(int *a){
    int i,j;
    for(i=n-1;i>0;i--){
        for(j=0;j<i;j++){
            if(a[j]>a[j+1]){//改成<变成递减
                swap(a[j],a[j+1]);
            }
        }
    }
}

//选择排序 一次循环找到一个当前未排序序列的最大（最小）值，放到队列首位（或末尾）
void sort_select(int *a){
    int i,j,min_pos;
    for(i=0;i<n-1;i++){
        min_pos=i;
        for(j=i+1;j<n;j++){//找未排序序列最小值
            if(a[min_pos]>a[j]){
                min_pos=j;
            }
        }
        swap(a[i],a[min_pos]);
    }
}

//插入排序，类比打扑克洗牌，注意把未排序数字插入合适位置
void sort_insert(int *a){
    int i,j,k,insert_val;
    for(i=1;i<n;i++){
        for(j=0;j<i;j++){
            if(a[i]<a[j]){
                insert_val=a[i];
                for(k=i-1;k>=j;k--){//元素后移
                    a[k+1]=a[k];
                }
                a[j]=insert_val;
                break;
            }
        }
    }
}

//快速排序 以一个数为锚点分为两部分，递归到每组一个元素
int partition(int *a,int left,int right){//以该部分数组最后一个数为锚点
    int i,k=left;
    for(i=left;i<right;i++){
        if(a[i]<a[right]){
            swap(a[k],a[i]);
            k++;
        }
    }
    swap(a[right],a[k]);
    return k;
}
int sort_quick(int *a,int left,int right){
    int pivot;
    if(left<right){
        pivot=partition(a,left,right);
        sort_quick(a,left,pivot-1);
        sort_quick(a,pivot,right);
    }
}

//堆排
void heap_max(int *a,int start,int end){
    int dad=start;
    int son=2*dad+1;
    while(son<end){
        if(son+1<end&&a[son]<a[son+1]) son++;
        if(a[dad]<a[son]){
            swap(a[dad],a[son]);
            dad=son;
            son=dad*2+1;
        }
    }
}
void arr_heap(int *a){
    int i;
    for(i=n/2-1;i>0;i--){
        heap_max(a,i,n);
    }
    swap(a[0],a[n-1]);//把最大值放到最后
    for(i=N-1;i>1;i--){//由于除了根节点，其他节点都没有改变，所以只需要对根节点进行一个排序即可
        heap_max(a,0,i);
        swap(a[0],a[i-1]);
    }
}

//malloc C里没有new
char* t=(char*)malloc(n*sizeof(char));
free(t);
//二维数组传参用指针，必须要写列数
void print(int p[][4],int row){
    int i,j;
    for(i=0;i<row;i++){
        for(j=0;j<sizeof(*p)/sizeof(int);j++){
            printf("%d",p[i][j]);
        }
        printf("\n");
    }
}

//二级指针实现数据排序，不改变源数据
#include<stdio.h>
#include<stdlib.h>
#inclued<string.h>

void print(char **p){ //char *p[]
    for(int i=0;i<5;i++){
        puts(p[i]);
    }
}

int main(){
    char *p[5];
    char b[5][10]={"l","w","hh","mm","tt"};
    int i,j,tmp;
    char *t;
    char **p2;
    for(i=0;i<5;i++){
        p[i]=b[i];
    }
    for(i=4;i>0;i--){
        for(j=0;j<i;j++){
            if(strcmp(p2[j],p2[j+1])==1){
                t=p2[j];
                p2[j]=p2[j+1];
                p2[j+1]=t;
            }
        }
    }
    print(p2);
    for(i=0;i<5;i++){
        puts(b[i]);
    }
}

//函数指针
#include<stdio.h>
#include<stdlib.h>

void b(){
    printf("fun b\n");
}

void a(void (*p)()){
    p();
}

int main(){
    void (*p)();//函数指针
    p=b;
    a(p);//相当于执行p函数
    return 0;
}

extern int k;//借用main.c文件的全局变量k
static int i;//只能在本文件中使用，static也可以修饰函数

//递归 Hanoi
void hanoi(int n,int a,int b,int c){
    if(n==1) printf("%c->%c\n",a,c);
    else{
        hanoi(n-1,a,c,b); //把n-1个盘子从a通过c移动到b
        printf("%c->%c\n",a,c);//把a的最后一个盘子移动c
        hanoi(n-1,b,a,c);//把n-1个盘子从b通过a移动到c
    }
}