【C/C++数据结构与算法】C语言链表

news2024/11/27 4:29:01

目录

一、单链表

二、双向循环链表

三、判断链表是否带环

四、链表的回文结构判断

五、复制带随机指针的链表

一、单链表

优点：头部增删效率高，动态存储无空间浪费

缺点：尾部增删、遍历效率低，不支持随机访问节点

头结点：单链表头结点可有可无，带头结点更方便进行初始化

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

typedef int NodeData;

typedef struct List 
{
    NodeData data;
    struct List* next;
}List;

void Init(List* list) 
{
    assert(list);
    list->next = (List*)malloc(sizeof(List));    // 空头结点
    list->next->next = NULL;
}

bool Empty(List* list) 
{
    assert(list);
    return list->next->next == NULL;
}

void Push(List* list, NodeData x) 
{
    assert(list);
    List* node = (List*)malloc(sizeof(List));
    if (node == NULL) 
    {
        perror("malloc");
        return;
    }
    node->data = x;
    node->next = list->next->next;
    list->next->next = node;
}

void Pop(List* list) 
{
    assert(list);
    if (!Empty(list)) 
    {
        List* cur = list->next->next;
        list->next = cur->next;
        free(cur);
        cur = NULL;
    }
}

size_t Size(List* list) 
{
    assert(list);
    size_t size = 0;
    List* cur = list->next->next;
    while (cur) 
    {
        ++size;
        cur = cur->next;
    }
    printf("the list size = %d\n", size);
    return size;
}

void PrintList(List* list) 
{
    assert(list);
    if (!Empty(list)) 
    {
        List* cur = list->next->next;
        printf("%d ", cur->data);
        while (cur->next) 
        {
            printf("-> %d ", cur->next->data);
            cur = cur->next;
        }
        printf("\n");
    }
}

int main() 
{
    List list;
    Init(&list);
    Push(&list, 1);
    Push(&list, 3);
    Push(&list, 5);
    Push(&list, 7);
    Size(&list);
    PrintList(&list);
    Pop(&list);
    Pop(&list);
    Pop(&list);
    Pop(&list);
    Pop(&list);
    Size(&list);
    PrintList(&list);
    return 0;
}

二、双向循环链表

特征：

  • 每个Node都有一个data值，一个prev前驱指针和一个next后置指针
  • C++的STL中封装的就是双向循环链表
  • 头部增删和尾部增删效率一样高，但依然不支持随机访问
  • 链表循环且带头结点，最后一个Node指向头结点，头结点也指向最后一个Node
  • 空链表的前驱和后置指针都指向头结点，头结点不存放数据

代码分析：

Push和Pop函数通过调用Insert和Erase函数对Node进行按址增删，减少了代码的复用

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

typedef int NodeData;

typedef struct List 
{
    NodeData data;
    struct List* prev;
    struct List* next;
}List;

void Init(List* list) 
{
    assert(list);
    list->prev = list;
    list->next = list;
}

bool Empty(List* list) 
{
    assert(list);
    return list->next == list;
}

void Insert(List* list, NodeData x, List* pos) 
{
    assert(list && pos);
    List* prev = pos->prev;
    List* node = (List*)malloc(sizeof(List));
    if (node == NULL) 
    {
        perror("malloc");
        exit(1);
    }
    node->data = x;
    node->next = pos;
    pos->prev = node;
    node->prev = prev;
    prev->next = node;
}

void Erase(List* list, List* pos) 
{
    assert(list && pos);
    List* prev = pos->prev;
    List* next = pos->next;
    prev->next = next;
    next->prev = prev;
    free(pos);
    pos = NULL;
}

void PushFront(List* list, NodeData x) 
{
    assert(list);
    Insert(list, x, list->next);
}

void PushBack(List* list, NodeData x) 
{
    assert(list);
    Insert(list, x, list);
}

void PopFront(List* list) 
{
    assert(list);
    Erase(list, list->next);
}

void PopBack(List* list) 
{
    assert(list);
    Erase(list, list->prev);
}

size_t Size(List* list) 
{
    assert(list);
    size_t size = 0;
    List* cur = list->next;
    while (cur != list) 
    {
        ++size;
        cur = cur->next;
    }
    printf("the list size is %d\n", size);
    return size;
}

void PrintList(List* list) 
{
    assert(list);
    if (!Empty(list)) 
    {
        List* cur = list->next;
        printf("%d ", cur->data);
        while (cur->next != list) 
        {
            printf("-> %d ", cur->next->data);
            cur = cur->next;
        }
        printf("\n");
    }
}

int main() 
{
    List list;
    Init(&list);
    PushFront(&list, 1);
    PushFront(&list, 3);
    PushFront(&list, 5);
    PushBack(&list, 2);
    PushBack(&list, 4);
    PushBack(&list, 6);
    Size(&list);
    PrintList(&list);   //5 -> 3 -> 1 -> 2 -> 4 -> 6

    PopFront(&list);
    PopBack(&list);
    PopBack(&list);
    PushFront(&list, 10);
    PushBack(&list, 20);
    Size(&list);
    PrintList(&list);   //10 -> 3 -> 1 -> 2 -> 20
    return 0;
}

三、判断链表是否带环

链表带环：尾结点指向链表的某个节点

函数设计：设置快慢指针，根据链表头结点head，判断链表是否带环，返回bool值

bool IsCircle(struct ListNode* head) 
{
    struct ListNode* fast = head;
    struct ListNode* slow = head;
    while (fast && fast->next) 
    {
        fast = fast->next->next;
        slow = slow->next;
        if (fast == slow) 
            return true;
    }
    return false;
}

四、链表的回文结构判断

函数要求：时间复杂度为O(n), 额外空间复杂度为O(1), 返回bool值

函数设计：

  1. 用快慢指针找到链表中间节点
  2. 将中间节点之后的链表逆置
  3. 设置头指针和中间节点指针进行回文判断
  4. 将中间节点之后的链表再次逆置, 还原链表结构
struct ListNode* MidNode(struct ListNode* head) 
{
    struct ListNode* fast = head;
    struct ListNode* slow = head;
    while (fast && fast->next) 
    {
        fast = fast->next->next;
        slow = slow->next;
    }
    return slow;
}

struct ListNode* ReverseList(struct ListNode* head) 
{
    struct ListNode* p1 = NULL;
    struct ListNode* p2 = head;
    struct ListNode* p3 = NULL;
    if (p2 != NULL) 
        p3 = head->next;
    while (p3) 
    {
        p2->next = p1;
        p1 = p2;
        p2 = p3;
        p3 = p3->next;
    }
    p2->next = p1;
    p1 = p2;
    p2 = p3;
    return p1;
}

bool ChkPalindrome(struct ListNode* A) 
{
    struct ListNode* mid = MidNode(A);
    mid = ReverseList(mid);
    struct ListNode* front = A;
    struct ListNode* back = mid;
    struct ListNode* cur = back;
    int flag = 1;
    while (back && front != cur) 
    {
        if (front->val != back->val) 
        {
            flag = 0;
            break;
        }
        front = front->next;
        back = back->next;
    }
    mid = ReverseList(mid);    //再次逆置，防止链表结构被破坏
    if (flag == 0)
        return false;
    return true;
}

五、复制带随机指针的链表

函数要求：

给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。

构造这个链表的深拷贝。 深拷贝应该正好由 n 个全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。

例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。

返回复制链表的头节点。

用一个由 n 个节点组成的链表来表示输入/输出中的链表。

每个节点用一个 [val, random_index] 表示：

        val：一个表示 Node.val 的整数。

        random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。

你的代码只接受原链表的头节点 head 作为传入参数。

函数设计：

  1. 在每个节点后面复制一个一模一样的copy节点
  2. copy->random = cur->random->next
  3. 将copy部分和原节点断开
struct Node* copyRandomList(struct Node* head) 
{
    //1. 在每个节点后面复制一个相同的节点
    struct Node* cur = head;
    if (cur == NULL) 
        return NULL;
    while (cur) 
    {
        struct Node* copy = (struct Node*)malloc(sizeof(struct Node));
        copy->val = cur->val;
        copy->next = cur->next;
        cur->next = copy;
        cur = copy->next;
    }
 
    //2. copy->random = cur->random->next
    cur = head;
    while (cur) 
    {
        struct Node* copy = cur->next;
        if (cur->random == NULL) 
            copy->random = NULL;
        else 
            copy->random = cur->random->next;
        cur = copy->next;
    }
 
    //3. 将copy部分和原链表断开
    cur = head;
    struct Node* copy = cur->next;
    struct Node* copytail = copy;
    while (cur) 
    {
        struct Node* next = copytail->next;
        cur->next = next;
        if (next) 
            copytail->next = next->next;
        cur = next;
        copytail = copytail->next;
    }
 
    return copy;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/662347.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【夜深人静学习数据结构与算法 | 第六篇】贪心算法

【夜深人静学习数据结构与算法 | 第六篇】贪心算法

目录 前言&#xff1a; 引入: 贪心算法&#xff1a; 455. 分发饼干 - 力扣&#xff08;LeetCode&#xff09; 376. 摆动序列 - 力扣&#xff08;LeetCode&#xff09; 53. 最大子数组和 - 力扣&#xff08;LeetCode&#xff09; 122. 买卖股票的最佳时机 II - 力扣&a…
阅读更多...
【Python 随练】统计字符类型个数

【Python 随练】统计字符类型个数

题目&#xff1a; 输入一行字符&#xff0c;分别统计出其中英文字母、空格、数字和其它字符的个数。 简介&#xff1a; 在本篇博客中&#xff0c;我们将解决一个字符统计问题&#xff1a;输入一行字符&#xff0c;统计其中英文字母、空格、数字和其他字符的个数。我们将提供…
阅读更多...
学习python爬虫需要掌握哪些库？

学习python爬虫需要掌握哪些库？

Python爬虫是指使用Python编写的程序&#xff0c;用来自动化地获取互联网上的数据。通过爬取网站的HTML内容&#xff0c;并解析和提取所需的数据&#xff0c;可以实现自动化地收集、分析和处理大量的在线数据。 学习Python爬虫需要掌握以下几个核心库&#xff1a; Requests&am…
阅读更多...
【ARM AMBA AXI 入门 9 - AXI 总线 AxPROT 与安全之间的关系 】

【ARM AMBA AXI 入门 9 - AXI 总线 AxPROT 与安全之间的关系 】

文章目录 介绍ARM Trustzone的安全扩展简介 1.1 AXI AxPROT 介绍1.1.1 AXI 对 Trustzone的支持 介绍 ARMv8 架构中的AXI&#xff08;Advanced eXtensible Interface&#xff09;总线与NS&#xff08;Non-Secure&#xff09;位密切相关。NS位是指在ARM TrustZone安全扩展中定义…
阅读更多...
LeetCode 1254. Number of Closed Islands【DFS,BFS,并查集】中等

LeetCode 1254. Number of Closed Islands【DFS,BFS,并查集】中等

本文属于「征服LeetCode」系列文章之一&#xff0c;这一系列正式开始于2021/08/12。由于LeetCode上部分题目有锁&#xff0c;本系列将至少持续到刷完所有无锁题之日为止&#xff1b;由于LeetCode还在不断地创建新题&#xff0c;本系列的终止日期可能是永远。在这一系列刷题文章…
阅读更多...
单片机MCU如何实现让部分代码运行在RAM中

单片机MCU如何实现让部分代码运行在RAM中

随着单片机硬件的发展&#xff0c;其中的RAM和flash越做越大。MCU在实际的使用中&#xff0c;通常程序都是运行在flash上的&#xff0c;RAM的高速空间并没有得到充分的利用&#xff0c;如果我们的程序需要运行的更快&#xff0c;系统有更好的实时性&#xff0c;我们可以考虑将这…
阅读更多...
CSS查缺补漏之《常用长度单位(px、em、rem、%、vw/vh、vmin/vmax)》

CSS查缺补漏之《常用长度单位(px、em、rem、%、vw/vh、vmin/vmax)》

此文内容较少&#xff0c;轻轻松松掌握&#xff0c;莫要有压力~ 正如现实生活中长度具有mm、dm、cm、m等&#xff0c;在css中&#xff0c;也具备多种长度单位&#xff0c;本文对常用的几种单位进行详细举例介绍~ px&#xff1a;像素单位 初学css时&#xff0c;px单位经常被使用…
阅读更多...
【Leetcode60天带刷】day08字符串——344.反转字符串， 541. 反转字符串II，剑指Offer 05.替换空格，151.翻转字符串里的单词

【Leetcode60天带刷】day08字符串——344.反转字符串， 541. 反转字符串II，剑指Offer 05.替换空格，151.翻转字符串里的单词

题目&#xff1a; 344. 反转字符串 编写一个函数&#xff0c;其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。 不要给另外的数组分配额外的空间&#xff0c;你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。 示例 1&#xff1a; 输入&…
阅读更多...
基于SpringBoot+Vue的“漫画之家”系统设计与实现

基于SpringBoot+Vue的“漫画之家”系统设计与实现

博主介绍&#xff1a; 大家好&#xff0c;我是一名在Java圈混迹十余年的程序员&#xff0c;精通Java编程语言&#xff0c;同时也熟练掌握微信小程序、Python和Android等技术&#xff0c;能够为大家提供全方位的技术支持和交流。 我擅长在JavaWeb、SSH、SSM、SpringBoot等框架下…
阅读更多...
新电脑机环境安装笔记

新电脑机环境安装笔记

「Navicat_15.0.25_64bit_Setup.exe」 下载https://www.aliyundrive.com/s/b9xUw2JpuJb Navicat Keygen Patch v5.6.0 下载 https://www.aliyundrive.com/s/YYyE5BQMMuN 全程断网操作 patch 将安装目录选中 提示 check 64 mysql安装&#xff1a; https://baijiahao.baidu…
阅读更多...
因子分析——SPSS实例分析

因子分析——SPSS实例分析

【续上篇主成分分析】 因子分析常用于通过可观测变量推断出其背后的公共因子&#xff08;也称为隐变量&#xff09;&#xff0c;样本在公共因子上的取值变化影响其在可观测变量上的取值&#xff0c;因为一般公共因子的个数小于可观测变量的数目&#xff0c;所以因子分析也可以…
阅读更多...
渠道归因（一）传统渠道归因

渠道归因（一）传统渠道归因

渠道归因&#xff08;一&#xff09;传统渠道归因 小P&#xff1a;小H&#xff0c;我又来了。。。最近在做ROI数据&#xff0c;但是有个问题。。。 小H&#xff1a;什么问题&#xff0c;不就是收入/成本吗&#xff1f; 小P&#xff1a;是的&#xff0c;每个渠道的成本很容易计算…
阅读更多...
基于html+css的图展示134

基于html+css的图展示134

准备项目 项目开发工具 Visual Studio Code 1.44.2 版本: 1.44.2 提交: ff915844119ce9485abfe8aa9076ec76b5300ddd 日期: 2020-04-16T16:36:23.138Z Electron: 7.1.11 Chrome: 78.0.3904.130 Node.js: 12.8.1 V8: 7.8.279.23-electron.0 OS: Windows_NT x64 10.0.19044 项目…
阅读更多...
如何打造创意百变的虚拟直播场景？

如何打造创意百变的虚拟直播场景？

场景对于直播来说是直接呈现给观众的&#xff0c;也是直播带货的“直接”的视觉冲击的价值核心&#xff0c;所以场景的设计十分重要。今天&#xff0c;我们就一起来看看如何低成本搭建一个网红同款直播间吧&#xff01; 直播间类型 直播间大体可以分为三种类型&#xff1a;虚拟…
阅读更多...
CUDA共享内存详解

CUDA共享内存详解

为什么需要共享内存&#xff1f; 共享内存的访问速度比访问全局速度快的多&#xff0c;因此对于多次访问全局内存的程序&#xff0c;特别是需要多次将全局内存的运算结果缓存到全局内存的运算&#xff0c;先将临时结果缓存到共享内存再做计算&#xff0c;会提高运算速度。 1、…
阅读更多...
C语言使用Wininet库网络编程跳坑记 —— cookies篇

C语言使用Wininet库网络编程跳坑记 —— cookies篇

笔者尝试C语言使用Wininet库进行网络编程时&#xff0c;我尝试使用 InternetSetCookieA() 或 HttpAddRequestHeadersA() 设置 cookie。 HttpAddRequestHeadersA(Request, headers, header_len, HTTP_ADDREQ_FLAG_ADD | HTTP_ADDREQ_FLAG_REPLACE); InternetSetCookieA(url, NU…
阅读更多...
基于SpringBoot+Vue的电影分享平台

基于SpringBoot+Vue的电影分享平台

✌全网粉丝20W,csdn特邀作者、博客专家、CSDN新星计划导师、java领域优质创作者,博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和毕业项目实战✌ &#x1f345;文末获取项目下载方式&#x1f345; 一、项目背景介绍&#xff1a; 当代社会&#xff0c;…
阅读更多...
Linux（环境准备）VMware与CentOS及XShell的安装

Linux（环境准备）VMware与CentOS及XShell的安装

目录 第 1 章 VMware 1.1 VMware 安装 1.1.1 VMware Workstation Pro 15.5 安装包 ​1.2.2 欢迎界面 1.2.3 同意许可证 1.2.4 选择安装路径 1.2.5 用户体检计划 1.2.6 快捷方式 1.2.7 开始安装 1.2.8 等待安装完成 1.2.9 安装完成 1.2.10 输入许可证 1.2.11 VM…
阅读更多...
工欲善其事，必先利其器--Vscode嵌入式Linux开发远程开发设置(适用于多平台)

工欲善其事，必先利其器--Vscode嵌入式Linux开发远程开发设置(适用于多平台)

点击上方“嵌入式应用研究院”&#xff0c;选择“置顶/星标公众号” 干货福利&#xff0c;第一时间送达&#xff01; 来源 | 嵌入式应用研究院 整理&排版 | 嵌入式应用研究院 最近搭了一台Ubuntu18.04版本的桌面PC&#xff0c;不得不说比起Window搭虚拟机搞起来爽多了&…
阅读更多...
python文件首行

python文件首行

类似于一切脚本文件一样&#xff0c;首行可用于指定解释器用于执行文件&#xff1b; 常见的是linux系统下的各个解释器。比如&#xff1a; #!/bin/sh– 使用Bourne shell或兼容的 shell执行文件&#xff0c;假定位于 /bin 目录中#!/bin/bash– 使用Bash shell执行文件#!/usr/…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023