數組的幾種排序算法的實現（1）

數據結構中的排序算法,各有用處,比如:
1,直接插入排序,在序列基本有序的情況下,移動的次數比較少,但是比較次數是一樣的
復雜度O(n*n);
2,冒泡排序,這個不用說了吧,剛學C的人都懂了
3,希爾排序,只要是找出較好的增量,將數據排列成基本有序時,最后一次來一次直接插入排序,是對直接插入排序的改進.復雜度為O(n(3/2));
4,快速排序,算是所有排序中復雜度一般情況下比較好的算法,它設了一個樞軸,將它分為兩部分,左邊比它小,右邊的比它大,復雜度為O(nlog n);
5,選擇排序,和冒泡差不多的復雜度,
6,歸並排序,這是一種穩定的排序方法,將數據分為各個有序的部分,再組合為一個整體,只要用遞歸的方法.
7,還有基數排序,樹形排序,堆排序,等等,這里不多說了,你多多學習多多消化吧,慢慢學吧,多看看課本的算法,自己實現一次,學完了你的編程能力就能很好的提高了.

解釋：時間復雜度

舉個簡單的例子，要從0加到n，我們會這么寫：
int sum = 0;
for(int i = 0; i<=n; ++i)
{
   sum += i;
}
一共算了n次加法，那么就說這個時間復雜度是O(n)。當然O(n)的精確的概念是，是n的最高次方，比如，某個計算共計算了3n + 2次，那么這個時間復雜度也是O(n)，因為3n + 2中的最高次方是n。

如果代碼這么寫：
int sum = 0;
for(int i = 0; i<=n; ++i)
{
   for(int j = 0; j <=n; ++j)
   {
      sum += (i + j);
   }
}

很顯然一共算了n^2次加法，那么就說這個時間復雜度是O(n^2)，和上面類似，如果某個算法計算了3*n^2 + n + 1次，其時間復雜度仍然是O(n^2)，因為3*n^2 + n + 1中最高的次方是n^2

所謂O(1)就是計算的次數是個常量，我們還以上面從0加到n的例子來說，如果我們用等差數列的公式，那么，代碼可以這么寫：
int sum = n * (n + 1) / 2
不管n有多大(當然不能溢出了)，通過上面的公式只需計算一次，也就說計算的次數是不變的，這種情況的時間復雜度就可以說成O(1)。 再比如如果某個計算，不管其他條件怎么變化，均只需計算5次即可得出結果，那么這種情況的時間復雜度，也是O(1)。

 

數組的排序方法有很多，效率也各不相同，下面簡單介紹一下幾種常見的排序算法。

      1.選擇排序法：將要排序的數組分成兩部分，一部分是從大到小已經排好序的，一部分是無序的，從無序的部分取出最小的放到已經排序的最后面。實現如下：

public int[] choiceSort(int[] arr){
        for(int i = 0;i < arr.length;i++){
            int m = i;
            for(int j = i + 1;j < arr.length;j++){
                //如果第j個元素比第m個元素小，將j賦值給m
                if(arr[j] < arr[m]){
                    m = j;
                }
            }
            //交換m和i兩個元素的位置
            if(i != m){
                int t = arr[i];
                arr[i] = arr[m];
                arr[m] = t;
            }
        }
        return arr;
    }

       2.冒泡排序法：冒泡排序的思路就不用介紹了。上實現：

 

 

public int[] bubbleSort(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]){
                    int t = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = t;
                }
            }
        }
        return arr;
    }

      3.插入排序法：將要排序的數組分成兩部分，每次從后面的部分取出索引最小的元素插入到前一部分的適當位置。基本實現如下：

public int[] insertSort(int[] arr){
        for(int i = 1;i < arr.length;i++){
            int temp = arr[i];
            int j = i - 1;
            while(temp < arr[j]){
                arr[j+1] = arr[j];
                j--;
                if(j == -1){
                    break;
                }
            }
            arr[j+1] = temp;
        }
        return arr;
    }

      4.快速排序法：快速排序法號稱是目前最優秀的算法之一，實現思路是，將一個數組的排序問題看成是兩個小數組的排序問題，而每個小的數組又可以繼續看成更小的兩個數組，一直遞歸下去，直到數組長度大小最大為2。實現如下：

public int[] fastSort(int[] arr,int left,int right){
        if(left < right){
            int s = arr[left];
            int i = left;
            int j = right + 1;
            while(true){
                //向右找大於s的元素的索引
                while(i+1 < arr.length && arr[++i] < s);
                //向左找小於s的元素的索引
                while(j-1 > -1 && arr[--j] > s);
                //如果i >= j 推出循環
                if(i >= j){
                    break;
                }else{
                    //教化i和j位置的元素
                    int t = arr[i];
                    arr[i] = arr[j];
                    arr[j] = t;
                }
            }
            arr[left] = arr[j];
            arr[j] = s;
            //對左面進行遞歸
            fastSort(arr,left,j-1);
            //對右面進行遞歸
            fastSort(arr,j+1,right);
        }
        return arr;
    }