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

    最近一直在刷二叉树题目，但在要验证结果时，通常用中序遍历、层序遍历查看结果，验证起来没有画图来得直观，所有想到自己动手制作二叉树的树形图。 直接开干，先从svg入手：

    什么是SVG？

    SVG定义

    SVG是可伸缩矢量图形 (Scalable Vector Graphics)，于2003年1月14日成为 W3C 推荐标准。

    SVG 用来定义用于网络的基于矢量的图形
    SVG 使用 XML 格式定义图形
    SVG 是万维网联盟的标准
    SVG 与诸如 DOM 和 XSL 之类的 W3C 标准是一个整体

    SVG优点

    SVG 可被非常多的工具读取和修改（比如记事本）
    SVG 与 JPEG 和 GIF 图像比起来，尺寸更小，且可压缩性更强。
    SVG 图像在放大或改变尺寸的情况下其图形质量不会有所损失
    SVG 图像可在任何的分辨率下被高质量地打印
    SVG 图像中的文本是可选的，同时也是可搜索的（很适合制作地图）
    SVG 可以与 JavaScript 技术一起运行
    SVG 是开放的标准
    SVG 文件是纯粹的 XML

    预定义元素

    矩形
    圆形
    椭圆
    直线
    文字
    路径
    折线
    多边形
    ... more ... 

    制作二叉树的树形图，就使用圆形、直线、文字三种元素即可：

    圆形 

    1. <svg xmlns="http://www.w3.org/2000/svg" version="1.1">
    2.   <circle cx="150" cy="50" r="30" stroke="black" stroke-width="2" fill="orange"/>
    3. svg>

     cx和cy属性定义圆点的x和y坐标；r属性定义圆的半径
    如果省略cx和cy，圆的中心会被设置为(0, 0)

    直线 

    1. <svg xmlns="http://www.w3.org/2000/svg" version="1.1">
    2.   <line x1="50" y1="50" x2="200" y2="200" style="stroke:red;stroke-width:2"/>
    3. svg>

    x1，y1，x2，y2 属性定义线条的直线两端点的坐标

    文字 

    1. <svg xmlns="http://www.w3.org/2000/svg" version="1.1">
    2.   <text x="30" y="150" fill="red">Welcome to Hann's HomePagetext>
    3. svg>

    x，y 属性定义文字左对齐显示时的起始坐标（居中对齐则是文字中间点）
    fill 属性定义文字的颜色

    结点SVG格式

    根结点

    由和组成，存放结点的数据域

    1. 	<g id="0,0">
    2. 	<circle cx="400" cy="50" r="30" stroke="black" stroke-width="2" fill="orange" />
    3. 	<text x="400" y="50" fill="red" font-size="20" text-anchor="middle" dominant-baseline="middle">1text>
    4. 	g>

    子树结点

    比根结点多出元素，用来表示父结点左或右指针的指向

    1. 	<g id="1,0">
    2. 	<circle cx="200" cy="170" r="30" stroke="black" stroke-width="2" fill="orange" />
    3. 	<text x="200" y="170" fill="red" font-size="20" text-anchor="middle" dominant-baseline="middle">2text>
    4. 	<line x1="200" y1="140" x2="379" y2="71" style="stroke:black;stroke-width:2"/>
    5. 	g>

    叶结点

    与子树结点相同，为区别显示把填充色改为greenlight

    1. 	<g id="1,1">
    2. 	<circle cx="600" cy="170" r="30" stroke="black" stroke-width="2" fill="lightgreen" />
    3. 	<text x="600" y="170" fill="red" font-size="20" text-anchor="middle" dominant-baseline="middle">3text>
    4. 	<line x1="600" y1="140" x2="421" y2="71" style="stroke:black;stroke-width:2"/>
    5. 	g>

    结点坐标

    坐标的确定

    结点坐标确定，把二叉树还原成满二叉树，结点位置标记为：

    [ [0,0], [1,0], [1,1], [2,0], [2,1], [2,2], [2,3], [3,0]......]，再用循环计算出各点坐标。

    连线的夹角

    实际上不用考虑连线夹角，只要计算出连线始终两端点的坐标即可：

    结点文本

    以字符串形式保存好属性变量的特征关键词，用于遍历二叉树时替换成实际数据：

    1. func XmlNode(M, N, X, Y int, Data string, Color ...string) string {
    2. 	var cColor, tColor string
    3. 	R := 30
    4. 	Node := `
    5. 	
    6. 	
    7. 		dominant-baseline="middle">DATA
    8. 	
    9. 	`
    10. 	if len(Color) == 0 {
    11. 		cColor, tColor = "orange", "red" //分别圆形背景色，文字颜色
    12. 	} else if len(Color) == 1 {
    13. 		cColor, tColor = Color[0], "red"
    14. 	} else {
    15. 		cColor, tColor = Color[0], Color[1]
    16. 	}
    17. 	Node = strings.Replace(Node, "M", strconv.Itoa(M), 1)
    18. 	Node = strings.Replace(Node, "N", strconv.Itoa(N), 1)
    19. 	Node = strings.Replace(Node, "X", strconv.Itoa(X), 2)
    20. 	Node = strings.Replace(Node, "Y", strconv.Itoa(Y), 2)
    21. 	Node = strings.Replace(Node, "RC", strconv.Itoa(R), 1)
    22. 	Node = strings.Replace(Node, "DATA", Data, 1)
    23. 	Node = strings.Replace(Node, "COLOR", cColor, 1)
    24. 	Node = strings.Replace(Node, "TextColor", tColor, 1)
    25. 	Node = strings.Replace(Node, "", "\n", -1)
    26. 	Node = strings.Replace(Node, "", "\t", -1)
    27. 	Node = strings.Replace(Node, "\n\t\t", " ", -1)
    28. 	return Node
    29. }

    二叉树转SVG

    遍历二叉树对应的满二叉树，读出数据域并计算坐标，转成svg格式：

    二叉树转svg

    1. func (bt *biTree) Xml4Tree() string {
    2. 	var Xml, Node string
    3. 	Head := " +
    4. 		"1999/xlink\" version=\"1.1\" width=\"Width\" height=\"Height\">\nCONTENT"
    5. 	Line := ``
    6. 	Link := `
    7. 	Hann's CSDN Homepage`
    8. 	List := bt.LevelNullwith()
    9. 	Levels := len(List)
    10. 	for i := Levels - 1; i >= 0; i-- {
    11. 		negative := -1
    12. 		TmpXml := ""
    13. 		for j := 0; j < Pow2(i); j++ {
    14. 			t := Pow2(Levels - i - 1)
    15. 			x, y := 50*(2*t*j+t), 120*i+50
    16. 			if List[i][j] != nil {
    17. 				fillColor := "orange"
    18. 				if i == Levels-1 || i > 0 && i < Levels-1 &&
    19. 					List[i+1][j*2] == nil && List[i+1][j*2+1] == nil {
    20. 					fillColor = "lightgreen"
    21. 				}
    22. 				TmpStr := ""
    23. 				switch List[i][j].(type) {
    24. 				case int:
    25. 					TmpStr = strconv.Itoa(List[i][j].(int))
    26. 				case float64:
    27. 					TmpStr = strconv.FormatFloat(List[i][j].(float64), 'g', -1, 64)
    28. 				case string:
    29. 					TmpStr = List[i][j].(string)
    30. 				default:
    31. 					TmpStr = "Error Type"
    32. 				}
    33. 				Xml = XmlNode(i, j, x, y, TmpStr, fillColor)
    34. 			}
    35. 			if i > 0 {
    36. 				line1 := strings.Replace(Line, "X1", strconv.Itoa(x), 1)
    37. 				line1 = strings.Replace(line1, "Y1", strconv.Itoa(y-30), 1)
    38. 				negative *= -1
    39. 				x0, y0 := 21, 21
    40. 				x += 50*negative*(2*t*j%2+t) - negative*x0
    41. 				line1 = strings.Replace(line1, "X2", strconv.Itoa(x), 1)
    42. 				line1 = strings.Replace(line1, "Y2", strconv.Itoa(y-120+y0), 1)
    43. 				Xml = strings.Replace(Xml, "", line1, 1)
    44. 			}
    45. 			if List[i][j] != nil {
    46. 				TmpXml += Xml
    47. 			}
    48. 		}
    49. 		Node = TmpXml + Node
    50. 	}
    51. 	Xml = strings.Replace(Head, "CONTENT", Node, 1)
    52. 	Xml = strings.Replace(Xml, "Width", strconv.Itoa(Pow2(Levels)*50), 1)
    53. 	Xml = strings.Replace(Xml, "Height", strconv.Itoa(Levels*120), 1)
    54. 	Xml = strings.Replace(Xml, "", Link, 1)
    55. 	return Xml
    56. }

    写入文件、调取浏览

    要把.svg文件的默认打开方式关联为默认浏览器，否则不显示而是提示是否要下载

    1.     //......
    2. 	for index, text := range texts {
    3. 		svgFile := "./biTree0" + strconv.Itoa(index+1) + ".svg"
    4. 		file, err1 = os.Create(svgFile)
    5. 		if err1 != nil {
    6. 			panic(err1)
    7. 		}
    8. 		_, err1 = io.WriteString(file, text)
    9. 		if err1 != nil {
    10. 			panic(err1)
    11. 		}
    12. 		file.Close()
    13. 		exec.Command("cmd", "/c", "start", svgFile).Start()
    14. 		//Linux 代码：
    15. 		//exec.Command("xdg-open", svgFile).Start()
    16. 		//Mac 代码：
    17. 		//exec.Command("open", svgFile).Start()
    18. 	}
    19.     //......

     满二叉树按层作图

    1. func Xml4Full(Levels int) string {
    2. 	var Xml, Node string
    3. 	Head := " +
    4. 		"1999/xlink\" version=\"1.1\" width=\"Width\" height=\"Height\">\nCONTENT"
    5. 	Line := ``
    6. 	Link := `
    7. 	Hann's CSDN Homepage`
    8. 	for i := 0; i < Levels; i++ {
    9. 		negative := -1
    10. 		for j := 0; j < Pow2(i); j++ {
    11. 			t := Pow2(Levels - i - 1)
    12. 			x, y := 50*(2*t*j+t), 120*i+50
    13. 			if Levels != 1 && i == Levels-1 {
    14. 				Xml = XmlNode(i, j, x, y, strconv.Itoa(Pow2(i)+j), "lightgreen")
    15. 			} else {
    16. 				Xml = XmlNode(i, j, x, y, strconv.Itoa(Pow2(i)+j))
    17. 			}
    18. 			if i > 0 {
    19. 				line1 := strings.Replace(Line, "X1", strconv.Itoa(x), 1)
    20. 				line1 = strings.Replace(line1, "Y1", strconv.Itoa(y-30), 1)
    21. 				negative *= -1
    22. 				x0, y0 := 21, 21
    23. 				//过连线起始端的半径与纵轴线夹角取45度时x,y坐标修正值21,21[30/1.414]
    24. 				//取30度时 x0,y0:= 15,30-26；取60度时 x0,y0:= 26[15*1.732],15
    25. 				x += 50*negative*(2*t*j%2+t) - negative*x0
    26. 				line1 = strings.Replace(line1, "X2", strconv.Itoa(x), 1)
    27. 				line1 = strings.Replace(line1, "Y2", strconv.Itoa(y-120+y0), 1)
    28. 				Xml = strings.Replace(Xml, "", line1, 1)
    29. 			}
    30. 			Node += Xml
    31. 		}
    32. 	}
    33. 	Xml = strings.Replace(Head, "CONTENT", Node, 1)
    34. 	Xml = strings.Replace(Xml, "Width", strconv.Itoa(Pow2(Levels)*50), 1)
    35. 	Xml = strings.Replace(Xml, "Height", strconv.Itoa(Levels*120), 1)
    36. 	Xml = strings.Replace(Xml, "", Link, 1)
    37. 	return Xml
    38. }

    全部源代码

    本文所用的二叉树插图，都是用以下代码制作svg图片，然后另存png格式上传：

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"io"
    6. 	"os"
    7. 	"os/exec"
    8. 	"strconv"
    9. 	"strings"
    10. )
    11.  
    12. type btNode struct {
    13. 	Data   interface{}
    14. 	Lchild *btNode
    15. 	Rchild *btNode
    16. }
    17.  
    18. type biTree struct {
    19. 	Root *btNode
    20. }
    21.  
    22. func Build(data interface{}) *biTree {
    23. 	var list []interface{}
    24. 	if data == nil {
    25. 		return &biTree{}
    26. 	}
    27. 	switch data.(type) {
    28. 	case []interface{}:
    29. 		list = append(list, data.([]interface{})...)
    30. 	default:
    31. 		list = append(list, data)
    32. 	}
    33. 	if len(list) == 0 {
    34. 		return &biTree{}
    35. 	}
    36. 	node := &btNode{Data: list[0]}
    37. 	list = list[1:]
    38. 	Queue := []*btNode{node}
    39. 	for len(list) > 0 {
    40. 		if len(Queue) == 0 {
    41. 			//panic("Given array can not build binary tree.")
    42. 			return &biTree{Root: node}
    43. 		}
    44. 		cur := Queue[0]
    45. 		val := list[0]
    46. 		Queue = Queue[1:]
    47. 		if val != nil {
    48. 			cur.Lchild = &btNode{Data: val}
    49. 			if cur.Lchild != nil {
    50. 				Queue = append(Queue, cur.Lchild)
    51. 			}
    52. 		}
    53. 		list = list[1:]
    54. 		if len(list) > 0 {
    55. 			val := list[0]
    56. 			if val != nil {
    57. 				cur.Rchild = &btNode{Data: val}
    58. 				if cur.Rchild != nil {
    59. 					Queue = append(Queue, cur.Rchild)
    60. 				}
    61. 			}
    62. 			list = list[1:]
    63. 		}
    64. 	}
    65. 	return &biTree{Root: node}
    66. }
    67.  
    68. func (bt *biTree) AppendNode(data interface{}) {
    69. 	root := bt.Root
    70. 	if root == nil {
    71. 		bt.Root = &btNode{Data: data}
    72. 		return
    73. 	}
    74. 	Queue := []*btNode{root}
    75. 	for len(Queue) > 0 {
    76. 		cur := Queue[0]
    77. 		Queue = Queue[1:]
    78. 		if cur.Lchild != nil {
    79. 			Queue = append(Queue, cur.Lchild)
    80. 		} else {
    81. 			cur.Lchild = &btNode{Data: data}
    82. 			return
    83. 		}
    84. 		if cur.Rchild != nil {
    85. 			Queue = append(Queue, cur.Rchild)
    86. 		} else {
    87. 			cur.Rchild = &btNode{Data: data}
    88. 			break
    89. 		}
    90. 	}
    91. }
    92.  
    93. func Copy(bt *biTree) *biTree {
    94. 	root := bt.Root
    95. 	if root == nil {
    96. 		return &biTree{}
    97. 	}
    98. 	node := &btNode{Data: root.Data}
    99. 	Queue1, Queue2 := []*btNode{root}, []*btNode{node}
    100. 	for len(Queue1) > 0 {
    101. 		p1, p2 := Queue1[0], Queue2[0]
    102. 		Queue1, Queue2 = Queue1[1:], Queue2[1:]
    103. 		if p1.Lchild != nil {
    104. 			Node := &btNode{Data: p1.Lchild.Data}
    105. 			p2.Lchild = Node
    106. 			Queue1 = append(Queue1, p1.Lchild)
    107. 			Queue2 = append(Queue2, Node)
    108. 		}
    109. 		if p1.Rchild != nil {
    110. 			Node := &btNode{Data: p1.Rchild.Data}
    111. 			p2.Rchild = Node
    112. 			Queue1 = append(Queue1, p1.Rchild)
    113. 			Queue2 = append(Queue2, Node)
    114. 		}
    115. 	}
    116. 	return &biTree{Root: node}
    117. }
    118.  
    119. func Mirror(bt *biTree) *biTree {
    120. 	root := bt.Root
    121. 	if root == nil {
    122. 		return &biTree{}
    123. 	}
    124. 	node := &btNode{Data: root.Data}
    125. 	Queue1, Queue2 := []*btNode{root}, []*btNode{node}
    126. 	for len(Queue1) > 0 {
    127. 		p1, p2 := Queue1[0], Queue2[0]
    128. 		Queue1, Queue2 = Queue1[1:], Queue2[1:]
    129. 		if p1.Lchild != nil {
    130. 			Node := &btNode{Data: p1.Lchild.Data}
    131. 			p2.Rchild = Node
    132. 			Queue1 = append(Queue1, p1.Lchild)
    133. 			Queue2 = append(Queue2, Node)
    134. 		}
    135. 		if p1.Rchild != nil {
    136. 			Node := &btNode{Data: p1.Rchild.Data}
    137. 			p2.Lchild = Node
    138. 			Queue1 = append(Queue1, p1.Rchild)
    139. 			Queue2 = append(Queue2, Node)
    140. 		}
    141. 	}
    142. 	return &biTree{Root: node}
    143. }
    144.  
    145. func (bt *biTree) BForder2D() [][]interface{} {
    146. 	var res [][]interface{}
    147. 	root := bt.Root
    148. 	if root == nil {
    149. 		return res
    150. 	}
    151. 	Queue := []*btNode{root}
    152. 	for len(Queue) > 0 {
    153. 		Nodes := []interface{}{}
    154. 		Levels := len(Queue)
    155. 		for Levels > 0 {
    156. 			cur := Queue[0]
    157. 			Queue = Queue[1:]
    158. 			Nodes = append(Nodes, cur.Data)
    159. 			Levels--
    160. 			if cur.Lchild != nil {
    161. 				Queue = append(Queue, cur.Lchild)
    162. 			}
    163. 			if cur.Rchild != nil {
    164. 				Queue = append(Queue, cur.Rchild)
    165. 			}
    166. 		}
    167. 		res = append(res, Nodes)
    168. 	}
    169. 	return res
    170. }
    171.  
    172. func (bt *biTree) LevelNullwith(Fills ...interface{}) [][]interface{} {
    173. 	var Nodes [][]interface{}
    174. 	var Fill0 interface{}
    175. 	if len(Fills) == 0 {
    176. 		Fill0 = nil
    177. 	} else if len(Fills) == 1 {
    178. 		Fill0 = Fills[0]
    179. 	} else {
    180. 		panic("Error: number of parameters is greater than 1")
    181. 	}
    182. 	root := bt.Root
    183. 	if root == nil {
    184. 		return Nodes
    185. 	}
    186. 	Count := 0
    187. 	Queue := []*btNode{root}
    188. 	for len(Queue) > 0 {
    189. 		nodes := []interface{}{}
    190. 		Level := len(Queue)
    191. 		for Level > 0 {
    192. 			cur := Queue[0]
    193. 			Queue = Queue[1:]
    194. 			nodes = append(nodes, cur.Data)
    195. 			Count++
    196. 			Level--
    197. 			if cur.Lchild != nil {
    198. 				Queue = append(Queue, cur.Lchild)
    199. 			}
    200. 			if cur.Rchild != nil {
    201. 				Queue = append(Queue, cur.Rchild)
    202. 			}
    203. 		}
    204. 		Nodes = append(Nodes, nodes)
    205. 	}
    206. 	newbiTree := Copy(bt)
    207. 	for i := 1; i < Pow2(len(Nodes))-Count; i++ {
    208. 		newbiTree.AppendNode(Fill0)
    209. 	}
    210. 	return newbiTree.BForder2D()
    211. }
    212.  
    213. func XmlNode(M, N, X, Y int, Data string, Color ...string) string {
    214. 	var cColor, tColor string
    215. 	R := 30
    216. 	Node := `
    217. 	
    218. 	
    219. 		dominant-baseline="middle">DATA
    220. 	
    221. 	`
    222. 	if len(Color) == 0 {
    223. 		cColor, tColor = "orange", "red"
    224. 	} else if len(Color) == 1 {
    225. 		cColor, tColor = Color[0], "red"
    226. 	} else {
    227. 		cColor, tColor = Color[0], Color[1]
    228. 	}
    229. 	Node = strings.Replace(Node, "M", strconv.Itoa(M), 1)
    230. 	Node = strings.Replace(Node, "N", strconv.Itoa(N), 1)
    231. 	Node = strings.Replace(Node, "X", strconv.Itoa(X), 2)
    232. 	Node = strings.Replace(Node, "Y", strconv.Itoa(Y), 2)
    233. 	Node = strings.Replace(Node, "RC", strconv.Itoa(R), 1)
    234. 	Node = strings.Replace(Node, "DATA", Data, 1)
    235. 	Node = strings.Replace(Node, "COLOR", cColor, 1)
    236. 	Node = strings.Replace(Node, "TextColor", tColor, 1)
    237. 	Node = strings.Replace(Node, "", "\n", -1)
    238. 	Node = strings.Replace(Node, "", "\t", -1)
    239. 	Node = strings.Replace(Node, "\n\t\t", " ", -1)
    240. 	return Node
    241. }
    242.  
    243. func Pow2(x int) int { //x>=0
    244. 	res := 1
    245. 	for i := 0; i < x; i++ {
    246. 		res *= 2
    247. 	}
    248. 	return res
    249. }
    250.  
    251. func Xml4Full(Levels int) string {
    252. 	var Xml, Node string
    253. 	Head := " +
    254. 		"1999/xlink\" version=\"1.1\" width=\"Width\" height=\"Height\">\nCONTENT"
    255. 	Line := ``
    256. 	Link := `
    257. 	Hann's CSDN Homepage`
    258. 	for i := 0; i < Levels; i++ {
    259. 		negative := -1
    260. 		for j := 0; j < Pow2(i); j++ {
    261. 			t := Pow2(Levels - i - 1)
    262. 			x, y := 50*(2*t*j+t), 120*i+50
    263. 			if Levels != 1 && i == Levels-1 {
    264. 				Xml = XmlNode(i, j, x, y, strconv.Itoa(Pow2(i)+j), "lightgreen")
    265. 			} else {
    266. 				Xml = XmlNode(i, j, x, y, strconv.Itoa(Pow2(i)+j))
    267. 			}
    268. 			if i > 0 {
    269. 				line1 := strings.Replace(Line, "X1", strconv.Itoa(x), 1)
    270. 				line1 = strings.Replace(line1, "Y1", strconv.Itoa(y-30), 1)
    271. 				negative *= -1
    272. 				x0, y0 := 21, 21
    273. 				//过连线起始端的半径与纵轴线夹角取45度时x,y坐标修正值21,21[30/1.414]
    274. 				//取30度时 x0,y0:= 15,30-26；取60度时 x0,y0:= 26[15*1.732],15
    275. 				x += 50*negative*(2*t*j%2+t) - negative*x0
    276. 				line1 = strings.Replace(line1, "X2", strconv.Itoa(x), 1)
    277. 				line1 = strings.Replace(line1, "Y2", strconv.Itoa(y-120+y0), 1)
    278. 				Xml = strings.Replace(Xml, "", line1, 1)
    279. 			}
    280. 			Node += Xml
    281. 		}
    282. 	}
    283. 	Xml = strings.Replace(Head, "CONTENT", Node, 1)
    284. 	Xml = strings.Replace(Xml, "Width", strconv.Itoa(Pow2(Levels)*50), 1)
    285. 	Xml = strings.Replace(Xml, "Height", strconv.Itoa(Levels*120), 1)
    286. 	Xml = strings.Replace(Xml, "", Link, 1)
    287. 	return Xml
    288. }
    289.  
    290. func (bt *biTree) Xml4Tree() string {
    291. 	var Xml, Node string
    292. 	Head := " +
    293. 		"1999/xlink\" version=\"1.1\" width=\"Width\" height=\"Height\">\nCONTENT"
    294. 	Line := ``
    295. 	Link := `
    296. 	Hann's CSDN Homepage`
    297. 	List := bt.LevelNullwith()
    298. 	Levels := len(List)
    299. 	for i := Levels - 1; i >= 0; i-- {
    300. 		negative := -1
    301. 		TmpXml := ""
    302. 		for j := 0; j < Pow2(i); j++ {
    303. 			t := Pow2(Levels - i - 1)
    304. 			x, y := 50*(2*t*j+t), 120*i+50
    305. 			if List[i][j] != nil {
    306. 				fillColor := "orange"
    307. 				if i == Levels-1 || i > 0 && i < Levels-1 &&
    308. 					List[i+1][j*2] == nil && List[i+1][j*2+1] == nil {
    309. 					fillColor = "lightgreen"
    310. 				}
    311. 				TmpStr := ""
    312. 				switch List[i][j].(type) {
    313. 				case int:
    314. 					TmpStr = strconv.Itoa(List[i][j].(int))
    315. 				case float64:
    316. 					TmpStr = strconv.FormatFloat(List[i][j].(float64), 'g', -1, 64)
    317. 				case string:
    318. 					TmpStr = List[i][j].(string)
    319. 				default:
    320. 					TmpStr = "Error Type"
    321. 				}
    322. 				Xml = XmlNode(i, j, x, y, TmpStr, fillColor)
    323. 			}
    324. 			if i > 0 {
    325. 				line1 := strings.Replace(Line, "X1", strconv.Itoa(x), 1)
    326. 				line1 = strings.Replace(line1, "Y1", strconv.Itoa(y-30), 1)
    327. 				negative *= -1
    328. 				x0, y0 := 21, 21
    329. 				x += 50*negative*(2*t*j%2+t) - negative*x0
    330. 				line1 = strings.Replace(line1, "X2", strconv.Itoa(x), 1)
    331. 				line1 = strings.Replace(line1, "Y2", strconv.Itoa(y-120+y0), 1)
    332. 				Xml = strings.Replace(Xml, "", line1, 1)
    333. 			}
    334. 			if List[i][j] != nil {
    335. 				TmpXml += Xml
    336. 			}
    337. 		}
    338. 		Node = TmpXml + Node
    339. 	}
    340. 	Xml = strings.Replace(Head, "CONTENT", Node, 1)
    341. 	Xml = strings.Replace(Xml, "Width", strconv.Itoa(Pow2(Levels)*50), 1)
    342. 	Xml = strings.Replace(Xml, "Height", strconv.Itoa(Levels*120), 1)
    343. 	Xml = strings.Replace(Xml, "", Link, 1)
    344. 	return Xml
    345. }
    346.  
    347. func main() {
    348.  
    349. 	var file *os.File
    350. 	var err1 error
    351.  
    352. 	list1 := []interface{}{"-", "*", 6, "+", 3, nil, nil, 2, 8}
    353. 	list2 := []interface{}{1, 2, 3, 4, 5, nil, 6, 7, 8}
    354. 	tree1 := Build(list1)
    355. 	tree2 := Build(list2)
    356. 	tree3 := Mirror(tree2)
    357. 	texts := []string{tree1.Xml4Tree(), tree2.Xml4Tree(), tree3.Xml4Tree(), Xml4Full(4)}
    358.  
    359. 	for index, text := range texts {
    360. 		svgFile := "./biTree0" + strconv.Itoa(index+1) + ".svg"
    361. 		file, err1 = os.Create(svgFile)
    362. 		if err1 != nil {
    363. 			panic(err1)
    364. 		}
    365. 		_, err1 = io.WriteString(file, text)
    366. 		if err1 != nil {
    367. 			panic(err1)
    368. 		}
    369. 		file.Close()
    370. 		exec.Command("cmd", "/c", "start", svgFile).Start()
    371. 		//Linux 代码：
    372. 		//exec.Command("xdg-open", svgFile).Start()
    373. 		//Mac 代码：
    374. 		//exec.Command("open", svgFile).Start()
    375. 	}
    376.  
    377. 	fmt.Println("Welcome to my homepage: https://blog.csdn.net/boysoft2002")
    378. 	exec.Command("cmd", "/c", "start", "https://blog.csdn.net/boysoft2002").Start()
    379.  
    380. }

    至此，已达成自己的预想结果，算法实在有点笨拙，但总算成功了。如有达人会更好的算法，且刚好看到此文，请务必给予点拨指教（不吝）......

     上面一长条“细线”并非分割线，而是11层的满二叉树，太宽了点击放大看看！

  • 相关阅读:
    SpringMVC - 以 Servlet 3.0 的方式搭建 SSM 框架
    《动态规划 ---- 线性规划一》----- 动态规划的基本概念，线性动态规划--＞背包问题
    如何通过编码器信号计算输送线/输送带线速度（飞剪、追剪算法基础）
    Spring MVC HandlerMethodReturnValueHandler原理解析
    案例分享 生产环境逐步迁移至k8s集群 - pod注册到consul
    TSINGSEE青犀老旧小区升级改造AI+视频监控方案
    驾校教练爆笑语录
    秒懂 BeanFactory、BeanFactoryPostProcessor、BeanPostProcessor、FactoryBean的区别
    MinGW-w64下载文件失败the file has been downloaded incorrectly!
    【转】浅谈威胁狩猎（Threat Hunting）
  • 原文地址：https://blog.csdn.net/boysoft2002/article/details/126685307