Struct BinaryTree 

pub struct BinaryTree<T> {
    pub root: Option<Box<TreeNode<T>>>,
}

Binar daraxt — har bir tugunning ko’pi bilan 2 ta farzandi bor.

Aylanib chiqishning 4 usuli

       1
     /   \
    2     3
   / \
  4   5

Usul	Tartib	Natija	Qachon kerak
Preorder	Ildiz → Chap → O’ng	1 2 4 5 3	Daraxtni nusxalash/serializatsiya
Inorder	Chap → Ildiz → O’ng	4 2 5 1 3	BST da tartiblangan ketma-ketlik
Postorder	Chap → O’ng → Ildiz	4 5 2 3 1	Daraxtni o’chirish, ifoda hisoblash
Level order	Qavat-qavat	1 / 2 3 / 4 5	Eng qisqa yo’l, qavatlar bilan ishlash

Dastlabki uchtasi — DFS (chuqurlikka), oxirgisi — BFS (kenglikka, navbat bilan).

Misol

use rust_algorithms::tree::{BinaryTree, TreeNode};

//      1
//     / \
//    2   3
//   / \
//  4   5
let daraxt = BinaryTree::from_root(TreeNode::new(
    1,
    Some(TreeNode::new(2, Some(TreeNode::leaf(4)), Some(TreeNode::leaf(5)))),
    Some(TreeNode::leaf(3)),
));

assert_eq!(daraxt.preorder(), vec![&1, &2, &4, &5, &3]);
assert_eq!(daraxt.inorder(), vec![&4, &2, &5, &1, &3]);
assert_eq!(daraxt.postorder(), vec![&4, &5, &2, &3, &1]);
assert_eq!(daraxt.level_order(), vec![vec![&1], vec![&2, &3], vec![&4, &5]]);
assert_eq!(daraxt.height(), 2);
assert_eq!(daraxt.size(), 5);

Fields

root: Option<Box<TreeNode<T>>>

Daraxt ildizi.

Implementations

impl<T> BinaryTree<T>

pub fn new() -> Self

Bo’sh daraxt.

pub fn from_root(root: TreeNode<T>) -> Self

Ildiz tugunidan daraxt yasaydi.

pub fn preorder(&self) -> Vec<&T>

Ildiz → Chap → O’ng.

pub fn inorder(&self) -> Vec<&T>

Chap → Ildiz → O’ng.

pub fn postorder(&self) -> Vec<&T>

Chap → O’ng → Ildiz.

pub fn inorder_iterative(&self) -> Vec<&T>

Inorderning rekursiyasiz varianti — stack bilan.

Chuqur daraxtlarda rekursiya stackni to’ldirishi mumkin; bu variant xavfsiz.

Misol

use rust_algorithms::tree::{BinaryTree, TreeNode};

let t = BinaryTree::from_root(TreeNode::new(
    2, Some(TreeNode::leaf(1)), Some(TreeNode::leaf(3)),
));
assert_eq!(t.inorder_iterative(), t.inorder());

pub fn level_order(&self) -> Vec<Vec<&T>>

Qavatma-qavat (BFS) — har bir qavat alohida vektor.

pub fn height(&self) -> usize

Balandlik: ildizdan eng uzoq bargacha qirralar soni. Bo’sh daraxtda 0.

pub fn size(&self) -> usize

Tugunlar soni.

pub fn leaf_count(&self) -> usize

Barglar (farzandsiz tugunlar) soni.

pub fn invert(&mut self)

Daraxtni “ko’zguga” aylantiradi: chap va o’ng shoxlarni almashtiradi.

Misol

use rust_algorithms::tree::{BinaryTree, TreeNode};

let mut t = BinaryTree::from_root(TreeNode::new(
    1, Some(TreeNode::leaf(2)), Some(TreeNode::leaf(3)),
));
t.invert();
assert_eq!(t.inorder(), vec![&3, &1, &2]);

pub fn is_balanced(&self) -> bool

Daraxt balanslanganmi? (har bir tugunda chap/o’ng balandlik farqi ≤ 1)

Trait Implementations

impl<T: Clone> Clone for BinaryTree<T>

fn clone(&self) -> BinaryTree<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for BinaryTree<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default> Default for BinaryTree<T>

fn default() -> BinaryTree<T>

Returns the “default value” for a type.