1. 二分查找

又叫折半查找，要求待查找的序列有序。每次取中间位置的值与待查关键字比较，如果中间位置的值比待查关键字大，则在前半部分循环这个查找的过程，如果中间位置的值比待查关键字小，则在后半部分循环这个查找的过程。直到查找到了为止，否则序列中没有待查的关键字。 

  1. public static int biSearch(int []array,int a){ 
  2.     int lo=0; 
  3.     int hi=array.length-1; 
  4.     int mid; 
  5.     while(lo<=hi){ 
  6.         mid=(lo+hi)/2;//中间位置 
  7.         if(array[mid]==a){ 
  8.             return mid+1; 
  9.         }else if(array[mid]<a){ //向右查找 
  10.             lo=mid+1; 
  11.         }else{ //向左查找 
  12.             hi=mid-1; 
  13.         } 
  14.     } 
  15.     return -1; 
  16.  }

2. 冒泡排序算法

（1）比较前后相邻的二个数据，如果前面数据大于后面的数据，就将这二个数据交换。
（2）这样对数组的第 0 个数据到 N-1 个数据进行一次遍历后，最大的一个数据就“沉”到数组第 N-1 个位置。
（3）N=N-1，如果 N 不为 0 就重复前面二步，否则排序完成。 

  1. public static void bubbleSort1(int [] a, int n){ 
  2.     int i, j;
  3.     for(i=0; i<n; i++){//表示 n 次排序过程。 
  4.         for(j=1; j<n-i; j++){ 
  5.             if(a[j-1] > a[j]){//前面的数字大于后面的数字就交换 
  6.                 //交换 a[j-1]和 a[j] 
  7.                 int temp; 
  8.                 temp = a[j-1]; 
  9.                 a[j-1] = a[j]; 
  10.                 a[j]=temp; 
  11.             } 
  12.         } 
  13.     } 
  14. }

3. 插入排序算法

通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应的位置并插入。
插入排序非常类似于整扑克牌。在开始摸牌时，左手是空的，牌面朝下放在桌上。接着，一次从桌上摸起一张牌，并将它插入到左手一把牌中的正确位置上。为了找到这张牌的正确位置，要将它与手中已有的牌从右到左地进行比较。无论什么时候，左手中的牌都是排好序的。
如果输入数组已经是排好序的话，插入排序出现最佳情况，其运行时间是输入规模的一个线性函数。如果输入数组是逆序排列的，将出现最坏情况。平均情况与最坏情况一样，其时间代价是(n2)。 

  1. public void sort(int arr[])
  2. { 
  3.     for(int i =1; i<arr.length;i++) 
  4.     { 
  5.         //插入的数 
  6.         int insertVal = arr[i]; 
  7.         //被插入的位置(准备和前一个数比较) 
  8.         int index = i-1; 
  9.         //如果插入的数比被插入的数小 
  10.         while(index>=0&&insertVal<arr[index]) 
  11.         { 
  12.             //将把 arr[index] 向后移动 
  13.             arr[index+1]=arr[index]; 
  14.             //让 index 向前移动 
  15.             index--; 
  16.         } 
  17.         //把插入的数放入合适位置 
  18.         arr[index+1]=insertVal; 
  19.     } 
  20.  }

4. 快速排序算法

快速排序的原理：选择一个关键值作为基准值。比基准值小的都在左边序列（一般是无序的），比基准值大的都在右边（一般是无序的）。一般选择序列的第一个元素。
一次循环：从后往前比较，用基准值和最后一个值比较，如果比基准值小的交换位置，如果没有继续比较下一个，直到找到第一个比基准值小的值才交换。找到这个值之后，又从前往后开始比较，如果有比基准值大的，交换位置，如果没有继续比较下一个，直到找到第一个比基准值大的值才交换。直到从前往后的比较索引>从后往前比较的索引，结束第一次循环，此时，对于基准值来说，左右两边就是有序的了。 

  1. public void sort(int[] a,int low,int high){ 
  2.     int start = low; 
  3.     int end = high;
  4.     int key = a[low]; 
  5.     while(end>start){ 
  6.         //从后往前比较 
  7.         while(end>start&&a[end]>=key) 
  8.             //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较 
  9.             end--; 
  10.         if(a[end]<=key){ 
  11.             int temp = a[end]; 
  12.             a[end] = a[start]; 
  13.             a[start] = temp; 
  14.         } 
  15.         //从前往后比较 
  16.         while(end>start&&a[start]<=key) 
  17.             //如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置 
  18.             start++; 
  19.         if(a[start]>=key){ 
  20.             int temp = a[start]; 
  21.             a[start] = a[end]; 
  22.             a[end] = temp; 
  23.         } 
  24.         //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的 
  25.         值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用 
  26.         } 
  27.     //递归 
  28.     if(start>low) sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1 
  29.     if(end<high) sort(a,end+1,high);//右边序列。从关键值索引+1 到最后一个 
  30. } 
  31.  }

5. 希尔排序算法

基本思想：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列
中的记录“基本有序”时，再对全体记录进行依次直接插入排序。
1. 操作方法：
选择一个增量序列 t1，t2，…，tk，其中 ti>tj，tk=1；
2. 按增量序列个数 k，对序列进行 k 趟排序；
3. 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

  1. private void shellSort(int[] a) { 
  2.     int dk = a.length/2; 
  3.     while( dk >= 1 ){ 
  4.         ShellInsertSort(a, dk); 
  5.         dk = dk/2; 
  6.     } 
  7. } 
  8. private void ShellInsertSort(int[] a, int dk) { 
  9.     //类似插入排序，只是插入排序增量是 1，这里增量是 dk,把 1 换成 dk 就可以了 
  10.     for(int i=dk;i<a.length;i++){ 
  11.         if(a[i]<a[i-dk]){ 
  12.             int j; 
  13.             int x=a[i];//x 为待插入元素 
  14.             a[i]=a[i-dk]; 
  15.             for(j=i-dk; j>=0 && x<a[j];j=j-dk){ 
  16.                 //通过循环，逐个后移一位找到要插入的位置。 
  17.                 a[j+dk]=a[j]; 
  18.             } 
  19.             a[j+dk]=x;//插入 
  20.         } 
  21.     } 
  22. }

6. 归并排序算法

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

  1. public class MergeSortTest { 
  2.     public static void main(String[] args) { 
  3.         int[] data = new int[] { 5, 3, 6, 2, 1, 9, 4, 8, 7 }; 
  4.         print(data); 
  5.         mergeSort(data); 
  6.         System.out.println("排序后的数组："); 
  7.         print(data); 
  8.     } 
  9.     public static void mergeSort(int[] data) { 
  10.         sort(data, 0, data.length - 1); 
  11.     } 
  12.     public static void sort(int[] data, int left, int right) { 
  13.         if (left >= right) 
  14.             return; 
  15.         // 找出中间索引 
  16.         int center = (left + right) / 2; 
  17.         // 对左边数组进行递归 
  18.         sort(data, left, center); 
  19.         // 对右边数组进行递归 
  20.         sort(data, center + 1, right); 
  21.         // 合并 
  22.         merge(data, left, center, right); 
  23.         print(data); 
  24.     } 
  25.     /** 
  26.     * 将两个数组进行归并，归并前面 2 个数组已有序，归并后依然有序13/04/2018 
  27.     Page 239 of 283 
  28.     * 
  29.     * @param data 
  30.     * 数组对象 
  31.     * @param left 
  32.     * 左数组的第一个元素的索引 
  33.     * @param center 
  34.     * 左数组的最后一个元素的索引，center+1 是右数组第一个元素的索引 
  35.     * @param right 
  36.     * 右数组最后一个元素的索引 
  37.     */ 
  38.     public static void merge(int[] data, int left, int center, int right) { 
  39.         // 临时数组 
  40.         int[] tmpArr = new int[data.length]; 
  41.         // 右数组第一个元素索引 
  42.         int mid = center + 1; 
  43.         // third 记录临时数组的索引 
  44.         int third = left; 
  45.         // 缓存左数组第一个元素的索引 
  46.         int tmp = left; 
  47.         while (left <= center && mid <= right) { 
  48.             // 从两个数组中取出最小的放入临时数组 
  49.             if (data[left] <= data[mid]) { 
  50.                 tmpArr[third++] = data[left++]; 
  51.             } else { 
  52.                 tmpArr[third++] = data[mid++]; 
  53.             } 
  54.         } 
  55.         // 剩余部分依次放入临时数组（实际上两个 while 只会执行其中一个） 
  56.         while (mid <= right) { 
  57.             tmpArr[third++] = data[mid++]; 13/04/2018 
  58.                 Page 240 of 283 
  59.             } 
  60.         while (left <= center) { 
  61.             tmpArr[third++] = data[left++]; 
  62.         } 
  63.         // 将临时数组中的内容拷贝回原数组中 
  64.         // （原 left-right 范围的内容被复制回原数组） 
  65.         while (tmp <= right) { 
  66.             data[tmp] = tmpArr[tmp++]; 
  67.         } 
  68.     } 
  69.     public static void print(int[] data) { 
  70.         for (int i = 0; i < data.length; i++) { 
  71.             System.out.print(data[i] + "\t"); 
  72.         } 
  73.         System.out.println(); 
  74.     } 
  75.  }

7. 桶排序算法

桶排序的基本思想是： 把数组 arr 划分为 n 个大小相同子区间（桶），每个子区间各自排序，最后合并 。计数排序是桶排序的一种特殊情况，可以把计数排序当成每个桶里只有一个元素的情况。
1.找出待排序数组中的最大值 max、最小值 min
2.我们使用 动态数组 ArrayList 作为桶，桶里放的元素也用 ArrayList 存储。桶的数量为(max-min)/arr.length+1
3.遍历数组 arr，计算每个元素 arr[i] 放的桶
4.每个桶各自排序 

  1. public static void bucketSort(int[] arr){ 
  2.     int max = Integer.MIN_VALUE; 
  3.     int min = Integer.MAX_VALUE; 
  4.     for(int i = 0; i < arr.length; i++){13/04/2018 
  5.         Page 241 of 283 
  6.         max = Math.max(max, arr[i]); 
  7.                                         min = Math.min(min, arr[i]); 
  8.                                        } 
  9.     //创建桶 
  10.     int bucketNum = (max - min) / arr.length + 1; 
  11.     ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum); 
  12.     for(int i = 0; i < bucketNum; i++){ 
  13.         bucketArr.add(new ArrayList<Integer>()); 
  14.     } 
  15.     //将每个元素放入桶 
  16.     for(int i = 0; i < arr.length; i++){ 
  17.         int num = (arr[i] - min) / (arr.length); 
  18.         bucketArr.get(num).add(arr[i]); 
  19.     } 
  20.     //对每个桶进行排序 
  21.     for(int i = 0; i < bucketArr.size(); i++){ 
  22.         Collections.sort(bucketArr.get(i)); 
  23.     }
  24. }

8. 基数排序算法

将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。 

  1. public class radixSort { 
  2.     inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,101,56,17,18,23,34,15,35,2 
  3.         5,53,51}; 
  4.     public radixSort(){ 
  5.         sort(a); 
  6.         for(inti=0;i<a.length;i++){ 
  7.             System.out.println(a[i]); 
  8.         } 
  9.     } 
  10.     public void sort(int[] array){ 
  11.         //首先确定排序的趟数; 
  12.         int max=array[0]; 
  13.         for(inti=1;i<array.length;i++){ 
  14.             if(array[i]>max){13/04/2018 
  15.                 Page 242 of 283 
  16.                 max=array[i]; 
  17.                             } 
  18.         } 
  19.         int time=0; 
  20.         //判断位数; 
  21.         while(max>0){ 
  22.             max/=10; 
  23.             time++; 
  24.         } 
  25.         //建立 10 个队列; 
  26.         List<ArrayList> queue=newArrayList<ArrayList>(); 
  27.         for(int i=0;i<10;i++){ 
  28.             ArrayList<Integer>queue1=new ArrayList<Integer>(); 
  29.             queue.add(queue1); 
  30.         } 
  31.         //进行 time 次分配和收集; 
  32.         for(int i=0;i<time;i++){ 
  33.             //分配数组元素; 
  34.             for(intj=0;j<array.length;j++){ 
  35.                 //得到数字的第 time+1 位数; 
  36.                 int x=array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10, i); 
  37.                 ArrayList<Integer>queue2=queue.get(x); 
  38.                 queue2.add(array[j]); 
  39.                 queue.set(x, queue2); 
  40.             } 
  41.             int count=0;//元素计数器; 
  42.             //收集队列元素; 
  43.             for(int k=0;k<10;k++){ 
  44.                 while(queue.get(k).size()>0){ 
  45.                     ArrayList<Integer>queue3=queue.get(k); 
  46.                     array[count]=queue3.get(0); 
  47.                     queue3.remove(0); 
  48.                     count++; 
  49.                 } 
  50.             } 
  51.         } 
  52.     } 
  53. }

9. 剪枝算法

在搜索算法中优化中，剪枝，就是通过某种判断，避免一些不必要的遍历过程，形象的说，就是剪去了搜索树中的某些“枝条”，故称剪枝。应用剪枝优化的核心问题是设计剪枝判断方法，即确定哪些枝条应当舍弃，哪些枝条应当保留的方法。

10. 回溯算法

回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。

11. 最短路径算法

从某顶点出发，沿图的边到达另一顶点所经过的路径中，各边上权值之和最小的一条路径叫做最短路径。解决最短路的问题有以下算法，Dijkstra 算法，Bellman-Ford 算法，Floyd 算法和 SPFA算法等。

12. 最大子数组算法

13. 最长公共子序算法

14. 最小生成树算法

现在假设有一个很实际的问题：我们要在 n 个城市中建立一个通信网络，则连通这 n 个城市需要布置 n-1 一条通信线路，这个时候我们需要考虑如何在成本最低的情况下建立这个通信网？
于是我们就可以引入连通图来解决我们遇到的问题，n 个城市就是图上的 n 个顶点，然后，边表示两个城市的通信线路，每条边上的权重就是我们搭建这条线路所需要的成本，所以现在我们有 n 个顶点的连通网可以建立不同的生成树，每一颗生成树都可以作为一个通信网，当我们构造这个连通网所花的成本最小时，搭建该连通网的生成树，就称为最小生成树。
构造最小生成树有很多算法，但是他们都是利用了最小生成树的同一种性质：MST 性质（假设N=(V,{E})是一个连通网，U 是顶点集 V 的一个非空子集，如果（u，v）是一条具有最小权值的边，其中 u 属于 U，v 属于 V-U，则必定存在一颗包含边（u，v）的最小生成树），下面就介绍两种使用 MST 性质生成最小生成树的算法：普里姆算法和克鲁斯卡尔算法。