概述
目的是将一个排序的链表转换成一个平衡的BST。平衡的BST是一个BST，其中每个节点的两个子树的深度相差不会超过1。
假设我们有下面的一个排序链表
-2->-1->0->1->2
那么它应该产生一个平衡的BST。
程序
package main
import "fmt"
type ListNode struct {
Val int
Next *ListNode
}
type SingleList struct {
Len int
Head *ListNode
}
func (s *SingleList) AddFront(num int) {
ele := &ListNode{
Val: num,
}
if s.Head == nil {
s.Head = ele
} else {
ele.Next = s.Head
s.Head = ele
}
s.Len++
}
type TreeNode struct {
Val int
Left *TreeNode
Right *TreeNode
}
func sortedListToBST(head *ListNode) *TreeNode {
len := lenOfList(head)
return sortedListToBSTUtil(&head, len)
}
func sortedListToBSTUtil(head **ListNode, n int) *TreeNode {
if *head == nil {
return nil
}
if n <= 0 {
return nil
}
left := sortedListToBSTUtil(head, n/2)
root := &TreeNode{Val: (*head).Val}
*head = (*head).Next
root.Left = left
root.Right = sortedListToBSTUtil(head, n-n/2-1)
return root
}
func lenOfList(head *ListNode) int {
length := 0
for head != nil {
length++
head = head.Next
}
return length
}
func main() {
singleList := &SingleList{}
fmt.Printf("AddFront: 2\n")
singleList.AddFront(2)
fmt.Printf("AddFront: 1\n")
singleList.AddFront(1)
fmt.Printf("AddFront: 0\n")
singleList.AddFront(0)
fmt.Printf("AddFront: -1\n")
singleList.AddFront(-1)
fmt.Printf("AddFront: -2\n")
singleList.AddFront(-2)
fmt.Println()
root := sortedListToBST(singleList.Head)
fmt.Printf("root: %d\n", root.Val)
fmt.Printf("root.Left: %d\n", root.Left.Val)
fmt.Printf("root.Left.Left: %d\n", root.Left.Left.Val)
fmt.Printf("root.Right: %d\n", root.Right.Val)
fmt.Printf("root.Right.Left: %d\n", root.Right.Left.Val)
}
输出
AddFront: 2
AddFront: 1
AddFront: 0
AddFront: -1
AddFront: -2
root: 0
root.Left: -1
root.Left.Left: -2
root.Right: 2
root.Right.Left: 1
