八種排序算法（內部排序）

　　八種排序算法很長時間沒有使用了，今天做一個總結，方便以后自己用的時候參考。

　　這八種排序算法都是內部算法，這八種排序算法分別是：

　　1. 插入排序
　　　　1）直接插入排序
　　　　2）希爾排序
　　2.選擇排序
　　　　1）簡單選擇排序
　　　　2）堆排序
　　3.交換排序
　　　　1）冒泡排序
　　　　2）快速排序
　　4.歸並排序
　　5.基數排序

一、直接插入排序

　　將一個記錄插入到已經排好序的有序表中，從而得到一個新的、記錄數增1的有序表。在實際操作中，先將序列的第一個記錄看成是一個有序的子序列，然后從第二個、第三個、……記錄逐個進行插入，直至整個序列有序為止。

　　插入排序算法Java實現：

　　public class DirectInsertionSort {
　　　　/**
　　　　* 直接插入排序
　　　　* @param args
　　　　*/
　　　　public static void main(String[] args) {
　　　　　　int[] arrayInt = {17,56,80,17,12,9,100,64,42,37,64,82,123,974,314,548};
　　　　　　int length = arrayInt.length;
　　　　　　
　　　　　　for( int i=1; i<length; i++){
　　　　　　　　for( int j=i; j>0; j--){
　　　　　　　　　　if( arrayInt[j] <= arrayInt[j-1]){
　　　　　　　　　　　　int k = arrayInt[j];
　　　　　　　　　　　　arrayInt[j] = arrayInt[j-1];
　　　　　　　　　　　　arrayInt[j-1] = k;
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}

　　　　　　for( int i=0; i<length; i++){
　　　　　　　　System.out.println( arrayInt[i]);
　　　　　　}
　　　　}

　　}

二、希爾排序

　　先將整個待排序的記錄序列分割成為若干子序列分別進行直接插入排序，帶整個序列中的記錄“基本有序”時，再對全體記錄進行依次直接插入排序。

　　希爾排序Java實現：

　　public class ShellSort {
　　　　/**
　　　　* 希爾排序
　　　　* @param args
　　　　*/
　　　　public static void main(String[] args) {
　　　　　　int[] arrayInt = {17,56,80,17,12,9,100,64,42,37,64,82,123,974,314,548};
　　　　　　int length = arrayInt.length;
　　　　　　System.out.println( "length="+length);

　　　　　　shellSort( arrayInt);

　　　　　　for( int i=0; i<length; i++){
　　　　　　　　System.out.println( "arrayInt[" + i + "]=" + arrayInt[i]);
　　　　　　}

　　　　}

　　　　public static void shellSort( int[] arrayInt){
　　　　　　int j = 0;
　　　　　　int temp = 0;
　　　　　　for ( int increment=arrayInt.length/2; increment>0; increment/=2){
　　　　　　　　for ( int i=increment; i<arrayInt.length; i++){
　　　　　　　　　　temp = arrayInt[i];
　　　　　　　　　　for ( j=i; j>=increment; j-=increment){
　　　　　　　　　　　　if( temp > arrayInt[j-increment]){
　　　　　　　　　　　　　　arrayInt[j] = arrayInt[j - increment];
　　　　　　　　　　　　}else{
　　　　　　　　　　　　　　break;
　　　　　　　　　　　　}
　　　　　　　　　　}
　　　　　　　　　　arrayInt[j] = temp;
　　　　　　　　}
　　　　　　}
　　　　}

　　}

三、簡單選擇排序

　　在待排序的一組數中，選出最小（大）的一個數與第一個位置的數交換；然后在剩下的數當中再找最小（大）的與第二個位置的數交換，以此類推，直到第n-1個元素和第n個元素比較為止。

　　簡單選擇排序Java實現：

　　public class SimpleSelectionSort {
　　　　/**
　　　　* 簡單選擇排序
　　　　* @param args
　　　　*/
　　　　public static void main(String[] args) {
　　　　　　int[] arrayInt = {17,56,80,17,12,9,100,64,42,37,64,82,123,974,314,548};
　　　　　　int length = arrayInt.length;

　　　　　　for( int i=0; i<length; i++){
　　　　　　　　for( int j=i+1; j<length; j++){
　　　　　　　　　　if( arrayInt[i] > arrayInt[j]){
　　　　　　　　　　　　int k = arrayInt[i];
　　　　　　　　　　　　arrayInt[i] = arrayInt[j];
　　　　　　　　　　　　arrayInt[j] = k;
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}
　　　　　　
　　　　　　for( int i=0; i<length; i++){
　　　　　　　　System.out.println( arrayInt[i]);
　　　　　　}
　　　　}

　　}

四、堆排序

　　一種樹形選擇排序，是對直接選擇排序的有效改進。

　　堆排序Java實現：

 

五、冒泡排序

　　對待排序的一組數，自上而下對相鄰的兩個數依次進行比較和調整，讓較大（小）的數往下沉，較小（大）的往上冒。即：每當兩相鄰的數比較后發現它們的排序與排序要求相反時，就將它們互換。

　　冒泡排序Java實現：

　　public class BubbleSort {
　　　　/**
　　　　* 冒泡排序
　　　　* @param args
　　　　*/
　　　　public static void main(String[] args) {
　　　　　　int[] arrayInt = {17,56,80,17,12,9,100,64,42,37,64,82,123,974,314,548};
　　　　　　int length = arrayInt.length;
　　　　　　
　　　　　　for( int i=0; i<length-1; i++){
　　　　　　　　for( int j=0; j<length-i-1; j++){
　　　　　　　　　　if( arrayInt[j] > arrayInt[j+1]){
　　　　　　　　　　　　int k = arrayInt[j];
　　　　　　　　　　　　arrayInt[j] = arrayInt[j+1];
　　　　　　　　　　　　arrayInt[j+1] = k;
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}
　　　　　　
　　　　　　for( int i=0; i<length; i++){
　　　　　　　　System.out.println( arrayInt[i]);
　　　　　　}
　　　　}

　　}

六、快速排序

　　通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然后再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

　　快速排序Java實現：

　　public class QuickSort {
　　　　/**
　　　　* 快速排序
　　　　* @param args
　　　　*/
　　　　public static void main(String[] args) {
　　　　　　int[] arrayInt = {17,56,80,17,12,9,100,64,42,37,64,82,123,974,314,548};
　　　　　　int start = 0;
　　　　　　int end = arrayInt.length-1;
　　　　　　
　　　　　　quickSort( arrayInt, start, end);
　　　　　　
　　　　}

　　　　public static void quickSort( int[] arrayInt, int start, int end){
　　　　　　if( start >= end){
　　　　　　　　return;
　　　　　　}
　　　　　　
　　　　　　int i = start;
　　　　　　int j = end;
　　　　　　int value = arrayInt[start];
　　　　　　boolean flag = true;
　　　　　　
　　　　　　while( i != j){
　　　　　　　　if( flag){
　　　　　　　　　　if( value > arrayInt[j]){
　　　　　　　　　　　　int k = arrayInt[i];
　　　　　　　　　　　　arrayInt[i] = arrayInt[j];
　　　　　　　　　　　　arrayInt[j] = k;
　　　　　　　　　　　　i++;
　　　　　　　　　　　　flag = false;
　　　　　　　　　　}else{
　　　　　　　　　　　　j--;
　　　　　　　　　　}
　　　　　　　　}else{
　　　　　　　　　　if( value < arrayInt[i]){
　　　　　　　　　　　　int k = arrayInt[i];
　　　　　　　　　　　　arrayInt[i] = arrayInt[j];
　　　　　　　　　　　　arrayInt[j] = k;
　　　　　　　　　　　　j--;
　　　　　　　　　　　　flag = true;
　　　　　　　　　　}else{
　　　　　　　　　　　　i++;
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}
　　　　　　
　　　　　　for( int m=0; m<arrayInt.length; m++){
　　　　　　　　System.out.print(arrayInt[m] + " ");
　　　　　　}
　　　　　　System.out.println();
　　　　　　
　　　　　　quickSort( arrayInt, start, j-1);
　　　　　　quickSort( arrayInt, i+1, end);
　　　　}
　　　　
　　}

七、歸並排序

　　建立在歸並操作上的一種有效的排序算法，該算法是采用“分治法”的一個非常典型的應用。

　　歸並排序Java實現：

　　public class MergeSort {
　　　　/**
　　　　* 歸並排序
　　　　* @param args
　　　　*/
　　　　public static void main(String[] args) {
　　　　　　int[] arrayInt = {17,56,80,17,12,9,100,64,42,37,64,82,123,974,314,548};
　　　　　　int start = 0;
　　　　　　int end = arrayInt.length-1;
　　　　　　
　　　　　　mergeSort( arrayInt, start, end);
　　　　　　
　　　　　　for( int i=0; i<arrayInt.length; i++){
　　　　　　　　System.out.print( arrayInt[i]+" ");
　　　　　　}
　　　　}

　　　　public static int[] mergeSort( int[] arrayInt, int start, int end){
　　　　　　int middle = ( start+end)/2;
　　　　　　
　　　　　　if( start < end){
　　　　　　　　mergeSort( arrayInt, start, middle);
　　　　　　　　mergeSort( arrayInt, middle+1, end);
　　　　　　　　sort( arrayInt, start, middle, end);
　　　　　　}
　　　　　　
　　　　　　return arrayInt;
　　　　}
　　　　
　　　　public static void sort( int[] arrayInt, int start, int middle, int end){
　　　　　　int[] arrayTemp = new int[ end-start+1];
　　　　　　int i = start;
　　　　　　int j = middle +1;
　　　　　　int k = 0;
　　　　　　
　　　　　　while( i <= middle && j <= end){
　　　　　　　　if( arrayInt[i] < arrayInt[j]){
　　　　　　　　　　arrayTemp[k] = arrayInt[i];
　　　　　　　　　　k++;
　　　　　　　　　　i++;
　　　　　　　　}else{
　　　　　　　　　　arrayTemp[k] = arrayInt[j];
　　　　　　　　　　k++;
　　　　　　　　　　j++;
　　　　　　　　}
　　　　　　}
　　　　　　
　　　　　　while( i<=middle){
　　　　　　　　arrayTemp[k] = arrayInt[i];
　　　　　　　　k++;
　　　　　　　　i++;
　　　　　　}
　　　　　　
　　　　　　while( j <= end){
　　　　　　　　arrayTemp[k] = arrayInt[j];
　　　　　　　　k++;
　　　　　　　　j++;
　　　　　　}
　　　　　　
　　　　　　for( int m=0; m<arrayTemp.length; m++){
　　　　　　　　arrayInt[m+start] = arrayTemp[m];
　　　　　　}
　　　　}

　　}

八、基數排序

　　屬於“分配式排序”，又稱“桶子法”。它是透過鍵值的部份資訊，將要排序的元素分配至某些“桶”中，藉以達到排序的作用。基數排序法是屬於穩定性的排序。

　　基數排序Java排序：