力扣算法题

一、简单题

1.删除有序数组中的重复项

思路：让index从0开始，利用一个for循环，从第一个元素开始两两比较，若两个数不相同，则把下标为i的数放进下标为index+1的位置上，否则进行下一次比较

代码：

class Solution {
    public int removeDuplicates(int[] nums) {
         int index=0;
        for (int i = 1; i < nums.length; i++) {
            if(nums[i]!=nums[i-1])
                nums[++index]=nums[i];
        }
        return index+1;
    }
}

2.二叉树的前序遍历

思路：利用递归算法，依次判断根的左右孩子是否为空，先判断左子树，在判断右子树，若不为空，则把key放入list中

代码：

class Solution {
    List<Integer> list = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {
        if(root!=null){
            list.add(root.key);
            preorderTraversal(root.left);
            preorderTraversal(root.right);
        }
        return list;
    }
}

3.合并两个有序链表

思路：先判断l1,l2两个链表是否为空，若都不为空，则比较两个链表的第一个节点，将更小的值放在head中，利用递归，进行之后的比较，形成一个新的链表
代码：

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1 == null || l2 == null) return l1 == null ? l2 : l1;
        ListNode head = l1.val < l2.val ? l1 : l2;
        head.next = mergeTwoLists(head.next, head == l1 ? l2 : l1);
        return head;
    }
}

二、中等题

1.二叉树的层序遍历

思路：BFS其实就是逐层遍历的, 但在没有辅助的情况下, BFS只是单纯从队列中取出元素, 并不知道自己在遍历哪一层的节点, 因此需要size去记录每一层节点的数量, 并在每一层用一个单独的list去保存当前层的节点。

代码:

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        if (root == null) return res;
        que.offer(root); 
        while (!que.isEmpty()) {
            int size = que.size(); 
            List<Integer> level = new ArrayList<>();
            for (int i = 0; i < size; i++) {
                TreeNode node = que.poll();
                level.add(node.val);
                if (node.left != null) que.offer(node.left);
                if (node.right != null) que.offer(node.right);
            }
            res.add(level); 
        }
        return res;
    }
}

2.两数相加

思路：两个链表表示两个整数， 在相加整数的过程应该是从个位开始，由于链表的每位数字都是按照逆序的方式存储的，所以在相加的时候直接从链表头节点开始就行，需要在相加的过程中考虑进位。用n1和n2来记录l1和l2节点的值，当l1、l2不指向空的时候就取n1、n2为当前节点的值，否则为0，用n来记录是否需要进位，sum记录元素在某一位置相加之和，遍历l1和l2，新建sum%10为参数的节点，l1和l2都走完后，最后判断n的值，如果大于0，则要进位1，在链表尾部增加参数值为n的节点。

代码：

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *head=nullptr;
        ListNode *tail=nullptr;
        int n=0;
        while(l1||l2){
            int n1=l1?l1->val:0;
            int n2=l2?l2->val:0;
            int sum=n1+n2+n;
            if(!head){
                head=tail=new ListNode(sum%10);
            }
            else{
                tail->next=new ListNode(sum%10);
                tail=tail->next;
            }
            n=sum/10;
            if(l1){
                l1=l1->next;
            }
            if(l2){
                l2=l2->next;
            }
        }
        if(n>0){
            tail->next=new ListNode(n);
        }
        return head;
    }
};