排序算法

基础排序算法

冒泡排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class MAOPAOSORT {
public:
    void sort(vector<int>& nums) {
        if(nums.empty()) {
            return;
        }
        maopaosort(nums);
    }
private:
    void swap(int& a, int& b) {
        int temp = a;
        a = b;
        b = temp;
    }
    void maopaosort(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]);
                }
            }
        }
    }
}

时间复杂度：O(n^2)，空间复杂度：O(1)

选择排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class CHOICESORT {
public:
    void sort(vector<int>& nums) {
        if(nums.empty()) {
            return;
        }
        choicesort(nums);
    }
private:
    void choiceswap(int& a, int& b) {
        int temp = a;
        a = b;
        b = temp;
    }
    void sort(vector<int>& nums) {
        for (int i = 0; i < nums.size(); i++) {
            int min = i;
            for (int j = i + 1; j < nums.size(); j++) {
                if (nums[j] < nums[min]) {
                    min = j;
                }
            }
            swap(nums[i], nums[min]);
        }
    }
}

时间复杂度：O(n^2)，空间复杂度：O(1)

插入排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class INSERTSORT {
public:
    void sort(vector<int>& nums) {
        if(nums.empty()) {
            return;
        }
        insertsort(nums);
    }
private:
    void insertsort(vector<int>& nums) {
        for (int i = 1; i < nums.size(); i++) {
            int temp = nums[i];
            int j = i - 1;
            while (j >= 0 && nums[j] > temp) {
                nums[j + 1] = nums[j];
                j--;
            }
            nums[j + 1] = temp;
        }
    }
}

时间复杂度：O(n^2)，空间复杂度：O(1)

归并排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class MERGESORT {
public:
    void sort(vector<int>& nums) {
        if(nums.empty()) {
            return;
        }
        mergesort(nums, 0, nums.size() - 1);
    }
private:
    void merge(vector<int>& nums, int left, int mid, int right) {
        vector<int> temp(right - left + 1);
        int i=left, j=mid+1, k=0;
        while (i<=mid || j<=right) {
            if (i > mid) {
                temp[k++] = nums[j++];
            }
            else if (j > right) {
                temp[k++] = nums[i++];
            }
            else{
                if(nums[i] < nums[j]) {
                    temp[k++] = nums[i++];
                }
                else{
                    temp[k++] = nums[j++];
                }
            }
        }
        for (int p = 0; p < temp.size(); p++) {
            nums[left + p] = temp[p];
        }
    }
    void mergesort(vector<int>& nums, int left, int right) {
        if (left >= right) {
            return;
        }
        int mid = left + ( right - left ) >> 1;
        mergesort(nums, left, mid);
        mergesort(nums, mid + 1, right);
        merge(nums, left, mid, right);
    }
}

时间复杂度：O(nlogn)，空间复杂度：O(n)

快速排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class QUICKSORT {
public:
    void sort(vector<int>& nums) {
        if(nums.empty()) {
            return;
        }
        sort(nums, 0, nums.size() - 1);
    }
private:
    void quicksort(vector<int>& nums, int left, int right) {
        if (left >= right) {
            return;
        }
        int i = left, j = right;
        int temp = nums[left];
        while (i < j) {
            while (i < j && nums[j] >= temp) {
                j--;
            }
            nums[i] = nums[j];
            while (i < j && nums[i] <= temp) {
                i++;
            }
            nums[j] = nums[i];
        }
        nums[i] = temp;
        quicksort(nums, left, i - 1);
        quicksort(nums, i + 1, right);
    }
}

时间复杂度：O(nlogn)，空间复杂度：O(logn)

猴子排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class MONKEYSORT {
public:
    void sort(vector<int>& nums) {
        if(nums.empty()) {
            return;
        }
        srand(time(NULL));
        sort(nums);
    }
private:
    void monkeysort(vector<int>& nums) {
        while (!isSorted(nums)) {
            for (int i = 0; i < nums.size(); i++) {
                int j = rand() % nums.size();
                swap(nums[i], nums[j]);
            }
        }
    }
}

时间复杂度：O(n!) ，空间复杂度：O(1)

end