java排序(轉)

/**//*功能:用Java語言實現直接插入排序
*直接插入排序是穩定的。算法時間複雜度是O(n ^2) 
*Date:2007-11-16
*Author:kemwin
*/
public class InsertSort ...{

public void sort(int[] data)...{ //定義參數爲數組首地址
   int i,j,temp;
   for(i=0;i<data.length;i++)...{ //插入,降序
    temp=data[i]; //temp爲要插入的元素
    j=i-1;                  
    while(j>=0&&temp>data[j]) //從a[i-1]開始找比a[i]小的數(也就是找比temp小的數),同時把數組元素向後移
    ...{
     data[j+1]=data[j];
     j--;
    }
  
    data[j+1]=temp; //插入
   
    /**//*以下是打印每一次排序後的序列,與算法無關*/
    for(int q=0;q<data.length;q++)...{
      System.out.print(data[q]+" "); 
      } 
    System.out.println(); //換行
   }
   
}

public static void main(String[] args)...{
   InsertSort insertSort=new InsertSort();
   int[] a=...{1,6,5,3,8};
   for(int i=0;i<a.length;i++)
   System.out.print(a[i]+" ");
   System.out.println(" 降序排序");
   insertSort.sort(a); 
  
   System.out.println("  after sort:");
   for(int i=0;i<a.length;i++)
    System.out.print(a[i]+" ");

}
}

 

 

快速排序(QuickSort)（時間複雜度：N*logN.）

1、算法思想
    　快速排序是C.R.A.Hoare於1962年提出的一種劃分交換排序。它採用了一種分治的策略，通常稱其爲分治法(Divide-and-ConquerMethod)。

（1） 分治法的基本思想
    　分治法的基本思想是：將原問題分解爲若干個規模更小但結構與原問題相似的子問題。遞歸地解這些子問題，然後將這些子問題的解組合爲原問題的解。

（2）快速排序的基本思想
    　設當前待排序的無序區爲R[low..high]，利用分治法可將快速排序的基本思想描述爲：
①分解：
    　在R[low..high]中任選一個記錄作爲基準(Pivot)，以此基準將當前無序區劃分爲左、右兩個較小的子區間R[low..pivotpos-1)和R[pivotpos+1..high]，並使左邊子區間中所有記錄的關鍵字均小於等於基準記錄(不妨記爲pivot)的關鍵字pivot.key，右邊的子區間中所有記錄的關鍵字均大於等於pivot.key，而基準記錄pivot則位於正確的位置(pivotpos)上，它無須參加後續的排序。
  注意：
    　劃分的關鍵是要求出基準記錄所在的位置pivotpos。劃分的結果可以簡單地表示爲(注意pivot=R[pivotpos])：
    　R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys
                  其中low≤pivotpos≤high。
②求解：
   　 通過遞歸調用快速排序對左、右子區間R[low..pivotpos-1]和R[pivotpos+1..high]快速排序。
③組合：
    　因爲當"求解"步驟中的兩個遞歸調用結束時，其左、右兩個子區間已有序。對快速排序而言，"組合"步驟無須做什麼，可看作是空操作。

2、快速排序算法QuickSort
  

void QuickSort(SeqList R，int low，int high)
   ...{ //對R[low..high]快速排序
     int pivotpos； //劃分後的基準記錄的位置
     if(low<high)...{//僅當區間長度大於1時才須排序
        pivotpos=Partition(R，low，high)； //對R[low..high]做劃分
        QuickSort(R，low，pivotpos-1)； //對左區間遞歸排序
        QuickSort(R，pivotpos+1，high)； //對右區間遞歸排序
      }
    } //QuickSort

  注意：
    　爲排序整個文件，只須調用QuickSort(R，1，n)即可完成對R[l..n]的排序。

3、劃分算法Partition
（1） 簡單的劃分方法
① 具體做法
　　第一步：(初始化)設置兩個指針i和j，它們的初值分別爲區間的下界和上界，即i=low，i=high；選取無序區的第一個記錄R[i](即R[low])作爲基準記錄，並將它保存在變量pivot中；
　　第二步：令j自high起向左掃描，直到找到第1個關鍵字小於pivot.key的記錄R[j]，將R[j])移至i所指的位置上，這相當於R[j]和基準R[i](即pivot)進行了交換，使關鍵字小於基準關鍵字pivot.key的記錄移到了基準的左邊，交換後R[j]中相當於是pivot；然後，令i指針自i+1位置開始向右掃描，直至找到第1個關鍵字大於pivot.key的記錄R[i]，將R[i]移到i所指的位置上，這相當於交換了R[i]和基準R[j]，使關鍵字大於基準關鍵字的記錄移到了基準的右邊，交換後R[i]中又相當於存放了pivot；接着令指針j自位置j-1開始向左掃描，如此交替改變掃描方向，從兩端各自往中間靠攏，直至i=j時，i便是基準pivot最終的位置，將pivot放在此位置上就完成了一次劃分。

②一次劃分過程
    　一次劃分過程中，具體變化情況【參見動畫演示】 

③劃分算法：
 

int Partition(SeqList R，int i，int j)
    ...{//調用Partition(R，low，high)時，對R[low..high]做劃分，
     //並返回基準記錄的位置
      ReceType pivot=R[i]； //用區間的第1個記錄作爲基準 '
      while(i<j)...{ //從區間兩端交替向中間掃描，直至i=j爲止
        while(i<j&&R[j].key>=pivot.key) //pivot相當於在位置i上
          j--； //從右向左掃描，查找第1個關鍵字小於pivot.key的記錄R[j]
        if(i<j) //表示找到的R[j]的關鍵字<pivot.key
            R[i++]=R[j]； //相當於交換R[i]和R[j]，交換後i指針加1
        while(i<j&&R[i].key<=pivot.key) //pivot相當於在位置j上
            i++； //從左向右掃描，查找第1個關鍵字大於pivot.key的記錄R[i]
        if(i<j) //表示找到了R[i]，使R[i].key>pivot.key
            R[j--]=R[i]; //相當於交換R[i]和R[j]，交換後j指針減1
       } //endwhile
      R[i]=pivot； //基準記錄已被最後定位
      return i；
    } //partition