Android常用的算法总结

一、二分查找法

注意：必须有前提，数组中的元素要有序。时间复杂度是O(logn)

public static int halfSeach_2(int[] arr, int key) {
        int min, max, mid;
        min = 0;
        max = arr.length - 1;
        mid = (max + min) >> 1; //(max+min)/2;
        while (arr[mid] != key) {
            if (key > arr[mid]) {
                min = mid + 1;
            } else if (key < arr[mid])
                max = mid - 1;
            if (max < min)
                return -1;
            mid = (max + min) >> 1;
        }
        return mid;
    }

二、冒泡排序

冒泡排序，数组从小到大排列，比较相邻的元素。如果第一个比第二个大，就交换他们两个。时间复杂度是O(n2)

public static int[] bubbleSort(int[] nums) {
        int temp = 0;
        for (int i = 0; i < nums.length - 1; i++) {
            for (int j = 0; j < nums.length - 1 - i; j++) {
                if (nums[j] > nums[j + 1]) {
                    temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
        return nums;
    }

三、快速排序

快速排序，通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，则分别对这两部分继续进行排序，直到整个序列有序。时间复杂度是O(n2)

    /**
     * 快速排序
     * 取第一个元素为基数，循环比较最小位置值与最大位置值，较大的往后排，较小的往前排，
     * 然后并较小的位数加一，较大的位数减一，循环结果就是中间位数，
     * 最后就是以中间两部分分开做递归运算再次比较排列，直到正确排序为止
     */
    public static void quickSort(int[] nums, int low, int high) {
        if (low < high) {
            int temp = nums[low]; // 选定的基准值（第一个数值作为基准值）
            int middle; // 记录临时中间值
            int i = low, j = high;
            do {
                while ((nums[i] < temp) && (i < high)) {
                    i++;
                }
                while ((nums[j] > temp) && (j > low)) {
                    j--;
                }
                if (i <= j) {
                    middle = nums[i];
                    nums[i] = nums[j];
                    nums[j] = middle;
                    i++;
                    j--;
                }
            } while (i <= j);
            if (low < j) {
                quickSort(nums, low, j);
            }
            if (high > i) {
                quickSort(nums, i, high);
            }
        }
    }

四、选择排序

选择排序，每次寻找序列中的最小值，然后放在最首位的位置。时间复杂度是：O(n2)

    /**
     * 选择排序
     * 从后往前排，设默认最小元素与较大位置比较，如果比最小元素大，
     * 则将该位置记为最小元素，并且循环比较最小元素，找到最小元素，
     * 最后将最小元素赋值最前方，
     */
    public static void selectSort(int[] nums) {
        int size = nums.length, temp;
        for (int i = 0; i < size; i++) {
            int k = i; //临时最小元素位数
            for (int j = size - 1; j > i; j--) {
                if (nums[j] < nums[k]) {
                    k = j;
                }
            }
            temp = nums[i];
            nums[i] = nums[k];
            nums[k] = temp;
        }
    }

五、插入排序

插入排序，通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。时间复杂度是：O(n2)

    /**
     * 插入排序
     * 基准元素相邻元素比较，较大的往后排，然后从较大的位置开始往后与基准元素比较排列，
     * 最后把最小的插入较小位
     */
    public static void insertSort(int[] nums) {
        int size = nums.length, temp, j;
        for(int i=1; i<size; i++) {
            temp = nums[i];//基准元素
            for(j = i; j > 0 && temp < nums[j-1];j--) {
                nums[j] = nums[j-1];
            }
            nums[j] = temp;
        }
    }