面试常用排序算法

冒泡排序

//每次循环确定末尾值
//时间复杂度O（n²）
//空间复杂度O（1）
class Solution {
public:
    vector<int> bubbleSort(vector<int>& nums) {
        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])
                {
					swap(nums[j],nums[j+1]);
                }
            }
        }
        return nums;
    }
};

选择排序

//每次循环确定首位值
//时间复杂度O（n²）
//空间复杂度O（1）
class Solution {
public:
    vector<int> selectSort(vector<int>& nums) {
        int n=nums.size();
        for(int i=0;i<n-1;++i)
        {
            int minIndex=i;
            for(int j=i+1;j<n;++j)
            {
            	minIndex = (nums[j]<nums[minIndex])?j:minIndex;
            }
            swap(nums[i],nums[minIndex]);
        }
        return nums;
    }
};

插入排序

//每次循环确定该数具体位置，类似抓牌
//时间复杂度O（n²）
//空间复杂度O（1）
class Solution {
public:
    vector<int> insertionSort(vector<int>& nums) {
        //插入排序
        int n=nums.size();
        for(int i=1;i<n;i++)
        {
        	for(int j = i-1;j>=0 && nums[j]>nums[j+1];--j)
        	{
        		swap(nums[j],nums[j+1]);
        	}  
        }
        return nums;
    }
};

希尔排序

/**
 * 将一个长数组按照相同的间隔h分为多个小数组，每个小数组分别进行插入排序
 * 将间隔h缩小，并继续排序，直至间隔为1。
 * 可以证明出当间隔h=3*h+1时，希尔排序平均时间复杂度最优
 * 时间复杂度O(n^3/2)
 * 空间复杂度O(1)
 */
class Solution {
public:
    vector<int> shellSort(vector<int>& nums) {
        int n = nums.size();
        int h =1;
        while(h<n/3){
            h = 3*h+1;
        }
        while(h>0){
            for(int i =h;i<n;++i){
                int flag = nums[i];
                int j = i-h;
                while(j>=0 && flag<nums[j]){
                    nums[j+h]=nums[j];
                    j-=h;
                }
                nums[j+h]=flag;
            }
            h/=3;
        }
        return nums;
    }
};

快速排序

//随机选一个数作为基准，将基准放置首位
//将所有小于基准数的元素移动至其左边，大于基准数的元素移动至其右边
//对 左子数组 和 右子数组 递归执行，直至子数组长度为 1 时终止递归，即可完成对整个数组的排序
//时间复杂度O（nlogn）
//空间复杂度O（logn）
class Solution {
public:
    void quickSort(vector<int>& nums, int l, int r)
	{
        if(l>=r) return;
        int k = (rand() % (r - l + 1)) + l;
		swap(nums[k], nums[l]);
		int i = l , j = r;
		while (i<j)
		{
            while (i < j && nums[l]<=nums[j]) --j;
			while (i < j && nums[l]>=nums[i]) ++i;
			swap(nums[i], nums[j]);
		}
		swap(nums[i], nums[l]);
		quickSort(nums, l, i - 1);
	    quickSort(nums, i + 1, r);
	}
};

归并排序

//整体就是一个简单递归，左边排好序，右边排好序，让其整体有序
//时间复杂度O（nlogn）
//空间复杂度O（n）
class Solution {
public:
    void MergeSort(vector<int>&nums,int l,int r)
    {
        if(l>=r) return;

        int mid=l+((r-l)>>1);
        MergeSort(nums,l,mid);
        MergeSort(nums,mid+1,r);
        Merge(nums,l,mid,r);
    }
    void Merge(vector<int>&nums,int l,int m,int r)
    {
        vector<int> temp(r-l+1);
        int i=l,j=m+1,k=0;
        while(i<=m && j<=r){
   
            temp[k++] = nums[i]<=nums[j]?nums[i++]:nums[j++];
        }
        while(i<=m) temp[k++]=nums[i++];
        while(j<=r) temp[k++]=nums[j++];
        for(int i=0;i<k;i++)
            nums[l+i]=temp[i];
    }
};

堆排序

//先将待排序的序列建成大根堆，此时整个序列最大值即为堆顶元素，将其与末尾元素交换，使末尾元素为最大值
//然后再调整堆顶元素使得剩下的 n-1个元素仍为大根堆，再重复执行以上操作。
//时间复杂度O（nlogn）
//空间复杂度O（1）
class Solution {
    void maxHeapify(int index,int size,vector<int>& nums)
    {
        int left = index*2+1;
        while(left<size)
        {
            //左右取大
            int largest = left+1 <size && nums[left+1] >nums[left] ? left+1:left;
            //父子取大
            largest = nums[largest]>nums[index]?largest:index;
            if(largest==index) break;
            swap(nums[index],nums[largest]);
            index = largest;
            left = index*2+1;
        }
    }
    void buildMaxHeap(vector<int>& nums, int size) {
        for (int i = size / 2-1 ; i >= 0; --i) {
            maxHeapify(i,size,nums);
        }
    }
    void heapSort(vector<int>& nums) {
        int size = nums.size();
        buildMaxHeap(nums, size);
        for (int i = size-1; i >= 0; --i) {
            swap(nums[i], nums[0]);
            maxHeapify(0,i,nums);
        }
    }
};

计数排序

//统计每个数个数，在按顺序还原
//时间复杂度O（n）
//空间复杂度O（n）
class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        int Min = INT_MAX, Max = INT_MIN;
        for (int c : nums) {
            Min = min(c, Min);
            Max = max(c, Max);
        }
        int len = Max - Min;
        vector<int> bucket (len+1);
        for (int c : nums) {
            bucket[c - Min]++;
        }
        int j = 0;
        for (int i = 0;i <= len; i++) {
            while (bucket[i]--) {
                nums[j++] = i + Min;
            }
        }
        return nums;

    }
};

基数排序

//将整数按位数切割成不同的数字，然后按每个位数分别比较
//时间复杂度O（n）
//空间复杂度O（n）
class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        int Max = INT_MIN;
        for (int c : nums) {
            Max = max(abs(c), Max);
        }
        int maxbits = 0;
        while(Max)
        {
            ++maxbits;
            Max/=10;
        }
        int len = nums.size();
        vector<int>bucket(len);
        for(int i = 0,exp = 1;i<maxbits;++i,exp*=10)
        {
            vector<int>count(19);
            for(int i = 0;i<len;++i)
            {
                int digit = (nums[i]/exp)%10+9;
                count[digit]++;
            }
            for (int i = 1; i < 19; ++i) {
                count[i] += count[i - 1];
            }
            for (int i = len - 1; i >= 0; --i) {
                int digit = (nums[i]/exp) % 10+9;
                bucket[count[digit]-1] = nums[i];
                count[digit]--;
            }
            //copy(bucket.begin(), bucket.end(), nums.begin());
            //nums.swap(bucket);
            for(int i = 0,j = 0;i<len;++i,++j)
            {
                nums[i] = bucket[j];
            }
        }
        return nums;

    }
};