【B战王卓】-数据结构与算法基础-排序

排序概述

插入排序

• 直接插入排序
• 采用顺序查找法查找插入位置

	// 直接插入排序
	//顺序表查找法插入位置
    void InsertSort(vector<int> &nums)
    {
        int temp;
        for (int i = 1; i < nums.size(); i++)
        {
            temp = nums[i];
            int j = i - 1;
            for (; j >= 0 && temp < nums[j]; j--)
            {
                nums[j + 1] = nums[j]; // 元素后移
            }
            nums[j + 1] = temp;
        }
    }

• 折半插入排序

    // 折半查找插入排序
    void BinsertSort(vector<int> &nums)
    {
        for (int i = 1; i < nums.size(); ++i)
        {
            int temp = nums[i]; // 哨兵位
            int low = 0, high = i - 1;
            while (low <= high)
            {
                int mid = (low + high) / 2;
                if (temp < nums[mid])
                {
                    high = mid - 1;
                }
                else
                {
                    low = mid + 1;
                }
            }
            // 这个排序的根本思想，是将折半排序的比较区间，逐渐缩小到最大的小于等于哨兵元素的那个元素的位置
            // 然后这个位置再加1，就是此元素应该插入的位置
            for (int j = i - 1; j >= high + 1; --j)
            {
                nums[j + 1] = nums[j];
            }
            nums[high + 1] = temp;
        }
    }

• 希尔排序
• 一种不稳定的排序算法

 // 希尔排序
    void ShellSort(vector<int> &nums, int n)
    {
        int temp;
        for (int i = n; i < nums.size(); i++)
        {
            temp = nums[i];
            int j;
            for (j = i - n; j >= 0 && (temp < nums[j]); j = j - n)
            {
                nums[j + n] = nums[j];
            }
            nums[j + n] = temp;
        }
    }

交换排序

• 冒泡排序

• n个元素比较n-1趟，其中每一趟比较n-m

    // 冒泡排序
    void BubbleSort(vector<int> &nums)
    {
        int i, j;
        int n = nums.size();
        for (int i = 0; i < n - 1; i++)
        {
            for (int j = 0; j < n - i - 1; j++)
            {
                if (nums[j] > nums[j + 1])
                {
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
    }

• 冒泡排序的改进

    // 冒泡排序的改进
    void BubbleSort1(vector<int> &nums)
    {
        int temp;
        int flag = 1;
        int j = nums.size() - 1;
        while (flag)
        {
            flag = 0;
            for (int i = 1; i <= j; i++)
            {
                if (nums[i - 1] > nums[i])
                {
                    temp = nums[i];
                    nums[i] = nums[i - 1];
                    nums[i - 1] = temp;
                    flag = 1;
                }
            }
            j--;
        }
    }

• 快速排序

    // 快速排序
    void QuickSort(vector<int> &nums, int start, int end)
    {
        if (start >= end)
        {
            return;
        }
        int left = start;
        int right = end;
        int temp = nums[left];
        while (left < right)
        {
            while (left < right && nums[right] > temp)
                right--;
            nums[left] = nums[right];
            while (left < right && nums[left] < temp)
                left++;
            nums[right] = nums[left];
        }
        nums[left] = temp; // 中心点位置
        QuickSort(nums, start, left - 1);
        QuickSort(nums, left + 1, end);
    }

选择排序

• 简单选择排序

// 选择排序
    void SelectSort(vector<int> &nums)
    {
        int min;
        int temp;
        for (int i = 0; i < nums.size() - 1; i++)
        {
            min = i;
            for (int j = i + 1; j < nums.size(); j++)
            {
                if (nums[min] > nums[j])
                    min = j;
            }
            temp = nums[i];
            nums[i] = nums[min];
            nums[min] = temp;
        }
    }

• 堆排序
• 堆，一种完全二叉树，但是父节点的数据大于左右孩子结点的数据，称为大根堆，反之，小根堆。

归并排序

    // 归并排序
    void MergeSort(vector<int> &nums, int left, int right)
    {
        if (left < right)
        {
            int mid = left + (right - left) / 2;
            MergeSort(nums, left, mid);
            MergeSort(nums, mid + 1, right);
            Merge(nums, left, right);
        }
        return;
    }
    void Merge(vector<int> &nums, int left, int right)
    {
        vector<int> temp(nums.size());
        int mid = left + (right - left) / 2;
        int p = left;
        int q = mid + 1;
        int k = left;
        while (p <= mid && q <= right)
        {
            if (nums[p] < nums[q])
                temp[k++] = nums[p++];
            else
                temp[k++] = nums[q++];
        }
        while (p <= mid)
            temp[k++] = nums[p++];
        while (q <= right)
            temp[k++] = nums[q++];
        for (int i = left; i <= right; i++)
        {
            nums[i] = temp[i];
        }
    }

基数排序

    // 基数排序
    void jishusort(vector<int> &nums, int d)
    {
        int p = 1;
        int n = nums.size();
        vector<vector<int>> buckets(10, vector<int>(n));
        vector<int> order(10);

        while (p < d)
        {
            for (int num : nums)
            {
                int index = num / p % 10;
                buckets[index][order[index]] = num;
                order[index]++;
            }
            int k = 0;
            for (int i = 0; i < 10; i++)
            {
                if (order[i] == 0)
                    continue;
                for (int j = 0; j < order[i]; j++)
                {
                    nums[k] = buckets[i][j];
                    k++;
                }
                order[i] = 0;
            }
            p *= 10;
        }
    }

各种排序比较