00001_C++实现单链表（代码带有详细注释）

最新推荐文章于 2022-07-19 12:52:15 发布
最新推荐文章于 2022-07-19 12:52:15 发布
阅读量297 收藏 2
点赞数 1
分类专栏： 数据结构与算法 文章标签： c++ 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42869804/article/details/108229554
版权

线性表（单链表）

Node.h单一节点定义

#pragma once
#ifndef NODE_H
#define NODE_H
#include <iostream>
using namespace std;
class Node
{
public:
    int data;//数据域
    Node* next;//next指针域
    void printNode();//打印节点信息
private:
};
void Node::printNode()
{
    cout << data << endl;
}
#endif       // !NODE_H

List.h链表定义

#pragma once
#ifndef LIST_H
#define LIST_H//引入List.h
#include "Node.h"
using namespace std;
class List
{
public:
     List();                                           //创建线性表
    ~List();                                           //销毁线性表
    void ClearList();                                  //清空线性表
    bool ListEmpty();                                  //判断线性表是否为空
    int ListLength();                                  //获取线性表的长度
    bool GetElem(int n, Node* pNode);                  //获取指定元素
    int LocateElem(Node* pNode);                       //寻找第一个满足e的数据元素的位序
    bool PriorElem(Node* pCurrentNode, Node* pPreNode);//获取指定元素的前驱
    bool NextElem(Node* pCurrentNode, Node* pNextNode);//获取指定元素的后继
    bool ListInsert(int n, Node* pNode);               //在第n个位置上插入元素
    bool ListDelete(int n, Node* pNode);               //删除第n个位置上的元素
    bool ListInsertHead(Node* pNode);                  //头插法
    bool ListInsertTail(Node* pNode);                  //尾插法
    void ListTraverse();                               //便利线性表
private:
    Node* m_pList;
    int m_iLength;
};
List::List()
{
    m_pList = new Node;//node类型的指针new一个Node类型数据
    m_pList->data = 0;//默认头节点的数值为0
    m_pList->next = NULL;
    m_iLength = 0;//设置当前链表长度为0
}
List::~List()
{
    ClearList();//执行清理链表的程序，类中声明，类外定义，删除 除了头节点以外的所有结点
    delete m_pList;//释放头节点
    m_pList = NULL;//设置头节点指针为NULL
}
void List::ClearList()//函数定义
{
    Node* currentNode = m_pList->next;//创建currentNode指针指向头节点的下一个节点
    while (currentNode != NULL)//循环结束条件：头节点的next指针为空，即只剩下头节点
    {
        Node* temp = currentNode->next;//C++中指针访问指向数据的成员用->访问，将currentNode所指向数据的next指针赋值给 Node类型的temp指针
        delete currentNode;//释放currentNode所指向的内容
        currentNode = temp;//将下一节点的指针继续赋值给currentNode
    }
    m_pList->next = NULL;//m_pList指针所指向内容的next指针指向的内容已被释放，所以设置这个next指针为空（NULL）
}
bool List::ListEmpty()
{
    if (m_iLength == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
    //return m_iLength == 0 ? true : false;
}
int List::ListLength()
{
    return m_iLength;
}
bool List::GetElem(int n, Node* pNode)//获得指定位置的节点内容，n负责定位，pNode负责将数据带出来
{
    if (n < 0 || n >= m_iLength)//如果n小于0或者大于当前链表的长度，则无法定位
    {
        return false;//定位失败
    }
    else
    {
        Node* currentNode = m_pList;//从头节点的下一个节点开始遍历
        for (int i = 0; i <= n; i++)
        {
            currentNode = currentNode->next;
        }
        pNode->data = currentNode->data;//将定位的节点数据赋值给pNode的data变量
        return true;//返回定位成功
    }
}
int List::LocateElem(Node* pNode)//定位元素的位置
{
    Node* currentNode = m_pList;//将头节点指针赋值给currentNode指针
    int count = 0;
    while (currentNode != NULL)
    {
        currentNode = currentNode->next;//遍历除头节点外的所有节点
        if (currentNode->data == pNode->data)
        {
            return count;//返回count值，即定位的节点位置
        }
        count++;
    }
    return -1;//如果没有查找成功则返回-1
}
bool List::PriorElem(Node* pCurrentNode, Node* pPreNode)//pCurrentNode 就是想要查找此节点的前驱节点，用pPreNode指针将内容带出来
{
    Node* currentNode = m_pList;//头节点指针赋值给currentNode
    Node* tempNode = NULL;
    while (currentNode != NULL)//直到当前指针所指内容为空（NULL）
    {
        tempNode = currentNode;
        currentNode = currentNode->next;//回溯到头节点的下一个节点
        if (currentNode->data == pCurrentNode->data)//定位到想要查找的节点
        {
            if (tempNode == m_pList)//如果定位的节点为头节点，则失败，因为头节点没有前驱节点
            {
                return false;
            }
            pPreNode->data = tempNode->data;//将数据带出去
            return true;
        }
    }
    return false;
}
bool List::NextElem(Node* pCurrentNode, Node* pNextNode)//pCurrentNode 就是想要查找此节点的后继节点，用pNextNode指针将内容带出
{
    Node* currentNode = m_pList;
    Node* tempNode = NULL;
    while (currentNode != NULL)
    {
        currentNode = currentNode->next;
        if (currentNode->data == pCurrentNode->data)//定位到想要查找的节点
        {
            if (currentNode->next == NULL)//如果定位的节点为尾节点，则失败，因为尾节点没有后继节点
            {
                return false;
            }
            pNextNode->data = currentNode->next->data;//将数据带出去
            return true;
        }
    }
    return false;
}
void List::ListTraverse()//遍历链表
{
    Node* currentNode = m_pList;
    while (currentNode->next != NULL)//直到遍历到尾节点
    {
        currentNode = currentNode->next;
        currentNode->printNode();//调用Node类的printNode（）方法
    }
}
bool List::ListInsert(int n, Node* pNode)//在指定位置插入节点，传入想要插入的节点
{
    if (n < 0 || n > m_iLength)
    {
        return false;
    }
    else
    {
        Node* currentNode = m_pList;
        for (int i = 0; i < n; i++)
        {
            currentNode = currentNode->next;
        }
        Node* newNode = new Node;//内存爆掉的情况，无法new一个Node对象的时候
        if (newNode == NULL)
        {
            return false;
        }
        newNode->data = pNode->data;
        newNode->next = currentNode->next;//newNode指针与currentNode指针所指向内容的next指针指向同一个Node节点
        currentNode->next = newNode;//currentNode指针所指向内容的next指针指向newNode
        m_iLength++;//更新链表的长度
        return true;//返回插入成功
    }
}
bool List::ListDelete(int n, Node* pNode)//删除指定位置的节点，并将节点信息带出来
{
    if (n < 0 || n >= m_iLength)
    {
        return false;
    }
    else
    {
        Node* currentNode = m_pList;
        Node* currentNodeBefore = NULL;
        for (int i = 0; i <= n; i++)//一直遍历到指定位置
        {
            currentNodeBefore = currentNode;
            currentNode = currentNode->next;
        }
        currentNodeBefore->next = currentNode->next;//将当前节点的前驱节点的next指针指向当前节点next指针所指向的内容（即后继节点）
        pNode->data = currentNode->data;//将删除节点的内容带出来
        currentNode = NULL;//当前节点指向内容为空
        m_iLength--;//更新链表长度
        return true;//返回删除成功
    }
}
bool List::ListInsertHead(Node* pNode)//头插法插入节点
{
    Node* temp = m_pList->next;
    Node* newNode = new Node;//内存爆掉的情况，无法new一个Node对象的时候
    if (newNode == NULL)
    {
        return false;
    }
    newNode->data = pNode->data;//将需要插入节点的信息赋值给newNode
    newNode->next = temp;//newNode的next指针指向头节点的下一个节点
    m_pList->next = newNode;//头节点的next指针指向newNode
    m_iLength++;//更新链表长度
    return true;//返回插入成功
}
bool List::ListInsertTail(Node* pNode)//尾插法插入节点
{
    Node* currentNode = m_pList;
    Node* tempNode = NULL;
    while (currentNode != NULL)//先遍历到尾节点，最终tempNode为尾节点，currentNode是尾节点的next指针所指向的内容为空（NULL）
    {
        tempNode = currentNode;
        currentNode = currentNode->next;
    }
    Node* newNode = new Node;
    if (newNode == NULL)
    {
        return false;
    }
    newNode->data = pNode->data;//将需要插入节点的信息赋值给newNode
    newNode->next = NULL;//尾插法，插入节点作为尾节点所以其next指针内容为空（NULL）
    tempNode->next = newNode;//未插入前链表的尾节点的next指针指向newNode
    m_iLength++;//更新链表长度
    return true;//返回插入成功
}
#endif // !LIST_H

List.cpp主函数

#include "List.h"
#include "Node.h"
int main()
{
    List* pList = new List();
    Node e1, e2, e3, e4, e5, e6, e7, e8;
    e1.data = 1;
    e2.data = 2;
    e3.data = 3;
    e4.data = 4;
    e5.data = 5;
    e6.data = 6;
    e7.data = 7;
    pList->ListInsertHead(&e1);//头插法插入节点
    pList->ListInsertHead(&e2);//头插法插入节点
    pList->ListInsertHead(&e3);//头插法插入节点
    pList->ListInsertHead(&e4);//头插法插入节点
    pList->ListInsertHead(&e5);//头插法插入节点
    pList->ListInsertHead(&e6);//头插法插入节点
    pList->ListInsertTail(&e1);//尾插法插入节点
    pList->ListInsertTail(&e2);//尾插法插入节点
    pList->ListInsertTail(&e3);//尾插法插入节点
    pList->ListInsertTail(&e4);//尾插法插入节点
    pList->ListInsertTail(&e5);//尾插法插入节点
    pList->ListInsertTail(&e6);//尾插法插入节点
    //pList->ListInsert(6, &e7);//指定位置插入节点
    //pList->ListDelete(6, &e8);//指定位置删除节点
    pList->NextElem(&e4, &e8);//e8是将后继节点（e5）的内容带出去
    pList->ListTraverse();//遍历整个链表的内容
    cout << pList->ListLength() << " " << e8.data << endl;//获取整个链表的长度，e8的数据
    delete pList;//删除链表，pList会自动执行析构函数，自动释放链表的所有内容
    pList = NULL;//指针pList的内容为空
    system("pause");
    return 0;
}
EvolutionValue
关注
专栏目录
C++编写一个简单的单链表注册登录小项目（简单+注释）
m0_57037805的博客
10-20 1855
这里使用C++语言的单链表、结构体、类和文件I/O编写了一个简单登录注册小项目，带有注释，易懂
单链表反序（反转）C++实现
dawn_after_dark的博客
06-23 7667
问题描述就是给一个链表，求出反转后的链表，比如1 2 3 4 5反转后为5 4 3 2 1. 链表的基础定义及实现参考博文：http://blog.csdn.net/dawn_after_dark/article/details/73610674 下面的解决方法都是基于此类进行解决的。解决方法方法一：利用三个指针思路，利用三个指针（pre,mid,after）,原始状态为head->pre->m
c++实现的单链表
04-09
c++实现的单链表数据结构，供大家学习数据结构与算法使用
C++实现单链表
df737373的博客
07-20 129
单链表 相对于顺序表，多了一个next指针，用来连接数据，构成链式结构 下面是代码 #include<iostream> #include<assert.h> using namespace std; typedef int DataType; struct SListNode { SListNode* ...
使用c++实现单链表的操作 代码及测试代码
Probie2014的博客
07-30 243
#include <iostream> #include <cstdlib> using namespace std; struct node{ int data; node *next; }; struct node *head=NULL; /*用于摧毁单链表的全部数据*/ void DestoryList(...
单链表的代码实现 C/C++
qq_43609939的博客
12-29 282
静态链表 #include<iostream> using namespace std; struct Node { int num; //数据域 struct Node *next; //指针域 该指针指向结构体类型 }; int main() { //创建三个结点 struct Node Node1 = { 1, ...
数据结构----单链表（C++实现）
WYJ的博客
03-17 2737
111
【数据结构】链队列的实现（附带详细注释）
weixin_65334260的博客
07-19 847
链队列就是只允许尾进头出的单链表。本篇采用链式结构实现了队列的链式存储，同时实现了对链队列的一些操作。
单链表部分伪代码
weixin_43862765的博客
09-20 1719
链表部分伪代码 1、设计一个递归算法，删除不带头结点的单链表L中所有值为x的结点 文字思想; 1)建立递归函数，每一轮进行判断L->data是否为x，是则进行删除结点操作，然后 L = L->next，直到遍历到链表尾部L->next = NULL LNode *getElemByPos(LinkList L,int i) { int j = 1; LNode *P = L->next; if (i == 0) { return L;
C++实现的数据结构与算法源码.rar
03-21
本资源包含了一份用C++编写的、带有注释的数据结构与算法的源码，可以帮助学习者深入理解这些概念并提高编程能力。 1. **数组**：在C++中，数组是最基本的数据结构，它允许存储相同类型的一系列元素。数组的索引从0...
单链表源代码(C++版的)
06-07
不错的可以下来研究一下的，对初学的还是有点用的
c++实现单链表源代码
03-20
c++单链表源代码，其中运用到数据结构及c++的模板等内容
c++实现单链表
03-29
用c++实现单链表，单链表的每个结点的地址存放在其直接前驱结点的指针域中。其中第一个结点没有前驱结点，因此需要一个头指针指向第一个节点，便于我们对整个链表进行操作；这里的单链表的最后一个节点的指针域存放的是头结点的地址。 单链表不能随意存取，必要的时候我们可以通过已知结点的指针域不断遍历从而获取我们要的结点。
C/C++实现单向链表
01-16
分别用C和C++实现了单向链表（创建链表，插入数据、获取指定位置的数据、删除指定位置的数据...），如果在使用中觉得api不够用可以进行扩展；其中包含测试。
C++单链表代码实现
lyh_lll的博客
09-28 273
C++的标准模板库（STL）提供了List容器，实质上它是一个双向循环链表，学习数据结构的过程中自己简单用c++写了单链表。 1、数据类型这里简单化设成了int，如果要实现其他数据类型可以写一个类模板Template<class T>就行了 2、遍历算法find从头遍历到尾，时间复杂度为O(N)，但单链表也没有其他方法可用了，二分法之类的算法我觉得至少应当在双向链表中讨论 3、双向链表，已经链表的一些相关算法后续慢慢更新 代码如下： class Single_List_Node{ p
单链表程序示范(C++)
weixin_34221036的博客
04-20 128
#include<iostream> #include<stdlib.h> using namespace std; typedef struct tagNote { int nNumber; struct tagNote* pNext; }Note; bool CreateList(Note*&pListHead); bool...
c++/c代码注释
赤贯妖星
11-28 297
1、// 双斜杠 单行注释 偏c++风格 // this is test function int Test() { int width = 10; int height = 10; // declaration and defined // char name = 'a'; return 0; } 双斜杠所在行的所在位置后面的文本 都将注释掉； 2、/* *...
单链表的基本操作——c++（有详细注解）
m0_67228478的博客
03-17 3125
呕心沥血 千辛万苦 凌晨一点仍在调试 上辈子连环杀人，这辈子软件工程 无语住了 #include<iostream> typedef struct LNode{ int date; struct LNode *next; }LNode,*LinkList;//创造一个链表 bool InitList(LinkList &L); void CreateList(LinkList &L,int n); void PrintList(LinkList L); vo
sparse Coding的C++代码——详细注释版
MachineLP的专栏
05-03 2145
#include "stdafx.h" #include #include #include #include #include #include #include #include "sparse_coding.h" #include "retr_data_base.h" using namespace cv; // 归一化的操作。 void normalizing(floa
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值