Java-算法初始台地-打卡20230430

写一半丢了MAD

1.遇到HashMap 扩容导致Npe

设置初始的容量为0，put进去一条数据就开始扩容。并发get到的值为null

2.算法复杂度O表示上限，但是不严格

3.递归性能不一定好，计算递归时间复杂度需要注意

3.1 计算x的n次方，时间复杂度由O(n) - O(logn)

private static int pown (int x, int n) {
        if (n == 0) {
            return 1;
        }
        if (n == 1) {
            return x;
        }
        return x * pown(x, n-1);
    }
    private static int powNLog (int x, int n) {
        if (n == 0) {
            return 1;
        }
        if (n == 1) {
            return x;
        }
        int t = powNLog(x, n/2);
        if (n %2 == 1) {
            return t * t * x;
        }
        return t * t;
    }
    public static void main(String[] args) {
        System.out.println(powNLog(2,20));
        System.out.println(pown(2,20));
    }

3.2 计算斐波那契队列，由O(n^2) -> O(n)

    public static void main(String[] args) {

        System.out.println(fibonaci(20));
        System.out.println(fibonaciOn(1,1, 20));
        System.out.println(fibonaciOnNotRecursion(20));
    }

    private static int fibonaci (int n) {
        if (n == 0) {
            return 0;
        }
        if (n == 1) {
            return 1;
        }
        if (n == 2) {
            return 1;
        }
        return fibonaci(n-1) + fibonaci(n -2);
    }

    private static int fibonaciOn (int first, int second, int n) {
        if (n == 0) {
            return 0;
        }
        if (n < 3) {
            return 1;
        }
        if (n == 3) {
            return first + second;
        }
        return fibonaciOn(second, first + second, n -1);
    }

    private static int fibonaciOnNotRecursion(int n) {
        if (n == 0) {
            return 0;
        }
        if (n < 3) {
            return 1;
        }
        int first = 1, second = 1;
        for(int i = 3; i < n; i++) {
            int term = second;
            second = first + second;
            first = term;
        }
        return first +second;
    }

4 手写了快排，但是看了解释用双指针效果更好点

 public static void main(String[] args) {
        int[] nums = new int[]{2,3,4,1,3,2,45,6,7,89,0,242};
        sortTwoPoint(nums);
        System.out.println(nums);
    }

    private static void sort(int [] nums) {
        if (nums == null) {
            return;
        }
        if (nums.length <= 1) {
            return;
        }

        quickSort(nums, 0, nums.length -1);

    }

    private static void sortTwoPoint(int [] nums) {
        if (nums == null) {
            return;
        }
        if (nums.length <= 1) {
            return;
        }

        quickSortTwoPoint(nums, 0, nums.length -1);

    }

    private static void quickSort(int[] nums, int low, int max) {
        if (max <= low) {
            return;
        }
        int term = nums[low];
        int idx = low;
        for (int i = low +1; i<= max; i++) {
            if (nums[i] < term) {
                transfer(nums, i, idx);
                if(nums[i] < nums[idx + 1]){
                    transfer(nums, i, idx + 1);
                    idx = idx + 1;
                }else {
                    idx = i;
                }
            }
        }
        quickSort(nums, 0, max-1);
        quickSort(nums, idx+1, max);
    }

    private static void quickSortTwoPoint(int[] nums, int low, int max) {
        if (max <= low) {
            return;
        }
        int term = nums[low];
        int p = low + 1, q = max;
        while (p < q) {
            while (p < q && nums[p] < term) {
                p++;
            }
            while (p < q && nums[q] > term) {
                q--;
            }
            transfer(nums, p, q);
        }
        transfer(nums, low, p);
        quickSort(nums, 0, p-1);
        quickSort(nums, p+1, max);
    }

    private static void transfer(int [] nums, int m, int n) {
        int term = nums[m];
        nums[m] = nums[n];
        nums[n] = term;
    }