資料結構之單向連結串列（C++語言描述）

阿新 • • 發佈：2019-02-02

該檔案是整個原始檔，包括單向連結串列節點的定義，各種操作函式，main()測試用例。

#include <iostream>

using namespace std;


struct ListNode     //用class時需要加public，因為public預設是private的
{
    int m_nValue;
    ListNode* m_pNext;
};

ListNode* CreateList();//新建單向連結串列
void deleteListMemory(ListNode** pHead);//刪除連結串列記憶體
void PrintListNode(ListNode* 
 pHead);//列印單向連結串列
int ListLength(ListNode* pHead);//單向連結串列測長
ListNode* SearchListNode1(ListNode* pHead, int pos);//查詢第pos位置的節點
int SearchListNode2(ListNode* pHead, int value);//查詢值為value的節點所在的位置
ListNode* InsertListNode(ListNode** pHead, int pos, int data);//在第pos個節點的後面插入新節點，
                                                             //當pos等於0時，表示在頭結點前面插入新節點 

ListNode* DeleteListNode1(ListNode** pHead, int pos);//指定刪除第pos位置的節點，pos從1開始
ListNode* DeleteListNode2(ListNode** pHead, int value);//刪除資料為value的所有節點
ListNode* ReverseList(ListNode* pHead);//翻轉一個連結串列
ListNode* SearchMidNode(ListNode* pHead);//尋找中間節點
ListNode* InsertNodeOrderly(ListNode* pHead);//在從小到大的排序連結串列pHead中插入節點，節點數值從控制檯輸入 

ListNode* InsertNodeOrderly(ListNode* pHead, ListNode* pInsertNode);//將節點從引數傳入，並插入
bool HasLoopInList(ListNode* pHead,ListNode** start);//判斷是否有迴環，如果有，將環的開始節點儲存在start中
ListNode* MergeListsOrderly(ListNode* pHead1, ListNode* pHead2);//合併有序單鏈表，非遞迴方法
ListNode* MergeListsOrderly_Recursively(ListNode* pHead1, ListNode* pHead2);//合併有序單鏈表，遞迴方法
int LastRemaining_Josephuse(unsigned int num, unsigned int kth);//約瑟夫環問題
ListNode* CreateLoopList();//新建單向迴圈連結串列,用於約瑟夫環
void PrintListFromTail_Iteratively(ListNode* pHead);//從尾部到頭列印連結串列，非遞迴，迭代
void PrintListFromTail_Recursively(ListNode* pHead);//從尾部到頭列印連結串列，遞迴

int main()
{
    ListNode* pHead = CreateList();
    cout << endl;

    //PrintListNode(pHead);
    //cout << endl;

    //int length = ListLength(pHead);
    //if (length != 0) cout << length << endl;

    //ListNode* result1 = SearchListNode1(pHead, 3);
    //if (result1 != NULL) cout << result1->m_nValue << endl;

    //int position = SearchListNode2(pHead, 7);
    //if (position) cout << position << endl;

    //ListNode* pNode = NULL;
    //ListNode* result2 = InsertListNode(&pHead, 3, 4);
    //if (result2 != NULL) PrintListNode(result2);
    //cout << endl;

    //ListNode* result3 = DeleteListNode1(&pHead, 3);
    //if (result3 != NULL) PrintListNode(result3);

    //ListNode* result4 = DeleteListNode2(&pHead, 3);
    //if (result4 != NULL) PrintListNode(result4);

    //ListNode* result5 = ReverseList(pHead);
    //if (result5 != NULL) PrintListNode(result5);

    //ListNode* result6 = SearchMidNode(pHead);
    //if (result6 != NULL) cout << result6->m_nValue << endl;

    //ListNode* pHead1 = new ListNode();ListNode* node1 = new ListNode();ListNode* node2 = new ListNode();
    //ListNode* node3 = new ListNode();ListNode* node4 = new ListNode();ListNode* node5 = new ListNode();
    //pHead1->m_nValue = 1;pHead1->m_pNext = node1;node1->m_nValue = 3;node1->m_pNext = node2;
    //node2->m_nValue = 4;node2->m_pNext = node3;node3->m_nValue = 6;node3->m_pNext = node4;
    //node4->m_nValue = 7;node4->m_pNext = node5;node5->m_nValue = 9;node5->m_pNext = NULL;
    //ListNode* result7 = InsertNodeOrderly(pHead);
    //if (result7 != NULL) PrintListNode(result7);
    //delete pHead, node1, node2, node3, node4, node5;
    //pHead = node1 = node2 = node3 = node4 = node5 = NULL;

    //ListNode* start = NULL;
    //bool result8 = HasLoopInList(pHead, &start);
    //if (start != NULL || result8) cout << start->m_nValue << endl;

    //ListNode* pHead2 = CreateList();
    //cout << endl;
    //ListNode* result9 = NULL;
    //result9 = MergeListsOrderly(pHead1, pHead2);
    //if (result9 != NULL) PrintListNode(result9);

    //ListNode* pHead2 = CreateList();
    //cout << endl;
    //ListNode* result10 = NULL;
    //result10 = MergeListsOrderly_Recursively(pHead1, pHead2);
    //if (result10 != NULL) PrintListNode(result10);

    //int result11 = -1;
    //result11 = LastRemaining_Josephuse(3, 0);
    //if (result11 != -1) cout << result11 << endl; 

    //ListNode* pHead = CreateLoopList();
    //if (pHead != NULL) PrintListNode(pHead);

    //PrintListFromTail_Iteratively(pHead);
    //cout << endl;
    //PrintListFromTail_Recursively(pHead);
    //cout << endl;

    deleteListMemory(&pHead);
    system("pause");
    return 0;
}

ListNode* CreateList()
{
    ListNode* pHead = NULL;
    ListNode* pNode = NULL;
    ListNode* pLastNode = NULL;

    int inputValue = 0;
    while (cin >> inputValue)
    {
        pNode = new ListNode();
        if (pNode == NULL)
        {
            cout << "申請記憶體失敗！" << endl;
            return NULL;
        }
        pNode->m_nValue = inputValue;
        pNode->m_pNext = NULL;

        if (pHead == NULL)
        {
            pHead = pNode;
        }
        else
        {
            pLastNode->m_pNext = pNode;
        }
        pLastNode = pNode;
    }

    return pHead;
}

void deleteListMemory(ListNode** pHead)
{
    if (*pHead == NULL || pHead == NULL) return;

    ListNode* pNode = *pHead;
    ListNode* pDeleted = NULL;
    while (pNode != NULL)
    {
        pDeleted = pNode;
        pNode = pNode->m_pNext;

        delete pDeleted;
        pDeleted = NULL;
    }
    pHead = NULL;
}

void PrintListNode(ListNode* pHead)
{
    if (NULL == pHead)
    {
        cout << "The list is empty!" << endl;
        return;
    }
    ListNode* pNode = pHead;
    while (pNode != NULL)
    {
        cout << pNode->m_nValue << " ";
        pNode = pNode->m_pNext;
    }
    return;
}

int ListLength(ListNode* pHead)
{
    if (NULL == pHead)
    {
        cout << "The list is empty!" << endl;
        return 0;
    }

    int length = 0;
    ListNode* pNode = pHead;
    while (pNode != NULL)
    {
        ++length;
        pNode = pNode->m_pNext;
    }

    return length;
}

ListNode* SearchListNode1(ListNode* pHead, int pos)
{
    if (pHead == NULL || pos <= 0)
    {
        cout << "Error:invalid input!" << endl;
        return NULL;
    }

    if (1 == pos) return pHead;
    else
    {
        ListNode* pNode = pHead;
        int index = 2;
        while (index <= pos)
        {
            pNode = pNode->m_pNext;
            if (NULL == pNode)
            {
                cout << "Error:the pos is larger than the length!" << endl;
                return NULL;
            }
            ++index;
        }
        return pNode;
    }
}

int SearchListNode2(ListNode* pHead, int value)
{
    if (NULL == pHead)
    {
        cout << "Error:the list is empty!" << endl;
        return 0;
    }

    ListNode* pNode = pHead;
    int pos = 1;
    while (pNode != NULL && pNode -> m_nValue != value)
    {
        pos++;
        pNode = pNode->m_pNext;
    }

    if (NULL == pNode)
    {
        cout << "Can't find the node!" << endl;
        return 0;
    }
    else return pos;
}

ListNode* InsertListNode(ListNode** pHead, int pos, int data)
{
    if (pos < 0)
    {
        cout << "Error:the position is invalid!" << endl;
    }

    ListNode* pNew = new ListNode();
    pNew->m_nValue = data;
    pNew->m_pNext = NULL;

    if (NULL == pHead || NULL == *pHead)
    {
        *pHead = pNew;
    }
    else if (0 == pos)
    {
        pNew->m_pNext = *pHead;
        *pHead = pNew;  
    }
    else
    {
        ListNode* pNode = SearchListNode1(*pHead, pos);
        if (pNode != NULL)
        {
            pNew->m_pNext = pNode->m_pNext;
            pNode->m_pNext = pNew;
        }   
    }
    return *pHead;
}

ListNode* DeleteListNode1(ListNode** pHead, int pos)
{
    if (*pHead == NULL || pHead == NULL || pos <= 0)
    {
        cout << "List is empty or the position is invalid!" << endl;
        return *pHead;
    }

    if (pos == 1)
    {
        ListNode* pDeleted = *pHead;
        *pHead = (*pHead)->m_pNext;
        delete pDeleted;
        pDeleted = NULL;

        return *pHead;
    }
    else
    {
        ListNode* pNode = SearchListNode1(*pHead, pos - 1);
        if (pNode != NULL && pNode->m_pNext != NULL)
        {
            ListNode* pDeleted = pNode->m_pNext;
            pNode->m_pNext = pNode->m_pNext->m_pNext;

            delete pDeleted;
            pDeleted = NULL;
        }
        return *pHead;
    }
}

ListNode* DeleteListNode2(ListNode** pHead, int value)
{
    if (*pHead == NULL || pHead == NULL)
    {
        cout << "List is empty!" << endl;
        return NULL;
    }

    ListNode* pToBeDeleted = NULL;
    while ((*pHead) != NULL && (*pHead)->m_nValue == value)
    {
        pToBeDeleted = *pHead;
        *pHead = (*pHead)->m_pNext;

        delete pToBeDeleted;
        pToBeDeleted = NULL;
    }

    ListNode* pNode = *pHead;
    while (pNode != NULL && pNode->m_pNext != NULL)
    {
        while (pNode->m_pNext->m_pNext != NULL && pNode->m_pNext->m_nValue == value)
        {
            pToBeDeleted = pNode->m_pNext;
            pNode->m_pNext = pNode->m_pNext->m_pNext;

            delete pToBeDeleted;
            pToBeDeleted = NULL;
        }
        if (pNode->m_pNext->m_nValue != value)
        {
            pNode = pNode->m_pNext;
        }
        else//pNode->m_pNext->m_pNext == NULL
        {
            if (pNode->m_pNext->m_nValue == value)
            {
                pToBeDeleted = pNode->m_pNext;
                pNode->m_pNext = pNode->m_pNext->m_pNext;

                delete pToBeDeleted;
                pToBeDeleted = NULL;
            }
        }
    }
    return *pHead;
}

ListNode* ReverseList(ListNode* pHead)
{
    if (pHead == NULL)
    {
        cout << "List is empty!" << endl;
        return NULL;
    }

    if (pHead->m_pNext == NULL) return pHead;

    ListNode* pPreNode = pHead;
    ListNode* pCurNode = pHead->m_pNext;
    ListNode* pNxtNode = pCurNode->m_pNext;
    ListNode* pReverseHead = NULL;

    pPreNode->m_pNext = NULL;

    while (pNxtNode != NULL)
    {
        pCurNode->m_pNext = pPreNode;

        pPreNode = pCurNode;
        pCurNode = pNxtNode;
        pNxtNode = pCurNode->m_pNext;
    }
    pCurNode->m_pNext = pPreNode;

    pReverseHead = pCurNode;
    return pReverseHead;
}

ListNode* SearchMidNode(ListNode* pHead)
{
    if (NULL == pHead)
    {
        cout << "List is empty!" << endl;
        return NULL;
    }

    ListNode* pCurNode = pHead;
    ListNode* pMidNode = pHead;
    int curIndex = 0;
    int midIndex = 0;

    while (pCurNode != NULL)
    {
        if (curIndex / 2 > midIndex)
        {
            midIndex++;
            pMidNode = pMidNode->m_pNext;
        }
        curIndex++;
        pCurNode = pCurNode->m_pNext;
    }
    return pMidNode;
}

ListNode* InsertNodeOrderly(ListNode* pHead)
{
    int value = 0;
    while (cin >> value)
    {
        ListNode* pInsertNode = new ListNode();
        pInsertNode->m_nValue = value;
        pInsertNode->m_pNext = NULL;

        if (pHead == NULL)
        {
            pHead = pInsertNode;
            continue;
        }

        if (pInsertNode->m_nValue <= pHead->m_nValue)
        {
            pInsertNode->m_pNext = pHead;
            pHead = pInsertNode;
            continue;
        }

        ListNode* pCurNode = pHead;
        ListNode* pPreNode = NULL;
        while (pInsertNode->m_nValue > pCurNode->m_nValue && pCurNode->m_pNext != NULL)
        {
            pPreNode = pCurNode;
            pCurNode = pCurNode->m_pNext;
        }
        if (pInsertNode->m_nValue <= pCurNode->m_nValue)
        {
            pPreNode->m_pNext = pInsertNode;
            pInsertNode->m_pNext = pCurNode;
        }
        else pCurNode->m_pNext = pInsertNode;
    }
    return pHead;
}

bool HasLoopInList(ListNode* pHead, ListNode** start)
{
    if (pHead == NULL)
    {
        cout << "List is empty!" << endl;
        *start = NULL;
        return false;
    }

    ListNode* pBehind = pHead;
    ListNode* pAhead = pHead->m_pNext;
    if (pAhead == NULL)
    {
        cout << "List has only one node, has no loop!" << endl;
        *start = NULL;
        return false;
    }

    while (pAhead != NULL && pBehind != NULL)
    {
        if (pAhead == pBehind)
        {
            int nodesInLoop = 1;
            ListNode* pNode1 = pAhead;
            while (pNode1->m_pNext != pAhead)
            {
                ++nodesInLoop;
                pNode1 = pNode1->m_pNext;
            }

            pNode1 = pHead;
            for (int i = 0; i < nodesInLoop; ++i)
            {
                pNode1 = pNode1->m_pNext;
            }

            ListNode* pNode2 = pHead;
            while (pNode1 != pNode2)
            {
                pNode1 = pNode1->m_pNext;
                pNode2 = pNode2->m_pNext;
            }
            *start = pNode1;
            return true;
        }
        pBehind = pBehind->m_pNext;
        pAhead = pAhead->m_pNext;
        if (pAhead != NULL)
            pAhead = pAhead->m_pNext;
    }
    cout << "List has no loop!" << endl;
    *start = NULL;
    return false;
}

ListNode* MergeListsOrderly(ListNode* pHead1, ListNode* pHead2)
{
    if (pHead1 == NULL) return pHead2;
    else if (pHead2 == NULL) return pHead1;

    ListNode* pMergeHead = NULL;
    ListNode* pNode = NULL;
    if (ListLength(pHead1) >= ListLength(pHead2))
    {
        pMergeHead = pHead1;
        pNode = pHead2;
    }
    else
    {
        pMergeHead = pHead2;
        pNode = pHead1;
    }

    ListNode* pNxtNode = NULL;
    while (pNode != NULL)
    {
        pNxtNode = pNode->m_pNext;
        pMergeHead = InsertNodeOrderly(pMergeHead, pNode);
        pNode = pNxtNode;
    }
    if (pMergeHead == pHead1) pHead2 = NULL;
    else if (pMergeHead == pHead2) pHead1 = NULL;
    return pMergeHead;
}

ListNode* InsertNodeOrderly(ListNode* pHead, ListNode* pInsertNode)
{
    if (pHead == NULL)
    {
        pHead = pInsertNode;
        return pHead;
    }
    if (pInsertNode->m_nValue <= pHead->m_nValue)
    {
        pInsertNode->m_pNext = pHead;
        pHead = pInsertNode;
        return pHead;
    }

    ListNode* pCurNode = pHead;
    ListNode* pPreNode = NULL;
    while (pInsertNode->m_nValue > pCurNode->m_nValue && pCurNode->m_pNext != NULL)
    {
        pPreNode = pCurNode;
        pCurNode = pCurNode->m_pNext;
    }
    if (pInsertNode->m_nValue <= pCurNode->m_nValue)
    {
        pPreNode->m_pNext = pInsertNode;
        pInsertNode->m_pNext = pCurNode;
    }
    else pCurNode->m_pNext = pInsertNode;

    return pHead;
}

ListNode* MergeListsOrderly_Recursively(ListNode* pHead1, ListNode* pHead2)
{
    if (pHead1 == NULL) return pHead2;
    if (pHead2 == NULL) return pHead1;

    ListNode* pMergeHead = NULL;
    if (pHead1->m_nValue < pHead2->m_nValue)
    {
        pMergeHead = pHead1;
        pMergeHead->m_pNext = MergeListsOrderly_Recursively(pHead1->m_pNext, pHead2);
    }
    else
    {
        pMergeHead = pHead2;
        pMergeHead->m_pNext = MergeListsOrderly_Recursively(pHead1, pHead2->m_pNext);
    }
    return pMergeHead;
}

#include <list>
int LastRemaining_Josephuse(unsigned int num, unsigned int kth)
{
    if (num < 1 || kth < 1)
    {
        cout << "Error: invalid input!" << endl;
        return -1;
    }

    std::list<int> numbers;
    numbers.clear();
    for (int i = 0; i < num; ++i)
        numbers.push_back(i);

    list<int>::iterator current = numbers.begin();
    while (numbers.size() > 1)
    {
        for (int i = 1; i < kth; ++i)
        {
            current++;
            if (current == numbers.end())
                current = numbers.begin();
        }

        list<int>::iterator next = ++current;
        if (next == numbers.end())
            next = numbers.begin();

        current--;
        numbers.erase(current);
        current = next;
    }
    return (*current);
}

ListNode* CreateLoopList()
{
    ListNode* pHead = CreateList();
    if (pHead == NULL || pHead->m_pNext == NULL)
    {
        cout << "Can't create a loop list,list is empty or has only one node!" << endl;
        return NULL;
    }

    ListNode* pNode = pHead;
    while (pNode->m_pNext != NULL)
    {
        pNode = pNode->m_pNext;
    }
    pNode->m_pNext = pHead;

    return pHead;
}

#include <stack>
void PrintListFromTail_Iteratively(ListNode* pHead)
{
    if (pHead == NULL)
    {
        cout << "List is empty!" << endl;
        return;
    }

    std::stack<ListNode*> nodesStack;
    ListNode* pNode = pHead;
    while (pNode != NULL)
    {
        nodesStack.push(pNode);
        pNode = pNode->m_pNext;
    }

    while (!nodesStack.empty())
    {
        pNode = nodesStack.top();
        cout << pNode->m_nValue << " ";
        nodesStack.pop();
    }
}

void PrintListFromTail_Recursively(ListNode* pHead)
{
    if (pHead != NULL)
    {
        if (pHead->m_pNext != NULL)
        {
            PrintListFromTail_Recursively(pHead->m_pNext);
        }
        printf("%d ", pHead->m_nValue);
    }
}

資料結構之單向連結串列（C++語言描述）

該檔案是整個原始檔，包括單向連結串列節點的定義，各種操作函式，main()測試用例。 #include <iostream> using namespace std; struct ListNode //用class時需要加publi

資料結構之單向連結串列

連結串列（Linked list）是一種常見的基礎資料結構，是一種線性表，但是不像順序表一樣連續儲存資料，而是在每一個節點（資料儲存單元）裡存放下一個節點的位置資訊（即地址）。連結串列可以分為單向連結串列、單向迴圈連結串列、雙向連結串列單向連結串列也叫單鏈

資料結構學習筆記-迴圈連結串列（C語言實現）

迴圈連結串列的概念主要就是讓單鏈表的尾節點的指標不為空並且指向頭節點。像這樣的迴圈連結串列和普通單鏈表除了判斷條件幾乎沒有任何區別，判斷條件就是從p->next是否為空改為p->next是否等於頭節點，如果等於頭節點則迴圈結束。#include <std

資料結構之雙向連結串列（JAVA實現）

歡迎轉載，請附出處： http://blog.csdn.net/as02446418/article/details/47114711 最近重新複習了一些基礎的資料結構，發覺自己好多已經淡忘了，索性重新撿起來以前的知識，今天筆者回顧了一下連結串列的知識，用J

資料結構之單向連結串列----python實現

單向連結串列單向連結串列也叫單鏈表，是連結串列中最簡單的一種形式，它的每個節點包含兩個域，一個資訊域（元素域）和一個連結域。這個連結指向連結串列中的下一個節點，而最後一個節點的連結域則指向一個空值。表元

（PAT乙級）1025 反轉連結串列（C語言實現）

總結： 1、首先要有hash雜湊思想，關鍵字是首地址，對應到的陣列內可以查詢到首地址對應的數值和下一地址。這樣可以構成一組資料的輸入。 2、還應該考慮輸入樣例中有不在連結串列中的結點的情況。所以用個sum計數統計在連結串列裡的有效節點。注意連結串列的最後為空，所以對應

資料結構—順序表基本操作（c語言程式碼）

順序表計算機內部儲存一張線性表是用一組連續地址記憶體單元，這種儲存結構即為順序儲存結構，這種結構下的線性表叫順序表。順序表有兩種定義方法： 1.靜態定義

設計模式之簡單工廠模式（C#語言描述）

嚴格意義上來說，簡單工廠模式並不屬於GoF的23種設計模式，但是它是學習其他工廠模式的基礎和前提條件。理解了簡單工廠模式，學習工廠方法模式和抽象工廠模式會比較容易一些。簡單工廠模式的定義定義一個工廠類，他可以根據不同的引數返回不同類的例項。通常情況下，被建立的類的例項通常都具有共同的父類。

C語言資料結構之靜態連結串列實現（A-B）U（B-A)

時間複雜度O(3n)不是很難，直接貼程式碼：StaticLinkList.h#ifndef _STATIC_LINK_LIST_H_ #define _STATIC_LINK_LIST_H_ #define MAXSIZE 100 typedef enum {ERROR,OK

C++資料結構之靜態連結串列

宣告：本文所有的字詞如指標，指向，地址都不是真正意義上的指標與地址，只是為了方便理解與說明。結點為結構體，與單鏈表相差無幾，都有資料域和指標域，只不過單鏈表中的next是真的指標，指向記憶體地址，而靜態連結串列中的next則指向下一個元素在陣列中的下標struct Node{

資料結構單鏈表之建立連結串列（尾插法）

接上一篇內容，這次使用尾插法來建立單鏈表： 1.同樣建立連結串列成員結構體： struct listnode { int value; listnode* next; }; 2.然後下面就是通過尾插法建立單鏈表的程式，這裡面稍稍要去理解

資料結構－單向連結串列

package com.mzs.demo5; public class Node { private int data; private Node next; public Node(int data) { this.data = data; } public void

Java手寫LinkedList 應用資料結構之雙向連結串列

作為Java程式設計師，紮實的資料結構演算法能力是必須的 LinkedList理解的最好方式是，自己手動實現它 ArrayList和LinkedList是順序儲存結構和鏈式儲存結構的表在java語言中的實現. 　　ArrayList提供了一種可增長陣

資料結構之核心連結串列

核心連結串列設計的非常巧妙，但也不是什麼難理解的內容，關於核心連結串列的介紹網上有很多，這裡就不贅述了，來個使用的例子吧。 list.h #ifndef HS_KERNEL_LIST_H #define HS_KERNEL_LIST_H #define offsetof(TYPE, MEM

資料結構------使用單向連結串列實現簡單的學生成績管理操作

函式宣告 ypedef int status; typedef int ElemType; //連結串列節點及連結串列資料表示定義 typedef struct No

Java版資料結構之迴圈連結串列的實現

簡介在指定結點後新增一個結點刪除指定結點的下一個結點獲取下一個結點獲取結點資料 public class LoopNode { int data;//資料域 LoopNode next;//下一個結點 public Loop

1.6 python資料結構之雙向連結串列/迴圈連結串列——以OrderedDict資料結構為例

在連結串列這一部分的最後，我們以python中十分強大的collections包中的OrderedDict為例，看一下雙向迴圈列表的功能實現。 OrderedDict 它提供了有序的dict結構，因此他不是常規的雜湊雜湊表，為了保證儲存物件有序，它用連結串列實現了這一功能，

【php實現資料結構】單向連結串列

什麼是單向連結串列連結串列是以鏈式儲存資料的結構，其不需要連續的儲存空間，連結串列中的資料以節點來表示，每個節點由元素(儲存資料)和指標(指向後繼節點)組成。單向連結串列（也叫單鏈表）是連結串列中最簡單的一種形式，每個節點只包含一個元素和一個指標。它有一個表頭，並且除了最後一個節點外，所有節點都有其後

資料結構之迴圈連結串列

迴圈連結串列是資料結構中連結串列的一種形式。相對於單向連結串列，將單向連結串列的尾結點的指標域指向該單向連結串列的頭結點，就構成了迴圈連結串列。可以這麼理解，單向連結串列就是一張單程火車票，比如你要從北京坐火車去上海，路上經過濟南、南京，此時北京、濟南、南京、上海就構成了

資料結構之跳躍連結串列

#include<stdio.h> #include<stdlib.h> #define MAX_LEVEL 10 //最大層數 //節點 typedef struct nodeStructure { int key; in

資料結構之單向連結串列（C++語言描述）

相關推薦