በእጥፍ የተገናኘ ዝርዝርን በመጠቀም የዲኪን አተገባበር  


የችግር ደረጃ መካከለኛ
ውስጥ በተደጋጋሚ ተጠየቀ የ Adobe የመርጨት አማዞን አሜሪካን ኤክስፕረስ ዴ ሻው ፋርስት አራት ኪይትስ GE የጤና google ኦክሲጀን የኪስ ቦርሳ Qualcomm Spotify Sprinklr UHG Optum ዋከር ጎሜ ZScaler
ዲክኤት የተገናኘ-ዝርዝር ተራ ፍልስፍና

የችግሩ መግለጫ  

ችግሩ “በድርብ የተገናኘ ዝርዝርን በመጠቀም የዲኪን ተግባራዊነት” የሚከተሉትን ተግባራት መተግበር ያስፈልግዎታል ይላል ዲክ ወይም ሁለቴ በመጠቀም የተጠናቀቀ ወረፋ የተገናኘ ዝርዝር,

  1. insertFront (x): በዲክ ጅምር ላይ ኤለመንት x ያክሉ
  2. አስገባ መጨረሻ (x): በዲክ መጨረሻ ላይ ኤለመንት x ያክሉ
  3. DeleteFront (): - ከዲክ አጀማመር አንድን አካል ይሰርዙ
  4. deleteEnd (): - ከዲክ መጨረሻ አንድ አባል ይሰርዙ
  5. getFront (): በ Deque መጀመሪያ ላይ ያለውን ንጥረ ነገር ይመልሱ
  6. getEnd (): በ Deque መጨረሻ ላይ ያለውን ንጥረ ነገር ይመልሱ
  7. isEmpty (): - ዲቁ ባዶ ይሁን ይመለሳል
  8. መጠን (): - የዲካን መጠን ይመልሱ
  9. ደምስስ (): - የ Deque ን ሁሉንም ነገሮች ሰርዝ

ለምሳሌ  

insertFront(5)
insertEnd(10)
insertEnd(11)
insertFront(19)
getFront()
getEnd()
deleteEnd()
getEnd()
deleteFront()
getFront()
size()
isEmpty()
erase()
isEmpty()
19
11
10
5
2
false
true

አልጎሪዝም  

ሁለቴ የተገናኘ ዝርዝርን በመጠቀም ዲካን ለመተግበር ፡፡ ሁለት ጠቋሚዎችን ከፊት እና ከኋላ እንጠብቃለን ፣ የፊት ለፊት ነጥቦችን በእጥፍ የተገናኘ ዝርዝር ፊት እና እስከ መጨረሻው ድረስ የኋላ ነጥቦችን እናገኛለን ፡፡ ደግሞም አንድን መጠበቅ አለብን ኢንቲጀር መጠን ፣ በዲኩ ውስጥ የአንጓዎችን ቁጥር የሚያከማች።

አስገባ ፣ ሰርዝ, ወይም ከመጀመር አንድ አካል ያግኙ እንጠቀማለን ፊት ጠቋሚ

አስገባ ፣ ሰርዝ, ወይም ከመጨረሻው አንድ አካል ያግኙ እንጠቀማለን የኋላ ጠቋሚ

በእጥፍ የተገናኘ ዝርዝርን በመጠቀም የዲኪን አተገባበርጭንቅላታም መያያዣ መርፌ

ፊትለፊት (x)

በዲክ ፊት ለፊት አንድ አካል ለማስገባት የሚከተሉትን ያድርጉ

  1. አዲስ መስቀለኛ መንገድ ከሚፈለገው እሴት ጋር ይፍጠሩ እና መስቀለኛ መንገድ ይደውሉ ፡፡
  2. ከፊቱ ባዶ ከሆነ የፊት እና የኋላ እኩል መስቀለኛ መንገድ ያድርጉ ፡፡
  3. ሌላ ፣ ከፊት ለፊት መስቀለኛውን ያስገቡ እና መስቀለኛ መንገዱን እንደ አዲስ ግንባር ምልክት ያድርጉበት ፡፡
  4. የመጠን መጠን
ተመልከት
ከተባዛ ዝርዝር II የተባዙን ያስወግዱ

የጊዜ ውስብስብነት ኦ (1)

የውሸት ኮድ

Create a new node with required value and call it node
if (front == null) {
  front = rear = node
} else {
  node.next = front
  front.prev = node
  front = node
}
size++

መጨረሻ አስገባ (x)

በዲክ መጨረሻ ላይ አንድ አካል ለማስገባት የሚከተሉትን ያድርጉ

  1. አዲስ መስቀለኛ መንገድ በሚፈለገው እሴት ይፍጠሩ እና መስቀለኛ መንገድ ይደውሉ ፡፡
  2. የኋላ ባዶ ከሆነ የፊት እና የኋላ እኩል መስቀለኛ መንገድ ያድርጉ ፡፡
  3. ሌላ ፣ ከኋላ በኋላ መስቀለኛውን ያስገቡ እና መስቀለኛ መንገዱን እንደ አዲስ የኋላ ምልክት ያድርጉበት ፡፡
  4. የመጠን መጠን

የጊዜ ውስብስብነት ኦ (1)

የውሸት ኮድ

Create a new node with required value and call it node
if (rear == null) {
  front = rear = node
} else {
  rear.next = node
  node.prev = rear
  rear = node
}
size++

ሰርዝ ፊት ()

ከዲክ ፊት ለፊት አንድ አካል ለመሰረዝ የሚከተሉትን ያድርጉ

  1. ግንባሩ ከንቱ ከሆነ ፣ የሚሰረዝ ምንም አካል የለም ፣ በቀላሉ ይመለሱ።
  2. ፊት ለፊት ከኋላ ጋር እኩል ከሆነ 1 መስቀለኛ መንገድ ብቻ አለ ፣ የፊት እና የኋላ ባዶ ያድርጉ ፡፡
  3. ሌላ ፣ የፊት እኩልዎችን ከፊት. ፊት ለፊት ያድርጉ እና front.prev ን ይሰርዙ
  4. የመቀነስ መጠን

የጊዜ ውስብስብነት = ኦ (1)

የውሸት ኮድ

if (front == null) {
  return
}
if (front == rear) {
  front = rear = null
} else {
  temp = front
  front = front.next
  front.prev = null
  deallocate space for temp
}
size--

ሰርዝ መጨረሻ ()

ከዲኪ መጨረሻ ላይ አንድ አካል ለመሰረዝ የሚከተሉትን ያድርጉ

  1. የኋላ ባዶ ከሆነ ለመሰረዝ ምንም አንጓ የለም ፣ በቀላሉ ይመለሱ።
  2. የኋላ ከፊት እኩል ከሆነ አንድ መስቀለኛ መንገድ ብቻ አለ ፣ የፊት እና የኋላ ባዶ ያድርጉ ፡፡
  3. አለበለዚያ እንደኋላ.prev እንደኋላ ያድርጉ እና የኋላ.next ን ይሰርዙ ፡፡
  4. የመቀነስ መጠን

የጊዜ ውስብስብነት = ኦ (1)

የውሸት ኮድ

if (rear == null) {
  return;
}
if (rear == front) {
  front = rear = null
} else {
  temp = rear
  rear = rear.prev
  rear.next = null
  deallocate space for temp
}
size--

ፊትለፊት ()

የዲቁ የፊት ክፍል ፊትለፊት የተጠቆመ ነው ፣ ስለሆነም ፊትለፊት ከንቱ ከሆነ ወደ ፊት መመለስ

ተመልከት
የቁልል ንጥረ ነገሮች ጥንድ ቅደም ተከተል ያላቸው መሆናቸውን ያረጋግጡ

የጊዜ ውስብስብነት = ኦ (1)

የውሸት ኮድ

if (front != null) {
  return front.data
}
return -1

መጨረሻ ()

የዲክ የመጨረሻ አካል በስተጀርባ የተጠቆመ ነው ፣ ስለሆነም የኋላ ኋላ ከንቱ መመለስ የኋላ ውሂብ

የጊዜ ውስብስብነት = ኦ (1)

የውሸት ኮድ

if (rear != null) {
  return rear.data
}
return -1

ባዶ ነው()

ዲቁ ከፊትም ከኋላም ባዶ ከሆነ ከንቱ ይሆናል ፣ ስለዚህ ፊት ከንቱ ከሆነ መመለስ ከሆነ ፣ ከዚያ ሐሰት ይመለስ።

የጊዜ ውስብስብነት = ኦ (1)

የውሸት ኮድ

if (front == null) {
  return true
}
return false

መጠን ()

የዲያቆን መጠኑ ‹መጠን› በተሰየመው ተለዋዋጭ ውስጥ ይቀመጣል ፣ ስለዚህ በቀላሉ የመመለስ መጠን ፡፡

የጊዜ ውስብስብነት = ኦ (1)

የውሸት ኮድ

return size

ደምስስ ()

ዲኪን መሰረዝ ማለት የዲቁትን ሁሉንም አንጓዎች መሰረዝ ማለት ነው ፡፡ ሁሉንም አንጓዎች ለመሰረዝ የሚከተሉትን ያድርጉ ፣

  1. የኋላውን እንደ ከንቱ ያዘጋጁ።
  2. ወደ ፊት በማመልከት ጊዜያዊ ጠቋሚ ቴምፕ ይፍጠሩ።
  3. በዲቁ ውስጥ ተጓዙ እና ደረጃ 4 ን ይድገሙ ፣ ማለትም ፣ ፊት ለፊት ደረጃ 4 ን አይደገምም።
  4. ቴምፕን ከፊት ፣ ከፊት እንደ ፊት ለፊት ያቀናብሩ እና ለቴምፖም ቦታ ይስጡ
  5. በመጨረሻም ቴምፕን እንደ ባዶ እና ከፊት እንደ ባዶ ያዘጋጁ እና መጠኑን እንደ 0 ያዘጋጁ።

የጊዜ ውስብስብነት = ኦ (n) ፣ በዲክ ውስጥ የአንጓዎች ቁጥር የት ነው

የውሸት ኮድ

rear = null
Node temp = front
while (front != null) {
  temp = front
  front.prev = null
  front = front.next
  deallocate space for temp
}
temp = front = null
size = 0

ኮድ  

በድርብ የተገናኘ ዝርዝርን በመጠቀም የዲካን ተግባራዊ ለማድረግ የጃቫ ኮድ

class DequeUsingDoublyLinkedList {
    // class representing Node of a doubly linked list
    static class Node {
        int data;
        Node next, prev;

        public Node(int data) {
            this.data = data;
        }
    }

    // front points to start of Deque and rear points to the end of Deque
    private static Node front = null;
    private static Node rear = null;
    private static int size = 0;

    private static void insertFront(int x) {
        // Create a new Node with required parameters
        Node node = new Node(x);
        if (front == null) {
            // This is the first node to be inserted
            front = rear = node;
        } else {
            // Add the node before front
            node.next = front;
            front.prev = node;
            // update front
            front = node;
        }
        // Increment size
        size++;
    }

    private static void insertEnd(int x) {
        // Create a new Node with required parameters
        Node node = new Node(x);
        if (rear == null) {
            // This is the first node to be inserted
            front = rear = node;
        } else {
            // Insert the node after rear
            rear.next = node;
            node.prev = rear;
            // update rear
            rear = node;
        }
        // Increment size
        size++;
    }
    private static void deleteFront() {
        if (front == null) {
            // no node to delete
            return;
        }
        if (front == rear) {
            // only 1 node is present
            front = rear = null;
        } else {
            // delete front and move front ahead
            front = front.next;
            front.prev = null;
            // Garbage Collector will automatically delete first node
            // as no pointer is pointing to it
        }
        // decrement size
        size--;
    }

    private static void deleteEnd() {
        if (rear == null) {
            // no node to delete
            return;
        }
        if (rear == front) {
            // only 1 node is present
            front = rear = null;
        } else {
            // delete rear and move rear backwards
            rear = rear.prev;
            rear.next = null;
            // Garbage Collector will automatically delete last node
            // as no pointer is pointing to it
        }
        // decrement size
        size--;
    }

    private static int getFront() {
        if (front != null) {
            // front points to first element in Deque, return its data
            return front.data;
        }
        // no node is present
        return -1;
    }

    private static int getEnd() {
        if (rear != null) {
            // rear points to last element in Deque, return its data
            return rear.data;
        }
        // no node is present
        return -1;
    }

    private static boolean isEmpty() {
        if (front == null) {
            return true;
        }
        return false;
    }
    
    private static int size() {
        return size;
    }
    
    private static void erase() {
        // mark rear as null
        rear = null;
        // traverse the doubly linked list
        while (front != null) {
            // delete all the prev pointers
            front.prev = null;
            front = front.next;
        }
        // After this deque looks like
        // a -> b -> c -> d ..., all the previous pointers are destroyed
        // No pointer is pointing to a, so Garbage collector will delete the whole Deque
        
        // set size as 0
        size = 0;
    }

    public static void main(String[] args) {
        // Example
        insertFront(5);                 // 5
        insertEnd(10);                  // 5 <-> 10
        insertEnd(11);                  // 5 <-> 10 <-> 11
        insertFront(19);                // 19 <-> 5 <-> 10 <-> 11
        System.out.println(getFront());
        System.out.println(getEnd());
        deleteEnd();                    // 19 <-> 5 <-> 10
        System.out.println(getEnd());
        deleteFront();                  // 5 <-> 10
        System.out.println(getFront());    
        System.out.println(size());
        System.out.println(isEmpty());
        erase();
        System.out.println(isEmpty());
    }
}
19
11
10
5
2
false
true

በእጥፍ የተገናኘ ዝርዝርን በመጠቀም ዲካን ለመተግበር C ++ ኮድ

#include<bits/stdc++.h> 
using namespace std;

// class representing a tree node
class Node {
    public:
    int data;
    Node *next;
    Node *prev;
    
    Node(int d) {
        data = d;
        next = NULL;
        prev = NULL;
    }
};

// function to create a new node
Node* newNode(int x) {
    Node *node = new Node(x);
    return node;
}

// front points to start of Deque and rear points to the end of Deque
Node *front = NULL;
Node *rear = NULL;
// Variable representing size of Deque
int Size = 0;

void insertFront(int x) {
    // Create a new Node with required parameters
    Node *node = newNode(x);
    if (front == NULL) {
        // This is the first node to be inserted
        front = rear = node;
    } else {
        // Add the node before front
        node->next = front;
        front->prev = node;
        // update front
        front = node;
    }
    // Increment size
    Size++;
}

void insertEnd(int x) {
    // Create a new Node with required parameters
    Node *node = newNode(x);
    if (rear == NULL) {
        // This is the first node to be inserted
        front = rear = node;
    } else {
        // Insert the node after rear
        node->prev = rear;
        rear->next = node;
        // update rear
        rear = node;
    }
    // Increment size
    Size++;
}

void deleteFront() {
    if (front == NULL) {
        // no node to delete
        return;
    }
    if (front == rear) {
        // only 1 node is present
        front = rear = NULL;
    } else {
        // delete front and move front ahead
        Node *temp = front;
        front = front->next;
        front->prev = NULL;
        // deallocate the memory taken by temp
        delete(temp);
    }
    // Decrement size
    Size--;
}

void deleteEnd() {
    if (rear == NULL) {
        // no node to delete
        return;
    }
    if (front == rear) {
        // only 1 node is present
        front = rear = NULL;
    } else {
        // delete rear and move rear backwards
        Node *temp = rear;
        rear = rear->prev;
        rear->next = NULL;
        // deallocate the memory taken by temp
        delete(temp);
    }
    // Decrement size
    Size--;
}

int getFront() {
    if (front != NULL) {
        return front->data;
    }
    return -1;
}

int getEnd() {
    if (rear != NULL) {
        return rear->data;
    }
    return -1;
}

int size() {
    return Size;
}

bool isEmpty() {
    if (front == NULL) {
        return true;
    }
    return false;
}

void erase() {
    // mark rear as null
    rear = NULL;
    // traverse the doubly linked list
    while (front != NULL) {
        Node *temp = front;
        // delete all the prev pointers
        front->prev = NULL;
        front = front->next;
        // Deallocate the memory taken by temp
        delete(temp);
    }
    // Set size as 0
    Size = 0;
}

int main() {
    // Example
    insertFront(5);                 // 5
    insertEnd(10);                  // 5 <-> 10
    insertEnd(11);                  // 5 <-> 10 <-> 11
    insertFront(19);                // 19 <-> 5 <-> 10 <-> 11
    cout<<getFront()<<endl;
    cout<<getEnd()<<endl;
    deleteEnd();                    // 19 <-> 5 <-> 10
    cout<<getEnd()<<endl;
    deleteFront();                  // 5 <-> 10
    cout<<getFront()<<endl;     
    cout<<size()<<endl;
    if (isEmpty()) {
        cout<<"true"<<endl;
    } else {
        cout<<"false"<<endl;
    }
    erase();
    if (isEmpty()) {
        cout<<"true"<<endl;
    } else {
        cout<<"false"<<endl;
    }
    
    return 0;
}
19
11
10
5
2
false
true