排序

选择排序算法

void select_sort(int arr[], size_t len)
{
    for (int i = 0; i < len - 1; i++)
    {
        for (int j = i + 1; j < len;j++)
        {
            if (arr[i]>arr[j])
            {
                int tempVal = arr[i];
                arr[i] = arr[j];
                arr[j] = tempVal;
            }
        }
    }
}

冒泡排序算法

void bubble_sort(int arr[], size_t len)
{
    for (int i = 0; i < len-1;i++)
    {
        for (int j = 0; j < len - 1 - i;j++)
        {
            if (arr[j]>arr[j+1])
            {
                int tempVal = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tempVal;
            }
        }
    }
}

插入排序算法优化过程

void insert_sort1(int arr[], size_t len)
{
    int tempVal;
    for (int i = 1; i < len; ++i)//确定插入过程中需要插入元素的下标i
    {
        for (int j = i - 1; j>=0; j--)//j为已序序列最后一个元素的下标
        {
            if (arr[j+1] < arr[j])//如果插入的元素和最后一个元素进行判断
            {
                tempVal = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = tempVal;
            }
            else
                break;
        }
    }

}

void insert_sort2(int arr[], size_t len)
{
    int tempVal,j;
    for (int i = 1; i < len;++i)//确定插入过程中需要插入元素的下标i
    {
        tempVal = arr[i];//保存一下待插入的元素值
        for (j = i - 1; j>=0;j--)//j为已序序列最后一个元素的下标
        {
            if (tempVal<arr[j])//如果插入的元素和最后一个元素进行判断
            {
                arr[j + 1] = arr[j];
            }
            else
                break;
        }
        arr[j + 1] = tempVal;//把保存的元素放在对应的位置
    }

}

void insert_sort3(int arr[], size_t len)
{
    int tempVal, j;
    for (int i = 1; i < len; ++i)//确定插入过程中需要插入元素的下标i
    {
        tempVal = arr[i];//保存一下待插入的元素值
        for (j = i - 1; j >= 0 && tempVal < arr[j]; j--)//j为已序序列最后一个元素的下标
        {
            arr[j + 1] = arr[j];
        }
        arr[j + 1] = tempVal;//把保存的元素放在对应的位置
    }
}

void insert_sort(int arr[], size_t len)
{
    int tempVal, j;
    for (int i = 1; i < len; ++i)//确定插入过程中需要插入元素的下标i
    {
        tempVal = arr[i];//保存一下待插入的元素值
        j = i - 1;
        while( j >= 0 && tempVal < arr[j])//j为已序序列最后一个元素的下标
        {
            arr[j + 1] = arr[j]; 
            j--;
        }
        arr[j + 1] = tempVal;//把保存的元素放在对应的位置
    }

}

希尔排序（插入排序的优化）

void shell_sort(int arr[], size_t len)
{
    int tempVal, j;
    int jump = len >> 1;
    while (jump != 0)
    {
        for (int i = jump; i < len; ++i)//确定插入过程中需要插入元素的下标i
        {
            tempVal = arr[i];//保存一下待插入的元素值
            j = i - jump;
            while (j >= 0 && tempVal < arr[j])//j为已序序列最后一个元素的下标
            {
                arr[j + 1] = arr[j];
                j-=jump;
            }
            arr[j + jump] = tempVal;//把保存的元素放在对应的位置
        }
        jump >>= 1;
    }
}

桶排序（时间最快 空间最大的排序）

void radix_sort(int arr[],size_t len)//桶排序
{
    int temp[10][10] = {};
    for (int n = 1; n < 1000;n*=10)
    {
        for (int x = 0; x < 10;x++)
        {
            for (int y = 0; y < 10;++y)
            {
                temp[x][y] = -1;//不一定是-1
            }

        }
        for (int i = 0; i < len;++i)
        {
            int tempIndex = (arr[i] / n) % 10;
            temp[tempIndex][i] = arr[i];
        }
        int k = 0;
        for (int x = 0; x < 10; x++)
        {
            for (int y = 0; y < 10; ++y)
            {
                if (temp[x][y] != -1)
                {
                    arr[k++] = temp[x][y];
                }
            }
        }

    }

}

归并排序（递归 合并）

void _merge_in_arr(int arr[], int left, int mid, int right)//处理合并
{
    //准备一个辅助数组
    int length = right - left + 1;//表示辅助数组长度
    int *pData = new int[length];//分配动态内存 保存数据
    //memset内存逐字节赋值 第一个参数是哪个内存 第二个参数赋什么值，第三个参数这个内存需要赋多大内存
    memset(pData, 0, sizeof(int)* length);
    //合并
    int low = left;//定义一个变量接一下左边第一个下标位置
    int hig = mid + 1;//定义一个变量接一下右边区域的第一个赋值
    int index = 0;//给辅助数组遍历的下标
    while (hig<=right&&low<=mid)//左右区间都有数据 都没比较结束
    {
        while (low <= mid&&arr[low] <= arr[hig])//左边区间没有越界 并且左区间的数值<=右区间的数值
        {
            pData[index++] = arr[low++];
        }
        while (hig <= right&&arr[low] > arr[hig])//右边区间没有越界 并且右区间的数值>右区间的数值
        {
            pData[index++] = arr[hig++];
        }
    }
    //到这一步，证明起码有一个区间是合并进了辅助数组
    if (hig<=right)//证明右区间并没有完成合并，左区间是完成合并 把右区间剩下的数据直接拷贝到辅助数组即可
        memcpy(&pData[index],&arr[hig],sizeof(int)*(right-hig+1));//内存拷贝有三个参数 表示把第二个参数的首地址拷贝到第一个参数的首地址里面 拷贝大小为第三个参数大小
    if (low <= mid)
        memcpy(&pData[index], &arr[low], sizeof(int)*(mid - low + 1));
    memcpy(&arr[left], pData, sizeof(int)* length);
    delete[] pData;
}
void _merge(int arr[], int left, int right)//通过递归把数组拆成两个部分
{
    if (left >= right)//当左右下标一致时 区间内只有一个元素 不用再拆分
        return;
    //int mid = (right - left) >> 1;
    int mid = ((right - left) >> 1) + left;
    _merge(arr, left, mid);//递归左区间
    _merge(arr, mid + 1, right);//递归右区间
    //合并操作
    _merge_in_arr(arr, left, mid, right);
}
void merge_sort(int arr[], size_t len)
{
    _merge(arr, 0, len-1);
}

快速排序

void quick_sort(int arr[], int low, int hight)
{
    int t = arr[low];//确定标杆的值
    int f = low + 1;//表示指的数应该比标杆小
    int b = hight;//表示指的数应该比标杆大
    if (low >= hight)return;//表示只有一个元素 无需定位
    int tempVal;
    while (f<=b)//表示待定位的区间是存在的
    {
        while (f<=b)
        {
            while (f <= b&&arr[f] <= t) f++;//一直找标杆大的元素
            while (f <= b&&arr[b] >= t) b--;//一直找比标杆小的元素
            if (f<b)//定位区间没有搜索完成
            {
                tempVal = arr[f];
                arr[f] = arr[b];
                arr[b] = tempVal;
                f++;
                b--;
            }
        }
        arr[low] = arr[b];
        arr[b] = t;
        quick_sort(arr, low, b - 1);
        quick_sort(arr,b+1,hight);

         
    }
}

二分查找

int binarySeaarch(int arr[], int low, int hight, int findVal)
{
    int mid = 0;//表示中间下标
    while (low <= hight)//表示区间存在
    {
        mid = ((hight - low) >> 1) + low;
        if (findVal == arr[mid])
            return mid;
        if (findVal < arr[mid])
            hight = mid - 1;
        if (findVal > arr[mid])
            low = mid + 1;
    }
    return -1;
}

 输出函数

void printArr(int arr[], int len)
{
    for (int i = 0; i < len;++i)
    {
        printf("%d     ", arr[i]);
    }
    printf("
//===========================
");
}

主函数

int main()
{
    srand((size_t)time(nullptr));
    int arr[LEN];
    int arr1[LEN]; 
    int arr2[LEN];
    int arr3[LEN];
    int arr4[LEN];
    int arr5[LEN]; 
    int arr6[LEN];
    int arr7[LEN];
    for (int i = 0; i < LEN;i++)
    {
        arr[i] = rand() % 900+100;
        arr1[i] = arr[i];
        arr2[i] = arr[i];
        arr3[i] = arr[i];
        arr4[i] = arr[i];
        arr5[i] = arr[i];
        arr6[i] = arr[i];
        arr7[i] = arr[i]; 
    }
    printArr(arr, LEN);
    select_sort(arr, LEN);
    printArr(arr, LEN);
    bubble_sort(arr1, LEN);
    printArr(arr1, LEN);
    insert_sort(arr2, LEN);
    printArr(arr2, LEN);
    shell_sort(arr3, LEN);
    printArr(arr3, LEN);
    radix_sort(arr4, LEN);
    printArr(arr4, LEN);
    insert_sort1(arr5, LEN);
    printArr(arr5, LEN);
    int ar[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    printf("%d
", binarySeaarch(ar, 0, 9, 10));
    merge_sort(arr7, LEN);
    printArr(arr7, LEN);
    cin.get();
    return 0;
}