連結：https://www.cnblogs.com/yolandaBlog/p/9188149.html

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

1.連結串列

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

 1 public class Node{
 2       private Object data;
 3   
 4       private  Node next;
 5   
 6       public Node(Object data){
 7                 this.data = data;
 8        }
 9   
10      //省略set、get方法
11 }

2.二叉樹

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

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

 1 public class BinTree {
 2     
 3     private BinTree lChild;//左結點
 4     
 5     private BinTree rChild;//右結點 
 6     
 7     private Object data; //資料域  
 8 
 9     public BinTree getlChild() {
10         return lChild;
11     }
12 
13     public void setlChild(BinTree lChild) {
14         this.lChild = lChild;
15     }
16 
17     public BinTree getrChild() {
18         return rChild;
19     }
20 
21     public void setrChild(BinTree rChild) {
22         this.rChild = rChild;
23     }
24 
25     public Object getData() {
26         return data;
27     }
28 
29     public void setData(Object data) {
30         this.data = data;
31     }
32     
33 }

3.排序

（1）氣泡排序

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

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

 1     public static void bubbleSort(int []arr) {
 2         for(int i =0;i<arr.length-1;i++) {
 3             for(int j=0;j<arr.length-i-1;j++) {  //-1為了防止溢位
 4                 if(arr[j]>arr[j+1]) {  //把大的數放在後面
 5                     int temp = arr[j];
 6                      
 7                     arr[j]=arr[j+1];
 8                      
 9                     arr[j+1]=temp;
10             }
11             }    
12         }
13     }

（2）快速排序

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

1     public static void quickSort(int[] numbers,int low,int high){
2         if(low < high) {
3         　　int middle = getMiddle(numbers,low,high); //將numbers陣列進行一分為二
4         　　quickSort(numbers, low, middle-1);   //對低欄位表進行遞迴排序
5         　　quickSort(numbers, middle+1, high); //對高欄位表進行遞迴排序
6         }
7     
8     }

（3）選擇排序

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

 1 public static void selectSort(int[]a){
 2     int minIndex=0;
 3     int temp=0;
 4 
 5     for(int i=0;i<a.length-1;i++) {
 6         minIndex=i;//無序區的最小資料陣列下標
 7         for(intj=i+1;j<a.length;j++) {
 8             //在無序區中找到最小資料並儲存其陣列下標
 9             if(a[j]<a[minIndex]) {
10                 minIndex=j;
11             }
12         }
13         //將最小元素放到本次迴圈的前端
14         temp=a[i];
15         a[i]=a[minIndex];
16         a[minIndex]=temp;
17     }
18 }

（4）插入排序

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

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

 1 private static int[] insertSort(int[]arr){
 2     for(int i=1;i<arr.length;i++){
 3         for(int j=i;j>0;j--){
 4             if(arr[j]<arr[j-1]){
 5                 int temp=arr[j];
 6                 arr[j]=arr[j-1];
 7                 arr[j-1]=temp;
 8              }else{
 9                  break;
10             }
11         }
12       }
13      return arr;
14 }

（5）希爾排序

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

 1 public static void main(String [] args)
 2 {
 3     int[]a={49,38,65,97,76,13,27,49,78,34,12,64,1};
 4         //希爾排序
 5         int d=a.length;
 6             while(true){
 7                 d=d/2;
 8                 for(int x=0;x<d;x++){
 9                     for(int i=x+d;i<a.length;i=i+d){
10                         int temp=a[i];
11                         int j;
12                         for(j=i-d;j>=0&&a[j]>temp;j=j-d){
13                             a[j+d]=a[j];
14                         }
15                         a[j+d]=temp;
16                     }
17                 }
18                 if(d==10){
19                     break;
20                 }
21             }
22 }

（6）歸併排序

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

 1     public static int[] sort(int[] nums, int low, int high) {
 2         int mid = (low + high) / 2;
 3         if (low < high) {
 4             // 左邊
 5             sort(nums, low, mid);
 6             // 右邊
 7             sort(nums, mid + 1, high);
 8             // 左右歸併
 9             merge(nums, low, mid, high);
10         }
11         return nums;
12     }

（6）堆排序

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

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

 1 遞迴
 2 int recursion(...){
 3     if(...) {  //遞迴終止條件
 4         return abc(...); 
 5     }
 6     return 0;
 7 }
 8 
 9 迭代
10 int iteration(...){
11     for(; ; ;) {    //迭代終止條件
12         a = b + c;
13     } 
14 }

5.位操作

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

6.概率

7.排列組合