markilue
/
self_example
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

leecode更新

This commit is contained in:
dingjiawen 2022-09-21 12:59:31 +08:00
parent 4b73b4cb59
commit b812f6384d
3 changed files with 447 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
Leecode/src/main/java/com/markilue/leecode/test/test.java Normal file
View File

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

126
Leecode/src/main/java/com/markilue/leecode/tree/InvertTree.java Normal file
View File

@ -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<TreeNode> 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;
}
}

277
Leecode/src/main/java/com/markilue/leecode/tree/IsSymmetric.java Normal file
View File

@ -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<TreeNode> 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<TreeNode> 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<TreeNode> 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<TreeNode> 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<TreeNode> 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;
}
}