java实现七大排序（插入，冒泡，选择，快速，堆，希尔，归并）

一、插入排序：

package com.ma.sort;

/**
 * Created by mh on 2018/1/3.
 */
public class InsertSort2 {
    public static void insert(int[] arr){
        for(int i = 1;i < arr.length;i++){//从arr[1](第二项)开始
            int j = i;
            int tmp = arr[j];
            while(j > 0 && (tmp < arr[j-1])){
                arr[j] = arr[j-1];
                j--;
            }
            arr[j] = tmp;
        }
    }
    public static void main(String[] args){
        int[] a = {7,4,8,3,10,6,11,2,12};
        insert(a);
        for(int i = 0;i<a.length;i++){
            System.out.print(a[i]+",");
        }
    }
}

二、冒泡排序（从后往前冒泡）：

package com.ma.sort;

/**
 * Created by mh on 2018/1/3.
 */
public class BubbleSort2 {
    public static void bub(int[] arr){
        for(int i=0;i<arr.length;i++){
            for(int j=arr.length-1;j>i;j--){//从后往前冒泡
                if(arr[j] < arr[j-1]){
                    int tmp = arr[j-1];
                    arr[j-1] = arr[j];
                    arr[j] = tmp;
                }
            }
        }
    }

    public static void main(String[] args){
        int[] a = {7,4,8,3,10,6,11,2,12};
        bub(a);
        for(int i = 0;i<a.length;i++){
            System.out.print(a[i]+",");
        }
    }
}

三、选择排序：

public class Select_sort {

	public static void selectionSort(int[] a) {
		int n = a.length;
		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;
				}
			}
			// 将最小值和a[i]调换
			if (k > i) {
				int tmp = a[i];
				a[i] = a[k];
				a[k] = tmp;
			}
		}
	}

	public static void main(String[] args) {
		int[] b = {7,4,8,3,10,6,11,2,12};
		selectionSort(b);
		for (int i = 0; i < b.length; i++) {
			System.out.print(b[i] + ",");
		}
	}
}

四、快速排序：

此文章讲的很好，不会的可以看下：快速排序原理剖析

我写的与该文章讲的有些许不同，但原理是一样的。

package com.ma.sort;

/**
 * Created by mh on 2018/1/3.
 */
public class QucikSort2 {
    public static int par(int[] brr,int start,int end){
        int key = brr[start];//以最左边为基准
        while(start<end){
            while(brr[end]>=key && start<end){//从右往左扫描，找比key小的值
                end--;
            }
            brr[start] = brr[end];
            while(brr[start]<=key && start<end){//从左往右扫描，找比key大的值
                start++;
            }
            brr[end] = brr[start];
        }
        brr[end] = key;
        return end;//此时end和start已经是一样的了
    }

    public static void sort(int[] arr,int lo,int high){
        if(lo>=high) return;
        int mid = par(arr,lo,high);
        sort(arr,lo,mid-1);
        sort(arr,mid+1,high);
    }

    public static void main(String[] args){
        int[] a = {7,4,8,3,10,6,11,2,12};
        sort(a,0,a.length-1);
        for(int i = 0;i<a.length;i++){
            System.out.print(a[i]+",");
        }
    }
}

五、堆排序：（最大堆）

package com.ma.sort;

/**
 * Created by mh on 2018/1/4.
 */
public class HeapSort {
    public static void heap(int[] arr,int start,int end){
        int i = 2*start+1;//如果存在那么i是start左孩子
        int tmp = arr[start];
        int k = start;
        while(i<=end){
            if((i+1)<=end && arr[i+1] > arr[i]) i = i + 1;//如果右孩子大于左孩子，那么i变为右孩子
            if(arr[i] < tmp) break;     //是小于tmp而不是arr[i]
            arr[k] = arr[i];
            k = i;
            i = 2*i+1;
        }
        arr[k] = tmp;

    }

    public static void sort(int[] arr,int length){
        for(int i = (length-1)/2;i >= 0;i--){//一开始堆是完全无序的，需从最后一个节点的父节点开始建立最大堆
            heap(arr,i,length);              //如下面main函数的3就是最后一个节点的父节点
        }
        for(int j = length;j > 0;j--){
            int tmp = arr[0];	//将最大值（堆头元素）与最后一个元素交换
            arr[0] = arr[j];
            arr[j] = tmp;
            heap(arr,0,j-1);
        }
    }

    public static void main(String[] args){
        int[] a = {7,4,8,3,10,6,11,2,12};
        sort(a,a.length-1);
        for(int i = 0;i<a.length;i++){
            System.out.print(a[i]+",");
        }
    }
}

六、希尔排序

package com.ma.test;
/**
 * Created by mh on 2017/12/3.
 */
public class ShellSort {
    public static void shellSort(int[] data) {
        int j;
        int temp;
        for (int increment = data.length / 2; increment > 0; increment /= 2) {//跨度increment
           // System.out.println("increment:" + increment);
            for (int i = increment; i < data.length; i++) {
                temp = data[i];
                for (j = i - increment; j >= 0; j -= increment) {//以跨度为increment进行插入排序
                    if (temp < data[j]) {
                        data[j + increment] = data[j];
                    } else {
                        break;
                    }
                }
                data[j + increment] = temp;
            }
        }
    }

    public static void main(String[] args) {
        int[] data = new int[] {7,4,8,3,10,6,11,2,12};
        shellSort(data);
        for (int i = 0; i < data.length; i++)
            System.out.print(data[i] + " ");
    }
}

七、归并排序

package com.ma.sort;

/**
 * Created by mh on 2018/1/3.
 */
public class MergeSort2 {
    public static void merge(int[] arr,int lo,int mid,int hi){//将两个有序数组合并成一个有序数组
        int[] tmp = new int[hi-lo+1];
        int i = 0;
        int k = lo;
        int j = mid+1;
        while(k <= mid && hi >= j){
            if(arr[k] > arr[j]) {
                tmp[i++] = arr[j++];
            }else{
                tmp[i++] = arr[k++];
            }
        }
        while(k <= mid){
            tmp[i++] = arr[k++];
        }
        while(j <= hi){
            tmp[i++] = arr[j++];
        }
        for(int z = 0;z < tmp.length;z++){
            arr[lo+z] = tmp[z];
        }
    }

    public static void sort(int[] arr,int lo,int hi){
        int mid = lo+(hi-lo)/2;
        if(lo < hi){
            sort(arr,lo,mid);
            sort(arr,mid+1,hi);
            merge(arr,lo,mid,hi);
        }

    }
    public static void main(String[] args){
        int[] a = {7,4,8,3,10,6,11,2,12};
        sort(a,0,a.length-1);
        for(int i = 0;i<a.length;i++){
            System.out.print(a[i]+",");
        }
    }

}

过程不想写了，类似的如下....(来自百度百科）