慕课网之C++数据结构学习笔记--线性表篇（二，链表）

最新推荐文章于 2024-08-12 15:45:48 发布
最新推荐文章于 2024-08-12 15:45:48 发布
阅读量140 收藏
点赞数
文章标签： 数据结构与算法 c/c++
原文链接：https://my.oschina.net/ykduan/blog/1502931
版权

      单链表是一种链式存取的数据结构，用一组地址任意的存储单元存储线性表中的数据元素，链表中的数据是以结点来表示的，每个结点的构成如图所示：数据域是存储数据的存储单元，指针域就是连接每个结点的地址数据。

单链表与顺序表相比：

1.顺序表可以方便的随机存取表中的任一结点，速度快；但是在表中插入删除一个数据时，为了保持其他数据的相对次序不变，平均需要移动一半的元素，效率很低；还有就是事先对表长估计无法确定，若是申请的表长过大，就会造成内存浪费，过小则还需要拷贝到一个更大的数组中，时间开销很大；

2，相反，链表则适用于插入删除频繁，表长估计不定的情形；

161205_vWGf_3315509.png

循环链表：是另一种形式的链式存贮结构，非常类似于单链表，它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。循环链表又分为单循环链表和多重循环链表。

161912_Ddrz_3315509.png

双向链表：也叫双链表，每个数据结点都有两个指针域，一个数据域；第一个指针域指向它的直接前驱，第二个指针域指向它的直接后继。可以看出来，从双链表的任意结点都可以很方便的访问它的前驱和后继结点。双向链表在插入操作时，需要考虑前后的方向的操作。

161950_oI2K_3315509.png

下面的例子主要是围绕单链表的实现，注释很详细，

一，链表的头文件List.h

#pragma once

#include "Node.h"
#ifndef LIST_H
#define LIST_H


class List
{
public:
    List(int size);//构造函数，初始化线性表
    ~List();//析构函数，销毁线性表
    void ClearList();//清空线性表
    bool ListEmpty();//判断线性表是否为空
    int ListLength();//获取线性表的长度
    bool GetElem(int i, int *e);//获取指定元素
    int LocateElem(int *e);//寻找第一个满足e的数据元素的位序
    bool PriorElem(int *currentElem, int *preElem);//获取指定元素的前驱
    bool NextElem(int *currentElem, int *nextElem);//获取指定元素的后继
    void ListTraverse();//遍历整个线性表
    bool ListInsert(int i, int *e);//在指定位置插入元素
    bool ListDelete(int i, int *e);//删除指定位置的元素
/*************************************************************************/
    //单链表
/*
public:
    List();//构造函数，初始化线性表
    ~List();//析构函数，销毁线性表
    void ClearList();//清空线性表
    bool ListEmpty();//判断线性表是否为空
    int ListLength();//获取线性表的长度
    bool GetElem(int i, Node *pNode);//获取指定元素
    int LocateElem(Node *pNode);//寻找第一个满足e的数据元素的位序
    bool PriorElem(Node *pCurrentNode, Node *pPreNode);//获取指定元素的前驱
    bool NextElem(Node *pCurrentNode, Node *pPreNode);//获取指定元素的后继
    void ListTraverse();//遍历整个线性表
    bool ListInsert(int i, Node *pNode);//在指定位置插入元素
    bool ListDelete(int i, Node *pNode);//删除指定位置的元素
    bool ListInsertHead(Node *pNode);//在头结点插入元素
    bool ListInsertTail(Node *pNode);//在尾结点插入元素
private:
    Node *m_pList;
    int m_iLength;
*/

/*************************************************************************/

private:
    int *m_pList;
    int m_iSize;
    int m_iLength;
};
#endif // !LIST_H

链表的cpp文件List.cpp
//

#include "stdafx.h"
#include "List.h"
#include <iostream>

using namespace std;

//构造函数，初始化线性表
List::List(int size)
{
    m_iSize = size;
    m_pList = new int[m_iSize];
    m_iLength = 0;

}
/**************************************/
//单链表中的构造函数
//List::List()
//{
//    m_pList = new Node;//为结点申请一块内存
//    m_pList->data = 0;//初始化单链表中的数据域
//    m_pList->next = NULL;//初始化单链表中的指针域
//    M_iLength = 0;
//}
/*************************************/
//析构函数，销毁线性表
List::~List()
{
    delete []m_pList;
    m_pList = NULL;
}
/*************************************/
//单链表中的析构函数
//List::~List()
//{
//    ClearList();//调用ClearList(),
//    delete m_pList;//删除申请的内存
//    m_pList = NULL;//将指针置为NULL
//}

/************************************/
//清空线性表
void List::ClearList()
{
    m_iLength = 0;
}
/***********************************/
//清空单链表
//void List::ClearList()
//{
//    Node *currentNode = m_pList->next;
//    while (currentNode != NULL)
//    {
//        Node *temp = currentNode->next;//先找到当前结点的下一个结点的指针域
//        delete currentNode;//然后删除当前结点
//        currentNode = temp;//然后把下一个结点的指针置为当前结点，进行循环
//    }
//    m_pList->next = NULL;//跳出循环，把当前结点的指针置为NULL
//}
/**********************************/
//判断线性表是否为空，适用于单链表
bool List::ListEmpty()
{
    if (m_iLength == 0)
    {
        return true;
    }
    return false;
}
//获取线性表的长度，适用于单链表
int List::ListLength()
{
    return m_iLength;
}
//获取指定元素
bool List::GetElem(int i, int * e)
{
    if(i < 0 || i >= m_iSize)
    {
        return false;
    }
    *e = m_pList[i];
    return true;
}
/*******************************************************************************/
//单链表中获取元素的函数
//bool List::GetElem(int i, Node *pNode)//该函数通过结点编号和结点地址(指针)，获取该元素
//{
//    if (i < 0 || i >= m_iLength)
//    {
//        return false;
//    }
//    Node *currentNode = m_pList;//把链表中的结点指针置为当前指针
//    Node *currentNodeBefore = NULL;//并把当前结点指针的前一个结点的指针置为null
//    for (int k = 0; k <= i; k++)//当前循环只为找到第i个结点
//    {
//        currentNodeBefore = currentNode;//把当前结点的指针指向
//        currentNode = currentNode->next;
//    }
//    pNode->data = currentNode->data;
//    return true;
//}
/*******************************************************************************/
//寻找第一个满足e的数据元素的位序
int List::LocateElem(int * e)
{
    for (int i = 0; i < m_iLength; i++)
    {
        if (m_pList[i] == *e)
        {
            return i;
        }
    }
    return -1;
}
/*******************************************************************************/
// 单链表中寻找第一个满足pNode结点的位序
//int List::LocateElem(Node *pNode)
//{
//    Node *currentNode = m_pList;
//    int count = 0;
//    while (currentNode->next != NULL)
//    {
//        currentNode = currentNode->next;
//        if (currentNode->data == pNode->data)
//        {
//            return count;
//        }
//        count++;
//    }
//    return -1;
//}
/*******************************************************************************/
//获取指定元素的前驱
bool List::PriorElem(int * currentElem, int * preElem)
{
    int temp = LocateElem(currentElem);
    if(temp == -1)
    {
        return false;
    }
    else
    {
        if (temp == 0)
        {
            return false;
        }
        else
        {
            *preElem = m_pList[temp - 1];
            return true;
        }
    }
}
/*******************************************************************************/

//bool List::PriorElem(Node *pCurrentNode, Node *pPreNode)
//{
//    Node *currentNode = m_pList;
//    Node *tempNode = NULL;
//    while (currentNode->next != NULL)
//    {
//        tempNode = currentNode;
//        currentNode = currentNode->next;
//        if (currentNode->data == pCurrentNode->data)
//        {
//            if (tempNode == m_pList)
//            {
//                return false;
//            }
//            pPreNode->data = tempNode->data;
//            return true;
//        }
//    }
//}
/*******************************************************************************/
//获取指定元素的后继
bool List::NextElem(int * currentElem, int * nextElem)
{
    
    int temp = LocateElem(currentElem);
    if (temp == -1)
    {
        return false;
    }
    else
    {
        if (temp == m_iLength - 1)
        {
            return false;
        }
        else
        {
            *nextElem = m_pList[temp + 1];
            return true;
        }
    }

}
/*******************************************************************************/

//bool List::NextElem(Node *pCurrentNode, Node *pNextNode)
//{
//    Node *currentNode = m_pList;
//
//    while (currentNode->next != NULL)
//    {
//        currentNode = currentNode->next;
//        if (currentNode->data == pCurrentNode->data)
//        {
//            if (currentNode->next == NULL)
//                return false;
//            {
//                return false;
//            }
//            pNextNode->data = currentNode->next->data;
//            return true;
//        }
//    }
//}
/*******************************************************************************/
//遍历整个线性表
void List::ListTraverse()
{
    for (int i = 0; i < m_iLength; i++)
    {
        cout << m_pList[i] << endl;
    }
}
/*******************************************************************************/
// 遍历单链表
//void List::ListTraverse()
//{
//    Node *currentNode = m_pList;
//    while (currentNode->next != NULL)
//    {
//        currentNode = currentNode->next;
//        currentNode->printNode();
//
//    }
//}
/*******************************************************************************/
//在指定位置插入元素
bool List::ListInsert(int i, int * e)
{
    if (i < 0 || i > m_iLength)
    {
        return false;
    }
    for (int k = m_iLength; k >= i; k--)
    {
        m_pList[k + 1] = m_pList[k];

    }
    m_pList[i] = *e;
    m_iLength++;
    return true;
}
/*******************************************************************************/
//在链表任意位置插入结点
//bool List::ListInsert(int i, Node *pNode)
//{
//    if (i < 0 || i > m_iLength)
//    {
//        return false;
//    }
//    Node *currentNode = m_pList;//找到头结点并保存到currentNode
//    for (int k = 0; k < i; k++)
//    {
//        currentNode = currentNode->next;
//    }
//    Node *newNode = new Node;
//    if (newNode == NULL)
//    {
//        return false;
//    }
//    newNode->data = pNode->data;
//    newNode->next = currentNode->next;
//    currentNode->next = newNode;
//    return true;
//}
/*******************************************************************************/
//删除指定位置的元素
bool List::ListDelete(int i, int * e)
{
    if (i < 0 || i >= m_iLength)
    {
        return false;
    }
    *e = m_pList[i];
    for (int k = i + 1; k < m_iLength; k++)
    {
        m_pList[k - 1] = m_pList[k];
    }
    m_iLength--;
    return true;
}
/********************************************************************************/
//删除任意位置的结点
//bool List::ListDelete(int i, Node *pNode)
//{
//    if (i < 0 || i >= m_iLength)
//    {
//        return false;
//    }
//    Node *currentNode = m_pList;
//    Node *currentNodeBefore = NULL;
//    for (int k = 0; k <= i; k++)
//    {
//        currentNodeBefore = currentNode;
//        currentNode = currentNode->next;
//    }
//
//    currentNodeBefore->next = currentNode->next;
//    pNode->data = currentNode->data;
//    delete currentNode;
//    currentNode = NULL;
//    m_iLength--;
//    return true;
//}
/********************************************************************************/


/********************************************************************************/
//在链表的头部插入结点
//bool List::ListInsertHead(Node *pNode)
//{
//    Node *temp = m_pList->next;
//    Node *newNode = new Node;//定义一个新的结点，从堆中申请内存
//    if (newNode == NULL)
//    {
//        return false;
//    }
//    newNode->data = pNode->data;
//    m_pList->next = newNode;//将新结点的指针域指向m_pList->next
//    newNode->next = temp;
//  m_iLength++;
//    return true;
//}
/********************************************************************************/

/********************************************************************************/
//在链表的尾部插入结点
//bool List::ListInsertTail(Node *pNode)
//{
//    Node *currentNode = m_pList;
//    while (currentNode->next != NULL)
//    {
//        currentNode = currentNode->next;
//    }
//
//    Node *newNode = new Node;
//    if (newNode == NULL)
//    {
//        return false;
//    }
//    newNode->data = pNode->data;
//    newNode->next = NULL;
//    currentNode->next = newNode;
//  m_iLength++;
//    return true;
//}
/*******************************************************************************/

结点的头文件Node.h和结点的cpp文件Node.cpp，可以自己补充想要实现的方法

下面是测试代码demo.cpp

#include "stdafx.h"
#include "stdio.h"
#include "stdlib.h"
#include "List.h"
#include <iostream>

using namespace std;
/***************************************************************************************/
/*
    线性表--顺序表

    3 5 7 2 9 1 8

    前驱  后继
    C语言类型的写法
    BOOL InitList(List **list);//创建线性表
    void DestroyList(List *list);//销毁线性表
    void ClearList(List *list);//清空线性表
    BOOL ListEmpty(List *list);//判断线性表是否为空
    int ListLength(List *list);//获取线性表长度
    BOOL GetElem(List *list, int i, Elem *e);//获取指定元素
    int LocateElem(List *list, Elem *e);//寻找第一个满足e的数据元素的位序
    BOOL PriorElem(List *list, Elem *currentElem, Elem *preElem);//获取指定元素的前驱
    BOOL NextElem(List *list, Elem *currentElem, Elem *preElem);//获取指定元素的后继
    BOOL ListInsert(List *list, int i, Elem *e);//在第i个位置插入元素
    BOOL ListDelete(List *list, int i, Elem *e);//删除第i个位置的元素
    void ListTraverse(List *list);//遍历线性表

*/
/********************************************************************************************/

int main(void)
{
    //3 5 7 2 9 1 8
    int e1 = 3;
    int e2 = 5;
    int e3 = 7;
    int e4 = 2;
    int e5 = 9;
    int e6 = 1;
    int e7 = 8;
    int temp = 0;
    List *list1 = new List(10);

    cout << "length:" << list1->ListLength() << endl;
    list1->ListInsert(0, &e1);
    cout << "length:" << list1->ListLength() << endl;
    list1->ListInsert(1, &e2);
    cout << "length:" << list1->ListLength() << endl;
    list1->ListInsert(2, &e3);
    list1->ListInsert(3, &e4);
    list1->ListInsert(4, &e5);
    list1->ListInsert(5, &e6);
    cout << "length:" << list1->ListLength() << endl;
    list1->ListInsert(6, &e7);

    list1->ListTraverse();

    list1->PriorElem(&e4, &temp);
    cout << "temp:" << temp << endl;
    list1->NextElem(&e4, &temp);
    cout << "temp:" << temp << endl;
    list1->GetElem(0, &temp);
    cout << "temp:" << temp << endl;

    list1->LocateElem(&temp);

    list1->ListDelete(0, &temp);

    if (!list1->ListEmpty())
    {
        cout << "not empty " << endl;
    }
    list1->ClearList();
    if (list1->ListEmpty())
    {
        cout << "empty " << endl;
    }
    list1->ListTraverse();

    cout << "#" << temp << endl;

    delete list1;
    return 0;
/*******************************************************************************/
//单链表实现检测
    /*Node node1;
    node1.data = 3;
    Node node2;
    node2.data = 4;
    Node node3;
    node3.data = 5;
    Node node4;
    node4.data = 6;

    Node node5;
    node5.data = 7;

    Node temp;


    List *pList = new List();

    pList->ListInsertHead(&node1);
    pList->ListInsertHead(&node2);
    pList->ListInsertHead(&node3);
    pList->ListInsertHead(&node4);

    pList->ListInsertTail(&node1);
    pList->ListInsertTail(&node2);
    pList->ListInsertTail(&node3);
    pList->ListInsertTail(&node4);

    pList->ListInsert(0,&node5);
    pList->ListDelete(0, &temp);
    pList->GetElem(0,&temp);
    pList->PriorElem(&node4, &temp);
    pList->NextElem(&node4, &temp);
    pList->ListTraverse();

    cout << "temp = " << temp.data << endl;
    delete pList;
    pList = NULL;*/


/*******************************************************************************/
}

 

 

 

 

 

转载于:https://my.oschina.net/ykduan/blog/1502931

chuodun0399
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构学习笔记】二、线性表---链表篇（2）
大家好我叫张同学
01-07 1202
文章目录链表概念:链表分类：单链表的实现： 链表概念: 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 注意: 1.从上图可看出，链式结构在逻辑上是连续的，但是在物理上不一定连续 2.现实中的结点一般都是从堆上申请出来的 3.从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续 链表分类： 单向 双向 带头 不带头 循环 非循环 单向..
数据结构与算法学习笔记分享（C++）
09-15
数据结构与算法学习笔记分享（C++） 数据结构是计算机科学中的一门重要学科，它研究的是数据的组织、存储和管理。数据结构是指数据在计算机中的组织形式，包括逻辑结构和物理结构两方面。逻辑结构是指数据之间的...
慕课网之C++数据结构学习笔记--线性表篇（一，顺序表）
chuodun0399的博客
08-01 166
线性表是最基本、最简单、也是最常用的一种数据结构。 线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储），但是把最后一个数据元...
考研c++数据结构 线性表高分复习笔记
gangangan0001的博客
10-27 625
基础概念 A1-A2-A3-...An 数据元素被一条线串起来 定义 线性表是具有相同特性数据元素的有限序列 相同特性 把同一类事物归类，方便批量处理 有限 表中元素个数为n，n有限大，n可以为0 序列 表中元素排成一排，体现了一对一的逻辑特性(每个元素有且仅有一个前驱和后继) 存储结构 顺序结构 利用数组来实现顺序的存储，使用位置关系来体现逻辑关系 A ...
【数据结构与算法】线性表
weixin_54136758的博客
01-09 907
数据结构(C++)线性表的知识总结
数据结构之线性表实现
Standxwf
04-26 412
/**********线性表 顺序存储方式*********/ #include #define MAXSIZE 20 #define TRUE 1 #define FALSE 0 typedef int Status; typedef int ElemType; typedef struct{ ElemType data[MAXSIZE]; int length; }SqList; /
循环单链表的结构和定义
Fenice
02-26 1140
#include "stdafx.h" #include using namespace std; #include enum Status{OK,ERROR}; typedef int ElemType; typedef struct Lnode { ElemType num; ///结点元素类型为int Lnode *next;
数据结构与算法学习笔记四---双向链表的表示和实现(C++)
我叫柱子哥
04-15 352
记录下双向链表的表示和实现。
【C++数据结构学习笔记---线性表】带头结点的双向循环链表
EnCaL
03-14 1264
【C++数据结构学习笔记---线性表】带头结点的双向循环链表 一个简单的实现例子，只用到了插入函数以及输出函数，初始化26个英文字母。 插入算法的思路：（insert）本算法为结点后插入 1、声明一结点p指向头结点，初始化i从0开始。 2、遍历链表，让指针p向后移动，直至移动到要插入元素的结点，即向后移动k次。 4、让指针q指向p的右边一个结点。 5、在系统中新建一个结点s。 接
笔记-数据结构.docx
08-07
数据结构笔记 数据结构是一门基础学科，它是计算机科学和技术的核心组成部分。数据结构是指在计算机中存储、组织和管理数据的方式，它是计算机程序设计和算法实现的基础。 一、 线性表 线性表是数据结构的基本...
数据结构笔记之线性表(-)：静态链表表示与实现
11-17
在计算机科学领域，数据结构是组织和管理大量数据的关键技术之一。...通过阅读和分析`static_linear_list.cpp`和`static_linear_list.h`，你可以学习到如何在C++中实现这种数据结构，同时掌握静态链表的原理和操作。
数据结构----清华殷人昆数据结构笔记（C＋＋版，ppt格式）
04-02
数据结构是计算机科学中至关重要的一个领域，它研究如何在计算机中组织和管理数据，以提高...通过学习这些笔记，不仅可以掌握数据结构的基本概念，还能深入了解C++实现细节，对于提升编程能力和算法设计能力大有裨益。
数据结构笔记精华.docx
07-06
"数据结构笔记精华" 本资源是一个详细的数据结构笔记，涵盖了数据结构的基本概念、算法和实现方法。笔记共分为多章节，每章节都对应着特定的...它可以作为数据结构课程的学习笔记，也可以作为考研备考的重要参考资料。
双端队列Deque
Jak的博客
08-09 789
Deque作为一个灵活且功能强大的数据结构，因其双端操作的特性，适用于广泛的场景。它的高效性能使得它在实际开发中被广泛应用，是许多算法和数据结构实现的基础。下面是基于LinkedList实现的Deque的示例，展示如何将LinkedList用作栈（LIFO）和队列（FIFO）。
【数据结构与算法】二叉树
qq_74047911的博客
08-10 986
当找到要删除的节点后,如果要删除节点的左边为空,就将姚删除节点的右边节点连接到要删除节点的位置,同理姚删除节点的右边为空的时候,就将要删除节点的左边连接到要删除的节点.我们这里选择找右子树的最小值,先将要删除节点的右孩子找到,然后根据二叉搜索树的性质,我们需要一直找其左子节点,能够找到最小的值.如果要插入的数据小于根节点的数据,就往左边遍历,否则右边遍历,直到tmp为空,那么parent就是要删除节点的父节点.如果当前节点不为空,同时当前节点的数据不是我们要删除的数据,那么我们一直遍历.
【经验分享】数据结构——哈希查找冲突处理方法（开放地址法-线性探测、平方探测、双散列探测、再散列，分离链接法）
VLOKL的博客
08-11 794
【经验分享】数据结构——哈希查找冲突处理方法（开放地址法-线性探测、平方探测、双散列探测、再散列，分离链接法）
集合（1）
最新发布
supercool7的博客
08-12 455
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
AcWing.算法提高课-第二章 搜索
m0_69379426的博客
08-07 740
ACwing算法提高课-搜索
C++实现线性表：数据结构电子笔记2
这份C++版的线性表电子笔记详细介绍了线性表的基本概念、抽象数据类型以及顺序存储结构的实现，为学习和理解数据结构提供了坚实的基础。对于初学者来说，这是一个很好的参考资料，可以帮助他们理解和掌握线性表的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值