数据结构——链表（C++代码实现）

最新推荐文章于 2024-09-25 15:54:35 发布
最新推荐文章于 2024-09-25 15:54:35 发布
阅读量2.7k 收藏 27
点赞数 2
文章标签： c++ 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47965537/article/details/109577857
版权

链表的介绍

链表是由元素之间互相依赖，串联而成的。链表存储的每一个元素，都是由数据域和指针域两部分组成，称为链表的一个结点。数据域存储数据，指针域存储下一结点的地址。

链表的特点

链表的内存空间是不连续的，这导致链表无法做随机访问的操作，获取数据只能从头往后遍历；数组与链表相比，不是查询快，而是数组可以随机访问，很多人会把查询和随机访问混淆了，查询是查找存储的特定数据，随机访问是访问指定位置的内容。

链表的实现

下面来用C++代码实现链表的构建、插入、遍历、删除功能。

1.单链表

#include <iostream>
using std::cin;
using std::cout;
using std::endl;

template <typename Type> class Node {//首先定义链表的结点类
public:
    Type data;//存储数据的变量
    Node<Type> *next;//存储下一结点的地址的指针
    Node(const Type &_data) {
        data = _data;
        next = NULL;
    }
};
template <typename Type> class LinkedList {//定义链表类
private:
    Node<Type> *head;//存储链表头结点地址的指针
public:
    LinkedList() {//构建一个新链表对象
        head = NULL;//新链表没有结点，head指向空地址
    }
    ~LinkedList() {
        Node<Type> *current_node = head;
        while (current_node != NULL) {
            Node<Type> *delete_node = current_node;
            current_node = current_node->next;
            delete delete_node;
        }
    }
    void insert(Node<Type> *node, int index) {
        if (head == NULL) {//插入元素前判断链表是否为空
            if (index != 0) {//链表为空，且插入位置不是头结点位置时，不执行插入操作
                return ;
            }
            head = node;//链表为空，且插入位置为头结点位置时，head指向新结点
            return ;
        }
        if (index == 0) {//链表不为空，且插入位置为头结点位置时
            node->next = head;//新结点指向目前的头结点
            head = node;//更新头结点，head指针指向新结点
            return ;
        }
        //一般的插入操作
        Node<Type> *current_node = head;//定义当前结点指针
        int count = 0;//记录经过的结点数
        while ((current_node->next != NULL) && (count < index - 1)) {//循环找到插入位置的前一个结点
            current_node = current_node->next;
            count++;
        }
        if (count == index - 1) {//判断插入的位置是否超出链表长度，没有超出才执行插入操作
            node->next = current_node->next;//新结点指向当前结点的下一个结点
            current_node->next = node;//当前结点指向新结点
            return ;
        }
        return ;
    }
    void output() {
        if (head == NULL) {//链表为空，不执行遍历操作
            return;
        }
        Node<Type> *current_node = head;//定义当前结点指针
        while (current_node->next != NULL) {//当前结点没有指向空地址，则不断向后遍历
            cout << current_node->data << " ";
            current_node = current_node->next;
        }
        cout << current_node->data << endl;
    }
    void delete_node(int index) {
        if (head == NULL) {//链表为空，不执行删除操作
            return ;
        }
        Node<Type> *current_node = head;//定义当前结点指针
        if (index == 0) {//当删除头结点时
            head = head->next;//head指向头结点的下一个结点，完成更新头结点
            delete current_node;//删除旧头结点的地址空间
            return;
        }
        //一般的删除操作
        int count = 0;//记录经过的结点数
        while ((current_node->next != NULL) && (count < index - 1)) {//循环找到删除位置的前一个结点
            current_node = current_node->next;
            count++;
        }
        if ((count == index - 1) && (current_node->next != NULL)) {//删除的位置不超过链表长度
            Node<Type> *delete_node = current_node->next;//定义指针指向删除的结点
            current_node->next = delete_node->next;//当前结点指向删除结点的下一个结点
            delete delete_node;//删除结点的地址空间
            return;
        }
        return;
    }
};

2.循环链表

循环链表需要注意的是，head指针指向的不再是头结点，而是指向尾结点；尾结点不指向空地址，而是指向头结点。

#include<iostream>
using std::cin;
using std::cout;
using std::endl;
template <typename Type> class Node {
public:
    Type data;
    Node<Type> *next;
    Node(const Type &_data) {
        data = _data;
        next = NULL;
    }
};
template <typename Type> class CircularLinkedList {
private:
    Node<Type> *head;
public:
    LinkedList() {
        head = NULL;
    }
    ~LinkedList() {
        if (head == NULL) {
            return;
        }
        Node<Type> *current_node = head->next;//定义指针指向第一个结点
        head->next = NULL;//尾结点指向空，打断循环
        while (current_node != NULL) {
            Node<Type> *delete_node = current_node;
            current_node = current_node->next;
            delete delete_node;
        }
    }
    void insert(Node<Type> *node, int index) {
        if (head == NULL) {
            if (index != 0) {
                return;
            }
            head = node;
            head->next = head;
            return;
        }
        if (index == 0) {
            node->next = head->next;//head->next才是头结点
            head->next = node;
            return;
        }
        Node<Type> *current_node = head->next;
        int count = 0;
        while ((current_node != head) && (count < index - 1)) {//判断条件改变
            current_node = current_node->next;
            count++;
        }
        if (count == index - 1) {
            node->next = current_node->next;
            current_node->next = node;
            if (node == head->next) {//增加判断是否插入到尾结点之后了，是则更新尾结点
	            head = node;
	        }
        }
    }
    void output() {
        if (head == NULL) {
            return;
        }
        Node<Type> *current_node = head->next;
        while (current_node != head) {//尾结点代替NULL地址
            cout << current_node->data << " ";
            current_node = current_node->next;
        }
        cout << current_node->data << endl;
    }
    void delete_node(int index) {
    	if (head == NULL) {
    		return;
    	}
        Node<Type> *current_node = head->next;
        if (index == 0) {
            head->next = current_node->next;
            delete current_node;
            return;
        }

        int count = 0;
        while ((current_node != head) && (count < index - 1)) {//判断条件与插入操作一致
            current_node = current_node->next;
            count++;
        }
        if ((count == index - 1) && (current_node != head)) {//判断条件改变
            Node<Type> *delete_node = current_node->next;
            current_node->next = delete_node->next;
            if (delete_node == head) {//判断是否删除尾结点了，是则更新尾结点
            	head = current_node;
            }
            delete delete_node;
            return;
        }
        return;
    }
};

3.双向循环链表

双向循环链表比单向循环链表存储的元素的指针域多了一个向前指的指针。

#include<iostream>
using std::cin;
using std::cout;
using std::endl;
template <typename Type> class Node {
public:
    Type data;
    Node<Type> *next;
    Node<Type> *prior;//结点的指针域增加向前的指针
    Node(const Type &_data) {
        data = _data;
        next = NULL;
        prior = NULL;
    }
};
template <typename Type> class DoubleLinkedList {
private:
    Node<Type> *head;
public:
    LinkedList() {
        head = NULL;
    }
    ~LinkedList() {
        if (head == NULL) {
            return;
        }
        Node<Type> *current_node = head->next;
        head->next = NULL;
        while (current_node != NULL) {
            Node<Type> *delete_node = current_node;
            current_node = current_node->next;
            delete delete_node;
        }
    }
    void insert(Node<Type> *node, int index) {
        if (head == NULL) {
            if (index != 0) {
                return;
            }
            head = node;
            head->next = head;
            head->prior = head;//增加前指向
            return;
        }
        if (index == 0) {
            node->next = head->next;
            node->prior = head;//新结点前指向尾结点
            head->next->prior = node;//头结点前指向新结点
            head->next = node;
            return;
        }
        Node<Type> *current_node = head->next;
        int count = 0;
        while ((current_node != head) && (count < index - 1)) {
            current_node = current_node->next;
            count++;
        }
        if (count == index - 1) {
            node->next = current_node->next;
            node->prior = current_node;//新结点前指向当前结点
            current_node->next->prior = node;//当前结点的下一结点前指向新结点
            current_node->next = node;
            if (node == head->next) {
            	head = node;
            }
            return;
        }
        return;
    }
    void output(int method = 0) {
        Node<Type> *current_node = head->next;
        if (method == 0) {//默认从前向后遍历
	        while(current_node != head) {
	        	cout << current_node->data << " ";
	        	current_node = current_node->next;
	        }
	        cout << current_node->data << endl;
	        return;
	    } else {//选择从后向前遍历
	    	while(current_node != head) {
	        	cout << current_node->data << " ";
	        	current_node = current_node->prior;
	        }
	        cout << current_node->data << endl;
	        return;
	    }
    }
    void delete_node(int index) {
    	if (head == NULL) {
    		return;
    	}
        Node<Type> *current_node = head->next;
        if (index == 0) {
            head->next = current_node->next;
            current_node->next->prior = head;//头结点的下一结点前指向尾结点
            delete current_node;
            return;
        }
        int count = 0;
        while ((current_node != head) && (count < index - 1)) {
            current_node = current_node->next;
            count++;
        }
        if ((count == index - 1) && (current_node != head)) {
            Node<Type> *delete_node = current_node->next;
            current_node->next = delete_node->next;
            delete_node->next->prior = current_node;//删除结点的下一结点前指向当前结点
            if (delete_node == head) {
            	head = current_node;
            }
            delete delete_node;
            return;
        }
        return;
    }
};
雨景_努力学习
关注
c++链表实现
weixin_46065039的博客
05-11 554
#include<iostream> using namespace std; template<typename T> struct Node { T Value; Node<T>* NextNode; }; template<class T> class LinkedList { public: Node<T>* List; //创建链表 LinkedList(unsigned int Coun...
数据结构与算法详解——链表篇（附c++实现代码）
JMasker的博客
05-01 3258
链表详解及完整实现
单链表
SCUT 段九鼎(C/C++学生)
08-01 387
C/C++中的链表数据结构实战
最新发布
weixin_35762258的博客
09-25 987
本文还有配套的精品资源，点击获取 简介：链表是计算机科学中的基础数据结构，尤其在C/C++编程中。它通过节点和指针链接数据，与数组不同，不依赖于连续内存地址。本教程涵盖链表的基本概念、创建过程、基本操作（插入、删除、遍历、查找），以及双向链表和循环链表的介绍。掌握链表的实现是深入学习数据结构和算法的基础。 1. 链表基本概念 链表是一种常见的基础数据结构，它...
【C++】链表实现
清风微醺的博客
01-28 863
单链表、头指针、头结点、首元节点 #include<iostream> using namespace std; typedef struct Node { int element; Node * next; }*PNODE; PNODE creat_list(); void traverse_list(PNODE pHead); int main() { PNODE pHead = creat_list(); traverse_list(pHead); return 0; }
C++实现链表
cnds123的专栏
02-21 5673
C++实现链表。本文介绍两种实现方法：一、使用指针自定义实现；二、使用C++ STL（标准模板库）中的list容器实现。
链表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++实现》（第二版）课本源代码
10-30
总之，《数据结构——C++实现》（第二版）的源代码提供了丰富的学习资源，不仅可以帮助初学者建立坚实的数据结构基础，也是经验丰富的开发者巩固和扩展知识的良好参考资料。通过实践和调试这些代码，你将能够更好地...
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
数据结构——链表的实现
12-29
在这个数据结构——链表的实现中，我们将深入探讨如何用C++来创建一个链表类，并实现搜索、删除、插入和查找等基本操作。 首先，链表的基本思想是使用节点（或称为元素）来存储数据，每个节点包含两部分：数据域和...
《数据结构——C++实现》（第二版）课本源代码.zip
06-16
《数据结构——C++实现》（第二版）是一本深入讲解这一主题的教材，提供了源代码供读者实践和学习。 本书的C++实现部分，旨在帮助读者掌握各种基本和高级数据结构，如数组、链表、栈、队列、树（二叉树、平衡树）、...
c++实现链表完整代码
11-07
c++实现链表完整代码，可直接使用，经测试可在c++环境下正常编译运行。
C++实现的一个简单链表
05-20
单链表的实现。以前都是用C语言实现的，今天用C++练一练手，做出来了。
链表：C++实现
Hamdh的博客
11-20 767
链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。相比于数组，链表具有动态性和灵活性，可以高效地进行插入和删除操作，但是查找操作的时间复杂度较高。在C++中，我们可以通过定义一个节点结构体和一个链表类来实现链表。
C++ 链表
LYSM
02-05 417
代码： // Test_Console_3.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include <iostream> #include<cstdlib> using namespace std; // 链表结构体 typedef struct listpoint { int data; // 数据 li...
链表的C++代码
Besion王
09-23 909
1.单链表反转  2.找出单链表的倒数第4个元素 3.找出单链表的中间元素 4.删除无头单链表的一个节点 5.两个不交叉的有序链表的合并  6.有个二级单链表，其中每个元素都含有一个指向一个单链表的指针。写程序把这个二级链表称一级单链表。  7.单链表交换任意两个元素（不包括表头）  8.判断单链表是否有环？如何找到环的“起始”点？如何知道环的长度？ 9.判断两个单链表是否相交  10.
C++ 实现链表
专业^团队的博客
06-22 1256
一.C++实现链表 二.Java实现链表 结构图如下：
C++ 数据结构链表的实现代码
HuangQinJian
01-18 2万+
C++ 链表之前一直没怎么在意C++中的链表，但是突然一下子让自己写，就老是出错。没办法，决定好好恶补一下该方面的知识，也为今后的数据结构大下个良好的基础，于是我总结出以下几点，有些地方可能不正确，还望大家不吝赐教，旨在共同进步。
链表（c++)
朱家小旺
10-10 379
一、单链表实现： #include<iostream> #include<vector> using namespace std; class intSLLnode { public: intSLLnode(){ next = 0; } intSLLnode(int i,intSLLnode *in = 0){info = i;next = in;} //private: int info; //用于存储信息 intSLLn
数据结构与算法单项链表代码C++
10-17
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。单向链表的实现可以使用C++语言来完成。以下是一个简单的单向链表的代码示例： ```c++ #include <iostream> using namespace std; // 定义链表节点结构体 struct ListNode { int val; ListNode* next; ListNode(int x) : val(x), next(NULL) {} }; // 定义链表类 class LinkedList { public: LinkedList() { head = NULL; } // 在链表头部插入节点 void insertAtHead(int val) { ListNode* newNode = new ListNode(val); newNode->next = head; head = newNode; } // 在链表尾部插入节点 void insertAtTail(int val) { ListNode* newNode = new ListNode(val); if (head == NULL) { head = newNode; } else { ListNode* cur = head; while (cur->next != NULL) { cur = cur->next; } cur->next = newNode; } } // 删除链表中第一个值为val的节点 void deleteNode(int val) { if (head == NULL) { return; } if (head->val == val) { ListNode* temp = head; head = head->next; delete temp; return; } ListNode* cur = head; while (cur->next != NULL && cur->next->val != val) { cur = cur->next; } if (cur->next != NULL) { ListNode* temp = cur->next; cur->next = cur->next->next; delete temp; } } // 遍历链表并输出每个节点的值 void printList() { ListNode* cur = head; while (cur != NULL) { cout << cur->val << " "; cur = cur->next; } cout << endl; } private: ListNode* head; }; // 测试代码 int main() { LinkedList list; list.insertAtHead(1); list.insertAtHead(2); list.insertAtTail(3); list.insertAtTail(4); list.printList(); list.deleteNode(2); list.printList(); return 0; } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值