אלגוריתמי סריקת עצים: חיפוש לעומק (DFS) לעומת חיפוש לרוחב (BFS)

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

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

הבנת מבני נתוני עץ

לפני שנצלול לאלגוריתמי הסריקה, בואו נסקור בקצרה את היסודות של מבני נתוני עץ.

מהו עץ?

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

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

סוגי עצים

קיימים מספר וריאציות של עצים, לכל אחד מהם מאפיינים ומקרי שימוש ספציפיים. כמה סוגים נפוצים כוללים:

• עץ בינארי: עץ שבו לכל צומת יש לכל היותר שני צאצאים, המכונים בדרך כלל צאצא שמאלי וצאצא ימני.
• עץ חיפוש בינארי (BST): עץ בינארי שבו הערך של כל צומת גדול או שווה לערך של כל הצמתים בתת-העץ השמאלי שלו וקטן או שווה לערך של כל הצמתים בתת-העץ הימני שלו. מאפיין זה מאפשר חיפוש יעיל.
• עץ AVL: עץ חיפוש בינארי מאוזן עצמית השומר על מבנה מאוזן כדי להבטיח מורכבות זמן לוגריתמית עבור פעולות חיפוש, הוספה ומחיקה.
• עץ אדום-שחור: עץ חיפוש בינארי מאוזן עצמית נוסף המשתמש במאפייני צבע כדי לשמור על איזון.
• עץ N-ary (או עץ K-ary): עץ שבו לכל צומת יכולים להיות לכל היותר N צאצאים.

חיפוש לעומק (DFS)

חיפוש לעומק (DFS) הוא אלגוריתם סריקת עצים הסורק רחוק ככל האפשר לאורך כל ענף לפני שהוא נסוג. הוא נותן עדיפות להיכנס לעומק העץ לפני שהוא סורק אחים. ניתן ליישם את DFS באופן רקורסיבי או איטרטיבי באמצעות מחסנית.

אלגוריתמי DFS

ישנם שלושה סוגים נפוצים של סריקות DFS:

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

דוגמאות יישום (Python)

הנה דוגמאות Python המדגימות כל סוג של סריקת DFS:

            
class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

# Inorder Traversal (Left-Root-Right)
def inorder_traversal(root):
    if root:
        inorder_traversal(root.left)
        print(root.data, end=" ")
        inorder_traversal(root.right)

# Preorder Traversal (Root-Left-Right)
def preorder_traversal(root):
    if root:
        print(root.data, end=" ")
        preorder_traversal(root.left)
        preorder_traversal(root.right)

# Postorder Traversal (Left-Right-Root)
def postorder_traversal(root):
    if root:
        postorder_traversal(root.left)
        postorder_traversal(root.right)
        print(root.data, end=" ")

# Example Usage
root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)

print("Inorder traversal:")
inorder_traversal(root)  # Output: 4 2 5 1 3
print("\nPreorder traversal:")
preorder_traversal(root) # Output: 1 2 4 5 3
print("\nPostorder traversal:")
postorder_traversal(root) # Output: 4 5 2 3 1

            

              
                Copy
              
            
          

DFS איטרטיבי (עם מחסנית)

ניתן ליישם את DFS גם באופן איטרטיבי באמצעות מחסנית. הנה דוגמה לסריקה מקדימה איטרטיבית:

            
def iterative_preorder(root):
    if root is None:
        return

    stack = [root]

    while stack:
        node = stack.pop()
        print(node.data, end=" ")

        # Push right child first so left child is processed first
        if node.right:
            stack.append(node.right)
        if node.left:
            stack.append(node.left)

#Example Usage (same tree as before)
print("\nIterative Preorder traversal:")
iterative_preorder(root)

            

              
                Copy
              
            
          

מקרי שימוש של DFS

• מציאת נתיב בין שני צמתים: DFS יכול למצוא ביעילות נתיב בגרף או בעץ. שקול ניתוב מנות נתונים ברשת (המיוצגת כגרף). DFS יכול למצוא נתיב בין שני שרתים, גם אם קיימים מספר נתיבים.
• מיון טופולוגי: DFS משמש במיון טופולוגי של גרפים מכוונים אציקליים (DAG). תארו לעצמכם תזמון משימות שבהן חלק מהמשימות תלויות באחרות. מיון טופולוגי מסדר את המשימות בסדר המכבד את התלות הללו.
• זיהוי מחזורים בגרף: DFS יכול לזהות מחזורים בגרף. זיהוי מחזורים חשוב בהקצאת משאבים. אם תהליך A מחכה לתהליך B ותהליך B מחכה לתהליך A, זה יכול לגרום לקיפאון.
• פתרון מבוכים: ניתן להשתמש ב-DFS כדי למצוא נתיב דרך מבוך.
• ניתוח והערכת ביטויים: קומפיילרים משתמשים בגישות מבוססות DFS לניתוח והערכת ביטויים מתמטיים.

יתרונות וחסרונות של DFS

יתרונות:

• פשוט ליישום: היישום הרקורסיבי הוא לרוב תמציתי וקל להבנה.
• יעיל בזיכרון עבור עצים מסוימים: DFS דורש פחות זיכרון מ-BFS עבור עצים מקוננים עמוקים מכיוון שהוא צריך לאחסן רק את הצמתים בנתיב הנוכחי.
• יכול למצוא פתרונות במהירות: אם הפתרון הרצוי נמצא עמוק בעץ, DFS יכול למצוא אותו מהר יותר מ-BFS.

חסרונות:

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

חיפוש לרוחב (BFS)

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

אלגוריתם BFS

1. הוסף את צומת השורש לתור.
2. כל עוד התור אינו ריק:
1. הוצא צומת מהתור.
2. בקר בצומת (לדוגמה, הדפס את ערכו).
3. הוסף את כל הצאצאים של הצומת לתור.

דוגמת יישום (Python)

            
from collections import deque

def bfs_traversal(root):
    if root is None:
        return

    queue = deque([root])

    while queue:
        node = queue.popleft()
        print(node.data, end=" ")

        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)

#Example Usage (same tree as before)
print("BFS traversal:")
bfs_traversal(root) # Output: 1 2 3 4 5

            

              
                Copy
              
            
          

מקרי שימוש של BFS

• מציאת הנתיב הקצר ביותר: BFS מובטח למצוא את הנתיב הקצר ביותר בין שני צמתים בגרף לא משוקלל. תארו לעצמכם אתרי רשתות חברתיות. BFS יכול למצוא את החיבור הקצר ביותר בין שני משתמשים.
• סריקת גרפים: ניתן להשתמש ב-BFS כדי לסרוק גרף.
• סריקת אתרי אינטרנט: מנועי חיפוש משתמשים ב-BFS כדי לסרוק את האינטרנט ולאנדקס דפים.
• מציאת השכנים הקרובים ביותר: במיפוי גיאוגרפי, BFS יכול למצוא את המסעדות, תחנות הדלק או בתי החולים הקרובים ביותר למיקום נתון.
• אלגוריתם מילוי שיטפונות: בעיבוד תמונה, BFS מהווה את הבסיס לאלגוריתמי מילוי שיטפונות (לדוגמה, כלי "דלי הצבע").

יתרונות וחסרונות של BFS

יתרונות:

• מובטח למצוא את הנתיב הקצר ביותר: BFS תמיד מוצא את הנתיב הקצר ביותר בגרף לא משוקלל.
• מתאים למציאת הצמתים הקרובים ביותר: BFS יעיל למציאת צמתים הקרובים לצומת ההתחלה.
• מונע לולאות אינסופיות: מכיוון ש-BFS סורק רמה אחר רמה, הוא מונע להיתקע בלולאות אינסופיות, אפילו בגרפים עם מחזורים.

חסרונות:

• דורש זיכרון רב: BFS יכול לדרוש זיכרון רב, במיוחד עבור עצים רחבים, מכיוון שהוא צריך לאחסן את כל הצמתים ברמה הנוכחית בתור.
• יכול להיות איטי יותר מ-DFS: אם הפתרון הרצוי נמצא עמוק בעץ, BFS יכול להיות איטי יותר מ-DFS מכיוון שהוא סורק את כל הצמתים בכל רמה לפני שהוא מעמיק.

השוואה בין DFS ו-BFS

הנה טבלה המסכמת את ההבדלים העיקריים בין DFS ו-BFS:

בחירה בין DFS ו-BFS

הבחירה בין DFS ו-BFS תלויה בבעיה הספציפית שאתה מנסה לפתור ובמאפיינים של העץ או הגרף שאתה עובד איתו. הנה כמה הנחיות שיעזרו לך לבחור:

• השתמש ב-DFS כאשר:
  • העץ עמוק מאוד ואתה חושד שהפתרון נמצא עמוק למטה.
  • שימוש בזיכרון הוא דאגה מרכזית, והעץ אינו רחב מדי.
  • אתה צריך לזהות מחזורים בגרף.
• השתמש ב-BFS כאשר:
  • אתה צריך למצוא את הנתיב הקצר ביותר בגרף לא משוקלל.
  • אתה צריך למצוא את הצמתים הקרובים ביותר לצומת התחלה.
  • זיכרון אינו מגבלה מרכזית, והעץ רחב.

מעבר לעצים בינאריים: DFS ו-BFS בגרפים

בעוד שדנו בעיקר ב-DFS וב-BFS בהקשר של עצים, אלגוריתמים אלה ישימים במידה שווה לגרפים, שהם מבני נתונים כלליים יותר שבהם לצמתים יכולים להיות חיבורים שרירותיים. העקרונות הבסיסיים נשארים זהים, אך גרפים עשויים להציג מחזורים, הדורשים תשומת לב נוספת כדי להימנע מלולאות אינסופיות.

בעת החלת DFS ו-BFS על גרפים, נפוץ לשמור על קבוצה או מערך "ביקר" כדי לעקוב אחר צמתים שכבר נסרקו. זה מונע מהאלגוריתם לבקר מחדש בצמתים ולהיתקע במחזורים.

מסקנה

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