算法

一、二分查找算法

要求：查找的集合是有序的

public static int binarySearch(int []array,int a){
        int low = 0;
        int high = array.length - 1;
        int mid;
        while(low <= high){
            mid = (high - low) / 2 + low;
            if(array[mid] == a){
                return mid;
            }else if (a > array[mid]){
                low = mid + 1;
            }else{
                high = mid - 1;
            }
        }
        return -1;
    }

二、冒泡排序(稳定)

依次比较相邻的元素，如果左边大于右边的元素，将二者交换位置，直到没有相邻的元素需要交换位置。

public static int[] bubbleSort(int[] arr){
        //外层循环控制排序趟数
        for(int i = 0;i < arr.length - 1;i++){
            //内层循环控制每一趟排序次数
            for (int j = 0;j < arr.length -1 -i;j++){
                if (arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    }

三、插入排序算法（稳定）

在有序队列中插入一个数据，仍然有序

public static int[] insertSort(int arr[]){
        for (int i = 1;i < arr.length;i++){
            //插入的数
            int insertVal = arr[i];
            //被插入的位置（准备和前一个数进行比较）
            int index = i - 1;
            //如果插入的数比被插入的数小
            while(index >= 0 && insertVal < arr[index]){
                //则将arr[index]向后移动
                arr[index + 1]=arr[index];
                //将index向前移动
                index--;
            }
            //将插入的数放入合适的位置
            arr[index + 1] = insertVal;
        }
        return arr;
    }

四、快速排序算法（不稳定）

通过一趟排序将要排序的数据序列分成独立的俩部分，其中一部分的所有数据比另一部分的所有数据都小，然后按此方法对两部分数据分别进行快速排序，整个排序过程递归进行。

 public static int[] quickSort(int[] arr,int low,int high){
        int start = low;//从前向后比较的索引
        int end = high;//从后向前比较的索引
        int key = arr[low];//基准值
        while (end > start){
            //从后向前比较
            while(end > start && arr[end] >= key) {
                end--;
            }
            //如果没有比基准值小的，则比较下一个，直到有比基准值小的,则交换位置，然后从前向后比较
            if (arr[end] <= key){
                int temp = arr[end];
                arr[end] = arr[start];
                arr[start] = temp;
            }
            //从前向后比较
            while(end > start && arr[start] <= key){
                start++;
            }
            if (arr[start] >= key){
                int temp = arr[start];
                arr[start] = arr[end];
                arr[end] = temp;
            }
            //此时第1次循环比较结束，基准值的位置已经确定。左边的值都比基准值小
            //右边的值都比基准值大，但是俩边的顺序还有可能不一样，接着进行下面的递归调用
        }
        //递归左边的序列：从第1个索引位置到“基准值索引-1”
        if (start > low) quickSort(arr, low, start - 1);
        //递归右边的序列，从“基准值索引-1”到最后一个位置
        if (end < high) quickSort(arr,end + 1,high);
        return arr;
    }

五、希尔排序算法（不稳定）

希尔排序算法的原理是先将整个待排序的记录序列分割成若干个子序列，分别进行直接插入排序，待整个序列中的记录基本有序时，再对全部记录依次进行直接插入排序。

public static int[] shellSort(int[] arr){
        int dk = arr.length / 3 + 1;
        while (dk == 1){
            ShellInsertSort(arr,dk);
            dk = dk / 3 + 1;
        }
        if (dk == 1){
            ShellInsertSort(arr,dk);
        }
        return arr;
    }
    public static void ShellInsertSort(int[] a,int dk){
        //类似于插入排序算法，但插入排序算法的增量是1，这里的增量是dk，将1换成dk即可
        for (int i = dk;i < a.length;i++){
            if (a[i] <a[i-dk]){
                int j;
                int x = a[i];//x为待插入的元素
                a[i] = a[i - dk];
                for (j = i - dk;j >= 0 && x < a[j];j = j - dk){
                    //通过循环，逐个后移一位找到要插入的位置
                    a[j + dk] = a[j];
                }
                a[j + dk] = x;//将数据插入对应的位置
            }
        }
    }

六、归并排序算法（稳定）

归并排序算法将待排序序列分为若干个子序列，先对每个子序列进行排序，等每个子序列都有序后，再将有序子序列合并为整体的有序序列。

七、桶排序

八、基数排序算法（稳定）

九、剪枝算法

十、回溯算法

十一、最短路径算法