数据结构——单链表

最新推荐文章于 2024-09-24 13:20:07 发布
最新推荐文章于 2024-09-24 13:20:07 发布
阅读量135 收藏
点赞数 3
文章标签： 数据结构 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75686636/article/details/141233823
版权

代码

#include <iostream>
using namespace std;
#include<time.h>
#include<stdlib.h>

//节点类型
struct Node
{
	Node(int data = 0) 
	{
		this->data_ = data;
		this->next_ = nullptr;
	}
	int data_;
	Node* next_;
};

//单链表代码实现
class Clink
{
public:
	Clink()
	{
		//给 head 初始化指向头结点
		this->head_ = new Node();//调用构造函数
	}
	~Clink()
	{
		//节点的释放
		Node* p = head_;
		while (p != nullptr)
		{
			head_ = head_->next_;
			delete p;
			p = head_;
		}
		head_ = nullptr;
	}
public:
	//尾插  O(n)
	void insertTail(int val)
	{
		//先找到当前链表的末尾节点
		Node* p = head_;//p指向头结点
		while (p->next_ != nullptr)
		{
			p = p->next_;
		}
		//生成新节点
		Node* node = new Node(val);
		//设置原来尾节点的地址域
		p->next_ = node;
	}
	//头插法 O(1)
	void insertHead(int val)
	{
		//生成新节点
		Node* node = new Node(val);
		//新节点设置地址域
		node->next_ = head_->next_;
		//头结点设置地址域 
		head_->next_ = node;
	}
	//链表打印
	void show()
	{
		Node* p = head_->next_;//p指向第一个节点
		while (p != nullptr)
		{
			cout << p->data_ << " ";
			p = p->next_; 
		}
		cout << endl;
	}
	//链表节点的删除——按值一个
	void remove(int val)
	{
		Node* q = head_;
		Node* p = head_->next_;
		while (p != nullptr)
		{
			if (p->data_ == val) 
			{
				q->next_ = p->next_;
				delete p;
				return;
			}
			else
			{
				q = q->next_;
				p = p->next_;
			}
		}
	}
	//链表节点的删除——按值多个
	void removeAll(int val)
	{
		Node* q = head_;
		Node* p = head_->next_;
		while (p != nullptr)
		{
			if (p->data_ == val)
			{
				q->next_ = p->next_;
				delete p;//释放开辟的堆内存			
				p = q->next_;//对指针p进行重置
			}
			else
			{
				p = p->next_;
				q = q->next_;
			}
		}
	}
	//搜索 list  O(n)
	bool find(int val)
	{
		Node* p = head_->next_;
		while (p != nullptr)
		{
			if (p->data_ == val)
			{
				return true;
			}
			p = p->next_;
		}
		return false;
	}

private:
	Node* head_;//指向链表的头结点
	Node* tail_;//指向链表的尾节点
};

int main()
{
	Clink link;
	srand(time(0));
	for (int i = 0; i < 10; i++)
	{
		int val = rand() % 100;
		link.insertTail(val);
		cout << val << " ";
	}
	cout << endl;
	link.insertTail(23);
	link.insertHead(23);
	link.insertHead(23);

	link.show();
	link.removeAll(23);
	link.show();

}

单链表逆序

//单链表逆序
void reverseLink(Clink& link)
{
	Node* head = link.head_;
	Node* p = head->next_;
	if (p == nullptr)
	{
		return;
	}
	head->next_ = nullptr;
	while (p != nullptr)
	{
		Node* q = p->next_;//记录p的下一个元素位置
		
		p->next_ = head->next_;//p的指针域
		head->next_ = p;//头结点的指针域

		p = q;
	}
}

单链表倒数第k个节点

//单链表倒数第k个节点
bool getLastKNode(Clink&link,int k,int&val)
{
	Node* p = link.head_;
	Node* q = link.head_;
	if (k < 1)//有效性判断
	{
		return false;
	}
	for (int i = 0; i < k; i++)
	{
		p = p->next_;//走到第1/2/3/4个节点
		if (p == nullptr)
		{
			return false;
		}
	}
	while (p != nullptr)
	{
		p = p->next_;
		q = q->next_;
	}
	val = q->data_;
	return true;

}
int main()
{
	Clink link;
	srand((unsigned int)time(0));
	for (int i = 0; i < 10; i++)
	{
		int val = rand() % 100;
		link.insertHead(val);
		cout << val << " ";
	}
	cout << endl;
	link.show();

	reverseLink(link);
	link.show();
	
	int val = 0;
	int k = 5;
	if (getLastKNode(link, k, val))
	{
		cout << val << endl;
	}
	else
	{
		cout << "无" << endl;
	}
}

合并两个有序的单链表

//合并两个有序的单链表
void mergeLink(Clink& link1, Clink& link2)
{
    Node* p = link1.head_->next_;
    Node* q = link2.head_->next_;
    Node* last = link1.head_;
    link2.head_ = nullptr;

    while (p != nullptr && q != nullptr)
    {
        if (p->data_ < q->data_)
        {
            last->next_ = p;
            p = p->next_;
        }
        else
        {
            last->next_ = q;
            q = q->next_;
        }
        last = last->next_;
    }
    if (p == nullptr)
    {
        last->next_ = q;
    }
    else if (q == nullptr)
    {
        last->next_ = p;
    }
}

int main()
{
    int arr[] = { 25,37,52,78,88,92,102 };
    int brr[] = { 13,23,40,56,89,100 };
    Clink link1;
    Clink link2;
    for (int v : arr)
    {
        link1.insertTail(v);
    }
    for (int v : brr)
    {
        link2.insertTail(v);
    }
    link1.show();
    link2.show();
    mergeLink(link1, link2);
    link1.show();
};

单链表判断是否有环？求环的入口节点

//单链表判断是否有环？求环的入口节点————快慢指针
bool isLinkHasCircle(Node*head,int &val)
{
    Node* fast = head;
    Node* slow = head;

    while (fast != nullptr && fast->next_ != nullptr)
    {
        slow = slow->next_;
        fast = fast->next_->next_;
        if (slow == fast)
        {
            fast = head;
            while (fast != slow)
            {
                slow = slow->next_;
                fast = fast->next_;
            }
            val = slow->data_;
            //快慢指针再次遇见，链表存在环
            return true;
        }
    }
    return false;
}

int main()
{
    Node head;
    Node n1(25), n2(67), n3(32), n4(18);
    head.next_ = &n1;
    n1.next_ = &n2;
    n2.next_ = &n3;
    n3.next_ = &n4;
    n4.next_ = &n4;
    int val = 0;
    if (isLinkHasCircle(&head, val))
    {
        cout << val << endl;
    }
    else
    {
        cout << "无" << endl;
    }
};

判断两个单链表是否相交，如果相交，返回相交节点的值

//判断两个单链表是否相交，如果相交，返回相交节点的值
bool isLinkHasMerge(Node* head1, Node* head2, int& val)
{
    int len1 = 0, len2 = 0;

    Node* p = head1;
    Node* q = head2;
    while (p != nullptr)
    { 
        len1++;
        p = p->next_;
    }
    while (q != nullptr)
    {
        len2++;
        q = q->next_;
    }

    p = head1, q = head2;
    if (len1 > len2)
    {
        int ans = len1 - len2;
        for (int i = 0; i < ans; i++)
        {
            p = p->next_;
        }
    }
    else
    {
        int ans = len2 - len1;
        for (int i = 0; i < ans; i++)
        {
            q = q->next_;
        }
    }

    while (p != nullptr)
    {
        if (p == q)
        {
            val = p->data_;
            return true;
        }
        p = p->next_;
        q = q->next_;
    }
    return false;
}


int main()
{
    Node head1;
    Node n1(25), n2(67), n3(32), n4(18);
    head1.next_ = &n1;
    n1.next_ = &n2;
    n2.next_ = &n3;
    n3.next_ = &n4;
   
    Node head2;
    Node n5(35);
    head2.next_ = &n5;
    n5.next_ = &n3;
    n3.next_ = &n4;

    int val = 0;
    if (isLinkHasMerge(&head1,&head2,val))
    {
        cout << val << endl;
    }
    else
    {
        cout << "无" << endl;
    }
    return 0;
};

删除链表倒数第k个节点

bool removeLastKNode(Node* head, int k) {
    Node* p = head;
    Node* q = head;

    if (head == nullptr || k < 1) {
        return false;
    }
    for (int i = 0; i < k; i++) {
        p = p->next_;
        if (p == nullptr) {
            return false;
        }
    }
    while (p->next_ != nullptr) {
        p = p->next_;
        q = q->next_;
    }

    Node* temp = q->next_;
    q->next_ = q->next_->next_;
    return true;
}
int main()
{
    Node head;
    Node n1(25), n2(67), n3(32), n4(18);
    head.next_ = &n1;
    n1.next_ = &n2;
    n2.next_ = &n3;
    n3.next_ = &n4;
    n4.next_ = nullptr;

    Node* p = head.next_;
    while (p != nullptr)
    {
        cout << p->data_ << " ";
        p = p->next_;
    }
    cout << endl;

    if (removeLastKNode(&head, 2))
    {
        p = head.next_;
        while (p != nullptr)
        {
            cout << p->data_ << " ";
            p = p->next_;
        }
    }

    cout << endl;
    return 0;
};

旋转链表

Node* func(Node* head, int k)
{    
    Node* p = head;

    //求链表结点的总个数
    int num = 0;
    //O(n)
    while (p->next_ != nullptr)
    {
        p = p->next_;
        num++;
    }
    num = k % (num+1);//实际移动次数
    if (num == 0)//移动次数为0的话，直接退出
    {
        return head;
    }

    //O(n)
    Node* q = head;
    p = head;
    for (int i = 0; i < num; i++)
    {
        p = p->next_;
    }
    while (p->next_!= nullptr)
    {
        p = p->next_;//倒数第一个结点
        q = q->next_;//倒数第k个结点的前一个结点
    }
    
    Node* temp = head->next_;//保存第一个节点位置
    head->next_ = q->next_;//头结点连接倒数第k个节点
    p->next_ = temp;//原来的尾节点连接原来的第一个节点
    q->next_ = nullptr;//q成为尾结点
    return head;
}
int main()
{
    Node head;
    Node n1(1), n2(2), n3(3), n4(4), n5(5);
    head.next_ = &n1;
    n1.next_ = &n2;
    n2.next_ = &n3;
    n3.next_ = &n4;
    n4.next_ = &n5;
    n5.next_ = nullptr;

    //旋转前
    Node* p = head.next_;
    while (p != nullptr)
    {
        cout << p->data_ << " ";
        p = p->next_;          
    }
    cout << endl;
   
    func(&head, 18);

    //旋转后
    p = head.next_;
    while (p != nullptr)
    {
        cout << p->data_ << " ";
        p = p->next_;
    }
    cout << endl;


    return 0;
};

_rm
关注
数据结构——单链表实验
06-15
熟悉单链表的定义，单链表的建立方法及相关基本操作，理解单链表的基本思想，能够根据实际情况选择合适的存储结构。 2.实验内容 1、利用头插法或尾插法建立单链表 2、对已建立的单链表实现插入、删除等基本操作； 3...
数据结构——单链表.zip
09-16
本资料包"数据结构——单链表.zip"专注于单链表的实现，特别针对严蔚敏教授的数据结构教材内容进行了完整的编程实现。下面，我们将深入探讨单链表及其相关操作。 单链表是一种线性数据结构，每个元素称为节点，每个...
数据结构——单链表（C语言版）.zip
11-02
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储...
JAVA数据结构——单链表的操作.docx
07-11
单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。在给定的文档中，主要介绍了如何在Java中实现单链表的操作。以下是详细的知识点解析： 1. **节点类(Node....
数据结构学习笔记——单链表
12-21
本文将深入探讨单链表这一常见数据结构，并与其他数据结构如数组进行对比。 单链表是一种线性数据结构，其特点是元素在内存中并非连续存储。每个节点由两部分构成：一个是存储数据的`data`变量，另一个是`next`指针...
数据结构之堆（优先级队列）
2302_77675796的博客
09-22 750
数据结构之堆（优先级队列）
数据结构：树、森林
最新发布
pranaa的博客
09-24 908
此外，访问子节点和父节点的索引计算也会变得复杂，因为需要额外的数据结构（如指针或索引数组）来跟踪每个节点的子节点位置。在转换为二叉树时，我们可以将节点的第一个孩子视为二叉树的左孩子，将节点的下一个兄弟视为二叉树的右孩子。这种转换在处理树形结构的问题时非常有用，因为二叉树具有一些特殊的性质（如左子树和右子树的明确区分）和高效的算法（如二叉搜索树、堆等）。二叉树和树的顺序存储结构在本质上是相似的，但由于二叉树结构的特殊性，它在顺序存储中更加高效和直接。二叉树转换为树的过程是上述转换的逆过程。
数据结构：串 及串的模式匹配（KMP）
pranaa的博客
09-23 1107
串（String）是由零个或多个字符组成的有限序列，又名叫字符串。在计算机科学中，串是一种重要的数据结构，用于表示文本数据。串中的元素称为字符，字符可以是字母、数字或其他符号，这些字符可以是任意字符集中的成员。串是许多编程语言中的基本数据类型，用于处理文本数据。
【JAVA-数据结构】时间和空间复杂度
Mr_star_galaxy的博客
09-24 979
这篇文章我们来谈一下，数据结构的前提，时间和空间复杂度。
数据结构：二叉树的遍历和线索二叉树
pranaa的博客
09-24 700
在普通二叉树中，每个节点有两个指针域，分别指向左右子节点，但在很多情况下，这两个指针域可能为空，这些空指针域就称为“空域”。线索二叉树就是将这些空域利用起来，存储指向该节点在某种遍历次序下的前驱和后继节点的指针（或线索）。二叉树的遍历是二叉树的一种重要的操作，指按照某种顺序访问树中的每个节点，并且每个节点仅被访问一次。首先访问根节点，然后递归地进行前序遍历左子树，最后递归地进行前序遍历右子树。首先递归地进行后序遍历左子树，然后递归地进行后序遍历右子树，最后访问根节点。遍历完左子树后，访问根节点，然后根据。
数据结构：二叉树
2302_81258662的博客
09-21 1394
树是一种非线性数据结构，用于表示层次关系。树由节点组成，每个节点包含一个值和指向其子节点的指针。树的特点是每个节点只能有一个父节点，但可以有多个子节点。
【数据结构初阶】链式二叉树接口实现超详解
fhvyxyci的博客
09-21 1260
1. 节点定义 2. 前中后序遍历 2. 1 遍历规则 2. 2 遍历实现 2. 3 结点个数 2. 3. 1 二叉树节点个数 2. 3. 2 二叉树叶子节点个数 2. 3. 3 二叉树第k层节点个数 2. 4 二叉树查找值为x的节点 2. 5 二叉树层序遍历 2. 6 判断二叉树是否是完全二叉树 3. 二叉树性质
【JAVA-数据结构】初识集合框架
Mr_star_galaxy的博客
09-24 935
Java 集合框架 Java Collection Framework ，又被称为容器 container ，是定义在 java.util 包下的一组接口 interfaces和其实现类 classes。其主要表现为将多个元素 element 置于一个单元中，用于对这些元素进行快速、便捷的存储 store 、检索 retrieve 、管理 manipulate ，即平时我们俗称的增删查改 CRUD。例如，一副扑克牌(一组牌的集合)、一个邮箱(一组邮件的集合)、一个通讯录(一组姓名和电话的映射关系)等等。
【C语言-数据结构】单链表的定义
m0_74209563的博客
09-21 370
不带头结点，写代码更麻烦对第一个数据结点和后续数据结点的处理需要用不同的代码逻辑对空表和非空表的处理需要用不同的代码逻辑带头结点，写代码更方便本文主要参考《王道计算机考研 数据结构》课程视频。
数据结构：特殊矩阵 及其存储
pranaa的博客
09-23 861
特殊矩阵的压缩存储是一种优化存储空间的技术，主要针对具有许多相同矩阵元素或零元素，且这些元素分布具有一定规律性的矩阵。这些矩阵包括对称矩阵、三角矩阵（上三角矩阵和下三角矩阵）、对角矩阵（如三对角矩阵）以及稀疏矩阵等。以下是对这些特殊矩阵压缩存储的详细介绍及例子。
数据结构：什么是数据类型（详解）
pranaa的博客
09-22 425
数据类型（Data Type）是编程中的一个基本概念，它定义了数据的种类和存储方式，以及可以对该数据执行的操作。在编程中，不同的数据类型允许程序员以不同的方式存储和操作数据。数据类型决定了数据的性质、大小、如何解释存储的位（bit）以及可以对这些数据执行哪些操作。数据类型主要分为两大类：基本数据类型（Primitive Data Types）和复合数据类型（Composite Data Types）。
数据结构：线性表的链式表示
pranaa的博客
09-22 822
线性表的链式表示，又称为链式存储结构或链式映像，是一种常见且灵活的数据结构表示方式。它使用指针（或链）将一组数据元素按照其逻辑顺序连接起来，而不需要这些元素在物理位置上连续存储。这种表示方式特别适用于需要频繁进行插入和删除操作的场景。
数据结构：树的定义及其性质
pranaa的博客
09-24 615
树是一种重要的非线性数据结构，树作为一种逻辑结构，同时也是一种分层结构。具有以下两个特点：1.树的根结点没有前驱，除根结点意外的节点只有一个前驱2.树中所有结点都可以有0个或多个后继树结构在多个领域都有广泛应用，如表示文件系统的结构、数据库的索引、层次数据关系等。具体来说，树是由n（n≥0）个节点组成的有限集合。当n=0时，称为空树；当n>0时，为非空树。
数据结构：二叉树（定义 特性 存储）
pranaa的博客
09-24 795
二叉树（Binary Tree）是树形结构的一种，它的特点是每个节点最多有两个子节点，通常被称为左子节点（left child）和右子节点（right child）。二叉树可以是空集，若不为空，则是由一个根节点（root node）和两个不相交的、分别被称为左子树和右子树的二叉树组成。
多项式相加算法实现及数据结构——单链表解析
"两个多项式的相加算法-数据结构课件" 在数据结构中，多项式是一种常见的数学概念，它可以通过链表结构来有效地表示和处理。这篇课件主要讲解了如何实现两个多项式的相加算法，这个算法是基于链表的数据结构设计的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值