《六月集训》第十二天——链表

最新推荐文章于 2023-01-10 22:44:16 发布
最新推荐文章于 2023-01-10 22:44:16 发布
阅读量165 收藏
点赞数 1
分类专栏： 刷题 文章标签： 数据结构 算法 c语言 leetcode 单向链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40864532/article/details/125248695
版权

文章目录

前言

        
刷题坚持每一天，以下题目引用自：力扣（LeetCode）

💎一、题目一

🏆1.题目描述

原题链接：328. 奇偶链表

给定单链表的头节点 head ，将所有索引为奇数的节点和索引为偶数的节点分别组合在一起，然后返回重新排序的列表。
第一个节点的索引被认为是 奇数 ， 第二个节点的索引为 偶数 ，以此类推。
请注意，偶数组和奇数组内部的相对顺序应该与输入时保持一致。
你必须在 O(1) 的额外空间复杂度和 O(n) 的时间复杂度下解决这个问题。

示例 1：
Alt
输入: head = [1,2,3,4,5]
输出: [1,3,5,2,4]

🏆2.解题思路

🔑思路：

​         把链表下标奇数和偶数放两列，循环完，和一起，返回头节点。

🏆3.代码详解

struct ListNode* oddEvenList(struct ListNode* head){
    if(head == NULL) return NULL;
    struct ListNode* add = head;
    struct ListNode* eve = head->next;
    struct ListNode* list1 = eve;
    while(eve && eve->next){
        add->next = eve->next;
        add = add->next;
        eve->next = add->next;
        eve = eve->next;
    }
    add->next = list1;
    return head;
}

💎二、题目二

🏆1.题目描述

原题链接：725. 分隔链表

给你一个头结点为 head 的单链表和一个整数 k ，请你设计一个算法将链表分隔为 k 个连续的部分。
每部分的长度应该尽可能的相等：任意两部分的长度差距不能超过 1 。这可能会导致有些部分为 null 。
这 k 个部分应该按照在链表中出现的顺序排列，并且排在前面的部分的长度应该大于或等于排在后面的长度。
返回一个由上述 k 部分组成的数组。

示例 1：
Alt
输入：head = [1,2,3], k = 5
输出：[[1],[2],[3],[],[]]
解释：
第一个元素 output[0] 为 output[0].val = 1 ，output[0].next = null 。
最后一个元素 output[4] 为 null ，但它作为 ListNode 的字符串表示是 [] 。

🏆2.解题思路

🔑思路：

​         先遍历一遍，统计有多少个节点。然后根据k值去分配每一行有多少个节点。对每一行分配完节点，然后把节点循环到未分配的下一节点。

🏆3.代码详解

struct ListNode** splitListToParts(struct ListNode* head, int k, int* returnSize){
    * returnSize = k;
    struct ListNode** ans = (struct ListNode**)malloc(sizeof(struct ListNode*)*k);
    struct ListNode* list = head;
    int count = 0;
    while(list){
        ++count;
        list = list->next;
    }
    int sur = count % k;
    int div = count / k;
    // printf("%d\n",div);
    struct ListNode* node = head;
    for(int i = 0; i < k; ++i){
        ans[i] = node;
        if(node){
            int ret = 0;
            if(sur > 0){
                ret = 1;
                --sur;
            }
            ret += div-1;
            for(int j = 0; j < ret; ++j) node = node->next;
            struct ListNode* p = node;
            node = node->next;
            p->next = NULL;
        }  
    }
    return ans;
}

💎三、题目三

🏆1.题目描述

原题链接：817. 链表组件

给定链表头结点 head，该链表上的每个结点都有一个 唯一的整型值 。同时给定列表 nums，该列表是上述链表中整型值的一个子集。
返回列表 nums 中组件的个数，这里对组件的定义为：链表中一段最长连续结点的值（该值必须在列表 nums 中）构成的集合。

示例 1：
Alt
输入: head = [0,1,2,3], nums = [0,1,3]
输出: 2
解释: 链表中,0 和 1 是相连接的，且 nums 中不包含 2，所以 [0, 1] 是 nums 的一个组件，同理 [3] 也是一个组件，故返回 2。

🏆2.解题思路

🔑思路：

​        用hash统计出现的元素。去遍历这个链表，当有不存的值时就是需要分割的时候，计数加一。

🏆3.代码详解

int numComponents(struct ListNode* head, int* nums, int numsSize){
    struct ListNode* list = head;
    int hash[10001];
    memset(hash, 0, sizeof(hash));
    for(int i = 0; i < numsSize; ++i){
        hash[nums[i]] = 1;
    }
    int ans = 0, flag = 0;
    while(list){
        if(hash[list->val]){
            if(flag == 0){
                ++ans;
                flag = 1;
            } 
            list = list->next; 
        }
        else{
            flag = 0;
            list = list->next; 
        }
        
    }
    return ans;
}

💎四、题目四

🏆1.题目描述

原题链接：622. 设计循环队列

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
你的实现应该支持如下操作：

  • MyCircularQueue(k): 构造器，设置队列长度为 k 。
  • Front: 从队首获取元素。如果队列为空，返回 -1 。
  • Rear: 获取队尾元素。如果队列为空，返回 -1 。
  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
  • isEmpty(): 检查循环队列是否为空。
  • isFull(): 检查循环队列是否已满。

示例 1：
MyCircularQueue circularQueue = new MyCircularQueue(3); // 设置长度为 3
circularQueue.enQueue(1); // 返回 true
circularQueue.enQueue(2); // 返回 true
circularQueue.enQueue(3); // 返回 true
circularQueue.enQueue(4); // 返回 false，队列已满
circularQueue.Rear(); // 返回 3
circularQueue.isFull(); // 返回 true
circularQueue.deQueue(); // 返回 true
circularQueue.enQueue(4); // 返回 true
circularQueue.Rear(); // 返回 4

🏆2.解题思路

🔑思路：

​         使用单链表操作即可。

🏆3.代码详解

int lengthSize;
int size;
typedef struct queue{
    int data;
    struct queue* next;
} MyCircularQueue;
typedef struct listqueue {
    MyCircularQueue* front;
    MyCircularQueue* REAR;
} linkqueue;


linkqueue* myCircularQueueCreate(int k) {
    linkqueue* obj = (linkqueue*)malloc(sizeof(linkqueue));
    obj->front = obj->REAR = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->front->next = obj->REAR->next = NULL;
    lengthSize = k;
    size = 0;
    return obj;
}
bool myCircularQueueIsEmpty(linkqueue* obj) {
    return size == 0;
}

bool myCircularQueueIsFull(linkqueue* obj) {
    return lengthSize == size;
}
bool myCircularQueueEnQueue(linkqueue* obj, int value) {
    if(myCircularQueueIsFull(obj)) return false;
    ++size;
    MyCircularQueue* node= (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    node->data = value;
    node->next = NULL;
    obj->REAR->next = node;
    obj->REAR = obj->REAR->next;
    return true;
}

bool myCircularQueueDeQueue(linkqueue* obj) {
    if(myCircularQueueIsEmpty(obj)) return false;
    --size;
    MyCircularQueue* node = obj->front;
    obj->front = obj->front->next;
    node->next = NULL;
    free(node);
    return true;
}

int myCircularQueueFront(linkqueue* obj) {
    if(myCircularQueueIsEmpty(obj)) return -1;
    return obj->front->next->data;
}

int myCircularQueueRear(linkqueue* obj) {
    if(myCircularQueueIsEmpty(obj)) return -1;
    return obj->REAR->data;
}
void myCircularQueueFree(linkqueue* obj) {
    free(obj);
}

💎五、星球推荐

        星球链接：英雄算法联盟

星球里有什么?
        【朋友圈】一个极致精准的自律、编程、算法的小圈子。
        【算法集训】以月为单位组织算法集训，每天四题，风雨无阻。
        【排行榜】每天、每周都会有榜单，激励大家不断进步，不断成长。
        【个人规划】每个人都写好自己的规划，也可以查看他人的规划，时刻警醒自己不掉队。
        【打卡挑战】每日一题打卡、每日早起打卡、算法集训打卡、规划完成情况打卡。
在星球里做什么?
        目前星球人数达到520+，在星球里你能够遇到一群志同道合之人，因为都是花钱进来的，你不会看到任何浑水摸鱼的人，每个人都有自己的每月规划，星主每月都会组织算法集训，每天一起刷题，你可以看到别人的解题报告，取其之长，补己之短。

Dimon1.
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
详解循环队列
Lemonflavoredgum的博客
10-27 644
循环队列是一种基于数组实现的队列数据结构，它的特点是队列的尾部指针可以循环到数组的头部，形成一个环形结构。循环队列的定义包括以下几个要素：一个固定大小的数组：循环队列使用一个数组来存储元素，数组的大小是预先指定的。一个头指针（front）：指向队列的第一个元素。一个尾指针（rear）：指向队列最后一个元素的下一个位置。当队列为空时，头指针和尾指针指向同一个位置。队列长度（size）：表示队列中元素的个数。
数据结构——循环队列
热门推荐
yue152152的博客
03-28 1万+
概念 基于队列的先进先出的原则，在确定了队列长度的前提下，另队列首尾相接而实现的一种结构。 循环队列的作用 循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/design-circular-queue 题目 设置循环队列 注意事项 .
【数据结构】循环队列的实现
记录学习点滴
08-24 5020
>✨给大家推荐一款很火爆的刷题、面试求职网站✨
LeetCode栈和队列经典例题
m0_70811813的博客
01-09 708
这里有四道关于栈和队列的经典题型
数据结构——循环链表
zhang_ysx的博客
01-10 2578
循环链表的简单操作
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
C语言——链表的归并_c语言链表详解
12-21
用c语言写链表归并
图解数据结构（使用Python）——链表
12-21
由于是第一次在CSDN平台发表文章，格式排版方面还不太熟悉，加上能力有限，所以文章内容会比较简单。最后希望自己能够在学习中进步，提高能力来丰富文章内容！ 1. 链表的概念及其优缺点 概念：链表（Linked List）是...
Python数据结构实战——链表(LinkedList)
12-21
定义链表类2.1.打印整个链表2.2.获取链表长度2.3.链表头部插入元素2.4.链表尾部插入元素2.5.链表任意位置插入元素2.6.链表任意位置删除元素2.7.链表中插入一堆数据2.8.完整代码+测试 1.定义结点类 class Node: def ...
数据结构——链表的实现
12-29
数据结构课程的链表类的C++实现，搜索，删除，插入，查找等函数
循环队列的介绍与实现
夜飘凌的博客
08-06 4171
#include <stdio.h> #include <stdlib.h> #include <time.h> #define MAXSZIE (20) typedef int ElementType; typedef struct SqQueue { ElementType data[MAXSZIE]; int front; int rear; } *Queue; Queue InitQueue(void) { Queue Q =
循环队列(顺序结构)
q322359的博客
09-16 593
循环队列(顺序结构)
数据结构和算法(一)Java实现循环队列
yuan_xw的专栏
02-17 3525
1. 数据结构和算法(一)Java实现循环队列 1.1 什么是循环队列   循环队列：具有队头指针（front）和队尾指针（rear），指示队列元素所在的位置，避免删除元素时移动大量元素。队列也是一种线性表，只不过它是操作受限的线性表，只能在两端操作，先进先出（First In First Out，FIFO）。 循环队列特性： 只能队尾插入元素、在队头删除元素。 先进先出（First In ...
数据结构（三）--循环队列
sakurakider的博客
09-25 2357
循环队列的基本操作刚把数据结构里面的队列学习了一下，主要是对循环队列的基本操作进行了了解，主要是想明白，循环队列的循环是咋实现的，就好了，然后把入队和出队，判断是否是空，和判断是否为满的弄懂就搞清楚循环队列了。队列 如图所示，队列是一种可以实现“先进先出”的存储结构，哪一个节点元素先进来，它最先出去，然后如果想继续加入节点，就在队伍的最后面加入。 队列分为链式队列（用链表实现的）和静态队列（也就
循环队列-链表实现
iorange
05-16 2906
#include #include   typedef struct QNode {     int data;     struct QNode *next; }QNode,*QueuePtr;   typedef struct {     QueuePtr front;     QueuePtr rear; }LinkQueue;   //
单链表循环队列
Acceleration_的博客
04-28 4184
// // queue_.cpp // Cycle // // Created by ljpc on 2018/5/30. // Copyright © 2018年 ljpc. All rights reserved. // #include "queue_.h" void creatCycleQueue(CycleQueue* que) // 创建一个循环队列指针que { que->size_ = 0; que->rear = NULL; } bool is.
循环队列（链表、数组）
m0_65213200的博客
08-25 701
循环队列（数组、链表）
数据结构之循环队列
qq_39126213的博客
03-27 225
循环链表循环队列 循环队列 注意点：头尾指针的做出了调整，初始全部0，而单向队列为 -1 而且数组中的有一元素被空出来，来表示队列满的情况 class CircleQueneDiy { //队列的最大长度 private int maxSize; private int front; //这里和单项队列做出了一个调整，将头指针指向了队列收个元素的地址 p...
c语言中如何写一循环链表队列,C语言数据结构——线性表链式循环队列(链表实现方式)...
weixin_26833939的博客
05-21 396
队列相关知识及操作请参看上一章一、链式队列链式队列 ： 用链表形式实现的队列。链表结点为队列数据存储区，链表结点包括两部分数据存储区和指针存储区。数据存储区 ：存放真实有效数据的区域。指针存储区 ：存放下一个链表结点的地址。注意：1. 链式队列不存在队列已满的情况。在内存足够大的情况下，每次动态申请链表结点内存都会成功，即不会出现队列已满的情况，除非数据量超大内存不够。2. 链式队列只存在队列为空...
哈希表设计与实现——链表法
最新发布
05-10
哈希表是一种高效的数据结构，可以用来存储和查找键值对。其中，哈希函数将键映射到一个特定的桶中，每个桶中存储一组键值对。在哈希表中，如果两个键被映射到同一个桶中，就会发生碰撞。为了解决这个问题，可以使用链表法。 链表法是一种解决哈希表碰撞问题的方法。具体来说，对于哈希表中的每个桶，可以使用一个链表来存储所有映射到该桶的键值对。如果发生碰撞，只需要将新的键值对添加到链表的末尾即可。 下面是一个使用链表法实现哈希表的示例代码： ```python class Node: def __init__(self, key, value): self.key = key self.value = value self.next = None class HashTable: def __init__(self, capacity): self.capacity = capacity self.buckets = [None] * capacity def hash_function(self, key): return hash(key) % self.capacity def put(self, key, value): index = self.hash_function(key) node = self.buckets[index] while node: if node.key == key: node.value = value return node = node.next new_node = Node(key, value) new_node.next = self.buckets[index] self.buckets[index] = new_node def get(self, key): index = self.hash_function(key) node = self.buckets[index] while node: if node.key == key: return node.value node = node.next return None def remove(self, key): index = self.hash_function(key) node = self.buckets[index] prev = None while node: if node.key == key: if prev: prev.next = node.next else: self.buckets[index] = node.next return prev = node node = node.next ``` 在这个示例中，我们定义了一个Node类来表示哈希表中的每个节点，每个节点包含一个键、一个值和一个指向下一个节点的指针。我们还定义了一个HashTable类来实现哈希表，其中包含一个桶数组和一些基本的操作方法，如put、get和remove。 在put方法中，我们首先使用哈希函数计算出键的索引，然后遍历桶中的链表，查找该键是否已经存在于哈希表中。如果找到了该键，我们只需要更新其对应的值即可。否则，我们创建一个新的节点，并将其添加到链表的开头。 在get方法中，我们同样使用哈希函数计算出键的索引，然后遍历桶中的链表，查找该键的值。如果找到了该键，我们返回其对应的值。否则，返回None。 在remove方法中，我们首先使用哈希函数计算出键的索引，然后遍历桶中的链表，查找该键。如果找到了该键，我们将其从链表中删除即可。 总的来说，链表法是一种简单且常用的哈希表解决碰撞问题的方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值