გაამართლებთ ბინარული ხის ელემენტის ძიების მექანიზმს და როგორ ხორციელდება მისი შემოვლა

ორობით ძებნის ხე (BST) ელემენტის ძებნა შემდეგი გზით ხდება:

1. ვიწყებთ ხის ფესვიდან.
2. ვადარებთ ძებნილ მნიშვნელობას მიმდინარე ნამდვილთან:
   • თუ მნიშვნელობა თანასწორია, ელემენტი იპოვეს.
   • თუ მნიშვნელობა ნაკლებია, გადავდივართ მარცხენა ქვედა ხეზე.
   • თუ მნიშვნელობა მეტია, გადავდივართ მარჯვენა ქვედა ხეზე.
3. ამ პროცესს ვიმეორებთ, სანამ ელემენტს არ ვიპოვით ან მივაღწევთ ცარიელ ნამდვილს (ელემენტი არ არსებობს).

ორობით ხის გადავლა — ეს არის მეთოდი ყველა ნამდვილის სერიული მონახულების. ძირითადი გადავლების ტიპებია:

• In-order (სინტეტიკური): მარცხენა ქვედა ხე → ნამდვილი → მარჯვენა ქვედა ხე. ეს საშუალებას გვაძლევს მივიღოთ ელემენტები სორტირებულ წესში.
• Pre-order (წინასწარი): ნამდვილი → მარცხენა ქვედა ხე → მარჯვენა ქვედა ხე.
• Post-order (შემდგომი): მარცხენა ქვედა ხე → მარჯვენა ქვედა ხე → ნამდვილი.

Go-ში ძებნის და გადავლების მაგალითი:

package main
import "fmt"

type Node struct {
    Value int
    Left, Right *Node
}

func (n *Node) Search(val int) *Node {
    if n == nil || n.Value == val {
        return n
    }
    if val < n.Value {
        return n.Left.Search(val)
    }
    return n.Right.Search(val)
}

func (n *Node) InOrder() {
    if n == nil {
        return
    }
    n.Left.InOrder()
    fmt.Print(n.Value, " ")
    n.Right.InOrder()
}

func main() {
    root := &Node{Value: 10}
    root.Left = &Node{Value: 5}
    root.Right = &Node{Value: 15}

    node := root.Search(5)
    if node != nil {
        fmt.Println("მოძებნული ნამდვილი მნიშვნელობით:", node.Value)
    } else {
        fmt.Println("ელემენტი არ მოიძებნა")
    }

    fmt.Print("In-order გადავლა: ")
    root.InOrder() // გამოტანა: 5 10 15
}