（转载）【8种排序算法】Java实现

import java.util.Arrays;
import java.util.Scanner;

/**
 * 
 * 1. 冒泡排序
 * 2. 选择排序
 * 3. 直接插入排序
 * 4. 希尔排序
 * 5. 快速排序
 * 6. 归并排序
 * 7. 堆排序
 * 8. 基数排序
 * 
 * @author CN
 *
 */
public class SortUtils {
	
	public static void main(String[] args) {
		int[] arr= {49,38,65,97,76,13,27};
		
//		bubleSort(arr);
		//selectSort(arr);
//		insertSort(arr);
//		shellSort(arr);
//		quickSort(arr, 0, arr.length-1);
//		RadixSort(arr, 2);
//		heapSort(arr);
//		mergeSort(arr);
        System.out.println(Arrays.toString(arr));
        
        noSum();
	}

	
	/**
	 * 1. 冒泡排序
	 * @param arr
	 */
	public static void bubleSort(int[] arr) {
		for(int i=0; i<arr.length; i++)
			for(int j=0; j<arr.length-i-1; j++)
				if(arr[j] > arr[j+1])
					swap(arr, j, j+1);
	}
	
	
	/**
	 * 2. 选择排序
	 * @param arr
	 */
	public static void selectSort(int[] arr) {
		int pos = 0;
		for(int i=0; i<arr.length; i++) {
			pos = i;
			for(int j=i+1; j<arr.length; j++)
				if(arr[j] < arr[pos])
					pos = j;
			swap(arr, i, pos);
		}
	}
	
	
	/**
	 * 3. 直接插入排序
	 * @param arr
	 */
	public static void insertSort(int[] arr) {
		for(int i=1; i<arr.length; i++)
			for(int j=i; j>0 && arr[j]<arr[j-1]; j--)
				swap(arr, j, j-1);
	}
	
	
	/**
	 * 4. 希尔排序
	 * @param arr 原数组
	 */
	public static void shellSort(int[] arr) {
		for(int dk=arr.length/2; dk>0; dk/=2) {
			// 从第dk个元素，逐个对其所在组进行直接插入排序操作
			for(int i=dk; i<arr.length; i++) {
				for(int j=i; j-dk>=0 && arr[j]<arr[j-dk]; j -= dk)
					swap(arr, j, j-dk);
			}
		}
	}
	
	
	/**
	 * 5. 快速排序
	 * @param arr 原数组
	 * @param low 开始位置
	 * @param high 结束位置
	 */
    public static void quickSort(int[] arr, int low, int high) {
        int key = arr[low]; // 选择枢轴
        int i = low;
        int j = high;

        while(i < j) {
            while(i < j && key <= arr[j]) j--; // 从后往前
            if(i < j)  arr[i++] = arr[j]; // 小值前放
            
            while(i < j && key >= arr[i])  i++; // 从前往后
            if(i < j)  arr[j--] = arr[i]; // 大值后放
        }
        arr[i] = key;
        
        // 左侧排序
        if(i-1 > low) quickSort(arr, low, i-1);
        // 右侧排序
        if(i+1 < high) quickSort(arr, i+1, high);
    }
    
    
    /**
     * 6. 归并排序
     * @param arr 原数组
     */
    public static void mergeSort(int[] arr) {
    	divide(arr, 0, arr.length-1);
    }
    /** 分 */
    public static void divide(int[] arr, int left, int right) {
    	if(left < right) {
    		// 对半拆分
    		int mid = (left + right)/2;
    		divide(arr, left, mid);
    		divide(arr, mid+1, right);
    		// 两个分组进行合并
    		merge(arr, left, mid+1, right);
    	}
    }
    /** 治 */
    public static void merge(int[] arr, int left, int mid, int right) {
    	int len = right-left+1;
    	int[] tmp = new int[len];
    	int i = 0;
    	int j = left;
    	int k = mid;
    	while(i < len) {
    		if(k > right) { // 如果右分组已全部被使用，将左分组全部移至至临时数组中
    			System.arraycopy(arr, j, tmp, i, mid-j);
    			break;
    		}
    		while(j<mid && arr[j]<arr[k]) // 如果左分组的第一个小，则移至临时数组
    			tmp[i++] = arr[j++];
    		if(j >= mid) { // 如果左分组已全部被使用，将右分组全部移至临时数组中
    			System.arraycopy(arr, j, tmp, i, right-k+1);
    			break;
    		}
    		while(k<=right && arr[k]<arr[j]) // 如果右分组的第一个小，则移至临时数组
    			tmp[i++] = arr[k++];
    	}
    	// 将临时数组复制至原数组中
    	System.arraycopy(tmp, 0, arr, left, len);
    }
    
    
    /**
     * 7. 堆排序(大顶堆-升序)
     * @param arr 原数组
     */
    public static void heapSort(int[] arr) {
    	// 构造大顶堆
    	for(int i=arr.length/2-1; i>=0; i--) {
    		adjustHeap(arr, i, arr.length);
    	}
    	// 选出最大值置于尾部，并调整堆
    	for(int i=arr.length-1; i>=0; i--) {
    		swap(arr, 0, i); // 交换至尾部
    		adjustHeap(arr, 0, i); // 重新调整
    	}
    }
    /**
     * 调整为堆大顶堆(在大顶堆的基础上)
     * @param arr 原数组
     * @param i 开始调整的位置
     * @param length 长度
     */
    public static void adjustHeap(int[] arr, int i, int length) {
    	// 从左子节点开始
    	for(int k=2*i+1; k<length; k=2*i+1) {
    		// 判断右子节点是否比左节点大
    		if(k+1 < length && arr[k]<arr[k+1])
    			k = k+1;
    		// 判断最大的子节点与父节点的大小
    		if(arr[k] > arr[i]) {
    			swap(arr, k, i);
    			i = k;
    		}
    		else // 比子节点都大，退出循环
    			break;
    	}
    }
    /** 交换函数 */
    public static void swap(int arr[], int i, int j) {
    	int temp = arr[i];
    	arr[i] = arr[j];
    	arr[j] = temp;
    }
    
    
    /**
     * 8. 基数排序
     * @param arr 原数组
     * @param maxLen 数字的最长位数
     */
    public static void RadixSort(int[] arr, int maxLen) {
    	int[][] tmp = new int[10][arr.length];
    	int[] nums = new int[10];
    	int d = 1; // 第i位数
    	int n = 1;
    	while(d <= maxLen) {
	    	for(int i=0; i<arr.length; i++) {
	    		// 获取某一位数
	    		int lsd = arr[i] / n % (10*d);
	    		tmp[lsd][nums[lsd]++] = arr[i];
	    	}
	    	// 放回原数组
	    	int k = 0;
	    	for(int i=0; i<10; i++) {
	    		for(int j=0; j<nums[i]; j++) 
	    			arr[k++] = tmp[i][j];
	    		nums[i] = 0;
	    	}
	    	d++;
	    	n *= 10;
	    	System.out.println(Arrays.toString(arr));
    	}
    }
    
    public static void noSum(){
    	/*System.out.println("第1个月的兔子对数:    1");
    	System.out.println("第2个月的兔子对数:    1");
    	int f1 = 1, f2 = 1, f, M=24;
    	for(int i=3; i<=M; i++) {
	    	 f = f2;
	    	 f2 = f1 + f2;
	    	 f1 = f;
	    	 System.out.println("第" + i +"个月的兔子对数: "+f2);
    	}*/
    	
    	 /* int count = 0;
    	  for(int i=101; i<200; i+=2) {
		    	 boolean b = false;
		    	 for(int j=2; j<=Math.sqrt(i); j++){
		    		 if(i % j == 0) { 
		    			 b = false; break; 
		    		 } else{ 
		    		  	b = true; 
		    		 }
		    	 }
		    	 if(b == true) {
		    		  count ++;System.out.println(i);
		    	 }
    	  }
    	  System.out.println( "素数个数是: " + count);*/

    	int[][] a = new int[10][10];
    	for(int i=0; i<10; i++) {
    		a[i][i] = 1;
    		a[i][0] = 1;
    	}
    	for(int i=2; i<10; i++) {
    		for(int j=1; j<i; j++) {
    			a[i][j] = a[i-1][j-1] + a[i-1][j];
    		}
    	}
    	for(int i=0; i<10; i++) {
    		for(int k=0; k<2*(10-i)-1; k++) {
    			System.out.print(" ");
    		}
	    	for(int j=0; j<=i; j++) {
	    			System.out.print(a[i][j] + "   ");
	    	}
    		System.out.println();
    	}
    }
}