16 冒泡，选择，交换，逆置

冒泡排序（沉石排序）

每一轮，两两比较，如果左边大于右边，则交换（升序）
轮数 == 个数-1

//稳定性；两个相等的值A和A~，如果排序开始前A再A~前，排序后A还在A~前，则算法稳定
//怎么判断是否稳定？看算法中是否有跳跃交换
//时间复杂度O(n^2)  空间复杂度O(1)  稳定性：稳定
//缺点：时间复杂度大  优点：实现简单，稳定
void BubbleSort(int *arr, int len)
{
    //assert
    
    for(int i = 0; i<len-1; i++)//控制轮数
    {
        for(int j = 0; j < len - 1 - i;j++)//控制每一轮比较的次数
        {
            if(arr[i] >arr[j+1])
            {
                int tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j+1] = tmp;
            }
        }
    }
}

void Show(int *arr,int len)
{
    for(int i = 0; i< len;i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

简单选择排序（选择排序）（升序）

每一轮从待排序列中找到最小值和待排序序列的第一个值交换

找的是最小值的下标而不是本身
轮数 == 个数-1

//时间复杂度O(n^2)  空间复杂度O(1)  稳定性：不稳定
void SelectSort(int *arr, int len)
{
    //assert
    
    int minindex;//保存最小值的下标
    for(int i = 0; i<len-1; i++)//控制轮数
    {
        minindex = i;
        for(int j = i+1; j < len;j++)//找到这一轮待排序序列的最小值的下标
        {
          if(arr[j] < arr[minindex])
          {
              minindex = j;
          }
        }
        //第二层for循环执行结束，可以确定待排序序列中最小值的下标，保存再minindex里
        if(i != minindex)
        {
            int tmp = arr[minindex];
            arr[minindex] = arr[i];
            arr[i] = tmp;
        }
    }
}

交换函数

void Swap(int *a, int *b)
{
    int tmp = *a;
    *b = *a;
    *a = tmp;
}

//只要不借助第三方变量，逆置中数组为偶数个元素时会出bug
void Swap1(int *a, int *b)
{
    *a = *a + *b;
    *b = *a - *b;
    *a = *a - *b;
}

void Swap2(int *a, int *b)
{
    *a = *a ^ *b;
    *b = *a ^ *b;
    *a = *a ^ *b;
}

逆置函数

void Reverse(int *arr, int len)
{
    int i = 0;
    int j = len - 1;
    
    while(i<j)
    {
        Swap(&arr[i], &arr[j]);
        i++;
        j--;
    }
}