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);
}
}