冒泡排序,快排,单例模式,二分查找等 java

    // 二分法查询数据中的某个数
    public static Integer findIndex(int[] arr, int n, int left, int right) {
        if (arr == null || left > right || arr.length == 0 || arr[left] > n || arr[right] < n) {
            return -1;
        }
        int hid = (left + right) / 2;
        if (arr[hid] == n) {
            return hid;
        } else if (arr[hid] < n) {
            return findIndex(arr, n, hid + 1, right);
        } else if (arr[hid] > n) {
            return findIndex(arr, n, left, hid - 1);
        }
        return -1;
    }

    // 冒泡排序
    public static void maoPaoSort(int[] arr) {

        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp;
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    // 插入排序
    public class InsertSort {
        public void sort(int[] arr) {
            if (arr.length >= 2) {
                for (int i = 1; i < arr.length; i++) {
                    //挖出一个要用来插入的值,同时位置上留下一个可以存新的值的坑
                    int x = arr[i];
                    int j = i - 1;
                    //在前面有一个或连续多个值比x大的时候,一直循环往前面找,将x插入到这串值前面
                    while (j >= 0 && arr[j] > x) {
                        //当arr[j]比x大的时候,将j向后移一位,正好填到坑中
                        arr[j + 1] = arr[j];
                        j--;
                    }
                    //将x插入到最前面
                    arr[j + 1] = x;
                }
            }
        }
    }

 // 快排
    private void quitSort(int[] arr, int startIndex, int endIndex) {
        // 左侧标记
        int left = startIndex;
        // 右侧标记
        int right = endIndex;
        // 分界值
        int markNum = arr[left];
        // 已经排序完成
        if (left >= right) {
            return;
        }
        while (left < right) {
            // 从右边进行排序
            while (arr[right] >= markNum) {
                right--;
            }
            // 出循环时 right 索引值小于标记值
            if (left < right) {
                // 将空位值与right值互换
                arr[left] = arr[right];
                left++;
            }
            // 换成从左侧开始查询
            while (arr[left] <= markNum) {
                left++;
            }
            // 出循环 left值大于标记值 将之前被移走的右侧空位值 替换为左侧值
            if (left < right) {
                arr[right] = arr[left];
                right--;
            }
        }
        // 将拿出的标记值 赋值给最后的左侧值位置 因为最后左侧值被拿走留下了坑 此时左右索引位置交汇 值是已经换走的空值 left=right
        arr[left] = markNum;
        quitSort(arr, startIndex, left - 1);
        quitSort(arr, left + 1, endIndex);
    }

    // 单例模式
    private static QatestController qatestController;

    public QatestController getSingleton() {
        if (qatestController == null) {
            synchronized (QatestController.class) {
                if (qatestController == null) {
						  qatestController = new QatestController();
                }
            }
        }
        return qatestController;
    }