java中的基本算法

  整理一下常用的又基礎的算法。由於平時的項目比較簡單，很少用到算法，但工作不只是眼前的苟且，還有詩和遠方。

1.鏈表

  鏈表用來存儲數據，由一系列的結點組成。這些結點的物理地址不一定是連續的，即可能連續，也可能不連續，但鏈表里的結點是有序的。一個結點由數據的值和下一個數據的地址組成。一個鏈表內的數據類型可以是多種多樣的。數組也是用來存儲數據的，與鏈表相比，需要初始化時確定長度。一個數組內的數據都是同一類型。在Java中，ArrayList是通過數組實現，而LinkedList則通過鏈表實現。一個簡單的鏈表類如下：

public class Node{
      private Object data;
  
      private  Node next;
  
      public Node(Object data){
                this.data = data;
       }
  
     //省略set、get方法
}

2.二叉樹

  二叉樹是n(n>=0)個結點的有序集合。每個結點最多有2個子節點，即左結點和右結點，且左右結點順序不能更改。

  當n=0時，為空二叉樹；當n=1時，為只有一個根二叉樹。

public class BinTree {
    
    private BinTree lChild;//左結點
    
    private BinTree rChild;//右結點 
    
    private Object data; //數據域  

    public BinTree getlChild() {
        return lChild;
    }

    public void setlChild(BinTree lChild) {
        this.lChild = lChild;
    }

    public BinTree getrChild() {
        return rChild;
    }

    public void setrChild(BinTree rChild) {
        this.rChild = rChild;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }
    
}

3.排序

（1）冒泡排序

  重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。時間復雜度 O（n²），為穩定算法。

  將數依次進行比較，並將大（或小）的，網后放，如下：

    public static void bubbleSort(int []arr) {
        for(int i =0;i<arr.length-1;i++) {
            for(int j=0;j<arr.length-i-1;j++) {  //-1為了防止溢出
                if(arr[j]>arr[j+1]) {  //把大的數放在后面
                    int temp = arr[j];
                     
                    arr[j]=arr[j+1];
                     
                    arr[j+1]=temp;
            }
            }    
        }
    }

（2）快速排序

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

    public static void quickSort(int[] numbers,int low,int high){
        if(low < high) {
        　　int middle = getMiddle(numbers,low,high); //將numbers數組進行一分為二
        　　quickSort(numbers, low, middle-1);   //對低字段表進行遞歸排序
        　　quickSort(numbers, middle+1, high); //對高字段表進行遞歸排序
        }
    
    }

（3）選擇排序

  每一次從待排序的數據元素中選出最小（或最大）的一個元素，存放在序列的起始位置，直到全部待排序的數據元素排完。 選擇排序是不穩定的排序方法（比如序列[5， 5， 3]第一次就將第一個[5]與[3]交換，導致第一個5挪動到第二個5后面）。

public static void selectSort(int[]a){
    int minIndex=0;
    int temp=0;

    for(int i=0;i<a.length-1;i++) {
        minIndex=i;//無序區的最小數據數組下標
        for(intj=i+1;j<a.length;j++) {
            //在無序區中找到最小數據並保存其數組下標
            if(a[j]<a[minIndex]) {
                minIndex=j;
            }
        }
        //將最小元素放到本次循環的前端
        temp=a[i];
        a[i]=a[minIndex];
        a[minIndex]=temp;
    }
}

（4）插入排序

  每步將一個待排序的記錄，按其順序碼大小插入到前面已經排序的字序列的合適位置（從后向前找到合適位置后），直到全部插入排序完為止。

  每一個數和它前面的數依次進行比較，因為前面的數的順序是已經排好的

private static int[] insertSort(int[]arr){
    for(int i=1;i<arr.length;i++){
        for(int j=i;j>0;j--){
            if(arr[j]<arr[j-1]){
                int temp=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=temp;
             }else{
                 break;
            }
        }
      }
     return arr;
}

（5）希爾排序

  把記錄按下標的一定增量分組，對每組使用直接插入排序算法排序；隨着增量逐漸減少，每組包含的關鍵詞越來越多，當增量減至1時，整個文件恰被分成一組，算法便終止。

public static void main(String [] args)
{
    int[]a={49,38,65,97,76,13,27,49,78,34,12,64,1};
        //希爾排序
        int d=a.length;
            while(true){
                d=d/2;
                for(int x=0;x<d;x++){
                    for(int i=x+d;i<a.length;i=i+d){
                        int temp=a[i];
                        int j;
                        for(j=i-d;j>=0&&a[j]>temp;j=j-d){
                            a[j+d]=a[j];
                        }
                        a[j+d]=temp;
                    }
                }
                if(d==10){
                    break;
                }
            }
}

（6）歸並排序

  建立在歸並操作上的一種有效的排序算法,該算法是采用分治法（Divide and Conquer）的一個非常典型的應用。將已有序的子序列合並，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合並成一個有序表，稱為二路歸並。時間復雜度O(n log n) 。

    public static int[] sort(int[] nums, int low, int high) {
        int mid = (low + high) / 2;
        if (low < high) {
            // 左邊
            sort(nums, low, mid);
            // 右邊
            sort(nums, mid + 1, high);
            // 左右歸並
            merge(nums, low, mid, high);
        }
        return nums;
    }

（6）堆排序

  利用堆積樹（堆）這種數據結構所設計的一種排序算法，它是選擇排序的一種。可以利用數組的特點快速定位指定索引的元素。（暫沒理解）

4.遞歸、迭代
  遞歸是自己調用自己，直到滿足結束遞歸的條件時結束。迭代是不斷的循環，直接循環結束。一般來說，能用迭代就不用遞歸，遞歸消耗資源大。

遞歸
int recursion(...){
    if(...) {  //遞歸終止條件
        return abc(...); 
    }
    return 0;
}

迭代
int iteration(...){
    for(; ; ;) {    //迭代終止條件
        a = b + c;
    } 
}

5.位操作

  位操作與邏輯運算符是2種不同的東西，初學之時，自己還經常記不清。位操作有6種，即與（&）、或（|）、異或（^）、取反（~）、左移（<<）、右移（>>）。在這些位操作運算符中，只有取反（~）是彈幕運算符，其他5種都是雙目運算符。

6.概率

7.排列組合