Datenstruktur und Algorithmus

In der Informatik und Softwaretechnik ist eine Datenstruktur ein Objekt zur Speicherung und Organisation von Daten. Es handelt sich um eine Struktur, weil die Daten in einer bestimmten Art und Weise angeordnet und verknüpft werden, um den Zugriff auf sie und ihre Verwaltung effizient zu ermöglichen.

1.Stapelspeicher

Ein Stapel kann eine theoretisch beliebige, in der Praxis jedoch begrenzte Menge von Objekten aufnehmen. Elemente können nur oben auf den Stapel gelegt und auch nur von dort wieder gelesen werden. Elemente werden übereinander gestapelt und in umgekehrter Reihenfolge vom Stapel genommen. Dies wird auch Last-In-First-Out-Prinzip (LIFO) genannt.

1.1 Begriff

Bottom Of Stack(bottom)：Kopf vom Stapelspeicher

Top Of Stack(top)：Schwanz vom Stapelspeicher

Herunternehmen(Pop)：Delete Element vom Top

Darauflegen(Push)：Insert Element vom Top

Empty Stack：Wenn Stapelspeicher 0 Element enthält

1.2 Operation

Darauflegen(push) verteilt Value zu Stapelspeicher Feld,dann plus Top 1

Herunternehmen (pop) verteilt Value zu Stapelspeicher Feld,dann minus Top 1

2.Warteschlange

Man kann sich eine Warteschlange wie eine Warteschlange von Kunden an einer Kasse vorstellen. Der Letzte, der sich in die Schlange stellt, wird auch als letzter bedient. Umgekehrt wird derjenige, der sich als erstes angestellt hat, als erster bedient.

2.1 Begriff

Kopf von der Warteschlange(front)：Erstes Element der Warteschlange

Schwanz von der Warteschlange(rear)：Letztes Element der Warteschlange

出队(Dequeue)：Delete Element von dem Kopf der Warteschlange

入队(Enqueue)：Insert Element von dem Schwanz der Warteschlange

2.2 Operation

Beim Enqueue muss Element vom Rear hinzugefügt werden;Beim Dequeue lässt Element vom Front ausgehen

3.Lineare Liste

3.1 Begriff

final Squenz des 0 order mehr Data Elements

Länge der Lineare Liste:Anzahl der Element im Lineare Liste

Präkursor:Das vorne Data Elements des Data Elements

Subsequence:Das rückstandig Data Elements des Data Elements

Die zwei Arten von Speicherstruktur der Lineare Liste

Man kann Linearer Liste mit Sequence Liste order verkettete Liste verwirklichen

Sequence Liste benutzen Feld,um innere Beziehung zu erklären.

Verkette Liste benutzen Zeiger,um innere Beziehung zu erklären.

3.2 Sequence Liste

Kern Operation

3.2.1 insert Element

zuerst beurteilen Index ob er legal ist

Falls Index legal ist

versetzen rückstandig Data Elements gesteckter Data Elements nach umgekehrte Reihenfolge,weil nach der Reihenfolge werden vorne Data Elements bedeckt

Wenn Operation hat sich beendet,verteilen value

Länge++

bool List::ListInsert(int i, int *Elem)
{
    if (i< || i>m_iLength)
    {
        return false;
    }
    else
    {
        //先在后面进行移动
        for (int k = m_iLength - ; k >= i; k--)
        {
            m_pList[k + ] = m_pList[k];
        }
        //插入元素
        m_pList[i] = *Elem;
        m_iLength++;
        return true;
    }
}

3.2.2 Delete Element

Zuerst beurteilen Index ob er legal ist

Falls Index legal ist

verteilen value der Data Elements zu einem Zeiger

versetzen rückstandig Data Elements gesteckter Data Elements nach Reihenfolge

Länge--

bool List::ListDelete(int i, int *Elem)
{
    if (i< || i>=m_iLength)
    {
        return false;
    }
    else
    {
        *Elem = m_pList[i];
        //先在前面进行移动，从后面开始移动会造成值的替代
        //k=i+1对应着k-1,若k=i,k <= m_iLength-1,m_pList[k] = m_pList[k+1];
        for (int k = i+; k <= m_iLength; k++)
        {
            m_pList[k-] = m_pList[k];
        }

        m_iLength--;
        return true;
    }
}

3.3 verkette Liste

Kopf Knoten:er ist nicht im Index des Felds inbegriffen,data ist NULL,next deutet nach erster Knoten

Kern Operation

3.3.1 insert Element

Zuerst beurteilen ob i legal ist

i kann nicht kleiner als 0,auch nicht größer als Länge der verkette Liste

newNode->next = currentNode->next;

currentNode->next = newNode;

bool List::ListInsert(int i, Node *pNode)
{
    if (i< || i>m_iLength)
    {
        return false;
    }
    Node *currentNode = m_pList;
    for (int k = ; k < i; k++)
    {
        currentNode = currentNode->next;
    }
    Node *newNode = new Node;
    if (newNode == NULL) //判断申请的结点内存是否为空
    {
        return false;
    }
    else
    {
        newNode->data = pNode->data;
        newNode->next = currentNode->next;
        currentNode->next = newNode;
        return true;
    }
}

3.3.2 Delete Node

Zuerst beurteilen ob i legal ist

currentNodeBefore->next = currentNode->next;
pNode->data = currentNode->data;
delete currentNode;
currentNode = NULL;

bool List::ListDelete(int i, Node *pNode)
{
    if (i< || i>=m_iLength)
    {
        return false;
    }
    Node *currentNode = m_pList;
    Node *currentNodeBefore = NULL;
    for (int k = ; k <= i; k++)
    {
        currentNodeBefore = currentNode;
        currentNode = currentNode->next;
    }
    currentNodeBefore->next = currentNode->next;
    pNode->data = currentNode->data;
    delete currentNode;
    currentNode = NULL;
    m_iLength--;
    return true;
}

4.Baum

4.1 Begriff

• Child：Kindknoten
• Parent：Parent node
• Degree：Wie viele Nachkommen besitzt
• Ordered tree：Baum nach bestimmte Reihenfolge
• Unordered tree：Baum nach keine Reihenfolge
• Binärbäume：Alle Knoten sind kleiner als 2
• Voll Binärbäume：Alle Knoten haben linken und rechten Kindknoten,alle Kindknoten stehen in gleiche Schicht
• Kompletter Binärbäume：Letzte Schicht des Baums hat erlaubt NULL Knoten,untererester Blattknoten stehen links

4.2 Feld Speicherung der Baum

Kern Operation:

4.2.1 add Knoten

direction = 0 repäsentiert linken Kindknoten,dierction = 1 repäsentiert rechten Kindknoten

linken Kindknoten = 2*Index+1；Rechten Kindknoten = 2*Index+2

下图可以验证

Linken Kindknoten und rechten Kindknoten können nicht kleiner als 0 order größer gleich als Länge des Felds

bool Tree::AddNode(int nodeIndex, int direction, int *pNode)
{
    if (nodeIndex< || nodeIndex >= m_iSize)
    {
        return false;
    }
    if (m_pTree[nodeIndex] == )
    {
        return false;
    }
    if (direction == )
    {
        //nodeIndex * 2 + 1<0可以省略
        if (nodeIndex *  + < || nodeIndex *  +  >= m_iSize)
        {
            return false;
        }
        //判断是否有左子节点
        if (m_pTree[nodeIndex *  + ] != )
        {
            return false;
        }
        m_pTree[nodeIndex *  + ] = *pNode;
    }
    if (direction == )
    {
        //nodeIndex * 2 + 2<0可以省略
        if (nodeIndex *  + < || nodeIndex *  +  >= m_iSize)
        {
            return false;
        }
        //判断是否有左子节点
        if (m_pTree[nodeIndex *  + ] != )
        {
            return false;
        }
        m_pTree[nodeIndex *  + ] = *pNode;
    }
    return true;
}

4.2.2 Delete Knoten

beurteilen Index und value des Knoten ob sie legal sind

Index = 0 und Knoten = 0

bool Tree::DeleteNode(int nodeIndex, int *pNode)
{
    if (nodeIndex< || nodeIndex >= m_iSize)
    {
        return false;
    }
    if (m_pTree[nodeIndex] == )
    {
        return false;
    }
    *pNode = m_pTree[nodeIndex];
    m_pTree[nodeIndex] = ;
    return true;
}

4.3 Verkette Speicherung des Baums

Kern Operation

Preorder Traversal:Wurzel Linke Rechte

Inorder Traversal:Linke Wurzel Rechte

Postorder Traversal:Linke Rechte Wurzel

void Node::PreorderTraversal()
{
    cout << this->index<<"  "<<this->data << endl;
    if (this->pLChild != NULL)
    {
        this->pLChild->PreorderTraversal();
    }
    if (this->pRChild != NULL)
    {
        this->pRChild->PreorderTraversal();
    }
}

void Node::InorderTraversal()
{
    if (this->pLChild != NULL)
    {
        this->pLChild->InorderTraversal();
    }
    cout << this->index << "  " << this->data << endl;
    if (this->pRChild != NULL)
    {
        this->pRChild->InorderTraversal();
    }
}

void Node::PostorderTraversal()
{
    if (this->pLChild != NULL)
    {
        this->pLChild->PostorderTraversal();
    }
    if (this->pRChild != NULL)
    {
        this->pRChild->PostorderTraversal();
    }
    cout << this->index << "  " << this->data << endl;
}

5.Graph

5.1 Begriff

Graph:Einfach gesagt,Graph ist ein Container,der mit Kanten und Knoten verbunden ist

Gerichteter Graph:Kante mit der Richtung

ungerichteter Graph:Kante ohne der Richtung

Gewicht:Verteilen ein Value zu einer Kante

Connected Graph:Setzen Graph G als ungerichteter Graph voraus,wenn jede Paar Knoten des Graphs eine Weg hat,G ist connected Graph

Spannbaum:Ein Spannbaum ist ein Teilgraph eines ungerichteten Graphen, der ein Baum ist und alle Knoten dieses Graphen enthält

Ausgangsgrad：die Zahl der Kanten,die von dem Knoten losfahren

Eingangsgrad：die Zahl der Kanten,die dem Knoten erreichen

Tiefensuche：nämlich Preorder Traversal.Im Gegensatz zur Breitensuche wird bei der Tiefensuche zunächst ein Pfad vollständig in die Tiefe beschritten, bevor abzweigende Pfade beschritten werden

Breitensuche ：nämlich nach Schicht Preorder Traversal.Im Gegensatz zur Tiefensuche werden zunächst alle Knoten beschritten, die vom Ausgangsknoten direkt erreichbar sind. Erst danach werden Folgeknoten beschritten

Subgraph:Wenn Knoten und Kanten der Graph H ist subset von Graph G,als Subset der Graph G bezeichnen wir Graph H

strongly-connected graph:Setzen Graph G als gerichteter Graph voraus,wenn jede Paar Knoten des Graphs eine Weg hat,G ist connected Graph

5.2 Speicherung des Graphs

Kern Operation

5.2.1 stellen adjacent matrix fur gerichtete Graph

Zuerst beurteilen Reih und Glied ob sie legal ist

Wenn Reih kleiner als 0 order größer als Capcity,return false

Wenn Glied kleiner als 0 order größer als Capcity,return false

Graph：

Adjacent matrix：

Index = row*m_iCapacity+col

bool cMap::setValueToMatrixForDirectedGraph(int row, int col, int val)
{
    if(row< || row>=m_iCapacity)
    {
        return false;
    }
    if (col <  || col >= m_iCapacity)
    {
        return false;
    }
    m_pMatrix[row*m_iCapacity + col] = val;
    return true;
}

5.3 Kleineste Spannbaum

5.3.1 Kruskal Algorithmus

Zuerst ordnen wir das Gewicht,dann wählen wir kleinest Kante aus,die Kreis kann nicht hervorgerufen werden.

5.3.2 Prim Algorithmus

Wir wählen beliebige Kante aus,dann wir fangen mit Startpunkt an,wählen kleineste Kante,die Kreis kann nicht hervorgerufen werden

6.Sort Algorithmus

6.1 Bubblesort

Großes Element sinkt,Kleines Element taucht auf

Komplexität:

Ungünstigster Fall:

Bester Fall:

6.2 Insertionsort

teilen eine Gruppe Daten in angeordenet Gruppe und ungeordenet Gruppe,angeordenet Gruppe steigt,ungeordenet Gruppe sinkt bis 0

Komplexität:

6.3 Quicksort

Komplexität:

O(nlog₂(n))