数据结构之单向链表（C++语言描述）

最新推荐文章于 2023-08-18 14:25:09 发布
最新推荐文章于 2023-08-18 14:25:09 发布
阅读量334 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 单向链表 数据结构 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alexander_1314/article/details/82154473
版权

该文件是整个源文件，包括单向链表节点的定义，各种操作函数，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);
    }
}
Alexander_1314
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法:单向链表实现与封装
08-26
今天小编就为大家分享一篇关于数据结构与算法:单向链表实现与封装，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
C/C++实现单向链表
01-16
分别用C和C++实现了单向链表（创建链表，插入数据、获取指定位置的数据、删除指定位置的数据...），如果在使用中觉得api不够用可以进行扩展；其中包含测试。
数据结构——链表单向链表的创建插入删除遍历操作（C++实现）
少年
10-30 1321
链表较数组优缺点 链表 优点： 插入删除元素效率高。 Note：插入和删除一个元素，只需要修改该位置上前后节点的指针即可。 不需要一个连续的很大的内存。 Note：链表内存为随机分配，基本不存在链表满的情况 缺点： 查找某个未知的元素效率低。 Note：需要从头结点或者尾结点（双向链表）开始，对每个节点进行遍历，直到找到该元素。 数组 优点： 存取速度快 缺点： 需要一个很连续的很大的内存。...
单链表（C++）
weixin_63198483的博客
11-14 1077
数据结构与算法---单链表上的各项操作（C++）
c++数据结构—单向链表
qq_67972375的博客
03-14 1401
由两部分组成：数据域和指针域,每个结点都有一个指针，每个节点指针的指向都是指向自身结点的下一个结点，最后一个结点的head指向为NULL,对单链表的操作只能从一端开始，如果需要查找链表中的某一个结点，则需要从头开始进行遍历。
C++ 单链表
vivian_ll的博客
10-22 1552
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)，简单来说链表并不像数组那样将数组存储在一个连续的内存地址空间里，它们可以不是连续的因为他们每个节点保存着下一个节点的引用（地址），所以较之数组来说这是一个优势。 ...
C++数据结构之--单向链表（SingleList）
最新发布
who_I_am__的博客
08-18 647
C++单向链表, 查找,头部添加,尾部添加,删除反转等功能.
单向链表类模板（全）C++
01-22
含单链表类LinkList.h, 结点类Node.h, 辅助头文件Assistance.h, 测试文件TestLinkList.cpp及TestLinkList.exe
用单向链表实现栈（C++源代码）
04-07
栈是基本的数据结构。其特点是添加和访问数据都在线性表的一端（头端）。数据访问遵循先进后出（FILO）的原则。栈一般用数组或者链表来实现。...是C++、数据结构及算法学习的一个小小练习。供大家参考。
C++数据结构与算法之反转链表的方法详解
01-20
本文实例讲述了C++数据结构与算法之反转链表的方法。分享给大家供大家参考，具体如下： 算法概述：要求实现将一条单向链表反转并考虑时间复杂度。 算法分析： 数组法(略)： 将列表元素逐个保存进数组，之后再逆向...
数据结构单链表C++语言的实现
04-20
数据结构中单链表的实现，包括两个链表的合并，求交集，求并集，增加，删除，插入功能
数据结构单链表初始化c/c++语言代码实现
01-22
很多刚接触数据结构的小白在学完单链表，只知道理论知识，却不知道如何实现，这是用c++语言实现的两种单链表初始化过程
数据结构-单链表(c++)超全超详细
Abieai的博客
11-26 7247
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、单链表是什么？二、单链表上基本操作的实现1.定义单链表2.单链表初始化3.头插法4.尾插法5.任意位置插入6.按位取值7.按值取位8.删除结点9.打印链表10.销毁链表三、完整代码(功能过多，建议注释一部分使用)总结 前言 顺序表可以随时存取表中的任意一个元素，它的存储位置可以用一个简单直观的公式表示，但插入和删除操作需要移动大量元素。链式存储线性表时，不需要使用地址的连续存储单元，即不要求逻辑上相邻元素在物理地址上也相邻
数据结构C++实现单链表以及各种操作！
qq_58240448的博客
06-30 2773
使用c++实现的单链表以及各种操作，入插入、删除等！
数据结构实验一(2)：单链表 C++实现
qq_45050714的博客
08-21 1491
数据结构实验：C++实现链表 实验内容 定义一个包含学生信息（学号，姓名，成绩）的单链表，使其具有如下功能（参见教材中基本操作）： (1) 前插法或者后插法构建表； (2) 逐个显示学生表中所有学生的相关信息（显示表，即遍历表）； (3) 根据姓名进行查找，返回此学生的学号和成绩（查找）； (4) 根据指定的位置可返回相应的学生信息（学号，姓名，成绩）（取值 ）； (5) 给定一个学生信息，插入到表中指定的位置（插入）； (6) 删除指定位置的学生记录（删除）； (7) 统计表中学生个数（相当于求
数据结构：链表及其C++实现
热门推荐
forGemini的博客
05-26 1万+
前言 链表是一种非常非常基础的数据结构，本文首先讲解链表的基础知识，然后使用C++的模板实现了一个链表类，并简单实现了常见的插入、删除、查找等算法。 阅读本文需要对C/C++的指针具有一定的了解。 基础知识 链表是一种逻辑上连续，内存上分散的线性表数据结构，其基本单位为结点，每个结点分数据区和指针区，数据区用于存放数据，指针区则用于指向其他结点，通过指针每个结点就被串接成了一条“链子”。
数据结构 单链表 C++ 实现
axyzstra 的博客
03-25 3420
单链表 单链表的定义 typedef int ElemType; typedef struct LNode { ElemType data; LNode *next; } LNode, *LinkList; 此处 LNode 强调一个结点，*LinkList 强调一个单链表的头指针，本例中只有头指针使用 *LinkList ； 单链表的头指针和头节点 若单链表没有头节点，那么单链表的头指针则指向链表的第一个元素；若由头节点，头指针指向头节点；例如头指针为 L；如果链表为空，则有 L ==
C++实现单链表（Single Linked List）
weixin_42133358的博客
05-14 7737
C++实现单链表（Single Linked List） 语言这个东西不用真的会忘， 我记得前前后后C++的基本语法我也看了好几遍了，一直没有动手写过什么东西，所以一遍遍的看，一遍遍的忘… … 正好最近在看数据结构，想着自己用C++来实现一下，一方面是熟悉整个逻辑过程，加深对数据结构的理解，另一方面，也熟悉一下C++。 单链表是线性表的链式存储结构，同顺序存储结构（可以理解为C++中的数组）不同的是，单链表在插入和删除一个结点时，不需要移动大量的元素，但是单链表没有数组中索引的概念，所以在查询一个元素
C++单链表
weixin_62313265的博客
12-13 4989
链表是一种常见的数据结构。它主要是利用动态内存分配、结合结构体并配合指针来实现的，能根据需要开辟和释放内存单元。
数据结构双向链表c++
03-31
双向链表是一种常见的数据结构，与单向链表相比，它每个节点都有两个指针，分别指向前驱节点和后继节点。这样，双向链表可以实现双向遍历，插入和删除操作也更加方便。 以下是用C语言实现双向链表的代码： ```c #...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值