Binary Tree เบซเบผเบทเบงเบดเบ—เบตเบเบฒเบ™เบเบฐเบเบฝเบกเบ•เบปเป‰เบ™เป„เบกเป‰เบ„เบปเป‰เบ™เบซเบฒเบ„เบนเปˆ

Prelude

เบšเบปเบ”เบ„เบงเบฒเบกเบ™เบตเป‰เปเบกเปˆเบ™เบเปˆเบฝเบงเบเบฑเบšเบ•เบปเป‰เบ™เป„เบกเป‰เบ„เบปเป‰เบ™เบซเบฒเบ„เบนเปˆ. เบšเปเปˆเบ”เบปเบ™เบกเบฒเบ™เบตเป‰เบ‚เป‰เบฒเบžเบฐเป€เบˆเบปเป‰เบฒเป„เบ”เป‰เป€เบฎเบฑเบ”เบšเบปเบ”เบ„เบงเบฒเบกเบเปˆเบฝเบงเบเบฑเบš เบเบฒเบ™เบšเบตเบšเบญเบฑเบ”เบ‚เปเป‰เบกเบนเบ™เป‚เบ”เบเปƒเบŠเป‰เบงเบดเบ—เบตเบเบฒเบ™ Huffman. เบขเบนเปˆเบ—เบตเปˆเบ™เบฑเป‰เบ™เบ‚เป‰เบญเบเบšเปเปˆเป„เบ”เป‰เป€เบญเบปเบฒเปƒเบˆเปƒเบชเปˆเบซเบผเบฒเบเบเบฑเบšเบ•เบปเป‰เบ™เป„เบกเป‰เบ„เบนเปˆ, เป€เบžเบฒเบฐเบงเปˆเบฒเบงเบดเบ—เบตเบเบฒเบ™เบ„เบปเป‰เบ™เบซเบฒ, เบเบฒเบ™เปƒเบชเปˆ, เปเบฅเบฐเบเบฒเบ™เบฅเบถเบšเปเบกเปˆเบ™เบšเปเปˆเบเปˆเบฝเบงเบ‚เป‰เบญเบ‡. เบ•เบญเบ™เบ™เบตเป‰เบ‚เป‰เบญเบเบ•เบฑเบ”เบชเบดเบ™เปƒเบˆเบ‚เบฝเบ™เบšเบปเบ”เบ„เบงเบฒเบกเบเปˆเบฝเบงเบเบฑเบšเบ•เบปเป‰เบ™เป„เบกเป‰. เปƒเบซเป‰เป€เบฅเบตเปˆเบกเบ•เบปเป‰เบ™.

เบ•เบปเป‰เบ™เป„เบกเป‰เปเบกเปˆเบ™เป‚เบ„เบ‡เบชเป‰เบฒเบ‡เบ‚เปเป‰เบกเบนเบ™เบ—เบตเปˆเบ›เบฐเบเบญเบšเบ”เป‰เบงเบเบ‚เปเป‰เบ—เบตเปˆเป€เบŠเบทเปˆเบญเบกเบ•เปเปˆเบเบฑเบ™เบ”เป‰เบงเบเบ‚เบญเบš. เบžเบงเบเป€เบฎเบปเบฒเบชเบฒเบกเบฒเบ”เป€เบงเบปเป‰เบฒเป„เบ”เป‰เบงเปˆเบฒเบ•เบปเป‰เบ™เป„เบกเป‰เป€เบ›เบฑเบ™เบเปเบฅเบฐเบ™เบตเบžเบดเป€เบชเบ”เบ‚เบญเบ‡เบเบฒเบŸ. เบ™เบตเป‰เปเบกเปˆเบ™เบ•เบปเบงเบขเปˆเบฒเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰:

Binary Tree เบซเบผเบทเบงเบดเบ—เบตเบเบฒเบ™เบเบฐเบเบฝเบกเบ•เบปเป‰เบ™เป„เบกเป‰เบ„เบปเป‰เบ™เบซเบฒเบ„เบนเปˆ

เบ™เบตเป‰เบšเปเปˆเปเบกเปˆเบ™เบ•เบปเป‰เบ™เป„เบกเป‰เบŠเบญเบเบซเบฒเบ„เบนเปˆ! เบ—เบธเบเบขเปˆเบฒเบ‡เบ–เบทเบเบ•เบฑเบ”!

Terminology

เบฎเบฒเบ

เบฎเบฒเบเบ•เบปเป‰เบ™เป„เบกเป‰ - เบ™เบตเป‰เปเบกเปˆเบ™เบ‚เปเป‰เบชเบนเบ‡เบชเบธเบ”เบ‚เบญเบ‡เบกเบฑเบ™. เปƒเบ™เบ•เบปเบงเบขเปˆเบฒเบ‡, เบ™เบตเป‰เปเบกเปˆเบ™ node A. เปƒเบ™เบ•เบปเป‰เบ™เป„เบกเป‰, เบžเบฝเบ‡เปเบ•เปˆเป€เบชเบฑเป‰เบ™เบ—เบฒเบ‡เบ”เบฝเบงเบชเบฒเบกเบฒเบ”เบ™เปเบฒเบˆเบฒเบเบฎเบฒเบเป„เบ›เบซเบฒเบ‚เปเป‰เบญเบทเปˆเบ™เป†! เปƒเบ™เบ„เบงเบฒเบกเป€เบ›เบฑเบ™เบˆเบดเบ‡, node เปƒเบ”เบชเบฒเบกเบฒเบ”เบ–เบทเบเบžเบดเบˆเบฒเบฅเบฐเบ™เบฒเป€เบ›เบฑเบ™เบฎเบฒเบเบ‚เบญเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰เบเปˆเบญเบเบ—เบตเปˆเบชเบญเบ”เบ„เป‰เบญเบ‡เบเบฑเบ™เบเบฑเบš node เบ™เบตเป‰.

เบžเปเปˆเปเบกเปˆ/เบฅเบนเบเบซเบฅเบฒเบ™

เบ—เบธเบเป† nodes เบเบปเบเป€เบงเบฑเป‰เบ™ root เบกเบตเปเบ‚เบšเบญเบฑเบ™เบ”เบฝเบงเบ—เบตเปˆเบ™เปเบฒเป„เบ›เบชเบนเปˆ node เบญเบทเปˆเบ™. เป‚เบซเบ™เบ”เบ—เบตเปˆเบขเบนเปˆเบ‚เป‰เบฒเบ‡เป€เบ—เบดเบ‡เบ‚เบญเบ‡เบ›เบฐเบˆเบธเบšเบฑเบ™เปเบกเปˆเบ™เป€เบญเบตเป‰เบ™เบงเปˆเบฒ เบžเปเปˆเปเบกเปˆ node เบ™เบตเป‰. เป‚เบซเบ™เบ”เบ—เบตเปˆเบขเบนเปˆเบ‚เป‰เบฒเบ‡เบฅเบธเปˆเบกเบ‚เบญเบ‡เบ›เบฐเบˆเบธเบšเบฑเบ™เปเบฅเบฐเป€เบŠเบทเปˆเบญเบกเบ•เปเปˆเบเบฑเบšเบกเบฑเบ™เบ–เบทเบเป€เบญเบตเป‰เบ™เบงเปˆเบฒ เป€เบŠเบทเป‰เบญเบชเบฒเบ node เบ™เบตเป‰. เปƒเบซเป‰เปƒเบŠเป‰เบ•เบปเบงเบขเปˆเบฒเบ‡. เปƒเบซเป‰เป€เบญเบปเบฒ node B, เบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™เบžเปเปˆเปเบกเปˆเบ‚เบญเบ‡เบกเบฑเบ™เบˆเบฐเป€เบ›เบฑเบ™ node A, เปเบฅเบฐเบฅเบนเบเบ‚เบญเบ‡เบกเบฑเบ™เบˆเบฐเป€เบ›เบฑเบ™ nodes D, E เปเบฅเบฐ F.

Leaf

เบ‚เปเป‰เบ—เบตเปˆเบšเปเปˆเบกเบตเบฅเบนเบเบˆเบฐเบ–เบทเบเป€เบญเบตเป‰เบ™เบงเปˆเบฒเปƒเบšเบ‚เบญเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰. เปƒเบ™เบ•เบปเบงเบขเปˆเบฒเบ‡, เปƒเบšเบˆเบฐเป€เบ›เบฑเบ™ nodes D, E, F, G, I, J, K.

เบ™เบตเป‰เปเบกเปˆเบ™ เบ„เบณ เบชเบฑเบšเบžเบทเป‰เบ™เบ–เบฒเบ™. เปเบ™เบงเบ„เบงเบฒเบกเบ„เบดเบ”เบญเบทเปˆเบ™เป†เบˆเบฐเบ–เบทเบเบ›เบถเบเบชเบฒเบซเบฒเบฅเบทเบ•เบทเปˆเบกเบญเบตเบ. เบ”เบฑเปˆเบ‡เบ™เบฑเป‰เบ™, เบ•เบปเป‰เบ™เป„เบกเป‰เบ„เบนเปˆเปเบกเปˆเบ™เบ•เบปเป‰เบ™เป„เบกเป‰เบ—เบตเปˆเปเบ•เปˆเบฅเบฐ node เบˆเบฐเบกเบตเบฅเบนเบเบšเปเปˆเป€เบเบตเบ™เบชเบญเบ‡เบ„เบปเบ™. เบ•เบฒเบกเบ—เบตเปˆเบ—เปˆเบฒเบ™เบ„เบฒเบ”เป€เบ”เบปเบฒ, เบ•เบปเป‰เบ™เป„เบกเป‰เบˆเบฒเบเบ•เบปเบงเบขเปˆเบฒเบ‡เบˆเบฐเบšเปเปˆเป€เบ›เบฑเบ™เบ„เบนเปˆ, เป€เบžเบฒเบฐเบงเปˆเบฒ nodes B เปเบฅเบฐ H เบกเบตเบซเบผเบฒเบเบเบงเปˆเบฒเบชเบญเบ‡เบฅเบนเบ. เบ™เบตเป‰เปเบกเปˆเบ™เบ•เบปเบงเบขเปˆเบฒเบ‡เบ‚เบญเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰เบ„เบนเปˆ:

Binary Tree เบซเบผเบทเบงเบดเบ—เบตเบเบฒเบ™เบเบฐเบเบฝเบกเบ•เบปเป‰เบ™เป„เบกเป‰เบ„เบปเป‰เบ™เบซเบฒเบ„เบนเปˆ

เบ‚เปเป‰เบ‚เบญเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰เบชเบฒเบกเบฒเบ”เบกเบตเบ‚เปเป‰เบกเบนเบ™เปƒเบ”เป†. เบ•เบปเป‰เบ™โ€‹เป„เบกเป‰โ€‹เบ„เบปเป‰เบ™โ€‹เบซเบฒโ€‹เบ–เบฒเบ™โ€‹เบชเบญเบ‡โ€‹เป€เบ›เบฑเบ™โ€‹เบ•เบปเป‰เบ™โ€‹เป„เบกเป‰โ€‹เบ„เบนเปˆโ€‹เบ—เบตเปˆโ€‹เบกเบตโ€‹เบ„เบธเบ™โ€‹เบชเบปเบกโ€‹เบšเบฑเบ”โ€‹เบ”เบฑเปˆเบ‡โ€‹เบ•เปเปˆโ€‹เป„เบ›โ€‹เบ™เบตเป‰โ€‹:

  1. เบ—เบฑเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰เบเปˆเบญเบเบŠเป‰เบฒเบเปเบฅเบฐเบ‚เบงเบฒเปเบกเปˆเบ™เบ•เบปเป‰เบ™เป„เบกเป‰เบ„เบปเป‰เบ™เบซเบฒเบ„เบนเปˆ.
  2. nodes เบ—เบฑเบ‡เบซเบกเบปเบ”เบ‚เบญเบ‡ subtree เบŠเป‰เบฒเบเบ‚เบญเบ‡ node arbitrary X เบกเบตเบกเบนเบ™เบ„เปˆเบฒเบ—เบตเปˆเบชเปเบฒเบ„เบฑเบ™เบ‚เปเป‰เบกเบนเบ™เบซเบ™เป‰เบญเบเบเปˆเบงเบฒเบกเบนเบ™เบ„เปˆเบฒเบ‚เบญเบ‡เบ‚เปเป‰เบกเบนเบ™เบ‚เบญเบ‡ node X เบ•เบปเบงเบ‚เบญเบ‡เบกเบฑเบ™เป€เบญเบ‡.
  3. เบ—เบธเบเป† nodes เปƒเบ™ subtree เบ—เบตเปˆเบ–เบทเบเบ•เป‰เบญเบ‡เบ‚เบญเบ‡ node X arbitrary เบกเบตเบกเบนเบ™เบ„เปˆเบฒเบ‚เปเป‰เบกเบนเบ™เบ—เบตเปˆเบชเปเบฒเบ„เบฑเบ™เบซเบผเบฒเบเบเปˆเบงเบฒเบซเบผเบทเป€เบ—เบปเปˆเบฒเบเบฑเบšเบกเบนเบ™เบ„เปˆเบฒเบ‚เบญเบ‡เบ‚เปเป‰เบกเบนเบ™เบ‚เบญเบ‡ node X เบ•เบปเบงเบ‚เบญเบ‡เบกเบฑเบ™เป€เบญเบ‡.

Key โ€” เบฅเบฑเบโ€‹เบชเบฐโ€‹เบ™เบฐโ€‹เปƒเบ”โ€‹เบซเบ™เบถเปˆเบ‡โ€‹เบ‚เบญเบ‡ node (เบชเปเบฒโ€‹เบฅเบฑเบšโ€‹เบ•เบปเบงโ€‹เบขเปˆเบฒเบ‡โ€‹, เบˆเปเบฒโ€‹เบ™เบงเบ™โ€‹เบซเบ™เบถเปˆเบ‡โ€‹)โ€‹. เบเบธเบ™เปเบˆเปเบกเปˆเบ™เบˆเปเบฒเป€เบ›เบฑเบ™เป€เบžเบทเปˆเบญเปƒเบซเป‰เป€เบˆเบปเป‰เบฒเบชเบฒเบกเบฒเบ”เบŠเบญเบเบซเบฒเบญเบปเบ‡เบ›เบฐเบเบญเบšเบ•เบปเป‰เบ™เป„เบกเป‰เบ—เบตเปˆเบเบฐเปเบˆเบ™เบตเป‰เบเบปเบ‡เบเบฑเบ™. เบ•เบปเบงเบขเปˆเบฒเบ‡เบ‚เบญเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰เบŠเบญเบเบซเบฒเบ„เบนเปˆ:

Binary Tree เบซเบผเบทเบงเบดเบ—เบตเบเบฒเบ™เบเบฐเบเบฝเบกเบ•เบปเป‰เบ™เป„เบกเป‰เบ„เบปเป‰เบ™เบซเบฒเบ„เบนเปˆ

เบ—เบฑเบ”เบชเบฐเบ™เบฐเบ•เบปเป‰เบ™เป„เบกเป‰

เปƒเบ™เบ‚เบฐเบ™เบฐเบ—เบตเปˆเบžเบงเบเป€เบฎเบปเบฒเบกเบตเบ„เบงเบฒเบกเบ„เบทเบšเบซเบ™เป‰เบฒ, เบ‚เป‰เบฒเบžเบฐเป€เบˆเบปเป‰เบฒเบˆเบฐเบชเบฐเบซเบ™เบญเบ‡เบšเบฒเบ‡เบชเปˆเบงเบ™ (เบญเบฒเบ”เบˆเบฐเบšเปเปˆเบ„เบปเบšเบ–เป‰เบงเบ™) เบ‚เบญเบ‡เบฅเบฐเบซเบฑเบ”เป€เบžเบทเปˆเบญเบ›เบฑเบšเบ›เบธเบ‡เบ„เบงเบฒเบกเป€เบ‚เบปเป‰เบฒเปƒเบˆเบ‚เบญเบ‡เบ—เปˆเบฒเบ™. เบฅเบฐเบซเบฑเบ”เป€เบ•เบฑเบกเบˆเบฐเบขเบนเปˆเปƒเบ™เบ•เบญเบ™เบ—เป‰เบฒเบเบ‚เบญเบ‡เบšเบปเบ”เบ„เบงเบฒเบก.

เบ•เบปเป‰เบ™เป„เบกเป‰เบ›เบฐเบเบญเบšเบ”เป‰เบงเบเบ‚เปเป‰. เป‚เบ„เบ‡เบชเป‰เบฒเบ‡เบ‚เบญเบ‡เป‚เบ™เบ”:

public class Node<T> {
    private T data;
    private int key;
    private Node<T> leftChild;
    private Node<T> rightChild;

    public Node(T data, int key) {
        this.data = data;
        this.key = key;
    }
    public Node<T> getLeftChild() {
        return leftChild;
    }

    public Node<T> getRightChild() {
        return rightChild;
    }
//...ะพัั‚ะฐะปัŒะฝั‹ะต ะผะตั‚ะพะดั‹ ัƒะทะปะฐ
}

เปเบ•เปˆเบฅเบฐ node เบกเบตเบชเบญเบ‡เบฅเบนเบ (เบกเบฑเบ™เป€เบ›เบฑเบ™เป„เบ›เป„เบ”เป‰เบ‚เป‰เบญเบ™เบ‚เป‰เบฒเบ‡เบงเปˆเบฒเบฅเบนเบเบŠเป‰เบฒเบเปเบฅเบฐ/เบซเบผเบทเบฅเบนเบเบ‚เบงเบฒเบˆเบฐเบกเบตเบ„เปˆเบฒ null). เบ—เปˆเบฒเบ™เบญเบฒเบ”เบˆเบฐเบฎเบนเป‰เบงเปˆเบฒเปƒเบ™เบเปเบฅเบฐเบ™เบตเบ™เบตเป‰เบ‚เปเป‰เบกเบนเบ™เบ•เบปเบงเป€เบฅเบเปเบกเปˆเบ™เบ‚เปเป‰เบกเบนเบ™เบ—เบตเปˆเป€เบเบฑเบšเป„เบงเป‰เปƒเบ™ node; key โ€” node key.

เบžเบงเบเป€เบฎเบปเบฒเป„เบ”เป‰เบ„เบฑเบ”เบญเบญเบ knot, เปƒเบ™เบ›เบฑเบ”เบˆเบธเบšเบฑเบ™เปƒเบซเป‰เป€เบงเบปเป‰เบฒเบเปˆเบฝเบงเบเบฑเบšเบเบฒเบ™เบเบปเบ”เบ”เบฑเบ™เบšเบฑเบ™เบซเบฒเบเปˆเบฝเบงเบเบฑเบšเบ•เบปเป‰เบ™เป„เบกเป‰. เบ•เปเปˆเป„เบ›เบ™เบตเป‰, เป‚เบ”เบเบ„เปเบฒเบงเปˆเบฒ "เบ•เบปเป‰เบ™เป„เบกเป‰" เบ‚เป‰เบฒเบžเบฐเป€เบˆเบปเป‰เบฒเบˆเบฐเบซเบกเบฒเบเป€เบ–เบดเบ‡เปเบ™เบงเบ„เบงเบฒเบกเบ„เบดเบ”เบ‚เบญเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰เบ„เบปเป‰เบ™เบซเบฒเบ„เบนเปˆ. เป‚เบ„เบ‡โ€‹เบชเป‰เบฒเบ‡โ€‹เบ•เบปเป‰เบ™โ€‹เป„เบกเป‰โ€‹เบชเบญเบ‡โ€‹:

public class BinaryTree<T> {
     private Node<T> root;

    //ะผะตั‚ะพะดั‹ ะดะตั€ะตะฒะฐ
}

เบžเบงเบเป€เบฎเบปเบฒเบ•เป‰เบญเบ‡เบเบฒเบ™เบžเบฝเบ‡เปเบ•เปˆเบฎเบฒเบเบ‚เบญเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰เป€เบ›เบฑเบ™เบžเบฒเบเบชเบฐเบซเบ™เบฒเบก, เป€เบžเบฒเบฐเบงเปˆเบฒเบˆเบฒเบเบฎเบฒเบ, เบเบฒเบ™เบ™เปเบฒเปƒเบŠเป‰เบงเบดเบ—เบตเบเบฒเบ™ getLeftChild() เปเบฅเบฐ getRightChild(), เบ—เปˆเบฒเบ™เบชเบฒเบกเบฒเบ”เป„เบ›เบซเบฒ node เปƒเบ”เปƒเบ™เบ•เบปเป‰เบ™เป„เบกเป‰.

เบชเบนเบ”เบเบฒเบ™เบ„เบดเบ”เป„เบฅเปˆเปƒเบ™เบ•เบปเป‰เบ™เป„เบกเป‰

ะŸะพะธัะบ

เปƒเบซเป‰เป€เบงเบปเป‰เบฒเบงเปˆเบฒเบ—เปˆเบฒเบ™เบกเบตเบ•เบปเป‰เบ™เป„เบกเป‰เบเปเปˆเบชเป‰เบฒเบ‡. เบงเบดเบ—เบตเบเบฒเบ™เบŠเบญเบเบซเบฒเบญเบปเบ‡เบ›เบฐเบเบญเบšเบ—เบตเปˆเบกเบตเบ„เบตเบ—เบตเปˆเบชเปเบฒเบ„เบฑเบ™? เบ—เปˆเบฒเบ™เบˆเปเบฒเป€เบ›เบฑเบ™เบ•เป‰เบญเบ‡เป„เบ”เป‰เบเป‰เบฒเบเบ•เบฒเบกเบฅเปเบฒเบ”เบฑเบšเบˆเบฒเบเบฎเบฒเบเบฅเบปเบ‡เบฅเบธเปˆเบกเบ•เบปเป‰เบ™เป„เบกเป‰เปเบฅเบฐเบ›เบฝเบšเบ—เบฝเบšเบกเบนเบ™เบ„เปˆเบฒเบ‚เบญเบ‡เบ„เบตเบเบฑเบšเบเบธเบ™เปเบˆเบ‚เบญเบ‡เป‚เบซเบ™เบ”เบ•เปเปˆเป„เบ›: เบ–เป‰เบฒเบ„เบตเปเบกเปˆเบ™เบซเบ™เป‰เบญเบเบเบงเปˆเบฒเบเบฐเปเบˆเบ‚เบญเบ‡เป‚เบซเบ™เบ”เบ•เปเปˆเป„เบ›, เบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™เป„เบ›เบซเบฒเบฅเบนเบเบซเบฅเบฒเบ™เบŠเป‰เบฒเบเบ‚เบญเบ‡เป‚เบซเบ™เบ”, เบ–เป‰เบฒเบกเบฑเบ™เป€เบ›เบฑเบ™. เบเบดเปˆเบ‡เปƒเบซเบเปˆเบเบงเปˆเบฒ, เป„เบ›เบ—เบฒเบ‡เบ‚เบงเบฒ, เบ–เป‰เบฒเบเบฐเปเบˆเปเบกเปˆเบ™เป€เบ—เบปเปˆเบฒเบเบฑเบ™, เป‚เบ™เบ”เบ—เบตเปˆเบ•เป‰เบญเบ‡เบเบฒเบ™เบˆเบฐเบžเบปเบšเป€เบซเบฑเบ™! เบฅเบฐเบซเบฑเบ”เบ—เบตเปˆเบเปˆเบฝเบงเบ‚เป‰เบญเบ‡:

public Node<T> find(int key) {
    Node<T> current = root;
    while (current.getKey() != key) {
        if (key < current.getKey())
            current = current.getLeftChild();
        else
            current = current.getRightChild();
        if (current == null)
            return null;
    }
    return current;
}

เบ–เป‰เบฒเบ›เบฐเบˆเบธเบšเบฑเบ™เบเบฒเบเป€เบ›เบฑเบ™ null, เบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™, เบเบฒเบ™เบ„เบปเป‰เบ™เบซเบฒเป„เบ”เป‰เบกเบฒเบฎเบญเบ”เบˆเบธเบ”เบชเบดเป‰เบ™เบชเบธเบ”เบ‚เบญเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰ (เปƒเบ™เบฅเบฐเบ”เบฑเบšเปเบ™เบงเบ„เบงเบฒเบกเบ„เบดเบ”, เบ—เปˆเบฒเบ™เบขเบนเปˆเปƒเบ™เบชเบฐเบ–เบฒเบ™เบ—เบตเปˆเบ—เบตเปˆเบšเปเปˆเบกเบตเบขเบนเปˆเปƒเบ™เบ•เบปเป‰เบ™เป„เบกเป‰ - เป€เบ›เบฑเบ™เบฅเบนเบเบซเบฅเบฒเบ™เบ‚เบญเบ‡เปƒเบš).

เปƒเบซเป‰เบžเบดเบˆเบฒเบฅเบฐเบ™เบฒเบ›เบฐเบชเบดเบ”เบ—เบดเบžเบฒเบšเบ‚เบญเบ‡เบงเบดเบ—เบตเบเบฒเบ™เบ„เบปเป‰เบ™เบซเบฒเปƒเบ™เบ•เบปเป‰เบ™เป„เบกเป‰เบ—เบตเปˆเบชเบปเบกเบ”เบนเบ™ (เบ•เบปเป‰เบ™เป„เบกเป‰เบ—เบตเปˆ nodes เบ–เบทเบเปเบˆเบเบขเบฒเบเบซเบผเบฒเบเบซเบผเบทเบซเบ™เป‰เบญเบเป€เบ—เบปเปˆเบฒเบ—เบฝเบกเบเบฑเบ™). เบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™, เบ›เบฐเบชเบดเบ”เบ—เบดเบžเบฒเบšเบเบฒเบ™เบŠเบญเบเบซเบฒเบˆเบฐเป€เบ›เบฑเบ™ O(log(n)), เปเบฅเบฐ logarithm เปเบกเปˆเบ™เบ–เบฒเบ™ 2. เป€เบšเบดเปˆเบ‡: เบ–เป‰เบฒเบกเบตเบญเบปเบ‡เบ›เบฐเบเบญเบš n เปƒเบ™เบ•เบปเป‰เบ™เป„เบกเป‰เบ—เบตเปˆเบชเบปเบกเบ”เบนเบ™, เบ™เบตเป‰เบซเบกเบฒเบเบ„เบงเบฒเบกเบงเปˆเบฒเบˆเบฐเบกเบต log(n) เบžเบทเป‰เบ™เบ–เบฒเบ™ 2 เบฅเบฐเบ”เบฑเบšเบ‚เบญเบ‡. เบ•เบปเป‰เบ™เป„เบกเป‰. เปเบฅเบฐเปƒเบ™เบเบฒเบ™เบŠเบญเบเบซเบฒ, เปƒเบ™เบ‚เบฑเป‰เบ™เบ•เบญเบ™เบซเบ™เบถเปˆเบ‡เบ‚เบญเบ‡เบงเบปเบ‡เบˆเบญเบ™, เบ—เปˆเบฒเบ™เบฅเบปเบ‡เป„เบ›เบซเบ™เบถเปˆเบ‡เบฅเบฐเบ”เบฑเบš.

เบชเบฐเปเบ”เบ‡เบเบดเปˆเบ‡เบ‡เปˆเบฒ

เบ–เป‰เบฒเบ—เปˆเบฒเบ™เป€เบ‚เบปเป‰เบฒเปƒเบˆเบ„เบงเบฒเบกเบชเปเบฒเบ„เบฑเบ™เบ‚เบญเบ‡เบเบฒเบ™เบ„เบปเป‰เบ™เบซเบฒ, เบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™เบเบฒเบ™เป€เบ‚เบปเป‰เบฒเปƒเบˆเบเบฒเบ™เปƒเบชเปˆเบˆเบฐเบšเปเปˆเบเบฒเบเบชเปเบฒเบฅเบฑเบšเบ—เปˆเบฒเบ™. เบ—เปˆเบฒเบ™เบžเบฝเบ‡เปเบ•เปˆเบ•เป‰เบญเบ‡เบเบฒเบ™เบฅเบปเบ‡เป„เบ›เบซเบฒเปƒเบšเบ‚เบญเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰ (เบ•เบฒเบกเบเบปเบ”เบฅเบฐเบšเบฝเบšเบเบฒเบ™เบชเบทเบšเป€เบŠเบทเป‰เบญเบชเบฒเบเบ—เบตเปˆเป„เบ”เป‰เบญเบฐเบ—เบดเบšเบฒเบเป„เบงเป‰เปƒเบ™เบเบฒเบ™เบ„เบปเป‰เบ™เบซเบฒ) เปเบฅเบฐเบเบฒเบเป€เบ›เบฑเบ™เบฅเบนเบเบซเบฅเบฒเบ™เบ‚เบญเบ‡เบกเบฑเบ™ - เบŠเป‰เบฒเบเบซเบผเบทเบ‚เบงเบฒ, เบ‚เบถเป‰เบ™เบเบฑเบšเบ„เบต. เบเบฒเบ™เบˆเบฑเบ”เบ•เบฑเป‰เบ‡เบ›เบฐเบ•เบดเบšเบฑเบ”:

   public void insert(T insertData, int key) {
        Node<T> current = root;
        Node<T> parent;
        Node<T> newNode = new Node<>(insertData, key);
        if (root == null)
            root = newNode;
        else {
            while (true) {
                parent = current;
                if (key < current.getKey()) {
                    current = current.getLeftChild();
                    if (current == null) {
                         parent.setLeftChild(newNode);
                         return;
                    }
                }
                else {
                    current = current.getRightChild();
                    if (current == null) {
                        parent.setRightChild(newNode);
                        return;
                    }
                }
            }
        }
    }

เปƒเบ™เบเปเบฅเบฐเบ™เบตเบ™เบตเป‰, เบ™เบญเบเป€เบซเบ™เบทเบญเบˆเบฒเบ node เปƒเบ™เบ›เบฑเบ”เบˆเบธเบšเบฑเบ™, เบกเบฑเบ™เบˆเปเบฒเป€เบ›เบฑเบ™เบ•เป‰เบญเบ‡เป€เบเบฑเบšเบฎเบฑเบเบชเบฒเบ‚เปเป‰เบกเบนเบ™เบเปˆเบฝเบงเบเบฑเบš parent เบ‚เบญเบ‡ node เบ›เบฐเบˆเบธเบšเบฑเบ™. เป€เบกเบทเปˆเบญเบ›เบฑเบ”เบˆเบธเบšเบฑเบ™เบเบฒเบเป€เบ›เบฑเบ™ null, เบ•เบปเบงเปเบ›เบซเบผเบฑเบเบˆเบฐเบกเบตเบŠเบตเบ”เบ—เบตเปˆเบžเบงเบเป€เบฎเบปเบฒเบ•เป‰เบญเบ‡เบเบฒเบ™.
เบ›เบฐเบชเบดเบ”เบ—เบดเบžเบฒเบšเบ‚เบญเบ‡เบเบฒเบ™เปเบŠเบเปเบกเปˆเบ™เปเบ™เปˆเบ™เบญเบ™เบ„เบทเบเบฑเบ™เบเบฑเบšเบเบฒเบ™เบ„เบปเป‰เบ™เบซเบฒ - O(log(n)).

เบฅเบปเบš

เบเบฒเบ™เป‚เบเบเบเป‰เบฒเบเปเบกเปˆเบ™เบเบฒเบ™เบ”เปเบฒเป€เบ™เบตเบ™เบ‡เบฒเบ™เบ—เบตเปˆเบเบฒเบเบ—เบตเปˆเบชเบธเบ”เบ—เบตเปˆเบˆเบฐเบ•เป‰เบญเบ‡เป„เบ”เป‰เบ›เบฐเบ•เบดเบšเบฑเบ”เบขเบนเปˆเป€เบ—เบดเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰. เบกเบฑเบ™เป€เบ›เบฑเบ™เบ—เบตเปˆเบŠเบฑเบ”เป€เบˆเบ™เบงเปˆเบฒเบ—เปเบฒเบญเบดเบ”เบžเบงเบเป€เบฎเบปเบฒเบˆเบฐเบ•เป‰เบญเบ‡เบŠเบญเบเบซเบฒเบญเบปเบ‡เบ›เบฐเบเบญเบšเบ—เบตเปˆเบžเบงเบเป€เบฎเบปเบฒเบˆเบฐเบฅเบถเบš. เปเบ•เปˆเบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™เปเบกเปˆเบ™เบซเบเบฑเบ‡? เบ–เป‰เบฒเบžเบงเบเป€เบฎเบปเบฒเบžเบฝเบ‡เปเบ•เปˆเบ•เบฑเป‰เบ‡เบเบฒเบ™เบญเป‰เบฒเบ‡เบญเบตเบ‡เบ‚เบญเบ‡เบกเบฑเบ™เป€เบ›เบฑเบ™ null, เบžเบงเบเป€เบฎเบปเบฒเบˆเบฐเบชเบนเบ™เป€เบชเบเบ‚เปเป‰เบกเบนเบ™เบเปˆเบฝเบงเบเบฑเบšเบ•เบปเป‰เบ™เป„เบกเป‰เบเปˆเบญเบเบ—เบตเปˆ node เบ™เบตเป‰เปเบกเปˆเบ™เบฎเบฒเบ. เบงเบดเบ—เบตเบเบฒเบ™เบเปเบฒเบˆเบฑเบ”เบ•เบปเป‰เบ™เป„เบกเป‰เปเบšเปˆเบ‡เบญเบญเบเป€เบ›เบฑเบ™เบชเบฒเบกเบเปเบฅเบฐเบ™เบต.

เบเปเบฅเบฐเบ™เบตเบ—เปเบฒเบญเบดเบ”. เป‚เบ™เบ”เบ—เบตเปˆเบ–เบทเบเบฅเบถเบšเบšเปเปˆเบกเบตเบฅเบนเบ

เบ–เป‰เบฒเบ‚เปเป‰เบ—เบตเปˆเบ–เบทเบเบฅเบถเบšเบšเปเปˆเบกเบตเบฅเบนเบ, เบ™เบตเป‰เบซเบกเบฒเบเบ„เบงเบฒเบกเบงเปˆเบฒเบกเบฑเบ™เป€เบ›เบฑเบ™เปƒเบš. เบ”เบฑเปˆเบ‡เบ™เบฑเป‰เบ™, เบ—เปˆเบฒเบ™เบžเบฝเบ‡เปเบ•เปˆเบชเบฒเบกเบฒเบ”เบเปเบฒเบ™เบปเบ”เบŠเปˆเบญเบ‡เบŠเป‰เบฒเบเบฅเบนเบเบซเบผเบทเบ‚เบงเบฒเป€เบ”เบฑเบเบ‚เบญเบ‡เบžเปเปˆเปเบกเปˆเบ‚เบญเบ‡เบ•เบปเบ™เป€เบ›เบฑเบ™ null.

เบเปเบฅเบฐเบ™เบตเบ—เบตเบชเบญเบ‡. เป‚เบซเบ™เบ”เบ—เบตเปˆเบˆเบฐเบฅเบถเบšเบกเบตเบฅเบนเบเปœเบถเปˆเบ‡เบญเบฑเบ™

เบเปเบฅเบฐเบ™เบตเบ™เบตเป‰เบเบฑเบ‡เบšเปเปˆเบชเบฑเบšเบชเบปเบ™เบซเบผเบฒเบ. เปƒเบซเป‰เบเบฑเบšเบ„เบทเบ™เป„เบ›เบซเบฒเบ•เบปเบงเบขเปˆเบฒเบ‡เบ‚เบญเบ‡เบžเบงเบเป€เบฎเบปเบฒ. เบชเบปเบกเบกเบธเบ”เบงเปˆเบฒเบžเบงเบเป€เบฎเบปเบฒเบ•เป‰เบญเบ‡เบเบฒเบ™เบฅเบถเบšเบญเบปเบ‡เบ›เบฐเบเบญเบšเบ—เบตเปˆเบกเบตเบ„เบต 14. เบ•เบปเบเบฅเบปเบ‡เป€เบซเบฑเบ™เบ”เบตเบงเปˆเบฒเป€เบ™เบทเปˆเบญเบ‡เบˆเบฒเบเบกเบฑเบ™เป€เบ›เบฑเบ™เบฅเบนเบเบซเบฅเบฒเบ™เบ—เบตเปˆเบ–เบทเบเบ•เป‰เบญเบ‡เบ‚เบญเบ‡เป‚เบซเบ™เบ”เบ—เบตเปˆเบกเบตเบเบธเบ™เปเบˆ 10, เบ”เบฑเปˆเบ‡เบ™เบฑเป‰เบ™เบฅเบนเบเบซเบฅเบฒเบ™เบ‚เบญเบ‡เบกเบฑเบ™ (เปƒเบ™เบเปเบฅเบฐเบ™เบตเบ™เบตเป‰เปเบกเปˆเบ™เบญเบฑเบ™เบ—เบตเปˆเบ–เบทเบเบ•เป‰เบญเบ‡) เบˆเบฐเบกเบตเบฅเบฐเบซเบฑเบ”เปƒเบซเบเปˆเบเบงเปˆเบฒ 10, เบ”เบฑเปˆเบ‡เบ™เบฑเป‰เบ™เป€เบˆเบปเป‰เบฒ. เบชเบฒเบกเบฒเบ” "เบ•เบฑเบ”" เบกเบฑเบ™เบญเบญเบเบˆเบฒเบเบ•เบปเป‰เบ™เป„เบกเป‰เป„เบ”เป‰เบขเปˆเบฒเบ‡เบ‡เปˆเบฒเบเบ”เบฒเบ, เปเบฅเบฐเป€เบŠเบทเปˆเบญเบกเบ•เปเปˆเบžเปเปˆเปเบกเปˆเป‚เบ”เบเบเบปเบ‡เบเบฑเบšเบฅเบนเบเบ‚เบญเบ‡ node เบ—เบตเปˆเบ–เบทเบเบฅเบถเบš, i.e. เป€เบŠเบทเปˆเบญเบกเบ•เปเปˆ node เบเบฑเบš key 10 เบเบฑเบš node 13. เบชเบฐเบ–เบฒเบ™เบฐเบเบฒเบ™เบˆเบฐเบ„เป‰เบฒเบเบ„เบทเบเบฑเบ™เบ–เป‰เบฒเบกเบฑเบ™เบˆเปเบฒเป€เบ›เบฑเบ™เบ•เป‰เบญเบ‡เบฅเบถเบš node เบ—เบตเปˆเป€เบ›เบฑเบ™เบฅเบนเบเบŠเป‰เบฒเบเบ‚เบญเบ‡เบžเปเปˆเปเบกเปˆเบ‚เบญเบ‡เบกเบฑเบ™. เบ„เบดเบ”เบเปˆเบฝเบงเบเบฑเบšเบกเบฑเบ™เบ•เบปเบงเบ—เปˆเบฒเบ™เป€เบญเบ‡ - เบเบฒเบ™เบ›เบฝเบšเบ—เบฝเบšเบ—เบตเปˆเปเบ™เปˆเบ™เบญเบ™.

เบเปเบฅเบฐเบ™เบตเบ—เบตเบชเบฒเบก. A node เบกเบตเบชเบญเบ‡เบฅเบนเบ

เบเปเบฅเบฐเบ™เบตเบ—เบตเปˆเบเบฒเบเบ—เบตเปˆเบชเบธเบ”. เปƒเบซเป‰เป€เบšเบดเปˆเบ‡เบ•เบปเบงเบขเปˆเบฒเบ‡เปƒเบซเบกเปˆ.

Binary Tree เบซเบผเบทเบงเบดเบ—เบตเบเบฒเบ™เบเบฐเบเบฝเบกเบ•เบปเป‰เบ™เป„เบกเป‰เบ„เบปเป‰เบ™เบซเบฒเบ„เบนเปˆ

เบŠเบญเบเบซเบฒเบœเบนเป‰เบชเบทเบšเบ—เบญเบ”

เบชเบปเบกเบกเบธเบ”เบงเปˆเบฒเบžเบงเบเป€เบฎเบปเบฒเบˆเปเบฒเป€เบ›เบฑเบ™เบ•เป‰เบญเบ‡เบฅเบถเบš node เบ—เบตเปˆเบกเบต key 25. เบžเบงเบเป€เบฎเบปเบฒเบ„เบงเบ™เปƒเบชเปˆเปƒเบœเปเบ—เบ™เบกเบฑเบ™? เบซเบ™เบถเปˆเบ‡เปƒเบ™เบœเบนเป‰เบ•เบดเบ”เบ•เบฒเบกเบ‚เบญเบ‡เบฅเบฒเบง (เบฅเบนเบเบซเบฅเบฒเบ™เบซเบผเบทเบฅเบนเบเบซเบฅเบฒเบ™เบ‚เบญเบ‡เบฅเบนเบเบซเบฅเบฒเบ™) เบ•เป‰เบญเบ‡เบเบฒเบเป€เบ›เบฑเบ™ เบœเบนเป‰เบชเบทเบšเบ—เบญเบ”(เบœเบนเป‰เบ—เบตเปˆเบˆเบฐเป€เบญเบปเบฒเบชเบฐเบ–เบฒเบ™เบ—เบตเปˆเบ‚เบญเบ‡ node เบ—เบตเปˆเบ–เบทเบเป‚เบเบเบเป‰เบฒเบ).

เบงเบดเบ—เบตเบเบฒเบ™เป€เบ‚เบปเป‰เบฒเปƒเบˆเบงเปˆเบฒเปƒเบœเบ„เบงเบ™เบˆเบฐเป€เบ›เบฑเบ™เบœเบนเป‰เบชเบทเบšเบ—เบญเบ”? เป‚เบ”เบ intuitively, เบ™เบตเป‰เปเบกเปˆเบ™ node เปƒเบ™เบ•เบปเป‰เบ™เป„เบกเป‰เบ—เบตเปˆเบกเบตเบเบฐเปเบˆเบ—เบตเปˆเปƒเบซเบเปˆเบ—เบตเปˆเบชเบธเบ”เบ•เปเปˆเป„เบ›เบˆเบฒเบ node เบ—เบตเปˆเบ–เบทเบเบฅเบถเบš. เบชเบนเบ”เบเบฒเบ™เบ„เบดเบ”เป„เบฅเปˆเปเบกเปˆเบ™เบ”เบฑเปˆเบ‡เบ•เปเปˆเป„เบ›เบ™เบตเป‰. เบ—เปˆเบฒเบ™เบˆเปเบฒเป€เบ›เบฑเบ™เบ•เป‰เบญเบ‡เป„เบ›เบซเบฒเบฅเบนเบเบซเบฅเบฒเบ™เบ—เบตเปˆเบ–เบทเบเบ•เป‰เบญเบ‡เบ‚เบญเบ‡เบกเบฑเบ™ (เบชเบฐเป€เบซเบกเบตเป„เบ›เบ—เบฒเบ‡เบ‚เบงเบฒ, เป€เบžเบฒเบฐเบงเปˆเบฒเบกเบฑเบ™เป€เบงเบปเป‰เบฒเปเบฅเป‰เบงเบงเปˆเบฒเบเบธเบ™เปเบˆเบชเบทเบšเบ—เบญเบ”เปเบกเปˆเบ™เปƒเบซเบเปˆเบเบงเปˆเบฒเบเบธเบ™เปเบˆเบ‚เบญเบ‡เป‚เบซเบ™เบ”เบ—เบตเปˆเบ–เบทเบเบฅเบปเบš), เปเบฅเบฐเบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™เป„เบ›เบœเปˆเบฒเบ™เบฅเบฐเบšเบปเบšเบ•เปˆเบญเบ‡เป‚เบชเป‰เบ‚เบญเบ‡เบฅเบนเบเบซเบฅเบฒเบ™เบŠเป‰เบฒเบเบ‚เบญเบ‡เบฅเบนเบเบซเบฅเบฒเบ™เบ‚เบงเบฒเบ™เบตเป‰. . เปƒเบ™เบ•เบปเบงเบขเปˆเบฒเบ‡, เบžเบงเบเป€เบฎเบปเบฒเบˆเบฐเป„เบ›เบซเบฒ node เบ—เบตเปˆเบกเบตเบฅเบฐเบซเบฑเบ” 35, เปเบฅเบฐเบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™เบฅเบปเบ‡เป„เบ›เบซเบฒเปƒเบšเบœเปˆเบฒเบ™เบฅเบฐเบšเบปเบšเบ•เปˆเบญเบ‡เป‚เบชเป‰เบ‚เบญเบ‡เบฅเบนเบเบŠเป‰เบฒเบเบ‚เบญเบ‡เบกเบฑเบ™ - เปƒเบ™เบเปเบฅเบฐเบ™เบตเบ™เบตเป‰, เบฅเบฐเบšเบปเบšเบ•เปˆเบญเบ‡เป‚เบชเป‰เบ™เบตเป‰เบ›เบฐเบเบญเบšเบ”เป‰เบงเบเบžเบฝเบ‡เปเบ•เปˆ node เบ—เบตเปˆเบกเบตเบเบธเบ™เปเบˆ 30. เป€เบงเบปเป‰เบฒเบขเปˆเบฒเบ‡เป€เบ‚เบฑเป‰เบกเบ‡เบงเบ”, เบžเบงเบเป€เบฎเบปเบฒเบเปเบฒเบฅเบฑเบ‡เบŠเบญเบเบซเบฒ เบชเปเบฒเบฅเบฑเบš node เบ™เป‰เบญเบเบ—เบตเปˆเบชเบธเบ”เปƒเบ™เบŠเบธเบ”เบ‚เบญเบ‡ nodes เบ‚เบฐเบซเบ™เบฒเบ”เปƒเบซเบเปˆเบเปˆเบงเบฒเบซเบ™เบถเปˆเบ‡เบ—เบตเปˆเบžเบงเบเป€เบฎเบปเบฒเบเปเบฒเบฅเบฑเบ‡เบŠเบญเบเบซเบฒ node.

Binary Tree เบซเบผเบทเบงเบดเบ—เบตเบเบฒเบ™เบเบฐเบเบฝเบกเบ•เบปเป‰เบ™เป„เบกเป‰เบ„เบปเป‰เบ™เบซเบฒเบ„เบนเปˆ

เบฅเบฐเบซเบฑเบ”เบงเบดเบ—เบตเบเบฒเบ™เบ„เบปเป‰เบ™เบซเบฒเบœเบนเป‰เบชเบทเบšเบ—เบญเบ”:

    public Node<T> getSuccessor(Node<T> deleteNode) {
        Node<T> parentSuccessor = deleteNode;//ั€ะพะดะธั‚ะตะปัŒ ะฟั€ะตะตะผะฝะธะบะฐ
        Node<T> successor = deleteNode;//ะฟั€ะตะตะผะฝะธะบ
        Node<T> current = successor.getRightChild();//ะฟั€ะพัั‚ะพ "ะฟั€ะพะฑะตะณะฐัŽั‰ะธะน" ัƒะทะตะป
        while (current != null) {
            parentSuccessor = successor;
            successor = current;
            current = current.getLeftChild();
        }
        //ะฝะฐ ะฒั‹ั…ะพะดะต ะธะท ั†ะธะบะปะฐ ะธะผะตะตะผ ะฟั€ะตะตะผะฝะธะบะฐ ะธ ั€ะพะดะธั‚ะตะปั ะฟั€ะตะตะผะฝะธะบะฐ
        if (successor != deleteNode.getRightChild()) {//ะตัะปะธ ะฟั€ะตะตะผะฝะธะบ ะฝะต ัะพะฒะฟะฐะดะฐะตั‚ ั ะฟั€ะฐะฒั‹ะผ ะฟะพั‚ะพะผะบะพะผ ัƒะดะฐะปัะตะผะพะณะพ ัƒะทะปะฐ
            parentSuccessor.setLeftChild(successor.getRightChild());//ั‚ะพ ะตะณะพ ั€ะพะดะธั‚ะตะปัŒ ะทะฐะฑะธั€ะฐะตั‚ ัะตะฑะต ะฟะพั‚ะพะผะบะฐ ะฟั€ะตะตะผะฝะธะบะฐ, ั‡ั‚ะพะฑั‹ ะฝะต ะฟะพั‚ะตั€ัั‚ัŒ ะตะณะพ
            successor.setRightChild(deleteNode.getRightChild());//ัะฒัะทั‹ะฒะฐะตะผ ะฟั€ะตะตะผะฝะธะบะฐ ั ะฟั€ะฐะฒั‹ะผ ะฟะพั‚ะพะผะบะพะผ ัƒะดะฐะปัะตะผะพะณะพ ัƒะทะปะฐ
        }
        return successor;
    }

เบฅเบฐเบซเบฑเบ”เป€เบ•เบฑเบกเบชเปเบฒเบฅเบฑเบšเบงเบดเบ—เบตเบเบฒเบ™เบฅเบถเบš:

public boolean delete(int deleteKey) {
        Node<T> current = root;
        Node<T> parent = current;
        boolean isLeftChild = false;//ะ’ ะทะฐะฒะธัะธะผะพัั‚ะธ ะพั‚ ั‚ะพะณะพ, ัะฒะปัะตั‚ัั ะปะธ  ัƒะดะฐะปัะตะผั‹ะน ัƒะทะตะป ะปะตะฒั‹ะผ ะธะปะธ ะฟั€ะฐะฒั‹ะผ ะฟะพั‚ะพะผะบะพะผ ัะฒะพะตะณะพ ั€ะพะดะธั‚ะตะปั, ะฑัƒะปะตะฒัะบะฐั ะฟะตั€ะตะผะตะฝะฝะฐั isLeftChild ะฑัƒะดะตั‚ ะฟั€ะธะฝะธะผะฐั‚ัŒ ะทะฝะฐั‡ะตะฝะธะต true ะธะปะธ false ัะพะพั‚ะฒะตั‚ัั‚ะฒะตะฝะฝะพ.
        while (current.getKey() != deleteKey) {
            parent = current;
            if (deleteKey < current.getKey()) {
                current = current.getLeftChild();
                isLeftChild = true;
            } else {
                isLeftChild = false;
                current = current.getRightChild();
            }
            if (current == null)
                return false;
        }

        if (current.getLeftChild() == null && current.getRightChild() == null) {//ะฟะตั€ะฒั‹ะน ัะปัƒั‡ะฐะน
            if (current == root)
                current = null;
            else if (isLeftChild)
                parent.setLeftChild(null);
            else
                parent.setRightChild(null);
        }
        else if (current.getRightChild() == null) {//ะฒั‚ะพั€ะพะน ัะปัƒั‡ะฐะน
            if (current == root)
                root = current.getLeftChild();
            else if (isLeftChild)
                parent.setLeftChild(current.getLeftChild());
            else
                current.setRightChild(current.getLeftChild());
        } else if (current.getLeftChild() == null) {
            if (current == root)
                root = current.getRightChild();
            else if (isLeftChild)
                parent.setLeftChild(current.getRightChild());
            else
                parent.setRightChild(current.getRightChild());
        } 
        else {//ั‚ั€ะตั‚ะธะน ัะปัƒั‡ะฐะน
            Node<T> successor = getSuccessor(current);
            if (current == root)
                root = successor;
            else if (isLeftChild)
                parent.setLeftChild(successor);
            else
                parent.setRightChild(successor);
        }
        return true;
    }

เบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™เบชเบฒเบกเบฒเบ”เบ›เบฐเบกเบฒเบ™ O(log(n)).

เบŠเบญเบเบซเบฒเบชเบนเบ‡เบชเบธเบ” / เบ•เปเปˆเบฒเบชเบธเบ”เปƒเบ™เบ•เบปเป‰เบ™เป„เบกเป‰

เบกเบฑเบ™เป€เบ›เบฑเบ™เบ—เบตเปˆเบˆเบฐเปเบˆเป‰เบ‡เบงเบดเบ—เบตเบเบฒเบ™เบŠเบญเบเบซเบฒเบ„เปˆเบฒเบ•เปเปˆเบฒเบชเบธเบ” / เบชเบนเบ‡เบชเบธเบ”เปƒเบ™เบ•เบปเป‰เบ™เป„เบกเป‰ - เบ—เปˆเบฒเบ™เบˆเปเบฒเป€เบ›เบฑเบ™เบ•เป‰เบญเบ‡เบเป‰เบฒเบเบ•เบฒเบกเบฅเปเบฒเบ”เบฑเบšเบ•เบฒเบกเบฅเบฐเบšเบปเบšเบ•เปˆเบญเบ‡เป‚เบชเป‰เบ‚เบญเบ‡เบญเบปเบ‡เบ›เบฐเบเบญเบšเบŠเป‰เบฒเบ / เบ‚เบงเบฒเบ‚เบญเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰, เบ•เบฒเบกเบฅเปเบฒเบ”เบฑเบš; เป€เบกเบทเปˆเบญเบ—เปˆเบฒเบ™เป„เบ›เบซเบฒเปเบœเปˆเบ™, เบกเบฑเบ™เบˆเบฐเป€เบ›เบฑเบ™เบญเบปเบ‡เบ›เบฐเบเบญเบšเบ•เปเบฒเปˆเบชเบธเบ”เบ—เบตเปˆ / เบชเบนเบ‡เบชเบธเบ”.

    public Node<T> getMinimum(Node<T> startPoint) {
        Node<T> current = startPoint;
        Node<T> parent = current;
        while (current != null) {
            parent = current;
            current = current.getLeftChild();
        }
        return parent;
    }

    public Node<T> getMaximum(Node<T> startPoint) {
        Node<T> current = startPoint;
        Node<T> parent = current;
        while (current != null) {
            parent = current;
            current = current.getRightChild();
        }
        return parent;
    }

เบ„เบงเบฒเบกเบŠเบฑเบšเบŠเป‰เบญเบ™ - O(log(n))

Symmetrical bypass

Traversal เปเบกเปˆเบ™เบเบฒเบ™เบขเป‰เบฝเบกเบขเบฒเบกเปเบ•เปˆเบฅเบฐเบ‚เปเป‰เบ‚เบญเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰เป€เบžเบทเปˆเบญเบ”เปเบฒเป€เบ™เบตเบ™เบเบฒเบ™เบšเบฒเบ‡เบขเปˆเบฒเบ‡เบเบฑเบšเบกเบฑเบ™.

เบชเบนเบ”เบเบฒเบ™เบ„เบดเบ”เป„เบฅเปˆเป„เบฅเบเบฐเบซเปˆเบฒเบ‡เบ‚เบญเบ‡เบชเบปเบกเบกเบฒเบ•เบฃเบดเบเปเบšเบšเบŠเป‰เบณเป†:

  1. เบ”เปเบฒเป€เบ™เบตเบ™เบเบฒเบ™เบเปˆเบฝเบงเบเบฑเบšเป€เบ”เบฑเบเบŠเป‰เบฒเบ
  2. เบ”เปเบฒเป€เบ™เบตเบ™เบเบฒเบ™เบเบฑเบšเบ•เบปเบงเบ—เปˆเบฒเบ™เป€เบญเบ‡
  3. เบ”เปเบฒเป€เบ™เบตเบ™เบเบฒเบ™เบเปˆเบฝเบงเบเบฑเบšเป€เบ”เบฑเบเบ™เป‰เบญเบเบ—เบตเปˆเบ–เบทเบเบ•เป‰เบญเบ‡

เบฅเบฐเบซเบฑเบ”:

    public void inOrder(Node<T> current) {
        if (current != null) {
            inOrder(current.getLeftChild());
            System.out.println(current.getData() + " ");//ะ—ะดะตััŒ ะผะพะถะตั‚ ะฑั‹ั‚ัŒ ะฒัะต, ั‡ั‚ะพ ัƒะณะพะดะฝะพ
            inOrder(current.getRightChild());
        }
    }

เบชเบฐเบซเบฅเบธเบš

เบชเบธเบ”เบ—เป‰เบฒเบ! เบ–เป‰เบฒเบ‚เป‰เบญเบเบšเปเปˆเป„เบ”เป‰เบญเบฐเบ—เบดเบšเบฒเบเบซเบเบฑเบ‡เบซเบผเบทเบกเบตเบ„เปเบฒเป€เบซเบฑเบ™เปƒเบ”เป†, เบเบฐเบฅเบธเบ™เบฒเบ›เปˆเบญเบเปƒเบซเป‰เบžเบงเบเป€เบ‚เบปเบฒเบขเบนเปˆเปƒเบ™เบ„เปเบฒเป€เบซเบฑเบ™. เบ•เบฒเบกเบชเบฑเบ™เบเบฒ, เบ‚เป‰เบญเบเปƒเบซเป‰เบฅเบฐเบซเบฑเบ”เบ„เบปเบšเบ–เป‰เบงเบ™.

Node.java:

public class Node<T> {
    private T data;
    private int key;
    private Node<T> leftChild;
    private Node<T> rightChild;

    public Node(T data, int key) {
        this.data = data;
        this.key = key;
    }

    public void setLeftChild(Node<T> newNode) {
        leftChild = newNode;
    }

    public void setRightChild(Node<T> newNode) {
        rightChild = newNode;
    }

    public Node<T> getLeftChild() {
        return leftChild;
    }

    public Node<T> getRightChild() {
        return rightChild;
    }

    public T getData() {
        return data;
    }

    public int getKey() {
        return key;
    }
}

BinaryTree.java:

public class BinaryTree<T> {
    private Node<T> root;

    public Node<T> find(int key) {
        Node<T> current = root;
        while (current.getKey() != key) {
            if (key < current.getKey())
                current = current.getLeftChild();
            else
                current = current.getRightChild();
            if (current == null)
                return null;
        }
        return current;
    }

    public void insert(T insertData, int key) {
        Node<T> current = root;
        Node<T> parent;
        Node<T> newNode = new Node<>(insertData, key);
        if (root == null)
            root = newNode;
        else {
            while (true) {
                parent = current;
                if (key < current.getKey()) {
                    current = current.getLeftChild();
                    if (current == null) {
                         parent.setLeftChild(newNode);
                         return;
                    }
                }
                else {
                    current = current.getRightChild();
                    if (current == null) {
                        parent.setRightChild(newNode);
                        return;
                    }
                }
            }
        }
    }

    public Node<T> getMinimum(Node<T> startPoint) {
        Node<T> current = startPoint;
        Node<T> parent = current;
        while (current != null) {
            parent = current;
            current = current.getLeftChild();
        }
        return parent;
    }

    public Node<T> getMaximum(Node<T> startPoint) {
        Node<T> current = startPoint;
        Node<T> parent = current;
        while (current != null) {
            parent = current;
            current = current.getRightChild();
        }
        return parent;
    }

    public Node<T> getSuccessor(Node<T> deleteNode) {
        Node<T> parentSuccessor = deleteNode;
        Node<T> successor = deleteNode;
        Node<T> current = successor.getRightChild();
        while (current != null) {
            parentSuccessor = successor;
            successor = current;
            current = current.getLeftChild();
        }

        if (successor != deleteNode.getRightChild()) {
            parentSuccessor.setLeftChild(successor.getRightChild());
            successor.setRightChild(deleteNode.getRightChild());
        }
        return successor;
    }

    public boolean delete(int deleteKey) {
        Node<T> current = root;
        Node<T> parent = current;
        boolean isLeftChild = false;
        while (current.getKey() != deleteKey) {
            parent = current;
            if (deleteKey < current.getKey()) {
                current = current.getLeftChild();
                isLeftChild = true;
            } else {
                isLeftChild = false;
                current = current.getRightChild();
            }
            if (current == null)
                return false;
        }

        if (current.getLeftChild() == null && current.getRightChild() == null) {
            if (current == root)
                current = null;
            else if (isLeftChild)
                parent.setLeftChild(null);
            else
                parent.setRightChild(null);
        }
        else if (current.getRightChild() == null) {
            if (current == root)
                root = current.getLeftChild();
            else if (isLeftChild)
                parent.setLeftChild(current.getLeftChild());
            else
                current.setRightChild(current.getLeftChild());
        } else if (current.getLeftChild() == null) {
            if (current == root)
                root = current.getRightChild();
            else if (isLeftChild)
                parent.setLeftChild(current.getRightChild());
            else
                parent.setRightChild(current.getRightChild());
        } 
        else {
            Node<T> successor = getSuccessor(current);
            if (current == root)
                root = successor;
            else if (isLeftChild)
                parent.setLeftChild(successor);
            else
                parent.setRightChild(successor);
        }
        return true;
    }

    public void inOrder(Node<T> current) {
        if (current != null) {
            inOrder(current.getLeftChild());
            System.out.println(current.getData() + " ");
            inOrder(current.getRightChild());
        }
    }
}

PS

Degeneration เบเบฑเบš O(n)

เบซเบฅเบฒเบโ€‹เบ—เปˆเบฒเบ™โ€‹เบญเบฒเบ”โ€‹เบˆเบฐโ€‹เป„เบ”เป‰โ€‹เบชเบฑเบ‡โ€‹เป€เบเบ”โ€‹เบงเปˆเบฒ: เบ–เป‰เบฒโ€‹เป€เบˆเบปเป‰เบฒโ€‹เป€เบฎเบฑเบ”โ€‹เปƒเบซเป‰โ€‹เบ•เบปเป‰เบ™โ€‹เป„เบกเป‰โ€‹เบšเปเปˆโ€‹เบชเบปเบกโ€‹เบ”เบธเบ™โ€‹เบˆเบฐโ€‹เป€เบ›เบฑเบ™โ€‹เปเบ™เบงโ€‹เปƒเบ”? เบ•เบปเบงเบขเปˆเบฒเบ‡, เปƒเบชเปˆเบ‚เปเป‰เบ—เบตเปˆเบกเบตเบ›เบธเปˆเบกเป€เบžเบตเปˆเบกเบ‚เบถเป‰เบ™เปƒเบ™เบ•เบปเป‰เบ™เป„เบกเป‰: 1,2,3,4,5,6... เบซเบผเบฑเบ‡เบˆเบฒเบเบ™เบฑเป‰เบ™, เบ•เบปเป‰เบ™เป„เบกเป‰เบˆเบฐเบ„เป‰เบฒเบเบ„เบทเบเบฑเบšเบšเบฑเบ™เบŠเบตเบฅเบฒเบเบŠเบทเปˆเบ—เบตเปˆเป€เบŠเบทเปˆเบญเบกเป‚เบเบ‡. เปเบฅเบฐเปเบกเปˆเบ™เปเบฅเป‰เบง, เบ•เบปเป‰เบ™เป„เบกเป‰เบˆเบฐเบชเบนเบ™เป€เบชเบเป‚เบ„เบ‡เบชเป‰เบฒเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰เบ‚เบญเบ‡เบกเบฑเบ™, เปเบฅเบฐเบ”เบฑเปˆเบ‡เบ™เบฑเป‰เบ™เบ›เบฐเบชเบดเบ”เบ—เบดเบžเบฒเบšเบ‚เบญเบ‡เบเบฒเบ™เป€เบ‚เบปเป‰เบฒเป€เบ–เบดเบ‡เบ‚เปเป‰เบกเบนเบ™. เบ„เบงเบฒเบกโ€‹เบŠเบฑเบšโ€‹เบŠเป‰เบญเบ™โ€‹เบ‚เบญเบ‡โ€‹เบเบฒเบ™โ€‹เบŠเบญเบโ€‹เบซเบฒโ€‹, เบเบฒเบ™โ€‹เปเบŠเบโ€‹, เปเบฅเบฐโ€‹เบเบฒเบ™โ€‹เบฅเบปเบšโ€‹เบเบฒเบ™โ€‹เบ”เปเบฒโ€‹เป€เบ™เบตเบ™โ€‹เบ‡เบฒเบ™โ€‹เบˆเบฐโ€‹เบเบฒเบโ€‹เป€เบ›เบฑเบ™โ€‹เบญเบฑเบ™โ€‹เบ”เบฝเบงโ€‹เบเบฑเบ™โ€‹เบเบฑเบšโ€‹เบšเบฑเบ™โ€‹เบŠเบตโ€‹เบฅเบฒเบโ€‹เบเบฒเบ™โ€‹เบ—เบตเปˆโ€‹เป€เบŠเบทเปˆเบญเบกโ€‹เบ•เปเปˆโ€‹: O(nโ€‹)โ€‹. เบ™เบตเป‰เปเบกเปˆเบ™เบชเบดเปˆเบ‡เบ—เบตเปˆเบชเปเบฒเบ„เบฑเบ™เบ—เบตเปˆเบชเบธเบ”, เปƒเบ™เบ„เบงเบฒเบกเบ„เบดเบ”เป€เบซเบฑเบ™เบ‚เบญเบ‡เบ‚เป‰เบญเบ, เบ‚เปเป‰เป€เบชเบเบ‚เบญเบ‡เบ•เบปเป‰เบ™เป„เบกเป‰เบ„เบนเปˆ.

เบžเบฝเบ‡เปเบ•เปˆเบœเบนเป‰เปƒเบŠเป‰เบฅเบปเบ‡เบ—เบฐเบšเบฝเบ™เบชเบฒเบกเบฒเบ”เป€เบ‚เบปเป‰เบฒเบฎเปˆเบงเบกเปƒเบ™เบเบฒเบ™เบชเปเบฒเบซเบผเบงเบ”. เป€เบ‚เบปเป‰เบฒโ€‹เบชเบนเปˆโ€‹เบฅเบฐโ€‹เบšเบปเบšเบเบฐเบฅเบธเบ™เบฒ.

เบ‚เป‰เบญเบเบšเปเปˆเป„เบ”เป‰เบขเบนเปˆเปƒเบ™เบชเบนเบ™เบ”เบปเบ™เบ™เบฒเบ™เปเบฅเป‰เบง, เปเบฅเบฐเบ‚เป‰เบญเบเบขเบฒเบเบฎเบนเป‰เบงเปˆเบฒเบšเบปเบ”เบ„เบงเบฒเบกเบเปˆเบฝเบงเบเบฑเบšเบซเบปเบงเบ‚เปเป‰เปƒเบ”เบ—เบตเปˆเป€เบˆเบปเป‰เบฒเบขเบฒเบเป€เบšเบดเปˆเบ‡เป€เบžเบตเปˆเบกเป€เบ•เบตเบก?

  • เป‚เบ„เบ‡เบชเป‰เบฒเบ‡เบ‚เปเป‰เบกเบนเบ™

  • เบชเบนเบ”เบเบฒเบ™เบ„เบดเบ”เป„เบฅเปˆ (DP, recursion, เบเบฒเบ™เบšเบตเบšเบญเบฑเบ”เบ‚เปเป‰เบกเบนเบ™, เปเบฅเบฐเบญเบทเปˆเบ™เป†)

  • เบเบฒเบ™โ€‹เบ™เปเบฒโ€‹เปƒเบŠเป‰โ€‹เป‚เบ„เบ‡โ€‹เบชเป‰เบฒเบ‡โ€‹เบ‚เปเป‰โ€‹เบกเบนเบ™โ€‹เปเบฅเบฐโ€‹เบงเบดโ€‹เบ—เบตโ€‹เบเบฒเบ™โ€‹เปƒเบ™โ€‹เบŠเบตโ€‹เบงเบดเบ”โ€‹เบ—เบตเปˆโ€‹เปเบ—เป‰โ€‹เบˆเบดเบ‡โ€‹

  • เบเบฒเบ™เบ‚เบฝเบ™เป‚เบ›เบฅเปเบเบฅเบก Android Applications เปƒเบ™ Java

  • เบเบฒเบ™เบ‚เบฝเบ™เป‚เบ›เบผเปเบเบผเบกเป€เบงเบฑเบšเปƒเบ™ Java

2 เบœเบนเป‰เปƒเบŠเป‰เบฅเบปเบ‡เบ„เบฐเปเบ™เบ™เบชเบฝเบ‡. 1 เบœเบนเป‰เปƒเบŠเป‰เบ‡เบปเบ”.

เบ—เบตเปˆเบกเบฒ: www.habr.com

เป€เบžเบตเปˆเบกเบ„เบงเบฒเบกเบ„เบดเบ”เป€เบซเบฑเบ™