【详解二叉树】

🌠作者：@TheMythWS.

🎇座右铭：不走心的努力都是在敷衍自己，让自己所做的选择，熠熠发光。 

目录

树形结构 

概念

树的示意图

树的基本术语

树的表示

树的应用

二叉树(重点) 

二叉树的定义

二叉树的五种不同形态 

两种特殊的二叉树

二叉树的性质(重点!!!)

练习题 

二叉树的存储

二叉树的基本操作 

二叉树的遍历概念理解（ (Traversing Binary Tree) )

1.先序遍历(DLR)

2.中序遍历(LDR) 

3.后序遍历(LRD)

练习题一

4.层序遍历 

练习题二

递归实现-先序中序后序遍历

非递归实现-先序中序后序遍历:

获取树中结点的个数 

获取叶子结点(度为0的结点)的个数 

获取第K层结点的个数 

获取二叉树的高度 

检测值为value的元素是否存在

层序遍历 

判断一棵树是不是完全二叉树 

OJ练习题 

 

树形结构 

概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

它具有以下的特点：

  • 有一个特殊的结点，称为根(root)结点，根结点没有直接前驱结点, 只有后继结点.
  • 除根结点外，其余结点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个集合Ti (1 <= i <=m) 又是一棵与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个直接后继
  • 树是递归定义的。 

树的示意图

注意：树形结构中，子树之间不能有交集，否则就不是树形结构   

树的基本术语

结点的度：一个结点含有子树的个数称为该结点的度； 如上图：A的度为6
树的度：(唯一性)一棵树中，所有结点度的最大值称为树的度； 如上图：树的度为6
叶子结点或终端结点：度为0的结点称为叶子结点； 如上图：B、C、H、I...等结点点为叶子结点
双亲结点或父结点：若一个结点含有子结点，则这个结点称为其子结点的父结点； 如上图：A是B的父结点
孩子结点或子结点：一个结点含有的子树的根结点称为该结点的子结点； 如上图：B是A的孩子结点
根结点：一棵树中，没有双亲结点的结点；如上图：A
结点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推
树的高度或深度：树中结点的最大层次； 如上图：树的高度为4

树的以下概念只需了解，只要知道是什么意思即可：
非终端结点或分支结点：度不为0的结点； 如上图：D、E、F、G...等节点为分支结点
兄弟结点：具有相同父结点的结点互称为兄弟结点； 如上图：B、C是兄弟结点
堂兄弟结点：双亲在同一层的结点互为堂兄弟；如上图：H、I互为堂兄弟结点
结点的祖先：从根到该结点所经分支上的所有结点；如上图：A是所有结点的祖先
子孙：以某结点为根的子树中任一结点都称为该结点的子孙。如上图：所有结点都是A的子孙
有序树与无序树:若一棵树中所有子树从左到右的排序是有顺序的，不能颠倒次序，称该树为有序树；反之称为无序树。 
森林：由m（m>=0）棵互不相交的树组成的集合称为森林  

树的表示

class Node {int value; // 树中存储的数据Node firstChild; // 第一个孩子引用Node nextBrother; // 下一个兄弟引用
}

树的应用

文件系统管理（目录和文件）  

二叉树(重点) 

二叉树的定义

一棵二叉树是结点的一个有限集合，该集合：
1. 或者为空
2. 或者是由一个根结点加上两棵别称为左子树和右子树的互不相交的二叉树组成。  

特点： 
1） 每个结点的度≤2；
2） 是有序树；
说明： 二叉树的特点是每个结点最多有两个孩子， 或者说， 在二叉树中， 不存在度大于2的结点， 
并且二叉树是有序树（ 树为无序树）, 其子树的顺序不能颠倒。  

二叉树的五种不同形态 

两种特殊的二叉树

1. 满二叉树: 一棵二叉树，如果每层的结点数都达到最大值，则这棵二叉树就是满二叉树。也就是说，如果一棵二叉树的层数为K，且结点总数是2^k - 1，则它就是满二叉树。
2. 完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从0至n-1的结点一一对应时称之为完全二叉树。
要注意的是满二叉树是一种特殊的完全二叉树。  

二叉树的性质(重点!!!)

练习题 

1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数n0为（ ）
A 不存在这样的二叉树
B 200
C 198
D 199
n0 = n2 + 1 = 200

2.在具有 2n 个结点的完全二叉树中，叶子结点个数为（ ）
A n
B n+1
C n-1
D n/2

3.一个具有767个结点的完全二叉树，其叶子结点个数为（）
A 383
B 384
C 385
D 386
奇数个结点的完全二叉树说明没有度为1的结点, 则767 = n0 + n2, n0 = n2 + 1, n2 = n0 - 1, 767 = 2n0 - 1, n0 = 384.

4.一棵完全二叉树的结点数为531个，那么这棵树的高度为（ ）
A 11
B 10
C 8
D 12 

二叉树的存储

顺序存储结构（数组表示） 

链式存储结构（指针表示） 

二叉树的链式存储是通过一个一个的结点引用起来的，常见的表示方式有二叉和三叉表示方式，具体如下：   

// 孩子表示法
class Node {int val; // 数据域Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
} 
// 孩子双亲表示法
class Node {int val; // 数据域Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树Node parent; // 当前结点的根结点
}

二叉树的基本操作 

前置说明

此处手动快速创建一棵简单的二叉树，快速进入二叉树操作学习，等二叉树结构了解的差不多时，我们反过头再来研究二叉树真正的创建方式。

public class BinaryTree {public static class BTNode {BTNode left;BTNode right;int value;BTNode(int value) {this.value = value;}}private BTNode root;public void createBinaryTree() {BTNode node1 = new BTNode(1);BTNode node2 = new BTNode(2);BTNode node3 = new BTNode(3);BTNode node4 = new BTNode(4);BTNode node5 = new BTNode(5);BTNode node6 = new BTNode(6);root = node1;node1.left = node2;node2.left = node3;node1.right = node4;node4.left = node5;node5.right = node6;}public static void main(String[] args) {BinaryTree binaryTree = new BinaryTree();binaryTree.createBinaryTree();}
}

 

注意：上述代码并不是创建二叉树的方式，真正创建二叉树方式后序详解重点讲解.
从概念中可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照该概念实现的。  

二叉树的遍历概念理解（ (Traversing Binary Tree) )

1.先序遍历(DLR)

2.中序遍历(LDR) 

3.后序遍历(LRD)

练习题一

问题1：如何可唯一地确定一棵二叉树？  
答:先序(找根)+中序(找位置) 或 后序(找根)+中序(找位置)均可唯一地确定一棵二叉树
先序 + 后序(X)

问题2：二叉树的二叉链表存储结构中，有多少个指针域未利用?  
答:二叉树的二叉链表存储结构中，假如有n个结点, 则共有2n个指针域(定义的)
已经使用的有n-1个指针域，所以有2n - (n - 1) = n+1个指针域未利用.
为什么是n - 1?(因为减去了一个根结点, 根结点是没有被指向的, 有n个结点除了根结点, 孩子结点就是n-1个)

4.层序遍历 

设二叉树的根结点所在层数为1，层序遍历就是从所在二叉树的根结点出发，首先访问第一层的树根结点，然后从左到右访问第2层上的结点，接着是第三层的结点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。  

总结:
学习二叉树结构，最简单的方式就是遍历。所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题(比如：打印节点内容、节点内容加1)。
遍历是二叉树上最重要的操作之一，是二叉树上进行其它运算之基础。 

在遍历二叉树时，如果没有进行某种约定，每个人都按照自己的方式遍历，得出的结果就比较混乱，如果按照某种规则进行约定，则每个人对于同一棵树的遍历结果肯定是相同的。

如果D代表根结点，L代表根结点的左子树，R代表根结点的右子树，则根据遍历根结点的先后次序有以下遍历方式：

  • DLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点--->根的左子树--->根的右子树。
  • LDR：中序遍历(Inorder Traversal)——根的左子树--->根节点--->根的右子树。
  • LRD：后序遍历(Postorder Traversal)——根的左子树--->根的右子树--->根结点。  

分析前序递归遍历，中序与后序图解类似  

前序遍历结果：1 2 3 4 5 6
中序遍历结果：3 2 1 5 4 6
后序遍历结果：3 2 5 6 4 1  

练习题二

1.某完全二叉树按层次输出（同一层从左到右）的序列为 ABCDEFGH 。该完全二叉树的前序序列为()
A: ABDHECFG B: ABCDEFGH C: HDBEAFCG D: HDEBFGCA

2.二叉树的先序遍历和中序遍历如下：先序遍历：EFHIGJK;中序遍历：HFIEJKG.则二叉树根结点为()
A: E B: F C: G D: H

3.设一课二叉树的中序遍历序列：badce，后序遍历序列：bdeca，则二叉树前序遍历序列为()
A: adbce B: decab C: debac D: abcde

4.某二叉树的后序遍历序列与中序遍历序列相同，均为 ABCDEF ，则按层次输出(同一层从左到右)的序列为()
A: FEDCBA B: CBAFED C: DEFCBA D: ABCDEF  

递归实现-先序中序后序遍历

我们先基于以下二叉树结构来实现：

public class TestBinaryTree {static class TreeNode {public char val;//数据域public TreeNode left;//左孩子的引用public TreeNode right;//右孩子的引用public TreeNode(char val) {this.val = val;}}//public TreeNode root;//二叉树的根结点public TreeNode createTree() {TreeNode A = new TreeNode('A');TreeNode B = new TreeNode('B');TreeNode C = new TreeNode('C');TreeNode D = new TreeNode('D');TreeNode E = new TreeNode('E');TreeNode F = new TreeNode('F');TreeNode G = new TreeNode('G');TreeNode H = new TreeNode('H');A.left = B;A.right = C;B.left = D;B.right = E;C.left = F;C.right = G;E.right = H;//this.root = A;return A;}// 前序遍历void preOrder(TreeNode root) {if (root == null) {return;}System.out.print(root.val + " ");preOrder(root.left);preOrder(root.right);}// 中序遍历void inOrder(TreeNode root) {if (root == null) {return;}inOrder(root.left);System.out.print(root.val + " ");inOrder(root.right);}// 后序遍历void postOrder(TreeNode root) {if (root == null) {return;}postOrder(root.left);postOrder(root.right);System.out.print(root.val + " ");}
}
public class Test {public static void main(String[] args) {TestBinaryTree testBinaryTree = new TestBinaryTree();TestBinaryTree.TreeNode root = testBinaryTree.createTree();testBinaryTree.preOrder(root);System.out.println();testBinaryTree.inOrder(root);System.out.println();testBinaryTree.postOrder(root);}
}

非递归实现-先序中序后序遍历:

此次我们对二叉树结构做了微调：

先序图解

中序图解 

后序图解 

 (直接修改创建二叉的代码) 

public TreeNode createTree2() {TreeNode A = new TreeNode('A');TreeNode B = new TreeNode('B');TreeNode C = new TreeNode('C');TreeNode D = new TreeNode('D');TreeNode E = new TreeNode('E');TreeNode F = new TreeNode('F');TreeNode G = new TreeNode('G');TreeNode H = new TreeNode('H');A.left = B;A.right = C;B.left = D;B.right = E;C.left = F;C.right = G;//E.right = H;//this.root = A;return A;}//非递归实现前序遍历:public void preOrderNor(TreeNode root) {if (root == null) {return;}TreeNode cur = root;Deque<TreeNode> stack = new ArrayDeque<>();while (cur != null || !stack.isEmpty()) {//如果cur == null && stack == null 说明已经遍历完了.while (cur != null) {stack.push(cur);System.out.print(cur.val + " ");cur = cur.left;}//左边为空, 弹出栈顶的元素TreeNode top = stack.pop();cur = top.right;/*如果右边为空, 最外层的while循环也进入不了,但是如果此时栈内还有元素, 也可以进入最外层while循环, 但是不能进入最内层while循环然后弹出栈顶的元素*///如果右边不为空, 循环也可以进入, 将新的元素压栈}}//非递归实现中序遍历:public void inOrderNor(TreeNode root) {if (root == null) {return;}TreeNode cur = root;Deque<TreeNode> stack = new ArrayDeque<>();while (cur != null || !stack.isEmpty()) {//如果cur == null && stack == null 说明已经遍历完了.while (cur != null) {stack.push(cur);cur = cur.left;}//左边为空, 弹出栈顶的元素TreeNode top = stack.pop();System.out.print(top.val + " ");cur = top.right;/*如果右边为空, 最外层的while循环也进入不了,但是如果此时栈内还有元素, 也可以进入最外层while循环, 但是不能进入最内层while循环然后弹出栈顶的元素*///如果右边不为空, 循环也可以进入, 将新的元素压栈}}//非递归实现后序遍历:public void postOrderNor(TreeNode root) {if (root == null) {return;}TreeNode cur = root;TreeNode prev = null;//这个引用用来记录已经打印过的节点Deque<TreeNode> stack = new ArrayDeque<>();while (cur != null || !stack.isEmpty()) {//如果cur == null && stack == null 说明已经遍历完了.while (cur != null) {stack.push(cur);cur = cur.left;}//左边为空, 查看栈顶的元素TreeNode top = stack.peek();if (top.right == null || top.right == prev) {//如果栈顶元素的右边为空或者栈顶元素的右边已经打印过--->直接打印 + 弹出这个栈顶元素，不需要要再往后遍历不然会重复打印，顺便记录刚刚这个栈顶元素也被打印过了，下次也不要打印它了System.out.print(top.val + " ");stack.pop();prev = top;} else {cur = top.right;}/*如果右边为空, 最外层的while循环也进入不了,但是如果此时栈内还有元素, 也可以进入最外层while循环, 但是不能进入最内层while循环然后查看栈顶的元素, 再判断.*///如果右边不为空, 循环也可以进入, 将新的元素压栈}}
public static void main(String[] args) {TestBinaryTree testBinaryTree = new TestBinaryTree();TestBinaryTree.TreeNode root = testBinaryTree.createTree2();testBinaryTree.preOrderNor(root);System.out.println();testBinaryTree.inOrderNor(root);System.out.println();testBinaryTree.postOrderNor(root);}

接下来我们用以下二叉树结构进行其它操作

获取树中结点的个数 

    // 获取树中结点的个数// 时间复杂度:O(N)// 空间复杂度:O(logN)满二叉树的情况, 相当于树的高度 ~ O(N)单分支树的情况.int size(TreeNode root) {//子问题思路(左子树结点 + 右子树结点 + 1) 建议写法!if (root == null) {return 0;}int leftSize = size(root.left);int rightSize = size(root.right);return leftSize + rightSize + 1;}public static int nodeSize;//注意这儿有问题, 在OJ上如果有两个树对象测试结点个数, 那么会测试出来的结点个数相同, 因为它们共用nodeSize了.public void size2(TreeNode root) {//遍历思路(遇到结点就 + 1)if (root == null) {return;}nodeSize++;size2(root.left);size2(root.right);}
public class Test {public static void main(String[] args) {TestBinaryTree testBinaryTree = new TestBinaryTree();TestBinaryTree.TreeNode root = testBinaryTree.createTree();System.out.println("(size1方法)结点个数: " + testBinaryTree.size(root));//8testBinaryTree.size2(root);int nodeSize = TestBinaryTree.nodeSize;System.out.println("(size2方法)结点个数: " + nodeSize);//8System.out.println("----------------");TestBinaryTree testBinaryTree2 = new TestBinaryTree();TestBinaryTree.TreeNode root2 = testBinaryTree2.createTree();System.out.println("(size1方法)结点个数: " + testBinaryTree.size(root));//8testBinaryTree.size2(root);int nodeSize2 = TestBinaryTree.nodeSize;System.out.println("(size2方法)结点个数: " + nodeSize2);//16, 结果有问题, 是因为nodeSize是静态变量, 新建一棵树对象会共用nodeSize, 所以遍历出来的结点个数有问题.}
}

获取叶子结点(度为0的结点)的个数 

    // 获取叶子结点的个数// 子问题:左子树的叶子结点 + 右子树的叶子结点int getLeafNodeCount(TreeNode root) {if (root == null) {return 0;}if (root.left == null && root.right == null) {//遇到叶子结点了.return 1;}int leftSize = getLeafNodeCount(root.left);int rightSize = getLeafNodeCount(root.right);return leftSize + rightSize;}public int leafSize;// 遍历思路:遇到叶子结点就 + 1public void getLeafNodeCount2(TreeNode root) {if (root == null) {return;}if (root.left == null && root.right == null) {//遇到叶子结点了.leafSize++;}getLeafNodeCount2(root.left);getLeafNodeCount2(root.right);}
public class Test {public static void main(String[] args) {TestBinaryTree testBinaryTree = new TestBinaryTree();TestBinaryTree.TreeNode root = testBinaryTree.createTree();System.out.println("叶子结点的个数: " + testBinaryTree.getLeafNodeCount(root));testBinaryTree.getLeafNodeCount2(root);System.out.println("叶子结点的个数: " + testBinaryTree.leafSize);}
}

获取第K层结点的个数 

    // 获取第K层结点的个数int getKLevelNodeCount(TreeNode root, int k) {if (root == null) {return 0;}if (k == 1) {return 1;}int leftSize = getKLevelNodeCount(root.left, k - 1);int rightSize = getKLevelNodeCount(root.right, k - 1);return leftSize + rightSize;}
public class Test {public static void main(String[] args) {TestBinaryTree testBinaryTree = new TestBinaryTree();TestBinaryTree.TreeNode root = testBinaryTree.createTree();System.out.println("第k层的结点个数: " + testBinaryTree.getKLevelNodeCount(root, 3));}
}

获取二叉树的高度 

    // 获取二叉树的高度// 时间复杂度O(N), 因为每一个结点都会被访问// 空间复杂度O(树的高度)public int getHeight(TreeNode root) {if (root == null) {return 0;}int leftHeight = getHeight(root.left);int rightHeight = getHeight(root.right);return (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;}
public class Test {public static void main(String[] args) {TestBinaryTree testBinaryTree = new TestBinaryTree();TestBinaryTree.TreeNode root = testBinaryTree.createTree();System.out.println("树的高度: " + testBinaryTree.getHeight(root));}
}

检测值为value的元素是否存在

    // 检测值为value的元素是否存在public TreeNode find(TreeNode root, int val) {if (root == null) {return null;}if (root.val == val) {return root;}TreeNode leftTree = find(root.left, val);if (leftTree != null) {//左子树找return leftTree;}TreeNode rightTree = find(root.right, val);if (rightTree != null) {//右子树找return rightTree;}return null;//都没找到}
public class Test {public static void main(String[] args) {TestBinaryTree testBinaryTree = new TestBinaryTree();TestBinaryTree.TreeNode root = testBinaryTree.createTree();TestBinaryTree.TreeNode E = testBinaryTree.find(root, 'E');if (E != null){System.out.println("查找到了E元素, 且E的值为: " + E.val);} else {System.out.println("没有此元素!");}TestBinaryTree.TreeNode J = testBinaryTree.find(root, 'J');if (J != null){System.out.println("查找到了J元素, 且J的值为: " + J.val);} else {System.out.println("没有此元素!");}}
}

层序遍历 

    //层序遍历(不带返回值)public void levelOrder(TreeNode root) {if (root == null) {return;}Queue<TreeNode> queue = new LinkedList<>();//先将头结点入队queue.offer(root);while (!queue.isEmpty()) {//队列不为空//出队的同时用cur记录出队的结点, 同时打印出队结点的valueTreeNode cur = queue.poll();System.out.print(cur.val + " ");//如果cur的左子树和右子树有结点就入队if (cur.left != null) {queue.offer(cur.left);}if (cur.right != null) {queue.offer(cur.right);}}}

public class Test {public static void main(String[] args) {TestBinaryTree testBinaryTree = new TestBinaryTree();TestBinaryTree.TreeNode root = testBinaryTree.createTree();testBinaryTree.levelOrder(root);}
}

 

判断一棵树是不是完全二叉树 

boolean isCompleteTree(TreeNode root){if (root == null) {return true;}Queue<TreeNode> queue = new LinkedList<>();queue.offer(root);while (!queue.isEmpty()) {TreeNode cur = queue.poll();if (cur != null) {queue.offer(cur.left);queue.offer(cur.right);} else {break;}}//走到这儿说明cur == nullwhile (!queue.isEmpty()) {TreeNode tmp = queue.poll();if (tmp != null) {//队列里剩余的元素不全是null, 说明不是完全二叉树return false;}}return true;}

OJ练习题 

1. 检查两颗树是否相同。

/*** 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 {//检查两棵树是否相同//时间复杂度和空间复杂度: O(min(m, n)) m 和 n是结点的个数//如果一颗树的结点多 一颗树的结点少 必然是不相等的, 所以只需要遍历完结点少的树就行了, 不需要去遍历剩下的结点.//如果两个树的结点一样, min(m, n) 结果都一样, 大不了最坏情况就O(n)public boolean isSameTree(TreeNode p, TreeNode q) {if (p == null && q != null || p != null && q == null) {return false;}//走到这里 要么都是空 要么都不是空if (p == null && q == null) {//都是空return true;}if (p.val != q.val) {//都不是空, 在判断值是否相等return false;}//p q都不是空, 且值一样, 当前只是判断了根结点是否相同, 所以下面还要进行递归判断左子树和右子树是否一样.return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);}
}

2.另一颗树的子树。

/*** 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 {//时间复杂度:O(S * T) 对于S上的每一个点都需要做一次深度优先搜索来和T匹配, 匹配一次的时间复杂度是O(T)//空间复杂度:O(max(ds, dt)), ds 和 dt分别代表两棵树的深度public boolean isSubtree(TreeNode root, TreeNode subRoot) {if (root == null) {return false;}if (isSameTree(root, subRoot)) {return true;}if (isSubtree(root.left, subRoot)) {return true;}if (isSubtree(root.right, subRoot)) {return true;}return false;}//检查两棵树是否相同//时间复杂度和空间复杂度: O(min(m, n)) m 和 n是结点的个数//如果一颗树的结点多 一颗树的结点少 必然是不相等的, 所以只需要遍历完结点少的树就行了, 不需要去遍历剩下的结点.//如果两个树的结点一样, min(m, n) 结果都一样, 大不了最坏情况就O(n)public boolean isSameTree(TreeNode p, TreeNode q) {if (p == null && q != null || p != null && q == null) {return false;}//走到这里 要么都是空 要么都不是空if (p == null && q == null) {//都是空return true;}if (p.val != q.val) {//都不是空, 在判断值是否相等return false;}//p q都不是空, 且值一样, 当前只是判断了根结点是否相同, 所以下面还要进行递归判断左子树和右子树是否一样.return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);}
}

3. 翻转二叉树。

/*** 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 TreeNode invertTree(TreeNode root) {if (root == null) {return null;}//方法1:利用临时结点来存储要交换的结点值
//        TreeNode tmpNode = root.left;
//        root.left = root.right;
//        root.right = tmpNode;
//        //递归进行翻转
//        invertTree(root.left);
//        invertTree(root.right);//方法2:利用返回值TreeNode left = invertTree(root.left);TreeNode right = invertTree(root.right);//翻转root.left = right;root.right = left;return root;}
}

4. 判断一颗二叉树是否是平衡二叉树。 

/*** 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 boolean isBalanced1(TreeNode root) {if (root == null) {return true;}int leftHeight = getHeight(root.left);int rightHeight = getHeight(root.right);return Math.abs(leftHeight - rightHeight) < 2&& isBalanced1(root.left)&& isBalanced1(root.right);}// 获取二叉树的高度// 时间复杂度O(N), 因为每一个结点都会被访问// 空间复杂度O(树的高度)public int getHeight(TreeNode root) {if (root == null) {return 0;}int leftHeight = getHeight(root.left);int rightHeight = getHeight(root.right);return (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;}//时间复杂度O(N)public boolean isBalanced(TreeNode root) {//看返回的是否为正数, 如果是负数说明不平衡return getHeight2(root) >= 0;}// public int getHeight2(TreeNode root) {//     if (root == null) {//         return 0;//     }//     int leftHeight = getHeight2(root.left);//     int rightHeight = getHeight2(root.right);//     if (leftHeight >= 0 && rightHeight >= 0 &&//             Math.abs(leftHeight - rightHeight) <= 1) {//         //return (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;//         return Math.max(leftHeight, rightHeight) + 1;//     } else {//左子树和右子树的高度差超过了2//         return -1;//     }// }public int getHeight2(TreeNode root) {if (root == null) {return 0;}int leftHeight = getHeight2(root.left);if (leftHeight < 0) {return -1;}int rightHeight = getHeight2(root.right);if (rightHeight < 0) {return -1;}if (Math.abs(leftHeight - rightHeight) <= 1) {//return (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;return Math.max(leftHeight, rightHeight) + 1;} else {//左子树和右子树的高度差超过了2return -1;}}
}

5. 对称二叉树。 

/*** 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 boolean isSymmetric(TreeNode root) {if (root == null) {return true;}return isSymmetricChild(root.left, root.right);}public boolean isSymmetricChild(TreeNode leftTree, TreeNode rightTree) {if (leftTree != null && rightTree == null || leftTree == null && rightTree != null) {return false;}if (leftTree == null && rightTree == null) {return true;}//走到这里说明左子树和右子树都不为空, 就需要先判断值是否一样if (leftTree.val != rightTree.val) {return false;}//走到这里说明左子树和右子树不为空, 且值一样//再判断左子树的左子树和右子树的右子树是否相等, 左子树的右子树和右子树的左子树是否相等.return isSymmetricChild(leftTree.left, rightTree.right) && isSymmetricChild(leftTree.right, rightTree.left);}
}

6. 二叉树的构建及遍历。 

import java.util.Scanner;
class TreeNode {public char val;public TreeNode left;public TreeNode right;public TreeNode(char val) {this.val = val;}
}
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {public static void main(String[] args) {Scanner in = new Scanner(System.in);// 注意 hasNext 和 hasNextLine 的区别while (in.hasNextLine()) { // 注意 while 处理多个 caseString str = in.nextLine();TreeNode root = createTree(str);inOrder(root);}}public static int i = 0;//每次递归i的值要发生变化, 所以定义在递归函数的外面public static TreeNode createTree(String str) {TreeNode root = null;if (str.charAt(i) != '#') {//按照根 左 右依次创建结点root  = new TreeNode(str.charAt(i));i++;root.left = createTree(str);root.right = createTree(str);} else {i++;}return root;}public static void inOrder(TreeNode root) {if (root == null) {return;}inOrder(root.left);System.out.print(root.val + " ");inOrder(root.right);}
}

7. 二叉树的层序遍历 。 

/*** 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>> levelOrder(TreeNode root) {List<List<Integer>> list = new ArrayList<>();if(root == null) {return list;}Queue<TreeNode> queue = new LinkedList<>();queue.offer(root);while (!queue.isEmpty()) {//队列不为空, 记录当前的结点个数size(相当于每一层的结点), 然后出队size个结点, 然后添加到集合.int size = queue.size();List<Integer> tmp = new ArrayList<>();while (size != 0) {//出队size个结点TreeNode cur = queue.poll();tmp.add(cur.val);size--;if (cur.left != null) {queue.offer(cur.left);}if (cur.right != null) {queue.offer(cur.right);}}list.add(tmp);}return list;}
}

8. 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先 。

/*** Definition for a binary tree node.* public class TreeNode {*     int val;*     TreeNode left;*     TreeNode right;*     TreeNode(int x) { val = x; }* }*/
class Solution {//方法1:// public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {//     if (root == null) {//         return null;//     }//     //先判断根结点是不是其中的一个//     if (root == p || root == q) {//         return root;//     }//     //去左子树和右子树找是否有p, q//     TreeNode leftRet = lowestCommonAncestor(root.left, p, q);//     TreeNode rightRet = lowestCommonAncestor(root.right, p, q);//     if (leftRet != null && rightRet != null) {//左子树和右子树都找到了p和q//         return root;//     } else if (leftRet != null) {//左子树找到的第一个p或者q, 就是公共祖先//         return leftRet;//     } else if (rightRet != null) {//右子树找到的第一个p或者q, 就是公共祖先//         return rightRet;//     }//     //左子树和右子树都没有找到//     return null;// }//方法2:// 找到根节点到指定节点node路径上的所有的节点, 存放到栈中.public boolean getPath(TreeNode root, TreeNode node, Deque<TreeNode> stack) {if (root == null || node == null) {return false;}stack.push(root);//放完之后 要检查if (root == node) {return true;}boolean ret1 = getPath(root.left, node, stack);if (ret1) {//ret1 == truereturn true;}boolean ret2 = getPath(root.right, node, stack);if (ret2) {//ret2 == truereturn true;}stack.pop();return false;}public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {//1.两个栈当中 存储好数据Deque<TreeNode> stack1 = new ArrayDeque<>();getPath(root, p, stack1);Deque<TreeNode> stack2 = new ArrayDeque<>();getPath(root, q, stack2);//2.判断栈的大小int size1 = stack1.size();int size2 = stack2.size();//哪个栈的元素多, 就要先出栈多出来的元素if (size1 > size2) {int size = size1 - size2;while (size != 0) {stack1.pop();size--;}} else {int size = size2 - size1;while (size != 0) {stack2.pop();size--;}}//通过上述操作--->栈里面的元素个数是一样的.while (!stack1.isEmpty() && !stack2.isEmpty()) {if (stack1.peek() != stack2.peek()) {stack1.pop();stack2.pop();} else {return stack1.peek();}}return null;}
}

9. 根据一棵树的前序遍历与中序遍历构造二叉树。

/*** 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 int i = 0;public TreeNode buildTree(int[] preorder, int[] inorder) {return buildTreeChild(preorder, inorder, 0, inorder.length - 1);}//建立子树(每次先序遍历确定根的时候, 从中序遍历找位置确定根的左右子树)public TreeNode buildTreeChild(int[] preorder, int[] inorder, int inbegin, int inend) {if (inbegin > inend) {//说明没有子树了.return null;}TreeNode root = new TreeNode(preorder[i]);//每次放入先序遍历的节点//找到当前根, 然后根据中序遍历去确定此节点的位置int rootIndex = findIndex(inorder, inbegin, inend, preorder[i]);i++;//加完之后, 下次找的就不是根节点了.root.left = buildTreeChild(preorder, inorder, inbegin, rootIndex - 1);root.right = buildTreeChild(preorder, inorder, rootIndex + 1, inend);return root;}//根据中序遍历, 确定根的位置private int findIndex(int[] inorder, int inbegin, int inend, int key){for (int i = inbegin; i <= inend; i++) {if (inorder[i] == key) {return i;}}return -1;}
}

10. 根据一棵树的中序遍历与后序遍历构造二叉树。 

/*** 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 int i = 0;public TreeNode buildTree(int[] inorder, int[] postorder) {i = postorder.length - 1;//从后往前找.return buildTreeChild(inorder, postorder, 0, inorder.length - 1);}//建立子树(每次后序遍历确定根的时候, 从中序遍历找位置确定根的左右子树)public TreeNode buildTreeChild(int[] inorder, int[] postorder, int inbegin, int inend) {if (inbegin > inend) {//说明没有子树了.return null;}TreeNode root = new TreeNode(postorder[i]);//每次放入后序遍历的节点//找到当前根, 然后根据中序遍历去确定此节点的位置int rootIndex = findIndex(inorder, inbegin, inend, postorder[i]);i--;//减完之后, 下次找的就不是根节点了.//注意:这儿要先建立右树, 因为后序遍历是左 右 根.root.right = buildTreeChild(inorder, postorder, rootIndex + 1, inend);root.left = buildTreeChild(inorder, postorder, inbegin, rootIndex - 1);return root;}//根据中序遍历, 确定根的位置private int findIndex(int[] inorder, int inbegin, int inend, int key) {for (int i = inbegin; i <= inend; i++) {if (inorder[i] == key) {return i;}}return -1;}
}

11. 二叉树创建字符串。

/*** 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 String tree2str(TreeNode root) {if (root == null) {return null;}StringBuilder stringBuilder = new StringBuilder();tree2strChild(root, stringBuilder);return stringBuilder.toString();}public void tree2strChild(TreeNode t, StringBuilder stringBuilder) {if (t == null) {return;}stringBuilder.append(t.val);//把根节点先加入if (t.left != null) {//左边不为空stringBuilder.append("(");tree2strChild(t.left, stringBuilder);//递归左边stringBuilder.append(")");} else {//左边为空if (t.right != null) {//右边不为空stringBuilder.append("()");} else {//右边为空return;}}if (t.right == null) {//右边为空return;} else {//右边不为空stringBuilder.append("(");tree2strChild(t.right, stringBuilder);//递归右边stringBuilder.append(")");}}
}

12. 二叉树前序非递归遍历实现 。 

/*** 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 {//递归的写法:/*//不好的写法: 没利用返回值 (遍历思路, 遇到一个打印一个)List<Integer> ret = new ArrayList<>();public List<Integer> preorderTraversal(TreeNode root) {//List<Integer> ret = new ArrayList<>();//这句话不能放在这儿, 因为每次递归ret都是新的值.所以要把ret提到函数外面if(root == null) {return ret;}//System.out.print(root.val+" ");ret.add(root.val);preorderTraversal(root.left);preorderTraversal(root.right);return ret;}*//*//将就的写法:public List<Integer> preorderTraversal(TreeNode root) {List<Integer> ret = new ArrayList<>();//这儿放到函数内是因为递归调用的不是本身的函数,不会让ret每次是新的值, 而是另一个函数func.func(root,ret);return ret;}public void func(TreeNode root,List<Integer> ret) {//递归的函数if(root == null) {return;}//System.out.print(root.val+" ");ret.add(root.val);func(root.left,ret);func(root.right,ret);}*///子问题思路// public List<Integer> preorderTraversal(TreeNode root) {//     List<Integer> ret = new ArrayList<>();//如果非要写在这儿, 将每次递归的返回值, 加到ret中//     if (root == null) {//         return ret;//     }//     ret.add(root.val);//     List<Integer> leftTree = preorderTraversal(root.left);//     ret.addAll(leftTree);//addAll(Collection<? extends E> c), 尾插c中的元素, 传入的参数是实现了collection接口且泛型类型<=Integer//     List<Integer> rightTree = preorderTraversal(root.right);//     ret.addAll(rightTree);//     return ret;// }//非递归的写法:public List<Integer> preorderTraversal(TreeNode root) {List<Integer> ret = new ArrayList<>();if (root == null) {return ret;}TreeNode cur = root;Deque<TreeNode> stack = new ArrayDeque<>();while (cur != null || !stack.isEmpty()) {//如果cur == null && stack == null 说明已经遍历完了.while (cur != null) {stack.push(cur);//System.out.print(cur.val + " ");ret.add(cur.val);cur = cur.left;}//左边为空, 弹出栈顶的元素TreeNode top = stack.pop();cur = top.right;/*如果右边为空, 最外层的while循环也进入不了,但是如果此时栈内还有元素, 也可以进入最外层while循环, 但是不能进入最内层while循环然后弹出栈顶的元素*///如果右边不为空, 循环也可以进入, 将新的元素压栈}return ret;}
}

13. 二叉树中序非递归遍历实现。 

/*** 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<Integer> inorderTraversal(TreeNode root) {//     List<Integer> ret = new ArrayList<>();//如果非要写在这儿, 将每次递归的返回值, 加到ret中//     if (root == null) {//         return ret;//     }//     List<Integer> leftTree = inorderTraversal(root.left);//     ret.addAll(leftTree);//addAll(Collection<? extends E> c), 尾插c中的元素, 传入的参数是实现了collection接口且泛型类型<=Integer//     ret.add(root.val);//     List<Integer> rightTree = inorderTraversal(root.right);//     ret.addAll(rightTree);//     return ret;// }//非递归写法:public List<Integer> inorderTraversal(TreeNode root) {List<Integer> ret = new ArrayList<>();if (root == null) {return ret;}TreeNode cur = root;Deque<TreeNode> stack = new ArrayDeque<>();while (cur != null || !stack.isEmpty()) {//如果cur == null && stack == null 说明已经遍历完了.while (cur != null) {stack.push(cur);cur = cur.left;}//左边为空, 弹出栈顶的元素TreeNode top = stack.pop();//System.out.print(cur.val + " ");ret.add(top.val);cur = top.right;/*如果右边为空, 最外层的while循环也进入不了,但是如果此时栈内还有元素, 也可以进入最外层while循环, 但是不能进入最内层while循环然后弹出栈顶的元素*///如果右边不为空, 循环也可以进入, 将新的元素压栈}return ret;}
}

14. 二叉树后序非递归遍历实现。 

/*** 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<Integer> postorderTraversal(TreeNode root) {//     List<Integer> ret = new ArrayList<>();//如果非要写在这儿, 将每次递归的返回值, 加到ret中//     if (root == null) {//         return ret;//     }//     List<Integer> leftTree = postorderTraversal(root.left);//     ret.addAll(leftTree);//addAll(Collection<? extends E> c), 尾插c中的元素, 传入的参数是实现了collection接口且泛型类型<=Integer//     List<Integer> rightTree = postorderTraversal(root.right);//     ret.addAll(rightTree);//     ret.add(root.val);//     return ret;// }//非递归实现:public List<Integer> postorderTraversal(TreeNode root) {List<Integer> ret = new ArrayList<>();if (root == null) {return ret;}TreeNode cur = root;TreeNode prev = null;//这个引用用来记录已经打印过的节点Deque<TreeNode> stack = new ArrayDeque<>();while (cur != null || !stack.isEmpty()) {//如果cur == null && stack == null 说明已经遍历完了.while (cur != null) {stack.push(cur);cur = cur.left;}//左边为空, 查看栈顶的元素TreeNode top = stack.peek();if (top.right == null || top.right == prev) {//如果栈顶元素的右边为空或者栈顶元素的右边已经打印过--->打印 + 弹出栈顶元素//System.out.print(top.val + " ");ret.add(top.val);stack.pop();prev = top;} else {cur = top.right;}//如果右边为空, 最外层的while循环也进入不了,//但是如果此时栈内还有元素, 也可以进入最外层while循环, 但是不能进入最内层while循环//然后查看栈顶的元素, 再判断.//如果右边不为空, 循环也可以进入, 将新的元素压栈}return ret;}
}

15.二叉树的深度。 

/*** 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 int maxDepth(TreeNode root) {if (root == null) {return 0;}int leftHeight = maxDepth(root.left);int rightHeight = maxDepth(root.right);return (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;   }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/171717.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

交换技术-电路交换-报文交换-分组交换

交换技术-电路交换-报文交换-分组交换

交换技术是指主机之间、通信设备之间或主机与通信设备之间为交换信息所采用的数据格式和交换装置的方式。按交换技术可分为&#xff1a;电路交换、报文交换和分组交换。 电路交换 交换(switching)&#xff0c;就是按照某种方式动态地分配传输线路的资源。 电路交换是在源结点…
阅读更多...
解决Vscode使用git提交卡住的问题

解决Vscode使用git提交卡住的问题

使用Vscode的git提交代码经常会很慢/卡住。 先点击左下角&#xff0c;进入设置 找到git的配置(建议直接搜索)&#xff0c;把use Editor As commit input的勾选去掉即可解决。
阅读更多...
【批量修改文件名，并去掉括号】

【批量修改文件名，并去掉括号】

操作 一、 批量修改文件名操作二、去除括号 一、 批量修改文件名操作 在浏览器等下载很多图片后&#xff0c;命名顺序乱七八糟&#xff0c;想要将图片进行重新命名&#xff0c;从数字1开始 首先&#xff0c;全选文件夹中的图片 右键&#xff0c;重明明&#xff0c;选择一张图…
阅读更多...
【c++文件】

【c++文件】

C是一种面向对象的编程语言&#xff0c;它广泛应用于各个领域&#xff0c;如游戏开发、嵌入式系统、操作系统等。在C编程中&#xff0c;文件操作是一项非常重要的技能。本文将介绍C文件操作的基本知识以及一些有趣的应用&#xff0c;带领大家一起探索C文件操作的魅力。 一、C文…
阅读更多...
jQuery_08 each函数的使用

jQuery_08 each函数的使用

each函数的使用 可以循环数组&#xff0c;json&#xff0c;dom对象数组 1.$.each(要循环的内容,function(index,element){处理函数}) 要循环的内容可以是数组&#xff0c;json对象&#xff0c;dom数组 function&#xff1a;循环的处理函数 每个成员都会执行这个函数一次 index&…
阅读更多...
kafka,RabbitMQ,RocketMQ,他们之间的区别，架构，如何保证消息的不丢失，保证不重复消费，保证消息的有序性

kafka,RabbitMQ,RocketMQ,他们之间的区别，架构，如何保证消息的不丢失，保证不重复消费，保证消息的有序性

文章目录 Kafka、RabbitMQ、RocketMQ 之间的区别是什么&#xff1f;性能数据可靠性服务可用性功能 RabbitMQ如何保证消息不丢失&#xff1f;Kafka 的架构说一下&#xff1f;Kafka 怎么保证消息是有序的&#xff1f;Kafka 怎么解决重复消费&#xff1f;Kafka 怎么保证消息不丢失…
阅读更多...
最新Midjourney绘画提示词Prompt教程无需魔法

最新Midjourney绘画提示词Prompt教程无需魔法

最新Midjourney绘画提示词Prompt教程无需魔法使用 一、AI绘画工具 SparkAi【无需魔法使用】&#xff1a; SparkAi是目前国内一款的ChatGPT对接OpenAI软件系统。那么如何搭建部署AI创作ChatGPT&#xff1f;小编这里写一个详细图文教程吧&#xff01;本系统使用NestjsVueTypes…
阅读更多...
C#，《小白学程序》第二十课：大数的加法（BigInteger Add）

C#，《小白学程序》第二十课：大数的加法（BigInteger Add）

大数的&#xff08;加减乘除&#xff09;四则运算、阶乘运算。 乘法计算包括小学生算法、Karatsuba和Toom-Cook3算法。 重复了部分 19 课的代码。 1 文本格式 using System; using System.Linq; using System.Text; using System.Collections.Generic; /// <summary>…
阅读更多...
如何在Ubuntu系统上安装MongoDB

如何在Ubuntu系统上安装MongoDB

简单介绍 MongoDB是由C语言编写的&#xff0c;是一个基于分布式文件存储的开源数据库系统。在高负载的情况下&#xff0c;添加更多的节点&#xff0c;可以保证服务器性能。MongoDB旨在为WEB应用提供可扩展的高性能数据存储解决方案。MongoDB将数据存储为一个文档&#xff0c;数…
阅读更多...
Centos Bind安装与排错

Centos Bind安装与排错

1.配置Centos系统静态IP vi/etc/sysconfig/network-scripts/ifcfg-ens33BOOTPROTOstaticIPADDR192.168.1.100NETMASK255.255.255.0GATEWAY192.168.1.1DNS18.8.8.8:wqsudo systemctl restart network.service 2.安装BIND&#xff08;需要服务器连接互联网&#xff0c;如果服务…
阅读更多...
肾合胶囊 | 冬不养肾春易病，若出现了这六大表现，小心是肾虚！

肾合胶囊 | 冬不养肾春易病，若出现了这六大表现，小心是肾虚！

冬季作为一年中最寒冷的季节&#xff0c;自然万物皆静谧闭藏&#xff0c;而肾具有潜藏、封藏、闭藏精气的特点&#xff0c;是封藏之本&#xff0c;肾的脏腑特性与冬季相通应&#xff0c;所以在冬季更应该重视养肾。 而现在正值初冬&#xff0c;正是开始养肾的最佳时间。此时培…
阅读更多...
VBA技术资料MF86：将PPT文件批量另存为PDF文件

VBA技术资料MF86：将PPT文件批量另存为PDF文件

我给VBA的定义&#xff1a;VBA是个人小型自动化处理的有效工具。利用好了&#xff0c;可以大大提高自己的工作效率&#xff0c;而且可以提高数据的准确度。我的教程一共九套&#xff0c;分为初级、中级、高级三大部分。是对VBA的系统讲解&#xff0c;从简单的入门&#xff0c;到…
阅读更多...
单例模式与多线程

单例模式与多线程

目录 前言 正文 1.立即加载/饿汉模式 2.延迟加载/懒汉模式 1.延迟加载/懒汉模式解析 2.延迟加载/懒汉模式的缺点 3.延迟加载/懒汉模式的解决方案 &#xff08;1&#xff09;声明 synchronized 关键字 &#xff08;2&#xff09;尝试同步代码块 &#xff08;3&am…
阅读更多...
图形编辑器开发：缩放和旋转控制点

图形编辑器开发：缩放和旋转控制点

大家好&#xff0c;我是前端西瓜哥。好久没写图形编辑器开发的文章了。 今天来讲讲控制点。它是图形编辑器的不可缺少的基础功能。 控制点是吸附在图形上的一些小矩形和圆形点击区域&#xff0c;在控制点上拖拽鼠标&#xff0c;能够实时对被选中进行属性的更新。 比如使用旋…
阅读更多...
数据库基础教程之数据库的创建（一）

数据库基础教程之数据库的创建（一）

双击打开Navicat&#xff0c;点击&#xff1a;文件-》新建连接-》PostgreSQL 在下图新建连接中输入各参数&#xff0c;然后点击&#xff1a;连接测试&#xff0c;连接成功后再点击确定。 点击新建数据库 数据库设置如下&#xff1a;
阅读更多...
[pyqt5]pyqt5设置窗口背景图片后上面所有图片都会变成和背景图片一样

[pyqt5]pyqt5设置窗口背景图片后上面所有图片都会变成和背景图片一样

pyqt5的控件所有都是集成widget&#xff0c;窗体设置背景图片后控件背景也会跟着改变&#xff0c;此时有2个办法。第一个办法显然我们可以换成其他方式设置窗口背景图片&#xff0c;而不是使用styleSheet样式表&#xff0c;网上有很多其他方法。还有个办法就是仍然用styleSheet…
阅读更多...
如何申请永久免费的SSL证书

如何申请永久免费的SSL证书

首先&#xff0c;让我们了解什么是SSL证书。 SSL&#xff08;Secure Socket Layer&#xff09;证书是一种数字证书&#xff0c;它提供了一种在互联网上安全地传输数据的方法。 这是一个必须的安全工具&#xff0c;可以加密您的网站和客户之间的所有信息。为了保护用户数据和确保…
阅读更多...
Unity 引擎宣布：自 2024 年起，开发者需支付费用！

Unity 引擎宣布：自 2024 年起，开发者需支付费用！

Unity引擎宣布的新的收费模式&#xff0c;从2024年1月1日开始&#xff0c;根据游戏的安装量来对开发者进行收费。具体来说&#xff0c;每次游戏被下载时&#xff0c;UnityRuntime也会被安装&#xff0c;因此可能会产生额外的费用。对于开发者来说&#xff0c;需要注意以下几点&…
阅读更多...
Spring Cloud Gateway 的简单介绍和基本使用

Spring Cloud Gateway 的简单介绍和基本使用

前言 本文主要对Spring Cloud Gateway进行简单的概念介绍&#xff0c;并通过多模块编程的方式进行一个简单的实操。 文章目录 前言1 什么是网关&#xff08;概念&#xff09;2 微服务中的网关2.1 问题12.2 问题2 3 网关作用4 Spring Cloud Gateway组成5 Spring Cloud Gateway基…
阅读更多...
tidyverse数据特征学习

tidyverse数据特征学习

目录 特征缩放 1&#xff0c;标准化-scale 2&#xff0c;归一化-rescale 3&#xff0c;行规范化 4&#xff0c;数据平滑 特征变换 1. 非线性特征 2. 正态性变换 3. 连续变量离散 特征降维 特征缩放 不同数值型特征的数据量纲可能相差多个数量级&#xff0c;这对很多…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023