排序集合大全

排序算法

    vector<int> sortArray(vector<int>& nums) {
        // for(int i = 0;i<nums.size();i++)
        // {
        //     bool flag = false;
        //     for(int j = i;j<nums.size();j++)
        //     {
        //         if(nums[i]>nums[j])
        //         {
        //             swap(nums[i],nums[j]);
        //             flag = true;
        //         }
        //     }
        //     if(!flag)
        //     {
        //         break;
        //     }
        // }

        //选择排序
        // for(int i = 0;i<nums.size();i++)
        // {
        //     int min1 = i;
        //     int m = nums[i];
        //     for(int j = i;j<nums.size();j++)
        //     {
        //         if(nums[j]<m)
        //         {
        //             m = nums[j];
        //             min1 = j;
        //         }
        //     }
        //     swap(nums[i],nums[min1]);
        // }
        //插入排序
        // for(int i = 1;i<nums.size();i++)
        // {
        //     int j = i -1;
        //     int key = nums[i];
        //     while(j>=0&&key<nums[j])
        //     {
        //         nums[j+1] = nums[j];
        //         j--;
        //     }
        //     nums[j+1] = key;
        // }
        //希尔排序
        // for(int gap = nums.size();gap>0;gap/=2)
        // {
        //     for(int i = gap;i<nums.size();i++)
        //     {
        //         int j = i -gap;
        //         int key = nums[i];
        //         while(j>=0&&key<nums[j])
        //         {
        //             nums[j+gap] = nums[j];
        //             j -= gap;
        //         }
        //         nums[j+gap] = key;
        //     }
        // }

        //快排
        // quickSort(nums,0,nums.size()-1);

        //归并排序
        // vector<int>copy(nums.size(),0);
        // mergesort(nums,0,nums.size()-1,copy);

        //堆排序
        sort_dui(nums);
        return nums;
    }
    void quickSort(vector<int>&nums,int begin,int end)
    {
        if(begin>=end)return ;
        //优化可以当end - begin很小的时候运用插入排序继续排序
        //随机选取val
        int pos = Partation(nums,begin,end);
        quickSort(nums,begin,pos-1);
        quickSort(nums,pos+1,end);
    }
    int Partation(vector<int>&arr,int l,int r)
    {
        int val = arr[l];
        while(l<r)
        {
            while(l<r&&arr[r]>val)
            {
                r--;
            }
            if(l<r)
            {
                arr[l] = arr[r];
                l++;
            }
            while(l<r&&arr[l]<val)
            {
                l++;
            }
            if(l<r)
            {
                arr[r] = arr[l];
                r--;
            }
        }
        arr[l] = val;
        return l;

    }

    void mergesort(vector<int>&nums,int l,int r,vector<int>&copy)
    {
        if(l>=r)return ;
        int mid = l+(r-l)/2;
        mergesort(nums,l,mid,copy);
        mergesort(nums,mid+1,r,copy);
        merge(nums,l,mid,r,copy);
    }

    void merge(vector<int>&nums,int l,int mid,int r,vector<int>&copy)
    {
        int idx = 0;
        int i = l;
        int j = mid+1;
        while(i<=mid&&j<=r)
        {
            if(nums[i]<=nums[j])
            {
                copy[idx++] = nums[i++];
            }
            else
            {
                copy[idx++] = nums[j++];
            }
        }
        while(i<=mid)
        {
            copy[idx++] = nums[i++];
        }
        while(j<=r)
        {
            copy[idx++] = nums[j++];
        }
        for(i = l,j = 0;i<=r;i++,j++)
        {
            nums[i] = copy[j];
        }
    }
    

堆排序：

#include <vector>
using namespace std;

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        sort_dui(nums);
        return nums;
    }
  
    void siftup(vector<int>& copy, int i, int val) {
        while (i > 0) {
            int father = (i - 1) / 2;
            if (val <= copy[father]) {
                break;
            }
            copy[i] = copy[father];
            i = father;
        }
        copy[i] = val;
    }

    void siftdown(vector<int>& copy, int i, int val) {
        int n = copy.size();
        while (2 * i + 1 < n) {
            int child = 2 * i + 1;
            if (child + 1 < n && copy[child + 1] > copy[child]) {
                child++;
            }
            if (val >= copy[child]) {
                break;
            }
            copy[i] = copy[child];
            i = child;
        }
        copy[i] = val;
    }

    void push(vector<int>& copy, int val) {
        copy.push_back(val);
        siftup(copy, copy.size() - 1, val);
    }

    void pop(vector<int>& copy) {
        if (copy.empty()) {
            return;
        }
        int n = copy.size();
        copy[0] = copy[n - 1];
        copy.pop_back();
        siftdown(copy, 0, copy[0]);
    }

    int top(vector<int>& copy) {
        return copy[0];
    } 

    void sort_dui(vector<int>& nums) {
        vector<int> copy;
        for (auto num : nums) {
            push(copy, num);
        }
        for (int i = nums.size() - 1; i >= 0; i--) {
            nums[i] = top(copy);
            pop(copy);
        }
    }
};

堆排序

class Solution {
public:
    void siftdown(vector<int>& nums, int i, int size) {
        int val = nums[i];
        while (i < size / 2) {
            int child = 2 * i + 1;
            if (child + 1 < size && nums[child + 1] > nums[child]) {
                child = child + 1;
            }
            if (nums[child] > val) {
                nums[i] = nums[child];
                i = child;
            } else {
                break;
            }
        }
        nums[i] = val;
    }

    void HeapSort(vector<int>& nums, int size) {
        int n = size - 1;
        for (int i = (n - 1) / 2; i >= 0; i--) {
            siftdown(nums, i, size);
        }
        for (int i = n; i > 0; i--) {
            int tmp = nums[0];
            nums[0] = nums[i];
            nums[i] = tmp;
            siftdown(nums, 0, i);
        }
    }

    vector<int> sortArray(vector<int>& nums) {
        HeapSort(nums, nums.size());
        return nums;
    }
};

基数排序：

class Solution {
public:
	void RadixSort(vector<int>& arr, int size)
	{
		int maxData = arr[0];
		for (int i = 1; i < size; i++)
		{
			if (maxData < abs(arr[i]))
			{
				maxData = abs(arr[i]);
			}
		}

		int len = to_string(maxData).size();

		vector<vector<int>> vecs;
		int mod = 10;
		int dev = 1;

		for (int i = 0; i < len; mod *= 10, dev *= 10, i++) // O(d) d：数据的长度
		{
			vecs.resize(20); // 20个桶，为了能处理负数 -9 - 9

			for (int j = 0; j < size; j++) // O(n)
			{
				// 得到当前元素第i个位置的数字
				int index = arr[j] % mod / dev + 10;
				vecs[index].push_back(arr[j]);
			}

			// 依次遍历所有的桶，把元素拷贝回原始的数组当中
			int idx = 0;
			for (auto vec : vecs) // O(20) 
			{
				for (int v : vec) // O(n)    O(20)*O(n) = O(n)
				{
					arr[idx++] = v;
				}
			}

			vecs.clear();
		}
	}

	vector<int> sortArray(vector<int>& nums) {
		RadixSort(nums, nums.size());
		return nums;
	}
};