常见排序算法代码实例

基本概念

时间复杂度：https://www.cnblogs.com/wonker/p/11236988.html

空间复杂度：https://www.cnblogs.com/wonker/p/11238418.html

稳定排序：假设序列中有两个值相等的元素，在排序后，如果这两个元素的相对前后位置没有发生改变，则是稳定排序。例如：int a = {11, 2, a, b,10};其中，a=b=3，排序后a = {2 ,a , b, 10, 11}，而不是a = {2 ,b , a, 10, 11}。

原地排序：在排序过程中不申请多余的存储空间，只利用原来存储待排数据的存储空间进行比较和交换。

排序算法

冒泡排序

C语言版本

int* bubble_sort(int* nums, int numsSize, int* returnSize)
{
    for (int i = 0; i < numsSize - 1; i++)
    {
        for (int j = 0; j < numsSize - 1 - i; j++)
        {
            if (nums[j] > nums[j + 1])
            {
                int temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
            }
        }
    }
    *returnSize = numsSize;
    return nums;
}

选择排序

C语言版本

void select_sort(int *nums, int numsSize)
{
    int min_index;

    for (int i = 0; i <numsSize; i++)
    {
        min_index = i;
        for (int j = i + 1; j <numsSize; j++)
        {
            if (nums[j] < nums[min_index])
            {
                min_index = j;
            }
        }
        swap(&nums[i], &nums[min_index]);
    }
}

插入排序

C语言版本

void insert_sort(int *nums, int numsSize)
{
    for (int i = 1; i < numsSize; i++)
    {
        if (nums[i] < nums[i - 1])
        {
            int j = i - 1;
            int tmp = nums[i];
            while (j >= 0 && nums[j] > tmp)
            {
                nums[j + 1] = nums[j];
                j--;
            }
            nums[j + 1] = tmp;
        }
    }
}

C++版本

vector<int> insert_sort(vector<int>& nums)
{
    int tmp;
    int j;
    int len = nums.size();
    for (int i = 1; i < len; i++)
    {
        if (nums[i] < nums[i - 1])
        {
            tmp = nums[i];
            j = i - 1;
            while (j >= 0 && nums[j] > tmp)
            {
                nums[j + 1] = nums[j];
                j--;
            }
            nums[j + 1] = tmp;
        }
    }

    return nums;
}
    

快速排序

C语言版本

void quick_sort(int *nums, int start, int end)
{
    if (start >= end)
    {
        return;
    }

    int left = start;
    int right = end;
    int pivot = nums[start];

    while (left < right)
    {
        while (left < right && nums[right] > pivot)
        {
            right--;
        }
        if (left < right)
        {
            nums[left++] = nums[right];
        }
    
        while (left < right && nums[left] < pivot)
        {
            left++;
        }
        if (left < right)
        {
            nums[right--] = nums[left];
        }
    }
    nums[left] = pivot;

    quick_sort(nums, start, left - 1);
    quick_sort(nums, left + 1, end);

}

C++版本

void quick_sort1(vector<int>& nums, int start, int end)
{
    if (start >= end)
    {
        return;
    }
    int left = start;
    int right = end;
    int pivot = nums[start];

    while (left < right)
    {
        while (left < right && nums[right] > pivot)
        {
            right--;
        }
        if (left < right)
        {
            nums[left++] = nums[right];
        }
        while (left < right && nums[left] < pivot)
        {
            left++;
        }
        if (left < right)
        {
            nums[right--] = nums[left];
        } 
    }
    nums[left] = pivot;
    quick_sort(nums, start, left - 1);
    quick_sort(nums, left + 1, end);
}

vector<int> quick_sort2(vector<int>& nums, int start, int end)
{
   int left = start;
   int right = end;
   int pivot_index = left + 5;
   int pivot = nums[pivot_index];

   while (left < right)
   {
       while (left < right && nums[right] >= pivot)
       {
           right--;
       }
       while (left < right && nums[left] <= pivot)
       {
           left++;
       }
       if (left < right)
       {
           swap(nums[left], nums[right]);
       }
   }
   swap(nums[left], nums[pivot_index]);
   quick_sort(nums, start, left - 1);
   quick_sort(nums, left + 1, end);
   return nums;
}

堆排序

C语言版本

void heapify(int *nums, int numsSize, int node)
{
    int c1 = node * 2 + 1;
    int c2 = node * 2 + 2;
    int max = node;

    if (c1 < numsSize && nums[c1] > nums[max])
    {
        max = c1;
    }
    if (c2 < numsSize && nums[c2] > nums[max])
    {
        max = c2;
    }
    if (max != node)
    {
        swap(&nums[max], &nums[node]);
        heapify(nums, numsSize, max);
    }
}

void build_heap(int *nums, int numsSize)
{
    int last_node = numsSize - 1;
    int last_parent = (last_node - 1) / 2;

    for (int i = last_parent; i >= 0; i--)
    {
        heapify(nums, numsSize, i);
    }
}

int *heap_sort(int *nums, int numsSize)
{
    
    build_heap(nums, numsSize);

    for (int i = numsSize - 1; i > 0; i--)
    {
        swap(&nums[0], &nums[i]);
        heapify(nums, i, 0);
    }

    return nums;
}

C++版本

    /*
     * 以下标为i的节点为根节点，把这一部分的节点构建成大顶堆
     * nums：需要构建的数组
     * length：数组需要排序的长度
     * 
     */
    void heapify(vector<int>& nums, int length, int i)
    {
        if (i >= length)
        {
            return;
        }
        int c1 = i * 2 + 1;
        int c2 = i * 2 + 2;
        int max = i;
        if (c1 < length && nums[c1] > nums[max])
        {
            max = c1;
        }
        if (c2 < length && nums[c2] > nums[max])
        {
            max = c2;
        }
        if (max != i)
        {
            swap(nums[i], nums[max]);
            heapify(nums, length, max);
        }
        
    }
    /*
     * 把数组构建成大顶堆
     * nums：需要构建的数组
     * length：数组长度
     */
    void build_heap(vector<int>& nums)
    {
        int length = nums.size();
        int last_node = length - 1;  //最后一个节点的下标
        int parent = (last_node - 1) / 2;  //最后一个节点的父节点的下标

        for (int i = parent; i >= 0; i--)
        {
            heapify(nums, length, i);
        }
    }
    vector<int> heap_sort(vector<int>& nums)
    {
        int i;
        int length = nums.size();

        build_heap(nums);
        for (int i = length - 1; i > 0; i--)
        {
            swap(nums[i], nums[0]);
            heapify(nums, i, 0);
        }

        return nums;
    }

希尔排序

C语言版本

int* shell_sort(int* nums, int numsSize)
{
    int max_index = numsSize - 1;
    for (int gap = max_index / 2; gap > 0; gap /= 2)
    {
        for (int i = gap; i < max_index; i++)
        {
            for (int j = i - gap; j >= 0; j -= gap)
            {
                if (nums[j] > nums[j + gap])
                {
                    swap(&nums[j], &nums[j + gap]);
                }
            }
        }
    }

    return nums;
}

C++版本

vector<int> shell_sort(vector<int>& nums)
 {
     int numsSize = nums.size();

     for (int gap = numsSize / 2; gap > 0; gap /= 2)
     {
         for (int i = gap; i < numsSize; i++)
         {
             for (int j = i - gap; j >= 0; j -= gap)
             {
                 if (nums[j] > nums[j + gap])
                 {
                     swap(nums[j], nums[j + gap]);
                 }
             }
         }
     }

     return nums;
 }