كدسة

كدسة مع 5 عمليات دفع متتابعة يليها 5 عمليات نزع متتابعة.

الكُدسة أو الكَدسة (الجمع: أكداس وكُدسات وكَدسات)، في علم الحاسوب، نوع بيانات مجرد يُمثِّل جماعة متسلسلة لها منفذ واحد لإدخال البيانات وإخراجها بعمليتين رئيستين: الدفع والنزع. في الأولى، يُضاف عنصر جديد على قمة ما يوجد مسبقًا، وفي الثانية يُزال العنصر الموجود في أعلى الكدسة أو قمتها. أما قَعْر الكدسة فهو موضع أول عنصر يُضاف إليها، وهو آخر عنصر يُنزع منها قبل أن تصبح فارغة.

لترتيب الإدخال في الكدسة أهمية خاصة، وهو: الداخل أخيرًا يخرج أولًا. يعني هذا أن إخراج العناصر في أعلى الكدسة سهل بسيط، أما إخراج أي عنصر يقع تحت عنصر القمة فيتطلب إخراج العناصر التي تقع فوقه كلها.

يُمكن أن تنشأ الكدسة بقائمة متصلة مع مؤشر يدل على قمة الكدسة. ويُمكن أيضًا أن تكون ذات مقاسٍ ثابت، فلو تجاوزته كمية البيانات قيل عندها أن الكدسة قد فاضت أو طفحت.

التسمية

يذكر معجم لسان العرب في مادة (ك د س): «الكُدْس والكَدْس: العَرَمَة مِنَ الطَّعَامِ وَالتمر وَالدراهِمِ ونحو ذلك، والجمع أَكداس». ويتصرَّف فعلها الثلاثي المُجرَّد من الباب الثاني: «كَدَسَ يَكْدِس كَدْساً». وفي المعجم المدرسي أن: «الكُدْس هو المجتمع من كل شيء»، ويذكر مزيده الثلاثي بحرفين (تكدَّس): «تكدس الحصيد: جُعِل كُدْسًا. وتكدَّست الأشياء: تراكمت وازدحمت وتجمع بعضها فوق بعض».

وفي المعاجم التقنية ورد لفظ (كدسة) من غير ضبطٍ كما في (معجم مصطلحات المعلوماتية) الصادر عن الجمعية العلمية السورية للمعلوماتية. ومن الأسماء الأخرى لهذه البنية أيضًا: المَكْدَس والكَوْمة والرُّكام، والرَّصَّة والصف القائم.

نبذة تاريخية

بدأ ظهور مفهوم الكدسة في علم الحاسوب بدءًا من سنة 1946م، عندما استعمل آلان تورنغ مصطلحي دَفَن ونقَّب للإشارة إلى استدعاء دالة وإعادة قيمة منها. أُنجِزت الكدسة وعمليتا الدفع والنزع مسبقًا في حاسوب زد4 الذي صنعه كونراد سوزه سنة 1945م.

اقترح فريدريش باور وكلاوس ساميلسون في أثنا عملهما في جامعة ميونخ التقنية فكرة الكدسة سنة 1955، وسمياها «المستدعي العملياتي»، وسجلا براءة اختراع فيها سنة 1957م. حصل ساميلسون سنة 1988، بعد وفاة باور (1980م)، على جائزة رواد الحاسوب التي يقدمها معهد مهندسي الكهرباء والإلكترونيات.

مبدأ العمل

تمثيل مُبسَّط للكدسة وللعمليات الرئيسة عليه

الكدسة قائمة خطية تجري كل العمليات عليها، من إدراج عناصر جديدة فيها وإزالة العناصر منها والوصول إلى عناصر فيها، على أحد نهايتي القائمة. وهي تختلف بذلك على القوائم الخطية الأخرى: الرتل، الذي تجري عمليات الإدخال على أحد نهايته، والإزالة على النهاية الأخرى، والرتل المزدوج: الذي تجري عمليات الإدخال والإخراج على نهايتيه.

ويتفق (معجم أكسفورد لعلم الحاسوب) مع هذا التعريف فالكَدْسة وفقًا له: قائمة خطية تُنجز العمليات على عنصرها، وصولًأ وإدراجًا وحذفًا، من أحد طرفيها الذي يُسمَّى قمةً، والوصول إلى عناصرها أو إدراجها وحذفها. وتُعرِّف الطبعة الرابعة من (معجم الحاسبات) الصادر عن مجمع اللغة العربية بالقاهرة الكدسة بأنها: «طريقة لتخزين البيانات في هيكل مدخله هو مخرجه، فيكون آخر بيان دخولًا هو أولها خروجًا»

كدسة الصحون تشبه في مبدأ عملها كدسة البيانات: لا يُمكن إزالة الصحون أو إضافتها إلا من رأس الكدسة.

تشبه الكدسة المحوسبة كدسة الصحون ذات النابض في المقاهي، وفيها تُوضع الصحون النظيفة الجاهزة للاستعمال على قمة الكدسة دافعة الصحون الموجودة مسبقًا إلى الأسفل. عند إزالة الصحن الموجود في القمة يحل محله الصحن الموجود تحته مباشرة.

للكدسة عمليتان رئيستان:

• الدفع: أي إضافة عنصر على أعلى الكدسة.
• النزع، وتُسمَّى أيضًا القَطْف: أي سحب عنصرٍ من أعلى الكدسة.

يُمكن أيضًا قراءة قيمة العنصر في أعلى الكدسة من غير تعديلها، وتُسمَّى هذه العملية وَصْوصة. لا تعد الوَصْوصة عملية رئسية لأنها تشمل عمليتن رئيستين: نزع القيمة لقراءتها ثُمَّ دفعها للكدسة.

يُسمَّى العنصر الأعلى في الكدسة رأسها، وهو العنصر الذي سيُزال لو أجريت عملية نزعٍ، ويُسمى العنصر تحته العنصر التالي بعد الرأس، والذي يليه الثالث بدءًا من الرأس وهكذا وصولًا لقعر الكدسة، وهو أبعد العناصر فيها عن الرأس.

إذا كانت الكدسة فارغة، أي لا عناصر فيها فهي في حالة غَيْض، وعندها لا يُمكِن إجراء عمليتي النزع والوَصْوصة لعدم وجود أي عنصر، أما إذا كانت الكدسة ممتلئة على آخرها، فهي في حالة فيض أو طَفْح، ولا يُمكن عندها إجراء عملية الدفع.

التنجيز

مخطط صنفي لكدسة بلغة النمذجة الموحَّدة.

يمكن تنجيز الكدسة بسهولة باستعمال مصفوفة أو قائمة متصلة مع اعتبارها حالة خاصة من القوائم المتصلة. ما يجعل بنية البيانات كدسةً ليس ليس طريقة تنجيزها بل طريقة التعامل معها: يُمكِن للمستخدم نزع عتصر من رأسها أو دفع عنصر إليها.

للكدسة 3 دوال رئيسة: دالة الدفع: لإضافة عنصر لرأس للكدسة ويُمرَّر لها العنصر الذي يُراد إضافته ولا تُعيد أي قمية، ودالة النزع: لإخراج عنصر من رأس الكدسة وهي تعيد العنصر المنزوع، ودالة التحقق من فراغها وتعيد قيمة منطقية: صائب للدالة على فراغ الكدسة، وباطل للدلالة على عدم فراغها. إذا كان للكدسة قد محدد فيمكن كتابة دالة تعيد القد.

بمصفوفة

البنية والسلوك

يُمكن أن تُستعمل مصفوفة لتنجيز كدسة محدودة القد. يؤدي الموقع الأول في المصفوفة،أي الموقع الذي تكون إزاحته صفرية array[0]، دور قعر الكدسة، سيخزن هذا الموقع أول عنصر يُدفَع إلى المصفوفة وهو الهنصر الأخير الذي سيزال قبل الوصول لحالة الغيض. يلزم تتبع قد الكدسة بمتغير يُسمَّى الرأس يحفظ عدد العناصر المدفوعة للكدسة، وبما أن إزاحة العنصر الأول صفرية، فإن الرأس يُشير إلى فهرس المصفوفة الذي سيدفع إليه العنصر التالي.

يُوصَف هيكل بيانات الكدسة المبنية بمصفوفة وإجرائية استبدائها كما يأتي:

تضيف إجرائية الدفع عنصرًا لرأس الكدسة وتزيد قيمتها بمقدار واحد بعد التأكد من عدم حصول فيض (طَفح):

صورة مُحرَّكة لعمليات دفع متتالية لكدسة مبنية بمصفوفة من حالة الغيض إلى حالة الفيض (الطفح).

أما إجرائية النزع فتنقص الرأس بمقدار واحد بعد التأكد من عدم حصول غيض (فراغ الكدسة)، ثُم تعيد العنصر الذي كان سابقًا في رأس الكدسة.

صورة مُحرَّكة لعمليات نزع متتالية لكدسة مبنية بمصفوفة من حالة الامتلاء الكامل إلى حالة الغيض.

يُمكن استعمال مصفوفة ديناميكية لجعل قد الكدسة ينمو ويتقلص حسب الحاجة. يُحسن هذا من كفاءة التنجيز لأن إضافة عنصر لكدسة مبنية بمصفوفة ديناميكية أو إزالته من نهاية الكدسة يستهلك زمنًا قدره O(1).

بلغات برمجة مختلفة

الكدسة المبنية بمصفوفة ودوالها مُنجَزة بلغة سي++:

# include <iostream>
using namespace std;

class myStack {
    
    // array to store elements
    int *arr;       
    
    // maximum size of stack
    int capacity;   
    
    // index of top element
    int top;

public:

    // constructor
    myStack(int cap) {
        capacity = cap;
        arr = new int[capacity];
        top = -1;
    }

    // push operation
    void push(int x) {
        if (top == capacity - 1) {
            cout << "Stack Overflow\n";
            return;
        }
        arr[++top] = x;
    }

    // pop operation
    int pop() {
        if (top == -1) {
            cout << "Stack Underflow\n";
            return -1;
        }
        return arr[top--];
    }

    // peek (or top) operation
    int peek() {
        if (top == -1) {
            cout << "Stack is Empty\n";
            return -1;
        }
        return arr[top];
    }

    // check if stack is empty
    bool isEmpty() {
        return top == -1;
    }

    // check if stack is full
    bool isFull() {
        return top == capacity - 1;
    }
};

int main() {
    myStack st(4);

    // pushing elements
    st.push(1);
    st.push(2);
    st.push(3);
    st.push(4);

    // popping one element
    cout << "Popped: " << st.pop() << "\n";

    // checking top element
    cout << "Top element: " << st.peek() << "\n";

    // checking if stack is empty
    cout << "Is stack empty: " << (st.isEmpty() ? "Yes" : "No") << "\n";

    // checking if stack is full
    cout << "Is stack full: " << (st.isFull() ? "Yes" : "No") << "\n";

    return 0;
}

الكدسة المبنية بمصفوفة مُنجَزة بلغة جافا:

import java.util.Arrays;

class myStack {

    // array to store elements
    private int[] arr;

    // maximum size of stack
    private int capacity;

    // index of top element
    private int top;

    // constructor
    public myStack(int cap) {
        capacity = cap;
        arr = new int[capacity];
        top = -1;
    }

    // push operation
    public void push(int x) {
        if (top == capacity - 1) {
            System.out.println("Stack Overflow");
            return;
        }
        arr[++top] = x;
    }

    // pop operation
    public int pop() {
        if (top == -1) {
            System.out.println("Stack Underflow");
            return -1;
        }
        return arr[top--];
    }

    // peek (or top) operation
    public int peek() {
        if (top == -1) {
            System.out.println("Stack is Empty");
            return -1;
        }
        return arr[top];
    }

    // check if stack is empty
    public boolean isEmpty() {
        return top == -1;
    }

    // check if stack is full
    public boolean isFull() {
        return top == capacity - 1;
    }
}

public class Main {
    public static void main(String[] args) {
        myStack st = new myStack(4);

        // pushing elements
        st.push(1);
        st.push(2);
        st.push(3);
        st.push(4);

        // popping one element
        System.out.println("Popped: " + st.pop());

        // checking top element
        System.out.println("Top element: " + st.peek());

        // checking if stack is empty
        System.out.println("Is stack empty: " +
                            (st.isEmpty() ? "Yes" : "No"));

        // checking if stack is full
        System.out.println("Is stack full: " +
                            (st.isFull() ? "Yes" : "No"));
    }
}

الكدسة المبنية بمصفوفة مُنجَزة بلغة بايثون:

class myStack:
    # constructor
    def __init__(self, cap):
        self.capacity = cap
        self.arr = [0] * self.capacity
        self.top = -1

    # push operation
    def push(self, x):
        if self.top == self.capacity - 1:
            print("Stack Overflow")
            return
        self.top += 1
        self.arr[self.top] = x

    # pop operation
    def pop(self):
        if self.top == -1:
            print("Stack Underflow")
            return -1
        val = self.arr[self.top]
        self.top -= 1
        return val

    # peek (or top) operation
    def peek(self):
        if self.top == -1:
            print("Stack is Empty")
            return -1
        return self.arr[self.top]

    # check if stack is empty
    def isEmpty(self):
        return self.top == -1

    # check if stack is full
    def isFull(self):
        return self.top == self.capacity - 1

if __name__ == "__main__":
    st = myStack(4)

    # pushing elements
    st.push(1)
    st.push(2)
    st.push(3)
    st.push(4)

    # popping one element
    print("Popped:", st.pop())

    # checking top element
    print("Top element:", st.peek())

    # checking if stack is empty
    print("Is stack empty: ", "Yes" if st.isEmpty() else "No")

    # checking if stack is full
    print("Is stack full: ", "Yes" if st.isFull() else "No")

بقائمة متصلة

يُمكن أن تُبنى الكدسة بقائمة متصلة، وتكون عندها مؤشر يُشير إلى رأس القائمة وقد يُضاف إليها عداد لتتبع عدد العناصر في القائمة أي قد الكدسة. تبنى الكدسة بقائمة متصلة كما يأتي:

تُنجَز عمليتي الدفع والنزع على رأس الكدسة، ولا يُمكن نظريًا أن يحصل فيض (طَفح) لأن قد الكدسة غير ثابت، لكن استهلاك كامل الذاكرة يؤدي لفيض الكدسة.

صورة مُحرَّكة لعمليات دفع متتالية لكدسة مبنية بقائمة متصلة.

صورة مُحرَّكة لعمليات نزع متتالية لكدسة مبنية بقائمة متصلة.

بلغات برمجة مختلفة

الكدسة المبنية بقائمة متصلة ودوالها مُنجَزة بلغة سي++:

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

class Node {
public:
    int data;
    Node* next;
    Node(int new_data) {
        this->data = new_data;
        this->next = nullptr;
    }
};

class Stack {
    Node* head;

public:
    Stack() { this->head = nullptr; }

    bool isEmpty() {
        return head == nullptr;
    }

    void push(int new_data) {
        Node* new_node = new Node(new_data);
        if (!new_node) {
            cout << "\nStack Overflow";
        }
        new_node->next = head;
        head = new_node;
    }

    void pop() {
        if (this->isEmpty()) {
            cout << "\nStack Underflow" << endl;
        } else {
            Node* temp = head;
            head = head->next;
            delete temp;
        }
    }

    int peek() {
        if (!isEmpty())
            return head->data;
        else {
            cout << "\nStack is empty";
            return INT_MIN;
        }
    }
};

int main() {
    Stack st;

    st.push(11);
    st.push(22);
    st.push(33);
    st.push(44);

    cout << "Top element is " << st.peek() << endl;

    cout << "Removing two elements..." << endl;
    st.pop();
    st.pop();

    cout << "Top element is " << st.peek() << endl;

    return 0;
}

الكدسة المبنية بقائمة متصلة مُنجَزة بلغة جافا:

// Java program to implement a stack using singly linked
// list

// Class representing a node in the linked list
class Node {
    int data;
    Node next;
    Node(int new_data) {
        this.data = new_data;
        this.next = null;
    }
}

// Class to implement stack using a singly linked list
class Stack {

    // Head of the linked list
    Node head;

    // Constructor to initialize the stack
    Stack() { this.head = null; }

    // Function to check if the stack is empty
    boolean isEmpty() {
      
        // If head is null, the stack is empty
        return head == null;
    }

    // Function to push an element onto the stack
    void push(int new_data) {
      
        // Create a new node with given data
        Node new_node = new Node(new_data);

        // Check if memory allocation for the new node
        // failed
        if (new_node == null) {
            System.out.println("\nStack Overflow");
            return;
        }

        // Link the new node to the current top node
        new_node.next = head;

        // Update the top to the new node
        head = new_node;
    }

    // Function to remove the top element from the stack
    void pop() {
      
        // Check for stack underflow
        if (isEmpty()) {
            System.out.println("\nStack Underflow");
            return;
        }
        else {
          
            // Assign the current top to a temporary
            // variable
            Node temp = head;

            // Update the top to the next node
            head = head.next;

            // Deallocate the memory of the old top node
            temp = null;
        }
    }

    // Function to return the top element of the stack
    int peek() {
      
        // If stack is not empty, return the top element
        if (!isEmpty())
            return head.data;
        else {
            System.out.println("\nStack is empty");
            return Integer.MIN_VALUE;
        }
    }
}

// Driver code
public class Main {
    public static void main(String[] args)
    {
        // Creating a stack
        Stack st = new Stack();

        // Push elements onto the stack
        st.push(11);
        st.push(22);
        st.push(33);
        st.push(44);

        // Print top element of the stack
        System.out.println("Top element is " + st.peek());

        // removing two elemements from the top
  		System.out.println("Removing two elements...");
        st.pop();
        st.pop();

        // Print top element of the stack
        System.out.println("Top element is " + st.peek());
    }
}

الكدسة المبنية بقائمة متصلة مُنجَزة بلغة بايثون:

# Java program to implement a stack using singly linked
# list

# Class representing a node in the linked list
class Node:
    def __init__(self, new_data):
        self.data = new_data
        self.next = None

# Class to implement stack using a singly linked list
class Stack:
    def __init__(self):

        # head of the linked list
        self.head = None

    # Function to check if the stack is empty
    def is_empty(self):

        # If head is None, the stack is empty
        return self.head is None

    # Function to push an element onto the stack
    def push(self, new_data):

        # Create a new node with given data
        new_node = Node(new_data)

        # Check if memory allocation for the new node failed
        if not new_node:
            print("\nStack Overflow")
            return

        # Link the new node to the current top node
        new_node.next = self.head

        # Update the top to the new node
        self.head = new_node

    # Function to remove the top element from the stack
    def pop(self):

        # Check for stack underflow
        if self.is_empty():
            print("\nStack Underflow")
        else:

            # Assign the current top to a temporary variable
            temp = self.head

            # Update the top to the next node
            self.head = self.head.next

            # Deallocate the memory of the old top node
            del temp

    # Function to return the top element of the stack
    def peek(self):

        # If stack is not empty, return the top element
        if not self.is_empty():
            return self.head.data
        else:
            print("\nStack is empty")
            return float('-inf')

# Creating a stack
st = Stack()

# Push elements onto the stack
st.push(11)
st.push(22)
st.push(33)
st.push(44)

# Print top element of the stack
print("Top element is", st.peek())

# removing two elemements from the top
print("Removing two elements...");
st.pop()
st.pop()

# Print top element of the stack
print("Top element is", st.peek())

انظرأيضًا

• قائمة بنى البيانات
• الرتل
• رتل مزدوج النهاية

المراجع

فهرس الإحالات

المنشورات

بالعربية

بالألمانية

بالإنجليزية

الوب

بالألمانية

بالإنجليزية

ثبت المراجع

المقالات المُحكَّمة

بالألمانية

• Hans Langmaack (2014). "Friedrich L. Bauers und Klaus Samelsons Arbeiten in den1950er-Jahren zur Einf ̈uhrung der Begriffe Kellerprinzipund Kellerautomat". Keller, Stack und automatisches Gedächtnis - eine Struktur mit Potenzial Tagungsband zum Kolloquium. Gesellschaft für Informatik (بالألمانية): 19–30. ISBN:978-3-88579-426-4. QID:Q138176909.

بالإنجليزية

• B. E. Carpenter; R. W. Doran (1977). "The other Turing machine". The Computer Journal (بالإنجليزية). 20 (3): 269–279. DOI:10.1093/COMJNL/20.3.269. ISSN:0010-4620. OCLC:952697705. Zbl:0362.68083. QID:Q55895981.
• Friedrich L. Bauer; Klaus Samelson (2001). "Verfahren zur automatischen Verarbeitung von kodierten Daten und Rechenmaschine zur Ausübung des Verfahrens". Pioneers and Their Contributions to Software Engineering: sd&m Conference on Software Pioneers, Bonn, June 28/29, 2001, Original Historic Contributions (بالإنجليزية والألمانية): 29–40. DOI:10.1007/978-3-642-48354-7_2. ISBN:978-3-642-48354-7. OCLC:7322999114. QID:Q138126423.

الكتب

بالعربية

• محمد خير أبو حرب (1985)، المعجم المدرسي، مراجعة: ندوة النوري (ط. 1)، دمشق: وزارة التربية، OCLC:1136027329، QID:Q116176016
• إدوارد وديع حداد (1988)، المعجم الحديث لمصطلحات الكومبيوتر والمعلوماتية: إنكليزي عربي مع مختصرت إنجليزية ومسرد عربي (بالعربية والإنجليزية)، بيروت: مكتبة لبنان ناشرون، OCLC:235968805، QID:Q138029424
• ابن منظور (1994)، لسان العرب (ط. 3)، بيروت: دار صادر، OCLC:4770578388، QID:Q114878607
• ر. د. كوانتن (1994)، قاموس الكمبيوتر المصور: مع دليل مواقع المصطلحات ومسردين: عربي-إنكليزي، وإنكليزي-عربي (بالعربية والإنجليزية)، ترجمة: أنطوان بطرس، مراجعة: جورج عبد المسيح، بيروت: مكتبة لبنان ناشرون، OCLC:48186000، QID:Q123718283
• نبيل الزهيري (1996)، المعجم الموسوعي لمصطلحات الكومبيوتر: إنكليزي - عربي (بالعربية والإنجليزية)، مراجعة: أيمن الدسوقي، هدى بركة (ط. 1)، بيروت: مكتبة لبنان ناشرون، OCLC:44585554، QID:Q123703339
• معجم مصطلحات المعلوماتية (بالعربية والإنجليزية)، دمشق: الجمعية العلمية السورية للمعلوماتية، 2000، OCLC:47938198، QID:Q108408025
• تيسير الكيلاني؛ مازن الكيلاني (2001). معجم الكيلاني لمصطلحات الحاسب الإلكتروني: إنجليزي-إنجليزي-عربي موضح بالرسوم (بالعربية والإنجليزية) (ط. 2). بيروت: مكتبة لبنان ناشرون. ISBN:978-9953-10-302-0. OCLC:473796723. QID:Q108807042.
• معجم مصطلحات الحاسبات (بالعربية والإنجليزية) (ط. 4)، القاهرة: مجمع اللغة العربية بالقاهرة، 2012، OCLC:1227674283، QID:Q124656273

بالإنجليزية

• John A. Ball (1978). Algorithms for RPN calculators (بالإنجليزية) (1st ed.). New York City: Wiley. ISBN:978-0-471-03070-6. LCCN:77014977. OCLC:570499840. QID:Q138028771.
• Ellis Horowitz; Sartaj Sahni (1984). Fundamentals of data structures in Pascal. Computer software engineering series (بالإنجليزية). Rockville: Computer Science Press. ISBN:978-0-914894-94-0. LCCN:83010136. OCLC:9621734. QID:Q138033715.
• Brian Carpenter; Robert W. Doran (1986), A.M. Turing's ACE report of 1946 and other papers, Charles Babbage Institute reprint series for the history of computing (10) (بالإنجليزية), Cambridge: The MIT Press, OCLC:681111364, QID:Q138069322
• Gerrit Blaauw; Fred Brooks (1997), Computer architecture: concepts and evolution (بالإنجليزية), Reading: Addison-Wesley, OCLC:1420815552, QID:Q138144427
• Donald Knuth (1997). The Art of Computer Programming: Fundamental Algorithms (PDF) (بالإنجليزية) (3rd ed.). Upper Saddle River: Addison-Wesley. Vol. 1. ISBN:978-0-201-89683-1. LCCN:97002147. OCLC:614169588. QID:Q47755251.
• Thomas H. Cormen; Charles E. Leiserson; Ron Rivest; Clifford Stein (2009). Introduction to Algorithms (بالإنجليزية) (3rd ed.). Cambridge: The MIT Press. ISBN:978-0-262-03384-8. LCCN:2009008593. QID:Q110418801.
• Martina Seidl; Marion Scholz; Christian Huemer; Gerti Kappel (2015). UML @ Classroom: An Introduction to Object-Oriented Modeling. Undergraduate Topics in Computer Science (بالإنجليزية). Cham: Springer Science+Business Media. DOI:10.1007/978-3-319-12742-2. ISBN:978-3-319-12742-2. OCLC:904341348. QID:Q138196816.
• Andrew Butterfield; Gerard Ekembe Ngondi, eds. (2016). A dictionary of computer science (بالإنجليزية) (7th ed.). Oxford: Oxford University Press. ISBN:978-0-19-968897-5. OCLC:942358940. OL:28266567M. QID:Q123266313.