leetCode热题16-21 解题代码,思路

前言

leetCode热题16-21 解题代码,思路
1 ✔ [200]岛屿数量 Medium 2023-03-08 191
2 ✔ [141]环形链表 Easy 2023-02-26 191
3 ✔ [103]二叉树的锯齿形层次遍历 Medium 2023-03-08 187
4 ✔ [88]合并两个有序数组 Easy 2023-02-26 187
5 ✔ [236]二叉树的最近公共祖先 Medium 2023-02-13 185
6 ✔ [46]全排列 Medium 2023-03-14 183

主要用到了深度优先搜索 ,双指针,二叉树,递归

里面包含了如何快速调试递归,二叉树的快速创建和可视化的展示方法,对所有此类型和类型的时候都可以使用,正所谓磨刀不误砍柴工。希望对大家有所帮助。
如何调试递归程序,有何技巧?

按照树形结构直观地打印出一棵二叉树、快速创建leetcode中树的结构(Java)


leetCode热题16-21 解题代码,思路

  • 前言
  • 1 ✔ [200]岛屿数量 Medium 2023-03-08 191
  • 2 ✔ [141]环形链表 Easy 2023-02-26 191
  • 3 ✔ [103]二叉树的锯齿形层次遍历 Medium 2023-03-08 187
  • 4 ✔ [88]合并两个有序数组 Easy 2023-02-26 187
  • 5 ✔ [236]二叉树的最近公共祖先 Medium 2023-02-13 185
  • 6 ✔ [46]全排列 Medium 2023-03-14 183

1 ✔ [200]岛屿数量 Medium 2023-03-08 191

//给你一个由 ‘1’(陆地)和 ‘0’(水)组成的的二维网格,请你计算网格中岛屿的数量。
//
// 岛屿总是被水包围,并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。
//
// 此外,你可以假设该网格的四条边均被水包围。
//
//
//
// 示例 1:
//
//
//输入:grid = [
// [“1”,“1”,“1”,“1”,“0”],
// [“1”,“1”,“0”,“1”,“0”],
// [“1”,“1”,“0”,“0”,“0”],
// [“0”,“0”,“0”,“0”,“0”]
//]
//输出:1
//
//
// 示例 2:
//
//
//输入:grid = [
// [“1”,“1”,“0”,“0”,“0”],
// [“1”,“1”,“0”,“0”,“0”],
// [“0”,“0”,“1”,“0”,“0”],
// [“0”,“0”,“0”,“1”,“1”]
//]
//输出:3
//
//
//
//
// 提示:
//
//
// m == grid.length
// n == grid[i].length
// 1 <= m, n <= 300
// grid[i][j] 的值为 ‘0’ 或 ‘1’
//
//
// Related Topics 深度优先搜索 广度优先搜索 并查集 数组 矩阵 2107 0


这道题目本身没什么难度,但是使用了递归,调试起来非常的掉头发,我从网上找了好的调试递归的方法,也整理成了文章:如何调试递归程序,有何技巧?

使用的演示代码就是这道题

自测代码

public class P200_NumberOfIslands{
	static  Integer leve = 0;
	 public static void main(String[] args) {
	 	 //测试代码
	 	 Solution solution = new P200_NumberOfIslands().new Solution();
		  String data = "[[\"1\",\"1\",\"1\",\"1\",\"0\"],[\"1\",\"1\",\"0\",\"1\",\"0\"],[\"1\",\"1\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\",\"0\"]]";
		 Character[][] characters = ArrayUtil.StrToCharacterArray(data);

		 System.out.println(solution.numIslands(characters));
	 }
	 
//力扣代码
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {

    public int numIslands(Character[][] grid) {


		int len = grid.length;
		int res = 0 ;
		for (int i = 0; i < len; i++) {
			int l = grid[i].length;
			for (int i1 = 0; i1 < l; i1++) {
				if (grid[i][i1] == '1'){
					/**/
					low(i, i1, grid,1);
					res++;
				}
			}
		}

		return res;

    }

	//输入:grid = [
//  ["1","1","1","1","0"],
//  ["1","1","0","1","0"],
//  ["1","1","0","0","0"],
//  ["0","0","0","0","0"]
//]
	public void low(int y , int x,Character[][] grid,int move){

		int r = x;
		int l = y;

		int length = grid[l].length;
		int len = grid.length;
		grid[l][r] = '0' ;

		String lev = "";
		for (Integer i = 0; i < leve; i++) {
			lev += "\t";
		}
		System.out.println(lev+"调用了第"+ ++leve +"层low函数 | 参数 l r "+l+" "+r);
		for (int i = 0; i < len; i++) {
			int length1 = grid[i].length;
			System.out.print(lev);
			for (int i1 = 0; i1 < length1; i1++) {
				System.out.print(  grid[i][i1]+" ");
			}
			System.out.println();
		}
		System.out.println();


		/*右*/
		while( r+1 < length && grid[l][r+1] == '1'&& ! (move == 2) ){
			low(l , ++r,grid,1);
		}
		r = x;

		/*左*/
		while(0<= r-1 && grid[l][r-1] == '1'&& !(move == 1)  ){
			low(l , --r,grid,2);
		}
		r = x;

		/*上*/
		while(0<= l-1 && grid[l-1][r] == '1'&& !(move == 3)   ){
			low(--l , r,grid,4);
		}
		l = y;
		/*下*/
		while(l+1 < len && grid[l+1][r] == '1'&& !(move == 4)   ){
			low(++l , r,grid,3);
		}
		l = y;


		System.out.println(lev+"退出了第"+ leve-- +"层low函数 | 参数 l r "+l+" "+r);
		for (int i = 0; i < len; i++) {
			int length1 = grid[i].length;
			System.out.print(lev);
			for (int i1 = 0; i1 < length1; i1++) {
				System.out.print(  grid[i][i1]+" ");
			}
			System.out.println();
		}
		System.out.println();

	}

}
//leetcode submit region end(Prohibit modification and deletion)

}


控制台打印展示

这样再配合断点调试,可以很快很省头发的找到问题。

调用了第1层low函数 | 参数 l r 0 0
0 1 1 1 0 
1 1 0 1 0 
1 1 0 0 0 
0 0 0 0 0 

	调用了第2层low函数 | 参数 l r 0 1
	0 0 1 1 0 
	1 1 0 1 0 
	1 1 0 0 0 
	0 0 0 0 0 

		调用了第3层low函数 | 参数 l r 0 2
		0 0 0 1 0 
		1 1 0 1 0 
		1 1 0 0 0 
		0 0 0 0 0 

			调用了第4层low函数 | 参数 l r 0 3
			0 0 0 0 0 
			1 1 0 1 0 
			1 1 0 0 0 
			0 0 0 0 0 

				调用了第5层low函数 | 参数 l r 1 3
				0 0 0 0 0 
				1 1 0 0 0 
				1 1 0 0 0 
				0 0 0 0 0 

				退出了第5层low函数 | 参数 l r 1 3
				0 0 0 0 0 
				1 1 0 0 0 
				1 1 0 0 0 
				0 0 0 0 0 

			退出了第4层low函数 | 参数 l r 0 3
			0 0 0 0 0 
			1 1 0 0 0 
			1 1 0 0 0 
			0 0 0 0 0 

		退出了第3层low函数 | 参数 l r 0 2
		0 0 0 0 0 
		1 1 0 0 0 
		1 1 0 0 0 
		0 0 0 0 0 

		调用了第3层low函数 | 参数 l r 1 1
		0 0 0 0 0 
		1 0 0 0 0 
		1 1 0 0 0 
		0 0 0 0 0 

			调用了第4层low函数 | 参数 l r 1 0
			0 0 0 0 0 
			0 0 0 0 0 
			1 1 0 0 0 
			0 0 0 0 0 

				调用了第5层low函数 | 参数 l r 2 0
				0 0 0 0 0 
				0 0 0 0 0 
				0 1 0 0 0 
				0 0 0 0 0 

					调用了第6层low函数 | 参数 l r 2 1
					0 0 0 0 0 
					0 0 0 0 0 
					0 0 0 0 0 
					0 0 0 0 0 

					退出了第6层low函数 | 参数 l r 2 1
					0 0 0 0 0 
					0 0 0 0 0 
					0 0 0 0 0 
					0 0 0 0 0 

				退出了第5层low函数 | 参数 l r 2 0
				0 0 0 0 0 
				0 0 0 0 0 
				0 0 0 0 0 
				0 0 0 0 0 

			退出了第4层low函数 | 参数 l r 1 0
			0 0 0 0 0 
			0 0 0 0 0 
			0 0 0 0 0 
			0 0 0 0 0 

		退出了第3层low函数 | 参数 l r 1 1
		0 0 0 0 0 
		0 0 0 0 0 
		0 0 0 0 0 
		0 0 0 0 0 

	退出了第2层low函数 | 参数 l r 0 1
	0 0 0 0 0 
	0 0 0 0 0 
	0 0 0 0 0 
	0 0 0 0 0 

退出了第1层low函数 | 参数 l r 0 0
0 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 
0 0 0 0 0 

1

提交代码


class Solution {

    public int numIslands(char[][] grid) {


		int len = grid.length;
		int res = 0 ;
		for (int i = 0; i < len; i++) {
			int l = grid[i].length;
			for (int i1 = 0; i1 < l; i1++) {
				if (grid[i][i1] == '1'){
					/**/
					low(i, i1, grid,1);
					res++;
				}
			}
		}

		return res;

    }

	//输入:grid = [
//  ["1","1","1","1","0"],
//  ["1","1","0","1","0"],
//  ["1","1","0","0","0"],
//  ["0","0","0","0","0"]
//]
	public void low(int y , int x,char[][] grid,int move){

		int r = x;
		int l = y;

		int length = grid[l].length;
		int len = grid.length;
		grid[l][r] = '0' ;

//		String lev = "";
//		for (Integer i = 0; i < leve; i++) {
//			lev += "\t";
//		}
//		System.out.println(lev+"调用了第"+ ++leve +"层low函数 | 参数 l r "+l+" "+r);
//		for (int i = 0; i < len; i++) {
//			int length1 = grid[i].length;
//			System.out.print(lev);
//			for (int i1 = 0; i1 < length1; i1++) {
//				System.out.print(  grid[i][i1]+" ");
//			}
//			System.out.println();
//		}
//		System.out.println();


		/*右*/
		while( r+1 < length && grid[l][r+1] == '1'&& ! (move == 2) ){

			low(l , ++r,grid,1);
		}
		r = x;

		/*左*/
		while(0<= r-1 && grid[l][r-1] == '1'&& !(move == 1)  ){
			low(l , --r,grid,2);
//			grid[l][r-1] = '0';
//			r--;
		}
		r = x;

		/*上*/
		while(0<= l-1 && grid[l-1][r] == '1'&& !(move == 3)   ){
			low(--l , r,grid,4);
//			grid[l-1][r] = '0';
//			l--;
		}
		l = y;
		/*下*/
		while(l+1 < len && grid[l+1][r] == '1'&& !(move == 4)   ){
			low(++l , r,grid,3);
//			grid[l+1][r] = '0';
//			l++;
		}
		l = y;


//		System.out.println(lev+"退出了第"+ leve-- +"层low函数 | 参数 l r "+l+" "+r);
//		for (int i = 0; i < len; i++) {
//			int length1 = grid[i].length;
//			System.out.print(lev);
//			for (int i1 = 0; i1 < length1; i1++) {
//				System.out.print(  grid[i][i1]+" ");
//			}
//			System.out.println();
//		}
//		System.out.println();

	}

}

2 ✔ [141]环形链表 Easy 2023-02-26 191

//给你一个链表的头节点 head ,判断链表中是否有环。
//
// 如果链表中有某个节点,可以通过连续跟踪 next 指针再次到达,则链表中存在环。 为了表示给定链表中的环,评测系统内部使用整数 pos 来表示链表尾连接到
//链表中的位置(索引从 0 开始)。注意:pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。
//
// 如果链表中存在环 ,则返回 true 。 否则,返回 false 。
//
//
//
// 示例 1:
//
//
//
//
//输入:head = [3,2,0,-4], pos = 1
//输出:true
//解释:链表中有一个环,其尾部连接到第二个节点。
//
//
// 示例 2:
//
//
//
//
//输入:head = [1,2], pos = 0
//输出:true
//解释:链表中有一个环,其尾部连接到第一个节点。
//
//
// 示例 3:
//
//
//
//
//输入:head = [1], pos = -1
//输出:false
//解释:链表中没有环。
//
//
//
//
// 提示:
//
//
// 链表中节点的数目范围是 [0, 10⁴]
// -10⁵ <= Node.val <= 10⁵
// pos 为 -1 或者链表中的一个 有效索引 。
//
//
//
//
// 进阶:你能用 O(1)(即,常量)内存解决此问题吗?
//
// Related Topics 哈希表 链表 双指针 1774 0

提交代码

public class Solution {
    public boolean hasCycle(ListNode head) {

		if (head == null) {
			return false;
		}

		ListNode first = head;
		ListNode end = head;


		while (first.next != null && first.next.next != null){
			first = first.next.next;
			end = end.next;
			if (first == end){
				return true;
			}
		}


		return false;

    }
}

3 ✔ [103]二叉树的锯齿形层次遍历 Medium 2023-03-08 187

//给你二叉树的根节点 root ,返回其节点值的 锯齿形层序遍历 。(即先从左往右,再从右往左进行下一层遍历,以此类推,层与层之间交替进行)。
//
//
//
// 示例 1:
//
//
//输入:root = [3,9,20,null,null,15,7]
//输出:[[3],[20,9],[15,7]]
//
//
// 示例 2:
//
//
//输入:root = [1]
//输出:[[1]]
//
//
// 示例 3:
//
//
//输入:root = []
//输出:[]
//
//
//
//
// 提示:
//
//
// 树中节点数目在范围 [0, 2000] 内
// -100 <= Node.val <= 100
//
//
// Related Topics 树 广度优先搜索 二叉树 749 0

自测代码

public class P103_BinaryTreeZigzagLevelOrderTraversal{
	 public static void main(String[] args) {
	 	 //测试代码
	 	 Solution solution = new P103_BinaryTreeZigzagLevelOrderTraversal().new Solution();
		 String data = "[3,9,20,null,null,15,7]";
		 TreeNode treeNode = TreeNode.mkTree(data);
		 List<List<Integer>> lists = solution.zigzagLevelOrder(treeNode);
		 System.out.println(PrintData.printArrayListToStrArray(lists));
	 }
	 
//力扣代码
//leetcode submit region begin(Prohibit modification and deletion)
/**
 * Definition for a binary tree node.
 * public 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;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {


		List<List<Integer>> res = new ArrayList<>();
		if (root == null) {
			return res;
		}
		ArrayList<Integer> integers1 = new ArrayList<>();
		integers1.add(root.val);
		res.add(integers1);
		Stack<TreeNode> integers = new Stack<>();
		integers.add(root);
		Boolean sgin = false;
		while (!integers.empty()){
			integers = level(integers,res,sgin);
			sgin = !sgin;
		}

		return res;
	}

	public Stack<TreeNode> level(Stack<TreeNode> data,List<List<Integer>> res,Boolean sgin){
		ArrayList<Integer> integers = new ArrayList<>();
		Stack<TreeNode> treeNodes = new Stack<>();
		if(sgin){
			while (!data.empty()) {
				TreeNode pop = data.pop();
				if (pop == null) {
					continue;
				}
				TreeNode left = pop.left;
				TreeNode right = pop.right;
				if (left != null) {
					integers.add(left.val);
					treeNodes.add(left);

				}
				if (right != null) {
					integers.add(right.val);
					treeNodes.add(right);

				}

			}

		}else {
			while (!data.empty()){
				TreeNode pop = data.pop();
				if (pop == null) {
					continue;
				}
				TreeNode right = pop.right;
				TreeNode left = pop.left;
				if (right != null) {
					integers.add(right.val);
					treeNodes.add(right);

				}

				if (left != null) {
					integers.add(left.val);
					treeNodes.add(left);

				}

			}

		}
		if (!integers.isEmpty()) {
			res.add(integers);
		}
		return treeNodes;
	}


}
//leetcode submit region end(Prohibit modification and deletion)

}


提交代码

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {


		List<List<Integer>> res = new ArrayList<>();
		if (root == null) {
			return res;
		}
		ArrayList<Integer> integers1 = new ArrayList<>();
		integers1.add(root.val);
		res.add(integers1);
		Stack<TreeNode> integers = new Stack<>();
		integers.add(root);
		Boolean sgin = false;
		while (!integers.empty()){
			integers = level(integers,res,sgin);
			sgin = !sgin;
		}

		return res;
	}

	public Stack<TreeNode> level(Stack<TreeNode> data,List<List<Integer>> res,Boolean sgin){
		ArrayList<Integer> integers = new ArrayList<>();
		Stack<TreeNode> treeNodes = new Stack<>();
		if(sgin){
			while (!data.empty()) {
				TreeNode pop = data.pop();
				if (pop == null) {
					continue;
				}
				TreeNode left = pop.left;
				TreeNode right = pop.right;
				if (left != null) {
					integers.add(left.val);
					treeNodes.add(left);

				}
				if (right != null) {
					integers.add(right.val);
					treeNodes.add(right);

				}

			}

		}else {
			while (!data.empty()){
				TreeNode pop = data.pop();
				if (pop == null) {
					continue;
				}
				TreeNode right = pop.right;
				TreeNode left = pop.left;
				if (right != null) {
					integers.add(right.val);
					treeNodes.add(right);

				}

				if (left != null) {
					integers.add(left.val);
					treeNodes.add(left);

				}

			}

		}
		if (!integers.isEmpty()) {
			res.add(integers);
		}
		return treeNodes;
	}


}

4 ✔ [88]合并两个有序数组 Easy 2023-02-26 187

//给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2,另有两个整数 m 和 n ,分别表示 nums1 和 nums2 中的元素数目。
//
// 请你 合并 nums2 到 nums1 中,使合并后的数组同样按 非递减顺序 排列。
//
// 注意:最终,合并后数组不应由函数返回,而是存储在数组 nums1 中。为了应对这种情况,nums1 的初始长度为 m + n,其中前 m 个元素表示应合并
//的元素,后 n 个元素为 0 ,应忽略。nums2 的长度为 n 。
//
//
//
// 示例 1:
//
//
//输入:nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
//输出:[1,2,2,3,5,6]
//解释:需要合并 [1,2,3] 和 [2,5,6] 。
//合并结果是 [1,2,2,3,5,6] ,其中斜体加粗标注的为 nums1 中的元素。
//
//
// 示例 2:
//
//
//输入:nums1 = [1], m = 1, nums2 = [], n = 0
//输出:[1]
//解释:需要合并 [1] 和 [] 。
//合并结果是 [1] 。
//
//
// 示例 3:
//
//
//输入:nums1 = [0], m = 0, nums2 = [1], n = 1
//输出:[1]
//解释:需要合并的数组是 [] 和 [1] 。
//合并结果是 [1] 。
//注意,因为 m = 0 ,所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。
//
//
//
//
// 提示:
//
//
// nums1.length == m + n
// nums2.length == n
// 0 <= m, n <= 200
// 1 <= m + n <= 200
// -10⁹ <= nums1[i], nums2[j] <= 10⁹
//
//
//
//
// 进阶:你可以设计实现一个时间复杂度为 O(m + n) 的算法解决此问题吗?
//
// Related Topics 数组 双指针 排序 1775 0

自测代码

public class P88_MergeSortedArray{
	 public static void main(String[] args) {
	 	 //测试代码
	 	 Solution solution = new P88_MergeSortedArray().new Solution();

		 int[] ints1 = ArrayUtil.StrToIntArray("[1]");
		 int[] ints2 = ArrayUtil.StrToIntArray("[]");
		 solution.merge(ints1,1,ints2,0);

	 }
	 
//力扣代码
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {

		int s1 = m-1;
		int s2 = n-1;
		int s3 = m+n-1;
		while (s1 >= 0 || s2 >=  0){

			if (s1 < 0) {
				while (s2 >=  0){
					nums1[s3--] = nums2[s2];
					s2--;
				}
				return;
			}

			if (s2 < 0) {
				while (s1 >=  0){
					nums1[s3--] = nums1[s1];
					s1--;
				}
				return;
			}

			if (nums1[s1] > nums2[s2]) {
				nums1[s3--] = nums1[s1];
				s1--;
			}else {
				nums1[s3--] = nums2[s2];
				s2--;
			}

		}



    }
}
//leetcode submit region end(Prohibit modification and deletion)

}


提交代码

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {

		int s1 = m-1;
		int s2 = n-1;
		int s3 = m+n-1;
		while (s1 >= 0 || s2 >=  0){

			if (s1 < 0) {
				while (s2 >=  0){
					nums1[s3--] = nums2[s2];
					s2--;
				}
				return;
			}

			if (s2 < 0) {
				while (s1 >=  0){
					nums1[s3--] = nums1[s1];
					s1--;
				}
				return;
			}

			if (nums1[s1] > nums2[s2]) {
				nums1[s3--] = nums1[s1];
				s1--;
			}else {
				nums1[s3--] = nums2[s2];
				s2--;
			}

		}



    }
}

5 ✔ [236]二叉树的最近公共祖先 Medium 2023-02-13 185

//给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。
//
// 百度百科中最近公共祖先的定义为:“对于有根树 T 的两个节点 p、q,最近公共祖先表示为一个节点 x,满足 x 是 p、q 的祖先且 x 的深度尽可能大(
//一个节点也可以是它自己的祖先)。”
//
//
//
// 示例 1:
//
//
//输入:root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
//输出:3
//解释:节点 5 和节点 1 的最近公共祖先是节点 3 。
//
//
// 示例 2:
//
//
//输入:root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
//输出:5
//解释:节点 5 和节点 4 的最近公共祖先是节点 5 。因为根据定义最近公共祖先节点可以为节点本身。
//
//
// 示例 3:
//
//
//输入:root = [1,2], p = 1, q = 2
//输出:1
//
//
//
//
// 提示:
//
//
// 树中节点数目在范围 [2, 10⁵] 内。
// -10⁹ <= Node.val <= 10⁹
// 所有 Node.val 互不相同 。
// p != q
// p 和 q 均存在于给定的二叉树中。
//
//
// Related Topics 树 深度优先搜索 二叉树 2195 0

自测代码

import cn.wanghaixin.solution.utils.ArrayUtil;
import cn.wanghaixin.solution.utils.TreeNode;

/**
 * 二叉树的最近公共祖先
 * @author Wang Hai Xin
 * @date 2023-03-15 15:38:10
 */
public class P236_LowestCommonAncestorOfABinaryTree{
	 public static void main(String[] args) {

        String s = "[3,5,1,6,2,0,8,null,null,7,4]";
         TreeNode treeNode = TreeNode.mkTree(s);
         TreeNode.show(treeNode);

         TreeNode left = treeNode.left;
         //测试代码
	 	 Solution solution = new P236_LowestCommonAncestorOfABinaryTree().new Solution();

         solution.lowestCommonAncestor(treeNode,treeNode,left);

	 }
	 
//力扣代码
//leetcode submit region begin(Prohibit modification and deletion)
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {

    private TreeNode ans = null;


    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {

        dfs(root,p,q);
        return ans;

    }

    public Boolean dfs(TreeNode root, TreeNode p, TreeNode q) {

        if (root == null) {
            return false;
        }
        Boolean left = dfs(root.left, p, q);
        Boolean right = dfs(root.right, p, q);

        if ((left && right) || (root.val == p.val||root.val == q.val) && ( right || left)) {
            ans = root;
        }


        return (left||right) || (root.val == p.val || root.val == q.val) ;
    }
}
//leetcode submit region end(Prohibit modification and deletion)

}


提交代码

class Solution {

    private TreeNode ans = null;


    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {

        dfs(root,p,q);
        return ans;

    }

    public Boolean dfs(TreeNode root, TreeNode p, TreeNode q) {

        if (root == null) {
            return false;
        }
        Boolean left = dfs(root.left, p, q);
        Boolean right = dfs(root.right, p, q);

        if ((left && right) || (root.val == p.val||root.val == q.val) && ( right || left)) {
            ans = root;
        }


        return (left||right) || (root.val == p.val || root.val == q.val) ;
    }
}

6 ✔ [46]全排列 Medium 2023-03-14 183

//给定一个不含重复数字的数组 nums ,返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
//
//
//
// 示例 1:
//
//
//输入:nums = [1,2,3]
//输出:[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
//
//
// 示例 2:
//
//
//输入:nums = [0,1]
//输出:[[0,1],[1,0]]
//
//
// 示例 3:
//
//
//输入:nums = [1]
//输出:[[1]]
//
//
//
//
// 提示:
//
//
// 1 <= nums.length <= 6
// -10 <= nums[i] <= 10
// nums 中的所有整数 互不相同
//
//
// Related Topics 数组 回溯 2458 0


自测代码

public class P46_Permutations{
	 public static void main(String[] args) {
	 	 //测试代码
	 	 Solution solution = new P46_Permutations().new Solution();
		 int[] ints = ArrayUtil.StrToIntArray("[0,1]");
		 solution.permute(ints);

	 }
	 
//力扣代码
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
    public List<List<Integer>> permute(int[] nums) {

		List<List<Integer>> res = new ArrayList<>();

		int len = nums.length;
		List<Integer> data = new ArrayList<>();
		dfs(nums,data,res,0,len);

		return res;
    }

	private void dfs(int[] nums,List<Integer> data, List<List<Integer>> res, int i,int len) {
		ArrayList<String> objectArrayList = new ArrayList<>();
		objectArrayList.add(ArrayUtil.arrayToString(nums));
		objectArrayList.add(ArrayUtil.arrayListToString(data));
		objectArrayList.add(ArrayUtil.arrayListToString(res));
		objectArrayList.add(i+" ");
		objectArrayList.add(len+" ");
		PrintData.printRecursionStart("dfs",objectArrayList);


		if (i == len) {
			ArrayList<Integer> integers = new ArrayList<>(data);
			res.add(integers);

			ArrayList<String> objectArrayList1 = new ArrayList<>();
			objectArrayList1.add(ArrayUtil.arrayToString(nums));
			objectArrayList1.add(ArrayUtil.arrayListToString(data));
			objectArrayList1.add(ArrayUtil.arrayListToString(res));
			objectArrayList1.add(i+" ");
			objectArrayList1.add(len+" ");
			PrintData.printRecursionEnd("dfs",objectArrayList1);
			return;
		}

		for (int i1 = 0; i1 < len; i1++) {
			int temp = nums[i1];
			if (nums[i1] != 11) {
				data.add(nums[i1]);
				nums[i1] = 11;
			}else {
				continue;
			}
			dfs(nums,data,res,i+1,len);
			data.remove(data.size()-1);
			nums[i1] = temp;
		}

		ArrayList<String> objectArrayList2 = new ArrayList<>();
		objectArrayList2.add(ArrayUtil.arrayToString(nums));
		objectArrayList2.add(ArrayUtil.arrayListToString(data));
		objectArrayList2.add(ArrayUtil.arrayListToString(res));
		objectArrayList2.add(i+" ");
		objectArrayList2.add(len+" ");
		PrintData.printRecursionEnd("dfs",objectArrayList2);
	}


}
//leetcode submit region end(Prohibit modification and deletion)

}


自测代码中利用了打印递归的的方法


    /**
     * description: printRecursionStart 递归打印输出值 
     * @author Wang Hai Xin
     * @date 
     * 
     * @param name
 * @param parameter
     * @return void
     */
    
    public static void printRecursionStart(String name,List<String> parameter) {
        int len = parameter.size();
        String lev = "";
        ++leve;
        for (Integer i = 1; i < leve; i++) {
            lev += "\t";
        }
        System.out.print(lev+"调用了第"+ leve +"层"+name+"函数 | ");

        for (int i = 0; i < len; i++) {
            System.out.print(  parameter.get(i)+" ");
        }
        System.out.println();
    }

    /**
     * description: printRecursionEnd 递归打印结束值
     * @author Wang Hai Xin
     * @date 
     * 
     * @param name
 * @param parameter
     * @return void
     */
    
    public static void printRecursionEnd(String name,List<String> parameter) {

        int len = parameter.size();
        String lev = "";
        for (Integer i = 1; i < leve; i++) {
            lev += "\t";
        }
        System.out.print(lev+"退出了第"+ leve-- +"层"+name+"函数 | ");
        for (int i = 0; i < len; i++) {
            System.out.print(  parameter.get(i)+" ");
        }
        System.out.println();
    }

提交代码

class Solution {
    public List<List<Integer>> permute(int[] nums) {

		List<List<Integer>> res = new ArrayList<>();

		int len = nums.length;
		List<Integer> data = new ArrayList<>();
		dfs(nums,data,res,0,len);

		return res;
    }

	private void dfs(int[] nums,List<Integer> data, List<List<Integer>> res, int i,int len) {
//		ArrayList objectArrayList = new ArrayList<>();
//		objectArrayList.add(ArrayUtil.arrayToString(nums));
//		objectArrayList.add(ArrayUtil.arrayListToString(data));
//		objectArrayList.add(ArrayUtil.arrayListToString(res));
//		objectArrayList.add(i+" ");
//		objectArrayList.add(len+" ");
//		PrintData.printRecursionStart("dfs",objectArrayList);


		if (i == len) {
			ArrayList<Integer> integers = new ArrayList<>(data);
			res.add(integers);

//			ArrayList objectArrayList1 = new ArrayList<>();
//			objectArrayList1.add(ArrayUtil.arrayToString(nums));
//			objectArrayList1.add(ArrayUtil.arrayListToString(data));
//			objectArrayList1.add(ArrayUtil.arrayListToString(res));
//			objectArrayList1.add(i+" ");
//			objectArrayList1.add(len+" ");
//			PrintData.printRecursionEnd("dfs",objectArrayList1);
			return;
		}

		for (int i1 = 0; i1 < len; i1++) {
			int temp = nums[i1];
			if (nums[i1] != 11) {
				data.add(nums[i1]);
				nums[i1] = 11;
			}else {
				continue;
			}
			dfs(nums,data,res,i+1,len);
			data.remove(data.size()-1);
			nums[i1] = temp;
		}

//		ArrayList objectArrayList2 = new ArrayList<>();
//		objectArrayList2.add(ArrayUtil.arrayToString(nums));
//		objectArrayList2.add(ArrayUtil.arrayListToString(data));
//		objectArrayList2.add(ArrayUtil.arrayListToString(res));
//		objectArrayList2.add(i+" ");
//		objectArrayList2.add(len+" ");
//		PrintData.printRecursionEnd("dfs",objectArrayList2);
	}


}

你可能感兴趣的:(leetcode,java,算法,递归调试,打印可视化二叉树)