文章目录
1.实现二叉树的先序、中序、后序遍历，包括递归方式和非递归 方式
更多图借鉴：二叉树的 先序遍历、中序遍历、后序遍历
public class Code_01_PreInPosTraversal {
public static class Node {
public int value;
public Node left;
public Node right;
public Node(int data) {
this.value = data;
}
}
//以下的三个方法属于递归版本的
public static void preOrderRecur(Node head) {
if (head == null) {
return;
}
System.out.print(head.value + " ");
preOrderRecur(head.left);
preOrderRecur(head.right);
}
public static void inOrderRecur(Node head) {
if (head == null) {
return;
}
inOrderRecur(head.left);
System.out.print(head.value + " ");
inOrderRecur(head.right);
}
public static void posOrderRecur(Node head) {
if (head == null) {
return;
}
posOrderRecur(head.left);
posOrderRecur(head.right);
System.out.print(head.value + " ");
}
public static void preOrderUnRecur(Node head) {//先序遍历，使用栈完成先前递归的功能
System.out.print("pre-order: ");
if (head != null) {//当加入的树不为空才执行操作
Stack<Node> stack = new Stack<Node>();
stack.add(head);//将头节点先压入栈
while (!stack.isEmpty()) {//当栈中不为空的，就继续这个循环
head = stack.pop();//获得栈中最顶的那个元素
System.out.print(head.value + " ");//打印最顶上元素的值
if (head.right != null) {//当节点右孩子不为空的时候就先压入右孩子（右边的就可以后压出）
stack.push(head.right);
}
if (head.left != null) {
stack.push(head.left);
}
}
}
System.out.println();
}
/**
*当前节点为空，从栈中拿一个打印，不为空，当压入栈的时候向右移动
**/
public static void inOrderUnRecur(Node head) {//中序遍历的非递归版本
System.out.print("in-order: ");
if (head != null) {
Stack<Node> stack = new Stack<Node>();
while (!stack.isEmpty() || head != null) {
if (head != null) {//一直地将左边的压入栈中先
stack.push(head);
head = head.left;
} else {
head = stack.pop();
System.out.print(head.value + " ");//在右边释放的时候打印
head = head.right;
}
}
}
System.out.println();
}
public static void posOrderUnRecur1(Node head) {//后序打印，压入栈中的顺序为：左右中
System.out.print("pos-order: ");
if (head != null) {
Stack<Node> s1 = new Stack<Node>();
Stack<Node> s2 = new Stack<Node>();
s1.push(head);
while (!s1.isEmpty()) {//将左边节点的最底下的元素都打印先
head = s1.pop();
s2.push(head);//用2栈记录最底下的元素，最先放入来的最后打印
if (head.left != null) {
s1.push(head.left);
}
if (head.right != null) {
s1.push(head.right);
}
}
while (!s2.isEmpty()) {
System.out.print(s2.pop().value + " ");
}
}
System.out.println();
}
public static void posOrderUnRecur2(Node h) {//后序遍历的第二种写法，只需要一个栈来完成，难度大点
System.out.print("pos-order: ");
if (h != null) {
Stack<Node> stack = new Stack<Node>();
stack.push(h);
Node c = null;
while (!stack.isEmpty()) {
c = stack.peek();
if (c.left != null && h != c.left && h != c.right) {
stack.push(c.left);
} else if (c.right != null && h != c.right) {
stack.push(c.right);
} else {
System.out.print(stack.pop().value + " ");
h = c;
}
}
}
System.out.println();
}
public static void main(String[] args) {
Node head = new Node(5);
head.left = new Node(3);
head.right = new Node(8);
head.left.left = new Node(2);
head.left.right = new Node(4);
head.left.left.left = new Node(1);
head.right.left = new Node(7);
head.right.left.left = new Node(6);
head.right.right = new Node(10);
head.right.right.left = new Node(9);
head.right.right.right = new Node(11);
// recursive
System.out.println("==============recursive==============");
System.out.print("pre-order: ");
preOrderRecur(head);
System.out.println();
System.out.print("in-order: ");
inOrderRecur(head);
System.out.println();
System.out.print("pos-order: ");
posOrderRecur(head);
System.out.println();
// unrecursive
System.out.println("============unrecursive=============");
preOrderUnRecur(head);
inOrderUnRecur(head);
posOrderUnRecur1(head);
posOrderUnRecur2(head);
}
}
上边代码实现的真正的心路历程如下图的有图所示:
2.实现直观地打印一颗二叉树
public static class Node {
public int value;
public Node left;
public Node right;
public Node(int data) {
this.value = data;
}
}
public static void printTree(Node head) {
System.out.println("Binary Tree:");
printInOrder(head, 0, "H", 17);
System.out.println();
}
public static void printInOrder(Node head, int height, String to, int len) {
if (head == null) {
return;
}
printInOrder(head.right, height + 1, "v", len);
String val = to + head.value + to;
int lenM = val.length();
int lenL = (len - lenM) / 2;
int lenR = len - lenM - lenL;
val = getSpace(lenL) + val + getSpace(lenR);
System.out.println(getSpace(height * len) + val);
printInOrder(head.left, height + 1, "^", len);
}
public static String getSpace(int num) {
String space = " ";
StringBuffer buf = new StringBuffer("");
for (int i = 0; i < num; i++) {
buf.append(space);
}
return buf.toString();
}
public static void main(String[] args) {
Node head = new Node(1);
head.left = new Node(-222222222);
head.right = new Node(3);
head.left.left = new Node(Integer.MIN_VALUE);
head.right.left = new Node(55555555);
head.right.right = new Node(66);
head.left.left.right = new Node(777);
printTree(head);
head = new Node(1);
head.left = new Node(2);
head.right = new Node(3);
head.left.left = new Node(4);
head.right.left = new Node(5);
head.right.right = new Node(6);
head.left.left.right = new Node(7);
printTree(head);
head = new Node(1);
head.left = new Node(1);
head.right = new Node(1);
head.left.left = new Node(1);
head.right.left = new Node(1);
head.right.right = new Node(1);
head.left.left.right = new Node(1);
printTree(head);
}
打印效果：（从左往右看）
3.在二叉树中找到一个节点的后继节点
【题目】 现在有一种新的二叉树节点类型如下：
public class Node {
public int value;
public Node left;
public Node right;
public Node parent;
public Node(int data) {
this.value = data;
}
}
该结构比普通二叉树节点结构多了一个指向父节点的parent指针。假 设有一 棵Node类型的节点组成的二叉树，树中每个节点的parent指针 都正确地指向 自己的父节点，头节点的parent指向null。只给一个在 二叉树中的某个节点 node，请实现返回node的后继节点的函数。在二叉树的中序遍历的序列中， node的下一个节点叫作node的后继节点。一个节点X如果有右子树，那么他的后继节点一定是整颗右子树最左的节点。如果节点X没有右子树，就需要寻找X的父节点，并且如果父节点还有个父父节点，并且父节点不是父父节点的左子树，就继续寻找上一个父节点，直到寻找到父节点是父父节点的左子树的节点才停下来，那个就是X得后继节点了.,如下图所示，1的后继结点是6,6的后继节点是3…
public class Code_03_SuccessorNode {
public static class Node {
public int value;
public Node left;
public Node right;
public Node parent;
public Node(int data) {
this.value = data;
}
}
public static Node getSuccessorNode(Node node) {//寻找后继节点
if (node == null) {
return node;
}
if (node.right != null) {//当当前节点的右孩子不为空的时候，就直接寻找该右子树最左的节点
return getLeftMost(node.right);
} else {//没有右子树进入下边的这个逻辑
Node parent = node.parent;//寻找父节点
while (parent != null && parent.left != node) {//当父父节点的左子节点不是父节点的时候都继续循环，最右节点没有后继节点，所以需要添加一个parent != null的判断
node = parent;
parent = node.parent;
}
return parent;
}
}
public static Node getLeftMost(Node node) {//寻找右子树中的最左的节点
if (node == null) {//如果传入的节点为空，那么他就是那个后继节点了
return node;
}
while (node.left != null) {//寻找最左的节点
node = node.left;
}
return node;
}
public static void main(String[] args) {
Node head = new Node(6);
head.parent = null;
head.left = new Node(3);
head.left.parent = head;
head.left.left = new Node(1);
head.left.left.parent = head.left;
head.left.left.right = new Node(2);
head.left.left.right.parent = head.left.left;
head.left.right = new Node(4);
head.left.right.parent = head.left;
head.left.right.right = new Node(5);
head.left.right.right.parent = head.left.right;
head.right = new Node(9);
head.right.parent = head;
head.right.left = new Node(8);
head.right.left.parent = head.right;
head.right.left.left = new Node(7);
head.right.left.left.parent = head.right.left;
head.right.right = new Node(10);
head.right.right.parent = head.right;
Node test = head.left.left;
System.out.println(test.value + " next: " + getSuccessorNode(test).value);
test = head.left.left.right;
System.out.println(test.value + " next: " + getSuccessorNode(test).value);
test = head.left;
System.out.println(test.value + " next: " + getSuccessorNode(test).value);
test = head.left.right;
System.out.println(test.value + " next: " + getSuccessorNode(test).value);
test = head.left.right.right;
System.out.println(test.value + " next: " + getSuccessorNode(test).value);
test = head;
System.out.println(test.value + " next: " + getSuccessorNode(test).value);
test = head.right.left.left;
System.out.println(test.value + " next: " + getSuccessorNode(test).value);
test = head.right.left;
System.out.println(test.value + " next: " + getSuccessorNode(test).value);
test = head.right;
System.out.println(test.value + " next: " + getSuccessorNode(test).value);
test = head.right.right; // 10's next is null
System.out.println(test.value + " next: " + getSuccessorNode(test));
}
}
寻找前驱节点：看学习笔记—寻找二叉树的前驱节点和后继节点
4.介绍二叉树的序列化和反序列化
序列化就是持久化，存储在硬盘中的意思。反序列化就是从硬盘中读取数据出来。
按先序遍历的方式来序列化，简图理解：
按层序列化：
两种方式序列化的代码：
public class Code_04_SerializeAndReconstructTree {
public static class Node {
public int value;
public Node left;
public Node right;
public Node(int data) {
this.value = data;
}
}
public static String serialByPre(Node head) {
if (head == null) {
return "#!";
}
String res = head.value + "!";
res += serialByPre(head.left);
res += serialByPre(head.right);
return res;
}
public static Node reconByPreString(String preStr) {
String[] values = preStr.split("!");
Queue<String> queue = new LinkedList<String>();
for (int i = 0; i != values.length; i++) {
queue.offer(values[i]);
}
return reconPreOrder(queue);
}
public static Node reconPreOrder(Queue<String> queue) {
String value = queue.poll();
if (value.equals("#")) {
return null;
}
Node head = new Node(Integer.valueOf(value));
head.left = reconPreOrder(queue);
head.right = reconPreOrder(queue);
return head;
}
public static String serialByLevel(Node head) {
if (head == null) {
return "#!";
}
String res = head.value + "!";
Queue<Node> queue = new LinkedList<Node>();
queue.offer(head);
while (!queue.isEmpty()) {
head = queue.poll();
if (head.left != null) {
res += head.left.value + "!";
queue.offer(head.left);
} else {
res += "#!";
}
if (head.right != null) {
res += head.right.value + "!";
queue.offer(head.right);
} else {
res += "#!";
}
}
return res;
}
public static Node reconByLevelString(String levelStr) {
String[] values = levelStr.split("!");
int index = 0;
Node head = generateNodeByString(values[index++]);
Queue<Node> queue = new LinkedList<Node>();
if (head != null) {
queue.offer(head);
}
Node node = null;
while (!queue.isEmpty()) {
node = queue.poll();
node.left = generateNodeByString(values[index++]);
node.right = generateNodeByString(values[index++]);
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
return head;
}
public static Node generateNodeByString(String val) {
if (val.equals("#")) {
return null;
}
return new Node(Integer.valueOf(val));
}
// for test -- print tree
public static void printTree(Node head) {
System.out.println("Binary Tree:");
printInOrder(head, 0, "H", 17);
System.out.println();
}
public static void printInOrder(Node head, int height, String to, int len) {
if (head == null) {
return;
}
printInOrder(head.right, height + 1, "v", len);
String val = to + head.value + to;
int lenM = val.length();
int lenL = (len - lenM) / 2;
int lenR = len - lenM - lenL;
val = getSpace(lenL) + val + getSpace(lenR);
System.out.println(getSpace(height * len) + val);
printInOrder(head.left, height + 1, "^", len);
}
public static String getSpace(int num) {
String space = " ";
StringBuffer buf = new StringBuffer("");
for (int i = 0; i < num; i++) {
buf.append(space);
}
return buf.toString();
}
public static void main(String[] args) {
Node head = null;
printTree(head);
String pre = serialByPre(head);
System.out.println("serialize tree by pre-order: " + pre);
head = reconByPreString(pre);
System.out.print("reconstruct tree by pre-order, ");
printTree(head);
String level = serialByLevel(head);
System.out.println("serialize tree by level: " + level);
head = reconByLevelString(level);
System.out.print("reconstruct tree by level, ");
printTree(head);
System.out.println("====================================");
head = new Node(1);
printTree(head);
pre = serialByPre(head);
System.out.println("serialize tree by pre-order: " + pre);
head = reconByPreString(pre);
System.out.print("reconstruct tree by pre-order, ");
printTree(head);
level = serialByLevel(head);
System.out.println("serialize tree by level: " + level);
head = reconByLevelString(level);
System.out.print("reconstruct tree by level, ");
printTree(head);
System.out.println("====================================");
head = new Node(1);
head.left = new Node(2);
head.right = new Node(3);
head.left.left = new Node(4);
head.right.right = new Node(5);
printTree(head);
pre = serialByPre(head);
System.out.println("serialize tree by pre-order: " + pre);
head = reconByPreString(pre);
System.out.print("reconstruct tree by pre-order, ");
printTree(head);
level = serialByLevel(head);
System.out.println("serialize tree by level: " + level);
head = reconByLevelString(level);
System.out.print("reconstruct tree by level, ");
printTree(head);
System.out.println("====================================");
head = new Node(100);
head.left = new Node(21);
head.left.left = new Node(37);
head.right = new Node(-42);
head.right.left = new Node(0);
head.right.right = new Node(666);
printTree(head);
pre = serialByPre(head);
System.out.println("serialize tree by pre-order: " + pre);
head = reconByPreString(pre);
System.out.print("reconstruct tree by pre-order, ");
printTree(head);
level = serialByLevel(head);
System.out.println("serialize tree by level: " + level);
head = reconByLevelString(level);
System.out.print("reconstruct tree by level, ");
printTree(head);
System.out.println("====================================");
}
}
5.折纸问题
【题目】 请把一段纸条竖着放在桌子上，然后从纸条的下边向上方对折1次，压出折痕后展开。此时 折痕是凹下去的，即折痕 突起的方向指向纸条的背面。如果从纸条的下边向上方连续对折 2 次，压出折痕后展开，此时有三条折痕，从上到下依次是下折痕、下折痕和上折痕。
给定一 个输入参数N，代表纸条都从下边向上方连续对折N次， 请从上到下打印所有折痕的方向。 例如：N=1时，打印： down N=2时，打印： down down up
解析：按题意对折4次后看出规律：1代表down，0代表up。
对折第1次产生的折痕为：
1
对折第2次产生的折痕为：
1 0
对折第3次产生的折痕为：
1 0 1 0
对折第3次产生的折痕为：
1 0 1 0 1 0 1 0
可以看出，从最上方的折痕向下打印的过程为二叉树中序遍历的过程。
具体的实现代码如下：
public class Code_05_PaperFolding {
public static void printAllFolds(int N) {
printProcess(1, N, true);
}
public static void printProcess(int i, int N, boolean down) {
if (i > N) {
return;
}
printProcess(i + 1, N, true);
System.out.println(down ? "down " : "up ");
printProcess(i + 1, N, false);
}
public static void main(String[] args) {
int N = 4;
printAllFolds(N);
}
}
6.判断一棵二叉树是否是平衡二叉树
什么是平衡二叉树。就是每一个结点的左右子树的高度差不超过1。
来举个栗子：
如上图所示，4节点的左子树高度为0，右子树高度也为0，所以左右子树高度差为0，4节点为平衡二叉树；
又比如2节点的左子树高度为0，右子树高度为1，左右子树高度差为1,所以2节点为平衡二叉树。
又比如：
如上图，3节点的左子树高度为2，右子树的高度为0，左右子树的高度差大于1，所以不是平衡二叉树。
有个结论：满二叉树一定是平衡二叉树，但是平衡二叉树不一定是满二叉树！
在面试中，红黑树一般都不考coding，太多了，面试一般就一个小时，红黑树关键记住概念性问题。
解题思路：
关键点：
1.左子树是否平衡
2.右子树是否平衡
3.左子树的高度
4.右子树的高度
最关键的是设计整个递归的行为。这也是解决二叉树问题最主要的思路。
public class Code_06_IsBalanceTree {
public static class Node{
public Node left;
public Node right;
public int value;
public Node(int data){
this.value = data;
}
}
public static class ReturnData{
public boolean isBalance;
public int height;
public ReturnData(boolean isBalance,int height){
this.isBalance = isBalance;
this.height = height;
}
}
public static boolean isBalance(Node head){
return process(head).isBalance;
}
public static ReturnData process(Node head){
if(head == null){
return new ReturnData(true,0);
}
ReturnData returnData_left = process(head.left);
if(!returnData_left.isBalance){
return new ReturnData(false,0);//这个高度随意的
}
ReturnData returnData_right = process(head.right);
if(!returnData_right.isBalance){
return new ReturnData(false,0);
}
if(Math.abs(returnData_left.height - returnData_right.height) > 1){
return new ReturnData(false,0);
}
return new ReturnData(true,Math.max(returnData_left.height,returnData_right.height) + 1);//返回的高度+1是加上了本层的高度
}
public static void main(String[] args) {
Node head = new Node(1);
head.left = new Node(2);
head.right = new Node(3);
head.left.left = new Node(4);
head.left.right = new Node(5);
head.right.left = new Node(6);
head.right.right = new Node(7);
System.out.println(isBalance(head));
}
}
7.判断一棵树是否是搜索二叉树、判断一棵树是否是完全二叉树
搜索二叉树：它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。
搜索二叉树：
使用二叉树遍历的非递归版本更方便判断。
采用二叉树的中序遍历的非递归版本，在其中打印的位置用比较大小代替即可。
代码：
完全二叉树：树中的每一层从左到右每个节点都会依次填满的。
情况：
1）有右孩子，没有左的，肯定不是完全二叉树。
2）如果遇到一个结点，左孩子不为空，右孩子为空；或者左右孩子都为空；则该节点之后的队列中的结点都为叶子节点；该树才是完全二叉树，否则就不是完全二叉树；
两个的代码如下：
public class Code_07_IsBSTAndCBT {
public static class Node {
public int value;
public Node left;
public Node right;
public Node(int data) {
this.value = data;
}
}
public static boolean isBST(Node head) {//莫氏方法，比较难懂的，用中序遍历好理解
if (head == null) {
return true;
}
boolean res = true;
Node pre = null;
Node cur1 = head;
Node cur2 = null;
while (cur1 != null) {
cur2 = cur1.left;
if (cur2 != null) {
while (cur2.right != null && cur2.right != cur1) {
cur2 = cur2.right;
}
if (cur2.right == null) {
cur2.right = cur1;
cur1 = cur1.left;
continue;
} else {
cur2.right = null;
}
}
if (pre != null && pre.value > cur1.value) {
res = false;
}
pre = cur1;
cur1 = cur1.right;
}
return res;
}
//判断是否是搜索二叉树，使用的是二叉树中序遍历的改版
public static boolean isBSTTreee(Node head){
if(head == null){
return true;
}
Stack<Node> stack = new Stack<>();
int pre = Integer.MIN_VALUE;//准备一个辅助数，用来存放先前一个数的值
while (!stack.isEmpty() || head != null){
if(head != null){
stack.push(head);
head = head.left;
}else {
head = stack.pop();
if(pre > head.value){
return false;
}
pre = head.value;
head = head.right;
}
}
return true;
}
//1）有右孩子，没有左的，肯定不是完全二叉树。
//2）如果遇到一个结点，左孩子不为空，右孩子为空；
//或者左右孩子都为空；则该节点之后的队列中的结点都为叶子节点；该树才是完全二叉树，否则就不是完全二叉树；
public static boolean isCBT(Node head) {
if (head == null) {
return true;
}
Queue<Node> queue = new LinkedList<Node>();
boolean leaf = false;//开启叶子节点阶段
Node l = null;
Node r = null;
queue.offer(head);
while (!queue.isEmpty()) {
head = queue.poll();
l = head.left;
r = head.right;
//每个节点拿到的每一个叶子结点都不为空
//当叶子阶段开启，并且左节点为空，右节点不为空就返回false
if ((leaf && (l != null || r != null)) || (l == null && r != null)) {
return false;
}
if (l != null) {//根据队列先进先出的特点，希望左边的先出，所以就先压入左边的
queue.offer(l);
}
if (r != null) {
queue.offer(r);
}
//else {//由于上边已经把左孩子为空，右孩子不为空的情况抛出了false，所以就直接判断右孩子不为空的就行了
// leaf = true;
//}
if(l == null || r == null){//开启叶子阶段，即为第二种情况的判断了
leaf = true;
}
}
return true;
}
// for test -- print tree
public static void printTree(Node head) {
System.out.println("Binary Tree:");
printInOrder(head, 0, "H", 17);
System.out.println();
}
public static void printInOrder(Node head, int height, String to, int len) {
if (head == null) {
return;
}
printInOrder(head.right, height + 1, "v", len);
String val = to + head.value + to;
int lenM = val.length();
int lenL = (len - lenM) / 2;
int lenR = len - lenM - lenL;
val = getSpace(lenL) + val + getSpace(lenR);
System.out.println(getSpace(height * len) + val);
printInOrder(head.left, height + 1, "^", len);
}
public static String getSpace(int num) {
String space = " ";
StringBuffer buf = new StringBuffer("");
for (int i = 0; i < num; i++) {
buf.append(space);
}
return buf.toString();
}
public static void main(String[] args) {
Node head = new Node(4);
head.left = new Node(2);
head.right = new Node(6);
head.left.left = new Node(1);
head.left.right = new Node(3);
head.right.left = new Node(5);
printTree(head);
System.out.println(isBST(head));
System.out.println(isCBT(head));
}
}
8.已知一棵完全二叉树，求其节点的个数
要求：时间复杂度低于O(N)，N为这棵树的节点个数
有个常用的定律：满二叉树：高度为L，结点个数 2^L - 1个.
完全二叉树还有一个很重要的特点就是，必须要上一层完全填满了才可以填下一层。
解题思路：
先遍历左边界，求出完全二叉树的高度h
然后遍历树的右子树的左边界，看它到没到最后一层，
如果到了最后一层，那么说明它的左子树是满的，高度是h-1
左子树的结点数2^(h-1) - 1 + 当前节点 + 递归求解 右子树的结点的个数，（右子树节点个数使用递归求）
如果没到最后一层，那么说明它的右子树是满的，高度是h-2
右子树的结点数2^(h-2) - 1 + 当前节点 + 递归求解 左子树的结点的个数 （左子树的节点个数使用递归求）
该算法的复杂度为：O((logN)^2)
代码解决：
public class Code_08_CompleteTreeNodeNumber {
public static class Node {
public int value;
public Node left;
public Node right;
public Node(int data) {
this.value = data;
}
}
public static int nodeNum(Node head) {
if (head == null) {
return 0;
}
return bs(head, 1, mostLeftLevel(head, 1));
}
public static int bs(Node node, int level, int h) {//l表示第几层，h表示二叉树的深度，是一个固定值不变的,返回的是节点的个数
if (level == h) {
return 1;
}
if (mostLeftLevel(node.right, level + 1) == h) {//如果右子树的左边界到了整棵树的最后一层
return (1 << (h - level)) + bs(node.right, level + 1, h);//此时左树是满的，左树和当前节点个数用公式求（1 << (h - level))-1+1）
} else {
return (1 << (h - level - 1)) + bs(node.left, level + 1, h);//此时右子树少一层，但也是满的，可以用公式求：1 << (h - level - 1)
}
}
public static int mostLeftLevel(Node node, int level) {
while (node != null) {
level++;
node = node.left;
}
return level - 1;
}
public static void main(String[] args) {
Node head = new Node(1);
head.left = new Node(2);
head.right = new Node(3);
head.left.left = new Node(4);
head.left.right = new Node(5);
head.right.left = new Node(6);
System.out.println(nodeNum(head));
}
}
8962
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
