Randomized Search Trees Raimund Seidel Cecilia R. Aragon Edited by Ohad Barzilay

Abstract A randomized strategy for maintaining balance in dynamically changing search trees that has optimal expected behavior.

Introduction נרצה לאחסן בצורה יעילה את קבוצת האברים X במבנה של עץ חיפוש. יהי שורש העץ. בניו השמאלי והימני של y: ו- בהתאמה. זמן הגישה לאיבר מ-X תלוי בעומקו של האיבר ! בבנייה offline של העץ (X ידוע מראש) נרצה שגודלם של- X< ושל- <X יהיה שונה לכל היותר באחד. עומק עץ מאוזן לא עולה על log2(n+1).

Introduction (con’t) עצים השומרים על מבנה מאוזן כאשר תוכנם משתנה דינאמית: AVL-Trees (a,b)-Trees BB(α)-Trees RB-Trees מבנים אלו שומרים על זמן גישה ועדכון של O(logn) ב-worst case. לעתים נדרש לשמור מידע בצמתים על מצב העץ כדי לאפשר restructuring במהלך העדכונים. עדכונים כאלו נקראים Rotations.

Rotate Operation Rotate Left x y A B C x y A B C Rotate Right

Related work בחירת פרמטרים נכונה ב- (a,b)-Trees וב- BB(α)-Trees מבטיחה מספר סיבובים קבוע בממוצע עבור m פעולות. אפשר להראות ש"רוב" הסיבובים קורים "קרוב" לשורש. עבור BB(α)-Trees אפשר להגיע ל- O(m/s) סיבובים עבור עץ בגודל s לאורך m פעולות. לפעמים נרצה לאפשר גישה מהירה יותר לחלק מהאברים: Offline Online

Related work פתרונות כגון D-trees או עצי 2-3 נותנים: גישה לאיבר ממשקל w בזמן O(log(W/w)) כאשר W הוא סכום המשקולות על העץ. עדכון איבר O(log(W/min{w-,w,w+})) כאשרw- ו- w+ הם האברים שבאים לפני ואחרי האיבר ממשקל w. עץ AVL ועץ אדום-שחור מציגים דוגמא למבנה נתונים שבו רק ביט אחד נשמר בכל קודקוד ומרמז על מבנה העץ. Splay Trees לא דורשים שום מידע נוסף אולם סובלים מהחסרונות של: שינויים מבניים גם במהלך גישה (ולא רק במהלך עדכון) לא מתאימים למימוש range-trees או segment-trees לא מתאימים לעבודה בסביבת cache .

"מריץ' ורץ' יוצא ריץ'רץ'..." Tree + Heap → Treap Let X be a set of n items each of which associated with a key and a priority. The treap of X is: An in-order binary tree with respect to the key. A Heap with respect to the priority.

Heap, Heap, Hooray ! עץ בינארי מאוזן כמעט מלא אב גדול מערכי בניו פעולות: ממשק - Extract_Max, Insert, Delete תחזוקה - Heapify – (שמירת תכונת הערמה). שימושים: תור קדימויות. מיון.

Binary Tree A parent is smaller than its left child and greater than its right child. 1 2 3

Treap Property אם y הוא בנו הימני של x אז: דוגמא: 80 V 57 S 37 A 60 G 63 Z 47 X 22 W 36 Y 31 D אם y הוא בנו הימני של x אז: x.priority < y.priority x.key < y.key דוגמא: המפתחות הם תווים (A-Z) העדיפויות הן שלמים (1-100)

To Be or Not to Be… אם נניח כי העדיפויות שונות זו מזו אזי לכל קבוצה סדורה X קיים ויחיד Treap כנ"ל השורש הוא הצומת בעל העדיפות הגבוהה ביותר שאר הצמתים מוכנסים לפי ערכי מפתחותיהם הכנסת אברי X בסדר יורד עפ"י עדיפויותיהם, ע"י ההכנסה "הרגילה" לעץ בינארי, תיתן את ה- Treap המבוקש.

Treap Operations Locate(T,key) Insert(T,x) חפש x ב-T חיפוש "רגיל" כך ש: x.key=key Insert(T,x) ראשית חפש מקום להכניס את x כעלה בעץ חיפוש בינארי (עפ"י x.key). סובב את x כלפי מעלה (rotate-up) עד שתספק את תכונת הערמה (עפ"י x.priority).

דוגמא נכניס לעץ את הצומת (69,L) V G Z A S X D K U Y J P T M Q L W 80 60 G 63 Z נכניס לעץ את הצומת (69,L) 37 A 57 S 47 X 31 D 53 K 39 U 22 W 36 Y 15 J 48 P 21 T 17 M 34 Q 69 L

דוגמא נכניס לעץ את הצומת (69,L) 80 V 60 G 63 Z נכניס לעץ את הצומת (69,L) נפעפע את הצומת החדש כלפי מעלה ע"י שימוש ב-rotate 37 A 57 S 47 X 31 D 53 K 39 U 22 W 36 Y 15 J 48 P 21 T 69 L 34 Q 17 M

דוגמא נכניס לעץ את הצומת (69,L) 80 V 60 G 63 Z נכניס לעץ את הצומת (69,L) נפעפע את הצומת החדש כלפי מעלה ע"י שימוש ב-rotate 37 A 57 S 47 X 31 D 53 K 39 U 22 W 36 Y 15 J 69 L 21 T 48 P 17 M 34 Q

דוגמא נכניס לעץ את הצומת (69,L) 80 V 60 G 63 Z נכניס לעץ את הצומת (69,L) נפעפע את הצומת החדש כלפי מעלה ע"י שימוש ב-rotate 37 A 57 S 47 X 31 D 69 L 39 U 22 W 36 Y 53 K 48 P 21 T 15 J 17 M 34 Q

דוגמא נכניס לעץ את הצומת (69,L) 80 V 60 G 63 Z נכניס לעץ את הצומת (69,L) נפעפע את הצומת החדש כלפי מעלה ע"י שימוש ב-rotate 37 A 69 L 47 X 31 D 53 K 57 S 22 W 36 Y 15 J 48 P 39 U 17 M 34 Q 21 T

דוגמא נכניס לעץ את הצומת (69,L) 80 V 69 L 63 Z נכניס לעץ את הצומת (69,L) נפעפע את הצומת החדש כלפי מעלה ע"י שימוש ב-rotate 57 S 47 X 60 G 37 A 53 K 48 P 39 U 22 W 36 Y 31 D 15 J 17 M 34 Q 21 T

More Treap Operations Delete(T,x) Split(X,a) ההפך מהכנסה: נאתר את הצומת נפעפע אותו כלפי מטה "נתלוש" אותו Split(X,a) נרצה לחלק את X לשתי קבוצות X1 ו- X2 כך ש: .

Split & Join Split(X,a) Join(X1,X2) נרצה לאחד את הקבוצות X1,X2 המקיימות כי כל אברי X1 קטנים מכל אברי X2. צור צומת זמני שבנו השמאלי יהיה T1 ובנו הימני T2. מחק את הצומת הזמני מהעץ (ע"י פעולת delete)

Finger Search FingerSearch(T,x,key) מעוניינים למצוא צומת y ב-T כך ש: y.key=key נתון מצביע (finger) לצומת x בעץ שאולי קרוב לצומת y המבוקש. כדי לאתר את y ננוע על המסלול בין x ל-y (הסברים בהמשך...)

"חלץ כרסו" (Excision) בהינתן קבוצה X נרצה לחלק אותה לשתי קבוצות – Y ו- Z כך ש: שימושי למיון-ז'ורדן ימומש ע"י פעולות split ו- join

עצים לא ממושקלים עצים ממושקלים ביצועים עצים לא ממושקלים עצים ממושקלים

Unweighted Randomized Search Trees - Definition Let X be a set of items, each of which is uniquely identified by a key that is drawn from a totally ordered set. We define an unweighted randomized search tree for X to be a treap for X where the priorities of the items are independent, identically distributed continuous random variables.

"דברי במספרים גברת..." (Bounds on expected behavior) Access Time – O(logn) Insertion Time - O(logn) *Insertion Time with predecessor/successor handle – O(1) Deletion time - O(logn) *Deletion time for element with handle - O(1) Number of rotations per update – 2

"...דברי בציונים" +Time for finger search over distance d - O(logd) +Time for fast finger search over distance d - O(log min{d,n-d}) Time for joining two trees of size m and n – O(log max{m,n}) Time for splitting a tree into trees of size m and n - O(log max{m,n}) **Time for fast joining/splitting - O(log min{m,n}) +Time for excising a tree of size d - O(log min{d,n-d})

"והרי עדכון שהגיע זה עתה..." Update time if cost of rotating a subtree of size s is O(s) - O(logn) Update time if cost of rotating a subtree of size s is O(s logks ), k≥0 - O(logk+1n) Update time if cost of rotating a subtree of size s is O(sa) - O(na-1) Update time if cost of rotating cost is f(s), with f(s) non-negative:

Weighted Randomized Search Trees - Definition Let X be a set of items identifiable by keys drawn from a totally ordered universe. Every item x∊X has associated with it an integer weight w(x) > 0. We define the weighted randomized search tree for X as a treap for X where the priorities are independent continuous random variables defined as follows: Let F be a fixed continuous probability distribution. The priority of element x is the maximum of w(x) independent random variables, each with distribution F .

Notation Let T be a weighted randomized search tree for a set X of weighted items. W denotes the sum of the weights of the items in X For an item x, the predecessor and the successor (by key rank) in X are denoted by x- and x+ respectively Tmin and Tmax denote the items of minimal and maximal key rank in X

Bounds on Expectation of Performance Time to access item x Time to insert item x Time to delete item x Insertion time for item x with handle on predecessor

Bounds on Expectation of Performance Time to delete item x with handle Number of ratations per update on item x Time for finger search between x and y, where V is the total weight between them. Join trees T1 and T2 of weight W1 and W2.

Bounds on Expectation of Performance Time to split T into trees T1 and T2 of weight W1 and W2. Time to fast joining/splitting Time for increasing weight of item x by ∆ Time for decreasing weight of item x by ∆

התאמת עדיפויות בכל גישה לאיבר x נגריל מספר אקראי r אם r גדול מ- x.priority נעדכן את העדיפות של x להיות ה-r החדש אם צריך, נפעפע את x כלפי מעלה (שמירה על תכונת הערמה) לאחר שניגשנו ל-x, k פעמים – תוחלת עומקו של x בעץ תהיה O(log(1/p)), כאשר p הוא שכיחות הגישות ל-x בעץ.

ניתוח עצי חיפוש אקראיים

Definitions D(x) - The depth of node x in a tree. S(x) - The size of the subtree rooted at node x. P(x, y) - The length of the unique path between nodes x and y in the tree. SL(x) and SR(x) - The length of the right Spine of the Left subtree of x and the length of the left Spine of the Right subtree of x. Left spine of a tree - The root together with the left spine of the root's left subtree.

More Definitions יהי T ה-treap המתאים לקבוצה: נניח כי אברי X מסודרים בסדר עולה: ki<ki+1 נגדיר את שני משתני האינדיקטור האקראיים הבאים: Ai,j הוא 1 אם"ם xi הוא אב קדמון של xj Ci;l,m הוא 1 אם"ם xi הוא אב קדמון משותף של xl ו-xm

Theorem 1 Let 1 ≤ l,m ≤ n , and let l<m

Proof 1 Clear.

יהי v ה-lca של xl ו- xm: ברור שהצמתים בין xl ל-v תורמים רק ל Ai,l שבסכום השמאלי ברור שהצמתים ביןv ל- xm תורמים רק ל Ai,m שבסכום הימני הצומת v וכל אבותיו עד לשורש תורמים 1 לכל האברים במשוואה ולכן מתקזזים שאר הצמתים בעץ לא תורמים כלום לאף איבר נשאר להשתכנע מדוע מספיק לבדוק רק עד m ורק מ- l

SL(xl) – אורך המסלול הימני ביותר היוצא מהבן השמאלי של xl. נשים לב שאין xi עם i>l על השדרה הימנית. אם לא קיים תת עץ שמאלי ל- xl אז: או ש l=1 וכל הנוסחא היא אפס אחרת xl-1 הוא אב קדמון של xl וכל האברים מתקזזים.

מסקנה נסמן: מלינאריות התוחלת נובע כי:

ניתוח המסקנה משום ש Ai,j ו- Ci;l,m הם משתני אינדיקטור, אזי: ai,j = Ex[Ai,j] = Pr[Ai,j=1] = = Pr[xj הוא אב קדמון של xi] ci;l,m = Ex[Ci;l,m] = Pr[Ci;l,m=1] = = Pr[xm ו- xl הוא אב קדמון משותף של xi] למעשה, בעזרת ניתוח התוחלות לעיל נוכל לנתח את כל הפעולות על העץ.

Ancestor Lemma Let T be the treap for X Let 1≤ i, j ≤ n. All priorities are distinct. xi is an ancestor of xj in T iff among all xh with h between and including i and j, the item xi has the largest priority.

Proof of Ancestor Lemma יהי xm בעל העדיפות הגבוהה ב-T. נסמן: לפי הגדרה, xm הוא שורש ה-treap ו- 'X , ''X הם בניו השמאלי והימני בהתאמה. נפריד למקרים: או ש: i או j שווים ל-m והדרוש נובע או שהם שוכנים בתתי עצים שונים אחרת, הם באותו תת עץ – וממשיכים ברקורסיה.

Common Ancestor Lemma Let T be the treap for X Let 1 ≤ l, m, i ≤ n with l<m. Let pν denote the priority of item x. All priorities are distinct xi is a common ancestor of xl and xm in T iff Which can be summarized as:

The Unweighted Case – Corollary 1 In an (unweighted) randomized search tree xi is an ancestor of xj with probability 1 / (|i-j| + 1). in other word we have ai,j= 1 / (|i-j| + 1). Proof: Since in an unweighted randomized search tree these priorities are independent identically distributed continuous random variables.

The Unweighted Case – Corollary 2 Let 1≤l<m≤n. In the case of unweighted randomized search trees the expectation for common ancestorship is given by : Proof: As before.

"תארוז לי הכל..." Let 1≤l<m≤n. Harmonic Numbers: Note the standard bound: lnn<Hn<1+lnn In an unweighted randomized search tree of n nodes the following expectations hold :

תוצאה מפתיעה תוצאה מפתיעה: תוחלת העומק שווה לתוחלת מספר הצאצאים ואולם העומק הוא מ"מ ממורכז בעוד מספר הצאצאים אינו כזה, למשל: Pr[D(x1)=n]=1/n! Pr[S(x1)=n]=1/n במקרה היותר כללי: Pr[S(xl)=s]=O(1/s2)

Lemma In an unweighed randomized search tree with n>1 nodes we have for index 1≤l≤n and any c>1: הוכחה: נזכיר כי עומקו של צומת נתון ע"י מספר אבותיו נפריד את האבות לשמאליים וימנים:

המשך ההוכחה ברור ש- D(xl)=1+L+R לכן L או R צריכים להשיג חצי מהחסם (clnn) נניח בה"כ ש-R. לפי א.ש. צ'רנוב, עבור מ"מ מקרי Z שהוא סכום של מ"מ אינדיקטורים ב"ת מתקיים כי: כדי החסם יהיה ב"ת ב- l נגדיר מ"מ חדש: כאשר המ"מ Ai,l עבור i>n מקיימים Ex[Ai,l]=1/(i-l+1)

סוף ההוכחה ברור שעבור k>0 מתקיים Pr[R’≥k] Pr[R≥k]< נשתמש בעובדה ש: Ex[R’]=Hn-1 , באי השוויון lnn-1<Hn-1<lnn , ובא.ש. צרנוב ונקבל: כלומר ההסתברות שצומת בעץ יהיה בעומק יותר מלוגריתמי קטנה מאוד. ניתוח תוחלת עומקו של עץ היא הרבה יותר מסובכת

המקרה הממושקל Every item xi has associated with it a positive integer weight wi The weighted randomized search tree for a set of items uses as priority for xi the maximum of wi independent continuous random variables, each with the same distribution. For i ≤ j let wi:j denote ∑i≤h≤j wh for i>j define wi:j =wj:i Let W = w1:n denote the total weight.

Corollary In an weighted randomized search tree xi is an ancestor of xj with probability wi/wi:j in other words: ai;j = wi/wi:j הוכחה: עפ"י למת האב הקדמון צריך שיתקיים שעדיפות xi היא הגבוהה מבין עדיפויות xi עד xj כלומר אחד מה-wi מ"מ שהוגרלו עבור xi הוא הגבוה ביותר מבין ה-wi:j שהוגרלו עבור שאר הקדקודים. המ"מ מתפלגים אחיד ולכן הדרוש.

Common Ancestor Lemma (weighted case) Analogous to the previous proof

אי שוויון שימושי The following inequalities (based on the area underneath f(x)=1/x) holds for 0≤α<A≤B : We can combine them with the corollaries just shown and get -

"תארוז לי 2"

החסם לא חוסם... ניתן לראות כי אם השונות של המשקלים wi גדולה מאוד, אין החסמים שהוצגו כאן טובים (בפרט ניתן להשיג את n עצמו, דבר מופרך מיסודו). שיפור החסמים טכני מדי ואינו "מאיר עיניים" כך למשל: Ex[D(x1)] < n - (n-1)(w1/W)1/(n-1)

בהתבסס על משפטי "תארוז לי" ניתוח הפעולות בהתבסס על משפטי "תארוז לי"

חיפושים חיפוש מוצלח חיפוש לא מוצלח מתחיל בשורש ואורכו כמספר האבות של הצומת המבוקש. אי לכך: במקרה הלא ממושקל – O(logn) במקרה הממושקל – O(1+log(W/w(x))) חיפוש לא מוצלח מתחיל בשורש ומסתיים ב- x- או ב- x+ במקרה הממושקל – O(1+log(W/min{w(x-),w(x+)}))

הכנסות ומחיקות הכנסת איבר מחיקת איבר חיפוש מקום להכניס אותו כעלה פעפוע כלפי מעלה לשמירת תכונת הערמה נשים לב ששלב הפעפוע חסום ע"י אורך מסלול החיפוש, ולכן זמן ההכנסה פרופורציוני כולו לביצוע חיפוש לא מוצלח ולכן: במקרה הלא ממושקל – O(logn) במקרה הממושקל – O(1+log(W/min{w(x-),w(x+)})) מחיקת איבר הפעולה הפוכה לחלוטין להכנסה ולכן דורשת אותו זמן

הכנסות ומחיקות – ניתוח מספר ה-rotations נניח כי אנו רוצים למחוק את קודקוד x מ-T מספר הסיבובים שנעשה כלפי מטה יהיה כסכום אורכי השדרה השמאלית של בנו הימני והשדרה הימנית של בנו השמאלי מדוע? ב-Rotate Left אנו מקצרים ב-1 את השדרה השמאלית של הבן הימני ב-Rotate Right אנו מקצרים ב-1 את השדרה הימנית של הבן השמאלי

Rotate Operation Rotate Left x y A B C x y A B C Rotate Right

הכנסות ומחיקות – ניתוח מספר ה-rotations לפיכך: במקרה הלא ממושקל – המדובר בפחות מ-2 סיבובים (!) במקרה הממושקל – O(1+log(1 + w(x)/w(x-) + w(x)/w(x+)))

מחיקת איבר עם Handle מחיקת איבר שיש לנו מצביע אליו "חוסכת" את חיפוש האיבר בעץ. אנו נשארים רק עם פעפוע האיבר כלפי מטה וזאת: במקרה הלא ממושקל – O(1) במקרה הממושקל – O(1+log(1 + w(x)/w(x-) + w(x)/w(x+))) דורש מצביע לאב

הכנסת איבר עם Handle בדומה, אם ידוע מיקום האיבר כעלה (ע"י מצביע ל- x- או ל- x+) – נשאר, שוב, רק לפעפע אותו כלפי מעלה. אם נתון רק x-, אולם הבן הימני שלו אינו ריק – יש לאתר את x+. כזכור x+ הוא האיבר התחתון שבשדרה השמאלית של בנו הימני של x-. התקורה במקרה הלא ממושקל היא O(1) במקרה הממושקל היא O(1+log( 1 + w(x-)/w*(x+) )) דורש שמירת מצביע לאב

Finger Searches מעונינים למצוא צומת y ב-T בעל מפתח k, ונתון מצביע (finger) לצומת x בעץ שאולי קרוב לצומת y המבוקש. נניח בה"כ כי: x=xl , y=xm , l<m כל שעלינו לעשות הוא לנוע על המסלול הקצר ביותר שבין xl ל-xm , שאת תוחלתו חישבנו קודם. המסלול יהיה לעלות ל-lca של x ו-y (נקרא לו u) ומשם לרדת ל- y. איך נזהה את ה-lca כשנגיע אליו? אם עברנו בדרך צומת שהמפתח שלו גדול מ-k "פספסנו את הפנייה" בדומה, אם הגענו לשורש העץ דרך בנו הימני, u הוא הצומת האחרון במסלול שאליו נגיע דרך בנו השמאלי (אם אין כזה, x עצמו) תיקון כעת עלול להיות יקר מדי

Finger Searches - Extra Pointers נגדיר "אב שמאלי" של צומת v כצומת הראשון בין v ושורש העץ שהמפתח שלו קטן מ-v. "אב ימני" של צומת v כצומת הראשון בין v ושורש העץ שהמפתח שלו גדול מ-v. הגדרה שקולה: צומת הוא "אב ימני" של כל צומתי השדרה הימנית של בנו השמאלי. צומת הוא "אב שמאלי" של כל צומתי השדרה השמאלית של בנו הימני.

Finger Searches - Extra Pointers נשמור בכל צומת מצביע לאביו השמאלי והימני (nil אם לא קיים כזה) נשתכנע כי תחזוקת המצביעים לא מייקרת את פעולות ההכנסה והמחיקה אלגוריתם ה- Finger Search: התחל ב-x ועלה לאבות הימניים עד שתגיע ל-nil או שהצומת הבא עם מפתח גדול מ-k כעת אתה ב-u. רד ל-y ע"י השוואת מפתחות רגילה.

Finger Searches – Extra keys כל צומת u בעץ יחזיק את min(u) ו-max(u) האיבר הקטן ביותר והגדול ביותר בהתאמה בתת העץ של u ה-lca של x ו- y הוא הצומת z הראשון במסלול בין x לשורש שמקיים: min(z) ≤ k ≤ max(z) תחזוקת min()/max() זמן קבוע במהלך rotations במהלך מחיקת צומת x יש לעדכן את: ה-min() של השדרה השמאלית של תת העץ הימני של הקודם של x בעץ. ה-max() של השדרה הימנית של תת העץ השמאלי של העוקב של x בעץ.

דוגמא בעת מחיקת M מהעץ נעדכן את ערכי ה-min של P ו-S 80 V 69 L 63 Z בעת מחיקת M מהעץ נעדכן את ערכי ה-min של P ו-S בעת מחיקת U מהעץ נעדכן את ערכי ה-max של S ו-L 57 S 47 X 60 G 37 A 53 K 48 P 39 U 22 W 36 Y 31 D 15 J 17 M 34 Q 21 T

Finger Searches – Extra keys העדכונים לא משפיעים אסימפטוטית על המקרה הלא ממושקל אבל עלולים להיות דומיננטיים במקרה הממושקל. כדי להעריך עדכוני min/max בעת הסרת הצומת הגדול\הקטן ביותר בעץ, יש להוסיף זקיפים עם מפתחות של ∞ ו-∞-

Finger Searches –"שיטת הסמוך" נזכיר כי אנחנו יוצאים מ-x בדרך ל-y. אנחנו מפספסים את הפנייה (u=lca) ומגלים זאת רק כשהגענו ל-z (האב הימני של u). נטען כי הדרך חזרה ל-u (excess path) די קצרה במקרה הלא ממושקל. ננסה לספור את צומתי הדרך הזו – excess nodes.

Finger Searches – "שיטת הסמוך" נסמן u=xν כאשר l≤ ν ≤m (בפרט בעל העדיפות הגבוהה ביותר) וכן z=xj כאשר m<j ≤n ה-excess nodes הם מהצורה xi כאשר 1 ≤ i<l נגדיר את המ"מ 0-1, Xi, האם xi הוא access node. E[Xi] הוא ההסתברות להצלחה והוא מורכב מסכום המ"מ הזרים Ei,j (xi הוא access node ו- xj הוא z). כדי ש Ei,j יתקיים צריך ש xj יהיה האב הימני של xi ושל u (כלומר גם xi וגם u נמצאים על השדרה הימנית של תת העץ השמאלי של xj) לפיכך בין i ל- j ל- xj יש את העדיפות הגבוהה ביותר, ל- xi יש את העדיפות השנייה, ול- u יש את העדיפות הגבוהה ביותר בין l ל j-1 לפי הגדרת u זה אומר כי העדיפות הגבוהה ביותר בין l ל- j-1 מתקבלת בין l ל- m.

Finger Searches – "שיטת הסמוך" מקבלים: ותוחלת מספר ה- access nodes היא: נעזר באי השוויון: ונקבל כי התוחלת חסומה ע"י: והפעלה חוזרת של אי השוויון תיתן חסם של 1. הנחנו כי ל- u יש "אב ימני". מה אם לא?

Finger Searches – "שיטת הסמוך" במקרה כזה, u נמצא על השדרה הימנית של העץ כולו ואנו עלולים להגיע עד לשורש העץ. כדי להמנע מכך על כל צומת להחזיק ביט נוסף – האם הוא נמצא על השדרה הימנית או השמאלית של העץ כולו. במהלך האלגוריתם אם נגיע לצומת כזה – אזי הגענו ל- u.

Fast Finger Searches בהינתן מצביעים לצמתים x ו- z בעץ ניתן לחפש צומת y עם מפתח k, ע"י Finger Search שיתבצע לסירוגין ובמקביל משני הצמתים. ננצל את הרעיון כך: נתחזק מצביעים ל- Tmin ול- Tmax. בכל שנרצה לבצע Finger Search מצומת x לצומת y, נבצע את החיפוש המסורג מ-x ומ- Tmax אם k>x.key ומ- Tmin אחרת. זמן החיפוש כעת יהיה פרופורציוני לאורכו של המסלול הקצר יותר ל- y כלומר: O(min{log(m-l+1), log(n-m+1)}) אם נסמן את הפרש המפתחות ב- d=m-l+1, נקבל חסם של O(log min{d,n-d})

Joins and Splits - Join נרצה לאחד את T1 עם T2. כל מפתחותיו של T1 קטנים משל T2 : ניצור עץ חדש ששורשו r. נחבר ל- r את T1 כבן שמאלי ו- T2 כבן ימני נסיר את r סיבוכיות: מחיקת r פרופורציונית לאורך השדרה הימנית של T1 ואורך השדרה השמאלית של T2. כלומר עומקו של האיבר המקסימלי ב- T1 והמינימלי ב- T2 במקרה הלא ממושקל זהו O(log max{m,n}) (m ו-n הוא מספר האברים ב- T1 וב- T2) המקרה הממושקל: (Wi הוא משקלו של Ti)

Joins and Splits – Split נכניס צומת חדש, x, עם מפתח k ועדיפות אינסופית T1 ו- T2 יתקבלו לאחר ההכנסה כבניו של השורש סיבוכיות: חיפוש מקום להכניס בו את הצומת החדש פרופורציוני למספר הפעפועים מעלה עד לשורש, דהיינו אורך השדרות הימנית והשמאלית של T1 ו-T2. זהה ל- Join

Fast Splits נרצה לקצר את אלגוריתם הפיצול לקצר את חיפוש נקודת ההכנסה של r כעלה אם ידוע שT1 המתקבל קטן יחסית, אפשר לנסות לחפש את r ע"י finger search מ-Tmin לקצר את הפעפוע מעלה יהי z ה-lca של Tmin ו-x z הוא: על המסלול בין x ל-Tmin על השדרה השמאלית של T כאשר, במהלך הפעפוע מעלה, r מגיע לשדרה השמאלית (כאביו הימני של z) - עצור בנו השמאלי של x הוא T1 T2 הוא העץ הראשי כאשר במקום x יושם בנו הימני של x

Fast Splits סיבוכיות פרופורציוני לאורך המסלול בין Tmin ל-x הפעפוע למעלה לא ארוך יותר מהמסלול בין x ל-z סה"כ O(logm) (m הוא מספר הצמתים ב-T1) ביצוע לסירוגין מTmin ו-Tmax ייתן: O(log min {n,m})

Fast Splits – weighted case הפעולה תלויה באורך L המסלול מ-Tmin ל-x כבר ראינו שזה ברור ש- Tmax הוא x- של x, אבל לא ברור שהוא אבא שלו. אולי x הוא בנו הימני של x+ חיפוש עלול לקחת O(1+log(1+w(x-)/w(x+))) כדי שלא יצא שכרנו בהפסדנו – נתחזק מצביעים לקודם ולעוקב בעץ תחזוקת מצביעי אב, עם זאת, דרושה רק עבור צומתי השדרה

Fast Joins רוורס של הפיצול המהיר: נחפש על השדרות הפנימיות (הימנית של T1 והשמאלית של T2) צומת עם עדיפות גבוהה יותר מעדיפות שורש העץ השני (כמו במיזוג רשימות) נניח ש-x על השדרה הימנית של T1 כזה: נמזג את Tx עם T2 ע"י האלגוריתם הרגיל ונתלה את התוצאה במקום x סימטרי הפוך לגבי x2 הסיבוכיות חסומה ע"י סיבוכיות ה- split

סוף Nice applets of treaps can be found on: http://babbage.clarku.edu/~achou/cs160/examples/bst_animation/Treap-Example.html http://babbage.clarku.edu/~achou/cs160/examples/bst_animation/index2.html