按要求编写字符界面(算法初阶、最小值和最大值)、填充每个节点的下一个右侧节点指针(树、深度优先搜索)、最大矩形(栈、数组)

按要求编写字符界面(算法初阶、最小值和最大值)

编写一个字符界面的Java Application 程序，接受用户输入的10个整数，并输出这10个整数的最大值和最小值。

import java.util.Scanner;
public class MaxMin {
    public static void main(String[] args) {
        Arrays array = new Arrays();
        array.setArr();
        int max=array.getMax();
        int min=array.getMin();
        System.out.println("数组中最大值="+max);
        System.out.println("数组中最小值="+min);
    }
}
class Arrays {
    private int[] arr;
    public Arrays() {
        arr = new int[10] ;
        for(int i = 0; i<arr.length;i++) {
            arr[i] =0;
        }
    }
    public void setArr() {
        Scanner sc = new Scanner(System.in);  
        System.out.println("请输入数组元素的值：");  
        arr = new int[10] ;
        for(int i = 0; i<arr.length;i++) {
            arr[i] = sc.nextInt();
        }
    }
    public int getMax() {
        int max = arr[0];
        for(int i : arr) {
            if(max < i)
                max = i;
        }
        return max; 
    }
    public int getMin() {
        int min= arr[0];
        for(int i : arr) {
            if(min > i)
                min= i;
        }
        return min; 
    }
}

填充每个节点的下一个右侧节点指针(树、深度优先搜索)

给定一个 **完美二叉树 **，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
struct Node {
int val;
Node *left;
Node *right;
Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。

进阶：

• 你只能使用常量级额外空间。
• 使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。

示例：

输入：root = [1,2,3,4,5,6,7] 输出：[1,#,2,3,#,4,5,6,7,#] 解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，’#’ 标志着每一层的结束。

提示：

• 树中节点的数量少于 4096
• -1000 <= node.val <= 1000

解答：

class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;
    public Node() {
    }
    public Node(int _val) {
        val = _val;
    }
    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
class Solution {
    public Node connect(Node root) {
        if (root == null)
            return root;
        if (root.left != null)
            root.left.next = root.right;
        if (root.next != null && root.right != null) {
            root.right.next = root.next.left;
        }
        connect(root.left);
        connect(root.right);
        return root;
    }
}

最大矩形(栈、数组)

给定一个仅包含 0 和 1 、大小为 rows x cols 的二维二进制矩阵，找出只包含 1 的最大矩形，并返回其面积。

示例 1：

输入：matrix = [["1","0","1","0","0"],["1","0","1","1","1"],["1","1","1","1","1"],["1","0","0","1","0"]]
输出：6
解释：最大矩形如上图所示。

示例 2：

输入：matrix = []
输出：0

示例 3：

输入：matrix = [["0"]]
输出：0

示例 4：

输入：matrix = [["1"]]
输出：1

示例 5：

输入：matrix = [["0","0"]]
输出：0

提示：

• rows == matrix.length
• cols == matrix[0].length
• 0 <= row, cols <= 200
• matrix[i][j] 为 ‘0’ 或 ‘1’

以下程序实现了这一功能，请你填补空白处内容：

class Solution {
	public int maximalRectangle(char[][] matrix) {
		if (matrix == null || matrix.length == 0)
			return 0;
		int m = matrix.length;
		int n = matrix[0].length;
		int[] left = new int[n];
		int[] right = new int[n];
		int[] height = new int[n];
		Arrays.fill(right, n);
		int cur_left = 0;
		int cur_right = n;
		int res = 0;
		for (int i = 0; i < m; i++) {
			cur_left = 0;
			cur_right = n;
			for (int j = 0; j < n; j++) {
				if (matrix[i][j] == '1')
					height[j]++;
				else
					height[j] = 0;
			}
			for (int j = 0; j < n; j++) {
				if (matrix[i][j] == '1') {
					left[j] = Math.max(left[j], cur_left);
				} else {
					left[j] = 0;
					cur_left = j + 1;
				}
			}
			for (int j = n - 1; j >= 0; j--) {
				if (matrix[i][j] == '1') {
					right[j] = Math.min(right[j], cur_right);
				} else {
					right[j] = n;
					cur_right = j;
				}
			}
			______________________;
		}
		return res;
	}
}

解答：

for (int j = 0; j < n; j++)
	res = Math.max(res, (right[j] - left[j]) * height[j]);

本文内容到此结束了，
如有收获欢迎点赞👍收藏💖关注✔️，您的鼓励是我最大的动力。
如有错误❌疑问💬欢迎各位大佬指出。
保持热爱，奔赴下一场山海。🏃🏃🏃