排序算法加二分查找一次满足

选择，冒泡，插入，归并，希尔，快排六大排序算法一次满足。

二分查找也写出来了。

顺便实现了查看排序算法效率的功能。

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

#define MAX(a,b) (((a)>(b))?(a):(b))

// 选择排序时间复杂度n^2
void ChooseSort(int* arrays, int len)
{
    int i, j;
    for (i = 0;i < len;i++)
    {
        int min=i;
        for (j = i + 1;j < len;j++)
        {
            if (arrays[j] < arrays[min])min = j;
        }
        int temp = arrays[i];
        arrays[i] = arrays[min];
        arrays[min] = temp;
    }
}

// 单边冒泡排序，对于只能比较相邻两边的情况有奇效
void UnilateralBubbleSort(int* arrays, int len)
{
    int i, j;
    char isExit = 0;
    for (i = 0;i < len;i++)
    {
        j = 0;
        isExit = 1;
        while (j < len - 1 - i)
        {
            if (arrays[j] > arrays[j + 1])
            {
                isExit = 0;
                int temp = arrays[j];
                arrays[j] = arrays[j + 1];
                arrays[j + 1] = temp;
            }
            j++;
        }
        if (isExit)break;
    }
}

// 双边冒泡排序，略快于单边冒泡排序
void BilateralBubbleSort(int* arrays, int len)
{
    int right = len - 1, left = 0;
    int i, j;
    char flag = 0;
    char isExit = 0;
    while (left < right)
    {
        isExit = 1;
        if (!flag)
        {
            i = left;
            while (i < right)
            {
                if (arrays[i] > arrays[i + 1])
                {
                    isExit = 0;
                    int temp = arrays[i];
                    arrays[i] = arrays[i + 1];
                    arrays[i + 1] = temp;
                }
                i++;
            }
            right--;
            flag = !flag;
        }
        else
        {
            j = right;
            while (j > left)
            {
                if (arrays[j] < arrays[j - 1])
                {
                    isExit = 0;
                    int temp = arrays[j];
                    arrays[j] = arrays[j - 1];
                    arrays[j - 1] = temp;
                }
                j--;
            }
            left++;
            flag = !flag;
        }
        if (isExit)break;
    }
}

// 插入排序
void InsertSort(int* arrays, int len)
{
    int i;
    for (i = 1;i < len;i++)
    {
        int j = i;
        while (j > 0 && arrays[j] < arrays[j - 1])
        {
            int temp = arrays[j];
            arrays[j] = arrays[j - 1];
            arrays[j - 1] = temp;
            j--;
        }
    }
}

// 归并排序递归版
void MergeSort(int* arrays, int len)
{
    // 归并排序用到分治法的思想，2,2,4,4,8,8，比如说找到16个球里的一个坏球，坏球较轻，4,4,2,2,1,1再1,1就能找到了
    // 这个排序呢我不太熟，就到这种程度
    if (len == 0 || len == 1)return;
    MergeSort(arrays, len >> 1);
    MergeSort(arrays + (len >> 1), len-(len >> 1));
    int i, j, index;
    int* temp = (int*)malloc(sizeof(int) * len);
    for (i = 0, j = len >> 1, index = 0;index < len;)
    {
        if (arrays[i] > arrays[j])
        {
            temp[index++] = arrays[j++];
            if (j == len)for (;i < (len>>1);i++)temp[index++] = arrays[i];
        }
        else
        {
            temp[index++] = arrays[i++];
            if (i == (len >> 1))for (;j < len;j++)temp[index++] = arrays[j];
        }
    }
    for (i = 0;i < index;i++)arrays[i] = temp[i];
    free(temp);
}

void ShellSort(int* arrays, int len)
{
    // 希尔排序是升级版插入排序，根据不同的步长事先排序一下
    int k, i;
    for (k = len << 1;k > 0;k--)
    {
        for (i = k;i < len;i+=k)
        {
            int j = i;
            while (j >= k && arrays[j] < arrays[j - k])
            {
                int temp = arrays[j];
                arrays[j] = arrays[j - k];
                arrays[j - k] = temp;
                j -= k;
            }
        }
    }
}

int QuickSort(int* arrays, int len)
{
    // 所有比第一个数大的放右边，比第一个数小的放左边
    // 具体操作是从右往左找，找到比目标数X，也就是比第一个数，小的数，把这个比较小的数放到目标数的位置上，
    // 记录下这个比较小的数的下标，目标数的下标变为这个比较小的数的下标，
    // 接着从比较小的数目前的下标开始从左往右找，找到比目标数大的数，将这个比较大的数放到目标数的位置上，
    // 记录下这个比较大的数的下标，目标数的下标变为这个比较大的数的下标，再从右往左找。
    // 找完后对左右递归各排一次
    if (len <= 1)return 1;
    int left = 0, right = len - 1;
    int X = arrays[left];
    char flag = 0;
    while (left < right)
    {
        if (!flag && arrays[right] < X)
        {
            arrays[left] = arrays[right];
            flag = !flag;
        }
        else if (flag && arrays[left] > X)
        {
            arrays[right] = arrays[left];
            flag = !flag;
        }
        if (flag)left++;
        else right--;
    }
    arrays[left] = X;    // 此时left=right
    QuickSort(arrays, left);
    QuickSort(arrays + left + 1, len - left - 1);
    return 0;
}

// 二分查找
int GetIndex(int* arr, int len,int val)
{
    int left = 0, right = len - 1;
    int mid;
    while (left < right)
    {
        mid = MAX(((right - left) >> 1),1);
        if (arr[left + mid] > val)right -= mid;
        else if (arr[left + mid] < val)left += mid;
        else return left + mid;
    }
    return -1;
}

void InitArray(int* arr,int len)
{
    if (arr == NULL)return;
    int i;
    for (i = 0;i < len;i++)arr[i] = rand() % len;
}

void PrintArray(int* arr, int len)
{
    if (arr == NULL)return;
    int i;
    for (i = 0;i < len;i++)printf("%d\t", arr[i]);
}

void DealSort(void(*p)(int*, int), int maxlen,int* arr, char IsShowTime)
{
    InitArray(arr, maxlen);
    if (!IsShowTime)
    {
        PrintArray(arr, maxlen);
        printf("\n");
        p(arr, maxlen);
        PrintArray(arr, maxlen);
    }
    else
    {
        clock_t now = clock();
        p(arr, maxlen);
        printf("%d\n", clock() - now);
    }
    printf("\n");
}

int main()
{
    int maxlen = 100;
    char isShowTime = 0;

    srand((unsigned int)time(NULL));
    int* arr = (int*)malloc(sizeof(int) * maxlen);

    DealSort(ChooseSort, maxlen, arr,isShowTime);

    DealSort(UnilateralBubbleSort, maxlen, arr, isShowTime);

    DealSort(BilateralBubbleSort, maxlen, arr, isShowTime);

    DealSort(InsertSort, maxlen, arr, isShowTime);

    DealSort(MergeSort, maxlen, arr, isShowTime);

    DealSort(ShellSort, maxlen, arr, isShowTime);

    DealSort(QuickSort, maxlen, arr, isShowTime);

    printf("%d\n", GetIndex(arr, maxlen, 72));

    free(arr);
    return 0;
}

代码纯c，主要是课开的傻逼，只能用纯c写写，用c++我造的轮子至少看起来更好用一点，这个就只能搞整数了，无聊透顶。