基础算法总结

1. 排序

1.1 冒泡排序法

每次内循环找到所有数组中最大值得坐标 放到最后面
替换的时候 如果当前坐标下的数比下一个数大，就会互换位置

static Integer[] test1(Integer[] nums) {
        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]) {
                    int temp = nums[j+1];
                    nums[j+1] = nums[j];
                    nums[j] = temp;
                }
            }
        }
        return nums;
    }

1.2 选择排序法

每次内循环找到最小值的坐标
每次替换仅替换最小值和最前面的值的位置

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

1.3 插入排序法

内循环是和前一个数值进行对比
当前一个比当前值大 换位置 然后indix前移

static Integer[] test3(Integer[] num) {
        for (int i = 1; i < num.length; i++) {
            for (int j = i; j > 0; j--) {
                if (num[j] < num[j - 1]) {
                    int temp = num[j];
                    num[j] = num[j - 1];
                    num[j - 1] = temp;
                }else {
                    break;
                }
            }
        }
        return num;
    }

1.4 递归

求一个数的阶层

static Integer test4(Integer num) {
        if (num == 1) {
            return  1;
        } else {
            return num * test4(num - 1);
        }
    }

1.5 快速排序法

双指针进行比较
选一个数把左边放比这个值小的，右边放比这个值大的
然后再递归左右两侧

private static void test5(Integer[] num, int left, int right) {
        if (left > right) {
            return;
        }
        int i = left;
        int j = right;
        int base = num[left];
        while (i < j) {
                while (num[j]>base&&i<j){
                    j--;
                }
                if (j>i){
                    num[i]=num[j];
                    i++;
                }
                while(num[i]<base&&i<j){
                    i++;
                }
                if (i<j){
                    num[j]=num[i];
                    j--;
                }
                if (i>=j){
                    num[i]=base;
                }
        }
        test5(num,left,i-1);
        test5(num,j+1,right);

    }

1.6 二分法

1/2 de 1/2 de 1/2 …

static int test6(Integer[] num, int start, int end, int tag) {
        if (num == null || num.length == 0) {
            return -1;
        }
        while (start <= end) {
            int mid = (start + end) / 2;
            if (tag == num[mid]) {
                return mid;
            } else if (tag > num[mid]) {
                start = mid + 1;
            } else {
                end = mid - 1;
            }
        }
        System.out.println("数据不存在");
        return -1;
    }