go 간단 한 이 진 트 리 구현

package data

import (
   "fmt"
   "reflect"
)

type Binary struct {
   Data interface{}
   left *Binary
   right *Binary
}

//       ——              
var i = -1
func (node *Binary) Create(data []interface{})*Binary {
   if node == nil {
      return nil
   }
   i = i +1
   //        
   var bin *Binary
   if i >= len(data) {
      return nil
   }else {
      bin = new(Binary)
      bin.Data = data[i]
      bin.left = bin.Create(data)
      bin.right = bin.Create(data)
   }
   return bin
}

func (node *Binary)New(index int,data []interface{})*Binary{
   if node == nil {
      return nil
   }
   bin := &Binary{data[index],nil,nil}
   //                    *2+1      +2    
   if index< len(data) && 2*index+1 < len(data){
      fmt.Println()
      bin.left = bin.New(index*2+1,data)
   }
   if i< len(data) && 2*index+2 < len(data){
      bin.right = bin.New(index*2+2,data)
   }
   return bin

}

//       ——     ： DLR
func (node *Binary) PrevSort() {
   //     
   if node == nil {
      return
   }
   //  D,       
   fmt.Print(node.Data, " ")
   //   ,           
   node.left.PrevSort()
   //   ，          
   node.right.PrevSort()
}

//       ——     ： LDR
func (node *Binary) MidSort() {
   if node == nil {
      return
   }
   //   ，          
   node.left.MidSort()
   //   ,      
   fmt.Print(node.Data, " ")
   //   ,           
   node.right.MidSort()
}

//       ——     ： LRD   --- 73415620
func (node *Binary) PostSort() {
   if node == nil {
      return
   }
   //   ，    
   node.left.PostSort()
   //   ，    
   node.right.PostSort()
   //   ,   
   fmt.Print(node.Data, " ")
}

//         （  ）
func (node *Binary) Height() int {
   //     
   if node == nil {
      return 0
   }
   //        
   lh := node.left.Height()
   //        
   rh := node.right.Height()
   //         ，             
   if lh > rh {
      lh++
      return lh
   } else {
      rh++
      return rh
   }
}

//               ---     
var num = 0 //      
func (node *Binary) LeafNum() {
   //     
   if node == nil {
      return
   }
   //       。     ==     == nil
   if node.left == nil && node.right == nil {
      num++
   }
   //              
   node.left.LeafNum()
   node.right.LeafNum()
}

//               ---     
func (node *Binary) LeafNum2(n *int) {
   //     
   if node == nil {
      return
   }
   if node.left == nil && node.right == nil {
      (*n)++
   }
   //              
   node.left.LeafNum2(n)
   node.right.LeafNum2(n)
}

//         
func (node *Binary) Search(Data interface{}) {
   if node == nil {
      return
   }
   //     、  
   if reflect.DeepEqual(node.Data, Data) {
      fmt.Println("  ！")
      return
   }
   //              
   node.left.Search(Data)
   node.right.Search(Data)
}

//      
func (node *Binary) Destroy() {
   if node == nil {
      return
   }
   //           ，      
   node.left.Destroy()
   node.left = nil
   //           ，      
   node.right.Destroy()
   node.right = nil
   node = nil
}

//       
func (node *Binary) Reverse() {
   if node == nil {
      return
   }
   //   Go      ，   、   
   node.left, node.right = node.right, node.left

   //   
   node.left.Reverse()
   node.right.Reverse()
}

//       
func (node *Binary) Copy() *Binary {
   if node == nil {
      return nil
   }
   //        。
   lChild := node.left.Copy()

   //        。
   rChild := node.right.Copy()

   //      
   newNode := new(Binary)
   newNode.Data = node.Data
   newNode.left = lChild
   newNode.right = rChild

   return newNode
}
func NewBinary(){
   node := new(Binary)
   node = node.New(0,[]interface{}{1,2,3,4,5,6,7,8,9})
   node.PrevSort()
}