LeedCode 巧妙思想记录

2024年6月9日 169次阅读

大致套路

求总共多少 – 用分治法

求最大 – 用动态规划

求是否存在 – 用二分（先排序）

数组和链表 – 大部分可以用双指针法

 

反转数字

//pop operation:
pop = x % 10;
x /= 10;

//push operation:
temp = rev * 10 + pop;
rev = temp;

数字回文

我们如何知道反转数字的位数已经达到原始数字位数的一半？

我们将原始数字除以 10，然后给反转后的数字乘上 10，所以，当原始数字小于反转后的数字时，就意味着我们已经处理了一半位数的数字。

        while(x > revertedNumber) {
            revertedNumber = revertedNumber * 10 + x % 10;
            x /= 10;
        }

合并两个有序链表

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1 == null) {
            return l2;
        }
        if(l2 == null) {
            return l1;
        }

        if(l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

给定一个二叉树，找出其最大深度

return root == null ? 0 : Math.max(maxDepth(root.left),maxDepth(root.right)) + 1;

DFS（深度优先）实现二叉树层次遍历

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
    List<List<Integer>> ans = new ArrayList<>(); 
    DFS(root, 0, ans);
    return ans;
    }
    
    private void DFS(TreeNode root, int level, List<List<Integer>> ans) {
        if(root == null){
            return;
        }
        //当前层数还没有元素，先 new 一个空的列表
        if(ans.size()<=level){
            ans.add(new ArrayList<>());
        }
        //当前值加入
        ans.get(level).add(root.val);

        DFS(root.left,level+1,ans);
        DFS(root.right,level+1,ans);
    }

}

基本二分查找

 public boolean bsearch(int[] a,int s,int e, int k){
        if (k < a[s] || k > a[e] || s > e){
            return false;
        }
        
        int mid = (e-s)/2;
        
        if(a[mid] == k){
            return true;
        }
        if(a[mid] > k){
            bsearch(a,s,mid-1,k);
        }else{
            bsearch(a,mid+1,e,k);
        }
    }

杨辉三角

class Solution {
        public List<Integer> getRow(int rowIndex) {
        List<Integer> result = new ArrayList<>();
        if (rowIndex == 0) {
            result.add(1);
            return result;
        }
        if (rowIndex == 1) {
            result.add(1);
            result.add(1);
            return result;
        }

        result.add(1);
        result.add(1);

        for (int i = 1; i < rowIndex; i++) {
            result.add(1);
            for (int j = 0; j < i; j++) {
                result.add(result.get(0) + result.get(1));
                result.remove(0); //因为每次删除首元素 所以每次的get(0)是不同的
            }
            result.add(1);
            result.remove(0);
        }

        return result;


    }

}

两个链表相交点

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    if (headA == null || headB == null) return null;
    ListNode pA = headA, pB = headB;
    while (pA != pB) {
        pA = pA == null ? headB : pA.next;
        pB = pB == null ? headA : pB.next;
    }
    return pA;
}

 

点赞