Scanner常用API

• hasNextInt()：当下一个字符是整数时返回 true, 反之返回 false；

  nextInt()：把字符转换为int类型并返回；

• hasNextLine()：当下一位还有字符时返回 true, 反之返回 false；

  nextLine()：把本行剩下的字符转化位String类型并返回；

• hasNext()：当下一位还有字符时返回true，反之返回false;

  next()：把两个空格之间的字符转换为String类型并返回；

二维数组

3 2

1 2 3

4 5 6

main(){
    Scanner sc = new Scanner(System.in);
    int m = sc.nextInt();
    int n = sc.nextInt();
    int[][] arr = new int[m][n];
    scc.nextLine(); // 跳过行列后的回车符
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++){
            arr[i][j] = sc.nextInt();
            
        }
    }
}

二维字符数组

链表输入

翻转链表；

public class ListInput {
    //先构建一个节点类，用于链表构建
    static class ListNode {
        int val;
        ListNode next;
        public ListNode(int val){
            this.val = val;
        }
    }
	public static void main(String[] args){
        //输入是一串数字，请将其转换成单链表格式之后，再进行操作
        //输入描述:
        //一串数字，用逗号分隔
        //输入
        //1,2,3,4,5
        Scanner sc = new Scanner(System.in);
        //以字符串形式作为输入
        String str = sc.next().toString();
        //通过分隔符将其转为字符串数组
        String[] ss  = str.split(",");
		//初始化一个整数数组
        int[] nums = new int[ss.length];
        //给整数数组赋值
        for(int j = 0; j<nums.length;j++) {
            nums[j] = Integer.parseInt(ss[j]);
        }
        Stack<ListNode> stack = new Stack<>();
        ListNode head = new ListNode(0);
        ListNode p = head;
        //链表初始化并放入stack中
        for(int i=0;i<nums.length;i++){
            p.next = new ListNode(nums[i]);
            p = p.next;
            stack.add(p);
        }
        p = head;
        while(!stack.isEmpty()){
            q = stack.pop();
            p.next = q;
            p = q;
        }
        head = head.next;
        while(head!=null){
            if(head.next == null){
                System.out.print(head.val);
            }else{
                System.out.print(head.val + ",");
            }
            head = head.next;
        }
    }
}

二叉树构建

public class BT {

    public static class TreeNode{
        int val;
        TreeNode left;
        TreeNode right;
        public TreeNode(int val) {
            this.val = val;
        }
        public TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
    public static TreeNode construct(int[] arr){
        List<TreeNode> list = new ArrayList<>();
        TreeNode root = null;
        int n = arr.length;
        for(int i=0;i<n;i++){
            TreeNode node = new TreeNode(arr[i]);
            list.add(node);
            if(i==0)
                root = node; // 构建根节点
        }
        for(int i=0;i*2+1<n;i++){
            TreeNode node = list.get(i);
            if(node!=null){
                node.left = list.get(i*2+1);
                if(i*2+2<n){
                    node.right = list.get(i*2+2);
                }
            }
        }
        return root;
    }

    // 二叉树右视图
    public static void main(String[] args) {
        int[] arr = {1,2,3,-1,5,-1,4};
        TreeNode root = construct(arr);
        List<Integer> res = new ArrayList<>();
        Queue<TreeNode> que = new LinkedList<>();
        que.offer(root);
        while(!que.isEmpty()){
            int size = que.size();
            while(size>0){
                TreeNode node = que.poll();
                if(size==1)
                    res.add(node.val);
                if(node.left!=null)
                    que.add(node.left);
                if(node.right!=null)
                    que.add(node.right);
                size--;
            }
        }
        for(int i=0;i<res.size();i++){
            System.out.println(res.get(i));
        }
    }
}