排序算法总结

这篇文章包含一些408常考的排序算法的代码实现

 c++ 版本

#pragma once
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
/***
*这个头文件包括一些408常见的排序算法：
* 1.insertSort 直接插入排序
* 2.shellSort 希尔排序
* 3.bubbleSort 冒泡排序
* 4.quickSort 快速排序
* 5.selectionSort 简单选择排序
* 6.heapSort 堆排序
* 7.countingSort 计数排序
***/
class Sort {
public:
	void insertSort(vector<int> &a) {
		int i, j, temp;
		for (i = 1; i < a.size(); ++i) {
			if (a[i] < a[i - 1]) {
				for (j = i - 1; j >= 0 && a[j] > temp; --j) {
					a[j + 1] = a[j];
				}
				a[j + 1] = temp;
			}
		}
	}
	void shellSort(vector<int> &a) {
		int dk, i, j;
		int n = a.size();
		for (dk = n / 2; dk >= 1; dk = dk / 2) {   // 划分子表的过程
			for (i = dk+1; i <= n; ++i) {    // 子表中直接插入排序的过程
				if (a[i] < a[i - dk]) {
					a[0] = a[i]; // a[0]用来暂存不符合要求的元素
					for (j = i - dk; j > 0 && a[j] > a[0]; j -= dk) {
						a[j + dk] = a[j];
					}
					a[j + dk] = a[0];
				}
			}
		}
	}// 1，5，3，2，4，3，9  -> 1, 5, 5,
	void bubbleSort(vector<int> &a) {
		int n = a.size();
		for (int i = 0; i < n-1; ++i) {
			bool flag = true;
			for (int j = n-1; j > i; --j) {
				if (a[j] < a[j - 1]) {
					swap(a[j], a[j - 1]);
					flag = false;
				}
				if (flag) { return; }
			}
		}
	}
	// 定义分区函数
	int partition(vector<int>& a, int l, int r) {
		int pivot = a[l]; // 定义一个变量存放枢轴，左边左右数比他小，右边所有数字比他大
		while (l < r) {
			while (l < r && a[r] >= pivot) { r--; } // while 循环从右往左找，直到找到第一个比数轴小的数字
			a[l] = a[r];  // 直接覆盖枢轴所在的位置，因为此时我们已经用一个变量pivot存放了这个枢轴
			while (l < r && a[l] <= pivot) { l++; }// while 循环从左往右边找，直到找到第一个比枢轴大的数字
			a[r] = a[l]; // 覆盖之前r指针停留的位置,因为此时我们已经用a[l]存放了从右往左找第一个比pivot大的数字
		}
		a[l] = pivot;   // l == r 时所有数字都被分配到两端，l所指的位置是pivot应该所处的位置
		return l;
	}
	void quickSort(vector<int>& a, int l, int r) {
		if (l < r) {
			int pivotPos = partition(a, l, r);
			quickSort(a, l, pivotPos - 1);
			quickSort(a, pivotPos + 1, r);
		}
	}
	void selectionSort(vector<int>& a) {
		int n = a.size();
		for (int i = 0; i < n; ++i) {
			int m = i;
			for (int j = i; j < n; ++j) {
				if (a[j] < a[m]) { m = j; }
			}
			if (m != i) { swap(a[i], a[m]); }
		}
	}
	// 下面是堆排序的代码实现
	void heapfiy(vector<int> &a, int n, int i) { // 调整堆的函数，首先传入的是最小堆的堆顶编号
		int largest = i;
		int left = 2 * i + 1;
		int right = 2 * i + 2;
		if (left < n && a[left] > a[largest]) {
			largest = left;
		}
		if (right < n && a[right] > a[largest]) {
			largest = right;
		}
		if (largest != i) {
			swap(a[i], a[largest]);
			heapfiy(a, n, largest);
		}
	}
	void heapSort(vector<int>& a) {
		int n = a.size();
		for (int i = n / 2 - 1; i >= 0; --i) {
			heapfiy(a, n, i);
		}
		for (int i = n - 1; i > 0; --i) {
			swap(a[0], a[i]);
			heapfiy(a, i, 0);
		}
	}
	void countingSort(vector<int> &a) {
		int n = a.size();
		vector<int> res;
		int volumn = *max_element(a.begin(), a.end());
		vector<int> cnt(volumn + 1, 0);
		for (int i = 0; i < n; ++i) {
			cnt[a[i]]++;
		}
		int idx = 0;
		for (int i = 0; i < cnt.size(); ++i) {
			while (cnt[i]--) {
				a[idx++] = i;
			}
		}
	}


};

python版本

### 这个封装的类中包含了一些408常见的排序算法
import random
class Sort:
    def __init__(self,a):
        self.a = a
        self.n = len(a)

    def insertSort(self):
        for i in range(1,self.n):
            if self.a[i-1] > self.a[i]:
                temp = self.a[i]
                j = i-1
                while j >= 0 and self.a[j] > temp:
                    self.a[j+1] = self.a[j]
                    j-=1
                self.a[j+1] = temp

    def BubbleSort(self):
        for i in range(self.n-1):
            flag = True
            for j in range(self.n-1,i,-1):
                if a[j] < a[j-1]:
                    a[j],a[j-1] = a[j-1],a[j]
                    flag = False
            if flag:return

    def partition(self,l,r):
        pivot = self.a[l]
        while l < r:
            while l < r and a[r] >= pivot:
                r -= 1
            self.a[l] = self.a[r]
            while l < r and self.a[l] <= pivot:
                l += 1
            self.a[r] = self.a[l]
        self.a[l] = pivot
        return l

    def qsort(self,l,r):
        if l < r:
            pivotPos = self.partition(l,r)
            self.qsort(pivotPos+1,r)
            self.qsort(l,pivotPos-1)

    def selectSort(self):
        for i in range(self.n):
            m = i
            for j in range(i+1,self.n):
                if self.a[j] < self.a[m]:
                    m = j
            self.a[i],self.a[m] = self.a[m],self.a[i]

    def heapify(self,n,i):
        largest = i
        left = 2 * i + 1
        right = 2 * i + 2
        if left < n and self.a[largest] < self.a[left]:
            largest = left
        if right < n and self.a[largest] < self.a[right]:
            largest = right
        if largest != i:
            a[largest],a[i] = a[i],a[largest]
            self.heapify(n,largest)

    def heapSort(self):
        n = len(self.a)
        for i in range(int(n/2) - 1,-1,-1):
            self.heapify(n,i)

        for i in range(n-1,0,-1):
            a[i],a[0] = a[0],a[i]
            self.heapify(i,0)  # 维护堆顶

if __name__ == '__main__':
    a = [random.randint(1, 29) for _ in range(6)]
    print(a)
    s = Sort(a)
    s.heapSort()
    print(a)