面试题——各种功能函数实现（二）排序算法

快排递归实现

class Solution {
    void quickSort(vector<int>& nums, int l, int r){
        if (l >= r) return;
        int mark = nums[l];
        int mark_ptr = l;
        for (int i=l; i<=r; i++){
            if (nums[i] < mark){
                mark_ptr++;
                swap(nums[i], nums[mark_ptr]);
            }
        }
        swap(nums[mark_ptr], nums[l]);
        quickSort(nums, l, mark_ptr-1);
        quickSort(nums, mark_ptr+1, r);
    }
public:
    vector<int> sortArray(vector<int>& nums) {
        if (nums.empty()) return {};
        quickSort(nums, 0, nums.size()-1);
        return nums;
    }
};

快排非递归实现，利用栈，BFS的思想，存储前后指针

class Solution {
    void quickSort(vector<int>& nums, int l, int r){
        using Pair = pair<int,int>;
        stack<Pair> stk; stk.push(Pair(l, r));
        while (!stk.empty()){
            auto index = stk.top(); stk.pop();
            int l = index.first; int r = index.second;
            if (l >= r) continue;
            int mark = nums[l];
            int mark_ptr = l;
            for (int i=l; i<=r; i++){
                if (nums[i] < mark){
                    mark_ptr++;
                    swap(nums[i], nums[mark_ptr]);
                }
            }
            swap(nums[mark_ptr], nums[l]);
            stk.push(Pair(l, mark_ptr-1));
            stk.push(Pair(mark_ptr+1, r));
        }
    }
public:
    vector<int> sortArray(vector<int>& nums) {
        if (nums.empty()) return {};
        quickSort(nums, 0, nums.size()-1);
        return nums;
    }
};

归并排序

class Solution {
    void mergeSort(vector<int>& nums, vector<int>& temp, int l, int r){
        if (l >= r) return;
        int mid = (l + r) / 2;
        mergeSort(nums, temp, l, mid);
        mergeSort(nums, temp, mid+1, r);
        int i=l,j=mid+1; int t = 0;
        while (i<=mid && j<=r){
            if (nums[i] <= nums[j]) temp[t++] = nums[i++];
            else temp[t++] = nums[j++];
        }
        while (i <= mid) temp[t++] = nums[i++];
        while (j <= r) temp[t++] = nums[j++];
        
        for (int i=l,t=0; i<=r; i++)
            nums[i] = temp[t++];
    }
public:
    vector<int> sortArray(vector<int>& nums) {
        if (nums.empty()) return {};
        vector<int> temp(nums.size(), 0);
        mergeSort(nums, temp, 0, nums.size()-1);
        return nums;
    }
};

堆排序

class Solution {
    void heap(vector<int>& nums, int p){
       for (int parent=p; parent*2+1<nums.size();){
           int child = parent*2+1;
           if (child+1<nums.size() && nums[child] > nums[child+1])
                child++;
            if (nums[child] > nums[parent])
                break;
            swap(nums[child], nums[parent]);
            parent = child;
       }
    }
    void buildheap(vector<int>& nums){
        for (int i=nums.size()/2; i>=0; i--)
            heap(nums, i);
    }
public:
    vector<int> sortArray(vector<int>& nums) {
        if (nums.empty()) return {};
        buildheap(nums);
        vector<int> temp(nums.size(), 0);
        for (int i=0; i<temp.size(); i++){
            temp[i] = nums[0]; nums[0] = nums.back(); nums.pop_back();
            heap(nums, 0);
        }
        return temp;
    }
};

冒泡排序

class Solution {
    void bubbleSort(vector<int>& nums){
       for (int i=0; i<nums.size(); i++){
           for (int j=0; j<nums.size()-i-1; j++){
               if (nums[j] > nums[j+1])
                    swap(nums[j], nums[j+1]);
           }
       }
    }
public:
    vector<int> sortArray(vector<int>& nums) {
        if (nums.empty()) return {};
        bubbleSort(nums);
        return nums;
    }
};

计数排序，只适用于0<=arr[i]<=n的情景

void jishuSort(vector<int>& nums, vector<int>& temp){
	for (int i=0; i<nums.size(); i++)
		temp[nums[i]]++;
	int t = 0;
	for (int i=0; i<nums.size(); i++){
		while (temp[i]){
			nums[t++] = i;
			temp[i]--;
		}
	}
}

循环排序，只适用于0<=arr[i]<=n的情景

void whileSort(vector<int>& nums){
	for (int i=0; i<nums.size(); i++){
		int temp = nums[i];
		while (temp != nums[temp-1])
			swap(temp, nums[temp-1]);
	}
}

希尔排序

class Solution {
    void shellSort(vector<int> &arr){
        int N = arr.size();
        //进行分组，最开始的增量gap为数组长度的一半
        for (int gap=N/2; gap>0; gap/=2){
            for (int i=gap; i<N; i++){
                for (int j=i-gap; j>=0&&arr[j+gap]<arr[j]; j-=gap){
                    swap(arr[j+gap], arr[j]);
                }
            }
        }    
    }
public:
    vector<int> sortArray(vector<int>& nums) {
        shellSort(nums);
        return nums;
    }
};

插入排序

class Solution {
    void straightSort(vector<int> &arr){
        int N = arr.size();
        for (int i=1; i<N; i++){
            for (int j=i-1; j>=0&&arr[j+1]<arr[j]; j-=1){
                swap(arr[j+1], arr[j]);
            }
        }    
    }
public:
    vector<int> sortArray(vector<int>& nums) {
        straightSort(nums);
        return nums;
    }
};

选择排序

class Solution {
    void selectSort(vector<int> &arr){
        int N = arr.size();
        for (int i=0; i<N-1; i++){
            int min = i;
            for (int j=i+1; j<N; j++){
                if (arr[j] < arr[min])
                    min = j;
            }
            swap(arr[i], arr[min]);
        }    
    }
public:
    vector<int> sortArray(vector<int>& nums) {
        selectSort(nums);
        return nums;
    }
};