[Datenstruktur] Sowohl mit Bildern als auch mit Texten können Sie die verknüpfte Liste leicht über das Logikdiagramm erfassen und verschiedene Schnittstellenfunktionen realisieren (2)

Junxi_s persönliche Homepage

Seien Sie fleißig und ermutigen Sie die Jahre, auf niemanden zu warten

C/C++-Spieleentwicklung

Hallo Mina-san, hier ist Junxi_. Wir werden weiterhin den Inhalt der primären Datenstruktur gemäß der Sequenztabelle vorstellen, über die wir zuvor gesprochen haben. Heute werde ich Ihnen das Grundwissen über die verknüpfte Liste und die Realisierung verschiedener Schnittstellen vermitteln Funktionen. Der zweite Teil von .
Nun, ohne weitere Umschweife, beginnen wir mit dem heutigen Studium! —

1. Implementierung einer kopflosen verknüpften Liste

• Die Schnittstellenfunktion unserer letzten verknüpften Liste wurde zum Einfügen und Löschen von Enden implementiert, und wir werden unser Lernen der verknüpften Liste aus dem vorherigen Inhalt fortsetzen.

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLTDataType;
typedef struct SListNode
{
    
    
    SLTDataType Data;
    struct SListNode * next;

}SLTNode;
//打印链表
void SLTPrint(SLTNode* phead);
//初始化链表
SLTNode* BuySListNode(SLTDataType x);
void SLTPushBack(SLTNode** pphead, SLTDataType x);
void SLTPushFront(SLTNode** pphead, SLTDataType x);

void SLTPopBack(SLTNode** pphead);
void SLTPopFront(SLTNode** pphead);
// 找某个数
SLTNode* SLTFind(SLTNode* phead, SLTDataType x);

// 在pos之前插入x
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);

// 在pos以后插入x
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

// 删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos);

// 删除pos的后一个位置
void SLTEraseAfter(SLTNode* pos);
//修改pos位置的值
void SLTModify(SLTNode**pphead, SLTNode* pos, SLTDataType x);
// 单链表的销毁
void SListDestroy(SLTNode** pphead);

---

1. Suchen Sie einen Knoten SLTMidify und ändern Sie die Nummer eines Knotens SLTModify

Finden Sie heraus, ob ein Knoten vorhanden ist

//找某个节点是否存在
SLTNode* SLTFind(SLTNode* phead, SLTDataType x)
{
    
    
    SLTNode* cur = phead;
    while (cur)
    {
    
    
        if (cur->Data == x)
            return cur;
        cur = cur->next;
    }
    printf("该节点不存在\n");
    return NULL;
}

• Für die Suche müssen wir nur die verknüpfte Liste durchlaufen, um zu vergleichen, ob die in jedem Knoten gespeicherten Daten dem von mir gesuchten x entsprechen. Wenn sie am Ende nicht gleich sind, bedeutet dies, dass der Knoten im nicht existiert verlinkte Liste.

Ändern Sie die Nummer eines Knotens

//修改某个节点的值
void SLTModify(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
    
    
    pos->Data = x;
}

• Dies kann mit der obigen Suchfunktion verknüpft werden. Ich werde zunächst herausfinden, ob der Knoten existiert. Wenn ich ihn finden kann, ändere ich die Daten des Knotens auf das gewünschte x.
• Beispiele sind wie folgt:

void TestSList2()
{
    
    
    int n = 0;
    int x = 0;
    printf("请输入需要定义的链表的长度：\n");
    scanf("%d", &n);
    printf("请输入需要放入链表中的元素，中间用空格隔开\n");
    SLTNode* plist = NULL;

    int val = 0;
    for (size_t i = 0; i < n; i++)
    {
    
    
        scanf("%d", &val);

        SLTPushBack(&plist, val);


    }
    SLTPrint(plist);
    //SLTFind(plist, 5);
    printf("请输入要修改的值\n");
    scanf("%d", &x);
    SLTNode* pos = SLTFind(plist, x);
    if (pos)
    {
    
    
        int m;
        printf("请输入要把该节点修改成什么值：\n");
        scanf("%d", &m);
        SLTModify(&plist, pos, m);
    }
    SLTPrint(plist);
}

2. Fügen Sie den Wert SLTInsert vor pos und den Wert SLTInsertAfter nach pos ein

Wert vor Pos einfügen

// 在pos之前插入x
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
    
    
    SLTNode* cur = *pphead;
    SLTNode* newnode = BuySListNode(x);
    //如果没有节点时就得头插
    assert(pphead);
    assert(pos);
    if (pos == *pphead)
    {
    
    
        SLTPushFront(pphead, x);
    }
    else {
    
    
        while (cur->next)
        {
    
    
            if (cur->next->Data == pos->Data)
            {
    
    
                cur->next = newnode;
                newnode->next = pos;
            }
            cur = cur->next;

        }
    }
}

• Analyse von Sonderfällen:
• Wir müssen diese Orte berücksichtigen, bevor wir Pos einfügen: 1. Ist Pos legal? 2. Ob pphead leer ist
• Nachdem wir die beiden oben genannten beurteilt haben, müssen wir nun das spezielle Einfügen von pos berücksichtigen. Wenn sich unser pos am Anfang der verknüpften Liste befindet, entspricht das Einfügen vor unserem pos unserem Einfügen am Kopf. Wenn nicht, werden wir es analysieren allgemeine Situation durch das Logikdiagramm
  
  

füge x nach Pos ein

// 在pos以后插入x
void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
    
    
    SLTNode* cur = BuySListNode(x);
    cur->next = pos->next;
    pos->next = cur;

}

• Dieser Teil ist relativ einfach. Wir finden die Position von pos über den vorherigen SLTFind, geben die Adresse des nächsten Knotens in dessen neben dem Cur ein, den wir einfügen möchten, und lassen den nächsten von pos auf cur zeigen.

3. Löschen Sie den Wert SLTErase an der Position von pos und löschen Sie den Wert SLTEraseAfter an der nächsten Ziffer von pos

Löschen Sie den Wert von pos position

// 删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos)
{
    
    
    SLTNode* cur = *pphead;
    assert(pos);
    assert(pphead);
    if (pos == *pphead)
    {
    
    
        SLTPopFront(pphead);
    }
    
    else
    {
    
    
        while (cur)
        {
    
    
            if (cur->next == pos)
            {
    
    
                cur->next = pos->next;
                free(pos);
            }
            cur = cur->next;
        }

    }
        
}

• Die Analyse der Behauptung ist die gleiche wie oben und ich werde sie hier nicht wiederholen. Wir löschen sie hier. Wenn sich pos im Header befindet, ist das Löschen dieses Knotens unsere Header-Löschung. Im Allgemeinen sieht das Diagramm der logischen Analyse wie folgt aus:
  

Löschen Sie den Wert der letzten Ziffer von pos

// 删除pos的后一个位置
void SLTEraseAfter(SLTNode* pos)
{
    
    
    assert(pos);
    //检查是否是尾节点
    assert(pos->next);
    pos->next = pos->next->next;
    free(pos->next);
    pos->next = NULL;
}

• Da wir nun pos kennen, können wir, wenn wir den nächsten von pos löschen möchten, einfach den nächsten von pos auf den nächsten des nächsten Knotens verweisen und ihn schließlich freigeben (pos->next) und ihn dann leer machen.

4. Zerstörung einer einzelnen verknüpften Liste

• Wenn unsere verknüpfte Liste aufgebraucht ist, müssen wir sie ebenfalls freigeben und dann leeren, da unsere einfach verknüpfte Liste dynamisch entwickelt wird.

// 单链表的销毁
void SListDestroy(SLTNode** pphead)
{
    
    
    assert(pphead);
    SLTNode* cur = *pphead;
    while (cur)
    {
    
    
        SLTNode* next = cur->next;
        free(cur);
        cur = next;
    }
    *pphead = NULL;
}

• Jeder Knoten wird durch Durchqueren freigegeben, und schließlich wird der Kopfzeiger auf leer gesetzt und die verknüpfte Liste wird zerstört.

---

Zusammenfassen

• Aufgrund des begrenzten Platzes ist der heutige Inhalt hier beendet. In diesem Artikel haben wir die Diskussion über die verbleibenden Schnittstellen beendet. Anschließend werden wir Sie zu einigen oj-Fragen führen, um Sie mit der praktischen Anwendung verknüpfter Listen vertrauter zu machen . Ich glaube, wenn Sie sich immer daran halten können, müssen Ihre Grundkenntnisse über verknüpfte Listen in Ordnung sein! Denken Sie daran, den Code selbst einzugeben!

• Wenn Sie Fragen haben, stellen Sie diese bitte im Kommentarbereich oder in der privaten Nachricht an mich. Bis zum nächsten Mal!

Für einen neuen Blogger ist es nicht einfach, einen neuen Blogger zu erstellen. Wenn Sie das Gefühl haben, dass der Inhalt des Artikels für Sie hilfreich ist, möchten Sie vielleicht vor dem Verlassen auf diesen neuen Blogger klicken. Ihre Unterstützung ist meine Motivation zum Update! ! !

**(Ke Li bittet Sie dreimal hintereinander, den Blogger zu unterstützen!!! Klicken Sie auf den Kommentar unten, um ihn zu liken und zu sammeln, um Ke Li zu helfen)**