六大排序算法c++实现

 

插入排序：

void insertionSort(vector<int> &A) {
	for (int j = 1;j < A.size();j++) {
		int key = A[j];
		int i=j-1;
		while(i>=0&&key < A[i]){
			A[i + 1] = A[i];
			i--;
		}
		A[i + 1] = key;
	}
}

选择排序

void selectionSort(vector<int> &A) {
	for (int j = 0;j < A.size();j++) {
		int min = j;
		for (int i = j + 1;i < A.size();i++) {
			if (A[i] < A[min])
				min = i;
		}
		if(j!=min) swap(A[j],A[min]);
	}
}

归并排序

//
void Merge(vector<int>&A, int p, int q, int r)
{
	vector<int> L(A.begin() + p, A.begin() + q+1);   //A[p......q]
	vector<int> R(A.begin() + q+1, A.begin() + r+1); //A[q+1......r]
	L.push_back(INT_MAX);
	R.push_back(INT_MAX);
	for (int i = 0, j = 0, k = p; k <= r; k++)
	{
		if (L[i] <= R[j]) A[k] = L[i++];
		else A[k] = R[j++];
	}
}
void MergeSort(vector<int>& A, int p, int r)
{
	if (p<r)
	{
		int q = (p + r) / 2;
		MergeSort(A, p, q);
		MergeSort(A, q + 1, r);
		Merge(A, p, q, r);
	}
}

* merge_sort: 非递归实现 --迭代
* 非递归思想: 将数组中的相邻元素两两配对。用merge函数将他们排序，
* 构成n/2组长度为2的排序好的子数组段，然后再将他们排序成长度为4的子数组段，
* 如此继续下去，直至整个数组排好序。
**/
// merge_sort(): 非递归实现-自底向上
// 将原数组划分为left[min...max] 和 right[min...max]两部分
void merge_sort(vector<int> &list)
{
	int length = list.size();
	vector<int> temp(length, 0);
	int i, left_min, left_max, right_min, right_max, next;
	for (i = 1; i < length; i *= 2) // i为步长，1,2,4,8……
	{
		for (left_min = 0; left_min < length - i; left_min = right_max)
		{
			right_min = left_max = left_min + i;
			right_max = left_max + i;
			if (right_max > length)
				right_max = length;
			next = 0;
			while (left_min < left_max && right_min < right_max)
				temp[next++] = list[left_min] > list[right_min] ? list[right_min++] : list[left_min++];
			
			while (left_min < left_max)
				list[--right_min] = list[--left_max];

			while (next > 0)
				list[--right_min] = temp[--next];
		}
	}
}

冒泡排序

void bubbleSort(vector<int> &A) {
    for (int j = 0; j < A.size(); j++)
        for (int i = A.size() - 1; i > j; i--)
            if (A[i] < A[i - 1]) swap(A[i], A[i - 1]);
}

堆排序

非递归：

void maxHeapify(vector<int>& A, int heap_size, int i) {
    int largest;
    while (i * 2 < heap_size) {
        largest = i * 2 + 1;
        if (largest<heap_size&&A[largest + 1]>A[largest]) {
            largest++;
        }
        if (A[i]<A[largest]) {//如果自己的孩子比自己大则交换两者的值  
            swap(A[i], A[largest]);
        }
        else break; //如果不比自己大则不交换  
        i = largest;
    }
}

递归：

void maxHeapify(vector<int>& A, int heap_size, int i) {
    int largest = i * 2 + 1;
    if (largest > heap_size) return;
    if (largest<heap_size&&A[largest + 1]>A[largest]) {
        largest++;
    }
    if (A[i]<A[largest]) {//如果自己的孩子比自己大则交换两者的值  
        swap(A[i], A[largest]);
        maxHeapify(A, heap_size, largest);
    }
}

void buildMaxHeap(vector<int>& A) {
	int heap_size = A.size() - 1;
	for (int i = heap_size / 2;i >= 0;i--) {
		maxHeapify(A, heap_size,i);
	}
}

void HeapSort(vector<int>& A) {
	buildMaxHeap(A);
	int heap_size = A.size() - 1;
	while (heap_size >= 1) {
		swap(A[heap_size], A[0]);
		heap_size--;
		maxHeapify(A, heap_size, 0);
	}
}

快排

int partition(vector<int>& A, int p, int r) {
	int x = A[r];
	int i = p;
	for (int j = p;j < r;j++) {
		if (A[j] <= x) {
			swap(A[j], A[i]);
			i++;
		}
	}
	swap(A[r], A[i]);
	return i;
}
void QuickSort(vector<int>& A, int p, int r)
{
	if (p<r)
	{
		int q = partition(A,p,r);
		QuickSort(A, p, q-1);
		QuickSort(A, q + 1, r);
	}
}

快排非递归实现：

数据规模很大时，递归的算法很容易导致栈溢出，改为非递归，模拟栈操作，

最大长度为n，每次压栈时先压长度较大的，此时栈深度为logn。  

/**使用栈的非递归快速排序**/
template<typename Comparable>
void quicksort2(vector<Comparable> &vec,int low,int high){
    stack<int> st;
    if(low<high){
        int mid=partition(vec,low,high);
        if(low<mid-1){
            st.push(low);
            st.push(mid-1);
        }
        if(mid+1<high){
            st.push(mid+1);
            st.push(high);
        }
        //其实就是用栈保存每一个待排序子串的首尾元素下标，下一次while循环时取出这个范围，对这段子序列进行partition操作
        while(!st.empty()){
            int q=st.top();
            st.pop();
            int p=st.top();
            st.pop();
            mid=partition(vec,p,q);
            if(p<mid-1){
                st.push(p);
                st.push(mid-1);
            }
            if(mid+1<q){
                st.push(mid+1);
                st.push(q);
            }       
        }
    }
}