C/Java六大基础排序算法

直接贴代码了，算是对我自己的一个总结和回顾，一段时间不写就会忘记。

#include <iostream>
using namespace std;


void SIS(int a[] , int n) {
	
	/**
		 简单插入排序  4 7 2 9 6 5
		 思想：判断大小，先移后插。
		 			从第二个元素 7开始，记为 base，每次和前面所有元素比较，如果 base > a[i]，则 a[i] 向右移动一位，
		 			直到 base <= a[i]，则a[i] = base。
		 稳定排序，时间复制度 O(n2)，空间复杂度 O(1)。
	 */ 
	for(int i = 1; i < n; i++) {
		int j = i;
		int base = a[i];
		while(j > 0 && base < a[j-1]) {
			 a[j] = a[j-1];
			 j--;
		}
		a[j] = base; 
	} 
}


void SSS(int a[], int n) {
	/**
		简单选择排序 4 7 2 9 6 5
		思想：记录第一个元素 i，每次从剩下的 n - i 个元素中找到最小的元素 a[k] 与 a[i] 交，则前 i 个元素已经有序。
		不稳定排序。 时间复制度 O(n2) 空间复杂度 O(1)
	*/ 
	for(int i = 0; i < n; i++) {
		int k  = i;
		for(int j = i + 1; j < n; j++) {
			if(a[j] < a [k]) {
				k = j;
			}
		}
		int temp = a[i];
		a[i] = a[k];
		a[k] = temp;		
	} 	
}
 
void BubbleS(int a[], int n) {
	
	/**
		冒泡排序	4 7 2 9 6 5
		思想：a[i] 与 a[i+1]比较，如果 a[i] > a[i+1]，则交换，一轮下去最大的在数组最下边，因此，下一次只用比较 n - 1 个元素的大小。直到最终有序。
		稳定排序。 时间复制度 O(n2) 空间复杂度 O(1)
	*/ 
	for(int i = 0; i< n; i++) {
		for(int j = 0; j < n - i - 1; j++) {
			if(a[j] > a[j+1]) {
				temp = a[j+1];
				a[j+1] = a[j];
				a[j] = temp;	
			}
		}
	}
}


/**
	快排	4 7 2 9 6 5
	1 partition 分区， 根据base值（以第一个为准）分成两部分，返回basePos
	2 主函数的递归形参，结束条件，递归本身 
	不稳定排序。 时间复制度 O(nlogn) 空间复杂度 O(nlogn)
*/ 
int Partition(int a[], int low, int high) {
	int base= a[low];
	while(low < high) {
		while(a[high] >= base&& low < high) {
			high--;
		}
		a[low] = a[high];
		while(a[low] <= base&& low < high) {
			low++;
		}
		a[high] = a[low];
	}
	a[low] = base;
	return low;
} 

void QS(int a[], int low, int high) {
	if(low < high) {	// 递归结束条件 
		int basePos = Partition(a, low, high);
		QS(a, low, basePos - 1);
		QS(a, basePos + 1, high);
	}
}

// 堆排序
 
void HeapAdjust(int a[], int k, int n) {
	int base = a[k-1];
	// 小顶堆  值得注意：数组从 0 开始
	for(int i = 2*k; i < n; i *= 2) {
		if(a[i-1] > a[i]) {
			i++;
		}
		if(base <= a[i-1]) {		// 这是base，第一次写成a[k-1]了 
			break;
		}
		a[k-1] = a[i-1]; 
		k = i;	
	}
	a[k-1] = base;
}

void HeapS(int a[], int n) {
	for(int i = n/2; i > 0; i-- ) { 	// 建初始堆 n/2 ~ 1 
		HeapAdjust(a, i, n);
	}
	for(int j = n; j > 1; j--) {	// 堆顶与堆尾交换 n ~ 2 
		int temp = a[j-1];
		a[j-1] = a[0];
		a[0] = temp;
		HeapAdjust(a, 1, j - 1);	// 每次只用调整堆顶，成为新的小顶堆 
	}
}

// 	二路归并排序
int temp[100];
void Merge(int a[], int low, int mid, int high) {
	int i, j, k;
	for(k = low; k <= high; k++) {
		temp[k] = a[k];
	}
	for(i = low, j = mid + 1, k = i; i <= mid && j <= high; k++) {
		if(temp[i] < temp[j]) {
			a[k] = temp[i++];
		}else {
			a[k] = temp[j++];
		}
	}
	while(i <= mid) {
		a[k++] = temp[i++];
	}
	while(j <= high) {
		a[k++] = temp[j++];
	}
}

void MergeSort(int a[], int low, int high) {
	if(low < high) {
		int mid = (low + high) / 2;
		// 递归  
		MergeSort(a, low, mid);
		MergeSort(a, mid + 1, high);
		Merge(a, low, mid, high);
	}
} 

int main() {
	int arr[14] = {34, 2, 24, 7, 45, 4, 31, 12, 98, 6, 54, 11, 433, 45};
	HeapS(arr, 14);
	for(int i = 0; i < 14; i++) {
		cout<< arr[i] <<" ";
	}
	
}