/*比较一次，交换一次*/
public static void insertion_sort( int[] arr ){for( int i=0; i<arr.length-1; i++ ) {    for( int j=i+1; j>0; j-- ) {if( arr[j-1] <= arr[j] )break;int temp = arr[j];arr[j] = arr[j-1];arr[j-1] = temp;}}
}/*比较一次，右移一次元素，直到正确的位置*/
public static void  directInsert(int arr[]){for(int i=1;i<arr.length;i++){int temp=arr[i];int j=i-1;for(;(j>=0&&temp<arr[j]);j--){arr[j+1]=arr[j];}arr[j+1]=temp;}
}

/*希尔排序*/
public static void shell_sort(int[] arr) {int gap = 1;int i, j;int len = arr.length;int temp;while (gap < len / 3)gap = gap * 3 + 1; // <O(n^(3/2)) by Knuth,1973>: 1, 4, 13, 40, 121, ...for (; gap > 0; gap /= 3)for (i = gap; i < len; i++) {temp = arr[i];for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap)arr[j + gap] = arr[j];arr[j + gap] = temp;}
}

/*冒泡排序*/
public static void bubbleSort(int arr[]){int len=arr.length;while(len>0) {for (int i = 0; i < len-1; i++) {if (arr[i] > arr[i + 1]) {//交换两个元素exChange(arr,i,i+1);}}len--;}}

/*快排*/
public static void qSort(int arr[] ){sort(arr,0,arr.length-1);}private static void sort(int []arr,int head,int tail ){if(head>=tail)return;int j=partition(arr,head,tail);sort(arr,head,j-1);sort(arr,j+1,tail);}private  static int partition(int []a,int head,int tail){//将数组切分为a[head, ... ,i-1]，a[i]，a[i+1, ... ,tail]int i=head,j=tail+1;int pivot=a[head];      //切分元素while(true) {while (a[++i] < pivot) {if (i == tail)break;}while (a[--j] > pivot) {if (j == head)break;}if (i >= j)break;SortHelper.exChange(a,i,j);      //交换元素
        }//将pivot放入正确的位置
        SortHelper.exChange(a,head,j);return j;}

/*选择排序*/
/*每次选择最大的元素放入数组末尾*/
public static void selectSort(int arr[]){int n=arr.length-1;while(n>=0){int max=0;for(int i=0;i<=n;i++){if(arr[i]>arr[max]){max=i;}}SortHelper.exChange(arr,n,max);n--;}}

import java.util.Arrays;public class HeapSort {private int[] arr;public HeapSort(int[] arr){this.arr = arr;}/*** 堆排序的主要入口方法，共两步。*/public void sort(){/**  第一步：将数组堆化*  beginIndex = 第一个非叶子节点。*  从第一个非叶子节点开始即可。无需从最后一个叶子节点开始。*  叶子节点可以看作已符合堆要求的节点，根节点就是它自己且自己以下值为最大。*/int len = arr.length - 1;int beginIndex = (len - 1) >> 1; for(int i = beginIndex; i >= 0; i--){maxHeapify(i, len);}/** 第二步：对堆化数据排序* 每次都是移出最顶层的根节点A[0]，与最尾部节点位置调换，同时遍历长度 - 1。* 然后从新整理被换到根节点的末尾元素，使其符合堆的特性。* 直至未排序的堆长度为 0。*/for(int i = len; i > 0; i--){swap(0, i);maxHeapify(0, i - 1);}}private void swap(int i,int j){int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}/*** 调整索引为 index 处的数据，使其符合堆的特性。* * @param index 需要堆化处理的数据的索引* @param len 未排序的堆（数组）的长度*/private void maxHeapify(int index,int len){int li = (index << 1) + 1; // 左子节点索引int ri = li + 1;           // 右子节点索引int cMax = li;             // 子节点值最大索引，默认左子节点。if(li > len) return;       // 左子节点索引超出计算范围，直接返回。if(ri <= len && arr[ri] > arr[li]) // 先判断左右子节点，哪个较大。cMax = ri;if(arr[cMax] > arr[index]){swap(cMax, index);      // 如果父节点被子节点调换，maxHeapify(cMax, len);  // 则需要继续判断换下后的父节点是否符合堆的特性。
        }}/*** 测试用例* * 输出：* [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9]*/public static void main(String[] args) {int[] arr = new int[]{3,5,3,0,8,6,1,5,8,6,2,4,9,4,7,0,1,8,9,7,3,1,2,5,9,7,4,0,2,6};        new HeapSort(arr).sort();        System.out.println(Arrays.toString(arr));}}

/*递归方式*/
static void merge_sort_recursive(int[] arr, int[] result, int start, int end) {if (start >= end)return;int len = end - start, mid = (len >> 1) + start;int start1 = start, end1 = mid;int start2 = mid + 1, end2 = end;merge_sort_recursive(arr, result, start1, end1);merge_sort_recursive(arr, result, start2, end2);int k = start;while (start1 <= end1 && start2 <= end2)result[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];while (start1 <= end1)result[k++] = arr[start1++];while (start2 <= end2)result[k++] = arr[start2++];for (k = start; k <= end; k++)arr[k] = result[k];
}
public static void merge_sort(int[] arr) {int len = arr.length;int[] result = new int[len];merge_sort_recursive(arr, result, 0, len - 1);
}/*迭代方式*/
public static void merge_sort(int[] arr) {int len = arr.length;int[] result = new int[len];int block, start;// 原版代码的迭代次数少了一次，没有考虑到奇数列数组的情况for(block = 1; block < len; block *= 2) {for(start = 0; start <len; start += 2 * block) {int low = start;int mid = (start + block) < len ? (start + block) : len;int high = (start + 2 * block) < len ? (start + 2 * block) : len;//两个块的起始下标及结束下标int start1 = low, end1 = mid;int start2 = mid, end2 = high;//开始对两个block进行归并排序while (start1 < end1 && start2 < end2) {result[low++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];}while(start1 < end1) {result[low++] = arr[start1++];}while(start2 < end2) {result[low++] = arr[start2++];}}int[] temp = arr;arr = result;result = temp;}result = arr;
}