二分排序演算法

A. 基本排序演算法原理

演算法原理：每次對相鄰的兩個元素進行比較，若前者大於後者則進行交換，如此一趟下來最後一趟的就是最大元素，重復以上的步驟，除了已經確定的元素 。

演算法原理：每次對相鄰的兩個元素進行比較，若前者大於後者則進行交換，如此一趟下來最後一趟的就是最大元素，重復以上的步驟，除了已經確定的元素

演算法步驟

1)  設置兩個變數i、j，排序開始的時候：i=0，j=n-1；

2）第一個數組值作為比較值，首先保存到temp中，即temp=A[0]；

3）然後j-- ,向前搜索,找到小於temp後,因為s[i]的值保存在temp中,所以直接賦值,s[i]=s[j]

4）然後i++,向後搜索,找到大於temp後,因為s[j]的值保存在第2步的s[i]中,所以直接賦值,s[j]=s[i],然後j--,避免死循環

5）重復第3、4步，直到i=j,最後將temp值返回s[i]中

6)  然後採用「二分」的思想,以i為分界線,拆分成兩個數組 s[0,i-1]、s[i+1,n-1]又開始排序

排序圖解

演算法原理：從第一個元素開始，左邊視為已排序數組，右邊視為待排序數組，從左往右依次取元素，插入左側已排序數組，對插入新元素的左側數組重新生成有序數組 。需要注意的是，在往有序數組插入一個新元素的過程中，我們可以採用按 順序循環 比較，也可以通過 折半查找法 來找到新元素的位置，兩種方式的效率 取決於數組的數據量

演算法原理：希爾排序也是利用插入排序的思想來排序。希爾排序通過將比較的全部元素分為幾個區域來提升插入排序的性能。這樣可以讓一個元素可以一次性地朝最終位置前進一大步。然後演算法再取越來越小的步長進行排序，演算法的最後一步就是普通的插入排序，但是到了這步，需排序的數據幾乎是已排好的了，插入效率比較高。

排序圖解

選擇排序(Selection sort)是一種簡單直觀的排序演算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。選擇排序的主要優點與數據移動有關。如果某個元素位於正確的最終位置上，則它不會被移動。選擇排序每次交換一對元素，它們當中至少有一個將被移到其最終位置上，因此對n個元素的表進行排序總共進行至多n-1次交換。在所有的完全依靠交換去移動元素的排序方法中，選擇排序屬於非常好的一種。

歸並排序，顧名思義就是一種 「遞歸合並」 的排序方法（這個理解很重要）。對於一個數列，我們把它進行二分處理，依次遞歸下去，然後將小范圍的數進行排序，最後將其合並在一起。就實現了歸並排序。

這實際上是運用了 分治思想 ，顯然，想要把一個數列排好序，最終達到的目的就是它的任何一部分都是有序的。這樣的話，我們可以考慮分別把數列分成N多個部分，讓每個部分分別有序，然後再將其統一，變成所有的東西都有序。這樣就實現了排序。這個想法就叫分治思想。

排序圖解

排序圖解

B. java 二分法 排序

二分排序就是用先用二分查找法來查某一個元素，然後再用別的排序演算法來進行排序。

package insert;

public class InsArrayApp {
public static void main(String[] args) {
int size = 100;
InsArray arr = new InsArray(size);

arr.insert(10);
arr.insert(9);
arr.insert(8);
arr.insert(7);
arr.insert(6);
arr.insert(10);
arr.insert(9);
arr.insert(8);
arr.insert(5);
arr.insert(4);
arr.insert(3);
arr.insert(2);
arr.insert(1);

arr.display();

// arr.insertSort();

// arr.display();

// System.out.println(arr.median());

// arr.noDups();

arr.noDups2();
arr.display();
}
}

class InsArray {
private int[] a;
private int nElems;

public InsArray(int size) {
a = new int[size];
nElems = 0;
}

public void insert(int value) {
a[nElems] = value;
nElems++;
}

public void display() {
for (int i = 0; i < nElems; i++) {
System.out.print(a[i] + " ");
}
System.out.println();
}

public void insertSort() {
int out, in;
int = 0;
int compare = 0;
/* for(out = 1;out<nElems;out++){
int tmp = a[out];
in = out;
while(in>0&&a[in-1]>=tmp){
a[in] = a[in-1];
--in;
}
a[in] = tmp;
}*/
for(out = 1;out<nElems;out++){
int tmp = a[out];
in = out;
while(in>0){
if(a[in-1]>=tmp){
a[in] = a[in-1];
--in;
++;
++compare;}
else{
break;
}
}
++compare;
a[in] = tmp;
}
System.out.println(":" + + "compare:" + compare);
}

public int median(){
insertSort();
int m = nElems/2;
return a[m];
}

public void noDups(){
insertSort();
/*
InsArray tmp = new InsArray(nElems);
for(int i = 0;i<nElems;i++){
for(int j = i+1;j<nElems;j++)
if(a[i] == a[j]){
a[j] = -1;
}
if(a[i]!=-1)
tmp.insert(a[i]);
}
*/
InsArray tmp = new InsArray(nElems);
int i;
for(int j = 0;j<this.nElems;j++){
/*if(tmp.nElems==tmp.find(this.a[j])) //binary find
tmp.insert(this.a[j]);
else
continue;*/
for( i = 0; i < tmp.nElems; i++) { // for each element
if(tmp.a[i]==this.a[j]) // found searchKey?
break;
}
if(i==tmp.nElems) // no
tmp.insert(this.a[j]);
}
this.a = tmp.a;
this.nElems = tmp.nElems;
}

public int find(long searchKey) {
int lowerBound = 0;
int upperBound = nElems-1;
int curIn;

while(true) {
curIn = (lowerBound + upperBound)/2;
if(a[curIn]==searchKey)
return curIn;
else if(lowerBound>upperBound)
return nElems;
else {
if(a[curIn]>searchKey)
upperBound = curIn-1;
else
lowerBound = curIn+1;
}
}
}

public void noDups2(){
insertSort();
for(int i = 0;i<nElems;i++){
for(int j = i+1;j<nElems;j++)
if(a[i] == a[j]){
a[j] = -1;
}
}
display();
int index = 0;
for(int i=0;i<nElems;i++){
if(a[i]!=-1){
index++;
}else{
for(int j=index+1;j<nElems;j++){
if(a[j]!=-1){
a[index] = a[j];
a[j]=-1;
index++;
break;
}
}
}
}
nElems = index;

}
}

上面的代碼，是我以前敲的，有個find()方法是二分查找，然後再用插入排序去進行排序。

C. 什麼是二分法

二分法（Bisection method） 即一分為二的方法. 設[a，b]為R的閉區間. 逐次二分法就是造出如下的區間序列([an，bn])：a0=a，b0=b，且對任一自然數n，[an+1，bn+1]或者等於[an，cn]，或者等於[cn，bn]，其中cn表示[an，bn]的中點。

(3)二分排序演算法擴展閱讀

典型演算法

演算法：當數據量很大適宜採用該方法。採用二分法查找時，數據需是排好序的。

基本思想：假設數據是按升序排序的，對於給定值key，從序列的中間位置k開始比較，

如果當前位置arr[k]值等於key，則查找成功；

若key小於當前位置值arr[k]，則在數列的前半段中查找,arr[low,mid-1]；

若key大於當前位置值arr[k]，則在數列的後半段中繼續查找arr[mid+1,high]，

直到找到為止,時間復雜度:O(log(n))。

D. 二分法的演算法步驟是什麼

在有序的有N個元素的數組中查找用戶輸進去的數據x。

演算法如下：

1、確定查找范圍front=0，end=N-1，計算中項mid=（front+end）/2。

2、若a[mid]=x或front>=end，則結束查找；否則，向下繼續。

3.、若a[mid]<x，說明待查找的元素值只可能在比中項元素大的范圍內，則把mid+1的值賦給front，並重新計算mid，轉去執行步驟2；若a[mid]>x，說明待查找的元素值只可能在比中項元素小的范圍內，則把mid-1的值賦給end，並重新計算mid，轉去執行步驟2。

(4)二分排序演算法擴展閱讀

基本思想：假設數據是按升序排序的，對於給定值key，從序列的中間位置k開始比較，

如果當前位置arr[k]值等於key，則查找成功；

若key小於當前位置值arr[k]，則在數列的前半段中查找，arr[low，mid-1]；

若key大於當前位置值arr[k]，則在數列的後半段中繼續查找arr[mid+1，high]，

直到找到為止，時間復雜度:O(log(n))。