线索化二叉树（先序，中序，后序）+线索化二叉树的遍历【java详解】

目录

线索化二叉树的基本介绍：

 举个栗子：

二叉树的中序线索化：

创建HeroNode类，表示节点信息：

编写中序线索化方法代码：

中序线索化遍历代码：

测试代码：

测试结果：

 二叉树的先序线索化：

编写先序线索化代码：

 先序线索化遍历代码：

测试结果：

二叉树前序和中序线索化完整代码：

二叉树的后续线索化：

定义一个PostTreadBinaryTree 来表示节点信息：

编写createBinaryTree方法来实现二叉树的创建：

编写后续线索化方法代码： 

后序线索化遍历：

代码详解：

 测试代码：

测试结果：

最后，后序线索化的详细代码，有需要可以自己查看：

小结：

写在之前：在学习线索化二叉树之前，要对二叉树的前中后序遍历有一定的了解，如果还不会的小伙伴可以看看我的这篇博客：二叉树-------前,中,后序遍历 + 前，中，后序查找+删除节点 （java详解）-CSDN博客

由于网上以及书上对线索化二叉树的前序和后序及其遍历介绍的较少，这里统一整理了一下，希望对各位有所帮助。欢迎点赞加关注支持博主~

------------------------------------------------------------------------------------------------------------------------------- 

线索化二叉树的基本介绍：

  • n个结点的二叉链表中含有n+1  【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）
  • 这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种
  • 一个结点的前一个结点，称为前驱结点
  • 一个结点的后一个结点，称为后继结点

 举个栗子：

将一颗普通的二叉树如下图所示（它是一个含有6个节点的二叉树，按照上述公式计算其空指针域为7【n+1】）：

中序线索化后，得到如图所示的二叉树（中序线索化后）：

 这实际上是一个将二叉树的指针域充分利用的过程（即充分利用各个节点的左右指针），那么，上述的过程究竟是如何实现的呢？看到这里，你想必还是一脸懵圈，别急，然我们再举个栗子（以中序线索化为例）：

我们先将上述数字转化为一个数组，当然这个数组不是随便写的，是通过中序遍历得到的，这个数组是：8,3,10,1,14,6  ，接着我们只需要结合原图，将左右指针为空的节点进行连线，具体如下：

说明：数字8左右指针都为空，理应联两条线，但根据其中序遍历的结果，它的左边为空，所以上述图中数字8只连了一根线，对应到3节点。同理数字10连两根线对应3,1；数字14连2根线，对应1，6；6连一根线，对应空（null），实际在图中表示为不连线---》连线的根数是根据节点的左右指针个数决定的，如数字8，节点左右指针为空，连两条线（对应左右指针的方向），而数字6右指针为空，所以连一条线

实际线索化后的二叉树（通常null省略罢了 ）：

 通过上面的一些描述，想必你对二叉树的线索化有了一定理解，那么我们接着开始进入正题：

二叉树的中序线索化：

说明：当线索化二叉树后，Node节点的属性left和right有如下情况：

1).left指向的是左子树，也可能是指向前驱节点，比如①节点left指向左子树，二⑩节点的left指向的就是前驱节点

2）.right指向的是右子树，也可能是指向后继节点，比如①节点right指向左=右子树，二⑩节点的right指向的就是后继节点

同时，为了方便表示线索后的二叉树，我们这样定义：
1. 如果leftType == 0 表示指向的是左子树, 如果 1 则表示指向前驱结点
2. 如果rightType == 0 表示指向是右子树, 如果 1表示指向后继结点

创建HeroNode类，表示节点信息：

//先创建HeroNode 结点class HeroNode {private int no;private String name;private HeroNode left; //默认nullprivate HeroNode right; //默认null//说明//1. 如果leftType == 0 表示指向的是左子树, 如果 1 则表示指向前驱结点//2. 如果rightType == 0 表示指向是右子树, 如果 1表示指向后继结点private int leftType;private int rightType;public int getLeftType() {return leftType;}public void setLeftType(int leftType) {this.leftType = leftType;}public int getRightType() {return rightType;}public void setRightType(int rightType) {this.rightType = rightType;}public HeroNode(int no, String name) {this.no = no;this.name = name;}public int getNo() {return no;}public void setNo(int no) {this.no = no;}public String getName() {return name;}public void setName(String name) {this.name = name;}public HeroNode getLeft() {return left;}public void setLeft(HeroNode left) {this.left = left;}public HeroNode getRight() {return right;}public void setRight(HeroNode right) {this.right = right;}@Overridepublic String toString() {return "HeroNode [no=" + no + ", name=" + name + "]";}}*/

通过上面的中序线索化构造的栗子，我们可以按照先

(一)先线索化左子树---》(二)线索化当前结点---》(三)在线索化右子树

编写中序线索化方法代码：

public void threadedNodes(HeroNode node) {//如果node==null, 不能线索化if (node == null) {return;}//(一)先线索化左子树threadedNodes(node.getLeft());//(二)线索化当前结点//处理当前结点的前驱结点//以8结点来理解//8结点的.left = null , 8结点的.leftType = 1if (node.getLeft() == null) {//让当前结点的左指针指向前驱结点node.setLeft(pre);//修改当前结点的左指针的类型,指向前驱结点node.setLeftType(1);}//处理后继结点if (pre != null && pre.getRight() == null) {//让前驱结点的右指针指向当前结点pre.setRight(node);//修改前驱结点的右指针类型pre.setRightType(1);}//!!! 每处理一个结点后，让当前结点是下一个结点的前驱结点pre = node;//(三)在线索化右子树threadedNodes(node.getRight());}

中序线索化遍历代码：

/遍历线索化二叉树的方法public void threadedList() {//定义一个变量，存储当前遍历的结点，从root开始HeroNode node = root;while (node != null) {//循环的找到leftType == 1的结点，第一个找到就是8结点//后面随着遍历而变化,因为当leftType==1时，说明该结点是按照线索化//处理后的有效结点while (node.getLeftType() == 0) {node = node.getLeft();}//打印当前这个结点System.out.println(node);//如果当前结点的右指针指向的是后继结点,就一直输出while (node.getRightType() == 1) {//获取到当前结点的后继结点node = node.getRight();System.out.println(node);}//替换这个遍历的结点node = node.getRight();}}

测试代码：

public class ThreadedBinaryTreeDemo {public static void main(String[] args) {//测试一把中序线索二叉树的功能HeroNode root = new HeroNode(1, "tom");HeroNode node2 = new HeroNode(3, "jack");HeroNode node3 = new HeroNode(6, "smith");HeroNode node4 = new HeroNode(8, "mary");HeroNode node5 = new HeroNode(10, "king");HeroNode node6 = new HeroNode(14, "dim");HeroNode node7 = new HeroNode(1, "xiao");//二叉树，后面我们要递归创建, 现在简单处理使用手动创建root.setLeft(node2);root.setRight(node3);node2.setLeft(node4);node2.setRight(node5);node3.setLeft(node6);//测试中序线索化ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();threadedBinaryTree.setRoot(root);threadedBinaryTree.threadedNodes();//测试: 以10号节点测试HeroNode leftNode = node5.getLeft();HeroNode rightNode = node5.getRight();System.out.println("10号结点的前驱结点是 ="  + leftNode); //3System.out.println("10号结点的后继结点是="  + rightNode); //1//当线索化二叉树后，能在使用原来的遍历方法//threadedBinaryTree.infixOrder();System.out.println("使用线索化的方式遍历 线索化二叉树");threadedBinaryTree.threadedList(); // 8, 3, 10, 1, 14, 6}
}

 

接着我们测试一下就以节点⑩为例（如上图），线索化后其前驱节点为③，其后继节点为①

同时，遍历的结果与中序遍历保持一致，即 8,3,10,1,14,6

测试结果：

 二叉树的先序线索化：

按照中序线索化的方法，我给出线索化的图解：

 

 

HeroNode类与上面基本一致，不做过多说明

按照  线索化当前节点---》线索化左子树---》线索化右子树  过程进行

编写先序线索化代码：

  //前序线索化public void pretreadedNodes(HeroNode node){if(node == null){return ;}if(node.getLeft() == null){node.setLeft(pre);node.setLeftType(1);}if(pre != null && pre.getRight() == null){pre.setRight(node);pre.setRightType(1);}pre = node;if(node.getLeftType() == 0) {pretreadedNodes(node.getLeft());}if(node.getRightType() == 0) {pretreadedNodes(node.getRight());}}

 先序线索化遍历代码：

//遍历前序线索化二叉树public void pretreadedList(){HeroNode node = root;while(node != null){while(node.getLeftType() == 0){System.out.println(node);node = node.getLeft();}System.out.println(node);while(node.getRightType() == 1){node = node.getRight();System.out.println(node);}node = node.getRight();}}

 

接着我们测试一下就以节点⑩为例（如上图），线索化后其前驱节点为⑧，其后继节点为⑥

同时，先序线索化遍历的结果与先序遍历保持一致

测试结果：

二叉树前序和中序线索化完整代码：

//测试
public class ThreadedBinaryTreeDemo {public static void main(String[] args){HeroNode root = new HeroNode(1, "tom");HeroNode node2 = new HeroNode(3, "jack");HeroNode node3 = new HeroNode(6, "smith");HeroNode node4 = new HeroNode(8, "mary");HeroNode node5 = new HeroNode(10, "king");HeroNode node6 = new HeroNode(14, "dim");root.setLeft(node2);root.setRight(node3);node2.setLeft(node4);node2.setRight(node5);node3.setLeft(node6);TreadedBinaryTree treadedBinaryTree = new TreadedBinaryTree(root);//treadedBinaryTree.intreadedNodes();treadedBinaryTree.pretreadedNodes();HeroNode leftNode = node5.getLeft();HeroNode rightNode = node5.getRight();System.out.println("10号节点的前驱节点是："+leftNode);System.out.println("10号节点的后继节点是："+rightNode);System.out.println("使用线索化二叉树的遍历：");treadedBinaryTree.pretreadedList();//treadedBinaryTree.intreadedList();}
}class TreadedBinaryTree{private HeroNode root;private HeroNode pre = null;public TreadedBinaryTree(HeroNode root) {this.root = root;}public void posttreadedNodes(){this.posttreadedNodes(root);}public void intreadedNodes(){this.intreadedNodes(root);}public void pretreadedNodes(){this.pretreadedNodes(root);}//遍历中序线索化二叉树public void intreadedList(){HeroNode node =root;while(node != null){while(node.getLeftType() == 0){node = node.getLeft();}System.out.println(node);while(node.getRightType() == 1){node = node.getRight();System.out.println(node);}node = node.getRight();}}//遍历前序线索化二叉树public void pretreadedList(){HeroNode node = root;while(node != null){while(node.getLeftType() == 0){System.out.println(node);node = node.getLeft();}System.out.println(node);while(node.getRightType() == 1){node = node.getRight();System.out.println(node);}node = node.getRight();}}//中序线索化public void intreadedNodes(HeroNode node){if(node == null){return ;}intreadedNodes(node.getLeft());if(node.getLeft() == null){node.setLeft(pre);node.setLeftType(1);}if(pre != null && pre.getRight() == null){pre.setRight(node);pre.setRightType(1);}pre = node;intreadedNodes(node.getRight());}//前序线索化public void pretreadedNodes(HeroNode node){if(node == null){return ;}if(node.getLeft() == null){node.setLeft(pre);node.setLeftType(1);}if(pre != null && pre.getRight() == null){pre.setRight(node);pre.setRightType(1);}pre = node;if(node.getLeftType() == 0) {pretreadedNodes(node.getLeft());}if(node.getRightType() == 0) {pretreadedNodes(node.getRight());}}//后续线索化二叉树public void posttreadedNodes(HeroNode node){if(node == null){return ;}posttreadedNodes(node.getLeft());posttreadedNodes(node.getRight());if(node.getLeft() == null){node.setLeft(pre);node.setLeftType(1);}if(pre != null && pre.getRight() == null){pre.setRight(node);pre.setRightType(1);}pre = node;}}class HeroNode{private int no;private String name;private HeroNode left;//默认nullprivate HeroNode right;//默认null//说明//1. 如果leftType == 0 表示指向的是左子树, 如果 1 则表示指向前驱结点//2. 如果rightType == 0 表示指向是右子树, 如果 1表示指向后继结点private int leftType;private int rightType;public HeroNode() {}public HeroNode(int no, String name) {this.no = no;this.name = name;}/*** 获取* @return no*/public int getNo() {return no;}/*** 设置* @param no*/public void setNo(int no) {this.no = no;}/*** 获取* @return name*/public String getName() {return name;}/*** 设置* @param name*/public void setName(String name) {this.name = name;}/*** 获取* @return left*/public HeroNode getLeft() {return left;}/*** 设置* @param left*/public void setLeft(HeroNode left) {this.left = left;}/*** 获取* @return right*/public HeroNode getRight() {return right;}/*** 设置* @param right*/public void setRight(HeroNode right) {this.right = right;}/*** 获取* @return leftType*/public int getLeftType() {return leftType;}/*** 设置* @param leftType*/public void setLeftType(int leftType) {this.leftType = leftType;}/*** 获取* @return rightType*/public int getRightType() {return rightType;}/*** 设置* @param rightType*/public void setRightType(int rightType) {this.rightType = rightType;}public String toString() {return "HeroNode{no = " + no + ", name = " + name + "}";}
}

二叉树的后续线索化：

（后序相对前序与中序复杂，单独拎出来讲---》主要是遍历过程复杂）

按照上述中序线索化的过程，我给出后续线索化的图解：

 

定义一个PostTreadBinaryTree 来表示节点信息：

public class PostTreadBinaryTree {private Node preNode;   //线索化时记录前一个节点//节点存储结构static class Node {String data;        //数据域Node left;          //左指针域Node right;         //右指针域Node parent;        //父节点的指针（为了后序线索化使用）boolean isLeftThread = false;   //左指针域类型  false：指向子节点、true：前驱或后继线索boolean isRightThread = false;  //右指针域类型  false：指向子节点、true：前驱或后继线索Node(String data) {this.data = data;}}

编写createBinaryTree方法来实现二叉树的创建：

 static Node createBinaryTree(String[] array, int index) {Node node = null;if(index < array.length) {node = new Node(array[index]);node.left = createBinaryTree(array, index * 2 + 1);node.right = createBinaryTree(array, index * 2 + 2);//记录节点的父节点（后序线索化遍历时使用）if(node.left != null) {node.left.parent = node;}if(node.right != null) {node.right.parent = node;}}return node;}

编写后续线索化方法代码： 

void postThreadOrder(Node node) {if(node == null) {return;}//处理左子树postThreadOrder(node.left);//处理右子树postThreadOrder(node.right);//左指针为空,将左指针指向前驱节点if(node.left == null) {node.left = preNode;node.isLeftThread = true;}//前一个节点的后继节点指向当前节点if(preNode != null && preNode.right == null) {preNode.right = node;preNode.isRightThread = true;}preNode = node;}

后序线索化遍历：

后序遍历线索化二叉树是一种对二叉树进行线索化的方法，使得在遍历二叉树时可以更高效地找到前驱和后继节点。下面是后序遍历线索化二叉树的思路：

  1. 首先，定义一个辅助指针pre，用于记录当前节点的前驱节点。
  2. 对于二叉树的每个节点，按照后序遍历的顺序进行处理。
  3. 如果当前节点的左子树不为空，就将当前节点的左子树线索化。具体步骤如下：
    • 找到当前节点的左子树的最右节点，即左子树中最后一个被访问的节点。
    • 将该最右节点的右指针指向当前节点，并将其线索化标记设置为1，表示指向后继节点。
  4. 如果当前节点的右子树不为空，就将当前节点的右子树线索化。具体步骤如下：
    • 找到当前节点的右子树的最左节点，即右子树中第一个被访问的节点。
    • 将该最左节点的左指针指向当前节点，并将其线索化标记设置为1，表示指向前驱节点。
  5. 更新pre指针为当前节点，以便在下一次迭代时使用。
  6. 重复步骤2-5，直到遍历完整个二叉树。

这样，通过后序遍历线索化二叉树，我们可以在不使用递归或栈的情况下，高效地找到任意节点的前驱和后继节点。

代码详解：

 void postThreadList(Node root) {//1、找后序遍历方式开始的节点Node node = root;while(node != null && !node.isLeftThread) {node = node.left;}Node preNode = null;while(node != null) {//右节点是线索if(node.isRightThread) {System.out.print(node.data + ", ");preNode = node;node = node.right;} else {//如果上个处理的节点是当前节点的右节点if(node.right == preNode) {System.out.print(node.data + ", ");if(node == root) {return;}preNode = node;node = node.parent;} else {    //如果从左节点的进入则找到有子树的最左节点node = node.right;while(node != null && !node.isLeftThread) {node = node.left;}}}}}

 测试代码：

 public static void main(String[] args) {String[] array = {"1","3","6","8","10","14"};Node root = createBinaryTree(array, 0);PostTreadBinaryTree tree = new PostTreadBinaryTree();tree.postThreadOrder(root);System.out.println("后序按后继节点遍历线索二叉树结果：");tree.postThreadList(root);}

该测试结果（遍历测试结果）与后序遍历的结果 一致

测试结果：

最后，后序线索化的详细代码，有需要可以自己查看：

//后序线索化
public class PostTreadBinaryTree {private Node preNode;   //线索化时记录前一个节点//节点存储结构static class Node {String data;        //数据域Node left;          //左指针域Node right;         //右指针域Node parent;        //父节点的指针（为了后序线索化使用）boolean isLeftThread = false;   //左指针域类型  false：指向子节点、true：前驱或后继线索boolean isRightThread = false;  //右指针域类型  false：指向子节点、true：前驱或后继线索Node(String data) {this.data = data;}}/*** 通过数组构造一个二叉树（完全二叉树）* @param array* @param index* @return*/static Node createBinaryTree(String[] array, int index) {Node node = null;if(index < array.length) {node = new Node(array[index]);node.left = createBinaryTree(array, index * 2 + 1);node.right = createBinaryTree(array, index * 2 + 2);//记录节点的父节点（后序线索化遍历时使用）if(node.left != null) {node.left.parent = node;}if(node.right != null) {node.right.parent = node;}}return node;}/*** 后序线索化二叉树* @param node  节点*/void postThreadOrder(Node node) {if(node == null) {return;}//处理左子树postThreadOrder(node.left);//处理右子树postThreadOrder(node.right);//左指针为空,将左指针指向前驱节点if(node.left == null) {node.left = preNode;node.isLeftThread = true;}//前一个节点的后继节点指向当前节点if(preNode != null && preNode.right == null) {preNode.right = node;preNode.isRightThread = true;}preNode = node;}/*** 后续遍历线索二叉树，按照后继方式遍历（思路：后序遍历开始节点是最左节点）* @param*/void postThreadList(Node root) {//1、找后序遍历方式开始的节点Node node = root;while(node != null && !node.isLeftThread) {node = node.left;}Node preNode = null;while(node != null) {//右节点是线索if(node.isRightThread) {System.out.print(node.data + ", ");preNode = node;node = node.right;} else {//如果上个处理的节点是当前节点的右节点if(node.right == preNode) {System.out.print(node.data + ", ");if(node == root) {return;}preNode = node;node = node.parent;} else {    //如果从左节点的进入则找到有子树的最左节点node = node.right;while(node != null && !node.isLeftThread) {node = node.left;}}}}}public static void main(String[] args) {String[] array = {"1","3","6","8","10","14"};Node root = createBinaryTree(array, 0);PostTreadBinaryTree tree = new PostTreadBinaryTree();tree.postThreadOrder(root);System.out.println("后序按后继节点遍历线索二叉树结果：");tree.postThreadList(root);}
}

小结：

1. 前序线索化二叉树遍历相对最容易理解，实现起来也比较简单。由于前序遍历的顺序是：根左右，所以从根节点开始，沿着左子树进行处理，当子节点的left指针类型是线索时，说明到了最左子节点，然后处理子节点的right指针指向的节点，可能是右子树，也可能是后继节点，无论是哪种类型继续按照上面的方式（先沿着左子树处理，找到子树的最左子节点，然后处理right指针指向），以此类推，直到节点的right指针为空，说明是最后一个，遍历完成。 
2. 中序线索化二叉树的网上相关介绍最多。中序遍历的顺序是：左根右，因此第一个节点一定是最左子节点，先找到最左子节点，依次沿着right指针指向进行处理（无论是指向子节点还是指向后继节点），直到节点的right指针为空，说明是最后一个，遍历完成。 
3. 后序遍历线索化二叉树最为复杂，通用的二叉树数节点存储结构不能够满足后序线索化，因此我们扩展了节点的数据结构，增加了父节点的指针。后序的遍历顺序是：左右根，先找到最左子节点，沿着right后继指针处理，当right不是后继指针时，并且上一个处理节点是当前节点的右节点，则处理当前节点的右子树，遍历终止条件是：当前节点是root节点，并且上一个处理的节点是root的right节点。

小结转载自：后序线索化二叉树（Java版）_线索二叉树的后序遍历-CSDN博客
 

博客到这里也是结束了，制作不易，喜欢的小伙伴可以点赞加关注支持下博主，这对我真的很重要~~

 

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

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

相关文章

OpenCV库及在ROS中使用

OpenCV库及在ROS中使用

OpenCV库及在ROS中使用 依赖 cv_bridge image_transport roscpp rospy sensor_msgs std_msgsCMakeLists.txt添加 find_package(OpenCV REQUIRED) include_directories(${OpenCV_INCLUDE_DIRS}) target_link_libraries(pub_img_topic ${catkin_LIBRARIES} ${Opencv_LIBS}) C …
阅读更多...
视觉设计师的项目评审复盘攻略：如何提升设计质量与效率

视觉设计师的项目评审复盘攻略：如何提升设计质量与效率

视觉设计师的角色是至关重要的&#xff0c;以确保设计项目满足预期的质量和结果。作为一名视觉设计师&#xff0c;有必要进行定期的项目审查&#xff0c;以确保项目在正轨上进行&#xff0c;并尽早解决任何问题。在本文中我们将讨论可视化设计人员如何做好项目评审&#xff0c;…
阅读更多...
每日五道java面试题之java基础篇（十）

每日五道java面试题之java基础篇（十）

目录: 第一题 JVM有哪些垃圾回收器&#xff1f;第二题 垃圾回收分为哪些阶段&#xff1f;第三题 线程的⽣命周期&#xff1f;线程有⼏种状态&#xff1f;第四题.ThreadLocal的底层原理第五题.并发、并⾏、串⾏之间的区别 第一题 JVM有哪些垃圾回收器&#xff1f; ● 新⽣代收集…
阅读更多...
.NET Core WebAPI中使用Log4net 日志级别分类并记录到数据库

.NET Core WebAPI中使用Log4net 日志级别分类并记录到数据库

一、效果 记录日志为文档 记录日志到数据库 二、添加NuGet包 三、log4net.config代码配置 <?xml version"1.0" encoding"utf-8" ?> <log4net><!-- Debug日志 --><appender name"RollingFileDebug" type"log4net…
阅读更多...
51_蓝桥杯_蜂鸣器与继电器

51_蓝桥杯_蜂鸣器与继电器

一 电路 二 蜂鸣器与继电器工作原理 2.1蜂鸣器与继电器 2.2 十六进制与二进制 二进制 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111 十六进制 0 1 2 3 4 5 6 7 8 9 A B C D E F 2.3非门 二 代码 …
阅读更多...
Nginx （window）2024版 笔记 下载 安装 配置

Nginx （window）2024版 笔记 下载 安装 配置

前言 Nginx (engine x) 是一款轻量级的 Web 服务器 、反向代理&#xff08;Reverse Proxy&#xff09;服务器及电子邮件&#xff08;IMAP/POP3&#xff09;代理服务器。 反向代理方式是指以代理服务器来接受 internet 上的连接请求&#xff0c;然后将请求转发给内部网络上的服…
阅读更多...
反转链表【基础算法精讲 06】

反转链表【基础算法精讲 06】

视频地址 反转链表【基础算法精讲 06】_哔哩哔哩_bilibili 概念 链表的每一个结点都包含节点值 和1指向下一个结点的next指针 , 链表的最后一个结点指向空; 206 . 反转链表 用cur记录当前遍历到的结点 &#xff0c; 用pre表示下一个结点 &#xff0c; 用nxt表示cur的下一个…
阅读更多...
点亮代码之灯，程序员的夜与电脑

点亮代码之灯，程序员的夜与电脑

在科技的海洋里&#xff0c;程序员是那些驾驶着代码船只&#xff0c;穿梭于虚拟世界的探险家。他们手中的键盘是航行的舵&#xff0c;而那台始终不愿关闭的电脑&#xff0c;便是他们眼中永不熄灭的灯塔。有人说&#xff0c;程序员不喜欢关电脑&#xff0c;这究竟是为什么呢&…
阅读更多...
Slider滑动输入条（antd-design组件库）简单使用

Slider滑动输入条（antd-design组件库）简单使用

1.Slider滑动输入条 滑动型输入器&#xff0c;展示当前值和可选范围。 2.何时使用 当用户需要在数值区间/自定义区间内进行选择时&#xff0c;可为连续或离散值。 组件代码来自&#xff1a; 滑动输入条 Slider - Ant Design 3.本地验证前的准备 参考文章【react项目antd组件-de…
阅读更多...
第18讲 投票帖子管理实现

第18讲 投票帖子管理实现

后端&#xff1a; /*** 删除指定id的投票信息* param id* return*/ GetMapping("/delete/{id}") Transactional public R delete(PathVariable(value "id")Integer id){voteDetailService.remove(new QueryWrapper<VoteDetail>().eq("vote_id…
阅读更多...
反向迭代器------封装的力量

反向迭代器------封装的力量

目录 一、list封装中模板参数Ref和Ptr的理解 二、反向迭代器的实现 一、list封装中模板参数Ref和Ptr的理解 对于反向迭代器&#xff0c;是我们在前面STL模拟实现中留下的一个问题。在之前的文章中&#xff0c;我们极大程度上的利用了模板&#xff0c;从而减少了许多的代码&…
阅读更多...
代码随想录算法训练营DAY19 | 二叉树 (6)

代码随想录算法训练营DAY19 | 二叉树 (6)

一、LeetCode 654 最大二叉树 题目链接&#xff1a;654.最大二叉树https://leetcode.cn/problems/maximum-binary-tree/ 思路&#xff1a;坚持左开右闭原则&#xff0c;递归划分数组元素生成左右子树。 class Solution {public TreeNode constructMaximumBinaryTree(int[] num…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023