面试：排序算法代码实现

目录

• 冒泡排序
• 插入排序
• 希尔排序
• 选择排序
• 堆排序
• 归并排序
• 快速排序

冒泡排序

/*====================冒泡排序=======================*/
void bubble_sort(int nums[], int n)
{
    for (int i = 0; i < n; i++)
    {
        bool has_swapped = false;
        int j = n - 1;
        while (j - 1 >= i)
        {
            if (nums[j - 1] > nums[j])
            {
                swap(nums[j - 1], nums[j]);
                has_swapped = true;
            }
            j--;
        }
        if (!has_swapped)
            break;
    }
}

插入排序

/*==================插入排序=========================*/
void insert_sort(int nums[], int n)
{
    for (int i = 1; i < n; i++)
    {
        int temp = nums[i];
        int j = i;
        while (j - 1 >= 0)
        {
            if (nums[j - 1] > nums[j])
            {
                nums[j] = nums[j - 1];
                j--;
            }
            else
                break;
        }
        nums[j] = temp;
    }
}

希尔排序

/*======================希尔排序==================================*/
void shell_sort(int nums[], int n)
{
    for (int increment = n / 2; increment > 0; increment /= 2)
    {
        for (int i = increment; i < n; i++)
        {
            int temp = nums[i];
            int j = i;
            while (j - increment >= 0)
            {
                if (nums[j - increment] > nums[j])
                {
                    nums[j] = nums[j - increment];
                    j -= increment;
                }
                else
                    break;
            }
            nums[j] = temp;
        }
    }
}

选择排序

/*================选择排序=============================*/
int find_index_of_min(int nums[], int start, int end);
void select_sort(int nums[], int n)
{
    for (int i = 0; i < n; i++)
    {
        int indexOfMin = find_index_of_min(nums, i, n - 1);
        swap(nums[indexOfMin], nums[i]);
    }
}

堆排序

/*================堆排序==========================*/
void perc_down(int nums[], int index, int end)
{
    int temp = nums[index];
    int parent = index;
    while (2 * parent + 1 < end)
    {
        int next = 2 * parent + 1;
        if (next + 1 < end && nums[next + 1] > nums[next])
            next++;
        if (nums[next] > temp)
        {
            nums[parent] = nums[next];
            parent = next;
        }
        else
            break;
    }
    nums[parent] = temp;
}

void heap_sort(int nums[], int n)
{
    //在原数组上建立最大堆
    for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    {
        perc_down(nums, i, n);
    }

    for (int i = n - 1; i >= 0; i--)
    {

        //依次从最大堆中取出最大元素放到原数组正确的位置上
        swap(nums[0], nums[i]);
        //调整最大堆
        perc_down(nums, 0, i);
    }
}

归并排序

• 递归实现：

/*===============================归并排序============================*/
void merge(int nums[], int temp[], int start, int end_1, int end_2)
{
    int i = start;
    int j = end_1 + 1;
    int k = start;

    while (i <= end_1 && j <= end_2)
    {
        if (nums[i] <= nums[j])
        {
            temp[k] = nums[i];
            i++;
            k++;
        }
        else
        {
            temp[k] = nums[j];
            j++;
            k++;
        }
    }
    while (i <= end_1)
    {
        temp[k] = nums[i];
        i++;
        k++;
    }
    while (j <= end_2)
    {
        temp[k] = nums[j];
        j++;
        k++;
    }

    for (int index = start; index <= end_2; index++)
        nums[index] = temp[index];
}

void merge_sort_core(int nums[], int temp[], int start, int end)
{
    if (start >= end)
        return;
    int mid = start + (end - start) / 2;
    merge_sort_core(nums, temp, start, mid);
    merge_sort_core(nums, temp, mid + 1, end);
    merge(nums, temp, start, mid, end);
}

void merge_sort(int nums[], int n)
{
    int *temp = new int[n];
    merge_sort_core(nums, temp, 0, n - 1);
    delete[] temp;
}

• 非递归循环实现：

void merge(int nums[], int temp[], int start, int end_1, int end_2)
{
    int i = start;
    int j = end_1 + 1;
    int k = start;
    while (i <= end_1 && j <= end_2)
    {
        if (nums[i] <= nums[j])
        {
            temp[k] = nums[i];
            i++;
            k++;
        }
        else
        {
            temp[k] = nums[j];
            j++;
            k++;
        }
    }
    while (i <= end_1)
    {
        temp[k] = nums[i];
        i++;
        k++;
    }
    while (j <= end_2)
    {
        temp[k] = nums[j];
        j++;
        k++;
    }
}

void merge_pass(int nums[], int temp[], int n, int length)
{
    int i = 0;
    for (; i + 2 * length - 1 < n; i += 2 * length)
        merge(nums, temp, i, i + length - 1, i + 2 * length - 1);
    if (i + length < n)
        merge(nums, temp, i, i + length - 1, n - 1);
    else
    {
        for (; i < n; i++)
            temp[i] = nums[i];
    }
}

void merge_sort(int nums[], int n)
{
    int *temp = new int[n];
    int length = 1;
    while (length < n)
    {
        merge_pass(nums, temp, n, length);
        length *= 2;
        merge_pass(temp, nums, n, length);
        length *= 2;
    }
    delete[] temp;
}

快速排序

/*================快速排序==============*/
void quick_sort_core(int nums[], int start, int end)
{
    if (start >= end)
        return;
    int pivot = nums[end];
    int i = start - 1, j = end;
    while (true)
    {
        while (nums[++i] < pivot)
        {
            if (i == end)
                break;
        }
        while (nums[--j] > pivot)
        {
            if (j == start)
                break;
        }
        if (i < j)
            swap(nums[i], nums[j]);
        else
            break;
    }
    swap(nums[end], nums[i]);
    quick_sort_core(nums, start, i - 1);
    quick_sort_core(nums, i + 1, end);
}

void quick_sort(int nums[], int n)
{
    quick_sort_core(nums, 0, n - 1);
}