八大排序方法——JAVA实现版本 (拿下来直接可以运行)

package sort;

import java.lang.reflect.Array;

public class mainsort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] intlist=new int[] {4,7,9,1,3,0};
		int[] result=new int[100];
		//1，冒泡排序
		//BubbleSort(intlist);
		//2，选择排序
		//SelectSort(intlist);
		//3.直接插入排序
		//insertSort(intlist);
		//3.2 直接插入排序升级版
		//insertEnhanceSort(intlist);
		//4. 快速排序
		//fastSort(intlist,0,intlist.length-1);
		//5. 希尔排序
		//ShellSortchange(intlist);
		
		//6. 归并排序
		//merge_sort_recursive(intlist,0,intlist.length-1);
		
		//7.基数排序
		//radixSort(intlist);
		
		//8.堆排序
		heapSort(intlist);
		for(int i=0;i<intlist.length;i++) {
			System.out.print(intlist[i]+",");
		}
		}
		
	
	//1,冒泡排序代码实现
	public static int[] BubbleSort(int [] a) {
		for(int i=0;i<a.length-1;i++) {
			for(int j=0;j<a.length-1-i;j++) {
				if(a[j]>a[j+1]) {
					int temp=a[j];
					a[j]=a[j+1];
					a[j+1]=temp;
				}
			}
		}
		
		return a;
	}
	
	//2,选择排序代码实现
	public static int[] SelectSort(int[] a) {
		
		for(int i=0;i<a.length;i++) {
			int minindex=i;
			for(int j=i+1;j<a.length;j++) {
				if(a[j]<a[minindex]) {
					minindex=j;
				}
			}
			if(minindex!=i) {
				int temp=a[minindex];
				a[minindex]=a[i];
				a[i]=temp;
			}
		}

		return a;
	}
	
	
	//3.1，直接插入排序 (基础功能版本)
	public static int[] insertSort(int[] a) {
		
		for(int i=1;i<a.length;i++) {
			for(int j=i;j>0;j--) {
				if(a[j]<a[j-1]) {
					int temp=a[j];
					a[j]=a[j-1];
					a[j-1]=temp;
				}
			}
		}
		
		
		return a;
	}
	
	
	//3.2 直接插入排序升级版
	public static int[] insertEnhanceSort(int[] a) {
		
		for(int i=1;i<a.length;i++) {
			int temp=a[i];
			int j;
			for(j=i;j>0&&temp<a[j-1];j--) {
					a[j]=a[j-1];
			}
			
			a[j]=temp;
		}
		
		return a;
	}
	
	//4 快速排序 
	public static int[] fastSort(int[] a,int low,int high) {
		
		if(low<high) {
			int index=getIndex(a,low,high);
			fastSort(a,low,index-1);
			fastSort(a,index+1,high);
		}
		return a ;
	}
	
	
	public static int getIndex(int[] a ,int low ,int high) {
		int temp =a[low];
		while(low<high) {
			while(low<high&&(a[high]>=temp)) {
				high--;
			}
			
			a[low]=a[high];
			while(low<high&&(a[low]<=temp)) {
				low++;
			}
			a[high]=a[low];
		}
		
		a[low]=temp;
		
		return low;
	}
	
	//5.1 希尔排序
	public static int[] ShellSortchange(int[] a) {
		for(int gap=a.length/2;gap>0;gap/=2) {
			for(int i=gap;i<a.length;i++) {
				int j=i;
				while(j-gap>=0&&a[j]<a[j-gap]) {
					//插入排序采用交换法
					int temp=a[j-gap];
					a[j-gap]=a[j];
					a[j]=temp;
					j-=gap;
				}
			}
		}
		return a;
	}
	
	
	//5.2 希尔排序
	public static int[] ShellSortmove(int[] a) {
		         //增量gap，并逐步缩小增量
		         for(int gap=a.length/2;gap>0;gap/=2){
		             //从第gap个元素，逐个对其所在组进行直接插入排序操作
		             for(int i=gap;i<a.length;i++){
		                 int j = i;
		                 int temp = a[j];
		                 if(a[j]<a[j-gap]){
		                     while(j-gap>=0 && temp<a[j-gap]){
		                         //移动法
		                         a[j] = a[j-gap];
		                         j-=gap;
		                     }
		                     a[j] = temp;
		                 }
		             }
		         }
		         
		         return a;
	}
	
	
	
	//6. 基数排序
	  public static void radixSort(int[] arr){
	        //获取最大的数
	        int maxNum = arr[0];
	        for(int i=1;i<arr.length;i++){
	            if(arr[i] > maxNum){
	                maxNum = arr[i];
	            }
	        }
	        //获取最大数的位数
	        int maxLength = (maxNum+"").length();
	        //创建处理排序的通
	        int[][] bucket = new int[10][arr.length];
	        //创建记录各个桶里装的元素计数器,如bucketCount[0]表示bucket[0]里装的元素个数
	        int[] bucketCount = new int[10];
	        //需要处理maxLength次,第一次处理个位,第二次处理十位,第三次处理百位
	        //count用来控制循环次数,n用来辅助取位数上的数字
	        for(int count=0,n=1;count<maxLength;count++,n*=10){
	            //用来遍历数组的每个数
	            for(int i=0;i<arr.length;i++){
	                //得到元素该轮位上的数
	                int result = arr[i] / n % 10;
	                //将该元素放入对应的桶中
	                bucket[result][bucketCount[result]] = arr[i];
	                //对应桶的计数器++
	                bucketCount[result]++;
	            }
	            //到这里,原数组的元素已全部放入桶中,开始从桶中依次取出元素
	            //index是原数组的下标
	            int index = 0;
	            //共有bucketCount.length个桶的元素需要取出
	            for(int j=0;j<bucketCount.length;j++){
	                //从桶中依次取出bucketCount[j]个元素
	                for(int m=0;m<bucketCount[j];m++){
	                    arr[index++] = bucket[j][m];
	                }
	                //取出元素后,将该桶计数器归零
	                bucketCount[j] = 0;
	            }
	        }

	    }
	
	//7.归并排序
	public static int[] merge_sort_recursive(int[] a,int low,int high){
        int mid = (low+high)/2;
        if(low<high){
        	merge_sort_recursive(a,low,mid);
            merge_sort_recursive(a,mid+1,high);
            //左右归并
            merge(a,low,mid,high);
        }
        return a;
    }
     
    public static void merge(int[] a, int low, int mid, int high) {
        int[] temp = new int[high-low+1];
        int i= low;
        int j = mid+1;
        int k=0;
        // 把较小的数先移到新数组中
        while(i<=mid && j<=high){
            if(a[i]<a[j]){
                temp[k++] = a[i++];
            }else{
                temp[k++] = a[j++];
            }
        }
        // 把左边剩余的数移入数组 
        while(i<=mid){
            temp[k++] = a[i++];
        }
        // 把右边边剩余的数移入数组
        while(j<=high){
            temp[k++] = a[j++];
        }
        // 把新数组中的数覆盖nums数组
        for(int x=0;x<temp.length;x++){
            a[x+low] = temp[x];
        }
    }
	
	//8.堆排序
    /**
    * 选择排序-堆排序
    * @param array 待排序数组
    * @return 已排序数组
    */
    public static int[] heapSort(int[] array) {
        //这里元素的索引是从0开始的,所以最后一个非叶子结点array.length/2 - 1
        for (int i = array.length / 2 - 1; i >= 0; i--) {  
            adjustHeap(array, i, array.length);  //调整堆
        }
  
        // 上述逻辑，建堆结束
        // 下面，开始排序逻辑
        for (int j = array.length - 1; j > 0; j--) {
            // 元素交换,作用是去掉大顶堆
            // 把大顶堆的根元素，放到数组的最后；换句话说，就是每一次的堆调整之后，都会有一个元素到达自己的最终位置
            swap(array, 0, j);
            // 元素交换之后，毫无疑问，最后一个元素无需再考虑排序问题了。
            // 接下来我们需要排序的，就是已经去掉了部分元素的堆了，这也是为什么此方法放在循环里的原因
            // 而这里，实质上是自上而下，自左向右进行调整的
            adjustHeap(array, 0, j);
        }
        return array;
    }
  
    /**
    * 整个堆排序最关键的地方
    * @param array 待组堆
    * @param i 起始结点
    * @param length 堆的长度
    */
    public static void adjustHeap(int[] array, int i, int length) {
        // 先把当前元素取出来，因为当前元素可能要一直移动
        int temp = array[i];
        for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {  //2*i+1为左子树i的左子树(因为i是从0开始的),2*k+1为k的左子树
            // 让k先指向子节点中最大的节点
            if (k + 1 < length && array[k] < array[k + 1]) {  //如果有右子树,并且右子树大于左子树
                k++;
            }
            //如果发现结点(左右子结点)大于根结点，则进行值的交换
            if (array[k] > temp) {
                swap(array, i, k);
                // 如果子节点更换了，那么，以子节点为根的子树会受到影响,所以，循环对子节点所在的树继续进行判断
                    i  =  k;
                        } else {  //不用交换，直接终止循环
                break;
            }
        }
    }
  
    /**
    * 交换元素
    * @param arr
    * @param a 元素的下标
    * @param b 元素的下标
    */
    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
	

	
}