מבנה נתונים תמציתי

במדעי המחשב מבנה נתונים תמציתי הוא מבנה נתונים, המשתמש בכמות זיכרון הקרובה לכמות הזיכרון המינמלית הדרושה על פי תורת האינפורמציה, אך (בניגוד לייצוגים דחוסים אחרים), עדיין תומך בביצוע שאילתות בזמן יעיל. הרעיון הוצג במקור על ידי ג'ייקובסון כדי לקודד מערך-סיביות, עצים, וגרפים מישוריים. בניגוד לאלגוריתמים כלליים לדחיסת נתונים, מבני נתונים תמציתיים משמרים את היכולת להשתמש בהם במקום, מבלי לחלץ אותם קודם. תחום קרוב למבני נתונים תמציתיים הוא תחום מבני נתונים דחוסים. בשניהם גודל מבנה הנתונים תלוי במידע המסוים המיוצג במבנה.

עבור מידע מסוים, אם על פי תורת האינפורמציה דרושים <math>Z</math> ביטים לייצוג של המידע, אזי ייצוג של המידע יקרא:
* מרומז אם הוא צורך <math>Z + O(1)</math> ביטים של זיכרון.
* תמציתי אם הוא צורך <math>Z + o(Z)</math> ביטים של זיכרון, 
* קומפקטי אם הוא צורך <math>O(Z)</math> ביטים של זיכרון.
לדוגמה, מבנה נתונים המשתמש ב<math>2Z</math> ביטים של אחסון הוא קומפקטי, <math>Z + \sqrt{Z}</math> ביטים הוא תמציתי, <math>Z + \lg Z</math> ביטים גם הוא תמציתי ו-<math>Z + 3</math> ביטים הוא מרומז.

מבנים מרומזים בדרך כלל מצומצמים לאחסון מידע באמצעות תמורה כלשהי של נתוני הקלט; הדוגמה הידועה ביותר לכך היא הערימה.

== מילונים תמציתיים ==
מילונים תמציתיים הניתנים לאינדוקס, או בשמם הנוסף מילוני דרגה/בחירה, מהווים בסיס למספר טכניקות של ייצוג תמציתי, כגון עצים בינאריים, עצים <math>k</math>-ארים, מולטי קבוצות, עצי סיפות ומערכים. הבעיה הבסיסית היא לאחסן תת-קבוצה <math>S</math> של העולם <math>U =
[0 \dots n) = \{0, 1, \dots, n - 1\}</math> המיוצגת בדרך כלל על ידי מערך-סיביות <math>B[0 \dots n)</math> כאשר <math>B[i] = 1</math> אם ורק אם <math>i \in S</math>. מילון הניתן לאינדוקס תומך בפעולות הרגילות על מילונים (שאילתות, ובמקרה הדינמי גם הוספות ומחיקות) כמו גם בפעולות הבאות:
* דרגה (rank) - שאילתה המקבלת אינדקס i של איבר ואיבר q (<math>q \in \{0, 1\}</math>) ומחזירה את מספר האיברים ב-B עד האינדקס i שהערך שלהם הוא q. פורמלית: <math>\mathbf{rank}_q(i) = |\{ k \in [0 \dots i] : B[k] = q \}|</math>.
* בחר (select) - שאילתה המקבלת אינדקס i ואיבר q (<math>q \in \{0, 1\}</math>) ומחזירה את המיקום של האיבר ה-i שהערך שלו הוא q. פורמלית: <math>\mathbf{select}_q(i)= \min \{k \in [0 \dots n) : \mathbf{rank}_q(k) = i\}</math>.

ישנו ייצוג פשוט המשתמש ב <math>n + o(n)</math> ביטים של זיכרון (מערך הביטים המקורי ומבנה עזר בגודל <math>o(n)</math>) התומך בפעולות דרגה (rank) ובחירה (select) בזמן קבוע. הוא משתמש ברעיון דומה לזה של שאילתות מינימום-טווח; ישנו מספר קבוע של רקורסיות לפני שעוצרים בתת-בעיה בגודל מוגבל. מערך הביטים  <math>B</math> מחולק לגושים גדולים בגודל <math>l = \lg^2 n</math>  ביטים וגושים קטנים בגודל <math>s = \lg n / 2</math> ביטים. לכל גוש גדול מאחסנים את הדרגה של הביט הראשון בטבלה נפרדת <math>R_l[0 \dots n/l)</math>; כל כניסה כזאת דורשת <math>\lg n</math> ביטים וסך הכל של <math>(n/l) \lg n = n / \lg n</math> ביטים של זיכרון. בגוש גדול מאוחסנת טבלה נוספת <math>R_s[0 \dots l/s)</math>, השומרת את הדרגה של כל אחד מ-<math>l/s = 2 \lg n</math>  הבלוקים הקטנים שהיא מכילה. ההבדל כאן הוא שדרושים רק <math>\lg l = \lg \lg^2 n = 2 \lg \lg n</math> ביטים לכל כניסה, כיוון שמספיק לשמור רק את ההפרשים מהדרגה של הביט הראשון בגוש הגדול המכיל. לכן, הטבלה דורשת סך הכל  <math>(n/s) \lg l = 4 n \lg \lg n / \lg n</math> ביטים. ניתן להשתמש בטבלת חיפוש <math>R_p</math> כדי לשמור את התשובה לכל שאילתת דרגה אפשרית במחרוזת ביטים באורך <math>s</math> לכל <math>i \in [0, s)</math>, בעלות של <math>2^s s \lg s = O(\sqrt{n} \lg n \lg \lg n)</math> ביטים של זיכרון. כיוון שכל טבלאות העזר הללו צורכות <math>o(n)</math> זיכרון, מבנה הנתונים הזה תומך בשאילתות דרגה בזמן <math>O(1)</math> ו<math>n + o(n)</math> ביטים של זיכרון.

כדי לענות על שאילתה עבור <math>\mathbf{rank}_1(i)</math> בזמן קבוע, האלגוריתם מחשב בזמן קבוע:
* <math>\mathbf{rank}_1(i) = R_l[\lfloor i / l \rfloor] + R_s[\lfloor i / s\rfloor] + R_p[i \lfloor i / s\rfloor, i \text{ mod } s]</math>
בפועל, ניתן להחליף את טבלת החיפוש <math>R_p</math> בפעולות על ביטים ובטבלאות קטנות יותר כדי למצוא את מספר הביטים הדולקים בבלוקים הקטנים. זה לעיתים קרובות מועיל, שכן מבני נתונים תמציתיים משמשים למערכות נתונים גדולות, שבהן החטאות מטמון נעשות הרבה יותר תכופות, והסיכויים שטבלת החיפוש תפונה מהמטמון גדלים. ניתן לתמוך בקלות בשאילתות בחירה על ידי ביצוע חיפוש בינארי על אותו מבנה עזר המשמש לפעולות דרגה; עם זאת, דבר זה דורש <math>O(\lg n)</math> זמן במקרה הגרוע ביותר. ניתן להשתמש במבנה מסובך יותר המשתמש ב-<math>3n/\lg \lg n + O(\sqrt{n} \lg n \lg \lg n) = o(n)</math> ביטים של זיכרון נוסף, כדי לתמוך בפעולות בחירה בזמן קבוע. למעשה, ברבים מהפתרונות האלה מוסתרים קבועים בסימון <math>O(\cdot)</math> אשר שולטים בבעיה לפני שניכר יתרון אסימפטוטי כל שהוא; יישומים באמצעות פעולות נרחבות על מילים ובלוקים של מילים-מיושרות לעיתים קרובות מראים ביצועים טובים יותר בפועל.

=== מילונים דחוסי-אנטרופיה ===
גישת ה-<math>n + o(n)</math> זיכרון ניתנת לשיפור בזכות ההבחנה כי ישנם <math>\textstyle \binom{n}{m}</math> תתי קבוצות של <math>[n)</math> באורך <math>m</math> (או מחרוזות בינאריות באורך <math>n</math>  עם בדיוק <math>m</math> 1ים), ולכן <math>\textstyle \mathcal{B}(m,n) = \lceil \lg \binom{n}{m} \rceil</math> הוא החסם התחתון של תורת האינפורמציה על מספר הביטים הדרושים לאחסון <math>B</math>. ישנו מילון (סטטי) תמציתי המשיג את החסם הזה, דהיינו משתמש ב-<math>\mathcal{B}(m,n) + o(\mathcal{B}(m,n))</math> זיכרון. ניתן להרחיב את המבנה הזה כדי לתמוך בשאילתות דרגה ובחירה, תוך שימוש ב- <math>\mathcal{B}(m,n) + O(m + n \lg \lg n / \lg n)</math> זיכרון. ניתן לצמצם את החסם הזה לתחלופת זיכרון/זמן על ידי הקטנת מקום האחסון של המילון ל-<math>\mathcal{B}(m,n) + O(n t^t / \lg^t n + n^{3/4})</math> וזמן שאילתה <math>O(t)</math> .

== דוגמאות ==

כאשר צריך לקודד רצף של פריטים בעלי אורך משתנה (כגון מחרוזות), ישנן מספר אפשרויות: גישה ישירה היא לשמור את האורך ואת הפריט באותה רשומה- והללו יכולות להיות ממוקמות אחת אחרי השנייה. זה מאפשר מעבר יעיל לעוקב, אבל לא מוצא את הפריט הkי. אופציה נוספת היא למקם את הפריטים לפי הסדר עם תו מפריד (למשל, מחרוזת עם סיומת אפס). אפשרות זו משתמשת במפריד במקום באורך, והיא איטית יותר באופן משמעותי, מפני שיש לסרוק את כל הרצף כדי למצוא תווים מפרידים. שתי האפשרויות יעילות מבחינת זיכרון. גישה אחרת היא הפרדה מאוגדת: ניתן למקם את הפריטים זה אחר זה, ללא מפרידים. ניתן לשמור את גבולות הפריט יכולים כרצף של אורכים, או באופן יעיל יותר, כהיסטים בתוך רצף זה. לחלופין, מקודדים בנוסף מחרוזת בינארית נפרדת המורכבת מ1ים במקומות בהם פריט מתחיל, ו0ים בכל מקום אחר. בהינתן המחרוזת זאת, פונקציית ה<math>select</math> יכולה לקבוע במהירות היכן כל פריט מתחיל, בהינתן האינדקס שלו. מבנה זה קומפקטי אך לא תמציתי, היות שהוא צורך 2Z זיכרון, דהיינו (O(Z.

דוגמה נוספת היא ייצוג של עץ בינארי: עץ בינארי שרירותי על <math>n</math> צמתים ניתן לייצג ב-<math>2n + o(n)</math> ביטים, תוך תמיכה במגוון רחב של פעולות על כל צומת, אשר כוללות את מציאת האב שלו, הילד הימני והשמאלי שלו, והחזרת גודל של תת-עץ, כל אחת בזמן קבוע. מספר העצים הבינאריים השונים על <math>n</math> קודקודים הוא <math>{\tbinom{2n}{n}} /(n+1)</math>. עבור <math>n</math> גדול, ערך זה הוא בערך <math>4^n</math>; ולכן ידרשו לכל הפחות כ-<math>\log_2(4^n)=2n</math> ביטים כדי לקודד אותו. עץ בינארי תמציתי לפיכך יתפוס רק <math>2</math> ביטים לכל צומת.

== לקריאה נוספת ==
* פונקציית גיבוב מינימלית מושלמת

== הערות שוליים ==

קטגוריה:מבני נתונים