java常用算法

记录常用的算法

选择排序

选择排序的基本思想是遍历数组的过程中，以 i 代表当前需要排序的序号，则需要在剩余的 [i…n-1] 中找出其中的最小值，然后将找到的最小值与 i 指向的值进行交换。因为每一趟确定元素的过程中都会有一个选择最大值的子流程，所以人们形象地称之为选择排序。

SELECTION(new Sortable() {   
    public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {   
        int len = array.length;   
        for (int i = 0; i < len; i++) {   
            int selected = i;   
            for (int j = i + 1; j < len; j++) {   
                int compare = array[j].compareTo(array[selected]);   
                if (compare != 0 && compare < 0 == ascend) {   
                    selected = j;   
                }   
            }   
  
            exchange(array, i, selected);   
        }   
    }   
}) 

 插入排序

插入排序的基本思想是在遍历数组的过程中，假设在序号 i 之前的元素即 [0..i-1] 都已经排好序，本趟需要找到 i 对应的元素 x 的正确位置 k ，并且在寻找这个位置 k 的过程中逐个将比较过的元素往后移一位，为元素 x “腾位置”，最后将 k 对应的元素值赋为 x ，插入排序也是根据排序的特性来命名的。

INSERTION(new Sortable() {   
    public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {   
        int len = array.length;   
        for (int i = 1; i < len; i++) {   
            T toInsert = array[i];   
            int j = i;   
            for (; j > 0; j--) {   
                int compare = array[j - 1].compareTo(toInsert);   
                if (compare == 0 || compare < 0 == ascend) {   
                    break;   
                }   
                array[j] = array[j - 1];   
            }   
  
            array[j] = toInsert;   
        }   
    }   
})  

冒泡排序

冒泡排序可以算是最经典的排序算法了，记得小弟上学时最先接触的也就是这个算法了，因为实现方法最简单，两层 for 循环，里层循环中判断相邻两个元素是否逆序，是的话将两个元素交换，外层循环一次，就能将数组中剩下的元素中最小的元素“浮”到最前面，所以称之为冒泡排序。

BUBBLE(new Sortable() {   
    public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {   
        int length = array.length;   
        int lastExchangedIdx = 0;   
        for (int i = 0; i < length; i++) {   
            // mark the flag to identity whether exchange happened to false   
            boolean isExchanged = false;   
            // last compare and exchange happened before reaching index i   
            int currOrderedIdx = lastExchangedIdx > i ? lastExchangedIdx : i;   
            for (int j = length - 1; j > currOrderedIdx; j--) {   
                int compare = array[j - 1].compareTo(array[j]);   
                if (compare != 0 && compare > 0 == ascend) {   
                    exchange(array, j - 1, j);   
                    isExchanged = true;   
                    lastExchangedIdx = j;   
                }   
            }   
            // if no exchange happen means array is already in order   
            if (isExchanged == false) {   
                break;   
            }   
        }   
    }   
})  

希尔排序

希尔排序的诞生是由于插入排序在处理大规模数组的时候会遇到需要移动太多元素的问题。希尔排序的思想是将一个大的数组“分而治之”，划分为若干个小的数组，以 gap 来划分，比如数组 [1, 2, 3, 4, 5, 6, 7, 8] ，如果以 gap = 2 来划分，可以分为 [1, 3, 5, 7] 和 [2, 4, 6, 8] 两个数组（对应的，如 gap = 3，则划分的数组为： [1, 4, 7] 、 [2, 5, 8] 、 [3, 6] ）然后分别对划分出来的数组进行插入排序，待各个子数组排序完毕之后再减小 gap 值重复进行之前的步骤，直至 gap = 1 ，即对整个数组进行插入排序，此时的数组已经基本上快排好序了，所以需要移动的元素会很小很小，解决了插入排序在处理大规模数组时较多移动次数的问题。

具体实例请参照插入排序。

希尔排序是插入排序的改进版，在数据量大的时候对效率的提升帮助很大，数据量小的时候建议直接使用插入排序就好了。

SHELL(new Sortable() {   
    public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {   
        int length = array.length;   
        int gap = 1;   
  
        // use the most next to length / 3 as the first gap   
        while (gap < length / 3) {   
            gap = gap * 3 + 1;   
        }   
  
        while (gap >= 1) {   
            for (int i = gap; i < length; i++) {   
                T next = array[i];   
                int j = i;   
                while (j >= gap) {   
                    int compare = array[j - gap].compareTo(next);   
                    // already find its position   
                    if (compare == 0 || compare < 0 == ascend) {   
                        break;   
                    }   
  
                    array[j] = array[j - gap];   
                    j -= gap;   
                }   
                if (j != i) {   
                    array[j] = next;   
                }   
            }   
            gap /= 3;   
        }   
  
    }   
})  

归并排序

归并排序采用的是递归来实现，属于“分而治之”，将目标数组从中间一分为二，之后分别对这两个数组进行排序，排序完毕之后再将排好序的两个数组“归并”到一起，归并排序最重要的也就是这个“归并”的过程，归并的过程中需要额外的跟需要归并的两个数组长度一致的空间，比如需要规定的数组分别为：[3, 6, 8, 11] 和 [1, 3, 12, 15] （虽然逻辑上被划为为两个数组，但实际上这些元素还是位于原来数组中的，只是通过一些 index 将其划分成两个数组，原数组为 [3, 6, 8, 11, 1, 3, 12, 15 ，我们设置三个指针 lo, mid, high 分别为 0,3,7 就可以实现逻辑上的子数组划分）那么需要的额外数组的长度为 4 + 4 = 8。

MERGE(new Sortable() {   
    public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {   
        this.sort(array, 0, array.length - 1, ascend);   
    }   
  
    private <T extends Comparable<T>> void sort(T[] array, int lo, int hi, boolean ascend) {   
        // OPTIMIZE ONE   
        // if the substring's length is less than 20,   
        // use insertion sort to reduce recursive invocation   
        if (hi - lo < 20) {   
            for (int i = lo + 1; i <= hi; i++) {   
                T toInsert = array[i];   
                int j = i;   
                for (; j > lo; j--) {   
                    int compare = array[j - 1].compareTo(toInsert);   
                    if (compare == 0 || compare < 0 == ascend) {   
                        break;   
                    }   
                    array[j] = array[j - 1];   
                }   
  
                array[j] = toInsert;   
            }   
  
            return;   
        }   
  
        int mid = lo + (hi - lo) / 2;   
        sort(array, lo, mid, ascend);   
        sort(array, mid + 1, hi, ascend);   
        merge(array, lo, mid, hi, ascend);   
    }   
  
    private <T extends Comparable<T>> void merge(T[] array, int lo, int mid, int hi, boolean ascend) {   
        // OPTIMIZE TWO   
        // if it is already in right order, skip this merge   
        // since there's no need to do so   
        int leftEndCompareToRigthStart = array[mid].compareTo(array[mid + 1]);   
        if (leftEndCompareToRigthStart == 0 || leftEndCompareToRigthStart < 0 == ascend) {   
            return;   
        }   
  
        @SuppressWarnings("unchecked")   
        T[] arrayCopy = (T[]) new Comparable[hi - lo + 1];   
        System.arraycopy(array, lo, arrayCopy, 0, arrayCopy.length);   
  
        int lowIdx = 0;   
        int highIdx = mid - lo + 1;   
  
        for (int i = lo; i <= hi; i++) {   
            if (lowIdx > mid - lo) {   
                // left sub array exhausted   
                array[i] = arrayCopy[highIdx++];   
            } else if (highIdx > hi - lo) {   
                // right sub array exhausted   
                array[i] = arrayCopy[lowIdx++];   
            } else if (arrayCopy[lowIdx].compareTo(arrayCopy[highIdx]) < 0 == ascend) {   
                array[i] = arrayCopy[lowIdx++];   
            } else {   
                array[i] = arrayCopy[highIdx++];   
            }   
        }   
    }   
})  

快速排序

快速排序也是用归并方法实现的一个“分而治之”的排序算法，它的魅力之处在于它能在每次partition（排序算法的核心所在）都能为一个数组元素确定其排序最终正确位置（一次就定位准，下次循环就不考虑这个元素了）。

快速排序的partition操作按以下逻辑进行，假定本次排序的数组为arr：

1） 选择一个元素（为了简单起见，就选择本次partition的第一个元素，即arr[0]）作为基准元素，接下来的步骤会为其确定排序完成后最终的位置；

2） 1）  接下来需要遍历[1…n-1]对应的数组元素以帮助找到arr[0]值（以v替代）对应的位置，定义i为当前访问数组的索引，lt为值小于v的最大索引，gt为值大于v的最小索引，那么在遍历过程中，如果发现i指向的值与v相等，则将i值加1，继续下一次比较；如果i指向的值比v小，则将i和lt对应的元素进行交换，然后分别将两个索引加1；如果i指向的值比v大，则将i与gt对应的元素进行交换，然后i自增，gt自减。循环遍历完成（i > gt时结束）之后可以保证[0…lt-1]对应的值都是比v小的，[lt..gt]之间的值都是与v相等的，[gt+1…n-1]对应的值都是比v大的。

3） 分别对[0…lt-1]和[gt+1…n-1]两个子数组进行排序，如此递归，直至子子子数组的长度为0。

QUICK(new Sortable() {   
    public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {   
        this.sort(array, 0, array.length - 1, ascend);   
    }   
  
    private <T extends Comparable<T>> void sort(T[] array, int lo, int hi, boolean ascend) {   
        if (lo >= hi) {   
            return;   
        }   
  
        T toFinal = array[lo];   
        int leftIdx = lo;   
        int rightIdx = hi;   
  
        int i = lo + 1;   
  
        while (i <= rightIdx) {   
            int compare = array[i].compareTo(toFinal);   
            if (compare == 0) {   
                i++;   
            } else if (compare < 0 == ascend) {   
                exchange(array, leftIdx++, i++);   
            } else {   
                exchange(array, rightIdx--, i);   
            }   
        }   
  
        // partially sort left array and right array   
        // no need to include the leftIdx-th to rightIdx-th elements   
        // since they are already in its final position   
        sort(array, lo, leftIdx - 1, ascend);   
        sort(array, rightIdx + 1, hi, ascend);   
    }   
})  

二分查找

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

 public static int biSearch(int []array,int a){
 int lo=0;
 int hi=array.length-1;
 int mid;
 while(lo<=hi){
mid=(lo+hi)/2;//中间位置
 if(array[mid]==a){
 return mid+1;
 }else if(array[mid]<a){ //向右查找
lo=mid+1;
 }else{ //向左查找
hi=mid-1;
 }
 }
 return -1;
 }

桶排序

桶排序的基本思想是： 把数组 arr 划分为 n 个大小相同子区间（桶），每个子区间各自排序，最后合并 。计数排序是桶排序的一种特殊情况，可以把计数排序当成每个桶里只有一个元素的情况。

1.找出待排序数组中的最大值 max、最小值 min

2.我们使用 动态数组 ArrayList 作为桶，桶里放的元素也用 ArrayList 存储。桶的数量为(maxmin)/arr.length+1

3.遍历数组 arr，计算每个元素 arr[i] 放的桶

4.每个桶各自排序

public static void bucketSort(int[] arr){
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
for(int i = 0; i < arr.length; i++){
max = Math.max(max, arr[i]);
min = Math.min(min, arr[i]);
}
//创建桶
int bucketNum = (max - min) / arr.length + 1;
ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
for(int i = 0; i < bucketNum; i++){
bucketArr.add(new ArrayList<Integer>());
}
//将每个元素放入桶
for(int i = 0; i < arr.length; i++){
int num = (arr[i] - min) / (arr.length);
bucketArr.get(num).add(arr[i]);
}
//对每个桶进行排序
for(int i = 0; i < bucketArr.size(); i++){
Collections.sort(bucketArr.get(i));
}
}

基数排序

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

public class radixSort {
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
5,53,51};
public radixSort(){
sort(a);
for(inti=0;i<a.length;i++){
System.out.println(a[i]);
}
}
public void sort(int[] array){
//首先确定排序的趟数;
int max=array[0];
for(inti=1;i<array.length;i++){
if(array[i]>max){
max=array[i];
}
}
int time=0;
//判断位数;
while(max>0){
max/=10;
time++;
}
//建立 10 个队列;
List<ArrayList> queue=newArrayList<ArrayList>();
for(int i=0;i<10;i++){
ArrayList<Integer>queue1=new ArrayList<Integer>();
queue.add(queue1);
}
//进行 time 次分配和收集;
for(int i=0;i<time;i++){
//分配数组元素;
for(intj=0;j<array.length;j++){
//得到数字的第 time+1 位数;
int x=array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10, i);
ArrayList<Integer>queue2=queue.get(x);
queue2.add(array[j]);
queue.set(x, queue2);
}
int count=0;//元素计数器;
//收集队列元素;
for(int k=0;k<10;k++){
while(queue.get(k).size()>0){
ArrayList<Integer>queue3=queue.get(k);
array[count]=queue3.get(0);
queue3.remove(0);
count++;
}
}
}
}
}

剪枝

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

 

回溯算法

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

最短路径算法

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

最大子数组算法
题目：输入一个整形数组，数组里有正数也有负数。数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。

最小生成树算法

现在假设有一个很实际的问题：我们要在 n 个城市中建立一个通信网络，则连通这 n 个城市需要布置 n-1 一条通信线路，这个时候我们需要考虑如何在成本最低的情况下建立这个通信网？

于是我们就可以引入连通图来解决我们遇到的问题，n 个城市就是图上的 n 个顶点，然后，边表示两个城市的通信线路，每条边上的权重就是我们搭建这条线路所需要的成本，所以现在我们有 n 个顶点的连通网可以建立不同的生成树，每一颗生成树都可以作为一个通信网，当我们构造这个连通网所花的成本最小时，搭建该连通网的生成树，就称为最小生成树。

构造最小生成树有很多算法，但是他们都是利用了最小生成树的同一种性质：MST 性质（假设N=(V,{E})是一个连通网，U 是顶点集 V 的一个非空子集，如果（u，v）是一条具有最小权值的边，其中 u 属于 U，v 属于 V-U，则必定存在一颗包含边（u，v）的最小生成树），下面就介绍两种使用 MST 性质生成最小生成树的算法：普里姆算法和克鲁斯卡尔算法。