LeetCode 4则

58.最后一个单词的长度 length of last word

/**
 * @Author BlazBlade
 * 58.最后一个单词的长度 length of last word
 * 给你一个字符串 s，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 最后一个 单词的长度。
 * 单词 是指仅由字母组成、不包含任何空格字符的最大子字符串。
 *
 * 示例:
 * 输入：s = "Hello World"
 * 输出：5
 * 解释：最后一个单词是“World”，长度为5。
 *
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode.cn/problems/length-of-last-word
 */


public class LeetCode58 {
    public int lengthOfLastWord(String s){
        int end = s.length() - 1; //字符串的长度-1
        //从后往前遍历直至遇到空格
        while(end >= 0 && s.charAt(end) == ' ' ){
            end --;
        }
        if (end < 0){
            return 0;
        }
        int start = end;
        //过滤空格再进行操作
        while( start >= 0 && s.charAt(start) != ' '){
            start --;
        }
        return end - start; //返回尾部减去头部即获得单词的长度
    }
}

83.删除排序链表中的重复元素 remove duplicates from sorted list

/**
 * @Author BlazBlade
 * 83.删除排序链表中的重复元素 remove duplicates from sorted list
 * 给定一个已排序的链表的头 head ， 删除所有重复的元素，使每个元素只出现一次 。返回 已排序的链表 。
 *
 * 示例:
 * 输入：head = [1,1,2]
 * 输出：[1,2]
 *
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode.cn/problems/lremove-duplicates-from-sorted-list
 */

public class LeetCode83 {
    //引入链表
    class ListNode {
        int val; //节点保存的内容
        ListNode next; //节点的引用, 指向下一个节点
        ListNode(int x) { val = x; }
    }
    ListNode deleteDuplicates(ListNode head){
        ListNode cur = head; //头节点
        while (cur != null && cur.next != null){ //当头部或下一位为null时则不需要继续重复
            if (cur.val == cur.next.val){ //所指和下一个节点值相同时则去重,指针跳转至下下个节点
                cur.next = cur.next.next;
            }else { //不相等则移动下一位置继续循环
                cur = cur.next;
            }
        }
        return head;
    }
}

102. 二叉树的层序遍历 binary tree level order traversal

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;

/**
 * @Author BlazBlade
 * 102. 二叉树的层序遍历 binary tree level order traversal
 * 给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
 *
 * 示例:
 * 输入：root = [3,9,20,null,null,15,7]
 * 输出：[[3],[9,20],[15,7]]
 *
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode.cn/problems/binary-tree-level-order-traversal
 */

public class LeetCode102 {
    class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
    public List<List<Integer>> breadthfirst(TreeNode root){
        List<List<Integer>> list = new ArrayList<>();//创建动态数组

        Queue<TreeNode> queue = new ArrayDeque<>();
        if (root != null){
            queue.add(root);//不为空时插入新的根结点
        }
        while (!queue.isEmpty()){//分配好内存后值为空，即值 = 空
            int n = queue.size(); //记录二叉树该层的结点数
            List<Integer> level = new ArrayList<>();
            for (int i = 0; i < n; i++){
                TreeNode node = queue.poll();//返回队首元素并删除队首元素，队列为空返回null
                level.add(node.val);
                if(node.left != null){
                    queue.add(node.left);//添加左结点
                }
                if (node.right != null){
                    queue.add(node.right);//添加右结点
                }
            }
            list.add(level);
        }
        return list;
    }
}

226. 翻转二叉树invert-binary-tree

/**
 * @Author BlazBlade
 * 226. 翻转二叉树invert-binary-tree
 * 给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
 * 示例:
 * 输入：root = [4,2,7,1,3,6,9]
 * 输出：[4,7,2,9,6,3,1]
 *
 * 来源：力扣（LeetCode）
 * 链接：https://leetcode.cn/problems/invert-binary-tree
 */

public class LeetCode226 {
    class TreeNode{
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode(){};
        TreeNode(int val){this.val = val;}
        TreeNode(int val, TreeNode left, TreeNode right){
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }

    public TreeNode invertTree(TreeNode root) {
        if (root == null){
            return null;
        }
        TreeNode left = invertTree(root.left);
        TreeNode right = invertTree(root.right);
        root.left = right;
        root.right = left;
//        TreeNode temp = root.left;
//        root.left = root.right;
//        root.right = temp;
//        TreeNode left = invertTree(root.left);
//        TreeNode right = invertTree(root.right);
        return root;
    }
}