1 分治（Divde & Conquer）

2 Pow(x,n)

https://leetcode.com/problems/powx-n/description/

• 思路1： 暴力解法：O(n)
• 思路2： 分治

public double myPow(double x, int n) {
        if (n == 0) {
            return 1;
        }

        if (n < 0) {
            if (n == Integer.MIN_VALUE) {
                n = Integer.MAX_VALUE - 1;
            }else{
                n = -n;
            }

            x = 1 / x;
        }

        if (n % 2 == 0) {
            return myPow(x * x, n / 2);
        } else {
            return x * myPow(x * x, n / 2);
        }

    }

    public double myPow_2(double x, int n) {

        double temp = x;
        if (n == 0) {
            return 1;
        }

        temp = myPow_2(x, n / 2);

        if (n % 2 == 0) {
            return temp * temp;
        } else {
            if (n > 0) {
                return x * temp * temp;
            } else {
                return (temp * temp) / x;
            }
        }

    }

3 求众数

https://leetcode.com/problems/majority-element/description/

• 思路1： 暴力解法：O(N^2)
• 思路2： Map, O(N)
• 思路3： 排序 O(N logN)
• 思路4： 分治 O(N logN)

• 暴力解法

 public int majorityElement(int[] nums) {

        int majorityCount = nums.length / 2;

        for (int num : nums) {
            int count = 0;

            for (int e : nums) {
                if (e == num) {
                    count++;
                }
            }

            if(count > majorityCount){
                return count;
            }
        }

        return -1;

    }

• HashMap

  private Map<Integer, Integer> countNums(int[] nums) {
        Map<Integer, Integer> counts = new HashMap<>();

        for (int num : nums) {
            if (!counts.containsKey(num)) {
                counts.put(num, 1);
            } else {
                counts.put(num, counts.get(num) + 1);
            }
        }

        return counts;
    }

    public int majorityElement_2(int[] nums) {
        Map<Integer, Integer> counts = countNums(nums);

        Map.Entry<Integer, Integer> majorityEntry = null;

        for (Map.Entry<Integer, Integer> entry : counts.entrySet()) {
            if(majorityEntry == null || entry.getValue() > majorityEntry.getValue()){
                majorityEntry = entry;
            }
        }

        return majorityEntry.getKey();
    }

• 排序

public int majorityElement_3(int[] nums) {

        Arrays.sort(nums);

        return nums[nums.length / 2];
    }

• 分治

private int countInRange(int[] nums, int num, int lo, int hi) {
        int count = 0;

        for (int i = lo; i <= hi; i++) {
            if (nums[i] == num) {
                count++;
            }
        }

        return count;
    }

    private int majEleRec(int[] nums, int lo, int hi) {
        if (lo == hi) {
            return nums[lo];
        }

        int mid = (hi - lo) / 2 + lo;
        int left = majEleRec(nums, lo, mid);
        int right = majEleRec(nums, mid + 1, hi);

        if (left == right) {
            return left;
        }

        int leftCount = countInRange(nums, left, lo, hi);
        int rightCount = countInRange(nums, right, lo, hi);

        return leftCount > rightCount ? left : right;

    }

    public int majorityElement_4(int[] nums) {
        return majEleRec(nums, 0, nums.length - 1);
    }