From b812f6384d793d26fc859fc3e50c2d9c67aa635f Mon Sep 17 00:00:00 2001 From: dingjiawen <745518019@qq.com> Date: Wed, 21 Sep 2022 12:59:31 +0800 Subject: [PATCH] =?UTF-8?q?leecode=E6=9B=B4=E6=96=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../java/com/markilue/leecode/test/test.java | 44 +++ .../com/markilue/leecode/tree/InvertTree.java | 126 ++++++++ .../markilue/leecode/tree/IsSymmetric.java | 277 ++++++++++++++++++ 3 files changed, 447 insertions(+) create mode 100644 Leecode/src/main/java/com/markilue/leecode/test/test.java create mode 100644 Leecode/src/main/java/com/markilue/leecode/tree/InvertTree.java create mode 100644 Leecode/src/main/java/com/markilue/leecode/tree/IsSymmetric.java diff --git a/Leecode/src/main/java/com/markilue/leecode/test/test.java b/Leecode/src/main/java/com/markilue/leecode/test/test.java new file mode 100644 index 0000000..7ed5b07 --- /dev/null +++ b/Leecode/src/main/java/com/markilue/leecode/test/test.java @@ -0,0 +1,44 @@ +package com.markilue.leecode.test; + +import com.markilue.leecode.tree.TreeNode; +import org.junit.Test; + +import java.util.ArrayList; + +/** + * @BelongsProject: Leecode + * @BelongsPackage: com.markilue.leecode.test + * @Author: dingjiawen + * @CreateTime: 2022-09-21 11:32 + * @Description: TODO + * @Version: 1.0 + */ +public class test { + + + //测试ArrayList的index是否发生变化 + @Test + public void test(){ +// ArrayList treeNodes1 = new ArrayList<>(); +// for (int i = 0; i < 4; i++) { +// treeNodes1.add(i); +// } +// for (int i = 0; i < 4; i++) { +// System.out.println(treeNodes1.remove(i)); +// +// System.out.println(treeNodes1.remove(4 - i));//java.lang.IndexOutOfBoundsException: Index: 4, Size: 3 +// System.out.println("======================="); +// } + } + + //测试null和null是否相等 + @Test + public void test1(){ + + String s1=null; + String s2=null; + + System.out.println(s1==s2); + + } +} diff --git a/Leecode/src/main/java/com/markilue/leecode/tree/InvertTree.java b/Leecode/src/main/java/com/markilue/leecode/tree/InvertTree.java new file mode 100644 index 0000000..768ae4e --- /dev/null +++ b/Leecode/src/main/java/com/markilue/leecode/tree/InvertTree.java @@ -0,0 +1,126 @@ +package com.markilue.leecode.tree; + +import org.junit.Test; + +import java.util.LinkedList; +import java.util.Queue; + +/** + * @BelongsProject: Leecode + * @BelongsPackage: com.markilue.leecode.tree + * @Author: dingjiawen + * @CreateTime: 2022-09-21 10:15 + * @Description: + * TODO 力扣226题:翻转二叉树： + * 给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。 + + * @Version: 1.0 + */ +public class InvertTree { + + + @Test + public void test(){ + + TreeNode root = new TreeNode(4); + TreeNode TreeNode2 = new TreeNode(2); + TreeNode TreeNode3 = new TreeNode(7); + TreeNode TreeNode4 = new TreeNode(1); + TreeNode TreeNode5 = new TreeNode(3); + TreeNode TreeNode6 = new TreeNode(6); + TreeNode TreeNode7 = new TreeNode(9); + + root.setRight(TreeNode3); + root.setLeft(TreeNode2); + TreeNode2.setLeft(TreeNode4); + TreeNode2.setRight(TreeNode5); + TreeNode3.setRight(TreeNode7); + TreeNode3.setLeft(TreeNode6); + + System.out.println(invertTree1(root)); + + } + + + @Test + public void test1(){ + + TreeNode root = new TreeNode(2); +// TreeNode TreeNode2 = new TreeNode(1); +// TreeNode TreeNode3 = new TreeNode(3); +// TreeNode TreeNode4 = new TreeNode(1); +// TreeNode TreeNode5 = new TreeNode(3); +// TreeNode TreeNode6 = new TreeNode(6); +// TreeNode TreeNode7 = new TreeNode(9); + +// root.setRight(TreeNode3); +// root.setLeft(TreeNode2); +// TreeNode2.setLeft(TreeNode4); +// TreeNode2.setRight(TreeNode5); +// TreeNode3.setRight(TreeNode7); +// TreeNode3.setLeft(TreeNode6); + + System.out.println(invertTree(null)); + + } + + /** + * 自己的思路:使用一个队列记录节点；每次将poll出的节点的左右对调 + * 速度超过100%，内存超过20.6% + * @param root + * @return + */ + public TreeNode invertTree(TreeNode root) { + + Queue treeNodes = new LinkedList<>(); + + if(root==null){ + return root; + } + treeNodes.offer(root); + + while (!treeNodes.isEmpty()){ + TreeNode node = treeNodes.poll(); + + TreeNode left=node.left; + node.left=node.right; + node.right=left; + + if(node.left!=null){ + treeNodes.offer(node.left); + } + if(node.right!=null){ + treeNodes.offer(node.right); + } + } + + return root; + + } + + /** + * 自己的思路(递归法): + * 速度超过100%，内存超过83.53% + * 本质上可以看做是前序遍历 + * @param root + * @return + */ + public TreeNode invertTree1(TreeNode root) { + + + if(root==null){ + return root; + } + + //交换左右 + TreeNode left=root.left; + root.left=root.right; + root.right=left; + //递归 + invertTree1(root.left); + invertTree1(root.right); + + return root; + + } +} diff --git a/Leecode/src/main/java/com/markilue/leecode/tree/IsSymmetric.java b/Leecode/src/main/java/com/markilue/leecode/tree/IsSymmetric.java new file mode 100644 index 0000000..6dd2993 --- /dev/null +++ b/Leecode/src/main/java/com/markilue/leecode/tree/IsSymmetric.java @@ -0,0 +1,277 @@ +package com.markilue.leecode.tree; + +import org.junit.Test; + +import java.util.ArrayList; +import java.util.Deque; +import java.util.LinkedList; +import java.util.Queue; + +/** + * @BelongsProject: Leecode + * @BelongsPackage: com.markilue.leecode.tree + * @Author: dingjiawen + * @CreateTime: 2022-09-21 10:44 + * @Description: TODO 力扣101题 对称二叉树: + * 给你一个二叉树的根节点 root ， 检查它是否轴对称。 + * @Version: 1.0 + */ +public class IsSymmetric { + + @Test + public void test() { + TreeNode root = new TreeNode(1); + TreeNode TreeNode2 = new TreeNode(2); + TreeNode TreeNode3 = new TreeNode(2); + TreeNode TreeNode4 = new TreeNode(3); + TreeNode TreeNode5 = new TreeNode(4); + TreeNode TreeNode6 = new TreeNode(4); + TreeNode TreeNode7 = new TreeNode(3); + + root.setRight(TreeNode3); + root.setLeft(TreeNode2); + TreeNode2.setLeft(TreeNode4); + TreeNode2.setRight(TreeNode5); + TreeNode3.setRight(TreeNode7); + TreeNode3.setLeft(TreeNode6); + + System.out.println(isSymmetric2(root)); + } + + @Test + public void test1() { + TreeNode root = new TreeNode(1); + TreeNode TreeNode2 = new TreeNode(2); + TreeNode TreeNode3 = new TreeNode(2); + TreeNode TreeNode4 = new TreeNode(3); +// TreeNode TreeNode5 = new TreeNode(4); +// TreeNode TreeNode6 = new TreeNode(4); + TreeNode TreeNode7 = new TreeNode(3); + + root.setRight(TreeNode3); + root.setLeft(TreeNode2); +// TreeNode2.setLeft(TreeNode4); + TreeNode2.setRight(TreeNode4); + TreeNode3.setLeft(TreeNode7); +// TreeNode3.setLeft(TreeNode6); + + System.out.println(isSymmetric3(root)); + } + + + /** + * 自己的思路:这里可以节点之前层序遍历的思路->每次循环队列里只放那一层的节点,通过for循环判断是否对称 + * 速度击败21.44%，内存击败38.97% + * + * @param root + * @return + */ + public boolean isSymmetric(TreeNode root) { + + if (root == null) { + return false; + } + + Deque treeNodes = new LinkedList<>(); + + if (root.left != null) { + treeNodes.addFirst(root.left); + } + + if (root.right != null) { + treeNodes.addLast(root.right); + } + + while (!treeNodes.isEmpty()) { + int size = treeNodes.size(); + + if (size % 2 != 0) { + return false; + } + Deque treeNodeTemp = new LinkedList<>(); + for (int i = 0; i < size / 2; i++) { + TreeNode first = treeNodes.removeFirst(); + TreeNode last = treeNodes.removeLast(); + if (first.val != last.val) { + return false; + } + boolean flag = false; + boolean flag1 = false; + + if (first.right != null) { + treeNodeTemp.addFirst(first.right); + flag1 = true; + } + + if (first.left != null) { + treeNodeTemp.addFirst(first.left); + flag = true; + } + + if (last.left != null) { + if (!flag1) { + return false; + } else { + treeNodeTemp.addLast(last.left); + } + } else { + if (flag1) { + return false; + } + } + + if (last.right != null) { + if (!flag) { + return false; + } else { + treeNodeTemp.addLast(last.right); + } + } else { + if (flag) { + return false; + } + } + + } + treeNodes = treeNodeTemp; + } + + return true; + + + } + + + /** + * 自己的思路改进版:减少null值判断 + * 速度击败21.44%，内存击败25.90% + * + * @param root + * @return + */ + public boolean isSymmetric1(TreeNode root) { + + if (root == null) { + return false; + } + + Deque treeNodes = new LinkedList<>(); + + treeNodes.addFirst(root.left); + treeNodes.addLast(root.right); + + + while (!treeNodes.isEmpty()) { + int size = treeNodes.size(); + + if (size % 2 != 0) { + return false; + } + Deque treeNodeTemp = new LinkedList<>(); + for (int i = 0; i < size / 2; i++) { + TreeNode first = treeNodes.removeFirst(); + TreeNode last = treeNodes.removeLast(); + + if (first != null && last != null) { + if (first.val != last.val) { + return false; + } + treeNodeTemp.addFirst(first.right); + treeNodeTemp.addFirst(first.left); + treeNodeTemp.addLast(last.left); + treeNodeTemp.addLast(last.right); + } else if (first == null && last == null) { + continue; + } else { + return false; + } + } + treeNodes = treeNodeTemp; + } + + return true; + + + } + + + /** + * 代码随想录思路递归版: + * 速度击败100%，内存击败57.51% + * + * @param root + * @return + */ + public boolean isSymmetric2(TreeNode root) { + + if (root == null) { + return false; + } + return compare(root.left, root.right); + } + + + public boolean compare(TreeNode left, TreeNode right) { + + if (left == null && right == null) { + return true; + } else if (left != null && right == null) { + return false; + } else if (left == null && right != null) { + return false; + } else if (left != null && right != null) { + if (left.val != right.val) { + return false; + } + } + + //如果左右相等，递归比较下面的 + boolean f1 = compare(left.left, right.right); + boolean f2 = compare(left.right, right.left); + + return f1 && f2; + + } + + /** + * 代码随想录思路迭代版:自己的思路改进——>没必要使用双端队列，只需要每次成对取出来就行了 + * 速度击败21.44%，内存击败83.51% + * + * @param root + * @return + */ + public boolean isSymmetric3(TreeNode root) { + + if (root == null) { + return true; + } + + Queue treeNodes = new LinkedList<>(); + + treeNodes.offer(root.left); + treeNodes.offer(root.right); + + + while (!treeNodes.isEmpty()) { + + TreeNode first = treeNodes.poll(); + TreeNode last = treeNodes.poll(); + + if (first != null && last != null) { + if (first.val != last.val) { + return false; + } + treeNodes.offer(first.right); + treeNodes.offer(last.left); + treeNodes.offer(first.left); + treeNodes.offer(last.right); + } else if (first == null && last == null) { + continue; + } else { + return false; + } + } + + return true; + } +}