数据结构之链表-链表实现及常用操作(C++篇)

最新推荐文章于 2024-03-06 00:44:51 发布
最新推荐文章于 2024-03-06 00:44:51 发布
阅读量159 收藏
点赞数
分类专栏： c++

来源：https://www.cnblogs.com/byonecry/p/4458821.html

0.摘要

  • 定义
  • 插入节点（单向链表）
  • 删除节点（单向链表）
  • 反向遍历链表
  • 找出中间节点
  • 找出倒数第k个节点
  • 翻转链表
  • 判断两个链表是否相交，并返回相交点
  • 判断链表是否有环路，获取连接点，计算环的长度
  • 二叉树和双向链表转化

1.定义

1.1单向链表

单向链表的节点包括：

  1. 数据域：用于存储数据元素的值。

  2. 指针域（链域）：用于存储下一个结点地址或者说指向其直接后继结点的指针。

     struct Node{
     int value;
     Node * next;
 };

1.2双向链表

双向链表的节点包括：

  1. 数据域：用于存储数据元素的值。
  2. 左指针域（左链域）：用于存储上一个结点地址或者说指向其直接前继结点的指针。

  3. 右指针域（右链域）：用于存储下一个结点地址或者说指向其直接后继结点的指针。

     struct DNode{
     int value;
     DNode * left;
     DNode * right;
 };

2.常用操作例题

2.1插入节点（单向链表）

//p节点后插入值为i的节点
void insertNode(Node *p, int i){
    Node* node = new Node;
    node->value = i;
    node->next = p->next;
    p->next = node;
}

2.2删除节点（单向链表）

当需要删除一个节点p时，只需要将p的前一个节点的next赋为p->next,但是由于是单向的，只知道p，无法知道p前一个节点，所以需要转换思路。将p下一个的节点覆盖到p节点即可，这样就等效于将p删除了。

void deleteNode(Node *p){
    p->value = p->next->value;
    p->next = p->next->next;
}

2.3反向遍历链表

法一：反向遍历链表就类似于事先遍历的节点后输出，即“先进后出”，那么可以将链表遍历存放于栈中，其后遍历栈依次弹出栈节点，达到反向遍历效果。

//1.stack
void printLinkedListReversinglyByStack(Node *head){
    stack<Node* > nodesStack;
    Node* pNode = head;
    //遍历链表
    while (pNode != NULL) {
        nodesStack.push(pNode);
        pNode = pNode->next;
    }
    while (!nodesStack.empty()) {
        pNode=nodesStack.top();
        printf("%d\t", pNode->value);
        nodesStack.pop();
    }
}
//2.递归
void printLinkedListReversinglyRecursively(Node *head){
    if (head!=NULL) {
        if (head->next!=NULL) {
            printLinkedListReversinglyRecursively(head->next);
        }
        printf("%d\t", head->value);
    }
}

2.4找出中间节点

用slow和fast指针标记，slow每次走一步，fast每次走两步，当fast到尾节点时，slow就相当于总长度的一半，即在中间节点。

//找出中间节点
Node* findMidNode(Node* head){
    Node* slow = head;
    Node* fast = head;
    while (fast->next != 0&&fast->next->next!=0) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

2.5找出倒数第k个节点

用slow和fast指针标记,fast指针事先走k步，然后slow和fast同时走，当fast到达末节点时，slow在fast的前k个节点，即为倒数第k个节点。

//找出倒数第k个节点
Node* findKNode(Node* head,int k){
    Node *temp1 = head;
    Node *temp2 = head;
    while (k-->0) {
        if(temp2 == NULL){
            return NULL;
        }
        temp2 =temp2->next;
    }
    while (temp2->next != NULL&&temp2->next->next!=NULL) {
        temp1 = temp1->next;
        temp2 = temp2->next->next;
    }
    return temp1;
}

2.6翻转链表

题意即为将链表反过来，即，原本为p1-p2-p3翻转为p3-p2-p1。读者需自行画图体会指针操作。

//翻转链表
Node * reverseLinkedList(Node* head,int k){
    Node *reversedHead = NULL;
    Node *pNode = head;
    Node *pre = NULL;
    while (pNode!=NULL) {
        if (pNode->next==NULL) {
            reversedHead = pNode;
        }
        Node* nxt = pNode->next;
        pNode->next = pre;
        pre=pNode;
        pNode=nxt;
    }
    return reversedHead;
}

2.7判断两个链表是否相交，并返回相交点

如果两个链表相交，其形状必为y形，而不可以能为x形，即两条链表必有相同的尾节点。首先，计算得到两个链表的长度:m,n，求得两个链表长度之差distance＝|m-n|，让较长得那个链表事先走distance步，这样，若是链表相交得话，二者指针必相撞，相撞点即为相交点。

Node* findCrosspoint(Node* l1, Node* l2){
    int m = getLinkedListLength(l1);
    int n = getLinkedListLength(l2);
    int distance=0;
    Node *temp1= l1;
    Node *temp2= l2;
    if (m>n) {
        distance = m - n;
        while (distance>0) {
            distance--;
            temp1=temp1->next;
        }
    } else{
        distance = n - m;
        while (distance>0) {
            distance--;
            temp2 = temp2->next;
        }
    }
    while(temp1!=temp2&&temp1->next!=NULL&&temp2->next!=NULL){
        temp1=temp1->next;
        temp2=temp2->next;
    }
    if(temp1 == temp2){
        return temp1;
    }
    return 0;
}

2.8判断链表是否有环路，获取连接点，计算环的长度

此题很有意思，具体详细请参考：http://www.cnblogs.com/xudong-bupt/p/3667729.html
判断是否含有环：slow和fast，slow指针每次走一步，fast指针每次走两步，若是链表有环，fast必能追上slow（相撞），若fast走到NULL，则不含有环。

//判断是否含有环
bool containLoop(Node* head){
    if (head==NULL) {
        return false;
    }
    Node* slow = head;
    Node* fast = head;
    while (slow!=fast&&fast->next!=NULL) {
        slow = slow->next;
        fast = fast->next->next;
    }
    if (fast==NULL) {
        return false;
    }
    return true;
}

判断环的长度：在相撞点处，slow和fast继续走，当再次相撞时，slow走了length步，fast走了2*length步，length即为环得长度。

//获得环的长度
int getLoopLength(Node* head){
    if (head==NULL) {
        return 0;
    }
    Node* slow = head;
    Node* fast = head;
    while (slow!=fast&&fast->next!=NULL) {
        slow = slow->next;
        fast = fast->next->next;
    }
    if (fast==NULL) {
        return 0;
    }
    //slow和fast首次相遇后，slow和fast继续走
    //再次相遇时，即slow走了一圈，fast走了两圈
    int length = 0;
    while (slow!=fast) {
        length++;
        slow = slow->next;
        fast = fast->next->next;
    }
    return length;
}

环得连接点：slow和fast第一次碰撞点到环的连接点的距离=头指针到环的连接点的距离，此式可以证明，详见上面链接。

//获得环的连接点
Node* getJoinpoit(Node* head){
    if (head==NULL) {
        return NULL;
    }
    Node* slow = head;
    Node* fast = head;
    while (slow!=fast&&fast->next!=NULL) {
        slow = slow->next;
        fast = fast->next->next;
    }
    if (fast==NULL) {
        return NULL;
    }
    Node* fromhead = head;
    Node* fromcrashpoint = slow;

    while (fromcrashpoint!=fromhead) {
        fromhead = fromhead->next;
        fromcrashpoint = fromcrashpoint->next;
    }
    return fromhead;
}

2.9二叉树和双向链表转化

二叉树和双向链表转化指的是，二叉树节点结构和双向链表的结构想类似，只不过二叉树节点的节点存储的两个指针为左右子数，而双向链表存储的是前后节点。题意为将二叉树的某种遍历转化为链表存储。此题很明显该用递归，读者可以画图体会一下指针变化。

二叉树节点或双向链表节点定义：

struct BinaryTreeNode{
    int value;
    BinaryTreeNode* left;
    BinaryTreeNode* right;
};

二叉树的中序遍历转换为双向链表

BinaryTreeNode* convertNode(BinaryTreeNode* pNode, BinaryTreeNode** pLastNodeInLast){
    if (pNode == NULL) {
        return NULL;
    }
    BinaryTreeNode *pCurrent = pNode;
    if (pCurrent->left != NULL) {
        convertNode(pCurrent->left, pLastNodeInLast);
    }

    pCurrent->left = *pLastNodeInLast;
    if (*pLastNodeInLast != NULL) {
        (*pLastNodeInLast)->right=pCurrent;
    }

    *pLastNodeInLast = pCurrent;
    if (pCurrent->right != NULL) {
        convertNode(pCurrent->right, pLastNodeInLast);
    }
    return NULL;
}

BinaryTreeNode* convertBTToDLL(BinaryTreeNode* root){
    BinaryTreeNode *pLastNodeInLast = NULL;
    convertNode(root, &pLastNodeInLast);
    BinaryTreeNode *pHeadOfList = pLastNodeInLast;
    while (pHeadOfList != NULL && pHeadOfList->left != NULL) {
        pHeadOfList = pHeadOfList->left;
    }
    return pHeadOfList;
}
修炼到救赎
关注
专栏目录
数据结构C++链表
03-04
基于C++的数据结构单链表，带主程序可运行，使用头文件可直接编程。
链表-使用C++链表实现的多文件目录管理系统.zip
03-13
通过理解和实现这个系统，开发者可以加深对链表和C++编程的理解，同时提升在数据结构和算法方面的技能。在实际工作中，这样的数据结构经常用于构建复杂的数据管理系统，如文件系统、数据库索引等。
链表C++实现
热门推荐
好记性不如烂笔头的专栏
03-03 5万+
节点定义：typedef struct node { int data; struct node *next; }NODE;类定义class LinkList { private: NODE *head; public: LinkList() { head = NULL; } ~LinkList(); bool clearSqList(); b
数据结构——链表（c++）
C.
06-18 1107
数据结构——链表（c++）
C++数据结构-链表
weixin_46465981的博客
06-08 181
C++数据结构-链表
数据结构算法集---C++语言实现.rar_queue stack_堆栈 栈_数据结构 队列_链表_队列
07-15
在这个C++实现的数据结构算法集中，主要涉及了几个核心概念：队列、堆栈和链表，这些都是数据组织和操作的基本工具。 首先，让我们来看看堆栈（Stack）。堆栈是一种后进先出（LIFO）的数据结构，它的操作类似于日常...
C++ 数据结构链表的实现代码
08-31
链表是一种重要的数据结构，它在计算机科学中广泛用于存储和操作动态集合。与数组不同，链表的元素不是在连续的内存位置上，而是通过指针连接。本篇文章将详细探讨C++中链表的实现，特别是如何通过类来表示链表。 ...
计算机科学：C++中链表数据结构详解及其基本操作实现
最新发布
11-02
内容概要：本文全面介绍了链表这一重要的非线性数据结构，在内存中的非连续特点和优势，如支持高效的动态内存分配以及便捷的数据元素插入和删除。此外还详尽解析了用C++语言分别针对单链表、双链表、循环链表这三种...
数据结构实验报告-利用链表实现简易学生信息管理系统(C语言)
04-07
3. **实践C语言编程技能**：通过实际编写代码来增强学生的编程能力，特别是处理链表时的数据结构设计与算法实现。 4. **熟悉软件开发流程**：了解从需求分析到代码实现再到测试调试的整个过程。 #### 实验环境 - **...
数据结构——链表（C++）
Flechazo41521的博客
03-06 989
链表是一种基本的线性数据结构，它由一系列节点组成，每个节点包含数据和对下一个节点的引用。链表的每个节点都有一个存储数据的字段和一个指向下一个节点的指针。链表的起始节点称为头节点，指向第一个数据节点的指针称为头指针。链表的最后一个节点没有指向其他节点的指针，称为尾节点。链表的主要优点在于它的动态特性和灵活性。与数组不同，链表不需要预先分配固定大小的存储空间，它可以在运行时根据需要动态地添加或删除节点。这使得链表在处理动态变化的场景中非常有用。
C++ 数据结构——链表
御承扬的博客
07-02 225
C++ 数据结构——链表 代码如下： // 数据结构2-链表.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include "pch.h" #include <iostream> using namespace std; typedef struct LNode //定义一个节点 { int data; //节点中的数据域 LNode...
链表的C++实现
hustyangju的足迹
05-13 1326
有的时候，处于内存中的数据并不是连续的。那么这时候，我们就需要在数据结构中添加一个属性，这个属性会记录下面一个数据的地址。有了这个地址之后，所有的数据就像一条链子一样串起来了，那么这个地址属性就起到了穿线连结的作用。 链表有：单链表，双链表，单循环链表，双循环链表。 理解单链表，其他几种也就大同小异。     相比较普通的线性结构，链表结构的优势是什么呢？我们可以总结一下：     （1）
链表实现C++
weixin_43672168的博客
03-13 398
C++实现链表
链表的实现(C++)
Shang1031
12-17 244
复习数据结构时把6年前自己读代码写的分析再读一遍，收获颇多 源码内容：建立一个链表并且对其进行“插入值”和“删除值” · 链表的基本分析 · //链表的默认大小 const int Capacity = 1024; template <typename T> class arrayList { public: //建立链表，定义初始化 arrayList()...
C++ 链表实现
快乐小半半的博客
01-09 278
Node.h #pragma once class Node { public: int data; Node *next; }; List.h #pragma once #include &amp;quot;Node.h&amp;quot; #ifndef LIST_H #define LIST_H class List { pub...
链表c++实现
xuqi7
10-19 486
昨天把链表实现代码写到  写链表收获 里了，今天看了看居然没有，不知道是没保存还是怎么了，没办法，今天就把自己的代码再粘一遍吧 对了，是用vs2013编辑的 SLNode.cpp #include struct SLNode{     int data;     SLNode *next;     SLNode(SLNode* nextNode = NULL){ 
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值