package com.algorithm;
import java.util.Random;
/**
* 八种常见排序算法：插入、冒泡、选择、希尔、归并、快排、堆排序、基数排序
* @author Wennian
*
*/
public class Sort {
public static void main(String[] args) {
// TODO Auto-generated method stub
// 构建初始化乱序数组，采用随机数的方式，生成整数（正数、0、负数）
int N = 100;
int[] arr = new int[N];
for(int i=0;i<N;i++){
// 随机生成0-N-1的数，其中1/10的数为负数
arr[i] = new Random().nextInt(N) - N/10;
}
Sort sort = new Sort();
//sort.BubbleSort(arr);
//sort.InserSort(arr);
//sort.SelectSort(arr);
//sort.SheelSort(arr);
//sort.QuickSort(arr);
//sort.mergeSort(arr);
sort.heapSort(arr);
for(int i=0;i<N;i++){
System.out.print(arr[i]+" ");
if(i%10 == 0 && i>0){
System.out.println();
}
}
}
/**
* 冒泡排序：一组数，每次把最大的数往后沉
* 时间复杂度：o(n^2) 空间复杂度：o(1)
* 稳定
*/
void BubbleSort(int[] arr){
int len = arr.length;
int end = len-1; // 初始时，结束位置为数组末尾
int start = 0; // 每次从第一个元素开始往后遍历
// 一共需要len趟才能排序完成
for(int i=0;i<len;i++){
start = 0;
while(start < end){
if(arr[start]>arr[start+1]){
arr[start] ^= arr[start+1];
arr[start+1] ^= arr[start];
arr[start] ^= arr[start+1];
}
start++;
}
end--; //每趟排序之后，待排数组长度减1
}
}
/**
* 插入排序：认为前面的数组已经有序，每次向原来的数组中插入一个数
* 时间复杂度o(n^2) 空间复杂度o(1)
* 稳定
* @param arr
*/
void InserSort(int[] arr){
int len = arr.length;
int end = 0; // 已经排序好的数组
int start = end+1; // 下一个要插入的元素
while(start<=len-1){
for(int i = end;i>=0;i--){
if(arr[i+1]<arr[i]){
arr[i+1] ^= arr[i];
arr[i] ^= arr[i+1];
arr[i+1] ^= arr[i];
}else{
break;
}
}
end = start;
start++;
}
}
/**
* 选择排序：有序区和无序区，有序区的元素小于无序区，每次选择无需去的最小元素放在有序区后面
* 时间复杂度o(n^2) 空间复杂度o(1)
* 稳定
*/
void SelectSort(int[] arr){
int len = arr.length;
int start = 0; // 无序区的第一个元素，认为他是最小值
while(start < len){
for(int i=start+1;i<len;i++){
if(arr[start]>arr[i]){
arr[start] ^= arr[i];
arr[i] ^= arr[start];
arr[start] ^= arr[i];
}
}
start++;
}
}
/**
* 希尔排序：缩小增量排序，每次缩小增量gap，间隔gap的数为一个子序列，
* 依次缩小增量，直到gap=1，对每个子序列采用直接选择排序
* 时间复杂度o(nlogn)~o(n^2) 空间复杂度 o(1)
* 不稳定
*/
void SheelSort(int[] arr){
int len = arr.length;
// gap选择为奇数，gap的选择直接影响排序的效率
// 若选择偶数，gap=4会重复gap=8的排序比较，时间浪费
for(int gap=len/2+1;gap>0;gap/=2){
//对子序列进行直接选择排序,一共有gap个子序列
for(int subarr=0;subarr<gap;subarr++){
int start = subarr;
// 直接选择排序
while(start<len){
for(int i=start+gap;i<len;i+=gap){
if(arr[start]>arr[i]){
arr[start] ^= arr[i];
arr[i] ^= arr[start];
arr[start] ^= arr[i];
}
}
start +=gap;
}
}
}
}
/**
* 快序排序：每次找到一个分割值，满足：左边<=分割值<=右边，重复此过程直到有序
* 时间复杂度o(nlogn) 空间复杂度o(1)
* 不稳定
* @param arr
*/
void QuickSort(int[] arr){
int len =arr.length;
int left = 0 ;
int right = len-1;
quickSort(arr,left,right);
}
void quickSort(int[] arr ,int left,int right){
if(left < right){
int split = arr[left];
int index1 = left, index2 = right;
while(index1<index2){
while(arr[index2]>=split && index1<index2){
index2--;
}
if(index1<index2)
arr[index1++] = arr[index2];
while(arr[index1]<=split && index1<index2){
index1++;
}
if(index1<index2)
arr[index2--] = arr[index1];
}
arr[index1] = split;
// 递归调用
quickSort(arr,left,index1);
quickSort(arr,index1+1,right);
}
}
/**
* 归并排序：将数组分为子数组，认为每一个子数组已经有序，对两个有序数组进行归并
* 时间复杂度o(nlogn) 空间复杂度o(n)
* 稳定
*/
void mergeSort(int[] arr){
int len = arr.length;
if(len<=0)
return;
divideArray(arr,0,len-1);
}
void divideArray(int[] arr,int left,int right){
if(left < right){
int mid = left + (right - left)/2;
// 分解
divideArray(arr,left,mid);
divideArray(arr,mid+1,right);
// 合并
mergeArray(arr,left,mid,right);
}
}
void mergeArray(int[] arr,int left,int mid,int right){
// 合并两个有序子数组arr[left..mid] arr[mid+1..right]
int i=left,m=mid,j=mid+1,n=right;
int[] tmp = new int[right-left+1];
int k=0;
while(i<=m && j<=n){
if(arr[i]<=arr[j])
tmp[k++] = arr[i++];
else
tmp[k++] = arr[j++];
}
while(i<=m)
tmp[k++] = arr[i++];
while(j<=n)
tmp[k++] = arr[j++];
// copy tmp to arr
for(int t=0;t<k;t++)
arr[left+t] = tmp[t];
}
/**
* 堆排序：大根堆，每次取堆顶元素，将堆顶元素与最后一个值交换，然后调整堆依次
* 整个过程相当于一个不断建堆的过程
* 时间复杂度o(nlogn) 空间复杂度o(1)
* 不稳定
*/
void heapSort(int[] arr){
// 将初始数组看做已经建好的堆，调整堆
// parent：i child:2i+1 2i+2
// 从第一个非叶子节点往上调整
int len = arr.length;
int last = len-1;
while(last >= 0){
// 调整堆，将最大值放在堆顶，即第一个元素
for(int p=(last-1)/2;p>=0;p--){
int cur = p;
// 只有第一次需要建立堆，其他时候只要从根节点开始调整堆即可
if(last != len-1){
cur = 0;
p = 0;
}
while(cur <= (last-1)/2){
int child = 2*cur+1;
if(child<last-1 && arr[child] < arr[child+1])
child += 1;
if(arr[cur] < arr[child]){
arr[cur] ^= arr[child];
arr[child] ^= arr[cur];
arr[cur] ^= arr[child];
}
cur = child;
}
}
// 交换堆顶元素和最后一个元素
if(arr[0] != arr[last]){
arr[last] ^= arr[0];
arr[0] ^= arr[last];
arr[last] ^= arr[0];
}
last--;
}
}
}
