• go语言｜二叉树递归遍历，可能有你没见过的花样玩法

    在上一篇博客《go语言｜数据结构：二叉树可视化（制作svg格式树形图）》中，已实现了用svg图片展示二叉树的树形结构。但对非满二叉树的比较复杂，需要先转成满二叉树，再获取各结点在满二叉树中的对应坐标位置，这种做法明显有个缺点就是遍历的次数比较多。

    树形图的关键在于获取结点的坐标。对满二叉树的来说，它的坐标数组可以标记为：[[(0,0)], [(1,0), (1,1)], [(2,0), (2,1), (2,2), (2,3)], [(3,0),(3,1), ...], ...]；如能对任意二叉树只做一次遍布，就获得这样的坐标，效率就提高了。首先，从递归遍历说起——

    递归遍历

    递归遍历时，看数据域和左右子树结点出现的位置顺序看，分先序、中序、后序三种方式。不管哪种方式都可以用2种方法，一种是直接打印遍历结果、一种返回遍历结果（结点的数据域数组）。如下代码，以先序遍历为例：

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type btNode struct {
    6. 	Data   interface{}
    7. 	Lchild *btNode
    8. 	Rchild *btNode
    9. }
    10.  
    11. type biTree struct {
    12. 	Root *btNode
    13. }
    14.  
    15. func Build(List ...interface{}) *biTree {
    16. 	if len(List) == 0 || List[0] == nil {
    17. 		return &biTree{}
    18. 	}
    19. 	node := &btNode{Data: List[0]}
    20. 	Queue := []*btNode{node}
    21. 	for lst := List[1:]; len(lst) > 0 && len(Queue) > 0; {
    22. 		cur, val := Queue[0], lst[0]
    23. 		Queue, lst = Queue[1:], lst[1:]
    24. 		if val != nil {
    25. 			cur.Lchild = &btNode{Data: val}
    26. 			Queue = append(Queue, cur.Lchild)
    27. 		}
    28. 		if len(lst) > 0 {
    29. 			val, lst = lst[0], lst[1:]
    30. 			if val != nil {
    31. 				cur.Rchild = &btNode{Data: val}
    32. 				Queue = append(Queue, cur.Rchild)
    33. 			}
    34. 		}
    35. 	}
    36. 	return &biTree{Root: node}
    37. }
    38.  
    39. func (bt *btNode) PreorderPrint() {
    40. 	if bt != nil {
    41. 		fmt.Print(bt.Data, " ")
    42. 		bt.Lchild.PreorderPrint()
    43. 		bt.Rchild.PreorderPrint()
    44. 	}
    45. }
    46.  
    47. func (bt *btNode) PreorderList() []interface{} {
    48. 	var res []interface{}
    49. 	if bt != nil {
    50. 		res = append(res, bt.Data)
    51. 		res = append(res, bt.Lchild.PreorderList()...)
    52. 		res = append(res, bt.Rchild.PreorderList()...)
    53. 	}
    54. 	return res
    55. }
    56.  
    57. func main() {
    58.  
    59. 	tree := Build(1, 2, 3, 4, 5, 6, 7, 8)
    60.  
    61. 	fmt.Println(tree.Root.PreorderList())
    62. 	tree.Root.PreorderPrint()
    63.  
    64. }

    创建函数Build()也作了改进，直接用变长参数，而非之前用数组作参数。另外，参数中如有不能连接的结点，直接放弃而非抛出错误panic()。如参数 1,nil,nil,2,3 就只返回一个结点。

    深度的遍历

    递归遍历核心就以下三行代码，先读出数据域，后左右递归的即先序遍历；读出放中间或最后一行就变成中序和后序遍历了。

    fmt.Print(bt.Data, " ")                //读出数据域
    bt.Lchild.PreorderPrint()          //左子树递归
    bt.Rchild.PreorderPrint()          //右子树递归

    如果把bt.Data换成其它呢，结点结构就定义了三个值，换成bt.Lchild，bt.Rchild就能遍历出左右子树结点。这样用处不大， 如果写成 bt.Lchild!=nil 或者 bt.Rchild!=nil，遍历结果就是该结点是否有左子树或右子树；写成 bt.Lchild==nil && bt.Rchild==nil 就能判断是否为叶结点。如果换作一个自定义函数呢，那就能得到自己想要的结果。也可以玩其它花样，比如累加所有结点的和，为了方便默认它们的数据域都是整数：

    1. //相同代码部分略，见上面的代码
    2.  
    3. func (bt *btNode) SumTree() int {
    4. 	var res int
    5. 	if bt != nil {
    6. 		res += bt.Data.(int)
    7. 		res += bt.Lchild.SumTree()
    8. 		res += bt.Rchild.SumTree()
    9. 	}
    10. 	return res
    11. }
    12.  
    13. func main() {
    14. 	tree := Build(1, 5, 26, 9, 8, 51)
    15. 	fmt.Println(tree.Root.SumTree())
    16. }
    17.  
    18. // 输出结果 100

    深度和高度的概念

    深度是从根节点数到它的叶节点，高度是从叶节点数到它的根节点。即深度是从上到下计数的，而高度是从下往上计数。

    二叉树的深度是指所有结点中最深的结点所在的层数。对于整棵树来说，最深的叶结点的深度就是树的深度，即树的高度和深度是相等的。但同一层的节点的深度是相同，它们的高度不一定相同。如下图，节点2和3的深度相等，但高度不相等；节点4、5、6深度也相等，但高度不全相等。

    深度的遍历

    从二叉树深度的定义可知，二叉树的深度应为其左、右子树深度的最大值加1。由此，需先分别求得左、右子树的深度，算法中“访问结点”的操作为：求得左、右子树深度的最大值，然后加 1 。递归代码如下：

    1. func (bt *btNode) MaxDepth() int {
    2. 	if bt == nil {
    3. 		return 0
    4. 	}
    5. 	Lmax := bt.Lchild.MaxDepth()
    6. 	Rmax := bt.Rchild.MaxDepth()
    7. 	if Lmax > Rmax {
    8. 		return 1 + Lmax
    9. 	} else {
    10. 		return 1 + Rmax
    11. 	}
    12. }

    遍历时用上这个函数就可得到所有结点的深度了，完整测试代码以8个结点的完全二叉树为例，返回结果是：“4 3 2 1 1 2 1 1”。最大值4为根结点的尝试，也就是整个二叉树的深度或高度；四个最小值1，表示有四个叶结点。

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type btNode struct {
    6. 	Data   interface{}
    7. 	Lchild *btNode
    8. 	Rchild *btNode
    9. }
    10.  
    11. type biTree struct {
    12. 	Root *btNode
    13. }
    14.  
    15. func Build(List ...interface{}) *biTree {
    16. 	if len(List) == 0 || List[0] == nil {
    17. 		return &biTree{}
    18. 	}
    19. 	node := &btNode{Data: List[0]}
    20. 	Queue := []*btNode{node}
    21. 	for lst := List[1:]; len(lst) > 0 && len(Queue) > 0; {
    22. 		cur, val := Queue[0], lst[0]
    23. 		Queue, lst = Queue[1:], lst[1:]
    24. 		if val != nil {
    25. 			cur.Lchild = &btNode{Data: val}
    26. 			Queue = append(Queue, cur.Lchild)
    27. 		}
    28. 		if len(lst) > 0 {
    29. 			val, lst = lst[0], lst[1:]
    30. 			if val != nil {
    31. 				cur.Rchild = &btNode{Data: val}
    32. 				Queue = append(Queue, cur.Rchild)
    33. 			}
    34. 		}
    35. 	}
    36. 	return &biTree{Root: node}
    37. }
    38.  
    39. func (bt *btNode) PreorderDepth() {
    40. 	if bt != nil {
    41. 		fmt.Print(bt.MaxDepth(), " ")
    42. 		bt.Lchild.PreorderDepth()
    43. 		bt.Rchild.PreorderDepth()
    44. 	}
    45. }
    46.  
    47. func (bt *btNode) MaxDepth() int {
    48. 	if bt == nil {
    49. 		return 0
    50. 	}
    51. 	Lmax := bt.Lchild.MaxDepth()
    52. 	Rmax := bt.Rchild.MaxDepth()
    53. 	if Lmax > Rmax {
    54. 		return 1 + Lmax
    55. 	} else {
    56. 		return 1 + Rmax
    57. 	}
    58. }
    59.  
    60. func main() {
    61.  
    62. 	tree := Build(1, 2, 3, 4, 5, 6, 7, 8)
    63.  
    64. 	tree.Root.PreorderDepth()
    65.  
    66. }

    叶结点的遍历

    1. func (bt *btNode) LeafPrint() {
    2. 	if bt != nil {
    3. 		if bt.Lchild == nil && bt.Rchild == nil {
    4. 			fmt.Print(bt.Data, " ")
    5. 		}
    6. 		bt.Lchild.LeafPrint()
    7. 		bt.Rchild.LeafPrint()
    8. 	}
    9. }
    10.  
    11. func (bt *btNode) LeafList() []interface{} {
    12. 	var res []interface{}
    13. 	if bt != nil {
    14. 		if bt.Lchild == nil && bt.Rchild == nil {
    15. 			res = append(res, bt.Data)
    16. 		}
    17. 		res = append(res, bt.Lchild.LeafList()...)
    18. 		res = append(res, bt.Rchild.LeafList()...)
    19. 	}
    20. 	return res
    21. }

    结点结构的三变量都用过了，对得到结点的坐标帮助不大，坐标需要的是结点在树中的层数和所在层数的索引号。于是尝试引入其它变量——

    坐标的遍历

    纵坐标遍历

    1. //相同代码部分略，见上面的代码
    2.  
    3. func (bt *btNode) LevelPrint(y int) {
    4. 	if bt != nil {
    5. 		fmt.Print(bt.Data, ":", y, " ")
    6.         y++
    7. 		bt.Lchild.LevelPrint(y)
    8. 		bt.Rchild.LevelPrint(y)
    9.         y--
    10. 	}
    11. }
    12.  
    13. func main() {
    14.  
    15. 	tree := Build(1, 2, 3, 4, 5, 6, 7, 8)
    16.  
    17. 	tree.Root.LevelPrint(0)
    18.  
    19. }
    20.  
    21. //输出结果 1:0 2:1 4:2 8:3 5:2 3:1 6:2 7:2

    改成返回数组形式如下： 另外也可以把y++,y--改成参数y+1，输出[0 1 2 3 2 1 2 2]，结果相同。

    1. //相同代码部分略，见上面的代码
    2.  
    3. func (bt *btNode) LevelList(y int) []int {
    4. 	var res []int
    5. 	if bt != nil {
    6. 		res = append(res, y)
    7. 		res = append(res, bt.Lchild.LevelList(y+1)...)
    8. 		res = append(res, bt.Rchild.LevelList(y+1)...)
    9. 	}
    10. 	return res
    11. }
    12.  
    13. func main() {
    14.  
    15. 	tree := Build(1, 2, 3, 4, 5, 6, 7, 8)
    16. 	fmt.Print(tree.Root.LevelList(0))
    17.  
    18. }

    横坐标遍历

    依葫芦画瓢，照纵坐标的方式遍历：

    1. func (bt *btNode) IndexPrint(x int) {
    2. 	if bt != nil {
    3. 		fmt.Print(bt.Data, ":", x, " ")
    4. 		bt.Lchild.IndexPrint(x - 1)
    5. 		bt.Rchild.IndexPrint(x + 1)
    6. 	}
    7. }

    但结果不符合要求：1:0 2:-1 4:-2 8:-3 5:0 3:1 6:0 7:2

    最底下一层最靠近中间的左右两结点横坐标是-1,1就OK了，以满二叉树为例来说比较好理解：

    从上图的规律看，每层平移的距离不一样的，不能平移正负1，移动距离应该是2的高度减一次方才对，调用时参数为（0,2的高度-2次方），完整的测试代码如下：

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type btNode struct {
    6. 	Data   interface{}
    7. 	Lchild *btNode
    8. 	Rchild *btNode
    9. }
    10.  
    11. type biTree struct {
    12. 	Root *btNode
    13. }
    14.  
    15. func Build(List ...interface{}) *biTree {
    16. 	if len(List) == 0 || List[0] == nil {
    17. 		return &biTree{}
    18. 	}
    19. 	node := &btNode{Data: List[0]}
    20. 	Queue := []*btNode{node}
    21. 	for lst := List[1:]; len(lst) > 0 && len(Queue) > 0; {
    22. 		cur, val := Queue[0], lst[0]
    23. 		Queue, lst = Queue[1:], lst[1:]
    24. 		if val != nil {
    25. 			cur.Lchild = &btNode{Data: val}
    26. 			Queue = append(Queue, cur.Lchild)
    27. 		}
    28. 		if len(lst) > 0 {
    29. 			val, lst = lst[0], lst[1:]
    30. 			if val != nil {
    31. 				cur.Rchild = &btNode{Data: val}
    32. 				Queue = append(Queue, cur.Rchild)
    33. 			}
    34. 		}
    35. 	}
    36. 	return &biTree{Root: node}
    37. }
    38.  
    39. func Pow2(x int) int { //x>=0
    40. 	res := 1
    41. 	for i := 0; i < x; i++ {
    42. 		res *= 2
    43. 	}
    44. 	return res
    45. }
    46.  
    47. func Max(L, R int) int {
    48. 	if L > R {
    49. 		return L
    50. 	} else {
    51. 		return R
    52. 	}
    53. }
    54.  
    55. func (bt *btNode) MaxDepth() int {
    56. 	if bt == nil {
    57. 		return 0
    58. 	}
    59. 	Lmax := bt.Lchild.MaxDepth()
    60. 	Rmax := bt.Rchild.MaxDepth()
    61. 	return 1 + Max(Lmax, Rmax)
    62. }
    63.  
    64. func (bt *btNode) IndexPrint(x, w int) {
    65. 	if bt != nil {
    66. 		fmt.Print(bt.Data, ":", x, " ")
    67. 		bt.Lchild.IndexPrint(x-w, w/2)
    68. 		bt.Rchild.IndexPrint(x+w, w/2)
    69. 	}
    70. }
    71.  
    72. func main() {
    73.  
    74. 	tree := Build(1, 2, 3)
    75. 	tree.Root.IndexPrint(0, Pow2(tree.Root.MaxDepth()-2))
    76. 	fmt.Println()
    77.  
    78. 	tree = Build(1, 2, 3, 4, 5, 6, 7)
    79. 	tree.Root.IndexPrint(0, Pow2(tree.Root.MaxDepth()-2))
    80. 	fmt.Println()
    81.  
    82. 	tree = Build(1, 2, 3, 4, 5, 6, 7, 8)
    83. 	tree.Root.IndexPrint(0, Pow2(tree.Root.MaxDepth()-2))
    84. 	fmt.Println()
    85.  
    86. 	tree = Build(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
    87. 	tree.Root.IndexPrint(0, Pow2(tree.Root.MaxDepth()-2))
    88. 	fmt.Println()
    89.  
    90. }
    91.  
    92. /*输出结果
    93. 1:0 2:-1 3:1 
    94. 1:0 2:-2 4:-3 5:-1 3:2 6:1 7:3 
    95. 1:0 2:-4 4:-6 8:-7 5:-2 3:4 6:2 7:6 
    96. 1:0 2:-4 4:-6 8:-7 9:-5 5:-2 10:-3 11:-1 3:4 6:2 12:1 13:3 7:6 14:5 15:7 
    97. */

    横纵坐标联合输出

    综上，把横纵坐标放一起以数组形式输出，参数多一个是变动的平移距离：

    1. //相同代码部分略，见上面的代码
    2.  
    3. func (bt *btNode) Coordinate(x, y, w int) []interface{} {
    4. 	var res []interface{}
    5. 	if bt != nil {
    6. 		res = append(res, []interface{}{bt.Data, x, y})
    7. 		res = append(res, bt.Lchild.Coordinate(x-w, y+1, w/2)...)
    8. 		res = append(res, bt.Rchild.Coordinate(x+w, y+1, w/2)...)
    9. 	}
    10. 	return res
    11. }
    12.  
    13. func main() {
    14.  
    15. 	tree := Build(1, 2, 3)
    16. 	fmt.Println(tree.Root.Coordinate(0, 0, Pow2(tree.Root.MaxDepth()-2)))
    17.  
    18. 	tree = Build(1, 2, 3, 4, 5, 6, 7)
    19. 	fmt.Println(tree.Root.Coordinate(0, 0, Pow2(tree.Root.MaxDepth()-2)))
    20.  
    21. 	tree = Build(1, 2, 3, nil, nil, 5, 6, 7, 8)
    22. 	fmt.Println(tree.Root.Coordinate(0, 0, Pow2(tree.Root.MaxDepth()-2)))
    23.  
    24. 	tree = Build(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
    25. 	fmt.Println(tree.Root.Coordinate(0, 0, Pow2(tree.Root.MaxDepth()-2)))
    26.  
    27. 	tree = Build(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)
    28. 	fmt.Println(tree.Root.Coordinate(0, 0, Pow2(tree.Root.MaxDepth()-2)))
    29.  
    30. }
    31.  
    32. /*输出结果
    33. [[1 0 0] [2 -1 1] [3 1 1]]
    34. [[1 0 0] [2 -2 1] [4 -3 2] [5 -1 2] [3 2 1] [6 1 2] [7 3 2]]
    35. [[1 0 0] [2 -4 1] [3 4 1] [5 2 2] [7 1 3] [8 3 3] [6 6 2]]
    36. [[1 0 0] [2 -4 1] [4 -6 2] [8 -7 3] [9 -5 3] [5 -2 2] [10 -3 3] [11 -1 3] [3 4 1] [6 2 2] [12 1 3] [13 3 3] [7 6 2] [14 5 3] [15 7 3]]
    37. [[1 0 0] [2 -8 1] [4 -12 2] [8 -14 3] [16 -15 4] [9 -10 3] [5 -4 2] [10 -6 3] [11 -2 3] [3 8 1] [6 4 2] [12 2 3] [13 6 3] [7 12 2] [14 10 3] [15 14 3]]
    38. */

    至此，坐标遍历全部完成，再加上判断有否左右子树结点就能作图了：

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type btNode struct {
    6. 	Data   interface{}
    7. 	Lchild *btNode
    8. 	Rchild *btNode
    9. }
    10.  
    11. type biTree struct {
    12. 	Root *btNode
    13. }
    14.  
    15. func Build(List ...interface{}) *biTree {
    16. 	if len(List) == 0 || List[0] == nil {
    17. 		return &biTree{}
    18. 	}
    19. 	node := &btNode{Data: List[0]}
    20. 	Queue := []*btNode{node}
    21. 	for lst := List[1:]; len(lst) > 0 && len(Queue) > 0; {
    22. 		cur, val := Queue[0], lst[0]
    23. 		Queue, lst = Queue[1:], lst[1:]
    24. 		if val != nil {
    25. 			cur.Lchild = &btNode{Data: val}
    26. 			Queue = append(Queue, cur.Lchild)
    27. 		}
    28. 		if len(lst) > 0 {
    29. 			val, lst = lst[0], lst[1:]
    30. 			if val != nil {
    31. 				cur.Rchild = &btNode{Data: val}
    32. 				Queue = append(Queue, cur.Rchild)
    33. 			}
    34. 		}
    35. 	}
    36. 	return &biTree{Root: node}
    37. }
    38.  
    39. func Pow2(x int) int { //x>=0
    40. 	res := 1
    41. 	for i := 0; i < x; i++ {
    42. 		res *= 2
    43. 	}
    44. 	return res
    45. }
    46.  
    47. func Max(L, R int) int {
    48. 	if L > R {
    49. 		return L
    50. 	} else {
    51. 		return R
    52. 	}
    53. }
    54.  
    55. func (bt *btNode) MaxDepth() int {
    56. 	if bt == nil {
    57. 		return 0
    58. 	}
    59. 	Lmax := bt.Lchild.MaxDepth()
    60. 	Rmax := bt.Rchild.MaxDepth()
    61. 	return 1 + Max(Lmax, Rmax)
    62. }
    63.  
    64. func (bt *btNode) Coordinate(x, y, w int) []interface{} {
    65. 	var res []interface{}
    66. 	if bt != nil {
    67. 		res = append(res, []interface{}{bt.Data, x, y, w, bt.Lchild != nil, bt.Rchild != nil})
    68. 		res = append(res, bt.Lchild.Coordinate(x-w, y+1, w/2)...)
    69. 		res = append(res, bt.Rchild.Coordinate(x+w, y+1, w/2)...)
    70. 	}
    71. 	return res
    72. }
    73.  
    74. func main() {
    75.  
    76. 	tree := Build(1, 2, 3, 4, 5, 6, 7, 8)
    77. 	list := tree.Root.Coordinate(0, 0, Pow2(tree.Root.MaxDepth()-2))
    78. 	fmt.Println(list)
    79. 	//数组的遍历
    80. 	for _, data := range list {
    81. 		for _, d := range data.([]interface{}) {
    82. 			fmt.Print(d, " ")
    83. 		}
    84. 		/*内循环或者用：
    85. 		for i, _ := range data.([]interface{}) {
    86. 			fmt.Print(data.([]interface{})[i], " ")
    87. 		}
    88. 		*/
    89. 		fmt.Println()
    90. 	}
    91. }
    92.  
    93. /*输出结果
    94. [[1 0 0 true true] [2 -4 1 true true] [4 -6 2 true false] [8 -7 3 false false] [5 -2 2 false false] [3 4 1 true true] [6 2 2 false false] [7 6 2 false false]]
    95. 1 0 0 true true 
    96. 2 -4 1 true true 
    97. 4 -6 2 true false 
    98. 8 -7 3 false false 
    99. 5 -2 2 false false 
    100. 3 4 1 true true 
    101. 6 2 2 false false 
    102. 7 6 2 false false 
    103. */

    作图时的用法，以上面完整代码的输出为例：

    遍历到 2 -4 1 2 true true ，表示(-4,1)处是结点2，true true就有2条子树的连线，指向坐标 (-4-2, 1+1) (-4+2, 1+1)，即 (-6, 2) 和 (-2, 2)，即结点4和结点；

    遍历到 4 -6 2 1 true false，表示(-6,2)处是结点4，true false说明它只有左子树，指向坐标 (-7,3)，即结点8；

    遍历到 8 -7 3 0 false false，表示(-7,3)处是结点8，false,false说明它是叶结点。

    具体如何把结点和坐标转换到二叉树svg图形格式，请参见上篇文章：

     《go语言｜数据结构：二叉树可视化（制作svg格式树形图）》。

    BTW，以上所有代码不论是哪一个递归遍历都可以有三种顺序，比如坐标遍历的代码：

    1. //先序
    2. func (bt *btNode) Coordinate(x, y, w int) []interface{} {
    3. 	var res []interface{}
    4. 	if bt != nil {
    5. 		res = append(res, []interface{}{bt.Data, x, y})
    6. 		res = append(res, bt.Lchild.Coordinate(x-w, y+1, w/2)...)
    7. 		res = append(res, bt.Rchild.Coordinate(x+w, y+1, w/2)...)
    8. 	}
    9. 	return res
    10. }

    换个顺序就成为中序和后序遍历：

    1. //中序
    2. func (bt *btNode) Coordinate(x, y, w int) []interface{} {
    3. 	var res []interface{}
    4. 	if bt != nil {
    5. 		res = append(res, bt.Lchild.Coordinate(x-w, y+1, w/2)...)
    6. 		res = append(res, []interface{}{bt.Data, x, y})
    7. 		res = append(res, bt.Rchild.Coordinate(x+w, y+1, w/2)...)
    8. 	}
    9. 	return res
    10. }
    11.  
    12.  
    13. //后序
    14. func (bt *btNode) Coordinate(x, y, w int) []interface{} {
    15. 	var res []interface{}
    16. 	if bt != nil {
    17. 		res = append(res, bt.Lchild.Coordinate(x-w, y+1, w/2)...)
    18. 		res = append(res, bt.Rchild.Coordinate(x+w, y+1, w/2)...)
    19. 		res = append(res, []interface{}{bt.Data, x, y})
    20. 	}
    21. 	return res
    22. }

    (本文完)

  • 相关阅读:
    2067: [蓝桥杯2023初赛] 幸运数
    svn(乌龟svn)和SVN-VS2022插件(visualsvn) 下载
    C语言动态实现顺序栈
    你还不懂java的日志系统吗
    749个看图识字含MP3音频ACCESS\EXCEL数据库
    Jvm类加载机制
    Java中支持分库分表的框架/组件/中间件简介
    Java正则表达式之捕获组奥秘探索
    企业为什么要选择通配符SSL证书使用？
    如何在 Windows 10/11 上编辑 PDF [4 种简单方法]
  • 原文地址：https://blog.csdn.net/boysoft2002/article/details/126018226