业余刷leetcode

我的顺序是从最简单开始，速度是一天2道（18.3.22start-），都是以自己最low想法来随意写，以后补充优化。

一、easy

title 108：将有序数组转为二叉搜索树

public class title108 {
    public TreeNode sortedArrayToBST(int[] nums) {
        TreeNode root = createTree(nums,0,nums.length-1);
        return root;
    }
    private TreeNode createTree(int[] nums,int left,int right){
        if(left > right){
            return null;
        }
        int mid = (left + right) / 2;
        TreeNode root = new TreeNode(nums[mid]);
        root.left = createTree(nums,left,mid-1);
        root.right = createTree(nums,mid+1,right);
        return root;
    }
}
class TreeNode {
      int val;
      TreeNode left;
      TreeNode right;
      TreeNode(int x) { val = x; }
  }

title 504：十进制转7进制

public class title504 {
    public String convertToBase7(int num) {
        StringBuffer res = new StringBuffer();
        if(num < 0){
            num = Math.abs(num);
            res.append("-");
        }
        int max = getMax(num);
        System.out.println("max="+max);
        while(max >= 0){
            int cur = (int)(num / Math.pow(7,max));
            num -= cur * Math.pow(7,max);
            System.out.println("cur="+cur);
            res.append(cur);
            max--;
        }
        return res.toString();
    }
    private int getMax(int num){
        int res = 0;
        int sum = 7;
        while(sum <= num){
            sum = sum * 7;
            res++;
        }
        return res;
    }
    public static void  main(String[] args){
        title504 test = new title504();
        System.out.println(test.convertToBase7(-7));
    }
}

优化一下：

title 541：反转字符串

 public String reverseStr(String s, int k) {
        StringBuilder res = new StringBuilder();
        int len = s.length();
        while(len > 0) {
            if(len >= 2*k) {
                res.append(getReverse(s.substring(0, 2*k), k));
            }else{
                res.append(getReverse(s,k));
                break;
            }
            s = s.substring(2*k);
            len = s.length();
        }
        return res.toString();
    }
    private String getReverse(String str,int k){
        int len = str.length();
        if(len > k){
            String tmp = str.substring(0,k);
            str = new StringBuffer(tmp).reverse().append(str.substring(k)).toString();
        }else if(len <= k){
            str = new StringBuffer(str).reverse().toString();
        }
        return str;
    }
    public static void  main(String[] args){
        title541 test = new title541();
        System.out.println(test.reverseStr("absdhcgeowmfrg",2));
    }

优化一下：

title 746：每次只能上1个或者2个台阶，每个台阶有cost，求上到顶端的最小代价

public int minCostClimbingStairs(int[] cost) {
        int length = cost.length + 1;
        int dp0 = 0;
        int dp1 = 0;
        int dp2 = 0;
        for (int i = 2; i < length; i++) {
            dp2 = Math.min(dp0 + cost[i - 2] , dp1 + cost[i - 1]);
            dp0 = dp1;
            dp1 = dp2;
        }
        return dp2;
    }

title 350：返回两个数组的交集，与顺序无关。

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        if(nums1.length == 0 || nums2.length == 0){
            return new int[]{};
        }
        List<Integer> cur = new ArrayList<Integer>();
        quickSortArr(nums1,0,nums1.length-1);
        quickSortArr(nums2,0,nums2.length-1);
        int len1 = nums1.length;
        int len2 = nums2.length;
        int i = 0;
        int j = 0;
        while(i < len1 && j < len2){
            if(nums1[i] == nums2[j]){
                cur.add(nums1[i]);
                i++;
                j++;
            }else if(nums1[i] > nums2[j]){
                j++;
            }else{
                i++;
            }
        }
        int[] res = new int[cur.size()];
        for(int index = 0; index < cur.size();index++){
            res[index] = cur.get(index);
        }
        return res;
    }
    private void quickSortArr(int[] arr,int left,int right){
        if(left > right){
            return;
        }
        int key = arr[left];
        int i = left;
        int j = right;
        while(i < j){
            while(i < j && arr[j] > key){
                j--;
            }
            while(i < j && arr[i] <= key){
                i++;
            }
            if(i < j){
                int t = arr[i];
                arr[i] = arr[j];
                arr[j] = t;
            }
        }
        int t = arr[i];
        arr[i] = arr[left];
        arr[left] = t;
        quickSortArr(arr,left,i-1);
        quickSortArr(arr,i+1,right);
    }
}

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        if(nums1.length == 0 || nums2.length == 0){
            return new int[]{};
        }
        List<Integer> cur = new ArrayList<Integer>();
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        int len1 = nums1.length;
        int len2 = nums2.length;
        int i = 0;
        int j = 0;
        while(i < len1 && j < len2){
            if(nums1[i] == nums2[j]){
                cur.add(nums1[i]);
                i++;
                j++;
            }else if(nums1[i] > nums2[j]){
                j++;
            }else{
                i++;
            }
        }
        int[] res = new int[cur.size()];
        for(int index = 0; index < cur.size();index++){
            res[index] = cur.get(index);
        }
        return res;
    }
    
}

title 121：给一个价值数组，求出一次买入一次卖出后的最高收益；

public int maxProfit(int[] prices) {
        if(prices.length < 1){
            return 0;
        }
        int min = prices[0];
        int profit = 0;
        int len = prices.length;
        for(int i = 1; i < len; i++){
            if(min > prices[i]){
                min = prices[i];
            }else{
                if(profit < prices[i] - min){
                    profit = prices[i] - min;
                }
            }
        }
        return profit;
    }

title 674：给一个无序数组，返回数组中最长自增序列长度；

public int findLengthOfLCIS(int[] nums) {
        if(nums.length == 0){
            return 0;
        }
        int count = 1;
        int cur = nums[0];
        int max = 1;
        for(int i = 1; i < nums.length;i++){
            if(nums[i] > cur){
                count++;
            }else {
                max = count > max ? count : max;
                count=1;
            }
            cur = nums[i];
        }
        max = count > max ? count : max;
        return max;
    }

title 107：自下向上将二叉树节点值放在数组中，一层一个list；

public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> traversal = new ArrayList<List<Integer>>();  
          
        if(root == null) return traversal;  
          
        LinkedList<TreeNode> queue = new LinkedList<TreeNode>();  
        queue.add(root);  
        while(!queue.isEmpty()) {  
            int levelLen = queue.size();  
            List<Integer> levelNodes = new ArrayList<Integer>();              
            for (int i = 0; i < levelLen; i++) {  
                TreeNode node = queue.removeFirst();  
                levelNodes.add(node.val);  
                if(node.left != null) queue.add(node.left);  
                if(node.right != null) queue.add(node.right);  
            }  
            traversal.add(0, levelNodes);   //*头插法  和正常层次遍历的不同  
        }  
        return traversal;  
    }

title 747：判断一个有最大数的数组的最大值是否比其他值的2倍还大，也就是比第二大的数的2倍还大；

public int dominantIndex(int[] nums) {
        if(nums.length == 0){
            return -1;
        }
        if(nums.length == 1){
            return 0;
        }
        int index = 0;
        int max = nums[0];
        int submax = nums[0];
        int len = nums.length;
        int count = 1;
        for(int i = 1; i < len;i++){
            if(max < nums[i]){
                submax = max;
                max = nums[i];
                index = i;
                count = 1;
            }else if(max == nums[i]){
                count++;
            }else{
                if(submax == max){
                    submax = nums[i];
                    continue;
                }
                if(submax < nums[i]){
                    submax = nums[i];
                }
            }
        }
        if(max >= 2*submax && count < 2){
            return index;
        }
        return -1;
    }

title 458:有1000个瓶子里有一个有毒药，15分钟毒药生效，需要多少头小猪才能在1小时内确定哪一个是毒药？

public int poorPigs(int buckets, int minutesToDie, int minutesToTest) {
        int res = 0;
        while(Math.pow((minutesToTest/minutesToDie + 1),res) < buckets){
            res++;
        }
        return res;
    }

title 415：求两个只包含数字的字符串的和。

二、middle

三、hard