ሞሪስ ትራቫርስል  


የችግር ደረጃ መካከለኛ
ውስጥ በተደጋጋሚ ተጠየቀ አማዞን ፌስቡክ አራት ኪይትስ google የ Microsoft
ዛፍ የዛፍ ተሻጋሪ

ሞሪስ መሻገሪያ በሁለትዮሽ ዛፍ ውስጥ የሚገኙትን አንጓዎች ቁልል እና ድጋሜ ሳይጠቀሙ ለማቋረጥ የሚያስችል ዘዴ ነው ፡፡ ስለዚህ የቦታውን ውስብስብነት ወደ መስመራዊነት መቀነስ።

Inorder መተላለፍ  

ለምሳሌ

ሞሪስ ትራቫርስልጭንቅላታም መያያዣ መርፌ

9 7 1 6 4 5 3
            1

          /    \

        2        3

      /   \

   4        5
4 2 5 1 3
            7

          /   \

       14       21
14 7 21

አልጎሪዝም

  1. ከአንድ መስቀለኛ መንገድ ጋር የሚዛመዱ ተለዋዋጮችን እና ጠቋሚዎችን የያዘ የክፍል መስቀለኛ ክፍልን ያስጀምሩ ፡፡
  2. የስር መስቀለኛ መንገድን የሚቀበል ሞሪስ ትሬቨርሳል ተግባርን ይፍጠሩ።
  3. ሥሩ ከንቱ ከሆነ ይመለሱ ፡፡
  4. የማጣቀሻ curr እንደ ስር ያዘጋጁ ፡፡ Curr ባዶ አይደለም እያለ ተጓዙ ፡፡
  5. የግራው የግራ ልጅ በካሩ ውስጥ የተከማቸ ዋጋ የሌለበት የህትመት ዋጋ ከሆነ እና የቀኝ ልጅ ስለሆነ ፡፡
  6. ሌላ የማዘመኛ curr የግራ ንዑስ ቁጥሩ የቀኝ መስቀለኛ የቀኝ መስቀለኛ መንገድ እና እንደ ግራው የከርሩ ልጅ curr ያዘምኑ።

ኮድ

የሞሪስ ትራቨርሳልን በመጠቀም የሁለትዮሽ ዛፍ ለማቋረጥ የ C ++ ፕሮግራም

#include <bits/stdc++.h> 
using namespace std;
  
struct Node{ 
    int data; 
    struct Node* left; 
    struct Node* right; 
}; 
  
void MorrisTraversal(struct Node* root){ 
    struct Node *curr, *pre; 
  
    if(root == NULL) 
        return; 
  
    curr = root; 
    while(curr != NULL){ 
  
        if(curr->left == NULL){ 
            printf("%d ", curr->data); 
            curr = curr->right; 
        } 
        else{ 
            pre = curr->left; 
            while (pre->right != NULL && pre->right != curr) 
                pre = pre->right; 
  
            if(pre->right == NULL) { 
                pre->right = curr; 
                curr = curr->left; 
            } 
            else{ 
                pre->right = NULL; 
                cout<<curr->data<<" "; 
                curr = curr->right; 
            }
        } 
    } 
} 
  
struct Node* newNode(int data){ 
    struct Node* node = new Node; 
    node->data = data; 
    node->left = NULL; 
    node->right = NULL; 
  
    return (node); 
} 
  
int main(){ 
    struct Node *root = newNode(5);
    root->left = newNode(7);
    root->right = newNode(3);
    root->left->left = newNode(9);
    root->left->right = newNode(6);
    root->left->right->left = newNode(1);
    root->left->right->right = newNode(4);
  
    MorrisTraversal(root); 
  
    return 0; 
}
9 7 1 6 4 5 3

የጃቫ ፕሮግራም ሞሪስ ትራቨርሳልን በመጠቀም የሁለትዮሽ ዛፍ ለማቋረጥ

class Node { 
    int data; 
    Node left, right; 
  
    Node(int item) 
    { 
        data = item; 
        left = right = null; 
    } 
} 
  
class BTree{ 
    Node root; 
  
    void MorrisTraversal(Node root){ 
        Node curr, pre; 
  
        if(root == null) 
            return; 
  
        curr = root; 
        while(curr != null){ 
            if(curr.left == null){ 
                System.out.print(curr.data + " "); 
                curr = curr.right; 
            } 
            else{ 
                pre = curr.left; 
                while(pre.right != null && pre.right != curr) 
                    pre = pre.right; 
  
                if(pre.right == null){ 
                    pre.right = curr; 
                    curr = curr.left; 
                } 
  
                else{ 
                    pre.right = null; 
                    System.out.print(curr.data + " "); 
                    curr = curr.right; 
                } 
            } 
        } 
    } 
  
    public static void main(String args[]){ 
        BTree tree = new BTree(); 
        tree.root = new Node(5);
        tree.root.left = new Node(7);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(9);
        tree.root.left.right = new Node(6);
        tree.root.left.right.left = new Node(1);
        tree.root.left.right.right = new Node(4);
  
        tree.MorrisTraversal(tree.root); 
    } 
}
9 7 1 6 4 5 3

ውስብስብነት ትንተና

የጊዜ ውስብስብነት

ኦ (ኤን) ፣ ምክንያቱም በሁለትዮሽ ዛፍ ውስጥ ያሉትን ሁሉንም አንጓዎች እናቋርጣለን። N ኖዶች ስላሉ የጊዜ ውስብስብነቱ መስመራዊ ነው ፡፡

ተመልከት
ከተሰጠው የደረጃ ቅደም ተከተል ትራንስፖርት BST ን ይገንቡ

የቦታ ውስብስብነት

ኦ (1) ፣ ምክንያቱም እኛ ችግሩን ለመፍታት ድጋሜ ወይም ቁልል እየተጠቀምን አይደለም ፡፡ ለቋሚ የቦታ ውስብስብነት የሚጠቅሙ የማያቋርጥ ተለዋዋጭዎችን ተጠቅመናል ፡፡

መተላለፍን ቀድመው ያዙ  

ለምሳሌ

            1

          /    \

        2        3

      /   \

   4        5
1 2 4 5 3
            7

          /   \

       14       21
7 14 21

አልጎሪዝም

  1. ከአንድ መስቀለኛ መንገድ ጋር የሚዛመዱ ተለዋዋጮችን እና ጠቋሚዎችን የያዘ የክፍል መስቀለኛ ክፍልን ያስጀምሩ ፡፡
  2. መስቀለኛ መንገድን የሚቀበል ተግባር MorrisTraversal ይፍጠሩ።
  3. መስቀለኛ መንገድ ባዶ ሆኖ ሳለ ተጓዙ ፡፡
  4. የመስቀለኛ ክፍል ግራ ልጅ በመስቀለኛ ክፍል ውስጥ የተከማቸ ባዶ የሕትመት ዋጋ ከሆነ እና ትክክለኛ ልጅ ስለሆነ ኖት ያዘምኑ።
  5. ሌላ መደብር የመስቀለኛ ክፍል ግራ ልጅ በሌላ መስቀለኛ መንገድ ተለዋዋጭ curr ውስጥ።
  6. ትክክለኛው የጠርዝ ልጅ መስቀለኛ (መስቀለኛ መንገድ) ከንቱ አይደለም ወይም እኩል ካልሆነ እና ተሻጋሪ እና ትክክለኛ ልጅ ስለሆነ ፡፡
  7. ትክክለኛው የቁርጥ ልጅ ከኖድ ወይም ከእኩል ጋር እኩል ከሆነ ፣ የቀኝ የከርሩን ልጅ እንደ ትክክለኛ እና አንጓ እንደ ትክክለኛ ልጅ ያዘምኑ።
  8. ሌላ የሕትመት መስቀለኛ መንገድ ውሂብ ያትሙና የግራ ልጅ እንደመሆንዎ መጠን ትክክለኛውን የጠርዝ ልጅ እንደ መስቀለኛ እና መስቀለኛ መንገድ ያዘምኑ።

ኮድ

የሞሪስ ትራቨርሳልን በመጠቀም የሁለትዮሽ ዛፍ ለማቋረጥ የ C ++ ፕሮግራም

#include <bits/stdc++.h> 
using namespace std;  
  
class node{  
    public: 
        int data;  
        node *left, *right;  
};  
  
node* newNode(int data){  
    node* temp = new node(); 
    temp->data = data;  
    temp->left = temp->right = NULL;  
    return temp;  
}  
  
void MorrisTraversal(node* root){  
    while(root){  
        if(root->left == NULL){  
            cout<<root->data<<" ";  
            root = root->right;  
        }  
        else{  
            node* curr = root->left;  
            while(curr->right && curr->right != root)  
                curr = curr->right;  
  
            if(curr->right == root){  
                curr->right = NULL;  
                root = root->right;  
            }  
  
            else{  
                cout<<root->data<<" ";  
                curr->right = root;  
                root = root->left;  
            }  
        }  
    }  
}  
  
int main(){  
    node *root = newNode(5);
    root->left = newNode(7);
    root->right = newNode(3);
    root->left->left = newNode(9);
    root->left->right = newNode(6);
    root->left->right->left = newNode(1);
    root->left->right->right = newNode(4);  
  
    MorrisTraversal(root);  
  
  
    return 0;  
}
5 7 9 6 1 4 3

የጃቫ ፕሮግራም ሞሪስ ትራቨርሳልን በመጠቀም የሁለትዮሽ ዛፍ ለማቋረጥ

class Node{ 
      
    int data; 
    Node left, right; 
      
    Node(int item){ 
        data = item; 
        left = right = null; 
    } 
}
  
class BTree{ 
      
    Node root; 
      
    void MorrisTraversal(){ 
        MorrisTraversal(root); 
    } 
  
    void MorrisTraversal(Node node) { 
        while(node != null){ 
            if(node.left == null) { 
                System.out.print(node.data + " "); 
                node = node.right; 
            } 
            else{ 
                Node curr = node.left; 
                while (curr.right != null && curr.right != node) { 
                    curr = curr.right; 
                } 
  
                if(curr.right == node){ 
                    curr.right = null; 
                    node = node.right; 
                } 
   
                else{ 
                    System.out.print(node.data + " "); 
                    curr.right = node; 
                    node = node.left; 
                } 
            } 
        } 
    } 
      
    public static void main(String args[]){ 
        BTree tree = new BTree(); 
        tree.root = new Node(5);
        tree.root.left = new Node(7);
        tree.root.right = new Node(3);
        tree.root.left.left = new Node(9);
        tree.root.left.right = new Node(6);
        tree.root.left.right.left = new Node(1);
        tree.root.left.right.right = new Node(4);
        
        tree.MorrisTraversal(); 
    } 
}
5 7 9 6 1 4 3

ውስብስብነት ትንተና

የጊዜ ውስብስብነት

ኦ (ኤን) ፣ ምክንያቱም በሁለትዮሽ ዛፍ ውስጥ ያሉትን ሁሉንም አንጓዎች እናቋርጣለን። N ኖዶች ስላሉ የጊዜ ውስብስብነቱ መስመራዊ ነው ፡፡

ተመልከት
የድህረ ቅጥያ አገላለጽ ግምገማ

የቦታ ውስብስብነት

ኦ (1) ፣ ምክንያቱም እኛ ችግሩን ለመፍታት ድጋሜ ወይም ቁልል እየተጠቀምን አይደለም ፡፡ ለቋሚ የቦታ ውስብስብነት የሚጠቅሙ የማያቋርጥ ተለዋዋጭዎችን ተጠቅመናል ፡፡