      12. ⢠  ॢ.

     12.1. ।⠢    ॢ쥢.

      筮 ॢ. T-ॢ.

     㥬 .   ஢  ५ (   
ࠢ )   㣨 窨.     祪 ஢-
   ५  ⠪ . 祭 ⨭ ( n- ᫮
㤥  (2  ⥯ (n - 1)) 祪) 뢠   -
ॢ.   뢠 ୥.   設    
뭠  (  設,    ५) -   ࠢ. 
类 設, ஬ ,  ⢥ .
      ࠭ ஥ 筮 ⢮  設  
筮  ॢ, ᮤঠ饥    設   
।.    設 ⮣ ⢠ ᠭ -
 䨪஢ ⨯ T (   ⮡ࠦ  ⢠
設    ⢮  祭 ⨯ T). ,  , 㤥
뢠 T-ॢ. ⢮  T-ॢ쥢 稬 Tree(T).
     ᨢ ।. 类 ⮥ T-ॢ  ࠧ-
   : ७ (騩   T),   ࠢ
ॢ  (     묨).  ࠧ -
  筮 ᮮ⢥⢨  ⢮  -
 T-ॢ쥢  ந T * Tree (T) * Tree (T). -
稢 १ empty ⮥ ॢ,  

     Tree (T) = {empty} + T * Tree (T) * Tree (T).








     ॢ. .

     㥬  ஥ T-ॢ.    設 x -
।   ॢ (  設 x      -
⮬),  ࠢ ॢ (ࠢ  設 x    ⮬-
)  ॢ  ୥  x (設 x    ⮬). 
 ࠢ ॢ 設 x   묨,  ॢ  
୥   x ᥣ  (ᮤন  ࠩ  x). ⮩
ॢ 㤥  ᨬ  楯  y[1]..y[n]  
設,  ன y [i+1] -  y [i]   i. ( -
 ॢ ࠢ ,  ॢ    - .)

     冷祭 T-ॢ.

        ⢥ 祭 ⨯ T 䨪஢ 冷. -
 T-ॢ 㯮冷祭, ᫨ 믮 ⠪ ᢮⢮: 
 設 x  ⪨    ॢ   ⪨
 x,   ⪨   ࠢ ॢ  ⪨  x.




     12.1.1.  ,     㯮冷祭 ॢ  ⪨
ࠧ.
     .    ॢ.

     ।⠢    ॢ쥢.

      ॢ 㤥  ।⠢  ⢠  
⮪     設.  ⮬     ⢮ 
 ࠧ ।⠢.
      㯮冷祭     "
᢮ "  ॢ: ਤ  - 設  ࠢ ᥡ  
⥬,  ⠬ 室,  蠥,     -
ࠢ. 砢      ⮬ ࠢ,   -
,  ⠪  㦥 ,   ,  ஬ 
  .    ।,   祭 ⨯
T  冷,  ᬠਢ ⮫쪮 㯮冷祭 ॢ.







     ࠭ ॢ쥢  ணࠬ.

      뫮  ᮯ⠢ 設  筮  ॢ
  ᫠  1,  2, 3,... (,    (n) = 2n, ࠢ
 (n) = 2n + 1)  ࠭ ⪨  ᨢ val [1...]. 
 ᯮᮡ , ᪮        ࠭
 ᨩ   筮 ॢ.

       ⠪ ᯮᮡ.   ᨢ

       val: array [1..n] of T;
       left, right: array [1..n] of 0..n;

(n  -  ᨬ쭮   ᫮ 設 ॢ)  ६
root: 0..n.  設 ࠭ T-ॢ 㤥   
- ᫮  1  n.  設   ࠧ . -
⪠    設   ஬ x ࠢ val [x]. ७  
root. ᫨ 設  ஬ i  뭮,    ࠢ
left [i]  right [i]. 騬 뭮 ᮮ⢥ ᫮
0.  ࠧ 祭 root = 0  ᮮ⢥  ⮬
ॢ.
       ࠭  ॢ  ᯮ   ᨢ; 
 i,  ᢮ - ..     ࠬ  設  -
祭  val  [i] ࠧ.  㤥 㤮, ⮡  ᢮-
 ᫠ 뫨 "易  ᯨ᮪": ࢮ ࠭    ᯥ-
쭮  ६  free: 0..n,  ᫥饥  i ᢮ ᫮
࠭  left [i], ⠪  ᢮ ᫠

     free, left [free], left [left[free]],...

 ᫥ ᢮ ᫠ i 祭 left  [i]  =  0.  -
⢮  free = 0 砥,  ᢮ ᥫ  . (-
砭.  ᯮ짮  뢠 ᢮ 設  ᨢ
left, , 筮,  ⥬  ᯥ宬  뫮 ᯮ짮 -
ᨢ right.)
       祭 0 (饣 ⢨ 設) 
뫮  ᯮ짮  㣨 ᫮  1..n. ⮡ -
ભ , 㤥  0 ᯮ짮 ⠭ null = 0.

     12.1.2. ⠢ ணࠬ,  ।,  ᮤন  
  t:  T   㯮冷祭 ॢ (࠭ ⠪,  ⮫쪮
 ᠭ).

     襭.

  if root = null then begin
  | .. ਭ
  end else begin
  | x := root;
  | {ਠ: ⠥ ஢ 稥 t  ⮬ -
  |  ॢ  ୥ x}
  | while ((t < val [x]) and (left [x] <> null)) or
  | |     ((t > val [x]) and (right [x] <> null)) do begin
  | | if t < val [x] then begin {left [x] <> null}
  | | | x := left [x];
  | | end else begin {t > val [x], right [x] <> null}
  | | | x := right [x];
  | | end;
  | end;
  | { t = val [x],  t   ॢ}
  | ..⢥ = (t = val [x])
  end;

     12.1.3.  襭, ᯮ ᫥騩 . -
ਬ  । ᨢ val,   祩    ஬
null   val [null] = t.

     襭.

  val [null] := t;
  x := root;
  while t <> val [x] do begin
  | if t < val [x] then begin
  | | x := left [x];
  | end else begin
  | | x := right [x];
  | end;
  end;
  ..⢥: (x <> null).

     12.1.4.  ⠢  ணࠬ    t  -
⢮, ।⠢ 㯮冷祭 ॢ (᫨  t 㦥
, 祣   ).

     襭. । 楤 get_free (var i: integer), -
 ᢮ ( 饥 ஬) ᫮ i  ᮮ⢥騬
ࠧ ४ ᯨ᮪ ᢮ ᥫ.

  procedure get_free (var i: integer);
  begin
  | {free <> null}
  | i := free;
  | free := left [free];
  end;

  ᯮ짮 ணࠬ ਮ⠥ :

  if root = null then begin
  | get_free (root);
  | left [root] := null; right [root] := null;
  | val [root] := t;
  end else begin
  | x := root;
  | {ਠ: ⠫  t  ⮬ ॢ 
  |  ୥  x}
  | while ((t < val [x]) and (left [x] <> null)) or
  | |     ((t > val [x]) and (right [x] <> null)) do begin
  | | if t < val [x] then begin
  | | | x := left [x];
  | | end else begin {t > val [x]}
  | | | x := right [x];
  | | end;
  | end;
  | if t <> val [x] then begin {t   ॢ}
  | | get_free (i);
  | | left [i] := null; right [i] := null;
  | | val [i] := t;
  | | if t < val [x] then begin
  | | | left [x] := i;
  | | end else begin {t > val [x]}
  | | | right [x] := i;
  | | end;
  | end;
  end;

     12.1.5. ⠢ ணࠬ 㤠    t    -
⢠, ।⠢ 㯮冷祭 ॢ (᫨  ⠬ ,
祣   ).

     襭.

  if root = null then begin
  | {ॢ , 祣   }
  end else begin
  | x := root;
  | {⠫ 㤠 t  ॢ  ୥  x; ᪮
  |    ॡ    x, 
  |  ६  father: 1..n  direction: (l, r);
  |  ন ⠪ ਠ: ᫨ x  ७,  father
  |  -  ,  direction ࠢ l  r  ᨬ 
  |  ⮣,   ࠢ 뭮  x}
  | while ((t < val [x]) and (left [x] <> null)) or
  | |     ((t > val [x]) and (right [x] <> null)) do begin
  | | if t < val [x] then begin
  | | | father := x; direction := l;
  | | | x := left [x];
  | | end else begin {t > val [x]}
  | | | father := x; direction := r;
  | | | x := right [x];
  | | end;
  | end;
  | {t = val [x]  t   ॢ}
  | if t = val [x] then begin
  | | ..㤠 設 x   殬 father  ࠢ
  | |   direction
  | end;
  end;

  設  x ந室 -ࠧ  ࠧ . 
⮬ ᯮ 楤

  procedure make_free (i: integer);
  begin
  | left [i] := free;
  | free := i;
  end;

 砥 ᫮ i  ᯨ᮪ ᢮.  4   
ᨬ    ⢨ 뭮  㤠塞 -
.

  if (left [x] = null) and (right [x] = null) then begin
  | {x - , ..   뭮}
  | make_free (x);
  | if x = root then begin
  | | root := null;
  | end else if direction = l then begin
  | | left [father] := null;
  | end else begin {direction = r}
  | | right [father] := null;
  | end;
  end else if (left[x]=null) and (right[x] <> null) then begin
  | {x 㤠,  right [x]   x}
  | make_free (x);
  | if x = root then begin
  | | root := right [x];
  | end else if direction = l then begin
  | | left [father] := right [x];
  | end else begin {direction = r}
  | | right [father] := right [x];
  | end;
  end else if (left[x] <> null) and (right[x]=null) then begin
  | ..ᨬ筮
  end else begin {left [x] <> null, right [x] <> null}
  | ..㤠 設   뭮ﬨ
  end;

 設   뭮ﬨ  ᤥ  ⠪, 
   ।⥫쭮   設, ⪠  ன
 ।⢥ ᫥騬 ( 浪 ⠭)  -
⮬  ⪮  x.

    y := right [x];
    father := x; direction := r;
    {⥯ father  direction ⭮  設 y}
    while left [y] <> null do begin
    | father := y; direction := r;
    | y := left [y];
    end;
    {val [y] - 쭠  ⮪,  val [x],
     y    뭠}
    val [x] := val [y];
    ..㤠 設 y ( 㤠 設,  ன  -
       뭠,  㦥 )

     12.1.6.  ணࠬ 㤠, ⨢,   -
 砨 (ਬ,    )  ꥤ.

     12.1.7.  ᯮ짮 㯮冷祭 ॢ  ।⠢-
 㭪権,  ।   -    ⢠
祭 ⨯ T,  祭   ⨯ U. 樨: -
᫥  祭      㬥,  祭 
 㬥, ।  㭪樨      㬥,
᪫祭    । 㭪樨.

     襭.   ࠭,    ᨢ

         func_val: array [1..n] of U;

᫨ val [x] = t, func_val [x] = u,  祭 ࠭ 㭪樨
 t ࠢ u.

     業 ⢠ ⢨.

         権 (஢ન,   ᪫祭)
⢮ ⢨  ॢ室  C  *  (  ॢ).  
"஢ ਦ" ॢ (     )
   浪 稭 ࠢ  ᫠ 設. 
 ਢ ॢ    ࠧ 㦥:   襬
砥    設  ࠧ 楯   ࠢ  設.
 , ᫨  ⢠   饬
 뢠饬 浪.  , ,    -
  ⮢ " 砩 浪" ।  ॢ 㤥
  C * ( ᫠ 設). ᫨ ⮩ 業 " ।-
" , 室  ⥫  ⢨    ঠ
"ᡠ஢" ॢ.  ⮬ .  ᫥饬 㭪.

     12.1.8.  ।,  室 㬥 ⠪ ᪨
k-  ⢠ (  浪  ⠭),  祬  -
⢮  ⢨       C*( ॢ). 
⥫ ଠ  ࠭  設 ॢ?

     襭.   設 㤥 ࠭ ᫮     -
⮬.     ᪫祭 設 ॡ ४樨 
     ⮩ 設.   ᪠ k-  設
ন  ⠪  ਠ:  ᪮ 設  s-
設 ॢ  ୥  x ( s  x - ६).)

     12.2. ஢ ॢ.

     ॢ 뢠 ᡠ஢ ( -ॢ  
⥫ ⮣ ⮤ ..ᮭ-᪮   ..-
),  ᫨     設    ࠢ -
ॢ쥢 ⮩ 設 ⫨   祬  1. (  ⭮,
   뭮 , 㣮 - ᫨   - 易 
⮬.)

     12.2.1.    쭮   ᨬ쭮  -
⢮ 設  ᡠ஢ ॢ  n.

     襭. ᨬ쭮 ᫮ 設 ࠢ (2  ⥯ n)  -
1. ᫨ m (n) - 쭮 ᫮ 設, ,   ,
     m (n + 2) = 1 + m (n) + m (n+1),
㤠
     m (n) = fib (n+1) - 1
(fib(n)  -  n- ᫮ , fib(0)=1, fib(1)=1, fib(n+2) =
fib(n) + fib(n+1)).

     12.2.2. ,  ᡠ஢ ॢ  n 設
    C * (log n)  ன ⠭ C, 
饩  n.

     襭. 樥  n  ,  fib [n+1] >= (a
 ⥯ n),  a - 訩 ७ ⭮ ࠢ a*a =
1 + a,   a = (sqrt(5)  +  1)/2.  ⠥  ᯮ짮
।饩 祩.

     饭.

       ⨬  ⠭  ᡠ஢ ॢ ᫥
祭  㤠 ⮢.   ⮣  室  -
८ࠧ ॢ,  騥 ⢠ ⮪   -
設    騥 㯮冷祭,  ᯮᮡ騥 襩
ᡠ஢. 襬 ᪮쪮 ⠪ ८ࠧ.

      設 a  ࠢ 뭠 b. 稬 १ P -
 ॢ 設 a, १ Q  R -   ࠢ ॢ
設 b.







     冷祭 ॢ ॡ, ⮡ P < a < Q  <  b  <  R
(筥  ᫥  ᪠ " ⪠  P  ⪨
 a", "⪠  a   ⪨  Q"   ..,    
  ᥡ  ⮣  ). 筮 ⮣  ॡ 㯮冷-
祭 ॢ  ୥ b,   뭮 a,  ஬ P  Q -
  ࠢ ॢ a, R -  ࠢ  ॢ  b.  ⮬
ࢮ ॢ  ८ࠧ  ஥,   㯮冷-
祭.    ८ࠧ    ࠢ 饭
(ࠢ - ᪮  ᨬ筮, ,  - -
   讥, ஥  ᥩ 襬).

      b - ࠢ  a, c -   b, P - ॢ
a, Q  R -  ࠢ ॢ c, S - ࠢ  ॢ  b.
 P < a < Q < c < R < b < S.








  冷 ᮮ⢥ ॢ  ୥ c, 騬 
뭠 a  ࠢ 뭠 b,  ண P  Q - ॢ 設
a,   R  S - ॢ 設 b. ⢥饥 ८ࠧ-
 㤥 뢠 訬 ࠢ 饭. (筮 ।-
 ᨬ筮  讥  饭.)

     12.2.3.  ॢ, ᡠ஢ , ஬ , 
஬ ࠧ  ࠢ 2 (..     ࠢ  ॢ
 ᡠ஢    ⫨  2). , 
      ॢ饭  ᡠ஢   
ᠭ ८ࠧ, 祬     ⠭  ०
 㬥  1.

     襭.     , ਬ,  -
ॢ,    ࠢ k.      ࠢ  ॢ
ࠢ k+2. 稬 ७ १ a,   ࠢ 뭠 ( -
⥫쭮  )  १  b.  ᬮਬ   ࠢ ॢ
設 b.    易⥫쭮    k+1,    㣮
      k  k+1 ( k   , ⠪ 
ॢ ᡠ஢). ᫨    ॢ  ࠢ
k+1,    ࠢ  - k,  ॡ 讥 ࠢ 饭; 
⠫   .

------------------------------------
------------------------------------
------------------------------------

                                         㬥訫  1



------------------------------------
------------------------------------
------------------------------------

                                           



   k-1  k (   砥 k)

------------------------------------
------------------------------------
------------------------------------
                                         㬥訫  1


          ஢ ॢ.

     12.2.4.  ᡠ஢ ॢ     㤠-
 . ,   ⠭ ᡠ஢ 
 ᪮쪨 饭, 祬  ᫮      
ॢ.

     襭. 㤥 뢠  騩 䠪:

     .  ᫨  ᡠ஢ ॢ X    -
ॢ쥢 Y   ᡠ஢ ॢ Z, 祬   Z
⫨砥      Y   祬  1,  祭 ⠪
"ਢ" ॢ  ॢ  ᡠ஢  饭-
ﬨ  (祬 ⢮ 饭  ॢ室 ,  -
ன  ਢ).
      砥 ਢ   ⮣  ॢ
   , ⠪  筮   .
     ⥫⢮  .   ,  ன -
 ਢ. ᫨  ந室  ୥ (  -
 楫),   祢 ("ਢ"  ᡠ஢    ᫮-
).   ஥ ॢ, ਬ,  -
ॢ ன 設 x.   .
     (1)  ᫥ ਢ ᡠ஢  設 x  -
訫 (, , 訫 ᡠ஢   ।
x:   ॢ  ୥  x  ).  
᫠  । 樨, ,      ਢ
楫 ॢ  ୥  x.
     (2) ஢  x 訫.  ⮬ ࠧ -
  ࠢ 2 (    , ⠪   Z ⫨-
   Y   祬  1). ६  ਠ.
    (2)  ࠢ  (  襥)  ॢ  設  x.
   (.. Z) ࠢ k, ࠢ - k+2.  -
ண   ॢ 設 x (.. Y) 뫠 ࠢ k+1. -
ॢ  ୥ x   室 ॢ  k+3,   
  ᫥ ਢ.
      ।饩  饭 ८ࠧ ॢ   -
  x  ᡠ஢ ॢ  k+2  k+3.  
  ॢ  ୥ x -  ࠢ   ० ⮩
-    㬥訫  1,    ᯮ짮
। 樨.

      -------------                     ----------------
      -------------                     ----------------
      -------------k                    ----------------k
 2                                 2



     (2)   ॢ 設 x.      
(.. Z) ࠢ k+2, ࠢ - k.  ண  ॢ
(..  Y) 뫠 ࠢ k+1. ॢ  ୥ x  室 ॢ
X   k+2, ᫥ ਢ  ⠫  ࠢ  k+3.  ᫥
室饣  饭 (. । ) ॢ  ୥
 x ⠭ ᡠ஢,   㤥 ࠢ k+2  k+3,
⠪     ࠢ  ⮩ ॢ  -
 x  ॢ X  ॢ室 1   ᫠  ।-
 樨.

     12.2.5. ⠢ ணࠬ    㤠  -
⮢,  ࠭騥  ᡠ஢.  ᫮ ⢨  
ॢ室 C*( ॢ). 蠥 ࠭    設
ॢ ⥫ ଠ, 室  ஢.

     襭. 㤥 ࠭    設  ࠧ  
⮩  ࠢ   ॢ쥢:

  diff [i] = ( ࠢ ॢ 設  ஬ i) -
             (  ॢ 設  ஬ i).

  ॡ  楤, ᮮ⢥騥 訬  -
 ࠢ   饭ﬨ.  砫  砭.
     (1)  㦭, ⮡  饭 ॢ   
 . ( ⨢ 砥 ॡ   ४஢
ଠ   ,  ⥫쭮.) ⮣  ,
⠪      設  ॢ  롨 ᨬ  
祭. ( ⨭  㪠 ᡮ  設,   -
 - .)








           ࠢ 饭









          讥 ࠢ 饭

     (2)  ᫥  ८ࠧ     ⠪  ᮮ-
⢥ 祭  ᨢ diff.  ⮣  筮  
 ॢ쥢 P, Q, ...  筮  ⠭, ⮬ -
 ।,     ࠢ .

      楤 饭:

  procedure SR (a:integer); { ࠢ 饭  ୥ a}
  | var b: 1..n; val_a,val_b: T; h_P,h_Q,h_R: integer;
  begin
  | b := right [a]; {b <> null}
  | val_a := val [a]; val_b := val [b];
  | h_Q := 0; h_R := diff[b]; h_P := (max(h_Q,h_R)+1)-diff[a];
  | val [a] := val_b; val [b] := val_a;
  | right [a] := right [b] {ॢ R}
  | right [b] := left [b] {ॢ Q}
  | left [b] := left [a] {ॢ P}
  | left [a] := b;
  | diff [b] := h_Q - h_P;
  | diff [a] := h_R - (max (h_P, h_Q) + 1);
  end;

  procedure BR (a:integer);{讥 ࠢ 饭  ୥ a}
  | var b,c: 1..n; val_a,val_b,val_c: T;
  |     h_P,h_Q,h_R,h_S: integer;
  begin
  | b := right [a]; c := left [b]; {b,c <> null}
  | val_a := val [a]; val_b := val [b]; val_c := val [c];
  | h_Q := 0; h_R := diff[c]; h_S := (max(h_Q,h_R)+1)+diff[b];
  | h_P := 1 + max (h_S, h_S-diff[b]) - diff [a];
  | val [a] := val_c; val [c] := val_a;
  | left [b] := right [c] {ॢ R}
  | right [c] := left [c] {ॢ Q}
  | left [c] := left [a] {ॢ P}
  | left [a] := c;
  | diff [b] := h_S - h_R;
  | diff [c] := h_Q - h_P;
  | diff [a] := max (h_S, h_R) - max (h_P, h_Q);
  end;

 饭 (讥  ) 뢠 ᨬ筮.

     楤      㤠  ⮢    
࠭,  ⮫쪮    㤠    ᮯ஢
४樥  ᨢ  diff   ⠭ ᡠ஢.
 ⮬ ᯮ 楤  ⠪ ᢮⢠:

   :    ࠢ ॢ 設  ஬ a ᡠ-
       ஢,  ᠬ 設 ࠧ     2,  
       ॢ  ୥ a ᨢ diff  ࠢ쭮;
   :  ॢ  ୥ a ᡠ஢  ᨢ diff -
       ⢥⢥ , d -    (ࠢ  0
        -1);  ⠫쭮   ⠫  뫮}

  procedure balance (a: integer; var d: integer);
  begin {-2 <= diff[a] <= 2}
  | if diff [a] = 2 then begin
  | | b := right [a];
  | | if diff [b] = -1 then begin
  | | | BR (a); d := -1;
  | | end else if diff [b] = 0 then begin
  | | | SR (a); d := 0;
  | | end else begin {diff [b] = 1}
  | | | SR (a); d := - 1;
  | | end;
  | end else if diff [a] = -2 then begin
  | | b := left [a];
  | | if diff [b] = 1 then begin
  | | | BL (a); d := -1;
  | | end else if diff [b] = 0 then begin
  | | | SL (a); d := 0;
  | | end else begin {diff [b] = -1}
  | | | SL (a); d := - 1;
  | | end;
  | end else begin {-2 < diff [a] < 2, 祣   }
  | | d := 0;
  | end;
  end;

     ⠭  ᡠ஢  ॡ      
쥢    , ⮬ 㤥 ࠭  ⥪    
ᬠਢ    設. ⠬ ⥪  
 (設, ࠢ   ), .. 祭 ⨯

        record
        | vert: 1..n; {設}
        | direction : (l, r); {l - , r- ࠢ}
        end;

ணࠬ   t ⥯ 룫廊 ⠪:

  if root = null then begin
  | get_free (root);
  | left [root] := null; right [root] := null; diff[root] := 0;
  | val [root] := t;
  end else begin
  | x := root; ..ᤥ ⥪ 
  | {ਠ: ⠫  t  ⮬ ॢ 
  |  ୥  x; ⥪ ᮤন   x}
  | while ((t < val [x]) and (left [x] <> null)) or
  | |     ((t > val [x]) and (right [x] <> null)) do begin
  | | if t < val [x] then begin
  | | | ..  ⥪  <x, l>
  | | | x := left [x];
  | | end else begin {t > val [x]}
  | | | ..  ⥪  <x, r>
  | | | x := right [x];
  | | end;
  | end;
  | if t <> val [x] then begin {t   ॢ}
  | | get_free (i); val [i] := t;
  | | left [i] := null; right [i] := null; diff [i] := 0;
  | | if t < val [x] then begin
  | | | ..  ⥪  <x, l>
  | | | left [x] := i;
  | | end else begin {t > val [x]}
  | | | ..  ⥪  <x, r>
  | | | right [x] := i;
  | | end;
  | | d := 1;
  | | {ਠ: ⥪ ᮤন   襬 ॢ,
  | |    ண 㢥稫  ࠢ  ⮩ 
  | |  室 ॢ  d (=0  1);  ॢ  ᡠ-
  | |  ஢; 祭 diff   設 ࠢ;  -
  | |  ⠫쭮 ॢ    ⠫    뫮  -  ⭮,
  | |  祭 diff}
  | | while (d <> 0) and ..⥪  do begin {d = 1}
  | | | ..  ⥪   <v, direct>
  | | | if direct = l then begin
  | | | | if diff [v] = 1 then begin
  | | | | | c := 0;
  | | | | end else begin
  | | | | | c := 1;
  | | | | end;
  | | | | diff [v] := diff [v] - 1;
  | | | end else begin {direct = r}
  | | | | if diff [v] = -1 then begin
  | | | | | c := 0;
  | | | | end else begin
  | | | | | c := 1;
  | | | | end;
  | | | | diff [v] := diff [v] + 1;
  | | | end;
  | | | {c =   ॢ  ୥  v  ࠢ-
  | | |    室 ॢ; ᨢ diff ᮤন ࠢ-
  | | |   祭  ⮣ ॢ;  襭
  | | |  ᡠ஢  v}
  | | | balance (v, d1); d := c + d1;
  | | end;
  | end;
  end;

  ஢,  祭 d   ࠢ ⮫쪮 0  1
(  -1): ᫨ c = 0,  diff [v] = 0  ஢  ந-
.

     ணࠬ 㤠 ந 筮.   ᭮  ࠣ-
 ⠪:

  {ਠ: ⥪ ᮤন   襬 ॢ,
    ண   ࠢ  ⮩ 
   室 ॢ  d (=0  -1);  ॢ
   ᡠ஢; 祭 diff   設 ࠢ;
    ⠫쭮 ॢ  ⠫  뫮 -
    ⭮, 祭 diff}
  while (d <> 0) and ..⥪  do begin
  | {d = -1}
  | ..  ⥪   <v, direct>
  | if direct = l then begin
  | | if diff [v] = -1 then begin
  | | | c := -1;
  | | end else begin
  | | | c := 0;
  | | end;
  | | diff [v] := diff [v] + 1;
  | end else begin {direct = r}
  | | if diff [v] = 1 then begin
  | | | c := -1;
  | | end else begin
  | | | c := 0;
  | | end;
  | | diff [v] := diff [v] - 1;
  | end;
  | {c =   ॢ  ୥  v  ࠢ-
  |    室 ॢ; ᨢ diff ᮤন
  |  ࠢ 祭  ⮣ ॢ;
  |   襭 ᡠ஢  v}
  | balance (v, d1);
  | d := c + d1;
  end;

 ஢,  祭 d   ࠢ ⮫쪮 0  -1
(   -2): ᫨ c = -1,  diff [v] = 0  ஢  -
.
     ⬥⨬ ⠪,  稥 ⥪  譨  ६-
 father  direction ( ஫ ⥯ ࠥ 設 ⥪).

     12.2.6. ,    
     ()  ன   砥 ஢ (. 㭮 )
;
     ()  ஢ ॡ       饭
(᫥ 祣  ॢ ⠭ ᡠ஢),
         ६     㤠   
 饭.

     砭.  ࠫ    ணࠬ    
㤠  ⠪,  ⮡   뫨    宦  
㣠. ᯮ ᯥ䨪   ,      -
.

        㣨 ᯮᮡ ।⠢ , ࠭-
騥 ᫮ ⢨ 浪 log n   . 襬
   (뢠 -ॢﬨ).
         設 ᮤঠ    ࠭
⢠.      㦨  ࠭楩    ࠢ
ॢ. 㤥 ⥯ ࠭  設 k >= 1 ⮢ -
⢠ (᫮ k    設  設,  ⠪ 
  㤠  ⮢, . ).  k -
⮢ 㦠 ࠧ⥫ﬨ  k+1  ॢ.    䨪஢
஥  ᫮ n >= 1. 㤥 ᬠਢ ॢ, 騥
⠪ ᢮⢠:
     (1)  設 ᮤন  n  2n ⮢ ( ᪫-
祭 ,   ᮤঠ  ᫮ ⮢  0
 2n).
     (2) 設  k ⠬    k+1  뭠,    
 뭮  (⠪ 設 뢠 ﬨ).
     (3)   室    ⮩  .
       ந室 ⠪. ᫨ ,   
,    (..  ᮤন   2n ⮢),  
஡. ᫨  ,  2n+1  (      
  ) ࠧ     n ⮢  ࠧ-
騩  । .  ।     -
   設 ।饣 ஢.  , ᫨   -
 2n ⮢. ᫨   ,   ࠧ  ,  -
  ।   .. ᫨   殢  ⨬
   ७,    ,  ७  -
饯   設,   ॢ 㢥稢  1.
      .  , 室饬   -
, ᢮  㤠 ।⢥ ᫥饣  , -
 室  . ⮬ 筮  㤠 -
    .  ᫨   ⮬ ⠭ ,  
    ᥤ  - ᫨ ⮫쪮      
  쭮    ࠧ  n. ᫨    
ࠧ n,     2n ⮢,   ࠧ⥫ -
2n+1. ᫥ 㤠   ⠥ 2n ⮢ - 
ࠧ   . ᫨  ⮬ 設 ।饣 ஢  -
  ,    ..

     12.2.7.  ᠭ 奬 ࠭ , 㡥-
,    ⠪   C*log(n) ⢨ 
権 祭, ᪫祭  ஢ન ਭ.

     12.2.8.  । ᡠ஢  ॢ  :
ॡ, ⮡   設    ࠢ ॢ
  ᫨誮 ᨫ쭮 ⫨騥 ⢠ 設. (२-
⢮ ⠪ । ⮨  ⮬,   饭 -
  ᡠ஢  ⮫쪮   設.) 
 ᭮ ⮩    ᯮᮡ  ࠭  ,  ࠭騩
業    C*log(n)  ⢨  祭, 㤠  ஢ન
ਭ. (.  ⠪ ᯮ 訥    
饭.  ஡ .   줠, ࣥ  
" ".)
