面试常见算法

/**
     * 快速排序
     * 选择一个基准值，将比基准值小的放在左侧，大的放在右侧
     * 再将两侧的数组进行递归调用即可
     */
    public void quickSort(int[] numbers, int start, int end){
        if (start < end) {
            int base = numbers[start]; // 选定的基准值（第一个数值作为基准值）
            int temp; // 记录临时中间值
            int i = start, j = end;
            do {
                while ((numbers[i] < base) && (i < end)) {
                    i++;
                }
                while ((numbers[j] > base) && (j > start)){
                    j--;
                }
                if (i <= j) {
                    temp = numbers[i];
                    numbers[i] = numbers[j];
                    numbers[j] = temp;
                    i++;
                    j--;
                }
                for (int x : numbers){
                    System.out.print(x + ",");
                }
                System.out.println("--------------------------");
            } while (i <= j);
            if (start < j) {
                quickSort(numbers, start, j);
            }
            if (end > i) {
                quickSort(numbers, i, end);
            }
        }
    }

     /**
     * 选择排序
     * 在未排序序列中找到最小元素，存放到排序序列的起始位置
     * 再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾
     * 以此类推，直到所有元素均排序完毕。
     */
    public void selectSort(int[] arr) {
        int temp, k, j;
        for (int i = 0; i < arr.length; i++) {
            k = i;
            for (j = arr.length - 1; j > i; j--) {
                if (arr[j] < arr[k]) {
                    k = j;    //k为当前这一趟最小的元素下标值
                }
            }
            temp = arr[i];
            arr[i] = arr[k];
            arr[k] = temp;
        }
    }

/**
     * 插入排序
     * 从第一个元素开始，该元素可以认为已经被排序
     * 取出下一个元素，在已经排序的元素序列中从后向前扫描
     * 如果该元素（已排序）大于新元素，将该元素移到下一位置
     * 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
     * 将新元素插入到该位置中
     * 重复步骤2
     */
    public void insertSort(int[] arr) {
        int temp, j;
        for (int i = 1; i < arr.length; i++) {
            temp = arr[i];
            for (j = i; j > 0 && temp < arr[j - 1]; j--) {
                arr[j] = arr[j - 1];
            }
            arr[j] = temp;
        }
    }

 /**
     * Atoi函数实现
     * atoi() 函数会扫描 str 字符串，跳过前面的空白字符（例如空格，tab缩进等），直到遇上数字或正负符号才开始做转换，而再遇到非数字或字符串结束时('\0')才结束转换，并将结果返回。
     * 返回转换后的整型数；如果 str 不能转换成 int 或者 str 为空字符串，那么将返回 0。如果超出Integer的范围，将会返回Integer最大值或者最小值
     */
    public int myAtoi(String str) {
        if (str == null || str.length() < 0) {
            return 0;
        }
        str = str.replaceAll(" ", "");
        char flag = '+';
        int i = 0;
        if (str.charAt(0) == '-') {
            flag = '-';
            i++;
        } else if (str.charAt(0) == '+') {
            i++;
        }
        double res = 0;
        while (i < str.length() && str.charAt(i) > '0' && str.charAt(i) < '9') {
            res = res * 10 + str.charAt(i) - '0';
            i++;
        }
        if (flag == '-') {
            res = -1 * res;
        }
        if (res > Integer.MAX_VALUE) {
            return Integer.MAX_VALUE;
        } else if (res < Integer.MIN_VALUE) {
            return Integer.MIN_VALUE;
        }
        return (int) res;
    }

 /**
     * 二分查找
     * 要求待查找的序列有序。
     * 每次取中间位置的值与待查关键字比较，如果中间位置的值比待查关键字大，则在前半部分循环这个查找的过程，如果中间位置的值比待查关键字小，则在后半部分循环这个查找的过程。直到查找到了为止，否则序列中没有待查的关键字。
     * 返回key所在数组位置
     */
    public int binSearch(int[] arr, int key) {
        int mid = arr.length / 2;
        if (key == arr[mid]) {
            return mid;
        }
        int start = 0;
        int end = arr.length - 1;
        while (start < end) {
            mid = (end - start) / 2 + start;
            if (key < arr[mid]) {
                end = mid - 1;
            } else if (key > arr[mid]) {
                start = mid + 1;
            } else {
                return mid;
            }
        }
        return -1;
    }