链表

2024/4/20 1:36:07
数据结构学习笔记＜1＞ 线性表

数据结构学习笔记＜1＞ 线性表

目录一、线性表的抽象数据类型描述二、顺序表1.定义2.操作(1)创建空表(2)查找下标为K的元素(3)查找元素X(4)插入(5)删除(6)返回线性表的长度n3.完整代码演示三、线性表的链式存储1.定义2.操作(1)插入操作(2)查找1.按值查找:Find2.按序号查找：FindKth(3)删除操作(4)求…
阅读更多...
重排链表

重排链表

给定一个单链表 L 的头节点 head ，单链表 L 表示为： L0 → L1 → … → Ln-1 → Ln 。请将其重新排列后变为：L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 思路&…
阅读更多...
环形链表和寻找重复数

环形链表和寻找重复数

**环形链表**给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 struct ListNode *detectCycle(struct ListNode *head) {struct ListNode*fasthead;//定义快慢指针struct ListNode*slowhead;while(fast){//快指针走两步&#x…
阅读更多...
链表的逆序

链表的逆序

1）prev指针指向已经反转好的链表的最后一个节点，最开始没有反转，所以指向null 2）curr指针指向待反转链表的第一个节点，最开始第一个节点待反转，所以指向pHead 3）next指针指向待反转链表的第二个…
阅读更多...
判断链表是否有环

判断链表是否有环

判断给定的链表中是否有环。如果有环则返回true，否则返回false。 我们使用两个指针，quick 与 slow。 它们起始都位于链表的头部。随后，quick 指针每次向后移动一个位置，而slow指针向后移动两个位置。如果链表中存在环&#xff0c…
阅读更多...
PAT B1075 链表元素分类 (25 分)

PAT B1075 链表元素分类 (25 分)

这题可以开一个数组用来保存地址，然后遍历原来的链表三次，第一次找到所有负值结点的地址，第二次找到所有【0,k】区间值的结点，第三次找到所有大于k的结点，这样也可以保证所有保存的地址也是按照原来内部顺序排列的。 …
阅读更多...
java集合之List

java集合之List

写在前面 集合类是java语言对数据结构的实现 List接口介绍 java.util.List是有序的 collection（也称为序列），继承自Collection接口，是单列集合的一个重要分支。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户…
阅读更多...
【设备管理系统】-部署到正式环境

【设备管理系统】-部署到正式环境

后端比较简单，只有一个master分支，直接变更就行了。 前端比较麻烦一点，有2个分支，一个dev分支（测试环境），一个master分支（正式环境），而且两个分支的代码还不…
阅读更多...
LeetCode 剑指 Offer 18. 删除链表的节点

LeetCode 剑指 Offer 18. 删除链表的节点

原题目：https://leetcode-cn.com/problems/shan-chu-lian-biao-de-jie-dian-lcof/ 代码： class Solution { public:ListNode* deleteNode(ListNode* head, int val) {if(head NULL) return head;ListNode* hairnew ListNode(0),*pre;hair->next he…
阅读更多...
c语言中实现循环单链表

c语言中实现循环单链表

循环单链表与单链表的区别就是循环单链表的首节点和尾节点是相连的。 c语言构建循环单链表： //生成结构体： typedef struct node { int member; struct node *next; }*linklist; //创建链表并初始化值 linklist create_list() { linklist h…
阅读更多...
算法与数据体系课笔记之- 9.2链表相关题目（进行中）

算法与数据体系课笔记之- 9.2链表相关题目（进行中）

目录9.链表相关题目分析 总览笔记思维导图链接常见题目汇总：1. 求链表中间节点题意：题解：代码实现：代码测试：复杂度分析：2. 回文链表题目链接题意：题解：代码实现：复杂度分…
阅读更多...
基础算法系列 之单链表

基础算法系列 之单链表

单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素，每个结点的构成：元素 指针。其代码如下： public class Node{int data;Node next;public Node(int data){this.datadata;}public void *append*…
阅读更多...
c语言-用数组模拟 --实现顺序表的-增，删，改，查

c语言-用数组模拟 --实现顺序表的-增，删，改，查

#include <stdio.h> #include <malloc.h> /*采用数组模拟线性表*/ #define MAXSIZE 20 typedef struct LNode * List;//定义一个指向LNode结构的指针 struct LNode{int Data[MAXSIZE];//创建一个int类型的数组 int Last;//指向数组最后一个元素的下标,最后一个元素…
阅读更多...
第二章算法设计3

第二章算法设计3

第二章算法设计3 题目描述 已知两个链表A和B分别表示两个集合&#xff0c;其元素递增排列。请设计算法求出A与B的交集&#xff0c;并存放于A链表中。 代码实现 #pragma once #include <iostream> #include<string> #define MAXSIZE 100using namespace std;//单…
阅读更多...
第三章算法设计题8

第三章算法设计题8

第三章算法设计题8 题目描述 我的思路 代码实现 #pragma once #include <iostream> using namespace std;#define MAXSIZE 10//顺序队类型定义 typedef struct {int *base;int front;// 队首指针int rear;// 队尾指针 } SqQueue;//初始化队列 void initQueue(SqQueue&a…
阅读更多...
第四章算法设计题1

第四章算法设计题1

第四章算法设计题1 题目描述 注意&#xff1a;C里面数字&#xff08;字母&#xff09;字符与数字之间的相互转换 代码实现 #pragma once #include <iostream>using namespace std;void count() {//创建频度数组 并初始化全为0int times[36] { 0 };//输入的字符char …
阅读更多...
C++ 数据结构——双链表

C++ 数据结构——双链表

/*双链表的实现*/ #include <iostream> using namespace std; template<typename T> struct DNode {T data; //数据域DNode<T> *piror,*next; //指针域 前驱 后继 }; template<typename T> class LinkList { private:DNode&…
阅读更多...
数据结构——线性表知识点总结

数据结构——线性表知识点总结

理论 线性表是一种最简单&#xff0c;最基本的数据结构用来描述数据元素之间单一的前去和后继关系。所有二维表的逻辑结构都是线性的。线性表的顺序存储结构称为顺序表&#xff0c;其基本思想是用一段连续的存储单元依次存储线性表的数据元素。只要确定了存储顺序表的起始位置…
阅读更多...
1月12日学习总结

1月12日学习总结

上午写了一下删除链表中重复元素&#xff0c;不知道为什么输出不了结果 对循环链表进行元素的删除和增加&#xff0c;构建循环链表就是将链表的末指针指向头指针 题目描述 构建一个双向链表并进行删除和插入操作&#xff0c;按要求输出。输入格式 输入&#xff1a; 第一行输入…
阅读更多...
Leetcode202.快乐数（C++,哈希集合，快慢指针）

Leetcode202.快乐数（C++,哈希集合，快慢指针）

Leetcode202.快乐数&#xff08;C,哈希集合&#xff0c;快慢指针&#xff09;题目示例知识点思路代码题目 编写一个算法来判断一个数 n 是不是快乐数。 「快乐数」 定义为&#xff1a; 对于一个正整数&#xff0c;每一次将该数替换为它每个位置上的数字的平方和。 然后重复这…
阅读更多...
【Java】链表的中间结点

【Java】链表的中间结点

&#x1f388;目录&#x1f388; 问题描述&#x1f512; 解题分析&#x1f511; 代码实现&#x1f513; 题目入口&#x1f4cc;&#xff1a;链表的中间结点 问题描述 给定一个头结点为 head 的非空单链表&#xff0c;返回链表的中间结点。 如果有两个中间结点&#xff0c;则…
阅读更多...
Leetcode-每日一题【382.链表随机结点】

Leetcode-每日一题【382.链表随机结点】

题目 给你一个单链表,随机选择链表的一个节点,并返回相应的节点值。每个节点被选中的概率一样 。 实现 Solution 类&#xff1a; Solution(ListNode head) 使用整数数组初始化对象。int getRandom() 从链表中随机选择一个节点并返回该节点的值。链表中所有节点被选中的概率相…
阅读更多...
C++中的list的函数

C++中的list的函数

List 小结 结构体函数： 无参数的： list <type> l ; 就是新建一个空的链表1个参数的： list <type> l ( n ) ; 就是建立一个有n个元素的 链表，这些元素的值都是默认的 list <type> l ( t ) // t是个list <type> ; 就是建立一个和t一模一样的链表…
阅读更多...
PAT乙级真题 1025 反转链表 C++实现

PAT乙级真题 1025 反转链表 C++实现

题目 给定一个常数 K 以及一个单链表 L&#xff0c;请编写程序将 L 中每 K 个结点反转。例如&#xff1a;给定 L 为 1→2→3→4→5→6&#xff0c;K 为 3&#xff0c;则输出应该为 3→2→1→6→5→4&#xff1b;如果 K 为 4&#xff0c;则输出应该为 4→3→2→1→5→6&#xff…
阅读更多...
PAT甲级真题 1074 Reversing Linked List (25分) C++实现（模拟反转链表）

PAT甲级真题 1074 Reversing Linked List (25分) C++实现（模拟反转链表）

题目 Given a constant K and a singly linked list L, you are supposed to reverse the links of every K elements on L. For example, given L being 1→2→3→4→5→6, if K3, then you must output 3→2→1→6→5→4; if K4, you must output 4→3→2→1→5→6. Input …
阅读更多...
leetcode[142]环形链表 II Python3实现（快慢指针寻找链表环入口）

leetcode[142]环形链表 II Python3实现（快慢指针寻找链表环入口）

# 给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 # # 为了表示给定链表中的环&#xff0c;我们使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;索引从 0 开始&#xff09;。 如果 pos 是 -1&#xff0c;则在该链…
阅读更多...
leetcode[203]移除链表元素 Java实现（注意移动node.next的时机，易错）

leetcode[203]移除链表元素 Java实现（注意移动node.next的时机，易错）

//给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 // // // 示例 1&#xff1a; // // //输入&#xff1a;head [1,2,6,3,4,5,6], val 6 //输出&#xff1a;[1,2,3,4,5] // // // …
阅读更多...
java当中的集合类或集合框架

java当中的集合类或集合框架

collection接口是集合类的顶层接口,collections是工具类 collection有两个子接口,一个list接口,一个是set接口 list接口有序可重复,set接口无序不可重复 list接口常用的实现类有 arrayList 基于数组实现的 linkedList 基于链表实现的 区别参考数组和链表区别 vector 基于数组实…
阅读更多...
java之数据结构【入门篇】

java之数据结构【入门篇】

定义 数据结构是指相互之间存在着一种或多种关系的数据元素的集合 。 常见的数据结构 数据存储的常用结构有数组&#xff0c;栈&#xff0c;队列&#xff0c;链表&#xff0c;树&#xff0c;图&#xff0c;堆&#xff0c;散列表等&#xff0c;如下图所示。 数组&#xff0…
阅读更多...
【备品备件】入库流程--赠品入库，商贸入库和退库入库

【备品备件】入库流程--赠品入库，商贸入库和退库入库

赠品入库 前台页面&#xff1a;GiftsWarehousing.vue 方法&#xff1a;listZprk 前台js文件&#xff1a;zprk.js 查询方法对应的后台类&#xff1a;SpareZprkController 查询参数&#xff1a;ZZPJH 查询方法对应的SQL语句&#xff1a; select ZZPJH, BUKRS, WERKS, CGHTH,…
阅读更多...
LeetCode 328. 奇偶链表

LeetCode 328. 奇偶链表

原题目&#xff1a;https://leetcode-cn.com/problems/odd-even-linked-list/ 代码&#xff1a; class Solution { public:ListNode* oddEvenList(ListNode* head) {if(headNULL) return head;ListNode*p,*q,*t;p head;qhead;while(q->next&&q->next->next)…
阅读更多...
哈希表的JAVA实现（HashTable）

哈希表的JAVA实现（HashTable）

Google面试问题描述 有一个公司, 当有新员工报道的时候, 要求将该员工的信息保存(id, 姓名, 年龄, 住址等), 当输入该员工的的id时, 要求查找该员工的所有信息。 注: 不要使用数据库, 尽量节省内存, 速度越快越好 思路分析 不让使用数据库, 越快越好, 我们选择哈希表 使用链…
阅读更多...
java 合并有序链表

java 合并有序链表

牛客题目链接 1. 题目考点 哑结点原地重建单链表归并排序 2. 考点解析 普通遍历方式 public ListNode mergeTwoLists (ListNode l1, ListNode l2) {// write code hereif (l1 null) return l2;if (l2 null) return l1;ListNode dummy new ListNode(0);ListNode r dumm…
阅读更多...
链表经典练习题合集2（Java版）

链表经典练习题合集2（Java版）

本篇主要为leetcode上链表部分中等及困难难度练习题&#xff0c;链表部分的习题画图十分重要&#xff0c;只要链表结构画出来&#xff0c;再写代码解决问题就容易很多。做完这些难度高的习题后发现&#xff0c;其实中等难度的习题只是将两个甚至三个以上的知识点融汇到一个题目…
阅读更多...
剑指offer删除链表中重复的节点

剑指offer删除链表中重复的节点

由题可知链表是排好序的&#xff0c;且重复的节点不做保留。 我们肯定是需要遍历链表的&#xff0c;所以cur必不可少&#xff08;curhead&#xff09;&#xff0c;在原有链表进行操作的话有点复杂&#xff0c;所以接下来我们可以new一个新节点newHead用来接收数据。然后我们遍历…
阅读更多...
剑指Offer链表分割

剑指Offer链表分割

题目描述 现有一链表的头指针 ListNode* pHead&#xff0c;给一定值x&#xff0c;编写一段代码将所有小于x的结点排在其余结点之前&#xff0c;且不能改变原来的数据顺序&#xff0c;返回重新排列后的链表的头指针。 分析 可以新new两个节点&#xff0c;一个连接比x值小的节点…
阅读更多...
lc24. 两两交换链表中的节点

lc24. 两两交换链表中的节点

思路一&#xff1a;常规做法&#xff0c;两个指针&#xff0c;一个记录当前的&#xff0c;一个记录下一个的&#xff0c;依次遍历即可 思路二&#xff1a;递归&#xff0c;这个也是同样的思路&#xff0c;但是递归的时候&#xff0c;一次需要移动两个位置 代码如下&#xff1…
阅读更多...
一文读懂移除链表元素

一文读懂移除链表元素

目录 创建链表 删除链表元素 结果 leetcode链接 创建链表 属性 int valListNode next 构造器 无参构造有参构造 重写toSting方法 静态方法打印链表 public class ListNode {int val;ListNode next;ListNode() {}ListNode(int val) {this.val val;}ListNode(int val, …
阅读更多...
算法之合并多个有序链表

算法之合并多个有序链表

两个有序数组&#xff0c;合并为一个链表&#xff0c;并且合并后仍然有序 自定义链表结构如下 public class Node {Node head;Node next;Integer val;public Node (Integer node){val node;}public static void list(Node node){Node next node;while (next ! null){System…
阅读更多...
【五月集训5.12】———链表

【五月集训5.12】———链表

☘前言☘ 开更五月集训专题&#xff0c;由浅入深&#xff0c;深入浅出&#xff0c;飞向大厂&#xff01; &#x1f9d1;&#x1f3fb;作者简介&#xff1a;一个从工业设计改行学嵌入式的年轻人 ✨联系方式&#xff1a;2201891280(QQ) ⏳全文大约阅读时间&#xff1a; 20min 全…
阅读更多...
【五月集训5.13】———双向链表

【五月集训5.13】———双向链表

☘前言☘ 开更五月集训专题&#xff0c;由浅入深&#xff0c;深入浅出&#xff0c;飞向大厂&#xff01; &#x1f9d1;&#x1f3fb;作者简介&#xff1a;一个从工业设计改行学嵌入式的年轻人 ✨联系方式&#xff1a;2201891280(QQ) ⏳全文大约阅读时间&#xff1a; 20min 全…
阅读更多...
删除倒数第 N 个节点

删除倒数第 N 个节点

给定单向链表&#xff0c;删除指定的倒数第 N 个节点。 需要考虑链表长度大于、小于 N&#xff0c;假设 N 是有效的整数。 package com.loo; public class RemoveNthFromEnd { public static void main(String[] args) { Node head new Node(1); Node n1 n…
阅读更多...
4.3 设计链表

4.3 设计链表

707 设计链表题目在链表类中实现这些功能&#xff1a;get(index)&#xff1a;获取链表中第 index 个节点的值。如果索引无效&#xff0c;则返回-1。addAtHead(val)&#xff1a;在链表的第一个元素之前添加一个值为 val 的节点。插入后&#xff0c;新节点将成为链表的第一个节点…
阅读更多...
PTA 1052 Linked List Sorting

PTA 1052 Linked List Sorting

题目描述 分析&#xff1a; 首先先找出这条链表中存在的结点&#xff0c;也就是有效结点&#xff0c;利用flag判断结点是否有效&#xff0c;完后对结点进行排序&#xff0c;排序函数首先判断flag的值&#xff0c;按flag从大到小排序即把有效结点排在前面&#xff0c;完后按数据…
阅读更多...
数据仓库拉链表

数据仓库拉链表

转载&#xff1a;http://itindex.net/detail/56925-%E6%95%B0%E6%8D%AE%E4%BB%93%E5%BA%93-%E6%8B%89%E9%93%BE-%E5%8E%9F%E7%90%86
阅读更多...
C语言练习——双链表下学生成绩管理系统

C语言练习——双链表下学生成绩管理系统

双链表实现学生成绩管理系统学生和班级结构体初始化学生&#xff1a;班级&#xff1a;学生链表创建&#xff08;这里以尾插法为例子&#xff01;&#xff09;&#xff1a;班级链表创建&#xff1a;输入数据到链表中&#xff1a;求班级里头最高分&#xff1a;求班级里头最低分&a…
阅读更多...
LeetCode50天刷题计划第二季（Day 20 — 复制带随机指针的链表（12.00-12.30 ）

LeetCode50天刷题计划第二季（Day 20 — 复制带随机指针的链表（12.00-12.30 ）

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录前言一、题目复制带随机指针的链表示例提示二、思路三、代码前言 芜湖 学习第一天~ 一、题目 复制带随机指针的链表 给你一个长度为 n 的链表&#xff0c;每个节…
阅读更多...
LeetCode50天刷题计划（Day 16—— 两两交换链表中的节点（9.10-10.30）

LeetCode50天刷题计划（Day 16—— 两两交换链表中的节点（9.10-10.30）

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录前言一、题目两两交换链表中的节点示例提示二、思路三、代码前言 简单的链表题&#xff0c;但是不能小看&#xff0c;要细心的&#xff0c;不然就是无穷的debugQAQ …
阅读更多...
qml的focus问题

qml的focus问题

这是应用中令人头痛的焦点问题。 如果没有焦点项&#xff0c;键事件就不能被处理&#xff0c;它就不能在一个屏幕中做任何事情——应用程序会挂起!! 基本上&#xff0c;qml中的基本元素是“item”。 item有两个属性&#xff0c;焦点和活动焦点。 activeFocus是只读的&#xf…
阅读更多...
字节二面，让写一个LFU缓存策略算法，懵了

字节二面，让写一个LFU缓存策略算法，懵了

点击上方 果汁简历 &#xff0c;选择“置顶公众号” 优质文章&#xff0c;第一时间送达LRU全称 "Least Recently Used"&#xff0c;最近最少使用策略&#xff0c;判断最近被使用的时间&#xff0c;距离目前最远的数据优先被淘汰&#xff0c;作为一种根据访问时间来更…
阅读更多...
LinkHashMap分析，Link体现在哪里？如何实现

LinkHashMap分析，Link体现在哪里？如何实现

linkHashMap分析 1. link体现在哪里&#xff1f; LinkHashmap继承与HashMap。重写了其中的几个方法。并且在hashMap的基础上维护了一个双向列表。用于连接所有的实体&#xff0c;链表连接的顺序通常来说是插入的顺序&#xff0c;注意这里说的是通常&#xff0c;也是可以改变的…
阅读更多...
SDUT-2122 数据结构实验之链表七：单链表中重复元素的删除

SDUT-2122 数据结构实验之链表七：单链表中重复元素的删除

数据结构实验之链表七&#xff1a;单链表中重复元素的删除Time Limit: 1000MS Memory Limit: 65536KBSubmit StatisticProblem Description按照数据输入的相反顺序&#xff08;逆位序&#xff09;建立一个单链表&#xff0c;并将单链表中重复的元素删除&#xff08;值相同的元素…
阅读更多...
SDUT-2054 数据结构实验之链表九：双向链表

SDUT-2054 数据结构实验之链表九：双向链表

数据结构实验之链表九&#xff1a;双向链表Time Limit: 1000MS Memory Limit: 65536KBProblem Description学会了单向链表&#xff0c;我们又多了一种解决问题的能力&#xff0c;单链表利用一个指针就能在内存中找到下一个位置&#xff0c;这是一个不会轻易断裂的链。但单链表有…
阅读更多...
SDUT-1197 约瑟夫问题

SDUT-1197 约瑟夫问题

约瑟夫问题Time Limit: 1000MS Memory Limit: 65536KBSubmit Statistic DiscussProblem Descriptionn个人想玩残酷的死亡游戏&#xff0c;游戏规则如下&#xff1a; n个人进行编号&#xff0c;分别从1到n&#xff0c;排成一个圈&#xff0c;顺时针从1开始数到m&#xff0c;数到…
阅读更多...
双指针解题思路

双指针解题思路

指针的解题思路一般分为三类&#xff1a; 1.首尾指针&#xff1a;范围查找&#xff0c;比如二分搜索等 滑动窗口&#xff1a;指针处在数组同一方向&#xff0c;根据条件移动左右指针&#xff0c;用于获取范围和等 快慢指针&#xff1a; 多用于链表计算时&#xff0c;判断是否…
阅读更多...
题100.2021秋周练习-2-1 Add Two Polynomials (20 分)

题100.2021秋周练习-2-1 Add Two Polynomials (20 分)

文章目录题100.2021秋周练习-2-1 Add Two Polynomials (20 分)一、题目二、题解题100.2021秋周练习-2-1 Add Two Polynomials (20 分) 一、题目 二、题解 本题要注意的是1.该链表带假的头节点2.当结果多项式的单项式系数为0时&#xff0c;该单项式不能接入结果链表中&#xff0…
阅读更多...
leetcode笔记总结——（15）面试题：链表相交（python编写）

leetcode笔记总结——（15）面试题：链表相交（python编写）

力扣题目链接 目录1、题目描述&#xff1a;2、实现思路&#xff1a;3、代码描述&#xff08;python&#xff09;&#xff1a;1、题目描述&#xff1a; 2、实现思路&#xff1a; A长度为 a, B长度为b&#xff0c; 假设存在交叉点&#xff0c;此时 A到交叉点距离为 c&#xff0c;…
阅读更多...
6.两两交换链表中的节点

6.两两交换链表中的节点

题目&#xff1a; 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 解题思路&#xff08;迭代&#xff09;&#xff1a; 利用迭…
阅读更多...
结构体类型数据的动态存储分配和链表及其基本操作

结构体类型数据的动态存储分配和链表及其基本操作

1.结构体类型数据的动态存储分配 一.前言 c语言提供了一些内存管理函数&#xff0c;用于动态分配内存空间&#xff08;堆区&#xff09;.可以根据需要开辟内存的单元,在程序执行时&#xff0c;需要多少空间就分配多少内存空间&#xff0c;且当空间不再使用还可以释放 二.关于…
阅读更多...
力扣:合并K个升序链表(超简单题解)

力扣:合并K个升序链表(超简单题解)

合并K个升序链表 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 示例 1&#xff1a; 输入&#xff1a;lists [[1,4,5],[1,3,4],[2,6]] 输出&#xff1a;[1,1,2,3,4,4,5,6] 解释&#xff1a;链表…
阅读更多...
Golang-无限缓存channel的设计与实现

Golang-无限缓存channel的设计与实现

无限缓存channel的设计与实现 一.引言 Go语言的Channel有两种类型&#xff0c;一种是无缓存的channle&#xff0c;一个种是有缓存的channel&#xff0c;但是对于有缓存的channle来说&#xff0c;其缓存长度在创建时就已经固定了&#xff0c;中间也不能扩缩容&#xff0c;这导致…
阅读更多...
【LeetCode】LRU缓存

【LeetCode】LRU缓存

LRU缓存 题目链接&#xff1a;https://leetcode-cn.com/problems/lru-cache/ 双向链表map map用来确定链表中是否存在此key的节点 双向链表用来实际存储 每次get&#xff0c;都把get的节点放到链表头部 每次put&#xff0c;两种情况 key存在&#xff0c;更新value&#xff0c;此…
阅读更多...
LeetCode链表

LeetCode链表

文章目录链表两数相加[237. 删除链表中的节点 - 力扣&#xff08;LeetCode&#xff09;](https://leetcode-cn.com/problems/delete-node-in-a-linked-list/)删除链表的倒数第N个节点合并有序链表合并k个升序链表反转链表反转链表II删除元素删除元素II[203. 移除链表元素 - 力扣…
阅读更多...
学习笔记-哈希表（散列）

学习笔记-哈希表（散列）

哈希表&#xff08;散列&#xff09; 解决一个问题&#xff1a; 有一个公司,当有新的员工来报道时,要求将该员工的信息加入(id,性别,年龄,住址…),当输入该员工的 id 时,要求查找到该员工的所有信息. 要求: 不使用数据库,尽量节省内存,速度越快越好>哈希表(散列&#xff09…
阅读更多...
删除有序链表中的重复结点

删除有序链表中的重复结点

#删除有序链表中的重复结点 class Solution:def deleteDuplicates(self,head):if headNone or head.nextNone:return headcurheadwhile cur.next!None:if cur.valcur.next.val:cur.nextcur.next.nextelse:curcur.nextreturn head
阅读更多...
python链表逆序反转(如head-＞1-＞2-＞3-＞4-＞5-＞6反转后为head-＞6-＞5-＞4-＞3-＞2-＞1)

python链表逆序反转(如head-＞1-＞2-＞3-＞4-＞5-＞6反转后为head-＞6-＞5-＞4-＞3-＞2-＞1)

#链表逆序反转(如head->1->2->3->4->5->6反转后为head->6->5->4->3->2->1) class Node:def __init__(self,valueNone,nextNone):self.valuevalueself.nextnextdef reverse(head):curhead #初始化当前结点为头结点preNonewhile cur!None:te…
阅读更多...
LeetCode:从尾到头打印链表(python)

LeetCode:从尾到头打印链表(python)

def Reverselink(arr):return arr[::-1]if __name____main__:headlist(map(int,input().strip().split()))print(Reverselink(head))
阅读更多...
如何判断链表有环的三种解法(Python)

如何判断链表有环的三种解法(Python)

一、问题描述 二、解题思路 三、最优解的代码实现 一、问题描述 有一个单向链表&#xff0c;链表中有可能出现环&#xff0c;如何判断链表是否有环&#xff1f; 二、解题思路 方法一&#xff1a; 首先从头节点开始&#xff0c;依次遍历单链表中的每一个节点。每遍历一个新节…
阅读更多...
利用Python实现链表

利用Python实现链表

class Node:相当于C语言中的结构体&#xff0c;定义了一个结点类型def __init__(self,data):self.datadataself.nextNone # 初始化为None&#xff0c;如果后面不赋新值则一直为Noneclass LinkedList:__init__(self):属于类的构造函数或者初始化方法&#xff0c;每当创建一个这种…
阅读更多...
【力扣面试】面试题 04.03. 特定深度节点链表

【力扣面试】面试题 04.03. 特定深度节点链表

【力扣面试】面试题 04.03. 特定深度节点链表 文章目录题目解题思路代码题目 给定一棵二叉树&#xff0c;设计一个算法&#xff0c;创建含有某一深度上所有节点的链表&#xff08;比如&#xff0c;若一棵树的深度为 D&#xff0c;则会创建出 D 个链表&#xff09;。返回一个包…
阅读更多...
Leetcode206反转链表

Leetcode206反转链表

还是之前说的链表的题画图就完事了&#xff0c;重点考虑头、尾、和中间即可。 第一种方法 我们可以采用三指针来解决这个问题。 我们定义三个引用&#xff0c;cur表示当前节点&#xff08;从head开始curhead&#xff09;&#xff0c;prev表示当前节点的前驱&#xff08;最开始…
阅读更多...
链表实例

链表实例

下图为最一简单链表的示意图&#xff1a; 第 0 个结点称为头结点&#xff0c;它存放有第一个结点的首地址&#xff0c;它没有数据&#xff0c;只是一个指针变量。以下的每个结点都分为两个域&#xff0c;一个是数据域&#xff0c;存放各种实际的数据&#xff0c;如学号 num&a…
阅读更多...
链表回文（牛客网：OR36 链表的回文结构）

链表回文（牛客网：OR36 链表的回文结构）

目录 前言 一&#xff0c;题目分析 1.1什么是回文 1.2题目分析 二&#xff0c;解题思路 情况一&#xff1a; 情况二: tips&#xff1a; 三&#xff0c;源码分享 前言 小伙伴们大家好啊&#xff01;今天我们为大家带来一篇有关判断链表回文的文章。大家一旦想到回文&am…
阅读更多...
计蒜客-A1003-合并两个飞有序的链表（C++vector实现）

计蒜客-A1003-合并两个飞有序的链表（C++vector实现）

本题测试用例比较坑&#xff0c;一开始我是按照两两按照序号对比&#xff0c;然后每次添加两个&#xff0c;发现过不了&#xff0c;然后就看了一下网上大神写的&#xff0c;发现应该是如果第一个小于等于第二个数&#xff0c;那么第一个指针偏移&#xff0c;只能说明用例不清楚…
阅读更多...
Day_14 ArrayList集合的底层原理

Day_14 ArrayList集合的底层原理

文章目录ArrayList集合的底层原理ArrayList集合的底层源码分析数据结构栈和队列数组和链表数组单向链表结构双向链表结构Set集合HashSet集合哈希表HashSet集合去重原理ArrayList集合的底层原理 1. 当创建ArrayList集合的时候,代码底层会创建一个长度为0的数组ArrayList<E&g…
阅读更多...
C语言课程设计————学生成绩管理系统

C语言课程设计————学生成绩管理系统

有帮别人做课程设计&#xff0c;做课程管理&#xff0c;电影管理&#xff0c;成绩管理&#xff0c;学生信息管理之类的&#xff0c;然后&#xff0c;打算上传学生成绩管理系统给需要的人&#xff0c;有需要可以自己下载提取&#xff0c;定制私信我 部分代码 int main() {int …
阅读更多...
java - HashMap 源码阅读 - 笔记

java - HashMap 源码阅读 - 笔记

创建一个dome public static void main(String[] args) {Map<String, String> map new HashMap<>(); // 初始化里面的table&#xff0c;当插入一个元素的时候&#xff0c;扩容为16 map.put("数据1", "数据1 1");map.put("数据1",…
阅读更多...
【剑指 Offer】 25. 合并两个排序的链表

【剑指 Offer】 25. 合并两个排序的链表

1、题目描述 输入两个递增排序的链表&#xff0c;合并这两个链表并使新链表中的节点仍然是递增排序的 2、算法思想 1、首先新创一个链表&#xff0c;用来存储两个链表合并后的样子 2、再创建一个新的指针指向新链表 3、判断两个链表的大小&#xff0c;如果l1大&#xff0c;把l2…
阅读更多...
【指针】深度剖析

【指针】深度剖析

1.一维数组 int a[] {1,2,3,4}; printf("%d\n",sizeof(a));//16 整个数组的大小 printf("%d\n",sizeof(a0));//4 第一个元素的地址 printf("%d\n",sizeof(*a));//4 第一个元素 printf("%d\n",sizeof(a1));//4 第二…
阅读更多...
【atoi】模拟实现atoi函数，将字符串转化为数字

【atoi】模拟实现atoi函数，将字符串转化为数字

1.目的 编码实现函数atoi()&#xff0c;把一个字符串转化为一个整型数值 例如&#xff08;“12345”转化成12345&#xff09; 2.避坑 避免一下几种坑没有考虑到 1.字符串有没有正负号问题&#xff1b; 2.字符串里夹杂着各种字母或是异常字符的情况; 3.考虑字符串转化成int 整型…
阅读更多...
【数据结构】带头节点的双向循环链表基本操作

【数据结构】带头节点的双向循环链表基本操作

目的 实现双向循环带头节点的链表的增删改查 创建返回链表头节点 // 创建返回链表的头结点. ListNode* ListCreate() {ListNode *head (ListNode*)malloc(sizeof(ListNode));head->next head;head->prev head;return head; }双向链表的销毁 // 双向链表销毁 void Li…
阅读更多...
C++队列的基本用法

C++队列的基本用法

PS.更多数据结构知识详见&#xff1a; 八大数据结构 C队列的用法 队列的数据结构 ADT 队列&#xff08;Queue&#xff09; Data同线性表。具有相同的数据类型&#xff0c;相邻的元素存在前驱和后继关系 OpreationInitQueue(): 初始化一个空的队列DestoryQueue(): 销毁…
阅读更多...
利用虚拟头节点删除链表中的元素

利用虚拟头节点删除链表中的元素

移除链表元素 删除链表中等于给定值 val 的所有节点。 示例: 输入: 1->2->6->3->4->5->6, val 6 输出: 1->2->3->4->5 思路&#xff1a;添加一个虚拟的头节点&#xff0c;这样即便原来的头节点是要删除的节点也可以和非头节点一样删除&#x…
阅读更多...
[数据结构与算法] - 快速排序

[数据结构与算法] - 快速排序

目录快速排序&#xff1a;性能&#xff1a;优化&#xff1a;动态演示&#xff1a;方法&#xff1a;版本1&#xff1a;hoare法版本2&#xff1a;挖坑法版本3&#xff1a;前后指针法总代码&#xff1a;递归版本&#xff1a;非递归版本&#xff1a;快速排序&#xff1a; 基本思想…
阅读更多...
[牛客] - OR36 链表的回文结构

[牛客] - OR36 链表的回文结构

题目链接 题目&#xff1a; 对于一个链表&#xff0c;请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法&#xff0c;判断其是否为回文结构。 给定一个链表的头指针A&#xff0c;请返回一个bool值&#xff0c;代表其是否为回文结构。保证链表长度小于等于900。 过程&am…
阅读更多...
Java实现队列数据结构

Java实现队列数据结构

文章目录队列的基本概念循环队列实现思路代码实现测试队列的基本概念 什么是队列 队列是一种特殊的线性表它只允许在表的前端&#xff08;队头&#xff09;进行删除操作 在表的后端&#xff08;队尾&#xff09;进行插入操作队列是一个有序表(可以用数组或链表实现)队列先进先出…
阅读更多...
线性表的合并

线性表的合并

线性表的应用 线性表的合并 问题描述&#xff1a; 假设利用两个线性表La和Lb表示两个集合A和B&#xff0c;现要求一个新的集合AA∪B 即&#xff1a; La(7,5,3,11) Lb(2,6,3) A(7,8,3,11,2,6) 算法步骤&#xff08;A既是参数&#xff0c;也是操作的结果&#xff09; 依次…
阅读更多...
链表（6）----查找链表中间节点

链表（6）----查找链表中间节点

1、链表定义 typedef struct ListElement_t_ {void *data;struct ListElement_t_ *next; } ListElement_t;typedef struct List_t_{int size;int capacity;ListElement_t *head;ListElement_t *tail; } List_t;2、查找链表中间节点&#xff0c;设置快慢指针&#xff0c;快指针一…
阅读更多...
链表（10）----判断两个单链表是否相交

链表（10）----判断两个单链表是否相交

1、链表定义 typedef struct ListElement_t_ {void *data;struct ListElement_t_ *next; } ListElement_t;typedef struct List_t_{int size;int capacity;ListElement_t *head;ListElement_t *tail; } List_t; 2、判断两个单链表是否相交&#xff0c;关键判断两个单链表最后节…
阅读更多...
链表（11）----求相交链表的第一个交点

链表（11）----求相交链表的第一个交点

1、链表定义 typedef struct ListElement_t_ {void *data;struct ListElement_t_ *next; } ListElement_t;typedef struct List_t_{int size;int capacity;ListElement_t *head;ListElement_t *tail; } List_t;2、判断两个链表是否相交&#xff0c;如果相交则求第一个交点 List…
阅读更多...
链表（15）----给定链表中间某个节点，将待插入节点插入给定节点之前

链表（15）----给定链表中间某个节点，将待插入节点插入给定节点之前

1、 链表定义 typedef struct ListElement_t_ {void *data;struct ListElement_t_ *next; } ListElement_t;typedef struct List_t_{int size;int capacity;ListElement_t *head;ListElement_t *tail; } List_t;2、给定链表中间某个节点&#xff0c;将待插入节点插入给定节点之…
阅读更多...
链表（16）----删除链表重复元素

链表（16）----删除链表重复元素

其他相关题目下面以超链接形式给出&#xff1a; 链表面试题合集 1、单链表基本操作 2、双链表基本操作 3、循环单链表基本操作 4、反转单链表 5、查找单链表倒数第K个节点 6、倒序打印链表 7、查找链表中间节点 8、删除链表第K个节点&#xff0c;平均时间复杂度为O(1) …
阅读更多...
每日一题：8. 删除链表中的节点（C++）

每日一题：8. 删除链表中的节点（C++）

每日一题&#xff1a;8. 删除链表中的节点&#xff08;C&#xff09; 题目&#xff1a; 请编写一个函数&#xff0c;用于 删除单链表中某个特定节点 。在设计函数时需要注意&#xff0c;你无法访问链表的头节点 head &#xff0c;只能直接访问 要被删除的节点 。 题目数据保证…
阅读更多...
【力扣】C语言实现反转链表

【力扣】C语言实现反转链表

目录 一、目的 二、方法 方法一&#xff1a;分隔头插 方法二&#xff1a;逆转箭头 一、目的 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1] 二、方法 方法一&#x…
阅读更多...
【链表】带头节点和不带头节点单链表的区别

【链表】带头节点和不带头节点单链表的区别

目录 &#x1f354;当链表的结点只包含一个指针域时&#xff0c;叫做单链表 &#x1f354;不论带不带头节点&#xff0c;所有的链表都要有个头指针&#xff01; &#x1f35f;带头结点的链表的头指针指向的是头结点&#xff0c;头结点的指针域指向首元结点 &#x1f35f;不带…
阅读更多...
【第二节】线性表--链表

【第二节】线性表--链表

&#x1f354;链表许多结构 单链表&#xff0c;单循环链表&#xff0c;双链表&#xff0c;双循环链表&#xff0c;带头节点的单链表&#xff0c;不带头节点的双向链表...... 1.线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素&#xff08;这组存储单元…
阅读更多...
栈Stack 和 队列Queue 的实现 ( 用顺序表链表实现 )

栈Stack 和 队列Queue 的实现 ( 用顺序表链表实现 )

1 栈的实现&#xff1a;1.1 顺序表实现栈&#xff1a;1.2 链表实现栈&#xff1a;2 队列的实现&#xff1a;2.1 顺序表实现队列&#xff1a;2.2 链表实现队列&#xff1a;3 标准库中的 Stack / Queue栈&#xff1a;后进先出 队列&#xff1a;先进先出 更复杂的队列&#xff1a;…
阅读更多...
LeetCode刷题 #141 环形链表 ( 快慢指针判断链表中是否带环 )

LeetCode刷题 #141 环形链表 ( 快慢指针判断链表中是否带环 )

给定一个链表判断链表中是否有带环。如果链表中存在环&#xff0c;则返回 true&#xff0c;否则返回 false。   题目中为了表示链表中的环&#xff0c;我们使用 pos 来表示链表尾连接到链表中的位置&#xff08;索引从 0 开始&#xff09;。如果 pos 是 -1&#xff0c;则在该…
阅读更多...
数据结构 单链表的回文结构

数据结构 单链表的回文结构

链表的回文结构&#xff0c;即 1 --> 2 --> 3 --> 2 --> 1 这样的形式&#xff0c;链表正着和反过来是一样的。 1 时间复杂度 O(N) 思路&#xff1a; 1、将原链表进行拷贝&#xff1b; 2、对拷贝的链表进行逆置&#xff1b; 3、然后比较逆置之后的链表和原链表是…
阅读更多...
LeetCode刷题 #206 反转链表 Java

LeetCode刷题 #206 反转链表 Java

题目&#xff1a; 反转一个单链表。 示例&#xff1a; 输入&#xff1a;1 ->2 ->3 ->4 ->5 -> NULL 输出&#xff1a;5 ->4 ->3 ->2 ->1 -> NULL 思路&#xff1a; 首先&#xff0c;还是要先考虑特殊情况&#xff0c;当链表为空时&#xff0c;…
阅读更多...
LeetCode刷题 #203 移除链表元素 Java

LeetCode刷题 #203 移除链表元素 Java

题目&#xff1a; 删除链表中等于给定值 val 的所有节点。 示例&#xff1a; 输入&#xff1a;1 ->2 ->6 ->3 ->4 ->5 ->6 , val 6 输出&#xff1a;1 ->2 ->3 ->4 ->5 思路&#xff1a; 首先&#xff0c;要考虑到空链表情况。即 head null …
阅读更多...
872. 叶子相似的树 / 剑指 Offer 33. 二叉搜索树的后序遍历序列 / 剑指 Offer 34. 二叉树中和为某一值的路径 / 剑指 Offer 35. 复杂链表的复制

872. 叶子相似的树 / 剑指 Offer 33. 二叉搜索树的后序遍历序列 / 剑指 Offer 34. 二叉树中和为某一值的路径 / 剑指 Offer 35. 复杂链表的复制

872. 叶子相似的树 2021.5.10 每日一题 题目描述 请考虑一棵二叉树上所有的叶子&#xff0c;这些叶子的值按从左到右的顺序排列形成一个 叶值序列 。举个例子&#xff0c;如上图所示&#xff0c;给定一棵叶值序列为 (6, 7, 4, 9, 8) 的树。如果有两棵二叉树的叶值序列是相同…
阅读更多...
《Java后端知识体系》系列之Java集合

《Java后端知识体系》系列之Java集合

先上集合知识图谱&#xff1a;有不足的或者错误的地方欢迎下方评论指正&#xff01;集合 Collection List ArrayList: 底层实现&#xff1a;底层是可变数组的数据结构&#xff0c;默认的初始化长度为10&#xff0c;如果没有设置容量默认是空数组&#xff0c;然后在进行add的时候…
阅读更多...
C语言之 单链表1（simply linked list）

C语言之 单链表1（simply linked list）

单链表 链表优点&#xff1a; 1.按需申请空间&#xff0c;需要就申请&#xff0c;不需要就释放 2.头部或中间插入数据&#xff0c;不需要挪动数据 3.不存在空间浪费 缺点&#xff1a; 1.每次存放一个数据&#xff0c;到要存一个指针去链接后面的数据节点 2.不支持随机访问&a…
阅读更多...
利用回溯的深度优先遍历找出基于邻接表存储的图中一个顶点到另一个顶点的所有简单路径

利用回溯的深度优先遍历找出基于邻接表存储的图中一个顶点到另一个顶点的所有简单路径

邻接表存储方法 对图中的每个顶点 i 建立单链表&#xff0c;将i的所有邻接点链起来。 每个单链表添加一个表头节点(表示顶点信息)。并将所有的表头节点构成一个数组&#xff0c;下标为 i 的元素表示顶点 i 的表头节点。 存储类型定义如下 typedef struct ANode {int adjvex; …
阅读更多...
第五章 树和二叉树

第五章 树和二叉树

第五章 树和二叉树 5.1 树和二叉树的定义 5.1.1 树的定义 树(Tree)是n&#xff08;n>0&#xff09;个结点的有限集。 ​ 若n0&#xff0c;称为空树&#xff1b; ​ 若n > 0 ,则它满足如下两个条件&#xff1a; ​ &#xff08;1&#xff09;有且仅有一个特定的称为…
阅读更多...
【LeetCode】Sama的个人记录_76

【LeetCode】Sama的个人记录_76

在遍历过程中同时维护"最小值"和"第二最小值"即可实现O(1)的空间与O(n)的时间class Solution {public boolean increasingTriplet(int[] nums) {int min Integer.MAX_VALUE;int mid Integer.MAX_VALUE;for (int num : nums) {if (num < min) {min nu…
阅读更多...
【Java数据结构】链表(Linked List)-单向链表

【Java数据结构】链表(Linked List)-单向链表

一、什么是链表(Linked List) 链表(Linked List)是一种常见的数据结构&#xff0c;它由一系列节点组成&#xff0c;每个节点包含一个值和指向下一个节点的引用。链表可以用于实现栈、队列等数据结构。相比数组&#xff0c;链表的优点在于可以高效地进行插入和删除操作&#xf…
阅读更多...
链表（实现插入一个数）

链表（实现插入一个数）

在存储一大波数时&#xff0c;使用数组显得不够灵活&#xff0c;如在排好序的一个序列中插入一个数&#xff0c;使用数组来实现时&#xff0c;需要把插入位置后面的所有数都后移。 这样的操作很浪费时间&#xff0c;但是用链表的话&#xff0c;只需要修改插入位置的指针即可。…
阅读更多...
leetcode104-每日刷题档

leetcode104-每日刷题档

给定一个二叉树&#xff0c;找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明: 叶子节点是指没有子节点的节点。 思路&#xff1a;先将root结点加入到我们队列当中 每一层 每一层 进行遍历 用一个tmp 当作中间变量 将每一层的左右结点加入到…
阅读更多...
leetcode141环形链表-每日刷题档

leetcode141环形链表-每日刷题档

如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;索引从 0 开始&#xff09;。如果 pos 是 -1&#xff0c;则在该链…
阅读更多...
PAT 甲 1052 Linked List Sorting 踩坑链表题

PAT 甲 1052 Linked List Sorting 踩坑链表题

2022.1.22 练习 PAT甲 1052 Linked List Sorting &#xff08;原题链接&#xff09; 坑点已在代码相应位置添加注释 心得&#xff1a;链表题注意测试点中可能含有无效结点&#xff0c;需要遍历构造链表,排除无效结点&#xff0c;构造出一条有效的链表。 题解如下&#xff1a…
阅读更多...
PAT 甲 1020 Tree Traversals

PAT 甲 1020 Tree Traversals

2022.1.23 练习 PAT甲 1020 Tree Traversals &#xff08;原题链接&#xff09; 已知一个非空二叉树的中序遍历和后序遍历&#xff0c;求输出层序遍历。 题解如下&#xff1a; #include <bits/stdc.h> using namespace std; const int MAX_SIZE30; int post[MAX_SIZE]…
阅读更多...
LinkedList总结

LinkedList总结

简介 public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, Serializable 双链表实现了List和Deque接口。 实现所有可选列表操作&#xff0c;并允许所有元素&#xff08;包括null &#xff09;。…
阅读更多...
几种链表概念

几种链表概念

何谓链表？ ：链式存储的线性表，简称链表。链表由多个链表元素组成，这些元素称为节点。结点之间通过逻辑连接，形成链式存储结构。存储结点的内存单元，可以是连续的也可以是不连续的。逻辑连接与物理存储次序没有关系。 链表分为两个域： 值域：用于存放结点的值 链域：用…
阅读更多...
数据结构PTA 基础实验6-2.1 列出连通集

数据结构PTA 基础实验6-2.1 列出连通集

基础实验6-2.1 列出连通集题目解法题目 给定一个有N个顶点和E条边的无向图&#xff0c;请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时&#xff0c;假设我们总是从编号最小的顶点出发&#xff0c;按编号递增的顺序访问邻接点。 输入格式: 输入第1行…
阅读更多...
C++ 单向链表

C++ 单向链表

文章目录前言头文件cpp文件前言 最近终于闲下来了&#xff0c;把之前写的单向链表代码总结上传一下。 头文件 //声明头节点 struct Node {int val;Node* pNext;Node(int val) {this->val val;this->pNext NULL;} };//声明链表类 class List { public://创建链表Node*…
阅读更多...
C语言使用链表队列实现初始化，出队列，入队列，取队头，遍历

C语言使用链表队列实现初始化，出队列，入队列，取队头，遍历

C语言使用链表队列实现初始化&#xff0c;出队列&#xff0c;入队列&#xff0c;取队头&#xff0c;遍历 1.C语言使用链表队列实现初始化&#xff0c;出队列&#xff0c;入队列&#xff0c;取队头&#xff0c;遍历 #include<stdio.h> #include<stdlib.h> #includ…
阅读更多...
专题：链表常考题目汇总

专题：链表常考题目汇总

文章目录 反转类型&#xff1a;206.反转链表完整版二刷记录 25. K个一组反转链表1 &#xff1a;子链表左闭右闭反转版本2 &#xff1a; 子链表左闭右开反转版本&#xff08;推荐&#xff09;⭐反转链表左闭右闭和左闭右开 合并类型&#xff1a;21.合并两个有序链表1: 递归法2: …
阅读更多...
1.7 HashMap源码分析

1.7 HashMap源码分析

1.存储结构 HashMap的内部存储结构其实是数组和链表的结合。当实例化一个HashMap时&#xff0c;系统会创建一个长度为Capacity的Entry数组&#xff0c;这个长度被称为容量(Capacity)&#xff0c;在这个数组中可以存放元素的位置我们称之为“桶”(bucket)&#xff0c;每个bucket…
阅读更多...
阿里巴巴java性能调优实战：深入浅出HashMap的设计与优化

阿里巴巴java性能调优实战：深入浅出HashMap的设计与优化

深入浅出HashMap的设计与优化 在上一讲中我提到过 Collection 接口&#xff0c;那么在 Java 容器类中&#xff0c;除了这个接口之外&#xff0c;还定 义了一个很重要的 Map 接口&#xff0c;主要用来存储键值对数据。 HashMap 作为我们日常使用最频繁的容器之一&#xff0c;相信…
阅读更多...
线性表之链表

线性表之链表

目录概念分类单向、双向带头、不带头循环、非循环无头单向非循环链表带头双向循环链表链表的实现单向带头非循环双向带头循环链表优缺点优点缺点单链表相关的面试题概念 链表是一种逻辑结构上连续&#xff0c;物理存储结构上非连续、非顺序的存储结构&#xff0c;之所以会形成这…
阅读更多...
创建链表（带头、双向、循环）

创建链表（带头、双向、循环）

第一次尝试 //这是 .h 部分的代码 #pragma once//使用这种方式来重命名数据类型&#xff0c;这样可以很方便的修改后续数据的数据类型&#xff0c;相当于#define的作用 typedef int ListType;//创建数据结点 typedef struct ListNode {//数据ListType _date;//指向下一个结点s…
阅读更多...
C语言 线索二叉树

C语言 线索二叉树

线索二叉树&#xff0c;我个人的理解是&#xff1a;在创建一个二叉树的基础上&#xff0c;把二叉树中的只有一个孩子或没有孩子的结点中的指向空的指针进行填充&#xff0c;以便于二叉树的遍历。 首先&#xff0c;还是先创建一个二叉树。 还是以上个代码中所表示的样板为例&am…
阅读更多...
链表头插, 链表逆置

链表头插, 链表逆置

title: reverse the linkList date: 2020-09-23 17:49:03 tags: [链表头插, 链表逆置, C语言, 算法, AL, DS] categories: DSandAL 链表的头插和逆置操作&#xff0c;很有技巧性&#xff0c;很值得思考#include <stdio.h> #include <stdlib.h>typedef struct MyStr…
阅读更多...
循环链表的打印 合并

循环链表的打印 合并

title: 循环链表的打印 合并 date: 2020-10-02 21:12:27 tags: 打印、合并循环链表 categories: 数据结构 本文中的所有操作均使用 设有尾指针的循环链表完成&#xff0c;目前只写了打印和合并两个操作&#xff0c;后续持续更新~ 看名字都可以知道&#xff0c;使用尾指针的循环…
阅读更多...
Leecode 141. 环形链表 快慢指针

Leecode 141. 环形链表 快慢指针

原题链接&#xff1a;Leecode 141. 环形链表 解法一&#xff1a;哈希 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode(int x) : val(x), next(NULL) {}* };*/ class Solution { public:bool hasCycle(ListN…
阅读更多...
Leecode 142. 环形链表 II 快慢指针

Leecode 142. 环形链表 II 快慢指针

原题链接&#xff1a;Leecode 142. 环形链表 II 看过的解释的最清楚的题解&#xff1a;环形链表 II&#xff08;双指针法&#xff0c;清晰图解&#xff09; 这里用do while是因为slow指针和fast指针开始都是设成head指针。 /*** Definition for singly-linked list.* struct…
阅读更多...
Leecode 61. 旋转链表

Leecode 61. 旋转链表

原题链接&#xff1a;Leecode 61. 旋转链表 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(int x) : val(x), next(nullptr) {}* ListNode(int x, ListN…
阅读更多...
用C++写双向链表list时我自己常犯的错误！

用C++写双向链表list时我自己常犯的错误！

这一篇博客记录我自己在写双向链表list时所犯的一个小错误&#xff01;&#xff08;2次了&#xff0c;我还没有完全记住&#xff09;&#xff0c;因此希望通过本篇博客来记录这个错误&#xff0c;日后学习coding过程中希望若再次遇到此类错误能第一时间反应过来或者能避免这种错…
阅读更多...
Leecode 203. 移除链表元素

Leecode 203. 移除链表元素

原题链接&#xff1a;Leecode 203. 移除链表元素 迭代: /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(int x) : val(x), next(nullptr) {}* ListNode(in…
阅读更多...
冲刺春招-精选笔面试 66 题大通关 day3

冲刺春招-精选笔面试 66 题大通关 day3

day3题目&#xff1a;206. 反转链表、199. 二叉树的右视图、bytedance-016. 16. 最短移动距离 学习计划链接&#xff1a;冲刺春招-精选笔面试 66 题大通关 今日知识点&#xff1a;链表、二叉树&#xff0c;难度仍为简单、中等、困难&#xff08;字节&#xff1a;重新定义简单…
阅读更多...
LeetCode刷题 #142 环形链表Ⅱ ( 返回链表开始入环的第一个节点)

LeetCode刷题 #142 环形链表Ⅱ ( 返回链表开始入环的第一个节点)

给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。   为了表示给定链表中的环&#xff0c;我们使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;索引从 0 开始&#xff09;。如果 pos 是 -1&#xff0c;则在该链表中没…
阅读更多...
循环双链表与双循环链表差别_实施循环双链表| C程序

循环双链表与双循环链表差别_实施循环双链表| C程序

循环双链表与双循环链表差别Solution: 解&#xff1a; Input: The data of each node 输入&#xff1a;每个节点的数据 Output: The circular doubly linked list 输出&#xff1a;圆形双向链表 Data structure used: A circular doubly linked list where each node contai…
阅读更多...
算法通关40讲 笔记四（映射 集合 哈希表）

算法通关40讲 笔记四（映射 集合 哈希表）

映射&#xff08;Map&#xff09;&#xff1a; 集合&#xff08;Set&#xff09;&#xff1a; 解决 hashcollision 哈希碰撞 问题&#xff0c;lies和foes在9的位置重合了&#xff0c;在9这个位置放一个链表&#xff0c;既拉链法。 List和Map&#xff0c;Set对比 HashMap时…
阅读更多...
代码随想录算法训练营第二十二天|235. 二叉搜索树的最近公共祖先、701.二叉搜索树中的插入操作 、450.删除二叉搜索树中的节点

代码随想录算法训练营第二十二天|235. 二叉搜索树的最近公共祖先、701.二叉搜索树中的插入操作 、450.删除二叉搜索树中的节点

二叉搜索树的最近公共祖先 题目链接&#xff1a;力扣 其实可以用之前普通二叉树最近公共祖先的算法。但是这样没有很好的利用二叉搜索树是有序的性质。 TreeNode* lowestCommonAncestor1(TreeNode* root, TreeNode* p, TreeNode* q) {if(!root || root p ||rootq) return roo…
阅读更多...
数据结构（二）—— 链表（2）

数据结构（二）—— 链表（2）

文章目录 1 143 重排链表1.1 找到原链表的中点&#xff08;「876. 链表的中间结点」&#xff09;。2.2 将原链表的右半端反转&#xff08;「206. 反转链表」&#xff09;3.3 交叉合并两个链表&#xff08;与「21. 合并两个有序链表」思路不同&#xff09;3.4 补充 21 合并两个有…
阅读更多...
顺序表 增删改查的基本操作 / 实现MyArrayList

顺序表 增删改查的基本操作 / 实现MyArrayList

顺序表1 ArrayList 的使用1.1 创建 ArrayList 实例1.2 添加元素1.3 删除1.4 查找1.5 获取修改元素1.6 遍历2 实现自己的 MyArrayList线性表是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构&#xff0c;常见的线性表&#xff1a;顺序表、链表、…
阅读更多...
2.3线性表——循环链表和双向链表基本操作的实现

2.3线性表——循环链表和双向链表基本操作的实现

注意&#xff1a;以下内容均省略思路&#xff0c;只有代码和时间复杂度。此内容为本人学习过程中的一些学习记录&#xff0c;如有错误&#xff0c;恳请各位指正、建议&#xff0c;末学将感激不尽&#xff01; 目录 1.两个循环链表的合并 2.双向链表的结构定义 3.双向链表结…
阅读更多...
力扣--合并两个有序链表

力扣--合并两个有序链表

合并两个有序链表 题目: 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4] 示例2&#xff1a; 输入&#xff1a;l1 [], l2 [] …
阅读更多...
数据结构及算法之栈（基于链表）讲解

数据结构及算法之栈（基于链表）讲解

1&#xff0c;具体实现 package com.dream21th.algorithmicdatastructure.linkedlist;/*** Auther: hp* Date: 2019/9/13 20:19* Description:*/ public class LinkedListStack<E> implements Stack<E> {private LinkedList<E> linkedListnew LinkedList<…
阅读更多...
（LeetCode） 两数相加

（LeetCode） 两数相加

给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0c;这两个数都不会以 0 …
阅读更多...
每日题解:LeetCode 109. 有序链表转换二叉搜索树

每日题解:LeetCode 109. 有序链表转换二叉搜索树

题目地址 个人博客地址 题目描述 给定一个单链表&#xff0c;其中的元素按升序排序&#xff0c;将其转换为高度平衡的二叉搜索树。 本题中&#xff0c;一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 示例:给定的有序链表&#xff1a…
阅读更多...
每日题解:LeetCode 23. 合并K个排序链表

每日题解:LeetCode 23. 合并K个排序链表

题目地址 个人博客地址 题目描述 合并 k 个排序链表&#xff0c;返回合并后的排序链表。请分析和描述算法的复杂度。 示例:输入: [1->4->5,1->3->4,2->6 ] 输出: 1->1->2->3->4->4->5->6解法 CPP class Solution { public:ListNode* …
阅读更多...
郝斌_数据结构_连续存储数组源代码

郝斌_数据结构_连续存储数组源代码

郝斌《数据结构》课程源代码 连续存储数组的实现 用者自取&#xff0c;自由分享 /* 时间&#xff1a;2020.12.28 内容&#xff1a;连续存储数组的算法演示 */#include <stdio.h> #include <malloc.h> #include <stdlib.h>struct Arr {int * pBase; //储存…
阅读更多...
顺序表_主程序

顺序表_主程序

顺序表检验bo2-1.h的主程序 以下内容为main2-1.cpp /** 时间&#xff1a;2021.01.30* 内容&#xff1a;检验 bo2-1.h 的主函数&#xff0c;也是线性表主要功能检验主函数* 位置&#xff1a;* 高书p15*/#include "c1.h"typedef int ElemType; // 定义ElemType为整型…
阅读更多...
leetcode: 206. 反转链表

leetcode: 206. 反转链表

题目描述 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道题&#xff1f; 来源&#xff1a;力扣&#xff08;LeetCode&#xff09; 链接&#xff…
阅读更多...
题135.pta数据结构题集-02-线性结构3 Reversing Linked List (25 分)

题135.pta数据结构题集-02-线性结构3 Reversing Linked List (25 分)

文章目录题135.pta数据结构题集-02-线性结构3 Reversing Linked List (25 分)一、题目二、题解题135.pta数据结构题集-02-线性结构3 Reversing Linked List (25 分) 一、题目 二、题解 碰到这个数并不大的节点地址问题&#xff0c;其实用数组下标来表示地址是完全没问题的&…
阅读更多...
链表（7）----倒序打印链表

链表（7）----倒序打印链表

1、链表定义 typedef struct ListElement_t_ {void *data;struct ListElement_t_ *next; } ListElement_t;typedef struct List_t_{int size;int capacity;ListElement_t *head;ListElement_t *tail; } List_t;2、倒序打印链表 int ReversePrintList( List_t *list){if( list…
阅读更多...
剑指offer 刷题 十二 双指针（25 52）

剑指offer 刷题 十二 双指针（25 52）

剑指 Offer 25. 合并两个排序的链表 输入两个递增排序的链表&#xff0c;合并这两个链表并使新链表中的节点仍然是递增排序的。 双指针&#xff1a; def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:cur, cur1, cur2 ListNode(), l1, l2res curwhile c…
阅读更多...
《数据结构与算法之美》 笔记四 数组

《数据结构与算法之美》 笔记四 数组

文章目录前言如何实现随机访问&#xff1f;低效的“插入”和“删除”警惕数组的访问越界问题容器能否完全替代数组&#xff1f;解答开篇内容小结思考题&#xff1a;前言 是的&#xff0c;在每一种编程语言中&#xff0c;基本都会有数组这种数据类型。不过&#xff0c;它不仅仅…
阅读更多...
《数据结构与算法之美》 笔记五 链表 上

《数据结构与算法之美》 笔记五 链表 上

文章目录前言五花八门的链表结构单链表循环链表双向链表空间换时间链表 VS 数组性能对比解答开篇前言 今天我们来聊聊“链表&#xff08;Linked list&#xff09;”这个数据结构。学习链表有什么用呢&#xff1f;为了回答这个问题&#xff0c;我们先来讨论一个经典的链表应用场…
阅读更多...
Leetcode 算法面试冲刺 实战 二（链表）（九）

Leetcode 算法面试冲刺 实战 二（链表）（九）

文章目录99 重排链表599 向循环有序链表插入节点99 重排链表 给定一个单链表L: L0→L1→…→Ln-1→Ln, 重新排列后为&#xff1a;L0→Ln→L1→Ln-1→L2→Ln-2→… 必须在不改变节点值的情况下进行原地操作。 我的思路是从中间往后的链表反转&#xff0c;然后再合并。但是不…
阅读更多...
SDUT-2056 不敢死队问题

SDUT-2056 不敢死队问题

不敢死队问题Time Limit: 1000 ms Memory Limit: 65536 KiBSubmit Statistic DiscussProblem Description说到“敢死队”&#xff0c;大家不要以为我来介绍电影了&#xff0c;因为数据结构里真有这么道程序设计题目&#xff0c;原题如下&#xff1a;有M个敢死队员要炸掉敌人的一…
阅读更多...
SDUT-2120 数据结构实验之链表五：单链表的拆分

SDUT-2120 数据结构实验之链表五：单链表的拆分

数据结构实验之链表五&#xff1a;单链表的拆分Time Limit: 1000MS Memory Limit: 65536KBSubmit StatisticProblem Description输入N个整数顺序建立一个单链表&#xff0c;将该单链表拆分成两个子链表&#xff0c;第一个子链表存放了所有的偶数&#xff0c;第二个子链表存放了…
阅读更多...
SDUT-3331 数据结构实验之链表八：Farey序列

SDUT-3331 数据结构实验之链表八：Farey序列

数据结构实验之链表八&#xff1a;Farey序列Time Limit: 10MS Memory Limit: 600KBSubmit Statistic DiscussProblem DescriptionFarey序列是一个这样的序列&#xff1a;其第一级序列定义为&#xff08;0/1&#xff0c;1/1&#xff09;&#xff0c;这一序列扩展到第二级形成序列…
阅读更多...
单向链表和双向链表的反转

单向链表和双向链表的反转

在Java中&#xff0c;单向链表和双向链表是非常常见的数据结构。在本篇博客中&#xff0c;我们将探讨如何反转这两种链表。 首先&#xff0c;我们创建了一个名为 Node 的单向链表类。它包含一个整数值和一个指向下一个节点的引用&#xff1a; public static class Node {publi…
阅读更多...
链表-leetcode

链表-leetcode

目录 141. Linked List Cycle 142. Linked List Cycle II 876. Middle of the Linked List 160. Intersection of Two Linked Lists 21. Merge Two Sorted Lists 23. Merge k Sorted Lists 206. Reverse Linked List 234. Palindrome Linked List 92. Reverse Linked L…
阅读更多...
什么是链表（Java）（2020）

什么是链表（Java）（2020）

都2020年了&#xff0c;到底什么是链表&#xff1f; (敲黑板&#xff1a;本文出续集了&#xff0c;详情点击什么是链表&#xff08;C语言&#xff09;) 前言 &#xff08;本文适合没有基础的小白&#xff0c;或者想了解学习方法的入门者食用 ps:本文所指的是单向链表&#…
阅读更多...
Java集合源码分析（十二）：超级接口Map

Java集合源码分析（十二）：超级接口Map

我们在前面说到的无论是链表还是数组&#xff0c;都有自己的优缺点&#xff0c;数组查询速度很快而插入很慢&#xff0c;链表在插入时表现优秀但查询无力。哈希表则整合了数组与链表的优点&#xff0c;能在插入和查找等方面都有不错的速度。我们之后要分析的HashMap就是基于哈希…
阅读更多...
Java LinkedList公共对象peekFirst（）方法（带示例）

Java LinkedList公共对象peekFirst（）方法（带示例）

LinkedList公共对象peekFirst()方法 (LinkedList public Object peekFirst() method) This method is available in package java.util.LinkedList.peekFirst(). 软件包java.util.LinkedList.peekFirst()中提供了此方法。 This method is used to retrieve the first or initia…
阅读更多...
初学习单链表

初学习单链表

package linkedlist;import java.sql.SQLOutput;public class SingleLinkedListDemo{public static void main(String[] args){//进行测试//先创建节点HeroNode hero01 new HeroNode(1, "宋江", "及时雨");HeroNode hero02 new HeroNode(2, "卢俊义…
阅读更多...
线性表的合并C/C++代码实现

线性表的合并C/C++代码实现

1&#xff0c;无序线性表的合并 只要从B中依次取得每个数据元素&#xff0c; 并依值在A中进行查访&#xff0c; 若不存在&#xff0c; 则插入。 代码如下&#xff1a; #include<stdio.h> #include<stdlib.h> #include<string.h>#define MAXSIZE 100 #defin…
阅读更多...
本篇博客记录的是我写过的LeetCode中关于栈的题

本篇博客记录的是我写过的LeetCode中关于栈的题

第一题&#xff08;对应LeetCode题库的第20题&#xff09;(简单题&#xff01;) &#xff08;当然&#xff0c;后续if自己看不懂自己的总结&#xff0c;可以去力扣网站翻阅回对应的题目去看题解&#xff01;&#xff09; 题目&#xff1a;有效的括号&#xff08;字符串的括号…
阅读更多...
对于单向链表的排序与去重

对于单向链表的排序与去重

#include "bits/stdc.h" using namespace std;struct node {int num;node* next; }; class Chain {public:Chain(){headtailnew node;}void GetElement(int ele)//单个元素补充{tail->numele;tail->nextnew node;tailtail->next;}void GetChain(int num)//知…
阅读更多...
c语言练习92：链表的中间结点

c语言练习92：链表的中间结点

链表的中间结点 链表的结点为空时无法访问其next成员否则会报错 /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/typedef struct ListNode ListNode; struct ListNode* middleNode(struct ListNode* head){if(h…
阅读更多...
基础数据结构——哈希表

基础数据结构——哈希表

目录 1.哈希表的概念 2.哈希表设计思想与原理 3.代码实现 1.哈希表的概念 顺序结构以及平衡树中&#xff0c;元素关键码与其存储位置之间没有对应的关系&#xff0c;因此在查找一个元素时&#xff0c;必须要经过关键 码的多次比较。顺序查找时间复杂度为O(N)&#xff0c;平衡…
阅读更多...
2-3线性表-顺序表和链表的比较

2-3线性表-顺序表和链表的比较

一.逻辑结构 都属于线性表&#xff0c;都是线性结构 二.存储结构 1.顺序表 &#xff08;1&#xff09;优点&#xff1a;支持随机存取&#xff0c;存储密度高 &#xff08;2&#xff09;缺点&#xff1a;大片连续空间分配不方便&#xff0c;改变容量不方便 2.链表 &#xff08;…
阅读更多...
二叉树的层序遍历 / 判断完全二叉树

二叉树的层序遍历 / 判断完全二叉树

1 二叉树的层序遍历 二叉树的层序遍历即&#xff0c;按照层一排一排的读取节点的值&#xff0c;如下图&#xff0c;层序遍历得到的就应该是&#xff1a;“1234567”。 public static void levelOrder(TreeNode root) {if (root null) {return;}// 创建一个链表&#xff0c;然…
阅读更多...
顺序表和链表1

顺序表和链表1

目录 1、线性表&#xff1a; 2、顺序表 &#xff1a; 2.1、概念及结构&#xff1a; 2.2、接口函数代码以文件形式进行呈现&#xff1a; 2.2.1、test.c源文件&#xff1a; 2.2.2、SeqList.c源文件&#xff1a; 2.2.3、SeqList.h头文件&#xff1a; 2.3、数组相关面试题…
阅读更多...
链表相关知识

链表相关知识

前置知识&#xff1a; 内存区域&#xff1a; 一.内存四区&#xff1a; 代码区&#xff1a;函数代码 存放在代码区 函数名就是函数地址。全局区&#xff1a;全局的变量 字符串常量 初始化 int a 0;栈 区&#xff1a;告诉计算机 int double char 定义一个变量c&#xff0c;系统…
阅读更多...
初学数据结构——链表

初学数据结构——链表

#include<iostream> using namespace std;//声明链表结点的结构体 typedef struct LinkNode {int data;struct LinkNode *next; }LinkNode, *Linklist;//初始化链表 const bool Init_List(Linklist &l) throw(bool) {//为头结点分配内存l (LinkNode*)malloc(sizeof(…
阅读更多...
Python3 list问题

Python3 list问题

Python内置的一种数据类型是列表&#xff1a;list。list是一种有序的集合&#xff0c;可以随时添加和删除其中的元素。Python中的list数据结构实现要更比想象的更简单一些&#xff0c;保留了数组内存连续性访问的方式&#xff0c;只是每个节点存储的不是实际数据&#xff0c;而…
阅读更多...
明天程序设计需要打印的 代码总结

明天程序设计需要打印的 代码总结

1.快慢指针 经典题目-- T1-删除排序数组中的重复项: 给你一个 升序排列 的数组 nums &#xff0c;请你 原地 删除重复出现的元素&#xff0c;使每个元素 只出现一次 &#xff0c;返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。 由于在某些语言中不能改变数组的长…
阅读更多...
集合的合并 C语言实现

集合的合并 C语言实现

数据结构c语言单链表对集合的合并 首先初始化一个链表&#xff0c;并判断是否为空&#xff08;这里就不写了&#xff09; 然后就是对链表的创建&#xff0c;将数据输入到链表中&#xff0c;但是不知道要输入的集合中有多少数据&#xff0c;所以改成直接插入数据&#xff0c;不…
阅读更多...
循环单链表的创建及基本操作 C语言

循环单链表的创建及基本操作 C语言

数据结构c语言循环单链表 在单链表的基础上增加了循环&#xff0c;和单链表几乎是一样的&#xff0c;只是对链表头结点的定义和对链表结尾的判断&#xff0c;从NULL变成了指向头结点L。别的定义和单链表一样。 代码如下&#xff1a; #include <stdio.h> #include <s…
阅读更多...
Java List问题

Java List问题

List包括List接口以及List接口的所有实现类。因为List接口实现了Collection接口&#xff0c;所以List接口拥有Collection接口提供的所有常用方法&#xff0c;又因为List是列表类型&#xff0c;所以List接口还提供了一些适合于自身的常用方法。 在List集合中&#xff0c;我们常用…
阅读更多...
Linus:利用二级指针删除单向链表

Linus:利用二级指针删除单向链表

感谢网友full_of_bull投递此文&#xff08;注&#xff1a;此文最初发表在这个这里&#xff0c;我对原文后半段修改了许多&#xff0c;并加入了插图&#xff09; Linus大婶在slashdot上回答一些编程爱好者的提问&#xff0c;其中一个人问他什么样的代码是他所喜好的&#xff0c…
阅读更多...
LeetCode刷题——双指针（python代码）

LeetCode刷题——双指针（python代码）

LeetCode刷题——双指针&#xff08;python代码&#xff09; 一、双指针 双指针通俗来说就是用两个变量存储数据&#xff0c;然后根据逻辑关系进行使用的一种思想。 二、刷题 2.1 反转链表 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链…
阅读更多...
刷题笔记----每周例题：206. 反转链表.92. 反转链表 II，25. K 个一组翻转链表

刷题笔记----每周例题：206. 反转链表.92. 反转链表 II，25. K 个一组翻转链表

206反转链表 206. 反转链表 题解&#xff08;递归和迭代&#xff09;&#xff1a; class Solution { public:ListNode* reverseList(ListNode* head) {//递归/*//链表节点小于2&#xff0c;返回if(head nullptr || head->next nullptr)return head;//递归下一节点链表Li…
阅读更多...
链表训练题——小王子单链表

链表训练题——小王子单链表

题目描述 小王子有一天迷上了排队的游戏&#xff0c;桌子上有标号为 1-101−10 的 1010 个玩具&#xff0c;现在小王子将他们排成一列&#xff0c;可小王子还是太小了&#xff0c;他不确定他到底想把那个玩具摆在哪里&#xff0c;直到最后才能排成一条直线&#xff0c;求玩具的…
阅读更多...
【基础知识②】排序算法、链表

【基础知识②】排序算法、链表

文章目录排序算法堆排序冒泡排序简单排序算法将单链表按照奇偶位置拆分成两个链表[905. 按奇偶排序数组](https://leetcode-cn.com/problems/sort-array-by-parity/)删除链表中重复的节点链表中环的入口结点圆圈中最后剩下的结点两两交换链表中得结点排序算法 TODO 补充学习排…
阅读更多...
链表虚拟头结点的设置 LeetCode_24

链表虚拟头结点的设置 LeetCode_24

LeetCode_24 两两交换链表中的节点 因为头结点会发生变化&#xff0c;返回时找到头结点是关键。这就可以引入虚拟头结点&#xff1a; 设置 Node dummyNode 指向当前头结点&#xff0c;再令一个preNode dummyNode。 public ListNode swapPairs(ListNode head) {ListNode dumm…
阅读更多...
leetcode:237. 删除链表中的节点

leetcode:237. 删除链表中的节点

题目描述 请编写一个函数&#xff0c;使其可以删除某个链表中给定的&#xff08;非末尾&#xff09;节点&#xff0c;你将只被给定要求被删除的节点。 现有一个链表 – head [4,5,1,9]&#xff0c;它可以表示为: 示例 1: 输入: head [4,5,1,9], node 5 输出: [4,1,9] 解释…
阅读更多...
LeetCode刷题笔记 Java 腾讯 链表 反转链表

LeetCode刷题笔记 Java 腾讯 链表 反转链表

给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 不停的变换当前指针&#xff08;指向上一级&#xff09;即可 class Solution {public ListNode reverseList(ListNode head) {ListNode prenull,currhead;while(curr!null){ListNode next …
阅读更多...
K个一组翻转链表-链表25-C++

K个一组翻转链表-链表25-C++

算法思想&#xff1a; 链表分区为已翻转部分待翻转部分未翻转部分每次翻转前&#xff0c;要确定翻转链表的范围&#xff0c;这个必须通过 k 此循环来确定需记录翻转链表前驱和后继&#xff0c;方便翻转完成后把已翻转部分和未翻转部分连接起来初始需要两个变量 pre 和 end&…
阅读更多...
Java数据结构习题： 编写一个方法remove（），接受一条链表和一个字符串key作为参数，删除链表中所有item域为key的结点

Java数据结构习题： 编写一个方法remove（），接受一条链表和一个字符串key作为参数，删除链表中所有item域为key的结点

编写一个方法remove&#xff08;&#xff09;&#xff0c;接受一条链表和一个字符串key作为参数&#xff0c;删除链表中所有item域为key的结点 核心代码&#xff1a; //接受一条链表和一个字符串key作为参数&#xff0c;删除链表中所有item域为key的结点public void remove(O…
阅读更多...
Java数据结构习题：编写一个方法removeAfter（），接受一个结点作为参数并删除该结点的后续结点（如果参数结点或参数结点的后续结点为空则什么也不做）

Java数据结构习题：编写一个方法removeAfter（），接受一个结点作为参数并删除该结点的后续结点（如果参数结点或参数结点的后续结点为空则什么也不做）

核心算法&#xff1a; //编写一个方法removeAfter&#xff08;&#xff09;&#xff0c;接受一个结点作为参数并删除该结点的后续结点&#xff08;如果参数结点或参数结点的后续结点为空则什么也不做&#xff09;public Object removeAfter(NODE Top_Node){if(Top_Node null |…
阅读更多...
Java数据结构习题编写一个方法find()，接受一个字符串key作为参数。如果链表中的某个结点的元素数据为key，则方法返回ture，否则返回first

Java数据结构习题编写一个方法find()，接受一个字符串key作为参数。如果链表中的某个结点的元素数据为key，则方法返回ture，否则返回first

核心代码&#xff1a; //编写一个方法find()&#xff0c;接受一个字符串key作为参数。如果链表中的某个结点的元素数据为key&#xff0c;则方法返回ture&#xff0c;否则返回firstpublic class Node {//链表指针private NODE first null;public NODE getFirst() {return firs…
阅读更多...
严蔚敏数据结构C语言版 P34 算法2.17（静态链表的插入）——中职

严蔚敏数据结构C语言版 P34 算法2.17（静态链表的插入）——中职

严蔚敏数据结构C语言版 P34 算法2.17 静态链表的插入&#xff1a; 由于严书静态链表写的不是很清楚&#xff08;反正是可选章节得知道理解即可&#xff09;&#xff0c;这里采用大话数据结构的插入思想&#xff0c;当然还是自己理解敲出的&#xff0c;所以仅供参考 /* 严蔚敏…
阅读更多...
48 两个链表的交叉（Intersection of Two Linked Lists）

48 两个链表的交叉（Intersection of Two Linked Lists）

文章目录1 题目2 解决方案2.1 思路2.2 图解2.3 时间复杂度2.4 空间复杂度3 源码1 题目 题目&#xff1a;两个链表的交叉&#xff08;Intersection of Two Linked Lists&#xff09; 描述&#xff1a;请写一个程序&#xff0c;找到两个单链表最开始的交叉节点。 如果两个链表没…
阅读更多...
42 翻转链表（Reverse Linked List）

42 翻转链表（Reverse Linked List）

文章目录1 题目2 解决方案2.1 思路2.2 图解2.3 时间复杂度2.4 空间复杂度3 源码1 题目 题目&#xff1a;翻转链表&#xff08;Reverse Linked List&#xff09; 描述&#xff1a;翻转一个链表。 lintcode题号——35&#xff0c;难度——easy 样例1&#xff1a; 输入&#xff…
阅读更多...
211. 添加与搜索单词——前缀数2.0、回溯

211. 添加与搜索单词——前缀数2.0、回溯

class WordDictionary { private:vector<WordDictionary*> treeNode; //26个子树bool isEnd; public:WordDictionary() : treeNode(26), isEnd(false){}//添加单词void addWord(string word) {//正常前缀树的添加流程WordDictionary* node this;for(char ch : word){c…
阅读更多...
[数据结构] 单链表如何判环以及求环的长度,入口

[数据结构] 单链表如何判环以及求环的长度,入口

目录 如何判环? 如何求环的长度? 如何求环的入口呢? 示例 如何判环? 思路: 利用两个移动速度不同的指针,若在均不为空的情况下相遇,则存在环 如何求环的长度? 思路:若存在环,那么快慢指针从相遇点重新出发到再次相遇的过程中, 一定是慢指针走了一圈&#xff0c;快指针…
阅读更多...
蓝桥杯第一轮基础练习总结

蓝桥杯第一轮基础练习总结

蓝桥杯第一轮基础练习总结 基础练习 闰年判断 问题描述 给定一个年份&#xff0c;判断这一年是不是闰年。 当以下情况之一满足时&#xff0c;这一年是闰年&#xff1a; \1. 年份是4的倍数而不是100的倍数&#xff1b; \2. 年份是400的倍数。 其他的年份都不是闰年。 输…
阅读更多...
二叉树系列之「把二叉树打印成多行」

二叉树系列之「把二叉树打印成多行」

从上到下按层打印二叉树&#xff0c;同一层结点从左至右输出。每一层输出一行。 public class Solution {ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {ArrayList<ArrayList<Integer>> result new ArrayList<>();if(pRoot null) re…
阅读更多...
LeetCode每日一题【blog00063】-2021/10/10 -分隔链表

LeetCode每日一题【blog00063】-2021/10/10 -分隔链表

本文目录如下&#xff1a;题目&#xff1a;分隔链表题目&#xff1a;分隔链表 题目描述: 给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。你应当 保留 两个分区中每个节点的初…
阅读更多...
基础数据结构——队列

基础数据结构——队列

目录 1.什么是队列 2.队列的使用 3.队列的模拟实现 4.部分队列oj题目解析 1.什么是队列 在队列这种数据结构中&#xff0c;最先插入在元素将是最先被删除&#xff1b;反之最后插入的元素将最后被删除&#xff0c;因此队列又称为“先进先出”&#xff08;FIFO—first in fi…
阅读更多...
青岛大学_王卓老师【数据结构与算法】Week04_05_双向链表的删除_学习笔记

青岛大学_王卓老师【数据结构与算法】Week04_05_双向链表的删除_学习笔记

本文是个人学习笔记&#xff0c;素材来自青岛大学王卓老师的教学视频。 一方面用于学习记录与分享&#xff0c;另一方面是想让更多的人看到这么好的《数据结构与算法》的学习视频。 如有侵权&#xff0c;请留言作删文处理。 课程视频链接&#xff1a; 数据结构与算法基础–…
阅读更多...
JAVA集合详解(list、set、map)

JAVA集合详解(list、set、map)

1.接口继承关系和实现 集合类存放于 Java.util 包中&#xff0c;主要有 3 种&#xff1a;set(集&#xff09;、list(列表包含 Queue&#xff09;和 map(映射)。 Collection&#xff1a;Collection 是集合 List、Set、Queue 的最基本的接口。Iterator&#xff1a;迭代器&#…
阅读更多...
稀疏矩阵的存储与获取（十字链表法 C++版）

稀疏矩阵的存储与获取（十字链表法 C++版）

此稀疏矩阵我们打算采用十字链表法进行存储。 代码实现及结果测试: #include<stdio.h> #include<stdlib.h> #define null NULL #define N 4 //矩阵的行数 #define M 7 //矩阵的列数/*稀疏矩阵的十字链表法实现方式 *///十字链表的元素结点 typedef struc…
阅读更多...
C++链表几个问题

C++链表几个问题

创建链表 //利用链表创建三个学生的信息&#xff0c;学生信息包括姓名和年龄&#xff0c;输出名为kaka学生的年龄#include<iostream> using namespace std;//第一步&#xff0c;创建结构体 struct student {char name[20];int age;student *next; //第二步&#xff0c;在…
阅读更多...
链表（8）----删除链表的第K个节点，时间复杂度为O(1)

链表（8）----删除链表的第K个节点，时间复杂度为O(1)

1、链表定义 typedef struct ListElement_t_ {void *data;struct ListElement_t_ *next; } ListElement_t;typedef struct List_t_{int size;int capacity;ListElement_t *head;ListElement_t *tail; } List_t;2、给定链表的头结点和第K个节点&#xff0c;在平均时间复杂度为O(…
阅读更多...
磕代码：Java：合并两个有序链表（递归+常见思路）

磕代码：Java：合并两个有序链表（递归+常见思路）

1.递归 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* ListNode(int val, ListNode next) { this.val val; this.next next; }* }1.考虑异常情…
阅读更多...
华为机试真题 C++ 实现【单向链表中间节点】【2022.11 Q4新题】

华为机试真题 C++ 实现【单向链表中间节点】【2022.11 Q4新题】

题目描述 求单向链表中间的节点值&#xff0c;如果奇数个节点取中间&#xff0c;偶数个取偏右边的那个值。 输入描述 第一行 链表头节点地址 后续输入的节点数 n nn 后续输入每行表示一个节点&#xff0c;格式 节点地址 节点值 下一个节点地址(-1表示空指针) 输入保证链表不…
阅读更多...
[JavaScript]删除链表的倒数第n个节点

[JavaScript]删除链表的倒数第n个节点

文章目录描述示例1js代码描述 给定一个链表&#xff0c;删除链表的倒数第 nn 个节点并返回链表的头指针 例如&#xff0c; 给出的链表为: 1\to 2\to 3\to 4\to 51→2→3→4→5, n 2n2. 删除了链表的倒数第 nn 个节点之后,链表变为1\to 2\to 3\to 51→2→3→5. 备注&#xff1…
阅读更多...
leetcode — JavaScript专题（一）：检查是否是类的对象实例、数组原型对象的最后一个元素、计数器、睡眠函数、有时间限制的缓存

leetcode — JavaScript专题（一）：检查是否是类的对象实例、数组原型对象的最后一个元素、计数器、睡眠函数、有时间限制的缓存

专栏声明&#xff1a;只求用最简单的&#xff0c;容易理解的方法通过&#xff0c;不求优化&#xff0c;不喜勿喷 2618. 检查是否是类的对象实例 题面 请你编写一个函数&#xff0c;检查给定的对象是否是给定类或超类的实例。 可以传递给函数的数据类型没有限制。 知识点&am…
阅读更多...
【LeetCode】每日一题：链表部分经典题型

【LeetCode】每日一题：链表部分经典题型

文章目录 1.反转链表2.链表的中间节点3.合并两个有序链表4.相交链表5.环形链表6.环形链表Ⅱ ​&#x1f47b;内容专栏&#xff1a;《LeetCode刷题专栏》 &#x1f428;本文概括&#xff1a;归纳链表部分经典题型。206.反转链表、876.链表的中间节点、21.合并两个有序链表、160.…
阅读更多...
数据结构之单链表合并

数据结构之单链表合并

分析 1.传递两个链表参数 2.创建辅助变量存储第一个链表&#xff0c;防止第一个链表的头节点发生变化 3.创建辅助变量存储第二个链表的下一个节点&#xff0c;防止在改变当前节点的指针时&#xff0c;导致后续节点失效 4.遍历第二个链表&#xff0c;在遍历过程中遍历第一个链表…
阅读更多...
6-3图-邻接表

6-3图-邻接表

邻接表 回顾&#xff1a; 邻接矩阵&#xff1a;数组实现的顺序存储&#xff0c;空间复杂度高&#xff0c;不适合存储稀疏图 一.基本概念 邻接表&#xff1a;顺序链式存储 第一行&#xff1a;A指向123三个顶点&#xff0c;对应BCD三个顶点&#xff08;123顺序可交换&#xff…
阅读更多...
快慢指针求解链表中环的入口节点推导

快慢指针求解链表中环的入口节点推导

当慢指针抵达环的入口节点B时&#xff0c;此时快指针应该在节点B处&#xff0c;此后快指针移动2Y的距离&#xff0c;慢指针移动Y的距离后在节点C相遇&#xff0c;也就是说BDBCY; 从开始移动到快慢指针相遇&#xff0c;慢指针移动的总距离为&#xff1a;S慢S_慢S慢​ABBCXY; 快指…
阅读更多...
leetcode_反转链表

leetcode_反转链表

给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]输入&#xff1a;head [1,2] 输出&#xff1a;[2,1]输入&#xff1a;head [] 输出&#xff1a;[]class Solution { publi…
阅读更多...
ArrayList和LinkList的区别

ArrayList和LinkList的区别

ArrayList和LinkList的区别 ArrayList和LinkList是List接口的两种不同实现&#xff1b;并且都是线程不安全。 ArrayList是基于动态数组的数据结构&#xff0c;LinkList是基于双向链表的数据结构&#xff1b; 对于随机访问get和set时&#xff0c;ArrayList效率更高&#xff1b;…
阅读更多...
带你玩转单向链表（学习必备）

带你玩转单向链表（学习必备）

本文概要 本篇文章主要介绍数据结构中单向链表各种操作&#xff0c;适合有C语言基础的同学&#xff0c;文中描述和代码示例很详细&#xff0c;干货满满&#xff0c;感兴趣的小伙伴快来一起学习吧&#xff01; &#x1f31f;&#x1f31f;&#x1f31f;个人简介&#x1f31f;&…
阅读更多...
奇偶链表

奇偶链表

题目描述&#xff1a; 给定一个单链表&#xff0c;把所有的奇数节点和偶数节点分别排在一起。请注意&#xff0c;这里的奇数节点和偶数节点指的是节点编号的奇偶性&#xff0c;而不是节点的值的奇偶性。 请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)&#xff0c;时…
阅读更多...
最通俗易懂的链表讲解

最通俗易懂的链表讲解

我先来带你认识一下什么是链表&#xff1a; 链表是一种物理存储单元上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点&#xff08;链表中每一个元素称为结点&#xff09;组成&#xff0c;结点可以在运行时动态生…
阅读更多...
【华为OD机试python】 阿里巴巴找黄金宝箱(Ⅲ)【2023 B卷|100分】

【华为OD机试python】 阿里巴巴找黄金宝箱(Ⅲ)【2023 B卷|100分】

题目描述 一贫如洗的樵夫阿里巴巴在去砍柴的路上，无意中发现了强盗集团的藏宝地， 藏宝地有编号从0-N的箱子，每个箱子上面贴有一个数字。 阿里巴巴念出一个咒语数字，查看宝箱是否存在两个不同箱子，这两个箱子上贴的数字相同， 同时这两个箱了的编号之差的绝对值小于等于咒语…
阅读更多...
Java集合框架----LinkedList源码

Java集合框架----LinkedList源码

LinkedList的源码分析 LinkedList的数据结是双向链表&#xff0c;因为是链表结构&#xff0c;所以LinkedList更加适用于增删频繁而查询修改不频繁的场景&#xff0c;其适用场景和ArrayList有一些相反的。 LinkedList的结构 1、实现了List接口&#xff1a;可以使用List接口中…
阅读更多...
[剑指offer]JT15---反转链表(不积硅步无以至千里)

[剑指offer]JT15---反转链表(不积硅步无以至千里)

剑指offer第十五题题目如下思路与代码题目如下 思路与代码 很多同学看到这个题会很懵&#xff0c;链表咋反转&#xff0c;别慌 就是一个个反转就行了。 不积硅步无以至千里&#xff0c;不积小流无以成江海 首尾交换成为尾链表&#xff0c;原尾链表next成为首链表 简单来说&…
阅读更多...
【线程安全的HashMap有哪些，CurrentHashMap底层是怎么实现线程安全的】

【线程安全的HashMap有哪些，CurrentHashMap底层是怎么实现线程安全的】

在 Java 中&#xff0c;线程安全的 HashMap 通常有以下几种实现&#xff1a; Collections.synchronizedMap 方法&#xff1a;该方法可以将 HashMap 转换为线程安全的 Map。 Hashtable 类&#xff1a;Hashtable 是一种线程安全的集合类&#xff0c;它与 HashMap 类似&#xff0…
阅读更多...
n个结点的完全二叉树顺序存储在一维数组a中，设计一个算法，由此数组得到该完全二叉树的二叉链表结构

n个结点的完全二叉树顺序存储在一维数组a中，设计一个算法，由此数组得到该完全二叉树的二叉链表结构

#include<stdio.h> #include<stdlib.h> typedef struct btnode {char element;struct btnode* Lchild, * Rchild; }BTNode; typedef struct btree {struct btnode* Root; }BTree; //创建新节点 BTNode* NewNode() {BTNode* p (BTNode*)malloc(sizeof(BTNode));ret…
阅读更多...
图和树的存储方式：邻接矩阵和邻接表

图和树的存储方式：邻接矩阵和邻接表

邻接矩阵和邻接表摘要无向图和有向图的区别稀疏图和稠密图邻接矩阵邻接矩阵的初始化邻接矩阵的读入邻接表邻接表的实现基础算法和数据结构合集&#xff1a; https://blog.csdn.net/GD_ONE/article/details/104061907 摘要 本文主要介绍邻接矩阵和邻接表的实现方式&#xff0c…
阅读更多...
力扣每日一题：83. 删除排序链表中的重复元素

力扣每日一题：83. 删除排序链表中的重复元素

目录题目&#xff1a;83. 删除排序链表中的重复元素示例1示例2提示解题思路解题代码解题感悟题目&#xff1a;83. 删除排序链表中的重复元素 难度&#xff1a; 简单 题目&#xff1a; 存在一个按升序排列的链表&#xff0c;给你这个链表的头节点 head &#xff0c;请你删除所…
阅读更多...
java 集合简述

java 集合简述

一、常见的集合 加粗代表线程安全 list 数据结构类数组ArrayList vector stack CopyOnWriteArrayList链表linkedlist set 数据结构类数组HashSet(hash桶是单链表) CopyOnWriteArraySet LinkedHashSet(链表保证顺序)链表TreeSet ConcurrentSkipListSet map 数据结构类数组Has…
阅读更多...
每天一道算法题の约瑟夫问题详解

每天一道算法题の约瑟夫问题详解

约瑟夫问题 &#xff1a;有 N 个人围成一圈&#xff0c;每个人都有一个编号&#xff0c;编号由入圈的顺序决定&#xff0c;第一个入圈的人编号为 1&#xff0c;最后一个为 N&#xff0c;从第 k (1<k<N)个人开始报数&#xff0c;数到 m (1<m<N)的人将出圈&#xff…
阅读更多...
链表学习之找到两个链表相交的第一个节点

链表学习之找到两个链表相交的第一个节点

链表解题技巧 额外的数据结构&#xff08;哈希表&#xff09;&#xff1b;快慢指针&#xff1b;虚拟头节点&#xff1b; 找到两个链表相交的第一个节点 给定两个链表&#xff0c;这两个链表可能有环&#xff0c;可能无环。判断这两个链表是否相交&#xff0c;相交则返回第一…
阅读更多...
C/C++每日一练(20230501)

C/C++每日一练(20230501)

目录 1. 对链表进行插入排序 &#x1f31f;&#x1f31f; 2. 找出小于平均值的数 ※ 3. 二叉树的最大深度 &#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Golang每日一练 专栏 Python每日一练 专栏 C/C每日一练 专栏 Java每日一练 专栏 1. 对链表进行…
阅读更多...
【leetcode】栈与队列

【leetcode】栈与队列

1. 有效的括号 OJ&#xff1a;有效的括号 给定一个只包括 (&#xff0c;)&#xff0c;{&#xff0c;}&#xff0c;[&#xff0c;] 的字符串 s &#xff0c;判断字符串是否有效。 有效字符串需满足&#xff1a; &#xff08;1&#xff09;左括号必须用相同类型的右括号闭合。 &…
阅读更多...
力扣算法 Java 刷题笔记【链表篇】hot100（三）如何 K 个一组反转链表（困难） 1

力扣算法 Java 刷题笔记【链表篇】hot100（三）如何 K 个一组反转链表（困难） 1

文章目录1. K 个一组翻转链表 &#xff08;困难&#xff09;1. K 个一组翻转链表 &#xff08;困难&#xff09; 地址: https://leetcode-cn.com/problems/reverse-nodes-in-k-group/ 2021/11/26 做题反思&#xff1a; 创建两个结点基线条件reverse(ListNode a, ListNode b) …
阅读更多...
线性表的链式存储结构与顺序存储结构（链表和数组）的区别及优缺点

线性表的链式存储结构与顺序存储结构（链表和数组）的区别及优缺点

线性表的链式存储结构与顺序存储结构&#xff08;链表和数组&#xff09;的区别及优缺点 参照《大话数据结构》整理&#xff1a; 顺序存储结构&#xff1a; 优点&#xff1a; 无须为表示表中元素之间的逻辑关系而增加额外的存储空间可以快速的存取表中任一位置的元素 O(1) …
阅读更多...
C++中的链表

C++中的链表

以下为本人在大一时阅读《C Primer Plus》中关于链表的章节所做的笔记 链表 链表内元素结构&#xff1a; struct node { int data ; node * next ; } ; 链表的起始元素&#xff1a; node * head ;链表的创建函数&#xff1a; node * CreateList() { node * s, * p ;…
阅读更多...
LeetCode 206 反转链表 -- 递归法和双指针法

LeetCode 206 反转链表 -- 递归法和双指针法

来源&#xff1a;力扣&#xff08;LeetCode&#xff09; 链接&#xff1a;https://leetcode-cn.com/problems/reverse-linked-list 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5…
阅读更多...
LeetCode 203 移除链表元素 -- 虚拟头节点

LeetCode 203 移除链表元素 -- 虚拟头节点

来源&#xff1a;力扣&#xff08;LeetCode&#xff09; 链接&#xff1a;https://leetcode-cn.com/problems/remove-linked-list-elements 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 …
阅读更多...
leetcode 160.链表相交

leetcode 160.链表相交

⭐️ 往期相关文章 &#x1f4ab;链接1&#xff1a;链表分割 &#x1f4ab;链接2&#xff1a;链表中倒数第k个结点(快慢指针问题) &#x1f4ab;链接3&#xff1a;leetcode 876.链表的中间结点(快慢指针问题) &#x1f4ab;链接4&#xff1a;leetcode 206.反转链表 &#x1f4…
阅读更多...
牛客网剑指Offer（二叉搜索树与双向链表）

牛客网剑指Offer（二叉搜索树与双向链表）

输入一棵二叉搜索树&#xff0c;将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点&#xff0c;只能调整树中结点指针的指向。 分析&#xff1a; 对二叉搜索树进行中序遍历&#xff0c;递归操作。 /** public class TreeNode {int val 0;TreeNode left nul…
阅读更多...
牛客网剑指offer习题（二叉树中和为某一值的路径复杂链表的复制）

牛客网剑指offer习题（二叉树中和为某一值的路径复杂链表的复制）

1、输入一颗二叉树的根节点和一个整数&#xff0c;按字典序打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。 分析&#xff1a; 需要输出一个二叉树中结点值的和为输入整数的所有路径&#xff0c;每个路径…
阅读更多...
数据结构与算法（链表）

数据结构与算法（链表）

1. 链表 1.1 如何实现单链表的增删操作 链表是一个基本的数据结构&#xff0c;存储特点是&#xff1a;可以用任意一个存储单元存储单链表中的数据元素&#xff08;可以不连续&#xff09;。单链表中的一个存储单元包括存储的数据元素和指向直接后继的索引。这两个总和成为一个…
阅读更多...
Java基础知识（容器）

Java基础知识（容器）

9. 容器 9.1 java Collections框架 该框架中包含集合接口和接口的实现类及操作他们的算法&#xff08;查找、排序、反转、替换、复制、取最小元素、最大元素&#xff09;&#xff0c;提供list、queue、set、stack、map等数据结构。 1、set&#xff1a;主要特点是集合中的元素…
阅读更多...
数据结构 建立单调有序链表

数据结构 建立单调有序链表

方法一&#xff1a;先建立链表&#xff0c;后对链表进行排序 #include <stdio.h> #include <stdlib.h> typedef struct LNode {int data;struct LNode *next; }; void creatListH(struct LNode *head, int n);//创建链表 void print(struct LNode *head);//输出链…
阅读更多...
数据结构与算法（一）——数据结构【数组、队列、链表、栈】

数据结构与算法（一）——数据结构【数组、队列、链表、栈】

一、概述 数据结构包括&#xff1a;线性结构 与 非线性结构 1.1 线性结构 对于线性结构&#xff0c;有两种不同的存储方式&#xff1a;顺序存储方式 和 链式存储方式。 顺序存储存储方式 即为顺序表&#xff0c;顺序表中的存储元素是连续的。也就是说&#xff0c;在内存分配…
阅读更多...
数据结构_单链表

数据结构_单链表

//链表初始化 LinkList() {first new Node;first->next nullptr; } //判空 Empty() {if (first->next nullptr)return1;else return 0; } //单链表的遍历 //1.工作指针p初始化 //2.重复执行下述操作&#xff0c;直到指针p为空 // 2.1 输出节点p的数据域 // 2.2 工作…
阅读更多...
【数据结构】线性表（链表）

【数据结构】线性表（链表）

链表的表示和实现 链表的定义 链表由一系列结点&#xff08;链表中每一个元素称为结点&#xff09;组成&#xff0c;结点可以在运行时动态生成。每个结点包括两个部分&#xff1a;一个是存储数据元素的数据域&#xff0c;另一个是存储下一个结点地址的指针域。 结点在存储器…
阅读更多...
桶排序，基数排序

桶排序，基数排序

桶排序 这里是百度百科桶排序介绍图&#xff0c;排序方法描述就是&#xff1a;对于要排序的目标取值范围在0~n-1的m个数&#xff0c;实例说明&#xff0c;排序3,5,6,1,2,4,3这7个数字&#xff0c;取值在0~9之间&#xff1b; 首先建立10个桶子&#xff0c;编号分别为0、1、2………
阅读更多...
【数据结构】哈希表中——拉链法

【数据结构】哈希表中——拉链法

前言 书接上回&#xff0c;我们接着来讲解哈希表相关的知识。 拉链法 拉链法是解决哈希冲突的另外一种思路&#xff0c;顾名思义&#xff0c;当两个key值哈希冲突时&#xff0c;会将两个值挂在一个链表上&#xff0c;因此也不会发生踩踏事件&#xff0c;是比较常用的解决哈希…
阅读更多...
python 单向循环（环形）链表

python 单向循环（环形）链表

不带头结点的单向循环链表的示意图 循环链表的应用场景【约瑟夫问题】 现假设 n 5&#xff08;一共有 5 个人&#xff09;&#xff0c;k 1&#xff08;从第 1 个人开始报数&#xff09;&#xff0c; m 2&#xff08;数 2 下&#xff09;&#xff0c;则出队编号的序列为&…
阅读更多...
55.链表中环的入口节点

55.链表中环的入口节点

文章目录1.题目2.思路3.代码1.题目 给一个链表&#xff0c;若其中包含环&#xff0c;请找出该链表的环的入口结点&#xff0c;否则&#xff0c;输出null。 2.思路 &#xff08;1&#xff09;可以借鉴前面判断链表里面是否有环的思想&#xff1a;设立一个快指针&#xff0c;一…
阅读更多...
火车管订票系统

火车管订票系统

火车订票系统 基于链表&#xff0c;参考文档为C语言项目开发实战第二版&#xff0c;清华大学出版社。 #include <stdio.h> #include <stdlib.h> #include <string.h> #define HEADER1 " -------------------------------BOOK TICKET-----------------…
阅读更多...
数据结构之Go实现线性表

数据结构之Go实现线性表

文章目录线性表基础知识线性表的基本概念线性表的结构体定义线性表的实现数组顺序表切片顺序表单链表双链表线性表基础知识 线性表的基本概念 &#xff08;1&#xff09;线性表的定义 线性表是具有相同特性数据元素的一个有限序列。该序列中所含元素的个数叫作线性表的长度&a…
阅读更多...
线性链表 反转 -(递归与非递归算法)_20230420

线性链表 反转 -(递归与非递归算法)_20230420

线性链表 反转 -(递归与非递归算法)_20230420 前言 线性链表反转是非常有趣的算法&#xff0c;它可以采用多种方式实现&#xff0c;比较简洁的方法是递归反转&#xff1b;传统的方式是利用迭代反转&#xff0c;设定三个变量&#xff0c;采用类似滚动数组的方式&#xff0c;实…
阅读更多...
重学数据结构：单链表的各种操作（C语言）

重学数据结构：单链表的各种操作（C语言）

单链表的各种操作&#xff08;C语言&#xff09;单链表的定义头插法建立链表(带头节点)尾插法建立链表&#xff08;带头节点&#xff09;头插法建立链表(不带头节点)按位序插入&#xff08;带头节点&#xff09;按位序插入&#xff08;不带头节点&#xff09;指定节点的后插操作…
阅读更多...
【c++】STL——模拟实现list

【c++】STL——模拟实现list

文章目录一、前言二、结构分析节点结构迭代器结构List结构三、反向迭代器四、结语一、前言 二、结构分析 节点结构 作为链表&#xff0c;每个位置节点的结构应该设置为结构体&#xff1a; template<class T> struct list_node {list_node(const T& x T()): _nex…
阅读更多...
一问三不知之HashMap的put方法

一问三不知之HashMap的put方法

一、获取hash HashMap在put方法中&#xff0c;它使用hashCode()和equals()方法。当我们通过传递key-value对调用put方法的时候&#xff0c;HashMap使用Key hashCode()和哈希算法来找出存储key-value对的索引。 二、索引下标位置元素为空 如果索引下标位置元素为空&#xff0…
阅读更多...
数据结构——双向链表（保姆级教程，包学包会）

数据结构——双向链表（保姆级教程，包学包会）

1.双向链表的概念 双向链表就是带头双向循环链表 我们在学完单链表之后&#xff0c;就感觉这个非常简单了&#xff0c;他的主要表现就是拥有头节点&#xff0c;链表永不为空&#xff0c;不需要二级指针&#xff1b;可以通过一个节点找到上一个或者下一个节点&#xff1b;头尾…
阅读更多...
算法基础第二章

算法基础第二章

算法基础第二章 第二章&#xff1a;数据结构1、链表1.1、单链表&#xff08;写邻接表&#xff1a;存储图和树&#xff09;1.2、双链表(优化某些问题) 2、栈与队列2.1、栈2.1.1、数组模拟栈2.1.2、单调栈 2.2、队列2.2.1、数组模拟队列2.2.2、滑动窗口&#xff08;单调队列的使用…
阅读更多...
C语言数据结构注意点-线性表

C语言数据结构注意点-线性表

目录 关于指针 LinkList L和LinkList *L的区别 初始化注意点 scanf()的操作 顺序表相关操作符号的确定 关于指针 ①指针和指针变量是两个不同的概念&#xff0c;但要注意的是&#xff0c;通常我们叙述时会把指针变量简称为指针。 ②指针变量其实是一个变量&…
阅读更多...
【刷题之路Ⅱ】LeetCode 622. 设计循环队列

【刷题之路Ⅱ】LeetCode 622. 设计循环队列

LeetCode 622. 设计循环队列 一、题目描述二、解题1、方案1——数组实现&#xff0c;预留一个空判满1.1、成环思路1.2、初始化接口1.3、入队接口1.4、出队接口1.5、取队头接口1.6、取队尾接口1.7、判空接口1.8、判满接口1.9、释放接口 2、方案2——单向循环链表实现&#xff0c…
阅读更多...
HNU-操作系统-讨论课6

HNU-操作系统-讨论课6

讨论题目&#xff1a; 以一种程序设计语言为例&#xff0c;如 Java、C、Python等介绍其为实现并发控制提供的各种锁机制
阅读更多...
【数据结构】线性表——带头双向循环链表

【数据结构】线性表——带头双向循环链表

文章目录 带头双向循环链表带头双向循环链表主体结构带头双向循环链表操作函数介绍带头双向循环链表操作函数实现带头双向循环链表的初始化函数&#xff1a;打印函数带头双向循环链表插入函数&#xff1a;指定结点后插入和查找函数头插尾插 带头双向循环链表删除函数指定结点删…
阅读更多...
【lc刷题 day7】二叉搜索树与双向链表 字符串的排列 最小的k个数 连续子数组的最大和 数字序列中某一位的数字 把数字翻译成字符串

【lc刷题 day7】二叉搜索树与双向链表 字符串的排列 最小的k个数 连续子数组的最大和 数字序列中某一位的数字 把数字翻译成字符串

剑指offer 36.二叉搜索树与双向链表 medium /* // Definition for a Node. class Node {public int val;public Node left;public Node right;public Node() {}public Node(int _val) {val _val;}public Node(int _val,Node _left,Node _right) {val _val;left _left;right…
阅读更多...
两数相加，链表应用 答案解析leetcode力扣

两数相加，链表应用 答案解析leetcode力扣

题目 两数相加 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0c;这两…
阅读更多...
算法训练 —— 链表（2）

算法训练 —— 链表（2）

目录 1. LeetCode24. 两两交换链表中的结点 2. LeetCode19. 删除链表的倒数第N个节点 3. LeetCode160.相交链表 4. LeetCode141.环形链表 5. LeetCode142.环形链表II 6. LeetCode138.复制带随机指针的链表 1. LeetCode24. 两两交换链表中的结点 两两交换链表中的结点 …
阅读更多...
HashMap 这套八股，不得背个十来遍？

HashMap 这套八股，不得背个十来遍？

HashMap、HashTable、ConcurrentHashMap 这一套感觉今年面试都不怎么问了&#xff0c;场景题越来越多&#xff0c;求职的门槛越来越高&#xff0c;这种常见的面试题问出来大概率就是要送波分了。 讲讲 HashMap 的底层结构和原理 HashMap 就是以 Key-Value 的方式进行数据存储…
阅读更多...
( “树” 之 BST) 109. 有序链表转换二叉搜索树 ——【Leetcode每日一题】

( “树” 之 BST) 109. 有序链表转换二叉搜索树 ——【Leetcode每日一题】

二叉查找树&#xff08;BST&#xff09;&#xff1a;根节点大于等于左子树所有节点&#xff0c;小于等于右子树所有节点。 二叉查找树中序遍历有序。 109. 有序链表转换二叉搜索树 给定一个单链表的头节点 head &#xff0c;其中的元素 按升序排序 &#xff0c;将其转换为高度…
阅读更多...
HashMap简单问答总结

HashMap简单问答总结

1、HashMap的初始长度是怎么计算的&#xff1f; 默认是这么实现的 给定一个数&#xff0c;例如12&#xff0c; 先往右移1位&#xff0c;或上之后再移2位&#xff0c;或之后再移4位等等&#xff0c;一直移到16位叫返回给定目标容量的二次幂。 2、 HashMap是怎么计算的 高16位和低…
阅读更多...
从尾到头打印链表（入门算法03）

从尾到头打印链表（入门算法03）

题目&#xff1a;输入一个链表的头节点&#xff0c;从尾到头反过来返回每个节点的值&#xff08;用数组返回&#xff09;。 实例&#xff1a; 输入&#xff1a;head [1,3,2] 输出&#xff1a;[2,3,1] 解题思路&#xff1a;这个貌似很简单&#xff0c;反转其实很容易想到可以使…
阅读更多...
集合选型规则

集合选型规则

总结-开发中如何选择集合实现类(记住) 先判断存储的类型 (一组对象[单列]或一组键值对[双列])一组对象[单列]:Collection接口允许重复:List 增删多:LinkedList [底层维护了一个双向链表] 改查多: ArrayList [底层维护Object类型的可…
阅读更多...
单链表归并排序c语言

单链表归并排序c语言

别忘记断链哦!!! 核心思路:利用快慢指针找到分治中点,其余和数组的归并无异 单链表别带头节点 #include <stdio.h> #include <stdlib.h> #include<stdbool.h>typedef int Elemtype;typedef struct LNode {Elemtype data;struct LNode *next; } LNode,*Li…
阅读更多...
leetcode：链表的中间结点

leetcode：链表的中间结点

1.题目描述 题目链接&#xff1a;876. 链表的中间结点 - 力扣&#xff08;LeetCode&#xff09; 我们先看题目描述&#xff1a; 2.解题思路 我们用画图用快慢指针来解决这个问题 定义一个快指针fast&#xff0c;一个慢指针slow 快指针一次走两个结点&#xff0c;慢指针一次…
阅读更多...
【数据结构初阶】单链表（附全部码源）

【数据结构初阶】单链表（附全部码源）

单链表 1&#xff0c;单链表的概念及结构2&#xff0c;单链表的实现2.1初始化内容&#xff08;所需文件&#xff0c;接口&#xff09;2.2申请结点2.3打印单链表2.4尾插2.5头插2.6尾删2.7头删2.8查找2.9在pos位置之后插入2.10在pos位置前面插入2.11删除pos之后的值2.12删除pos位…
阅读更多...
双向链表的知识点+例题

双向链表的知识点+例题

1.链表的种类 题中常考查以下两种&#xff1a; 上一讲我们学了无头单向非循环链表&#xff0c;这节&#xff0c;让我们看一下双向链表的操作吧~ 2基本操作 1&#xff0c;定义双向链表 2&#xff0c;创建一个节点 3&#xff0c;初始化双链表 4&#xff0c;尾插一个节点 5打印…
阅读更多...
工作流(1):表格设计

工作流(1):表格设计

我们对工厂流水线的工作流进行设计 比如 &#xff1a;组件装配&#xff0c;拍照-清洗-焊接-下料等 使用mysql数据库&#xff0c;主要工作流相关表有&#xff1a; 一、操作工序(环节、节点)表&#xff1a;work_procedure 所有操作工序(环节、节点)枚举 DROP TABLE IF EXIST…
阅读更多...
leetcode刷题日记:141. Linked List Cycle（环形链表）

leetcode刷题日记:141. Linked List Cycle（环形链表）

这一题是给我们一个链表让我们判断这是否是一个环形链表&#xff0c;我们知道如果一个链表中有环的话这一个链表是没有办法访问到尾的&#xff0c; 假若有如图所示的带环链表&#xff1a; 我们从图示中很容易看出来这一个链表在访问的时候会在里面转圈&#xff0c;我们再来看看…
阅读更多...
栈与队列：用栈实现队列

栈与队列：用栈实现队列

目录 题目&#xff1a; 栈与队列的数据模型对比&#xff1a; 思路分析&#x1f387;&#xff1a; 代码分析&#xff1a; 一、定义队列 二、初始化队列 三、入队 四、出队⭐ 代码解析&#xff1a; 五、获取队头元素 六、查看队列是否为空 七、销毁队列 完整代码 …
阅读更多...
《LeetCode力扣练习》代码随想录——链表（删除链表的倒数第N个节点---Java）

《LeetCode力扣练习》代码随想录——链表（删除链表的倒数第N个节点---Java）

《LeetCode力扣练习》代码随想录——链表&#xff08;删除链表的倒数第N个节点—Java&#xff09; 刷题思路来源于 代码随想录 19. 删除链表的倒数第 N 个结点 双指针 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* …
阅读更多...
链表指定结点的删除

链表指定结点的删除

删除节点就是将指定结点从链表中删除。 删除节点分为两种情况&#xff0c;一种是链表头删除&#xff0c;另一中链表中间或尾部删除。将待删节点于前一结点解除指向(中间或尾部)或直接删除该节结点并重建链表头(头节点)。 删除结点有以下情况&#xff1a; 1.链表为空&#xf…
阅读更多...
【C数据结构】单链表的基本操作（多功能+思路+图解+代码备注+完整代码+效果图）

【C数据结构】单链表的基本操作（多功能+思路+图解+代码备注+完整代码+效果图）

文章目录 前言1、单链表的定义2、结点的申请3、单链表的插入3.1、头插3.2、尾插3.3、在第i位插入 4、单链表的删除4.1、头删4.2、尾删4.3、在第i位删除 6、单链表的查找6.1、按值查找6.2、按位查找6.3、两者查找到后的更多的操作&#xff1a;插入操作&#xff1a;6.3.1、在第po…
阅读更多...
【经典题】二叉搜索树与双向链表

【经典题】二叉搜索树与双向链表

二叉搜索树与双向链表链接 解题思路 思路1 &#xff1a; 中序遍历&#xff0c;将节点放进vector中&#xff0c;再改链接关系&#xff0c;这很容易想出并解决&#xff0c;但这样明显不符合题意。 思路2&#xff1a; 这道题目要求将一个二叉搜索树转换成一个排序的双向链表&a…
阅读更多...
Java 编程技巧之数据结构

Java 编程技巧之数据结构

使用HashSet判断主键是否存在 HashSet 实现 Set 接口&#xff0c;由哈希表&#xff08;实际上是 HashMap &#xff09;实现&#xff0c;但不保证 set 的迭代顺序&#xff0c;并允许使用 null 元素。HashSet 的时间复杂度跟 HashMap 一致&#xff0c;如果没有哈希冲突则时间复杂…
阅读更多...
C++ STL 之双向队列 deque 详解

C++ STL 之双向队列 deque 详解

文章目录Part.I AttentionPart.II FuncitonPart.III CodePart.I Attention deque 是 double-ended queue 的缩写&#xff0c;意即双端队列&#xff0c;详细信息参见官网。deque<T>容器适配器是必须要包含头文件#include <deque>deque相较于vector&#xff1a;①它不…
阅读更多...
什么是链表，如何实现？（单链表篇）

什么是链表，如何实现？（单链表篇）

欢迎来到 Claffic 的博客 &#x1f49e;&#x1f49e;&#x1f49e; “仅仅活着是不够的&#xff0c;还需要有阳光&#xff0c;自由和花的芬芳。” 前言&#xff1a; 在日常使用的网站和软件中&#xff0c;列表属于最常见的一种东西了&#xff0c;其实现形式有顺序表&#xff0…
阅读更多...
JavaSE-集合框架013-队列Queue及双端队列Deque

JavaSE-集合框架013-队列Queue及双端队列Deque

原文链接 Queue 我们可以把LinkedList当作队列来用&#xff0c;也可以当作链表来用。LinkedList只是一个实现方式&#xff0c;但是可以具备很多特点 虽然他是一个链表&#xff0c;但是当你从后加从前取&#xff0c;就是队列&#xff08;Queue&#xff09;。当你从后加从后取&a…
阅读更多...
对链表学习的总结一

对链表学习的总结一

一，单链表结构定义 C/C++ 数组：一组具有相同类型数据的集合。结构体：不同类型数据的集合。 // Definition for singly-linked list. struct ListNode {int val;ListNode *next;ListNode(int x) : val(x), next
阅读更多...
数据结构与算法之《带头双向循环链表》详解

数据结构与算法之《带头双向循环链表》详解

文章目录 一、带头双向循环链表概念及结构 1、1 带头双向循环链表的概念 1、2 带头双向循环链表的结构 二、带头双向循环链表的思路及代码实现详解 2、1 带头双向循环链表实现思路 2、2 带头双向循环链表的模块细节及代码实现 2、2、1 结构体的声明与定义 2、2、2 初始化结构体…
阅读更多...
c++创建链表

c++创建链表

#include<iostream> #include<stdlib.h> using namespace std; struct Student {int num;float score;struct Student *next;}stu;void Creat(){int n; cout<<"请输入需要创建的学生数&#xff1a;"<<endl; cin>>n;struct Student *p,…
阅读更多...
栈应用——逆波兰算法

栈应用——逆波兰算法

个人主页&#xff1a;【&#x1f60a;个人主页】 系列专栏&#xff1a;【❤️数据结构与算法】 学习名言&#xff1a;传屐朝寻药&#xff0c;分灯夜读书 系列文章目录 第一章 ❤️ 学前知识 第二章 ❤️ 单向链表 第三章 ❤️ 递归 第四章 ❤️ 顺序栈 第五章 ❤️ 队列 文章目…
阅读更多...
(链表专题) 725. 分隔链表 ——【Leetcode每日一题】

(链表专题) 725. 分隔链表 ——【Leetcode每日一题】

725. 分隔链表 给你一个头结点为 head 的单链表和一个整数 k &#xff0c;请你设计一个算法将链表分隔为 k 个连续的部分。 每部分的长度应该尽可能的相等&#xff1a;任意两部分的长度差距不能超过 1 。这可能会导致有些部分为 null 。 这 k 个部分应该按照在链表中出现的顺…
阅读更多...
数据结构（C语言实现）——链表的介绍及基本操作的实现（单链表+带头双向循环链表）

数据结构（C语言实现）——链表的介绍及基本操作的实现（单链表+带头双向循环链表）

文章目录1. 前言2. 链表2.1 链表的概念及结构2.2 链表的分类3. 单链表3.1 结构类型3.2 创建结点3.3 打印链表3.4 尾部插入和删除3.5 头部插入和删除3.6 查找结点3.7 在某个位置插入和删除4. 带头双向循环链表4.1 结构类型4.2 创建结点4.3 初始化链表4.4 打印链表4.5 尾部插入和…
阅读更多...
带头单向链表源码及相关练习

带头单向链表源码及相关练习

目录 移除链表元素 链表的中间节点 链表倒数第k个节点 合并两个有序链表 相交链表 环形链表 环形链表2 分割链表 回文链表 public class MySingleList {//内部类的使用class ListNode {public int val;public ListNode next;public ListNode(int val) {this.val val;}…
阅读更多...
【数据结构】二叉树经典oj题

【数据结构】二叉树经典oj题

&#x1f680;write in front&#x1f680; &#x1f4dc;所属专栏&#xff1a;初阶数据结构 &#x1f6f0;️博客主页&#xff1a;睿睿的博客主页 &#x1f6f0;️代码仓库&#xff1a;&#x1f389;VS2022_C语言仓库 &#x1f3a1;您的点赞、关注、收藏、评论&#xff0c;是对…
阅读更多...
Java集合框架List接口

Java集合框架List接口

目录 List接口概念 List接口常用的方法 示例 List接口概念 Java集合框架中的List接口是一种有序的集合，它可以存储重复的元素。它是Collection接口的子接口，提供了一系列可以对列表进行操作的方法，如添加、插入、删除、获取元素等。List接口还可以通过索引访问元素，类似…
阅读更多...
用纯C实现单链表

用纯C实现单链表

前言 什么是单链表&#xff1f;链表是一种物理存储结构上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。链表的创建 需要创建一个小项目工程 创建三个文件 ⭐SListNode.h放单链表的头文件&#xff0c;函数声明 ⭐SListNode.c放单…
阅读更多...
单链表——简单的增删查改

单链表——简单的增删查改

前言&#xff1a;上次介绍了顺序表&#xff0c;这次我要分享对单链表的一些简单理解&#xff0c;主要框架与上次大致相同&#xff0c;内容主要是单链表的增删查改&#xff0c;适用于初学者&#xff0c;之后会继续更新一些更深入的内容。同时&#xff0c;这也仅仅是我个人对所学…
阅读更多...
二叉树（三）

二叉树（三）

我们之前对树和二叉树有了基本的了解&#xff0c;然后我们进一步对二叉树的性质进行分类。小伙伴们如果有疑问或者感兴趣的可以看一下我之前写的两篇博客。二叉树&#xff08;一&#xff09;&#xff1a;二叉树&#xff08;一&#xff09;_染柒_GRQ的博客-CSDN博客二叉树&#…
阅读更多...
Python双向链表的操作

Python双向链表的操作

目录 一、双向链表 双向链表示例图 二、双向链表的操作 1、判断链表是否为空 2&#xff0c;链表长度 3&#xff0c;遍历整个链表 4&#xff0c;在链表头部添加元素 5、链表尾部添加元素 6&#xff0c;在指定位置插入元素 7&#xff0c;修改指定位置的元素 8&#xff0…
阅读更多...
【新2023】华为OD机试 - 货币单位换算（Python）

【新2023】华为OD机试 - 货币单位换算（Python）

华为 OD 清单查看地址：blog.csdn.net/hihell/category_12199275.html 货币单位换算 题目 记账本上记录了若干条多国货币金额，需要转换成人民币分（fen），汇总后输出。 每行记录一条金额，金额带有货币单位，格式为数字+单位，可能是单独元，或者单独分，或者元与分的组合…
阅读更多...
追梦之旅【数据结构篇】——详解C语言实现动态版顺序栈

追梦之旅【数据结构篇】——详解C语言实现动态版顺序栈

详解C语言动态实现顺序栈~&#x1f60e;前言&#x1f64c;预备小知识&#x1f49e;栈的概念及结构整体实现内容分析&#x1f49e;1.头文件编码实现&#x1f64c;2.功能文件编码实现&#x1f64c;3.测试文件的编写&#xff1a;&#x1f64c;总结撒花&#x1f49e;&#x1f60e;博…
阅读更多...
【 K 个一组翻转链表_25】

【 K 个一组翻转链表_25】

大神的代码&#xff0c;学完了。核心在于怎么切分为k以及基于链表本身进行反转 public ListNode reverseKGroup_v2(ListNode head, int k){ListNode pHead new ListNode(-1, head);ListNode pre pHead;while(true){ListNode last pre.next;//保证每次切分为kfor(int i0;i&…
阅读更多...
leetcode142_环形链表 II

leetcode142_环形链表 II

文章目录 题目详情分析Java完整代码 题目详情 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给…
阅读更多...
Java ArrayList 和 LinkList 原理对比

Java ArrayList 和 LinkList 原理对比

Java 中的 ArrayList 和 LinkedList 都是实现了 List 接口的集合类它们都允许添加、删除和修改元素。但是它们的底层实现原理不同导致它们在不同的场景下拥有不同的优劣势。 ArrayListArrayList 的底层是通过数组实现的因此它具有数组的特性。它允许快速随机访问元素但是在插入…
阅读更多...
代码随想录--链表--移除链表元素题型

代码随想录--链表--移除链表元素题型

这里补充一下链表理论基础知识&#xff1a; 链表的存储方式&#xff1a; 数组在内存中是连续分布的&#xff0c;但是链表在内存中可不是连续分布的。链表是通过指针域的指针连接在内存中各个节点&#xff0c;所以链表中的节点在内存中不是连续分布的&#xff0c;而是散乱分布…
阅读更多...
【数据结构】链表OJ：力扣160. 相交链表

【数据结构】链表OJ：力扣160. 相交链表

最近这几篇内容都有关链表&#xff0c;接下来几篇内容会分享一些链表的OJ题&#xff0c;希望对你有所帮助。 今天要分享的内容是力扣160. 相交链表&#xff1a;160. 相交链表 - 力扣&#xff08;LeetCode&#xff09; 目录 题目&#xff1a; 题解 题目&#xff1a; 给你…
阅读更多...
单链表的成环问题

单链表的成环问题

前言&#xff1a;链表成环问题不仅考察双指针的用法&#xff0c;该问题还需要一定的数学推理和分析能力&#xff0c;看似简单的题目实则细思缜密&#xff0c;值得斟酌~ 目录 1.问题背景引入-判断链表是否成环&#xff1a; 1.1.正解&#xff1a;快慢指针 1.2 STL的集合判重 …
阅读更多...
Java 与数据结构（2）：链表

Java 与数据结构（2）：链表

一、链表 链表是一种常见的数据结构&#xff0c;它由一系列节点组成&#xff0c;每个节点包含两部分&#xff1a;数据和指向下一个节点的指针。链表中的第一个节点称为头节点&#xff0c;最后一个节点称为尾节点&#xff0c;尾节点的指针指向 NULL。 相比于数组&#xff0c;链…
阅读更多...
【小菜鸡刷题记】---链表篇

【小菜鸡刷题记】---链表篇

【小菜鸡刷题记】---链表篇 剑指 Offer 06. 从尾到头打印链表反转实现利用栈的特性递归实现 剑指 Offer 24. 反转链表头插法 剑指 Offer 35. 复杂链表的复制哈希迭代节点拆分 剑指 Offer 06. 从尾到头打印链表 剑指 Offer 06. 从尾到头打印链表 输入一个链表的头节点&#xff…
阅读更多...
【十字链表,邻接多重表（无向图的另一种链式存储结构）,图的遍历】

【十字链表,邻接多重表（无向图的另一种链式存储结构）,图的遍历】

文章目录 十字链表邻接多重表&#xff08;无向图的另一种链式存储结构&#xff09;图的遍历 十字链表 方便找到入度和出度边。 顶点结点&#xff1a; data&#xff1a;顶点存放的数据域。 firstin&#xff1a;第一个入度边。 firstout&#xff1a;第一个出度边。 弧度结点&am…
阅读更多...
【Java中的DoubleLinkedList数据结构及应用场景】

【Java中的DoubleLinkedList数据结构及应用场景】

DoubleLinkedList是Java中的一种链表数据结构&#xff0c;它是双向链表的一种形式。本文将详细介绍DoubleLinkedList的特性、实现和应用场景&#xff0c;并在文章最后提供MarkDown格式的示例。 一、DoubleLinkedList简介 DoubleLinkedList是Java中一种双向链表数据结构&#…
阅读更多...
二叉树的最大深度[简单]

二叉树的最大深度[简单]

优质博文&#xff1a;IT-BLOG-CN 一、题目 给定一个二叉树root&#xff0c;返回其最大深度。 二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。 示例 1&#xff1a; 输入&#xff1a;root [3,9,20,null,null,15,7] 输出&#xff1a;3 示例 2&#xff1a…
阅读更多...
链表：C++实现

链表：C++实现

引言&#xff1a; 链表是一种常见的数据结构&#xff0c;它由一系列节点组成&#xff0c;每个节点包含一个数据元素和一个指向下一个节点的指针。相比于数组&#xff0c;链表具有动态性和灵活性&#xff0c;可以高效地进行插入和删除操作&#xff0c;但是查找操作的时间复杂度较…
阅读更多...
大厂真题：【模拟】阿里蚂蚁2023秋招-奇偶操作

大厂真题：【模拟】阿里蚂蚁2023秋招-奇偶操作

题目描述与示例 题目描述 小红有一个长度为n的数组a&#xff0c;她将对数组进行m次操作&#xff0c;每次操作有两种类型&#xff1a; 将数组中所有值为奇数的元素加上x将数组中所有值为偶数的元素加上x 请你输出m次操作后的数组 输入描述 第一行两个整数n和m&#xff0c;…
阅读更多...
Java 算法篇-链表的经典算法：判断回文链表、判断环链表与寻找环入口节点(“龟兔赛跑“算法实现)

Java 算法篇-链表的经典算法：判断回文链表、判断环链表与寻找环入口节点(“龟兔赛跑“算法实现)

&#x1f525;博客主页&#xff1a; 【小扳_-CSDN博客】 ❤感谢大家点赞&#x1f44d;收藏⭐评论✍ 文章目录 1.0 链表的创建 2.0 判断回文链表说明 2.1 快慢指针方法 2.2 使用递归方式实现反转链表方法 2.3 实现判断回文链表 - 使用快慢指针与反转链表方法 3.0 判断环链表说明…
阅读更多...
环形链表和相交链表OJ题

环形链表和相交链表OJ题

环形链表和相交链表OJ题 这篇博客详细讲解了环形数组和相交数组的问题 文章目录 环形链表和相交链表OJ题一、环形链表e.g.1e.g.2 二、相交链表 一、环形链表 环形列表是指尾结点next不指向NULL了&#xff0c;而是指向包括自己的前面任意一个结点。 e.g.1 题目及要求&#xf…
阅读更多...
C专家编程 —— 对链接的思考

C专家编程 —— 对链接的思考

文章目录 编译器的作用动态链接和静态链接动态链接动态链接的优点 函数库链接的几个小秘密 编译器的作用 通常编译器被氛围六七个小的程序&#xff1a; C预处理器&#xff0c;得到main.i文件前端做语法语义分析&#xff0c;然后后端生成汇编的指令代码main.s文件优化器可以放…
阅读更多...
力扣每日一题82：删除排序链表中的重复元素||

力扣每日一题82：删除排序链表中的重复元素||

题目描述&#xff1a; 给定一个已排序的链表的头 head &#xff0c; 删除原始链表中所有重复数字的节点&#xff0c;只留下不同的数字 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,3,4,4,5] 输出&#xff1a;[1,2,5]示例 2&#xff1a; 输入&…
阅读更多...
2.1 Windows驱动开发：内核链表与结构体

2.1 Windows驱动开发：内核链表与结构体

在Windows内核中&#xff0c;为了实现高效的数据结构操作&#xff0c;通常会使用链表和结构体相结合的方式进行数据存储和操作。内核提供了一个专门用于链表操作的数据结构LIST_ENTRY&#xff0c;可以用来描述一个链表中的每一个节点。 使用链表来存储结构体时&#xff0c;需要…
阅读更多...
浅尝链表带环问题（LeetCode：141，142 环形链表）

浅尝链表带环问题（LeetCode：141，142 环形链表）

目录 前言 一&#xff0c;问题分析 1.1环形链表 I 1.2 环形链表II 二&#xff0c;是否带环分析 2.1推荐使用“二指针” 为什么不使用“一指针” 2.2思路分析 2.3代码实现 三&#xff0c;带环 - 入环节点 2.1思路分析 2.2代码实现 前言 小伙伴们大家好啊&#xf…
阅读更多...
C++删除单链表指定元素

C++删除单链表指定元素

C删除单链表指定元素 对于C单链表的创建与打印操作之前已经讲述过&#xff0c;那么普通的元素删除也可以很容易实现。在力扣203.移除链表元素中提出了一种元素删除操作&#xff0c;题目如下&#xff1a; 本来觉得很简单&#xff0c;但是在实现的过程中遇到了很多问题。这道题…
阅读更多...
CSDN每日一题学习训练——Java版（对给定的两个日期之间的日期进行遍历、子集 II、填充每个节点的下一个右侧节点指针）

CSDN每日一题学习训练——Java版（对给定的两个日期之间的日期进行遍历、子集 II、填充每个节点的下一个右侧节点指针）

版本说明 当前版本号[20231107]。 版本修改说明20231107初版 目录 文章目录 版本说明目录对给定的两个日期之间的日期进行遍历题目解题思路代码思路参考代码 子集 II题目解题思路代码思路参考代码 填充每个节点的下一个右侧节点指针题目解题思路代码思路参考代码 对给定的两…
阅读更多...
《程序设计基础》 第八章 指针 6-1 计算两数的和与差 (10 分)

《程序设计基础》 第八章 指针 6-1 计算两数的和与差 (10 分)

本题要求实现一个计算输入的两数的和与差的简单函数。 函数接口定义&#xff1a; void sum_diff( float op1, float op2, float *psum, float *pdiff ); 其中op1和op2是输入的两个实数&#xff0c;*psum和*pdiff是计算得出的和与差。 裁判测试程序样例&#xff1a; #inclu…
阅读更多...
【数据结构和算法】数据结构基础和算法思想

【数据结构和算法】数据结构基础和算法思想

文章目录 1. 基础的一些数据结构&#xff08;1&#xff09;数组&#xff08;2&#xff09;链表&#xff08;3&#xff09;二叉树&#xff08;4&#xff09;哈希表 2. 有哪些常见的算法思想&#xff1f;3. 常见排序算法及其复杂度 1. 基础的一些数据结构 &#xff08;1&#xf…
阅读更多...
ArrayList,LinkedList和Vector的区别

ArrayList,LinkedList和Vector的区别

他们三个都是属于java.util包中的List接口&#xff0c;均为可以伸缩的数组可以动态改变长度 ArrayList和Vector ArrayList和Vector都是基于Object[] array实现的&#xff0c;他们会在内存中开辟连续地址&#xff0c;由于地址连续他们支持用下标搜索数据&#xff0c;同时索引数…
阅读更多...
单链表OJ题：LeetCode--206.反转链表

单链表OJ题：LeetCode--206.反转链表

朋友们、伙计们&#xff0c;我们又见面了&#xff0c;今天给大家带来的是LeetCode中206题&#xff1a;反转链表 数 据 结 构&#xff1a;数据结构专栏 作 者&#xff1a;stackY、 C 语 言 &#xff1a;C语言专栏 LeetCode &#xff1a;LeetCode刷题训练营 LeetCod…
阅读更多...
Java实现双向链表及其常规操作

Java实现双向链表及其常规操作

数据结构链表的学习结束了&#xff0c;我已经将重要的三种链表的简单实现整理并发布在了博客上&#xff0c;希望我的文章可以给有需要的朋友们带来帮助&#xff0c;也希望大家可以指出我存在的问题&#xff0c;共同进步&#xff0c;2022年冲刺大厂☺☺(*&#xffe3;︶&#xf…
阅读更多...
链表经典练习题合集（Java版）

链表经典练习题合集（Java版）

最近开始了数据结构的学习&#xff0c;数据结构是比较抽象的&#xff0c;需要不断的进行画图总结&#xff0c;不断地刷相关的题来加强自己对于数据结构的理解&#xff0c;我会不断地更新博客以及上传自己的做题记录以及题解&#xff0c;希望可以给大家带来帮助&#xff0c;也希…
阅读更多...
高并发内存池项目（C++实战项目）

高并发内存池项目（C++实战项目）

文章目录&#x1f384;项目介绍◎项目来源▶项目源码◎内存池相关知识1、池化技术2、内存池3、内存池主要解决的问题4、malloc&#x1f384;设计思路◎第一阶段–设计一个定长的内存池适应平台的指针方案◎第二阶段–高并发内存池整体框架设计1.线程缓存&#xff08;thread cac…
阅读更多...
LeetCode刷题--- 61. 旋转链表（快慢指针+闭合为环）

LeetCode刷题--- 61. 旋转链表（快慢指针+闭合为环）

&#x1f48c; 所属专栏&#xff1a;【LeetCode题解&#xff08;持续更新中&#xff09;】 &#x1f600; 作  者&#xff1a;我是夜阑的狗&#x1f436; &#x1f680; 个人简介&#xff1a;一个正在努力学技术的码仔&#xff0c;专注基础和实战分享 &#xff0c;欢迎…
阅读更多...
代码随想录刷题-链表-设计链表

代码随想录刷题-链表-设计链表

文章目录设计链表习题我的解法代码随想录代码设计链表 本节对应代码随想录中&#xff1a;代码随想录&#xff0c;讲解视频&#xff1a;帮你把链表操作学个通透&#xff01;LeetCode&#xff1a;707.设计链表_哔哩哔哩_bilibili 习题 题目链接&#xff1a;707. 设计链表 - 力…
阅读更多...
【数据结构】链式二叉树

【数据结构】链式二叉树

前言 在前面我们学习了一些二叉树的基本知识&#xff0c;了解了它的结构以及一些性质&#xff0c;我们还用数组来模拟二叉树建立了堆&#xff0c;并学习了堆排序&#xff0c;可是数组结构的二叉树有很大的局限性&#xff0c;平常我们用的最多树结构的还是链式二叉树&#xff0c…
阅读更多...
【数据结构】万字深入浅出讲解单链表（附原码 | 超详解）

【数据结构】万字深入浅出讲解单链表（附原码 | 超详解）

&#x1f680;write in front&#x1f680; &#x1f4dd;个人主页&#xff1a;认真写博客的夏目浅石. &#x1f381;欢迎各位→点赞&#x1f44d; 收藏⭐️ 留言&#x1f4dd; &#x1f4e3;系列专栏&#xff1a;C语言实现数据结构 &#x1f4ac;总结&#xff1a;希望你看完…
阅读更多...
链表刷题(9-11)

链表刷题(9-11)

目录 相交链表 环形链表 环形链表Ⅱ 相交链表 力扣 第一种思路&#xff1a;判断尾节点地址是否相同&#xff0c;时间复杂度为O(N^2)。 第二种思路&#xff1a;(节点对齐)记录两个链表节点个数&#xff0c;再根据节点差设置两个快慢指针进行next节点比对。时间复杂度O(N)(3N)…
阅读更多...
初阶数据结构之队列

初阶数据结构之队列

目录 写在前面的话&#xff1a; 一&#xff0c;什么是队列 1.1队列基本结构 1.2队列实现结构 二&#xff0c;基本功能实现 2.1创建队列 2.2初始化队列 2.3队尾入队列 2.4队首出队列 2.5获取队列头部和尾部元素 2.6获取队列中元素个数 2.7检测队列是否为空 2.8释放队…
阅读更多...
Java集合介绍和使用场景

Java集合介绍和使用场景

集合的分类 集合List和Set都继承于Collection&#xff0c;都是单个储存元素的都是可以迭代的。 1. List 特点是是可重复、有序的&#xff0c;存入和迭代取出的次序相同。List的子类又有ArrayList、LinkedList、Vector。 ArrayList 底层采用数组结构存储&#xff0c;适合做查…
阅读更多...
206. 反转链表

206. 反转链表

总结 方法&#xff1a; 迭代递归 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例2: 输入&#xff1a;head [1,2] 输出&#xff1a;[2,1]示例3: …
阅读更多...
反转链表II（C++解法）

反转链表II（C++解法）

题目 给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], left 2, right 4 输出&#xff1a;[1…
阅读更多...
剑指offer JZ22 链表中倒数最后k个结点

剑指offer JZ22 链表中倒数最后k个结点

Java JZ22 链表中倒数最后k个结点 文章目录Java JZ22 链表中倒数最后k个结点一、题目描述二、先找长度再找k法三、快慢双指针法使用先找长度再找k法和快慢指针法解决剑指offer 第JZ22题链表中倒数最后k个结点的问题。 一、题目描述 输入一个长度为 n 的链表&#xff0c;设链表中…
阅读更多...
6-4图-十字链表与邻接多重表

6-4图-十字链表与邻接多重表

十字链表、邻接多重表 一.基础知识 十字链表&#xff1a;存储有向图 邻接多重表&#xff1a;存储无向图 二.进阶 1.十字链表&#xff08;有向图&#xff09; &#xff08;1&#xff09;顶点结点 data&#xff1a;当前顶点&#xff0c;如A firstin&#xff1a;指入&#xff08…
阅读更多...
静态链表（数组模拟单链表）

静态链表（数组模拟单链表）

文章目录1.题目1.1 图解1.2使用静态链表(数组模拟链表)C代码实现1.3 使用静态链表(列表模拟链表)python实现1.题目 实现一个单链表&#xff0c;链表初始为空&#xff0c;支持三种操作&#xff1a; 向链表头插入一个数&#xff1b;删除第 k 个插入的数后面的数&#xff1b;在第…
阅读更多...
leetcode141：环形链表

leetcode141：环形链表

给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;…
阅读更多...
【存储技术分享】SGL和SGE

【存储技术分享】SGL和SGE

1、SGL Scatter Gather List&#xff08;SGL&#xff09;是一种数据结构&#xff0c;用于描述分散存储的数据块&#xff08;即散布在不同的物理地址上的数据块&#xff09;和聚合存储的数据块&#xff08;即连续存储在同一物理地址上的数据块&#xff09;。SGL由多个元素组成&…
阅读更多...
设计链表(链表篇)

设计链表(链表篇)

你可以选择使用单链表或者双链表&#xff0c;设计并实现自己的链表。 单链表中的节点应该具备两个属性&#xff1a;val 和 next 。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。 如果是双向链表&#xff0c;则还需要属性 prev 以指示链表中的上一个节点…
阅读更多...
每日一题137——删除链表的节点

每日一题137——删除链表的节点

给定单向链表的头指针和一个要删除的节点的值&#xff0c;定义一个函数删除该节点。 返回删除后的链表的头节点。 注意&#xff1a;此题对比原题有改动 示例 1: 输入: head [4,5,1,9], val 5 输出: [4,1,9] 解释: 给定你链表中值为 5 的第二个节点&#xff0c;那么在调用…
阅读更多...
冲刺春招-精选笔面试 66 题大通关 day22（完）

冲刺春招-精选笔面试 66 题大通关 day22（完）

day22题目&#xff1a;151. 颠倒字符串中的单词、46. 全排列、2. 两数相加 今日知识点&#xff1a;字符串、递归、链表&#xff0c;难度为中等、中等、中等 学习计划链接&#xff1a;冲刺春招-精选笔面试 66 题大通关 昨日题目链接&#xff1a;冲刺春招-精选笔面试 66 题大通…
阅读更多...
冲刺春招-精选笔面试 66 题大通关 day19

冲刺春招-精选笔面试 66 题大通关 day19

day19题目&#xff1a;160. 相交链表、143. 重排链表、142. 环形链表 II 今日知识点&#xff1a;链表、递归、双指针&#xff0c;难度为简单、中等、中等 学习计划链接&#xff1a;冲刺春招-精选笔面试 66 题大通关 昨日题目链接&#xff1a;冲刺春招-精选笔面试 66 题大通关…
阅读更多...
MySTL实现之MyList

MySTL实现之MyList

MySTL实现 实现STL库中的基础容器及基本函数 文章目录MySTL实现MyList一、结点的基类二、迭代器三、MyList类四、测试总结MyList 平时很少使用STL中的List容器&#xff0c;因此在实现的时候走了很多弯路&#xff0c;也借鉴了不少博主的实现方式&#xff0c;在结合自己的理解进…
阅读更多...
《程序员面试金典（第6版）》面试题 02.01. 移除重复节点（哈希映射，多指针暴力破解，链表）

《程序员面试金典（第6版）》面试题 02.01. 移除重复节点（哈希映射，多指针暴力破解，链表）

题目描述 编写代码&#xff0c;移除未排序链表中的重复节点。保留最开始出现的节点。 题目传输门&#xff1a;面试题 02.01. 移除重复节点 示例1: 输入&#xff1a;[1, 2, 3, 3, 2, 1]输出&#xff1a;[1, 2, 3]示例2: 输入&#xff1a;[1, 1, 1, 1, 2]输出&#xff1a;[1, 2]…
阅读更多...
【Go LeetDay】总目录（1~83）

【Go LeetDay】总目录（1~83）

Leetcode Golang Day1~10 Golang每日一练(leetDay0001) 1. 两数之和 Two Sum 2. 两数相加 Add Two Numbers 3. 无重复字符的最长子串 Longest-substring-without-repeating-characters Golang每日一练(leetDay0002) 4. 寻找两个正序数组的中位数 Median of two sorted arra…
阅读更多...
21天学会C++：Day7----auto关键字

21天学会C++：Day7----auto关键字

CSDN的uu们&#xff0c;大家好。这里是C入门的第七讲。 座右铭&#xff1a;前路坎坷&#xff0c;披荆斩棘&#xff0c;扶摇直上。 博客主页&#xff1a; 姬如祎 收录专栏&#xff1a;C专题 目录 1. 知识引入 2. auto的使用 2.1 auto与指针和引用结合起来使用 2.2 在同一…
阅读更多...
链表

链表

声明&#xff1a;本文主要作为作者的复习笔记&#xff0c;由于作者水平有限&#xff0c;难免有错误和不准确之处&#xff0c;欢迎读者批评指正。 目录快捷跳转为什么引入链表&#xff1f;链表类似生活中的火车结构链表类和节点的定义问题单向链表单向不带头链表单向带头链表虚拟…
阅读更多...
算法训练~替换空格、递归思想的应用(从尾到头打印链表、二叉树重建)

算法训练~替换空格、递归思想的应用(从尾到头打印链表、二叉树重建)

目录 替换空格 从头到尾打印链表 重建二叉树 替换空格 题目链接&#xff1a;替换空格 题目描述&#xff1a; 请实现一个函数&#xff0c;将一个字符串中的每个空格替换成“%20”。例如&#xff0c;当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。 解…
阅读更多...
【C++】STL---list的模拟实现

【C++】STL---list的模拟实现

目录前言一、list和vector的区别二、节点的定义三、list类定义四、push_back函数五、push_front函数六、迭代器七、begin和end函数八、迭代器区间初始化九、迭代器的操作符重载操作符重载操作符- -重载操作符&#xff01;重载操作符重载操作符*重载十、insert函数十一、erase函…
阅读更多...
【C语言】数据结构-单链表

【C语言】数据结构-单链表

主页&#xff1a;114514的代码大冒险 qq:2188956112&#xff08;欢迎小伙伴呀hi✿(。◕ᴗ◕。)✿ &#xff09; Gitee&#xff1a;庄嘉豪 (zhuang-jiahaoxxx) - Gitee.com 文章目录 目录 文章目录 前言&#xff08;链表的优势&#xff09; 一、单链表是什么 二、单链表操作…
阅读更多...
Java实现将二维数组转化为链式储存

Java实现将二维数组转化为链式储存

文章目录代码思路代码实现代码思路 将二维数组压缩成链式存储大体思路与数组压缩成稀疏数组相似 这里我将链表的头节点储存二维数组的总行数、列数和有效值个 数 头结点之后的每个结点存储有效值的下标和值 转化思路如下图所示 代码实现 创建模拟结点的类 提供构造方法和toStr…
阅读更多...
147. 对链表进行插入排序

147. 对链表进行插入排序

class Solution { public:ListNode* insertionSortList(ListNode* head) {if(!head)return head;ListNode *newHead new ListNode(-5001, head);ListNode *left head, *right head -> next;while(right){if(left -> val < right -> val){ //如果默认有序则往…
阅读更多...
[数据结构]：09-二分查找（顺序表指针实现形式）（C语言实现）

[数据结构]：09-二分查找（顺序表指针实现形式）（C语言实现）

目录 前言 已完成内容 二分查找实现 01-开发环境 02-文件布局 03-代码 01-主函数 02-头文件 03-PSeqListFunction.cpp 04-SearchFunction.cpp 结语 前言 此专栏包含408考研数据结构全部内容&#xff0c;除其中使用到C引用外&#xff0c;全为C语言代码。使用C引用主要…
阅读更多...
【自动包装线标签打印翻转问题沟通】

【自动包装线标签打印翻转问题沟通】

最近纺丝自动包装线的标签打印机自动打印标签&#xff0c;是翻转状态。 但是这个打印机它不是平放的&#xff0c;它是通过悬臂安装在半空的中的&#xff0c;是翻转的&#xff0c; 它的标签一个打在侧面&#xff0c;一个打在正前方&#xff0c;打印出来的样子是这样的。 是反过…
阅读更多...
js求解《初级算法》141. 环形链表

js求解《初级算法》141. 环形链表

一、题目描述 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置…
阅读更多...
数据结构——链表OJ题目讲解（2）

数据结构——链表OJ题目讲解（2）

作者&#xff1a;几冬雪来 时间&#xff1a;2023年3月10日 内容&#xff1a;数据结构链表OJ题目讲解 来源&#xff1a;牛客网和力扣 目录 前言&#xff1a; 刷题&#xff1a; 1.反转链表&#xff1a; 1.改变指向的解法&#xff1a; 2.取头结点插入到新链表&#xff1a; …
阅读更多...
原地逆转链表

原地逆转链表

头插法原地逆转链表 根据头插法特性,将原来链表断开,重新使用头插法,新建 //头插法逆转链表 LinkList Reverse_List(LinkList L) {LNode *p,*r;pL->next;L->nextNULL;//将L置空,重新开始while(p!NULL){rp->next;p->nextL->next;L->nextp;pr;}return L; }指针…
阅读更多...
双向循环链表的创建和尾插法

双向循环链表的创建和尾插法

#include <stdio.h> #include <stdlib.h> #include<stdbool.h>typedef int Elemtype;typedef struct DNode{Elemtype data;struct DNode *prior,*next; }DNode,*DLinkList;DLinkList CreateList() {int x;//双向循环链表初始化DLinkList head(DLinkList)mall…
阅读更多...
王道数据结构习题代码2.3.8(链表)

王道数据结构习题代码2.3.8(链表)

第一题(链表中递归删除元素x) #include <stdio.h> #include <stdlib.h> #include<stdbool.h>typedef int Elemtype;typedef struct LNode {Elemtype data;struct LNode *next; } LNode,*LinkList;void Delete_x(LNode *P,LNode *C,Elemtype e) {if(CNULL)r…
阅读更多...
Leetcode25. K个一组翻转链表

Leetcode25. K个一组翻转链表

目录一、题目描述&#xff1a;二、解决思路和代码1. 解决思路2. 代码一、题目描述&#xff1a; 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交…
阅读更多...
114. 二叉树展开为链表——空间复杂度O(1)

114. 二叉树展开为链表——空间复杂度O(1)

class Solution { public:void flatten(TreeNode* root) {if(!root)return;TreeNode* ptr root;while(ptr){if(ptr -> left){ //如果左节点存在TreeNode* tempLeft ptr -> left; //获取左节点while(tempLeft -> right) //找到左节点上的最右节点tempLeft t…
阅读更多...
HashMap的扩容机制

HashMap的扩容机制

一、HashMap的底层 底层&#xff1a;采用数组链表(JDK1.7)&#xff0c;采用数组链表红黑树(JDK1.8)。 容器&#xff1a;HashMap默认容器长度为16&#xff0c;扩容因子为0.75&#xff0c;以2的n次方扩容。 二、HashMap的扩容机制原理 1、JDK1.7版本扩容 ①&#xff1a;先生成…
阅读更多...
letcode 2.两数相加（官方题解笔记）

letcode 2.两数相加（官方题解笔记）

题目描述 给你两个 非空 的链表&#xff0c;表示两个非负的整数。 它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 除数字 0 之外&#xff0c;这两个数都不会以 0 开头。 1…
阅读更多...
一学就会-----链表中倒数第K个节点

一学就会-----链表中倒数第K个节点

文章目录 题目描述思路一代码示例思路二代码示例 题目描述 输入一个链表&#xff0c;输出该链表中倒数第k个结点。 图片示例&#xff1a; 思路一 由于这道题目并没有要求时间复杂度&#xff0c;我们完全可以先遍历一遍链表&#xff0c;得到链表的结点总数&#xff08;count&am…
阅读更多...
[JS与链表]普通链表

[JS与链表]普通链表

为什么要用链表要储存一系列数据&#xff0c;最常用的数据结构是数组。数组有个缺点就是在中间插入或删除元素需要移动元素&#xff0c;成本很高。什么是链表链表也是有序元素的集合结构。链表中的元素在内存中并不是连续放置的。每个元素都可以理解为一个对象。包含了本身元素…
阅读更多...
Java数据结构实现及效率

Java数据结构实现及效率

Java数据结构实现及效率ListArrayListLinkedListSetHashSetTreeSetLinkedHashSetMapTreeMapLinkedHashMaphttps://www.cnblogs.com/alex-xyl/p/11460931.htmlList ArrayList 都是线性表 元素在内存连续存放&#xff0c;每个元素占用内存相同可以通过下标快速访问数组中的任何…
阅读更多...
数据结构——线性表练习3

数据结构——线性表练习3

题目描述 已知两个链表A和B分别表示两个集合&#xff0c;其元素递增排列。请设计算法求出两个集合A和B 的差集&#xff08;即仅由在A中出现而不在B中出现的元素所构成的集合&#xff09;&#xff0c;并以同样的形式存储&#xff0c;同时返回该集合的元素个数。 代码 #includ…
阅读更多...
两数相加的题型解法（包含流程图分析以及测试用例）

两数相加的题型解法（包含流程图分析以及测试用例）

两数相加一、题目需求二、解法三、测试用例四、流程图一、题目需求 给出两个 非空 的链表用来表示两个非负的整数。其中&#xff0c;它们各自的位数是按照 逆序 的方式存储的&#xff0c;并且它们的每个节点只能存储 一位 数字。 如果&#xff0c;我们将这两个数相加起来&…
阅读更多...
反转链表题型分析（包含简单与中等难度两种，附带流程图分析）

反转链表题型分析（包含简单与中等难度两种，附带流程图分析）

反转链表题型分析一、反转链表一&#xff08;简单&#xff09;&#xff08;一&#xff09;、题目要求&#xff08;二&#xff09;、解法&#xff08;三&#xff09;、测试用例&#xff08;四&#xff09;、流程图分析二、反转链表二&#xff08;中等&#xff09;&#xff08;一…
阅读更多...
2-4尾插建立单链表，C语言输出

2-4尾插建立单链表，C语言输出

本文讲述了使用尾插法建立单链表&#xff0c;并用C语言输出整个单链表的值。第二节使用该算法用链表实现了直接插入排序 1.尾插建立单链表&#xff0c;C语言输出。其中L表示头结点&#xff0c;L->next表示第一个元素 #include<stdio.h> #include<stdlib.h> #i…
阅读更多...
【剑指offer】06~09. 从尾到头打印链表（C# 实现）

【剑指offer】06~09. 从尾到头打印链表（C# 实现）

文章目录前言关于编译环境06. 从尾到头打印链表07. 重建二叉树09. 用两个栈实现队列结语前言 &#x1f60a; 大家好&#xff0c;我是作家桑。这是自己的一个 C# 做题记录&#xff0c;方便自己学习的同时分享出来。 关于编译环境 注意&#xff0c;笔者使用的编译环境是 .NET 7 和…
阅读更多...
数据结构与算法_单链表

数据结构与算法_单链表

要实现对一组数据的增删查改&#xff0c;我们可以用动态顺序表来实现。但是动态顺序表也有它的缺陷&#xff0c;那就是要对某个位置的数据进行删除&#xff0c;或者在某个数据之前或之后插入数据&#xff0c;就要改变部分数据原有的位置。 而用链表的话&#xff0c;就不会有这…
阅读更多...
【新2023】华为OD机试 - 相同字符连续出现的最大次数（Python）

【新2023】华为OD机试 - 相同字符连续出现的最大次数（Python）

相同字符连续出现的最大次数 题目 输入一串字符串 字符串长度不超过100 查找字符串中相同字符连续出现的最大次数 输入 输入只有一行，包含一个长度不超过100的字符串 输出描述 输出只有一行，输出相同字符串连续出现的最大次数 示例一 输入 hello输出 2示例二 输入…
阅读更多...
【刷题】876. 链表的中间结点

【刷题】876. 链表的中间结点

876. 链表的中间结点 一、题目描述二、示例三、实现方法1-两次遍历-未实现方法2-快慢指针 总结 876. 链表的中间结点 一、题目描述 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。如果有两个中间结点&#xff0c;则返回第二个中间结点。 二、示例 输入…
阅读更多...
HashSet底层原理

HashSet底层原理

特点&#xff1a;无序、不可重复 LinkedHashSet 有序、可重复&#xff08;底层通过双向链表的方式记录元素的存储顺序&#xff09; HashSet底层数据结构是哈希表 jdk1.8之前&#xff1a;哈希表组成&#xff1a;数组 链表 jdk1.8之后&#xff1a; 数组 链表 红黑树 存储…
阅读更多...
LeetCode第160题——相交链表（Java）

LeetCode第160题——相交链表（Java）

题目描述&#xff1a; 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交**&#xff1a;** 题目数据 保证 整个链式结构中不存在环。 注意&…
阅读更多...
【力扣面试】面试题 02.08. 环路检测

【力扣面试】面试题 02.08. 环路检测

【力扣面试】面试题 02.08. 环路检测 文章目录题目解题思路代码题目 给定一个链表&#xff0c;如果它是有环链表&#xff0c;实现一个算法返回环路的开头节点。若环不存在&#xff0c;请返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#…
阅读更多...
【LeetCode】二叉树的中序遍历(非递归形式：栈模拟递归，标记模拟递归，莫里斯遍历)...

【LeetCode】二叉树的中序遍历(非递归形式：栈模拟递归，标记模拟递归，莫里斯遍历)...

二叉树的中序遍历 题目链接&#xff1a;https://leetcode-cn.com/problems/binary-tree-inorder-traversal/ 面试的时候问这道题基本都是考察非递归的写法&#xff0c;但还是贴一下递归写法&#xff1a; 方法1&#xff1a;递归 var result []int func f(root *TreeNode) {if r…
阅读更多...
051、面试必刷TOP101--链表（230503）

051、面试必刷TOP101--链表（230503）

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言链表1、BM1 反转链表2、BM2 链表内指定区间反转3、BM3 链表中的节点每k个一组翻转4、BM4 合并两个排序的链表5、BM5 合并k个已排序的链表6、BM6 判断链表中是否…
阅读更多...
222. 完全二叉树的节点个数——位运算

222. 完全二叉树的节点个数——位运算

class Solution { public:int countNodes(TreeNode* root) {if(!root)return 0;TreeNode *node root;int level 0;//通过遍历左孩子可以得知二叉树层数while(node -> left){level;node node -> left;}//left是最后一层的最左节点&#xff0c; right是最底层理论上的最…
阅读更多...
199. 二叉树的右视图——广度搜索

199. 二叉树的右视图——广度搜索

class Solution { public:vector<int> rightSideView(TreeNode* root) {vector<int> vecInt;if(!root)return vecInt;deque<TreeNode*> que;que.push_back(root);while(!que.empty()){int n que.size();vecInt.push_back(que.back() -> val); //添加最…
阅读更多...
95. 不同的二叉搜索树 II——回溯

95. 不同的二叉搜索树 II——回溯

基本是按照官方题解的思路来的&#xff0c;对于回溯的套路还是不太熟练。 class Solution { public:vector<TreeNode*> generateTrees(int n) {if(!n)return {};return generateTrees(1, n);}vector<TreeNode*> generateTrees(int begin, int end) {if(begin >…
阅读更多...
王道数据结构习题代码5.4.5(树和森林)

王道数据结构习题代码5.4.5(树和森林)

第四题(左孩子右兄弟表示树,求树的叶结点个数) #include <stdio.h> #include <stdlib.h> #include<stdbool.h>#define MaxSize 50typedef char Elemtype;typedef struct node{ //左孩子右兄弟Elemtype data;struct node *fch,*nsib; }*Tree;Tree CreateTr…
阅读更多...
队列链式存储基本操作(C语言)

队列链式存储基本操作(C语言)

#include <stdio.h> #include <stdlib.h> #include<stdbool.h>typedef int ElemType;typedef struct LinkNode {ElemType data;struct LinkNode *next; } LinkNode;typedef struct {LinkNode *front,*rear;//队头指针,队尾指针 } LinkQueue;void InitQueue(…
阅读更多...
栈的基本操作(链式存储)

栈的基本操作(链式存储)

#include <stdio.h> #include <stdlib.h> #include<stdbool.h>typedef int ElemType;typedef struct StackNode {ElemType data;struct StackNode *next; } StackNode,*LinkStack;//初始化一个带头节点的链式栈 void InitLinkStack(LinkStack stack) {stack(…
阅读更多...
java 环形链表的约瑟夫问题

java 环形链表的约瑟夫问题

牛客题目链接 1. 题目考点 建立环形单链表链表节点的删除循环结束条件 2. 考点解析 public int ysf (int n, int m) {// write code here// 基础&#xff1a;建立带头结点的单链表ListNode head new ListNode(1);ListNode r head;for (int i 2; i < n; i) {ListNode …
阅读更多...
java 链表每 k 个一个组翻转

java 链表每 k 个一个组翻转

牛客题目链接 1. 题目考点 使用哑结点&#xff0c;原地重建单链表链表头插法 2. 考点解析 public ListNode reverseKGroup (ListNode head, int k) {// write code hereif (head null) return null;ListNode dummy new ListNode(0);ListNode p head, r dummy;int i 0,…
阅读更多...
Linux内核中与“文件系统”相关的数据结构

Linux内核中与“文件系统”相关的数据结构

文件系统相关的数据结构 4.1 file结构体 文件结构体代表一个打开的文件&#xff0c;系统中的每个打开的文件在内核空间都有一个关联的struct file。它由内核在打开文件时创建&#xff0c;并传递给在文件上进行操作的任何函数。在文件的所有实例都关闭后&#xff0c;内核释放这…
阅读更多...
ArrayList 和 LinkedList 有什么区别

ArrayList 和 LinkedList 有什么区别

ArrayList 和 LinkedList 是Java中的两种常见的集合类型&#xff0c;它们具有一些相似之处&#xff0c;但也存在一些重要的区别。 ArrayList ArrayList 是数组列表类型&#xff0c;它是通过一个可变大小的数组来实现的。这意味着 ArrayList 支持随机访问元素&#xff0c;因为…
阅读更多...
【小菜鸡刷题记】----双指针篇

【小菜鸡刷题记】----双指针篇

【小菜鸡刷题记】----双指针篇 剑指 Offer 18. 删除链表的节点剑指 Offer 22. 链表中倒数第k个节点剑指 Offer 25. 合并两个排序的链表剑指 Offer 52. 两个链表的第一个公共节点剑指 Offer 21. 调整数组顺序使奇数位于偶数前面剑指 Offer 57. 和为s的两个数字剑指 Offer 57 - I…
阅读更多...
寻找两个链表共同结点

寻找两个链表共同结点

寻找两个链表共同结点 这个相同结点是指,中间某个结点的next指针,指向同一片区域,并不是仅仅元素值相同 解决步骤 1、使用两个指针,先求出L1,L2的长度 2、先用一个指针p,将长链表,遍历到和短链表相同长度(p每次向后移动) 3、两个指针同时一起向后移动,直到指向相同结点位置 实现…
阅读更多...
C++ 20 list容器

C++ 20 list容器

目录 一、list容器 1.1 简介 1.2 构造函数 1.3 赋值和交换 1.4 大小操作 1.5 插入和删除 1.6 数据存取 1.7 反转和排序 一、list容器 1.1 简介 ① 功能&#xff1a;将数据进行链式存储。 ② 链表(list)是一种物理存储单元上非连续的存储结构&#xff0c;数据元素的逻…
阅读更多...
3.30--Redis之常用数据结构--链表（总结篇）------加油呀

3.30--Redis之常用数据结构--链表（总结篇）------加油呀

Redis 的 List 对象的底层实现之一是链表 链表节点结构设计 typedef struct listNode {//前置节点struct listNode *prev;//后置节点struct listNode *next;//节点的值void *value; } listNode;有前置节点和后置节点&#xff0c;这个是一个双向链表 list 结构为链表提供了链…
阅读更多...
ArrayList、LinkedList集合源码

ArrayList、LinkedList集合源码

一、ArrayList集合源码 1、ArrayList的特点 数据结构&#xff1a;基于数组实现&#xff0c;类型&#xff1a;object类型&#xff1b;存放元素&#xff1a;有序&#xff0c;可重复&#xff1b;线程是否安全&#xff1a;不安全&#xff0c;效率高。&#xff08;没有加上锁机制&a…
阅读更多...
(链表专题) 445. 两数相加 II ——【Leetcode每日一题】

(链表专题) 445. 两数相加 II ——【Leetcode每日一题】

445. 两数相加 II 给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。 你可以假设除了数字 0 之外&#xff0c;这两个数字都不会以零开头。 示例1&#xff1a; 输入&#xff1a;l1 [7,2,…
阅读更多...
[D-OJ练习] 线性表的链式存储结构与操作

[D-OJ练习] 线性表的链式存储结构与操作

请你定义一个链表&#xff0c;可以对链表进行“在某个元素之前插入一些元素”、“删除某个位置的元素”、“查找某元素”、“获取某个位置的元素”、“遍历输出所有元素”、“求链表的长度”等操作。键盘输入一些命令&#xff0c;可以执行上述操作。本题中&#xff0c;链表元素…
阅读更多...
[D-OJ练习] 一元多项式的运算

[D-OJ练习] 一元多项式的运算

已知一元多项式&#xff1a;A(x)a0a1xa2x2a3x3….anxn, B(x) b0b1xb2x2b3x3….bmxm设计算法实现C(x)A(x)B(x)。功能包括输入多项式A&#xff0c;输入多项式B&#xff0c;求A和B的和&#xff0c;显示求和后的结果等操作。本题中&#xff0c;链表的第一个元素位置为1&#xff0c;…
阅读更多...
LinkedList源码解析（空间结构和特性、常用方法、双端队列特性、ArrayList和LinkedList的区别总结）

LinkedList源码解析（空间结构和特性、常用方法、双端队列特性、ArrayList和LinkedList的区别总结）

1、概念 LinkedList是一个双向不循环链表&#xff0c;继承了AbstractSequentialList&#xff0c;实现了 List &#xff0c;Deque, Cloneable, Serializable接口&#xff0c;所以他有List的相关功能、同时还有双向队列、复制和序列化等功能。他的底层是使用Node组成的链表实现的…
阅读更多...
数据结构-利用链表实现队（包含源码+详细解析）

数据结构-利用链表实现队（包含源码+详细解析）

目录 一、基本概念 二、具体的实现 三、代码的展示 四、测试文件 五、总结 一、基本概念 队列是一种先进先出的数据结构&#xff0c;可以以线性或链式的形式进行存储。在链表中实现队列时&#xff0c;每个节点代表一个元素&#xff0c;每个节点包含两个属性&#xff1a;数…
阅读更多...
《408篇》线性表与链表

《408篇》线性表与链表

目录 一、线性表 1.1、顺序表 1.1.1、定义顺序表(静态分配) 1.1.2、初始化InitList(&L)&#xff08;静态分配&#xff09; 1.1.3、定义顺序表(动态分配) 1.1.4、初始化InitList(&L)&#xff08;动态分配&#xff09; 1.1.5、插入元素ListInsert(&L, i, e) …
阅读更多...
leetcode_删除链表中的结点

leetcode_删除链表中的结点

请编写一个函数&#xff0c;用于 删除单链表中某个特定节点 。在设计函数时需要注意&#xff0c;你无法访问链表的头节点 head &#xff0c;只能直接访问 要被删除的节点 。 题目数据保证需要删除的节点 不是末尾节点 。 输入&#xff1a;head [4,5,1,9], node 5 输出&#…
阅读更多...
某公司实习面试记录

某公司实习面试记录

哎&#xff01;面试之前被放两次鸽子&#xff0c;结果今天面试&#xff0c;面试完之后就凉凉了&#xff0c;伤心ing。面试流程记下&#xff1a; 1、自我介绍 自我介绍之后&#xff0c;面试官说在看不到的简历内容&#xff0c;应该是官网上面写的不够充分&#xff0c;但是我不知…
阅读更多...
leetcode HOT100总结

leetcode HOT100总结

本人菜鸡一枚&#xff0c;历时两个月时间把HOT100题做完(Ctrl C-V)了&#xff0c;做完之后还是感觉到很虚&#xff0c;很多中等题还是不会做&#xff0c;于是乎花几天时间把这100题给总结一下。一方面&#xff0c;对自己的知识梳理&#xff1b;另一方面&#xff0c;便于后续回顾…
阅读更多...
顺序表（更新版）——“数据结构与算法”

顺序表（更新版）——“数据结构与算法”

各位CSDN的uu们你们好呀&#xff0c;今天小雅兰又来更新新专栏啦&#xff0c;其实之前我就已经写过了顺序表的内容&#xff0c;只是之前的内容不是最新版的顺序表&#xff0c;现在&#xff0c;我来更新一下最新版的顺序表&#xff0c;下面&#xff0c;就让我们进入更新版的顺序…
阅读更多...
数据结构———单链表

数据结构———单链表

1.存储结构 单链表的特点是:用一组任意的存储单元存储线性表的数据元素&#xff0c;这种存储单元可以连续也可以不连续。 链表的结点包括两个域:存储数据元素的数据域和存储后继结点的指针域。 typedef struct LNode {ElemType data;//数据域struct LNode* next;//指针域…
阅读更多...
【数据结构】- 链表之单链表(下)

【数据结构】- 链表之单链表(下)

文章目录 前言一、单链表(下)1.1 查找修改1.2 在任意位置插入1.2.1 在pos位置插入(也就是pos位置之前)1.2.2 在pos位置之后插入 1.3 在任意位置删除1.3.1 删除pos位置得值1.3.2 删除pos位置后面的值 二、完整代码总结 前言 未来藏在迷雾中 叫人看来胆怯 带你踏足其中 就会云开…
阅读更多...
【两个月算法速成】day03-链表

【两个月算法速成】day03-链表

目录 203. 移除链表元素 题目链接 思路 代码 206. 反转链表 题目链接 思路 代码 总结 203. 移除链表元素 题目链接 力扣 思路 如下图所示就是移除链表的过程 但是值得注意的是&#xff0c;移除头节点和其他位置的节点是不一样的&#xff0c;以为头结点前面没有节点。…
阅读更多...
链栈(带头结点)（C/C++）

链栈(带头结点)（C/C++）

文章目录0.链栈的数据结构定义1.链栈的初始化2.进栈3.出栈4.读取栈顶元素5.判空全部代码0.链栈的数据结构定义 /*0.链栈的数据结构定义*/ typedef struct LinkNode {ElemType data;struct LinkNode* next; }LinkNode, * LinkStack;1.链栈的初始化 /*1.链栈的初始化*/ Status …
阅读更多...
leetcode-328 奇偶链表

leetcode-328 奇偶链表

题目如下&#xff1a; 给定单链表的头节点 head &#xff0c;将所有索引为奇数的节点和索引为偶数的节点分别组合在一起&#xff0c;然后返回重新排序的列表。 第一个节点的索引被认为是 奇数 &#xff0c; 第二个节点的索引为 偶数 &#xff0c;以此类推。 请注意&#xff0c;…
阅读更多...
【刷题之路Ⅱ】LeetCode 24. 两两交换链表中的节点

【刷题之路Ⅱ】LeetCode 24. 两两交换链表中的节点

【刷题之路Ⅱ】LeetCode 24. 两两交换链表中的节点 一、题目描述解题1、方法1——递归1.1、思路分析1.2、代码实现 2、方法2——迭代2.1、思路分析2.2、代码实现 3、方法3——交替的尾插3.1、思路分析3.2、代码实现 一、题目描述 原题连接&#xff1a; 24. 两两交换链表中的节…
阅读更多...
LeetCode刷题笔记 Java 腾讯 数组字符串 环形链表

LeetCode刷题笔记 Java 腾讯 数组字符串 环形链表

给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;…
阅读更多...
C结构简单而不失强大的表格

C结构简单而不失强大的表格

2023年了&#xff0c;想必已经不会有人对嵌入式开发中“数据结构&#xff08;Data Structure&#xff09;”的作用产生疑问了吧&#xff1f;无论你是否心存疑惑&#xff0c;本文都将给你一个完全不同的视角。 每每说起数据结构&#xff0c;很多人脑海里复现的一定是以下的内容&…
阅读更多...
LeetCode刷题笔记 Java 腾讯 链表 合并K个排序链表

LeetCode刷题笔记 Java 腾讯 链表 合并K个排序链表

给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 类似于合并两个排序列表&#xff0c;但是此处需要用一个优先队列储存所有队列。 取出最小值放入结果列表尾部&#xff0c;并把其下一个位置放入队…
阅读更多...
LeetCode刷题笔记 Java 腾讯 链表突击 二叉树的最近公共祖先

LeetCode刷题笔记 Java 腾讯 链表突击 二叉树的最近公共祖先

题目 官解 给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为&#xff1a;“对于有根树 T 的两个节点 p、q&#xff0c;最近公共祖先表示为一个节点 x&#xff0c;满足 x 是 p、q 的祖先且 x 的深度尽可能大&#xff08;一个节点也可以…
阅读更多...
LeetCode刷题笔记 Java 腾讯 链表突击 环形链表 II

LeetCode刷题笔记 Java 腾讯 链表突击 环形链表 II

题目 官解 给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 p…
阅读更多...
哈希Hash

哈希Hash

HashMap是Java中常用的数据结构之一&#xff0c;它提供了高效的键值对存储和检索功能。下面是HashMap底层的详细原理介绍&#xff1a; 1. 数据结构&#xff1a;HashMap底层使用数组和链表&#xff08;或红黑树&#xff09;的组合实现。它通过哈希算法将键转换为数组索引&#…
阅读更多...
SDUT-2121 数据结构实验之链表六：有序链表的建立

SDUT-2121 数据结构实验之链表六：有序链表的建立

数据结构实验之链表六&#xff1a;有序链表的建立Time Limit: 1000MS Memory Limit: 65536KBSubmit StatisticProblem Description输入N个无序的整数&#xff0c;建立一个有序链表&#xff0c;链表中的结点按照数值非降序排列&#xff0c;输出该有序链表。Input第一行输入整数个…
阅读更多...
【小米的技术分享】数据库索引原理与底层数据结构解析

【小米的技术分享】数据库索引原理与底层数据结构解析

大家好&#xff0c;我是小米。今天我们来探讨一下数据库索引原理以及底层索引数据结构&#xff0c;同时还会介绍叶子节点存储的内容以及索引失效的情况。废话不多说&#xff0c;让我们开始吧&#xff01; IO操作与索引 首先&#xff0c;我们先来了解一下IO操作对于数据库索引的…
阅读更多...
如何判断链表有环？

如何判断链表有环？

一个单向链表&#xff0c;链表中可能出现 “环”&#xff0c;就像下图这样。 如何用程序判断该链表是否为有环链表呢&#xff1f; 解题思路&#xff1a; 有一个很巧妙的方法&#xff0c;这个方法利用了两个指针。 创建两个指针p1和p2&#xff08;在Java里就是两个对象引用&…
阅读更多...
实验一 顺序表的实现

实验一 顺序表的实现

一、实验目的 1.熟悉和掌握Dev-C环境下的编译、调试和执行的方法及步骤。 2.熟悉线性表顺序存储的实现方式。 二、实验内容 实现顺序表的插入、删除、查看等操作。 操作菜单要求&#xff1a; ①插入&#xff1a;输入插入的位置和数据&#xff0c;输出插入后的数据&#xff1b; …
阅读更多...
约瑟夫问题Java环形单向链表代码实现

约瑟夫问题Java环形单向链表代码实现

文章目录约瑟夫问题的由来解题思路代码实现测试约瑟夫问题的由来 约瑟夫是1世纪的一名犹太历史学家。他在自己的日记中写道&#xff0c;他和他的40个战友被罗马军队包围在洞中。他们讨论是自杀还是被俘&#xff0c;最终决定自杀&#xff0c;并以抽签的方式决定谁杀掉谁。41个人…
阅读更多...
栈实现递归

栈实现递归

#include <stdio.h> #include <stdlib.h> #include<stdbool.h> #define MaxSize 50typedef char ElemType;/*利用栈计算递归表达式Pn(x) 1 ,n0; 2x ,n1; 2xPn-1(x)-2(n-1)Pn-2(x) ,n>1 */double p(int n,double x) {struct stack{int no;//当前n 也…
阅读更多...
基础算法系列 之双向循环链表

基础算法系列 之双向循环链表

双向链表(双链表)是链表的一种&#xff0c;双链表也是由节点组成&#xff0c;它的每个数据结点中都有两个指针&#xff0c;分别指向后继节点和前驱节点。 借图说话&#xff1a;图片来自于https://www.cnblogs.com/rongweijun/p/8072677.html&#xff0c;感谢大神的图片。 其代…
阅读更多...
4.4 反转链表

4.4 反转链表

206 反转链表题目给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。思路具体代码实现(C)模型&#xff08;知识点&#xff09;题目 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; …
阅读更多...
寻找链表中倒数第K个位置的元素(只能遍历一遍)

寻找链表中倒数第K个位置的元素(只能遍历一遍)

寻找链表中倒数第K个位置的元素(只能遍历一遍) 由于只能遍历一遍链表,我们无法先获取链表长度,在遍历到倒数第k个位置,这样的操作是遍历两次链表 用两个指针p、q其中p先走k步,然后q在和p同时走,当p到达结尾时,q正好在倒数第k个位置 实现代码 #include <stdio.h> #includ…
阅读更多...
寻找两个递增有序链表的交集

寻找两个递增有序链表的交集

寻找两个递增有序链表的交集 利用两个指针p、q遍历两个链表,当p的元素等于q的元素值时,添加进入结果链表中,如果p的数据小于q的数据时,p向下移动,否则q向下移动 实现代码 #include <stdio.h> #include <stdlib.h> #include<stdbool.h>typedef int Elemtype;…
阅读更多...
删除有序链表中重复元素

删除有序链表中重复元素

删除有序链表中重复元素 使用两个指针,p用来遍历链表,q每次指向p的下一个位置,若p->dataq->data则删除q 实现代码 #include <stdio.h> #include <stdlib.h> #include<stdbool.h>typedef int Elemtype;typedef struct LNode {Elemtype data;struct LN…
阅读更多...
链式前向星存图(有图详解)

链式前向星存图(有图详解)

链式前向星:既然是链式那么肯定和链表相关,前向星是每次指向都向前 链式前向星存图是以边为中心,并不是以结点为中心,它记录的是边的一些属性,包括边边的id、头节点、尾结点、权值、边的指向! 边的指向是遍历图的时候需要按照一定顺序去遍历,而不能胡乱的去遍历,那么就需要这些…
阅读更多...
长整数加减法JAVA版本

长整数加减法JAVA版本

长整数加减法 我在网上看到长整数加减法都是c或者c版本java版太少,所以上传一个java版本的供大家参考,我会把代码按各个类、粘贴上去,根据各个类去讲解如何实现长整数加减法。 主要思路 将读入的长整数转换为 循环链表,然后选择加减法方式,最后进行加法或者减法 图示 底层实现 …
阅读更多...
Java带哨兵节点的单向链表实现

Java带哨兵节点的单向链表实现

// 带哨兵节点&#xff08;虚拟节点&#xff09;的单向链表 public class Link{// 节点private class Node{private int v; // 数据private Node next; // 指向的下个节点// 构造方法(数据和下一个节点)public Node(int v, Node next) {this.v v;this.next next;}// 构造方法…
阅读更多...
【力扣面试】面试题 02.06. 回文链表(原地反转链表)

【力扣面试】面试题 02.06. 回文链表(原地反转链表)

【回文链表】面试题 02.06. 回文链表 文章目录题目解题思路代码题目 编写一个函数&#xff0c;检查输入的链表是否是回文的。 示例 1&#xff1a; 输入&#xff1a; 1->2 输出&#xff1a; false 示例 2&#xff1a; 输入&#xff1a; 1->2->2->1 输出&#xff1a;…
阅读更多...
单链表算法题

单链表算法题

我这边整理的左程云老师的算法基础课程关于单链表的算法题&#xff0c;主要是以下几个题目 反转单链表和双链表判断单链表是否是回文链表打印有序链表的公共部分单向链表按某值划分成左边小&#xff0c;中间相等&#xff0c;右边大的形式复制含有随机指针节点的链表两个单链表…
阅读更多...
160. 相交链表 ——【Leetcode每日一题】

160. 相交链表 ——【Leetcode每日一题】

160. 相交链表 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c…
阅读更多...
libuv系列--queue详解

libuv系列--queue详解

一、目的 在以前的博文《RT-Thread系列--双链表分析》我们介绍了如何实现双链表&#xff0c;其实这种双链表结构在linux内核中用得比较多&#xff0c;但是考虑到版权问题&#xff0c;libuv通过宏实现了同样功能的双链表结构。本篇的目的就是帮助大家理解其实现原理&#xff0c;…
阅读更多...
数据结构课程设计——集合的交、并和差运算

数据结构课程设计——集合的交、并和差运算

集合的交、并和差运算 数据结构课程设计任务书 学生姓名&#xff1a; 专业班级&#xff1a; 软件工程 指导教师&#xff1a; 工作单位&#xff1a; 题 目: 集合的并、交和差运算 基础要求&#xff1a; 掌握数据结构与…
阅读更多...
数据结构——实现双向链表

数据结构——实现双向链表

文章目录 :cool:前言:smile:带头双向循环链表的结构体搭建和初始化的操作:bear:创造一个哨兵位头结点:monkey:申请一个节点:dog:初始化:cat:打印:potato:判空:tomato:销毁:cow:尾插:strawberry:头插:banana:尾删:orange:头删:pear:查找:watermelon:在pos位置之前插入:apple:删除…
阅读更多...
Java中的集合全家桶介绍

Java中的集合全家桶介绍

Java中的集合 Java集合框架 早期的Java就提供了许多特设类&#xff0c;比如&#xff1a;Dictionary,Vector,Stack和Properties这些类来存储和操作对象组。 虽然很有用&#xff0c;但是却缺少一个核心与统一的主题&#xff0c;由于这个原因&#xff0c;在使用Vector类的方式和…
阅读更多...
力扣 相交链表

力扣 相交链表

力扣 相交链表 题目链接&#xff1a;https://leetcode-cn.com/problems/intersection-of-two-linked-lists 题目大致意思就是判断两个链表有没有交点&#xff0c;有的话给出交点&#xff0c;没有的话返回null 要求是不能修改链表&#xff0c;并且时间复杂度为O(NM)&#xff0c;…
阅读更多...
LeetCode：面试题 02.07. 链表相交

LeetCode：面试题 02.07. 链表相交

&#x1f34e;道阻且长&#xff0c;行则将至。&#x1f353; &#x1f33b;算法&#xff0c;不如说它是一种思考方式&#x1f340; 算法专栏&#xff1a; &#x1f449;&#x1f3fb;123 题解目录 一、&#x1f331;[面试题 02.07. 链表相交](https://leetcode.cn/problems/in…
阅读更多...
Redis学习之list底层链表源码分析

Redis学习之list底层链表源码分析

Redis底层链表的源码分析&#xff1a; 一.链表结点的结构(单个结点)&#xff1a; // listNode 双端链表节点typedef struct listNode {// 前置节点struct listNode *prev;// 后置节点struct listNode *next;// 节点的值void *value;} listNode;该链表为双向链表&#xff0c;由多…
阅读更多...
判断是否是搜索二叉树

判断是否是搜索二叉树

搜索二叉树&#xff0c;左边子树小于父节点&#xff0c;右边子树的每个节点大于父节点。标准搜索二叉树不会有相等的节点 搜索二叉树进行中序遍历&#xff0c;应该是升序的&#xff0c;利用此特点来进行判断是否是搜索二叉树 方式一 递归 int preValue Integer.MIN_VALUE; pr…
阅读更多...
求一棵二叉树的宽度

求一棵二叉树的宽度

方式一 利用hashmap记录每一个节点所在的层&#xff0c;利用队列进行宽度遍历 hashmap private int getMaxWidth1(Node head){int curMax 0;int curLevel 1;int curWidth 0;HashMap<Node, Integer> map new HashMap<>();map.put(head,1);LinkedList<Node&g…
阅读更多...
查找链表中是否存在X，若存在，则删除并且返回1，否则返回0

查找链表中是否存在X，若存在，则删除并且返回1，否则返回0

int findAndDel(LinkNode *&L,ElemType x){LinkNode *p ,*q;pL;while(p->next!NULL){if(p->next->datax){break;}pp->next;}if(p->nextNULL){return 0;}else{qp->next;p->nextp->next->next;free(q);return 1; }} 当传入参数是链表时&#xf…
阅读更多...
java复制含有随机指针节点的链表

java复制含有随机指针节点的链表

【题目】 有一种特殊的链表节点类&#xff0c;如下所示 class Node{int value;Node next;Node rand;Node(int val){value val;} }rand指针是单链表节点结构中新增的指针&#xff0c;rand可能指向链表中的任意一个结点&#xff0c;或者是null&#xff0c; 给定一个由Node节点类…
阅读更多...
再看LeetCode92

再看LeetCode92

题目&#xff1a; 反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。 说明: 1 ≤ m ≤ n ≤ 链表长度。 示例: 输入: 1->2->3->4->5->NULL, m 2, n 4 输出: 1->4->3->2->5->NULL 代码演示&#xff1a;&#xff08;注释很清楚&#xff0c…
阅读更多...
二叉树公共节点

二叉树公共节点

【题目】给定二叉树的两个二节点node1,node2&#xff0c;找出这两个节点的最低公共祖先节点 【思路】 2种情况 1.node1是node2的祖先节点或者node2是node1的祖先节点 2.node1和node2属于不同的子树 【方法一】利用递归 private Node lowestCommonAncestor(Node head, Node o1,…
阅读更多...
java两个单链表相交问题

java两个单链表相交问题

【题目】 给定2个可能有环&#xff0c;可能无环的单链表&#xff0c;头节点head1和head2,请实现一个函数&#xff0c; 如果两链表相交&#xff0c;返回相交的第一个节点&#xff0c;如果不相交&#xff0c;返回null 【要求】 如果两个链表的总长度是N&#xff0c;时间复杂度是O…
阅读更多...
每日一道LeetCode题目

每日一道LeetCode题目

给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链…
阅读更多...
C语言高级用法--函数指针：回调函数；转换表

C语言高级用法--函数指针：回调函数；转换表

函数指针最常见的两个用途&#xff1a;作为参数传递给另一个函数&#xff08;回调函数&#xff09;和转换表&#xff08;jump table&#xff09;&#xff0c;本文将探索这两方面的一些技巧。 一.回调函数 ​ 有一个简单的函数&#xff0c;它用于一个单链表中查找一个值。它的…
阅读更多...
LeetCode50天刷题计划第二季（Day 12 — 路径总和 II（12.00-12.40）二叉树展开为链表（16.40.-18.10）

LeetCode50天刷题计划第二季（Day 12 — 路径总和 II（12.00-12.40）二叉树展开为链表（16.40.-18.10）

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录前言一、题目路径总和 II示例提示二、思路三、代码四、题目二叉树展开为链表示例提示进阶五、思路1、空间复杂度O(n)2、空间复杂度O(1)六、代码1、空间复杂度O(n)2.空…
阅读更多...
[练习]自己写的C语言链表模板 ver 1.0

[练习]自己写的C语言链表模板 ver 1.0

#include <stdio.h> #include <stdlib.h> //定义布尔数值 true false #define true 1 #define false 0 //定义错误类型 wrong #define wrong 0x7fffffff typedef int boolean;//定义布尔类型 typedef struct Node *list,*position; struct Node{int data;//数据…
阅读更多...
（三）剑指offer之从尾到头打印链表

（三）剑指offer之从尾到头打印链表

题目描述&#xff1a; 输入一个链表&#xff0c;从尾到头打印链表每个节点的值。 输入描述&#xff1a; 输入为链表的表头 输出描述&#xff1a; 输出为需要打印的“新链表”的表头 /** * struct ListNode { * int val; * struct ListNode *next; * …
阅读更多...
LeetCode 面试题 02.03. 删除中间节点

LeetCode 面试题 02.03. 删除中间节点

原题目&#xff1a;https://leetcode-cn.com/problems/delete-middle-node-lcci/ 思路&#xff1a; 用下一个节点的值代替本节点的值&#xff0c;然后修改链表的指向 代码&#xff1a; class Solution { public:void deleteNode(ListNode* node) {node->val node->nex…
阅读更多...
数据结构和算法----链表

数据结构和算法----链表

链表&#xff08;Linked List&#xff09;是不同于数组的另一种数据结构&#xff0c;它的存储单元&#xff08;即结点或元素&#xff09;除了包含任意类型的数据之外&#xff0c;还需要包含指向另一个结点的引用&#xff0c;后文会用术语链接表示对结点的引用。 下面会列出链表…
阅读更多...
数据结构和算法（六）环形链表和 josepfu 问题解决

数据结构和算法（六）环形链表和 josepfu 问题解决

构建环形链表思路 创建第一个节点&#xff0c;first 指向该节点&#xff0c;并形成环装每创建一个新的节点&#xff0c;将该节点加入到已有的环形链表中 遍历环形链表 先让一个辅助指针指向 first 节点然后通过一个 while 循环遍历该环形链表知道 辅助指针的 next 下一个节点…
阅读更多...
键盘输入n个英文字母，输入格式为n,c1,c2,....cn，其中n代表字母的个数。请编程用这些输入数据建立一个单链表，并要求将字母不重复的存入链表

键盘输入n个英文字母，输入格式为n,c1,c2,....cn，其中n代表字母的个数。请编程用这些输入数据建立一个单链表，并要求将字母不重复的存入链表

思路&#xff1a;输入一个单词&#xff0c;扫描其在链表中是否出现&#xff0c;如果出现&#xff0c;什么都不做&#xff1b;否则&#xff0c;根据这个单词构造结点插入链表中 void createLNodeSame(LNode *& head) //1) {head (LNode *)malloc(sizeof(LNode)); //1)处…
阅读更多...
【LeetCode 热题 HOT 100】2. 两数相加--python实现

【LeetCode 热题 HOT 100】2. 两数相加--python实现

题目&#xff1a;两数相加 给你两个 非空 的链表&#xff0c;表示两个非负的整数。 它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外&#xf…
阅读更多...
【链表OJ题】给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

【链表OJ题】给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

【链表OJ题】&#xff1a; 本题来自于力扣算法题&#xff0c;链接&#xff1a;203.移除链表元素 题目&#xff1a;给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 这道题目简单来说就是…
阅读更多...
Go数据结构------链表

Go数据结构------链表

链表 讲数据结构就离不开讲链表。因为数据结构是用来组织数据的&#xff0c;如何将一个数据关联到另外一个数据呢&#xff1f;链表可以将数据和数据之间关联起来&#xff0c;从一个数据指向另外一个数据。 一、链表 定义&#xff1a; 链表由一个个数据节点组成的&#xff0c…
阅读更多...
两个递减单链表按照递增的顺序合并为一个单链表

两个递减单链表按照递增的顺序合并为一个单链表

#include<stdio.h>//#includetypedef struct node{int data;struct node *next;} linknode,*link;//linknode mynode;//mynode是一个struct node结构体 //link ptr_node;//ptr_node是一个指向struct node结构体的指针。//合并 link Union(link la,link lb) /*合并链表*/…
阅读更多...
《程序设计基础》 第八章 指针 例题8-4 输入年份和天数，输出对应的年、月、日 (15 分)

《程序设计基础》 第八章 指针 例题8-4 输入年份和天数，输出对应的年、月、日 (15 分)

要求定义和调用函数month_day ( year, yeardy, *****pmonth, *pday)&#xff0c;通过参数pmonth和pday返回计算得出的月和日。例如&#xff0c;输入2000和61&#xff0c;分别返回3和1&#xff0c;即2000年的第61天是3月1日。 函数接口定义&#xff1a; void month_day ( year…
阅读更多...
C语言学习笔记—链表（四）链表的删除

C语言学习笔记—链表（四）链表的删除

删除节点 链表的节点删除有两种情况 一、删除头节点 将头结点变为第二个节点即可。 二、删除非头节点 将要删除的节点的前一个节点指向到要删除的节点的下一个节点。 #include <stdio.h> //定义结构体 struct Test {int data;struct Test *next;//链表有一个指向自己…
阅读更多...
Java集合Collections

Java集合Collections

Java集合Collections一、类集设置的目的二、链表与二叉树思路2.1 链表2.2 二叉树三、常见数据结构四、Collection接口4.1 概述4.2 Collection 常用功能五、List 接口5.1 接口介绍5.2 List接口特点5.3 List接口中常用方法5.4 扩充方法六、ArrayList6.1 概述6.2 范例&#xff1a;…
阅读更多...
C语言学习笔记—链表（一）

C语言学习笔记—链表（一）

什么是链表&#xff1f; 链表是一种常见而重要的动态存储分布的数据结构。 我们知道数组元素是存储在一段连续地址上的。这样就带来了一线缺点&#xff0c;假如我们要删除或添加一个元素呢&#xff1f;那也就是说一旦增加或者删除元素就要其他相关的元素地址都要进行移动。 我…
阅读更多...
单链表题+数组题（快慢指针和左右指针）

单链表题+数组题（快慢指针和左右指针）

文章目录说明&#xff1a;本文章用于 “单链表题数组题”“链表”知识一、案例说明&#xff08;使用快慢指针&#xff09;问题1.1判断链表是否有环问题1.2&#xff1a;已知链表有环&#xff0c;请返回这个环的起点位置问题1.3&#xff1a;寻找无环单链表的中点&#xff0c;要求…
阅读更多...
线性结构-队列

线性结构-队列

队列是一种先进先出First In Fisrt Out,FIFO的线性表。 与一般的数组和链表不同&#xff0c;队列要求所有的数据只能从一端进入&#xff0c;从另一端离开。 输入进入的一端叫队尾rear&#xff0c;数据离开的一端叫队头front。 数据只能从队尾进入队列&#xff0c;从队头离开队…
阅读更多...
LeetCode 206. Reverse Linked List

LeetCode 206. Reverse Linked List

原题目&#xff1a;https://leetcode-cn.com/problems/reverse-linked-list/ 思路&#xff1a; 尾插法进行列表的翻转&#xff0c;prev保持已修改的链表&#xff08;初始为NULL&#xff09;&#xff0c; 先记录head的下一结点nex&#xff0c;把prev插入到head。再把nex赋值给…
阅读更多...
【SAP人员信息未同步】

【SAP人员信息未同步】

经过排查&#xff0c;无法选择的员工都是国望的&#xff0c;而国望是没有MES的。 如果需要新增该员工的培训记录&#xff0c;可以在MES的用户管理或者职员管理里&#xff0c;手动新增该员工&#xff0c;并把该员工改为芮邦工厂。
阅读更多...
PAT乙级真题 1075 链表元素分类 C++实现（测试点5：用map会超时）

PAT乙级真题 1075 链表元素分类 C++实现（测试点5：用map会超时）

题目 给定一个单链表&#xff0c;请编写程序将链表元素进行分类排列&#xff0c;使得所有负值元素都排在非负值元素的前面&#xff0c;而 [0, K] 区间内的元素都排在大于 K 的元素前面。但每一类内部元素的顺序是不能改变的。例如&#xff1a;给定链表为 18→7→-4→0→5→-6→…
阅读更多...
Java简单实现链式哈希表

Java简单实现链式哈希表

文章目录什么是哈希表试题代码输出结果什么是哈希表 散列表&#xff08;Hash table 也叫哈希表&#xff09;&#xff0c;是通过关键码值&#xff08;key value&#xff09;而直接进行访问的数据结构。也就是说&#xff0c;它通过关键码值映射到表中的一个位置来访问记录&#…
阅读更多...
PAT 甲 1032 Sharing

PAT 甲 1032 Sharing

2022.1.22 练习 PAT甲 1032 Sharing&#xff08;原题链接&#xff09; 题解如下&#xff1a; #include<bits/stdc.h> using namespace std; const int MAX_SIZE1e65;struct Node {string data;int next;int flag; }node[MAX_SIZE];int main() {std::ios::sync_with_std…
阅读更多...
LeetCode 143. 重排链表

LeetCode 143. 重排链表

原题目&#xff1a;https://leetcode-cn.com/problems/reorder-list/ 思路&#xff1a; 使用vector存储节点&#xff0c;然后使用双指针进行重新连接&#xff0c;最后注意最后的节点的next置为空 代码&#xff1a; class Solution { public:void reorderList(ListNode *head)…
阅读更多...
二维空间的创建与使用

二维空间的创建与使用

#include <stdio.h>//建立棋盘 void createBoard1(void ***p,int n) {*p (void **)malloc(sizeof(void*)*n);//申请n*n的空间for(int i 0;i<n;i){(*p)[i] (void *)malloc(sizeof(char)*n);memset((*p)[i],o,n);}return 0; } //下子 void initBoard(char***p,int n) …
阅读更多...
链表反致

链表反致

#include<iostream>using namespace std;struct Mynode {int data;struct Mynode *next;};class Myopersion { public:Mynode* Init();//初始化函数Mynode* Insert(Mynode* head,int arry[], int len);//插入元素void Play(Mynode* myhead);//遍历链表Mynode* Fanzhi(Myn…
阅读更多...
数据结构_链表练习题

数据结构_链表练习题

Java实现&#xff1a; 使用带head头的单向链表实现-水浒英雄排行榜管理 完成对英雄人物的增删改查操作&#xff0c;注&#xff1a;删除和修改&#xff0c;查找可以考虑学员独立完成&#xff0c;也可带学员完成第一种方法在添加英雄时&#xff0c;直接添加到链表的尾部第二种…
阅读更多...
双指针算法原理详解

双指针算法原理详解

双指针算法原理详解 参考链接 链表中快慢指针的妙用玩转快慢指针【LeetCode刷题笔记】链表与快慢指针双指针算法基本原理和实践 练习题 141. 环形链表面试题 02.08. 环路检测 相关链接 解析滑动窗口解明动态滑动窗口解析双指针 什么是双指针 双指针&#xff0c;指的是在…
阅读更多...
力扣 2.两数相加

力扣 2.两数相加

题目表述 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表 方法&#xff1a;模拟 算法思想 - 创建一个虚拟表头&a…
阅读更多...
【Java实现】合并两个有序链表

【Java实现】合并两个有序链表

&#x1f388;目录&#x1f388; 问题描述&#x1f512; 输入输出示例&#xff1a; 解题分析&#x1f511; 代码实现&#x1f513; 题目入口&#x1f4cc;&#xff1a;合并两个有序链表 问题描述 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个…
阅读更多...
4.合并两个有序链表

4.合并两个有序链表

题目: 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 解题思路(迭代): 先定义两个指针,一个指针不负责移动是指向头结点的指针,第二个指针负责移动,将数据挨个串在一起 public ListNode MergeTwoLists1(ListNode list1, …
阅读更多...
题183.2022寒假天梯赛训练-7-9 重排链表 (25 分)

题183.2022寒假天梯赛训练-7-9 重排链表 (25 分)

文章目录题183.2022寒假天梯赛训练-7-9 重排链表 (25 分)一、题目二、题解题183.2022寒假天梯赛训练-7-9 重排链表 (25 分) 一、题目 二、题解 这道题可谓坑点重重。。。基本思路就是先把原始链表遍历一遍得到顺序编号&#xff0c;然后按重排顺序输出节点&#xff0c;这个重排规…
阅读更多...
Remove Duplicates from Sorted List 2 删除排序链表中的重复元素

Remove Duplicates from Sorted List 2 删除排序链表中的重复元素

文章目录Remove Duplicates from Sorted List 2 删除排序链表中的重复元素双指针Remove Duplicates from Sorted List 2 删除排序链表中的重复元素 Given the head of a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers fr…
阅读更多...
结构体指针在函数中改变，但是函数运行完毕后回到主函数发现他没变（改变的是形参结构体指针）

结构体指针在函数中改变，但是函数运行完毕后回到主函数发现他没变（改变的是形参结构体指针）

如果你用的是结构体指针&#xff0c;是否遇到了在函数中改变他&#xff0c;但是函数运行完毕后回到主函数发现他没变的问题&#xff1f;本文给你讲明白 函数没有改变结构体的值&#xff1f; void bbb(struct node *p) {}对p操作了半天&#xff0c;回主函数一看没反应&#xf…
阅读更多...
双向链表的创建以及增删改查

双向链表的创建以及增删改查

实现起来其实不难&#xff0c;于是我把代码做了优化&#xff0c;模仿了stm32的库函数哈哈哈&#xff0c;便于理解和修改。不足之处请指出 #include "stdio.h" #include "stdlib.h"//宏定义 #define ElementType int #define uint unsigned intElementType…
阅读更多...
数据结构课设——报数问题（约瑟夫环）

数据结构课设——报数问题（约瑟夫环）

题目 问题描述&#xff1a;有n个小朋友围成一圈玩游戏&#xff0c;小朋友从1至n编号&#xff0c;2号小朋友坐在1号小朋友的顺时针方向&#xff0c;3号小朋友坐在2号小朋友的顺时针方向&#xff0c;……&#xff0c;1号小朋友坐在n号小朋友的顺时针方向。 游戏开始&#xff0c;…
阅读更多...
数据结构——二叉树的线索化

数据结构——二叉树的线索化

简述 二叉树的线索化就是对利用二叉树指向空的指针节点加以利用&#xff0c;以实现能快速找到二叉树的直接前驱和直接后继 使其指空的左孩子指针指向其前驱 使其指空的有孩子节点指向其后继 对于不同的遍历顺序线索化的方式都是相同的&#xff0c;只不过线索化的线索有所不同…
阅读更多...
数据结构——线性表练习2

数据结构——线性表练习2

题目描述 已知两个链表A和B分别表示两个集合&#xff0c;其元素递增排列。请设计算法求出A与B的交集&#xff0c;并存放于A链表中。 程序 #include <bits/stdc.h> using namespace std; typedef int Elemtype; typedef struct LNode {Elemtype data;struct LNode *nex…
阅读更多...
归并排序算法（Java实现包含自顶向下的归并排序算法以及自底向上的归并排序算法）

归并排序算法（Java实现包含自顶向下的归并排序算法以及自底向上的归并排序算法）

归并排序算法一、归并排序的概念二、原地归并的抽象方法&#xff08;一&#xff09;、原地归并的抽象方法的概念&#xff08;二&#xff09;、原地归并的抽象方法的代码示例三、自顶向下的归并排序&#xff08;一&#xff09;、自顶向下的归并排序的概念&#xff08;二&#xf…
阅读更多...
基础知识点（一）单向链表和双向链表

基础知识点（一）单向链表和双向链表

单向链表 单链表删除节点 单链表添加节点 双向链表 双链表删除节点 双链表添加节点 所以链表的增删效率很高。 https://www.cnblogs.com/skywang12345/p/3561803.html
阅读更多...
lc005

lc005

删除链表重复元素 class ListNode:def __init__(self, x):self.val xself.next None class Solution:def deleteDuplication(self, pHead):# write code herecur pHeadresult ListNode(0)result.next pHeadpre resultif not cur:return Nonewhile cur:if (cur.next) and…
阅读更多...
java笔记【3.数组和链表的区别】

java笔记【3.数组和链表的区别】

最主要的区别是&#xff1a;数据结构不同 数组是基于索引的数据结构&#xff0c;其中每个元素与索引相关联。数组占用的是一块连续的内存区 链表依赖于引用&#xff0c;其中每个节点由数据和对前一个和下一个元素的引用组成。链表在内存中&#xff0c;是分散的 正是因为这样的…
阅读更多...
跳表和散列

跳表和散列

增加了额外的向前指针的链表叫做跳表。它采用随机技术来决定链表的哪些节点应增加向前指针&#xff0c;以及增加多少个指针&#xff0c;跳表的查找、插入、删除的平均复杂度为O(logn)O(logn)O(logn)&#xff0c;然而&#xff0c;最坏情况下的时间复杂度却变成O(n)O(n)O(n)。 散…
阅读更多...
【数据结构：线性表】顺序表

【数据结构：线性表】顺序表

⚡线性表 线性表&#xff08;linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使 用的数据结构&#xff0c;常见的线性表&#xff1a;顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构&#xff0c;也就说是连续的一条直…
阅读更多...
[PTA团体程序设计天梯赛-练习集] L2-002 链表去重

[PTA团体程序设计天梯赛-练习集] L2-002 链表去重

题目详情 (pintia.cn)https://pintia.cn/problem-sets/994805046380707840/problems/994805072641245184 给定一个带整数键值的链表 L&#xff0c;你需要把其中绝对值重复的键值结点删掉。即对每个键值 K&#xff0c;只有第一个绝对值等于 K 的结点被保留。同时&#xff0c;所…
阅读更多...
数据结构（C语言实现）——栈和队列的介绍及基本操作的实现（动态顺序栈+链队）

数据结构（C语言实现）——栈和队列的介绍及基本操作的实现（动态顺序栈+链队）

文章目录 1. 前言2. 栈2.1 结构定义2.2 栈的初始化和销毁2.3 入栈和出栈2.4 获取栈顶元素2.5 判断栈是否为空2.6 求栈中元素个数 3. 队列3.1 结构定义3.2 队列的初始化和销毁3.3 入队和出队3.4 取队头队尾元素3.5 判断队列是否为空3.6 求队列中元素个数 4. 结尾 1. 前言 今天我…
阅读更多...
第七章 查找

第七章 查找

第七章 查找 7.1 查找的基本概念 问题&#xff1a;在哪查找&#xff1f;——查找表 查找表是由同一类型的数据元素(或记录)构成的集合。由于"集合"中的数据元素之间存在着松散的关系&#xff0c;因此查找表是一种应用灵便的结构。 问题&#xff1a;什么查找&…
阅读更多...
Reverse Nodes in k-Group 以K个节点为一组反转链表

Reverse Nodes in k-Group 以K个节点为一组反转链表

文章目录Reverse Nodes in k-Group 以K个节点为一组反转链表问题虚头法 dummy head递归Reverse Nodes in k-Group 以K个节点为一组反转链表 Given the head of a singly linked list and two integers left and right where left < right, reverse the nodes of the list f…
阅读更多...
数据结构面试题和常用算法（1）

数据结构面试题和常用算法（1）

数据结构面试题 关于数据结构的基础知识&#xff0c;请翻看之前的文章 这里是Java版 题目一&#xff08;PPT&#xff09; 1. 第一题 这个很简单。循环遍历就好在这里不做多的叙述 2. 第二题&#xff08;新浪&#xff09; /*单链表都是从头开始遍历。- 定义节点- 定义链表 …
阅读更多...
【从零开始的嵌入式生活】文件I/O1——标准I/O

【从零开始的嵌入式生活】文件I/O1——标准I/O

今天正式进入应用层的学习&#xff0c;那么梦开始的地方就是文件I/O&#xff0c;接下来几天的时间都会围绕这部分内容展开&#xff0c;主要内容如下&#xff1a; 三连即可提高学习效率 &#x1f9d1;&#x1f3fb;作者简介&#xff1a;一个学嵌入式的年轻人 ✨联系方式&#…
阅读更多...
数据结构之超硬核热门复杂度、数组、链表OJ题2W+文字+图片详解

数据结构之超硬核热门复杂度、数组、链表OJ题2W+文字+图片详解

OJ题 文章目录OJ题复杂度的OJ练习1.消失的数字2.旋转数组数组的相关OJ题1.移除元素2.删除有序数组中的重复值3.合并两个有序数组链表OJ题1.移除链表元素2.反转链表3.查找一个链表的中间结点4.链表中倒数第k个结点5.合并两个有序链表6.链表分割7.链表的回文结构8.链表的相交9.环…
阅读更多...
栈的顺序存储实现----用一个数组实现两个堆栈（浙）

栈的顺序存储实现----用一个数组实现两个堆栈（浙）

#include <stdio.h> #include <malloc.h> #include <stdbool.h> #define MaxSizeArray 16//该程序的缺陷之处&#xff1a;调用CreateStack(int MaxSize)函数时&#xff0c;需与MaxSize保持一致&#xff08;重在理解堆栈&#xff0c;哈哈&#xff09; //用一个…
阅读更多...
线性表的链式存储实现（浙）

线性表的链式存储实现（浙）

#include <stdio.h> #include <malloc.h> typedef struct LNode *List; struct LNode {int Data;List Next; }; List PtrL;//创建指向空的结点 //函数声明 int Length(List PtrL); List Find(int x,List Ptrl); List FindKth(int K, List Ptrl); List Insert(int …
阅读更多...
算法通关40讲 笔记五（树 图 二叉树遍历）

算法通关40讲 笔记五（树 图 二叉树遍历）

树&#xff0c;二叉树&#xff0c;二叉搜索树 图 树和链表的联系 链表是next连接 实际上&#xff0c;树是一个节点出2个next节点&#xff0c;左节点和右节点。 父亲节点&#xff0c;儿子节点&#xff0c;兄弟节点。 树本身是分层的&#xff0c;比如层次遍历BFS。 完全二叉树 …
阅读更多...
Leetcode 实战笔记 四（206, 209, 215, 217, 234）

Leetcode 实战笔记 四（206, 209, 215, 217, 234）

No. 206 反转链表No. 209 长度最小的子数组No. 215 数组中的第K个最大元素No. 217 存在重复元素No. 234 回文链表 206. 反转链表 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 迭代法&#xff1a; def reverseList(head):prev Nonec…
阅读更多...
反转链表的几种解法 — C++实现

反转链表的几种解法 — C++实现

题目描述 输入一个链表&#xff0c;反转链表后&#xff0c;输出新链表的表头。 牛客网题目链接 解题思路1 使用额外空间&#xff0c;然后采用头插法将遍历到的结点插入到新建立链表的头部&#xff0c;将原链表的尾结点作为新链表的头结点即可&#xff0c;这种方法消耗的存储…
阅读更多...
LeetCode 147 对链表进行插入排序

LeetCode 147 对链表进行插入排序

题目描述&#xff1a; 对链表进行插入排序。 插入排序的动画演示如上。从第一个元素开始&#xff0c;该链表可以被认为已经部分排序&#xff08;用黑色表示&#xff09;。 每次迭代时&#xff0c;从输入数据中移除一个元素&#xff08;用红色表示&#xff09;&#xff0c;并原…
阅读更多...
LeetCode 138 复制带随机指针的链表

LeetCode 138 复制带随机指针的链表

题目描述&#xff1a; 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的…
阅读更多...
LeetCode 82 删除排序链表中的重复元素 II

LeetCode 82 删除排序链表中的重复元素 II

题目描述&#xff1a; 存在一个按升序排列的链表&#xff0c;给你这个链表的头节点 head &#xff0c;请你删除链表中所有存在数字重复情况的节点&#xff0c;只保留原始链表中 没有重复出现 的数字。 返回同样按升序排列的结果链表。 示例&#xff1a; 输入&#xff1a;head…
阅读更多...
C语言——学生信息管理系统（链表＆菜单＆最强版）

C语言——学生信息管理系统（链表＆菜单＆最强版）

有主菜单&#xff0c;和四个功能子菜单&#xff01;功能强大&#xff01;&#xff01;&#xff01; #include<stdio.h> #include<string.h> #include<malloc.h> #include<windows.h> #include<stdlib.h> #include<conio.h> #define SIZE …
阅读更多...
【从零开始的嵌入式生活】数据结构5——树

【从零开始的嵌入式生活】数据结构5——树

前言 这周因为不能出去就尽量把数据结构更完&#xff0c;每天一篇文章发布&#xff0c;请大家监督我&#xff0c;如果我没法请我催更0.0 三连即可提高学习效率0.0 &#x1f9d1;&#x1f3fb;作者简介&#xff1a;一个学嵌入式的年轻人 ✨联系方式&#xff1a;2201891280(QQ) …
阅读更多...
【从零开始的嵌入式生活】数据结构4——栈与队列

【从零开始的嵌入式生活】数据结构4——栈与队列

前言 这周因为不能出去就尽量把数据结构更完&#xff0c;每天一篇文章发布&#xff0c;请大家监督我&#xff0c;如果我没法请我催更0.0 三连即可提高学习效率0.0 &#x1f9d1;&#x1f3fb;作者简介&#xff1a;一个学嵌入式的年轻人 ✨联系方式&#xff1a;2201891280(QQ) …
阅读更多...
【从零开始的嵌入式生活】数据结构3——线性表及链表

【从零开始的嵌入式生活】数据结构3——线性表及链表

前言 最近回到了学校&#xff0c;导致啥也不想干呢&#xff0c;本来打算去实习的&#xff0c;offer拿到了&#xff0c;我还去了两天&#xff0c;封校了&#xff0c;你说这整的&#xff0c;继续写文章把。。。。 主要内容为&#xff1a; 三连即可提高学习效率0.0 &#x1f9d…
阅读更多...
【从零开始的嵌入式生活】数据结构2——线性表及顺序表

【从零开始的嵌入式生活】数据结构2——线性表及顺序表

前言 今天开了个新正式进入数据结构的学习&#xff0c;这两天颈椎病需要治一治所以有些拖更&#xff0c;治好我就满血复活0.0大家注意身体呀&#xff01; 另外今天竟然接到了第一个实习的面试邀请&#xff0c;惊喜&#xff0c;这两天也会加油更新的同时看看面经&#xff0c;相…
阅读更多...
贪吃蛇（链表实现）

贪吃蛇（链表实现）

文章目录正好有需要的材料&#xff0c;做条蛇玩一下&#xff0c;顺便巩固链表知识1. 硬件准备2. 软件分析3. 代码实现蛇的初始信息蛇的移动产生新食物检查蛇的状态让蛇动起来正好有需要的材料&#xff0c;做条蛇玩一下&#xff0c;顺便巩固链表知识 1. 硬件准备 STM32F103开发…
阅读更多...
链表初步

链表初步

1、链表初步 /* *copyright(c) 2018,HH *All rights reserved. *作 者&#xff1a;HH *完成日期&#xff1a;2018年9月4日 *版本号&#xff1a;v1.0 * *问题描述:链表初步 *输入描述&#xff1a;&#xff1b; *程序输出&#xff1a; */#include<stdio.h> struct student…
阅读更多...
重学数据结构：链栈的各种操作（C语言）

重学数据结构：链栈的各种操作（C语言）

文章目录链栈的定义头插法建立链表(带头节点)打印链栈压栈退栈测试代码测试结果链栈的定义 其实跟链表的结构是一样的&#xff0c;连同操作基本一样&#xff0c;但是链栈只能在一端进行删除节点和增加节点. typedef struct LNode {struct LNode *next;int data;int maxsize; …
阅读更多...
leetcode:19. 删除链表的倒数第N个节点 中等难度

leetcode:19. 删除链表的倒数第N个节点 中等难度

题目描述 给定一个链表&#xff0c;删除链表的倒数第 n 个节点&#xff0c;并且返回链表的头结点。 示例&#xff1a; 给定一个链表: 1->2->3->4->5, 和 n 2.当删除了倒数第二个节点后&#xff0c;链表变为 1->2->3->5.说明&#xff1a; 给定的 n 保…
阅读更多...
数据结构 循环队列的顺序存储与链式存储

数据结构 循环队列的顺序存储与链式存储

循环队列的顺序存储 #include<stdio.h> #include<stdlib.h> #define MaxSize 10typedef int QElemType;typedef struct{ //对循环队列的结点的结构体进行定义QElemType data[MaxSize];int front; //头指针指向队首元素int rear; //尾指针指向队尾元…
阅读更多...
算法R2D1-快速排序

算法R2D1-快速排序

打开题目&#xff0c;发现完全忘了&#xff0c;完美。 n int(input()) q list(map(int,input().split()))def quick_sort(q,l,r):# 终止条件if l>r:return#随便找个切分点x q[lr>>1]#初始化指针i,j l-1,r1#如果两个指针还没交叉或重合就一直执行&#xff0c;直到…
阅读更多...
Leecode 25. K 个一组翻转链表 链表

Leecode 25. K 个一组翻转链表 链表

原题链接&#xff1a;Leecode 25. K 个一组翻转链表 emmmm&#xff0c;做题脑子要清醒。。下面的代码里有一些注释&#xff0c;但我感觉我写的很不清楚。。。大概的意思就是&#xff1a; 如果链表是1 2 3 4 5 &#xff0c;k3&#xff0c;反转前三个 1 2 3 的过程如下&…
阅读更多...
详解环形链表

详解环形链表

LeetCode链接 【题目描述】 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 实例1&#xff1a;有链表3-->2-->0-->-4-->2&#xff0c;可以一眼看出其内部是有环的。 但是用代码如何判断有环&am…
阅读更多...
Collection的子类

Collection的子类

List 特点&#xff1a;有序&#xff0c;有索引&#xff0c;元素可以重复 List是接口&#xff0c;不能直接使用&#xff0c;需要创建其实现类 List下常用实现类&#xff1a; 1、ArrayList集合底层结构是&#xff1a;数组&#xff0c;所以查询快&#xff0c;增删慢&#xff0c;线…
阅读更多...
Leecode 24. 两两交换链表中的节点 链表

Leecode 24. 两两交换链表中的节点 链表

原题链接&#xff1a;Leecode 24. 两两交换链表中的节点 class Solution { public:ListNode* swapPairs(ListNode* head) {if(headnullptr || head->nextnullptr)return head;ListNode* tmphead->next;ListNode* nodetmp->next;tmp->nexthead;head->nextswapPa…
阅读更多...
双向循环链表的创建及基本操作

双向循环链表的创建及基本操作

数据结构c语言双向循环链表 双向循环链表在定义上类似于循环单链表&#xff0c;就多了个前指针&#xff0c;以方便于向前查找。在双向链表中需要同时修改两个方向的指针&#xff0c;是单向链表指针的两倍。 完整代码如下&#xff1a; #include <stdio.h> #include <…
阅读更多...
【LeetCode】203 移除链表元素（JAVA实现）

【LeetCode】203 移除链表元素（JAVA实现）

题目描述&#xff1a; 解题思路&#xff1a; 题目要求要返回一个新的头节点&#xff0c;因此我们可以采用复制头节点的方式&#xff0c;定义节点cur来代替头节点进行操作&#xff0c;最后返回头节点即可&#xff1b;但是我们要考虑到如果头节点也是需要删除的节点的话&#xff…
阅读更多...
【数据结构】JAVA语言实现—顺序表和单链表的基本功能（附超详细注释）

【数据结构】JAVA语言实现—顺序表和单链表的基本功能（附超详细注释）

文章目录1、线性表2、顺序表2.1 概念及结构2.2 顺序表接口的实现2.2.1 打印顺序表2.2.2 在pos位置新增元素2.2.3 判定是否包含某个元素2.2.4 查找某个元素对应的位置2.2.5 获取 pos 位置的元素2.2.6 给 pos 位置的元素设为 value2.2.7 删除第一次出现的关键字key2.2.8 获取顺序…
阅读更多...
记：应聘锐明科技 C++工程师（两个月前就该发了）

记：应聘锐明科技 C++工程师（两个月前就该发了）

笔试 1.gcc的编译流程一般分为&#xff1a; 预处理、编译、汇编、链接。 hello.c 经过预处理可以得到 hello.i 使用 gcc -E hello.c –o hello.i 命令。 经过编译得到hello.s 使用 gcc -S hello.i 命令 得到汇编文件。 经过汇编得到hello.o 使用 gcc -c hello.s 命令 得到机器…
阅读更多...
零基础入门单向链表的：增，删，改，查

零基础入门单向链表的：增，删，改，查

该链表拥有一个头节点&#xff0c;头节点中的数据域用来存储链表的节点个数&#xff0c;指针域指向第一个数据节点。以下是代码。 链表结构体定义: struct ListNode { int num; struct ListNode* next; }; typedef struct ListNode Node; //重命名为Node 创建头节点 Node *hea…
阅读更多...
【Java】HashMap线程安全问题

【Java】HashMap线程安全问题

一、线程不安全的原因 jdk1.7和jdk1.8中HashMap都是线程不安全的&#xff0c;那就具体讲一下为什么会线程不安全(两个方面)。 &#xff08;1&#xff09;调用put方法 假如有两个线程A和B&#xff0c;A希望插入一个key-value到HashMap中&#xff0c;首先会通过A的key得到桶的…
阅读更多...
leetcode700-每日刷题档

leetcode700-每日刷题档

给定二叉搜索树&#xff08;BST&#xff09;的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在&#xff0c;则返回 NULL。 public TreeNode searchBST(TreeNode root, int val) {if (root null || root.val val) {retu…
阅读更多...
快慢指针(LeetCode寻找重复数)，弗洛伊德的乌龟和兔子

快慢指针(LeetCode寻找重复数)，弗洛伊德的乌龟和兔子

写此篇博客在于总结&#xff0c;记忆之用&#xff0c;欢迎评论补充。 弗洛伊德的乌龟和兔子&#xff0c;即快慢指针。 对于LeetCode287题&#xff0c;寻找重复数&#xff0c;题目如下&#xff1a; 给定一个包含 n 1 个整数的数组 nums&#xff0c;其数字都在 1 到 n 之间&…
阅读更多...
双向链表基本操作(C语言)

双向链表基本操作(C语言)

#include <stdio.h> #include <stdlib.h> #include<stdbool.h>//双向链表 typedef int Elemtype; typedef struct DNode {Elemtype data;struct DNode *prior,*next; } DNode,*DLinkList;//尾插法创建链表 DLinkList CreateList() {int x;DLinkList head(DLi…
阅读更多...
数据结构和算法（七）栈 Stack

数据结构和算法（七）栈 Stack

1、栈简介 栈&#xff08;Stack&#xff09;是一个先进后出的有序列表栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端为变化的一端&#xff0c;成为栈顶&#xff08;Top&#xff09;&#xff0c;另一端为固定的一端&#x…
阅读更多...
LeetCode刷题笔记 Java 腾讯 链表 合并两个有序链表

LeetCode刷题笔记 Java 腾讯 链表 合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 class Solution {public ListNode mergeTwoLists(ListNode list1, ListNode list2) {ListNode prenew ListNode(-1);ListNode headpre;while(list1!null&list2!null){if(…
阅读更多...
动态链表的增删查改 学习C语言

动态链表的增删查改 学习C语言

大家好~ 在学习C语言的过程中&#xff0c;动态链表的相关操作总是会把我弄得有点晕。思路是有的&#xff0c;但是写完代码之后就很容易被自己绕晕。 于是今天想把我在链表的创建、输出、插入删除的过程中出现的问题总结一下&#xff0c;理清一下自己的思路&#xff0c;防止以后…
阅读更多...
记录一下用js写链表，以后再看吧

记录一下用js写链表，以后再看吧

<!doctype html> <html> <head><meta charset"utf-8"><title>双链表-插入排序</title><meta http-equiv"Content-Type" content"text/html; charsetgb2312" /> </head> <script type"t…
阅读更多...
牛客 剑指offer 复杂链表的复制

牛客 剑指offer 复杂链表的复制

题目 \qquad输入一个复杂链表&#xff08;每个节点中有节点值&#xff0c;以及两个指针&#xff0c;一个指向下一个节点&#xff0c;另一个特殊指针random指向一个随机节点&#xff09;&#xff0c;请对此链表进行深拷贝&#xff0c;并返回拷贝后的头结点。&#xff08;注意&am…
阅读更多...
Leetcode-每日一题【61.旋转链表】

Leetcode-每日一题【61.旋转链表】

题目 给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], k 2 输出&#xff1a;[4,5,1,2,3] 示例 2&#xff1a; 输入&#xff1a;head [0,1,2], k 4输出&#xff1a…
阅读更多...
leetcode每日一道（8）：神仙思路！对于一个给定的链表，求环的入口节点

leetcode每日一道（8）：神仙思路！对于一个给定的链表，求环的入口节点

文章目录1. 题目描述2. 一般思路3. 神奇思路4. 代码4.1 普通思路4.2 神仙思路1. 题目描述 对于一个给定的链表&#xff0c;返回环的入口节点&#xff0c;如果没有环&#xff0c;返回null 拓展&#xff1a; 你能给出不利用额外空间的解法么&#xff1f; 2. 一般思路 当然这个题…
阅读更多...
leetcode每日一道（5）：使用插入排序对链表进行排序。

leetcode每日一道（5）：使用插入排序对链表进行排序。

题目描述 使用插入排序对链表进行排序。 Sort a linked list using insertion sort. 思路 可以开辟一条新的链表来存储&#xff0c;并且这里也用到了虚拟头节点的技巧。没什么难的事情&#xff0c;主要就是对链表的操作要熟悉&#xff0c;要考虑到断链之后新链头的保存&#x…
阅读更多...
题125.2021秋周练习-3-5 单链表分段逆转 (20 分)

题125.2021秋周练习-3-5 单链表分段逆转 (20 分)

文章目录题125.2021秋周练习-3-5 单链表分段逆转 (20 分)一、题目二、题解题125.2021秋周练习-3-5 单链表分段逆转 (20 分) 一、题目 二、题解 本题要你分段逆转链表&#xff0c;可想到用栈和队列来顺序存原始链表元素&#xff0c;然后元素出栈&#xff0c;出队接入新链表从而达…
阅读更多...
第四章 串、数组、广义表

第四章 串、数组、广义表

第四章 串、数组、广义表 4.1 串的定义(string) 定义 术语 子串&#xff1a;一个串中任意个连续字符组成的子序列(含空串)称为该串的子串 例如&#xff1a; 真子串是指不包含自身的所有子串 主串&#xff1a;包含子串的串相应地称为主串 字符位置&#xff1a;字符在序列中…
阅读更多...
案例2.1-一元多项式的运算（单链表实现）

案例2.1-一元多项式的运算（单链表实现）

案例2.1-一元多项式的运算&#xff08;单链表实现&#xff09; #pragma once #include <iostream> #include<string> using namespace std;typedef struct {double coef;int exp; } PolyArray;typedef struct pnode {double coef;int exp;struct pnode* next; } P…
阅读更多...
图的十字链表的建立，c/c++描述

图的十字链表的建立，c/c++描述

图比树有更复杂的数据关系。数据间是多对多的关系&#xff0c;有多个前驱&#xff0c;多个后继。对于有向图&#xff0c;图的邻接表&#xff0c;只能表示顶点的出边邻接点&#xff0c;即所有以表头顶点为边尾的顶点&#xff0c;求顶点的出度很方便&#xff0c;计算链表里除表头…
阅读更多...
【维修类别】

【维修类别】

需求分析 维修类别功能界面如下&#xff1a; 维修类别大致就是故障种类&#xff0c;它是丛属班组的&#xff0c;目前系统中在用的班组只有两个【电仪和设备】 除了从属于班组&#xff0c;维修类别还和具体的设备种类有关&#xff0c;&#xff08;比如加弹机&#xff0c;染色机…
阅读更多...
【需求研发001】--备品备件系统优化

【需求研发001】--备品备件系统优化

1.PDA领料出库&#xff0c;拣配任务清单按创建日期自动排序 PDA的领料出库&#xff0c;虽然是在PDA设备里操作&#xff0c;但是它真正调用的&#xff0c;是备品备件生产环境的后端。 因此&#xff0c;这个需求&#xff0c;只需要改动生产环境的后端API&#xff0c;即可。 找…
阅读更多...
leetcode[19]删除链表的倒数第N个节点 python3实现（经典快慢指针+虚节点）

leetcode[19]删除链表的倒数第N个节点 python3实现（经典快慢指针+虚节点）

# 给定一个链表&#xff0c;删除链表的倒数第 n 个节点&#xff0c;并且返回链表的头结点。 # # 示例&#xff1a; # # 给定一个链表: 1->2->3->4->5, 和 n 2. # # 当删除了倒数第二个节点后&#xff0c;链表变为 1->2->3->5. # # # 说明&…
阅读更多...
广义表的c/c++描述（上）理论篇

广义表的c/c++描述（上）理论篇

广义表仍然属于单链表&#xff0c;是在单链表的基础上扩大应用范围而来的&#xff0c;即链表中的节点不仅可以是元素、数据&#xff0c;还可以是子表&#xff0c;一个新的子链表&#xff0c;子表也有自己的表头节点。用结构体变量描述链表节点&#xff0c;每个节点都有两个指针…
阅读更多...
LeetCode61：旋转链表

LeetCode61：旋转链表

/*给定一个链表&#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置&#xff0c;其中 k 是非负数。示例 1:输入: 1->2->3->4->5->NULL, k 2 输出: 4->5->1->2->3->NULL 解释: 向右旋转 1 步: 5->1->2->3->4->NULL…
阅读更多...
LeetCode82:删除排序链表中的重复元素||

LeetCode82:删除排序链表中的重复元素||

/*给定一个排序链表&#xff0c;删除所有含有重复数字的节点&#xff0c;只保留原始链表中 没有重复出现 的数字。示例 1:输入: 1->2->3->3->4->4->5 输出: 1->2->5 示例 2:输入: 1->1->1->2->3 输出: 2->3 */ class Solution { public…
阅读更多...
数据结构（图）

数据结构（图）

1. 基于邻接矩阵存储的有向图&#xff0c;求出度为零的顶点个数 【问题描述】基于邻接矩阵存储的有向图&#xff0c;设计算法求出度为零的顶点个数。 【输入形式】第一行输入图的顶点个数verNum和边的个数edgeNum&#xff0c;用于构造图。 第二行顶点信息&#xff1b;接下来…
阅读更多...
数据结构（树和二叉树）

数据结构（树和二叉树）

1. 前序打印叶子结点 【问题描述】设计算法&#xff0c;要求按照前序遍历方式打印二叉树的叶子结点。 【输入形式】一行字符串&#xff0c;该行是扩展二叉树的前序遍历序列&#xff0c;用于构造二叉树。 【输出形式】二叉树的前序叶子遍历序列&#xff08;中间用空格隔开&am…
阅读更多...
*POJ 1214 “Accordian“ Patience

*POJ 1214 “Accordian“ Patience

题目描述 链表的练习题&#xff0c;自己对于此类题练习较少&#xff0c;需要在今后多加练习&#xff0c;此题代码量也较大&#xff0c;需要在日后多加练习 #include<cstdio> struct node{int size;node *pre,*post;node *down;char a,b;node():pre(NULL),post(NULL),dow…
阅读更多...
Leetcode 刷题必须Review 九 Lintcode（170 99 599 478 283）

Leetcode 刷题必须Review 九 Lintcode（170 99 599 478 283）

170 旋转链表 给定一个链表&#xff0c;旋转链表&#xff0c;使得每个节点向右移动k个位置&#xff0c;其中k是一个非负数 def rotateRight(self, head, k):# write your code hereif not head: return elif k 0: return headelif not head.next: return headdummy ListNod…
阅读更多...
LeetCode 142 环形链表 II

LeetCode 142 环形链表 II

题目描述&#xff1a; 给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 为了表示给定链表中的环&#xff0c;我们使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;索引从 0 开始&#xff09;。 如果 pos 是 -1&…
阅读更多...
leetcode_合并两个有序链表

leetcode_合并两个有序链表

将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4] 输入&#xff1a;l1 [], l2 [] 输出&#xff1a;[]输入&#xff1a;l1 [], l2 [0] 输出&#…
阅读更多...
向单向链表中部插入节点

向单向链表中部插入节点

构造一条含有两个节点的单向链表&#xff1a;学生A&#xff0c;学生B 单向链表的某一节点后插入&#xff0c;知道此节点的指针域next即可 例如向节点A后插入&#xff0c;节点C&#xff1a; C.next A.next; //A的下一个地址&#xff0c;就是B的地址&#xff1b;C连接B A.…
阅读更多...
单向链表新增节点之头插法（接上一篇尾插法）

单向链表新增节点之头插法（接上一篇尾插法）

使用“头插法”在单向链表的头部插入新的节点 与尾插法的区别是&#xff1a;只需要定义pHead&#xff08;指向头部节点首地址&#xff09;即可&#xff0c;不用定义pTail&#xff0c;更简单 不变的还是中间指针“pNode”在传递新的节点地址&#xff01;&#xff01;&#xff…
阅读更多...
顺序表和链表2

顺序表和链表2

目录 3、链表&#xff1a; 3.1 、链表的概念及结构 &#xff1a; 3.2、链表的分类 &#xff1a; 3.3、链表以文件形式进行实现 &#xff1a; 3.3.1、test.c源文件&#xff1a; 3.3.2、SList.c源文件&#xff1a; 3.3.3、SList.h头文件&#xff1a; 3.4、链表面试题&…
阅读更多...
链表新增节点之单向链表尾部插入新增节点

链表新增节点之单向链表尾部插入新增节点

保持头部节点首地址不变&#xff08;pHead始终指向头部节点首地址&#xff09;&#xff0c;更新尾部节点首地址&#xff08;pTail&#xff09;的方法 详见注释 /* *copyright(c) 2018,HH *All rights reserved. *作 者&#xff1a;HH *完成日期&#xff1a;2020年月4日 *版本…
阅读更多...
【链表OJ题】输入一个链表，输出该链表中倒数第k个结点。

【链表OJ题】输入一个链表，输出该链表中倒数第k个结点。

【链表OJ题】&#xff1a; 本题来自牛客网算法题&#xff0c;链接&#xff1a;链表中倒数第k个结点 题目&#xff1a;输入一个链表&#xff0c;输出该链表中倒数第k个结点。 对于这个题目&#xff0c;其实直接做的也不是不行&#xff0c;强硬一点直接先得到数组长度然后去减去…
阅读更多...
对于空链表的小疑惑

对于空链表的小疑惑

今天在写了leetcode的合并2个有序的链表&#xff08;T21&#xff09;时&#xff0c;我遇到了一个疑惑&#xff0c;那就是空的链表到底是直接是一个指针 nullptr 还是 new 一个这样的指针&#xff0c;但是不插入节点呢&#xff1f; 这里以单链表为例子&#xff1a; 请看以下代…
阅读更多...
【Leetcode60天带刷】day04链表——24. 两两交换链表中的节点， 19.删除链表的倒数第N个节点 ，面试题 02.07. 链表相交

【Leetcode60天带刷】day04链表——24. 两两交换链表中的节点， 19.删除链表的倒数第N个节点 ，面试题 02.07. 链表相交

题目&#xff1a;24. 两两交换链表中的节点 Leetcode原题链接&#xff1a;24. 两两交换链表中的节点 思考历程与知识点&#xff1a; 因为头结点没有前一个节点&#xff0c;所以为了让所有节点都能采用同一种调换方式&#xff0c;选择用虚拟头结点的写法。虚拟头结点可以理解…
阅读更多...
【Java】带你从零到一系列10 画图带你从顺序表到链表3

【Java】带你从零到一系列10 画图带你从顺序表到链表3

单向链表学会了&#xff1f;那来看看双向链表吧&#xff01; 前言&#xff1a;上一篇我们学习了单链表&#xff0c;已经找到对于链表的概念有了一定的掌握&#xff0c;我们之前说介绍单向还有双向的&#xff0c;所以我们这一篇将带你走进双向链表的学习&#xff01; 没有看过单…
阅读更多...
Java集合-HashMap-LinkedHashMap

Java集合-HashMap-LinkedHashMap

HashMap-LinkedHashMap概述重要的参数put函数的实现get函数的实现hash函数的实现Resize的实现概述 ①以数组链表红黑树实现。主要用来处理具有键值对特征的数据。 ②当链表长度大于阈值&#xff08;或者红黑树的边界值&#xff0c;默认为 8 &#xff09;并且当前数组的长度大于…
阅读更多...
【链表】206. 反转链表

【链表】206. 反转链表

题目&#xff1a; 题意&#xff1a;反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 代码&#xff1a; 只需要改变链表的next指针的指向&#xff0c;直接将链表反转 思路&#xff1a; 首先定义一个cur指针&a…
阅读更多...
线性结构之---列表

线性结构之---列表

什么是列表&#xff1f; 列表是一种简单强大的数据及结构&#xff0c;提供了丰富的操作接口 一种数据项按照相对位置存放的数据集&#xff0c;被称为无序表 例如&#xff1a;考试分数集合 “54,26,93,17,77,31” 如果用无序表表示就是[54,26,93,17,77,31] 无序表的操作 L…
阅读更多...
Golang每日一练(leetDay0113) 奇偶链表、链表随机节点

Golang每日一练(leetDay0113) 奇偶链表、链表随机节点

目录 328. 奇偶链表 Odd Even Linked-list &#x1f31f;&#x1f31f; 382. 链表随机节点 Llinked-list Random Node &#x1f31f;&#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Rust每日一练 专栏 Golang每日一练 专栏 Python每日一练 专栏 C/C每日…
阅读更多...
数据结构Java实现02--数组、链表和动态数组

数据结构Java实现02--数组、链表和动态数组

2.数组和链表 2.1 数组 数组 Array 是一种线性数据结构&#xff0c;其将相同类型元素存储在连续的内存空间中。我们将元素在数组中的位置称为元素的索引 index。 数组初始化。一种给定初始值&#xff0c;称为静态初始化。 /*以下两种方式均可静态初始化*/ int[] nums new …
阅读更多...
ArrayList、LinkedList、CopyOnWriterArrayList这三者有什么区别？

ArrayList、LinkedList、CopyOnWriterArrayList这三者有什么区别？

ArrayList、LinkedList、CopyOnWriterArrayList这三者有什么区别&#xff1f; 首选ArrayList是个数组&#xff0c;所以可以通过下标查询&#xff0c;查询速度快。在使用add()添加元素的时候,正常情况下是在数组末尾添加&#xff0c;如果需要扩容那么这个添加操作就会变得很长&…
阅读更多...
头指针单向链表基本操作

头指针单向链表基本操作

title: 头指针单向链表基本操作 date: 2020-10-04 16:47:34 tags: 单链表基本操作 categories: 数据结构 感觉每次自己提前写的东西都和老师讲的书上内容不太一样 当然大多数是老师讲的更正规一些&#xff0c;毕竟我只是一个会了链表本质就瞎玩的人 属于自己琢磨&#xff0c;自…
阅读更多...
数据结构与算法学习---数据结构篇（符号表）（默然回首，夯实基础）

数据结构与算法学习---数据结构篇（符号表）（默然回首，夯实基础）

一、符号表 符号表最主要的目的就是将一个键和一个值联系起来&#xff0c;符号表能够将存储的数据元素是一个键和一个值共同组成的键值对数据&#xff0c;我们可以根据键来查找对应的值。 符号表中&#xff0c;键具有唯一性。 符号表在实际生活中的使用场景是非常广泛的&…
阅读更多...
ListMap集合

ListMap集合

List集合 List接口 继承于Collection接口有序可重复原则&#xff0c;集合中每个元素具有对应的索引&#xff0c;可以通过索引直接访问该元素List集合默认按照添加元素的顺序设置索引List集合关心是否有序但并不关心是否重复List接口的实现类由ArrayList动态数组、Vector动态数…
阅读更多...
用链表来实现二叉树

用链表来实现二叉树

二叉树最多只能有两个子节点&#xff0c;也就是说分支度小于或等于2.所谓二叉树的链表表示法&#xff0c;就是利用链表来存储二叉树。 使用链表来表示二叉树的好处是节点的增加与删除操作相对容易&#xff0c;缺点是很难找到父节点&#xff0c;除非在每一节点多增加一个指向父…
阅读更多...
《数据结构和算法》— 哈希表

《数据结构和算法》— 哈希表

1.哈希表&#xff1a;也叫散列表&#xff0c;每一个元素都有对应的key和value&#xff0c;我们可以通过对应的key找到需要的value 举个例子&#xff1a; 1&#xff1a;韩梅梅 2&#xff1a;李雷 好处是可在一堆数据中&#xff0c;迅速的找到自己需要的元素 如果将key就是数组&…
阅读更多...
十道腾讯算法真题解析

十道腾讯算法真题解析

前言 大家好&#xff0c;这里收集了腾讯常考的十道算法题&#xff08;真题&#xff09;。在金三银四&#xff0c;希望对大家有帮助呀。 重排链表最长递增子序列环形链表反转链表最长回文子串全排列LRU 缓存合并K个升序链表无重复字符的最长子串删除链表的倒数第 N 个结点 1. …
阅读更多...
队列（链表实现）

队列（链表实现）

链式队列在进队时无队满问题&#xff0c;但有队空问题。 队空条件为 front NULL 目录 队列抽象数据类型&#xff08;模板&#xff09; 建立链式队列&#xff08;声明&#xff09; 清空队列 进队 出队 队列抽象数据类型&#xff08;模板&#xff09; template <class …
阅读更多...
数据仓库相关概念

数据仓库相关概念

概念&#xff1a; 拉链表的含义&#xff1a;http://zouzhi.iteye.com/blog/1139459 https://wenku.baidu.com/view/cea52b8cf18583d048645935.html 数据库镜像的含义&#xff1a;http://baike.baidu.com/link?urlLglJuxLjnYmMifoGejVbC3HWlwiRlg-Ha5a3Q1iTsCjlztTLItpckyiv…
阅读更多...
王道数据结构课代表 - 考研数据结构 第二章 线性表 究极精华总结笔记（C版本）

王道数据结构课代表 - 考研数据结构 第二章 线性表 究极精华总结笔记（C版本）

本篇博客是考研期间学习王道课程传送门的笔记&#xff0c;以及一整年里对数据结构知识点的理解的总结。希望对新一届的计算机考研人提供帮助&#xff01;&#xff01;&#xff01; 关于对 “线性表” 章节知识点总结的十分全面&#xff0c;涵括了《王道数据结构》课程里的全部要…
阅读更多...
基于链表的队列实现

基于链表的队列实现

队列接口声明&#xff1a; #ifndef __LINKLIST_QUEUE_H_ #define __LINKLIST_QUEUE_H_ struct unit {char data;struct unit* punit; };struct linklistqueue {int size;struct unit* phead;struct unit* ptail;void(*pfunenqueue)(struct linklistqueue* pqueue, char value)…
阅读更多...
leetcode237删除链表中的结点-每日刷题档

leetcode237删除链表中的结点-每日刷题档

首先把问题 放入&#xff1a; 请编写一个函数&#xff0c;用于 删除单链表中某个特定节点 。在设计函数时需要注意&#xff0c;你无法访问链表的头节点 head &#xff0c;只能直接访问 要被删除的节点 。 题目数据保证需要删除的节点 不是末尾节点 。 来源&#xff1a;力扣&a…
阅读更多...
Java集合源码分析（十六）：LinkedHashMap

Java集合源码分析（十六）：LinkedHashMap

LinkedHashMap是HashMap的子类&#xff0c;所以也具备HashMap的诸多特性。不同的是&#xff0c;LinkedHashMap还维护了一个双向链表&#xff0c;以保证通过Iterator遍历时顺序与插入顺序一致。除此之外&#xff0c;它还支持Access Order&#xff0c;即按照元素被访问的顺序来排…
阅读更多...
详解链表相交

详解链表相交

LeetCode链接 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 这里的相交并不是简单的值相同&#xff0c;而是节点是否相同&#xff01; 从这个实例中我们可以看出&#xff0c;A…
阅读更多...
【哈希表】383. 赎金信

【哈希表】383. 赎金信

题目&#xff1a; 给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串&#xff0c;判断第一个字符串 ransom 能不能由第二个字符串 magazines 里面的字符构成。如果可以构成&#xff0c;返回 true &#xff1b;否则返回 false。 (题目说明&#xff1a;为了不暴露赎金…
阅读更多...
【哈希表】454. 四数相加 II

【哈希表】454. 四数相加 II

题目&#xff1a; 给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) &#xff0c;使得 A[i] B[j] C[k] D[l] 0。 为了使问题简单化&#xff0c;所有的 A, B, C, D 具有相同的长度 N&#xff0c;且 0 ≤ N ≤ 500 。所有整数的范围在 -2^28 到 2…
阅读更多...
【链表】19. 删除链表的倒数第 N 个结点

【链表】19. 删除链表的倒数第 N 个结点

题目&#xff1a; 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 进阶&#xff1a;你能尝试使用一趟扫描实现吗&#xff1f; 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] 示例 2&#…
阅读更多...
剑指offer链表中倒数第K个节点

剑指offer链表中倒数第K个节点

第一种方法 看到这道题的第一想法便是先求一下链表的长度&#xff08;size&#xff09;&#xff0c;然后再根据一些判断条件遍历链表走到相应的位置即可。 分析&#xff1a;我们要找倒数第k个节点&#xff0c;那么只需要走到size-k的位置即可。&#xff08;可以简单的记为相加…
阅读更多...
直接插入排序-链表形式与顺序表形式

直接插入排序-链表形式与顺序表形式

//链表形式的直接插入排序 #include<stdio.h> #include<stdlib.h> typedef int T; typedef struct node {T element;struct node* Link; }Node; typedef struct list {Node* First; }List; Node* NewNode(T x) {Node* n (Node*)malloc(sizeof(Node));n->elemen…
阅读更多...
双向循环链表的头插、中插、尾插、删除、逆序顺序显示（C++实现）

双向循环链表的头插、中插、尾插、删除、逆序顺序显示（C++实现）

我们在单链表中，有了next指针，这就使得我们要查找下一个结点的时间复杂度为O(1),可是如果我们要查找的是上一个结点的话，那么最坏的时间复杂度为O(n)。因为我们每次都要从头开始遍历。 为了克服单向性这一缺点，双向链表就横空出示。双向链表是在单链表的每一个结点中再设置…
阅读更多...
链表（3）----循环单链表基本操作

链表（3）----循环单链表基本操作

1、循环链表基本定义 typedef struct CListElement_t_{void *data;struct CListElement_t *next; } CListElement_ttypedef struct CList_t_ {int size;int (*match)(const void *key1, const void *key2);int (*destroy)(void *data);CListElement_t *head;CListElement_t …
阅读更多...
【脚踢数据结构】内核链表

【脚踢数据结构】内核链表

(꒪ꇴ꒪ )&#xff0c;Hello我是祐言QAQ我的博客主页&#xff1a;C/C语言,Linux基础,ARM开发板&#xff0c;软件配置等领域博主&#x1f30d;快上&#x1f698;&#xff0c;一起学习&#xff0c;让我们成为一个强大的攻城狮&#xff01;送给自己和读者的一句鸡汤&#x1f914;&…
阅读更多...
栈和队列、

栈和队列、

目录 1、栈&#xff1a; 1.1、栈的概念及结构&#xff1a; 1.2、栈的实现&#xff1a; 1.2.1、test.c源文件&#xff1a; 1.2.2、Stack.c源文件&#xff1a; 1.2.3、Stack.h头文件&#xff1a; 1.3、例题1&#xff1a; 2、队列&#xff1a; 2.1、队列的概念及结构&…
阅读更多...
C++实现单链表（含完整代码）

C++实现单链表（含完整代码）

C实现单链表&#xff08;含完整代码&#xff09; 使用C实现单链表的基本操作 1、创建单链表 2、遍历单链表 3、插入单链表元素 4、单链表删除元素 5、判断单链表是否为空 6、单链表的长度 7、查找单链表元素 完整代码&#xff1a; #include <iostream>using namespace…
阅读更多...
零基础玩转C语言单链表

零基础玩转C语言单链表

下图为最一简单链表的示意图&#xff1a; 第 0 个结点称为头结点&#xff0c;它存放有第一个结点的首地址&#xff0c;它没有数据&#xff0c;只是一个指针变量。以下的每个结点都分为两个域&#xff0c;一个是数据域&#xff0c;存放各种实际的数据&#xff0c;如学号 num&…
阅读更多...
2.8-2.9单链表的基本操作详解

2.8-2.9单链表的基本操作详解

单链表的基本操作详解 单链表的创建、插入、删除、修改、查找等基本操作 单链表的结点上存储数据data和下个结点的地址——后继指针next&#xff0c;所以可以定义一个结构体存储这两个元素&#xff1a; //结点结构体 typedef struct Node {int data;struct Node* next; }Node…
阅读更多...
求带环链表的入口的多种解法

求带环链表的入口的多种解法

方法1&#xff1a; 公式推导:定义两个指针&#xff0c;一个快指针&#xff0c;一个慢指针。两个指针一起走&#xff0c;快指针每次走两步&#xff0c;慢指针每次走一步&#xff08;相当于速度不一样&#xff09;。如果有环&#xff0c;那么它们就一定会相遇&#xff0c;当他们相…
阅读更多...
LeetCode学习-第二十二

LeetCode学习-第二十二

第二十二天 我使用的C&#xff0c;错误的地方请见谅&#xff0c;文章初衷仅用来督促本人学习&#xff0c;如果恰巧能够给你带来帮助&#xff0c;我会十分开心。 文章目录第二十二天一、82. 删除排序链表中的重复元素 II二、15. 三数之和三、844. 比较含退格的字符串一、82. 删…
阅读更多...
先进后出之堆栈算法

先进后出之堆栈算法

栈的基本知识介绍与手动实现 我们都知道 Java 里面其实已经实现了栈结构&#xff0c;使用 Stack stack new Stack<>(); 就可以创建出一个堆栈。但是如果希望手动实现一个简单的堆栈&#xff0c;你定义一个链表节点&#xff0c;节点里面包含数据&#xff0c;以及下一个节…
阅读更多...
Java集合之Map

Java集合之Map

Map的基本介绍 说到Map&#xff0c;和我们数学中的函数很相似 1、Map的结构 相对于collection单列数据来说&#xff0c;Map是双列数据。 结构Key-Value<k,v> Map中的Key&#xff1a;无序的&#xff0c;不可重复的&#xff0c;可以理解为使用set存储key Map中的valu…
阅读更多...
数据结构C语言篇-链表的生成编程实现

数据结构C语言篇-链表的生成编程实现

链表的生成编程实现在表头插入生成单链表在表尾插入生成单链表在表头插入生成单链表 #include<stdio.h> #include<stdlib.h> typedef struct node {char data;//data为结点的数据信息struct node *next;//next为指向后继结点的指针 }LNode;//单链表结点类型 void…
阅读更多...
Leecode 23. 合并K个升序链表 链表 递归/优先队列

Leecode 23. 合并K个升序链表 链表 递归/优先队列

原题链接&#xff1a;Leecode 23. 合并K个升序链表 解法一&#xff1a;找到每一个链表表头最小值的链表&#xff0c;再递归遍历 class Solution { public:ListNode* rootnullptr;ListNode* tempnullptr;ListNode* mergeKLists(vector<ListNode*>& lists) {if(lists…
阅读更多...
从源码分析HashMap的实现原理

从源码分析HashMap的实现原理

HashMap整体分析 HashTable继承Map接口&#xff0c;提供了map中所有的操作并且等价于HashMap&#xff0c;除了它是多线程的并且允许为多个null值。基础的操作为get、put操作&#xff0c;通过hash函数将元素放到桶中&#xff0c;遍历集合需要时间去计算HashMap的容量&#xff08…
阅读更多...
数据结构 栈的顺序存储与链式存储

数据结构 栈的顺序存储与链式存储

//栈的顺序存储 #include<stdlib.h> #include<stdio.h>#define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define OK 1 #define ERROR 0 #define OVERFLOW -2typedef int status;typedef struct{int *base;int *top;int stacksize; }sqstack;//initstack 初…
阅读更多...
《隔离十四天》系列 -第十天 -数据结构与算法

《隔离十四天》系列 -第十天 -数据结构与算法

前言 好了&#xff0c;解放了就是爽不用天天测体温了&#xff0c;虽然自己健康的不得了&#xff0c;还能随意出去high&#xff0c;解放的日子真幸福。 今天呢看了一些数据结构的视频&#xff0c;来加深自己对一些数据结构的理解&#xff0c;因为对于一些算法都是依赖与数据结构…
阅读更多...
Leecode 21. 合并两个有序链表 链表

Leecode 21. 合并两个有序链表 链表

这道题在剑指offer上做过&#xff1a;剑指offer JZ25 合并两个排序的链表 好好反思一下自己为什么还是漏洞百出&#xff0c;做的那么慢。 代码一&#xff1a; class Solution { public:ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {if(!list1)return list2;…
阅读更多...
Leecode 19. 删除链表的倒数第 N 个结点 链表

Leecode 19. 删除链表的倒数第 N 个结点 链表

原题链接&#xff1a;Leecode 19. 删除链表的倒数第 N 个结点 题目说了&#xff1a;希望我们一次扫描完成这道题&#xff0c;所以先遍历一遍链表求长度&#xff0c;再遍历一遍删除倒数第n个数肯定是不行的&#xff0c;但是不知道链表长度就无法知道倒数第n个结点在哪&#x…
阅读更多...
4. 数据结构与算法——链表

4. 数据结构与算法——链表

数据结构与算法——链表 在这里插入代码片 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>Title</title> </head> <body> <script>// 封装链表的构造函数function LinkedLis…
阅读更多...
2. 数据结构与算法——队列

2. 数据结构与算法——队列

数据结构与算法——队列 实现队列 基于数组基于链表基于数组&#xff1a; <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>Title</title> </head> <body> <script>// 自定义…
阅读更多...
剑指offer（15）——C++实现反转单向链表

剑指offer（15）——C++实现反转单向链表

题目 输入一个链表&#xff0c;反转链表后&#xff0c;输出新链表的表头。 考察点 链表、指针的编程能力思维的全面性和代码的鲁棒性 解题思路 避免链表断开后找不到后继节点&#xff0c;所以需要事先保存后继节点信息。 设置三个指针&#xff0c;分别表示前继、当前、后继…
阅读更多...
Python - 两数相加 (有链表 无链表)

Python - 两数相加 (有链表 无链表)

一.引言 给定两个 非空 的列表&#xff0c;表示两个非负的整数。它们每位数字都是按照 顺序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。请将两个数相加并返回结果。 Tips: 两个数字均不会以0为开头 示例: nums1 [1,2,3] nums2 [2,3,4] add(nums1, num…
阅读更多...
LeetCode_链表_中等_445.两数相加 II

LeetCode_链表_中等_445.两数相加 II

目录 1.题目2.思路3.代码实现&#xff08;Java&#xff09; 1.题目 给你两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。 你可以假设除了数字 0 之外&#xff0c;这两个数字都不会以零开头。 …
阅读更多...
LeetCode 109 有序链表转换二叉搜索树

LeetCode 109 有序链表转换二叉搜索树

题目描述&#xff1a; 给定一个单链表&#xff0c;其中的元素按升序排序&#xff0c;将其转换为高度平衡的二叉搜索树。 本题中&#xff0c;一个高度平衡二叉树是指一个二叉树 每个节点 的左右两个子树的高度差的绝对值不超过 1。 示例&#xff1a; 给定的有序链表&#xff1…
阅读更多...
Day_16 泛型和异常处理

Day_16 泛型和异常处理

文章目录HashMapHashMap<K,V>的底层原理 1. 当创建HashMap<K,V>集合的时候,会在底层创建一个容量为16,加载因子为0.75的数组加载因子 : 扩容的时机 0.75指的是 : 当数组中的元素个数达到(容量 * 0.75)的时候,需要扩容2. 当底层数组中元素的个数达到扩容条件,会在…
阅读更多...
哈希--数组实现和邻接链表

哈希--数组实现和邻接链表

数组实现为&#xff1a;以8个为例子 #define Max 8 //the size of example template<class T> struct node{ T data; unsigned int flag; }; node<int> *testnew node<int>[10]; int arr[Max]; //recording some data; for(int i0;i<10;i) { test[i].flag…
阅读更多...
链表的快慢指针的妙用

链表的快慢指针的妙用

链表的快慢指针的使用 1. 环形链表 LeetCode题目 141. 环形链表 题目描述 给定一个链表&#xff0c;判断链表中是否有环。 为了表示给定链表中的环&#xff0c;我们使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;索引从 0 开始&#xff09;。 如果 pos 是 -1&…
阅读更多...
严蔚敏数据结构C语言版 P34 2.17(静态链表的删除操作的思想实践(删除静态链表第i个结点))——中职

严蔚敏数据结构C语言版 P34 2.17(静态链表的删除操作的思想实践(删除静态链表第i个结点))——中职

严蔚敏数据结构C语言版 P34 2.17 静态链表的删除操作的思想实践(删除静态链表第i个结点) /* 严蔚敏数据结构C语言版 P34 2.17 静态链表的删除操作的思想实践(删除静态链表第i个结点) *///头文件 #include<stdio.h> #include<stdlib.h>//宏区 #define SIZEMAX 10 …
阅读更多...
剑指offer-链表中环的入口结点

剑指offer-链表中环的入口结点

剑指offer-链表中环的入口结点 题目&#xff1a; 思路&#xff1a; 快慢指针判断是否存在环&#xff0c;然后再写一个函数用来判断环的大小即可 下面解释一下什么是快慢指针&#xff1a; 快慢指针说的通俗一点就是一个两个人比赛跑步&#xff0c;一个人一次就跑一格&#xff0…
阅读更多...
LeetCode 11.2题目

LeetCode 11.2题目

请编写一个函数&#xff0c;用于 删除单链表中某个特定节点 。在设计函数时需要注意&#xff0c;你无法访问链表的头节点 head &#xff0c;只能直接访问 要被删除的节点 。 题目数据保证需要删除的节点 不是末尾节点 /** * Definition for singly-linked list. * public cl…
阅读更多...
list容器简单功能模拟实现

list容器简单功能模拟实现

第一次尝试 #include<iostream> using namespace std;//每个节点的类 template<class T> struct ListNode {//节点存放的数据T _date;//指向前一个节点的指针ListNode<T>* _prev;//指向后一个节点的指针ListNode<T>* _next;//节点类的构造函数ListNod…
阅读更多...
创建队列

创建队列

第一次尝试 //这是 .h 部分的代码 #pragma once //使用这种方式来重命名数据类型&#xff0c;这样可以很方便的修改后续数据的数据类型&#xff0c;相当于#define的作用 typedef int QueueType;//创建队列 typedef struct Queue {//队列保存的数据QueueType _date;//指向下一个…
阅读更多...
【链表】142. 环形链表 II

【链表】142. 环形链表 II

题目&#xff1a; 题意&#xff1a; 给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 为了表示给定链表中的环&#xff0c;使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;索引从 0 开始&#xff09;。 如果 pos 是…
阅读更多...
创建链表（带头、单向、不循环）

创建链表（带头、单向、不循环）

第一次尝试 //这是 .h 部分的代码 #pragma once//使用这种方式来重命名数据类型&#xff0c;这样可以很方便的修改后续数据的数据类型&#xff0c;相当于#define的作用 typedef int ListType; //创建数据节点 typedef struct ListNode {ListType _date;//此处必须带上struct&a…
阅读更多...
超详细的逐句介绍Java高级接口之HashSet底层源码讲解（二）

超详细的逐句介绍Java高级接口之HashSet底层源码讲解（二）

一、HashSet HashSet 基于 HashMap 来实现的&#xff0c;是一个不允许有重复元素的集合。这是一个继承了于Set的子类方法。超详细的逐句介绍Java高级接口之HashSet底层源码讲解&#xff08;一&#xff09;详细介绍Hashset的初始化相关设置。下面我将介绍HashSet的具体的使用方…
阅读更多...
【链表】面试题 02.07. 链表相交

【链表】面试题 02.07. 链表相交

题目&#xff1a; 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c;函数…
阅读更多...
2.13---2.17-静态链表操作详解

2.13---2.17-静态链表操作详解

2.13—2.17-静态链表操作详解 链表的一些基本操作&#xff0c;包括对表中数据元素的添加、删除、查找和更改。 本节是建立在已能成功创建静态链表的基础上&#xff0c;因此我们继续使用上节中已建立好的静态链表学习本节内容&#xff0c;建立好的静态链表如图 1 所示&#xff…
阅读更多...
【链表】707. 设计链表

【链表】707. 设计链表

题目&#xff1a; 在链表类中实现这些功能&#xff1a; get(index)&#xff1a;获取链表中第 index 个节点的值。如果索引无效&#xff0c;则返回-1。addAtHead(val)&#xff1a;在链表的第一个元素之前添加一个值为 val 的节点。插入后&#xff0c;新节点将成为链表的第一个…
阅读更多...
2.10-头插法尾插法建立链表

2.10-头插法尾插法建立链表

头插法建立单链表 头插法会使输入的数据插入到链表的表头&#xff0c;输出数据时的数据与读入的数据时相反的&#xff0c;如&#xff0c;以1 2 3 4 5 6 7 8 9建立链表&#xff0c;输出的结果是9 8 7 6 5 4 3 2 1 。第一个元素会始终在链表的尾部 1.建立一个空表&#xff0c;此时…
阅读更多...
【链表】203. 移除链表元素

【链表】203. 移除链表元素

题目&#xff1a; 题意&#xff1a;删除链表中等于给定值 val 的所有节点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5] 示例 2&#xff1a; 输入&#xff1a;head [], val 1 输出&#xff1a;[] 示例 3&#xff1a…
阅读更多...
拒绝造轮子！如何移植并使用Linux内核的通用链表（附完整代码实现）

拒绝造轮子！如何移植并使用Linux内核的通用链表（附完整代码实现）

在实际的工作中&#xff0c;我们可能会经常使用链表结构来存储数据&#xff0c;特别是嵌入式开发&#xff0c;经常会使用linux内核最经典的双向链表 list_head。本篇文章详细介绍了Linux内核的通用链表是如何实现的&#xff0c;对于经常使用的函数都给出了详细的说明和测试用例…
阅读更多...
数据结构与算法分析之表、栈和队列（一）

数据结构与算法分析之表、栈和队列（一）

1.前驱元&#xff0c;后继元 对于除空表外的任何表&#xff0c;我们说后继&#xff1b;&#xff08;或继&#xff0c;之后&#xff09;并称&#xff08;i<N&#xff09;前驱(i>1)。表中的第一个元素是&#xff0c;而最后一个元素是。我们将不定义的前驱元&#xff0c;也…
阅读更多...
Java实现链表相关的操作

Java实现链表相关的操作

1.链表的定义&#xff1a; 链表是一种物理存储单元上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点&#xff08;链表中每一个元素称为结点&#xff09;组成&#xff0c;结点可以在运行时动态生成。每个结点包括两…
阅读更多...
查找单链表中从尾部开始的第n个结点 数据结构 C语言版

查找单链表中从尾部开始的第n个结点 数据结构 C语言版

查找单链表中从尾部开始的第n个结点1.问题描述2.解决思路3.代码实现4. 单链表链式存储基本操作1.问题描述 //查找从链表尾部开始的第n个结点 //尾插法建立单链表 2.解决思路 解1&#xff1a; 利用GetLength_L函数获取单链表的长度 尾部开始的第n个元素相当于从头结点开始的第Ge…
阅读更多...
左式堆代码

左式堆代码

struct node{int val;int len; // 最短路径长度node *lc,*rc;node(int a,int b,int c) {val a;siz b;len c;lc NULL;rc NULL;} }; void update(node *a) { // 更新当前节点信息node *l a->lc;node *r a->rc;int len1 0;int len2 0;if (l ! NULL) len1 l-&g…
阅读更多...
Java数据结构与算法之链表查找数据

Java数据结构与算法之链表查找数据

在链表中查找数据和在数组查找数据有些不同&#xff0c;我将介绍怎么在链表中查找数据&#xff0c;并返回其在第几位。 public int search_value(ListNode l,int e){for(int i0;i<l.length;i){if(l.vale)return i1;}return 0; }
阅读更多...
算法系列-链表

算法系列-链表

以前打算每周刷一道题&#xff0c;从2021年12月坚持到2022年3月&#xff0c;坚持了3个月&#xff0c;后来因为其它事情太多就停止了。 坚持做一件事情&#xff0c;肯定是有价值的。最近总算把很多事情理顺了&#xff0c;那就重新开始做题吧。不过这次换一下思路&#xff0c;从…
阅读更多...
5.2树和二叉树——二叉树的性质

5.2树和二叉树——二叉树的性质

记得上次写数据结构还是在上次... 历经一个半月&#xff0c;我又重新回归数据结构啦&#xff01; 性质1&#xff1a;在二叉树的第i层上至多有2^(i-1)个结点&#xff08;i>1&#xff09;。 证明&#xff1a;用数学归纳法证明 延伸&#xff1a;第i层上至少有1个结点 性质2&am…
阅读更多...
Linux下贪吃蛇的c语言实现

Linux下贪吃蛇的c语言实现

#include<curses.h> #include<stdlib.h> #include<pthread.h> #include<unistd.h> #define UP 1 #define DOWN -1 #define LEFT 2 #define RIGHT -2struct Snake{int hang;int lie;struct Snake*next; };//声明贪吃蛇结点的结构体struct Snake*headNU…
阅读更多...
【C 程序设计】构造类型知识点

【C 程序设计】构造类型知识点

1. 结构体类型 &#xff08;1&#xff09;构造结构体类型 定义成员变量的方式与普通变量的定义一样。成员列表必须用一对中括号 “{}” 括起。结构体类型名可以省略不写&#xff0c;但中括号 “{}”后面的分号 “;” 必不可少&#xff0c;分号 “;” 与中括号 “{}” 之间可以…
阅读更多...
PTA练习题：链表去重

PTA练习题：链表去重

给定一个带整数键值的链表 L&#xff0c;你需要把其中绝对值重复的键值结点删掉。即对每个键值 K&#xff0c;只有第一个绝对值等于 K 的结点被保留。同时&#xff0c;所有被删除的结点须被保存在另一个链表上。例如给定 L 为 21→-15→-15→-7→15&#xff0c;你需要输出去重后…
阅读更多...
PTA练习题： 两个有序链表序列的交集

PTA练习题： 两个有序链表序列的交集

已知两个非降序链表序列S1与S2&#xff0c;设计函数构造出S1与S2的交集新链表S3。 输入格式: 输入分两行&#xff0c;分别在每行给出由若干个正整数构成的非降序序列&#xff0c;用−1表示序列的结尾&#xff08;−1不属于这个序列&#xff09;。数字用空格间隔。 输出格式: …
阅读更多...
PTA练习题： 两个有序链表序列的合并

PTA练习题： 两个有序链表序列的合并

已知两个非降序链表序列S1与S2&#xff0c;设计函数构造出S1与S2合并后的新的非降序链表S3。 输入格式: 输入分两行&#xff0c;分别在每行给出由若干个正整数构成的非降序序列&#xff0c;用−1表示序列的结尾&#xff08;−1不属于这个序列&#xff09;。数字用空格间隔。 输…
阅读更多...
A*搜索算法实现实例（城市最短路径）

A*搜索算法实现实例（城市最短路径）

A*搜索算法 实例&#xff1a;城市最短路径代码实现 public class InformedSearch {public static void main(String[] args) {// TODO Auto-generated method stubString[] cities {"1号","2号","3号","4号","5号","6…
阅读更多...
「数据结构 | 链表」单链表、双向链表节点操作演示动画

「数据结构 | 链表」单链表、双向链表节点操作演示动画

目录 1. 什么是链表 2. 链表数据结构 2.1 单链表数据结构&#xff08;Java&#xff09; 2.2 双向链表数据结构&#xff08;Java&#xff09; 3. 单链表操作动画 3.1 新增节点 3.2 删除节点 4. 双向链表操作动画 4.1 新增节点 4.2 删除节点 5. 总结 1. 什么是链表 …
阅读更多...
PHP实现链表反转

PHP实现链表反转

324篇 PHP实现链表反转 <?phpclass Node{private $value;private $next;public function __construct($value = null){$this->value = $value;}publi
阅读更多...
Leetcode 202 快乐数（HashSet，环形链表思想）

Leetcode 202 快乐数（HashSet，环形链表思想）

Leetcode 202 快乐数&#xff08;HashSet&#xff09; 解法1 &#xff1a; 用HashSet来检测循环:star:为什么说数字n的位数由log n给定呢&#xff1f;解法2 &#xff1a; 链表的思想[出现循环表示链表出现环]&#xff0c;使用快慢指针法 题目链接>>>>>>>&…
阅读更多...
【刷题篇】反转链表

【刷题篇】反转链表

文章目录 一、206.反转链表二、92.反转链表 ||三、25. K 个一组翻转链表 一、206.反转链表 class Solution { public://使用头插//三个指针也可以ListNode* reverseList(ListNode* head) {if(headnullptr)return nullptr;ListNode* curhead;ListNode* newheadnew ListNode(0);L…
阅读更多...
Java并发编程框架Disruptor

Java并发编程框架Disruptor

Disruptor是什么&#xff1f; Disruptor是一个高性能的异步处理框架&#xff0c;一个轻量级的JMS&#xff0c;和JDK中的BlockingQueue有相似处&#xff0c;但是它的处理速度非常快&#xff0c;获得2011年程序框架创新大奖&#xff0c;号称“一个线程一秒钟可以处理600W个订单”…
阅读更多...
C++容器vector和list的insert比较

C++容器vector和list的insert比较

1&#xff1a;首先&#xff0c;我们先来了解一个vector和list&#xff1a; vector相当于是一个边长数组&#xff0c;可以动态增加数据&#xff1b; 而list相当于一个双向链表&#xff0c;也可以动态增加数据&#xff0c;相信学过STL的都知道&#xff0c;所以我也就不再介绍了那…
阅读更多...
python实现单链表的增、删、改、查

python实现单链表的增、删、改、查

下面的介绍主要基于单链表进行的程序编写。 单链表结构&#xff1a; 链表的增删改查函数如下&#xff1a; class SinLinkedList:# 节点的数据结构&#xff0c;包含一个值和一个指针class Node:__slots__ {_element, _next}def __init__(self, element):self._element eleme…
阅读更多...
数据结构之线性结构的离散存储（循环列表和双向链表）

数据结构之线性结构的离散存储（循环列表和双向链表）

循环列表&#xff1a; 将单链表中 终端节点的指针端由空指针改为指向头结点&#xff0c;就使整个单链表形成一个环&#xff0c;这种头尾相接的单链表称为单循环链表&#xff0c;简称循环链表。 循环链表解决了一个很麻烦的问题。如何从当中一个结点出发&#xff0c;访问到链表…
阅读更多...
写过的LeetCode中关于链表的思路值得我学习的题

写过的LeetCode中关于链表的思路值得我学习的题

第一题&#xff08;对应LeetCode题库的第141题&#xff09; &#xff08;当然&#xff0c;后续if自己看不懂自己的总结&#xff0c;可以去力扣网站翻阅回对应的题目去看题解&#xff01;&#xff09; &#xff08;leetcode刷题最好看英文版的题目描述&#xff0c;不然又会给傻…
阅读更多...
runtime error: member access within null pointer of type ‘ListNode‘ (solution.cpp) SUMMARY: Undefine

runtime error: member access within null pointer of type ‘ListNode‘ (solution.cpp) SUMMARY: Undefine

今天在LeetCode上写一道链表的环检测简单题&#xff08;题号&#xff1a;141&#xff09;时&#xff0c;在网站上编译时出现了如标题所述的error&#xff01; 主要是因为我忽略了一个重要且容易给轻视的小知识点&#xff01; 那就是C中 &&符号 和 ||符号的短路求值效…
阅读更多...
链表力扣142题---环形链表

链表力扣142题---环形链表

142题 环形链表&#xff08;判断是否有环&#xff09; 难道&#xff1a;中等 给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 为了表示给定链表中的环&#xff0c;我们使用整数 pos 来表示链表尾连接到链表中的位置&#xf…
阅读更多...
数组和链表的分析与对比

数组和链表的分析与对比

数组和链表的分析与对比 1. 内存的工作原理 计算机就像是很多抽屉的集合体&#xff0c;每个抽屉都有自己的地址。 需要将数据存储到内存时&#xff0c;你请求计算机提供存储空间&#xff0c;计算机给你一个存储地址。 需要存储多项数据时&#xff0c;有两种基本方式——数组和…
阅读更多...
智能指针(shared_ptr)

智能指针(shared_ptr)

原文链接:智能指针(shared_ptr)
阅读更多...
leetcode146. LRU 缓存(C++|数据结构|双链表|哈希表)

leetcode146. LRU 缓存(C++|数据结构|双链表|哈希表)

力扣 题目描述 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类&#xff1a; LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中&#xff0c;则返回关键字的值&#xf…
阅读更多...
leetcode-19. 删除链表的倒数第 N 个结点（C++|快慢指针）

leetcode-19. 删除链表的倒数第 N 个结点（C++|快慢指针）

链接&#xff1a;https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/ 题目 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5…
阅读更多...
day2 牛客TOP100：BM 11-20 链表 二分法 流输入 小美加法

day2 牛客TOP100：BM 11-20 链表 二分法 流输入 小美加法

文章目录 链表BM11 链表相加(二)BM12 单链表的排序归并排序分割 超时辅助数组快排 BM13 判断一个链表是否为回文结构BM14 链表的奇偶重排BM15 删除有序链表中重复的元素-IBM16 删除有序链表中重复的元素-IIJZ35 复杂链表的复制 二分法BM17 二分查找-IBM18 二维数组中的查找BM19…
阅读更多...
Leetcode -＞206 反转链表

Leetcode -＞206 反转链表

题目 算法思路及代码实现 #include <iostream> using namespace std;struct ListNode {int val; //当前节点的值ListNode *next;
阅读更多...
python剑指offer 链表中环的入口节点

python剑指offer 链表中环的入口节点

题目&#xff1a; 一个链表中包含环&#xff0c;请找出该链表的环的入口结点。思路&#xff1a;//先说个定理&#xff1a;两个指针一个fast、一个slow同时从一个链表的头部出发//fast一次走2步&#xff0c;slow一次走一步&#xff0c;如果该链表有环&#xff0c;两个指针必然在…
阅读更多...
LeetCode 23 合并 K 个升序链表

LeetCode 23 合并 K 个升序链表

LeetCode 23 合并 K 个升序链表 来源&#xff1a;力扣&#xff08;LeetCode&#xff09; 链接&#xff1a;https://leetcode.cn/problems/merge-k-sorted-lists/description/ 博主Github&#xff1a;https://github.com/GDUT-Rp/LeetCode 题目&#xff1a; 给你一个链表数组…
阅读更多...
链表经典面试题(一)

链表经典面试题(一)

面试题 1.反转链表的题目2.反转链表的图文分析3.反转链表的代码实现 1.反转链表的题目 2.反转链表的图文分析 我们在实现反转链表的时候,是将后面的元素变前面&#xff0c;前面的元素变后面&#xff0c;那么我们是否可以理解为&#xff0c;用头插法的思想来完成反转链表呢&…
阅读更多...
线性链表的插入与删除

线性链表的插入与删除

代码功能&#xff1a;实现链表插入与删除的基本功能 http://www.bnuoj.com/contest/problem_show.php?pid4101 线性表插入与删除操作 Input 第一行给出线性表内现有数据元素的数目N&#xff0c;1<N<10&#xff1b;第二行给出N个整数&#xff1a;a1、a2、a3…aN&#x…
阅读更多...
和链表相关的一些问题

和链表相关的一些问题

和链表相关的一些问题 作者&#xff1a;Grey 原文地址&#xff1a; 博客园&#xff1a;和链表相关的一些问题 CSDN&#xff1a;和链表相关的一些问题 反转单链表 题目描述见&#xff1a;LeetCode 206. Reverse Linked List 思路如下 对于任何一个节点 cur 来说&#xf…
阅读更多...
LinkedList常用方法

LinkedList常用方法

今天在刷剑指offer的时候&#xff0c;刷到了从上到下打印二叉树那题&#xff0c;需要使用队列来辅助实现。在JAVA中&#xff0c;我们常用LinkedList来模拟链式队列&#xff0c;发现好久没用LinkedList了&#xff0c;对它有一些陌生&#xff0c;因此整理一下&#xff0c;这里主要…
阅读更多...
python剑指offer系列复杂链表的复制

python剑指offer系列复杂链表的复制

题目&#xff1a; 输入一个复杂链表&#xff08;每个节点中有节点值&#xff0c;以及两个指针&#xff0c;一个指向下一个节点&#xff0c;另一个特殊指针指向任意一个节点&#xff09;&#xff0c;返回结果为复制后复杂链表的head。&#xff08;注意&#xff0c;输出结果中请不…
阅读更多...
有关企业链表中数据类型的强制转换

有关企业链表中数据类型的强制转换

From ChatGPT struct LinkNode {LinkNode* next; };struct LinkList {LinkNode node;int val 0; };void inti() {LinkList linkList;LinkNode* node (LinkNode*)(&linkList); }在提供的代码中&#xff0c;LinkNode 和 LinkList 是两个不同的结构体&#xff0c;但它们共享…
阅读更多...
python 实现剑指offer系列3：从尾到头打印链表

python 实现剑指offer系列3：从尾到头打印链表

newcoder&#xff1a;https://www.nowcoder.com/practice/d0267f7f55b3412ba93bd35cfa8e8035?tpId13&tqId11156&tPage1&rp1&ru%2Fta%2Fcoding-interviews&qru%2Fta%2Fcoding-interviews%2Fquestion-ranking 题目&#xff1a;输入一个链表&#xff0c;从尾…
阅读更多...
链表OJ（2）

链表OJ（2）

目录 一、 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的 二、编写代码&#xff0c;以给定值x为基准将链表分割成两部分&#xff0c;所有小于x的结点排在大于或等于x的结点之前 三、 链表的回文结构 四、 输入两个链表&…
阅读更多...
反转链表C++实现

反转链表C++实现

实现链表的反转有两个方法&#xff1a; &#xff08;1&#xff09;定义一个新的链表&#xff0c;实现链表反转&#xff0c;但是会造成内存空间的浪费&#xff1b; &#xff08;2&#xff09;只需要改变next指针的方向&#xff0c;就可以直接对链表反转&#xff0c;如下面动画…
阅读更多...
Leetcode链表篇 Day2

Leetcode链表篇 Day2

203. 移除链表元素 - 力扣&#xff08;LeetCode&#xff09; 1.暴力移除&#xff1a;分删除的为头结点和不为头节点 while删除头节点时&#xff1a;直接从下一个结点开始&#xff0c;headhead->next while不是头节点时&#xff1a;从head开始遍历(需记录的为 前继结点pre) 虚…
阅读更多...
PTA 《基础编程题目集》 6-6 求单链表结点的阶乘和

PTA 《基础编程题目集》 6-6 求单链表结点的阶乘和

本题要求实现一个函数&#xff0c;求单链表L结点的阶乘和。这里默认所有结点的值非负&#xff0c;且题目保证结果在int范围内。 函数接口定义&#xff1a; int FactorialSum( List L );其中单链表List的定义如下&#xff1a; typedef struct Node *PtrToNode; struct Node {…
阅读更多...
3.反转链表

3.反转链表

1.迭代 func reversrList(head *ListNode) *ListNode {cur : headvar pre *ListNode nilfor cur ! nil {pre, cur, cur.Next cur, cur.Next, pre //这句话最重要}return pre } 2.迭代 不使用递归&#xff0c;使用三个指针来完成迭代 第一个curr代表当前节点 第二个…
阅读更多...
并查集及其优化详解

并查集及其优化详解

1.第一种实现方式&#xff1a;quick_find 查询时间复杂度&#xff1a;O&#xff08;1&#xff09; 合并时间复杂度&#xff1a;O&#xff08;n&#xff09; 实现方式&#xff1a;采用数组&#xff0c;维护的数组实际上是一颗高度最大为2的树 //quick_find实现 class Disjoi…
阅读更多...
算法基础——用数组模拟实现单链表和双向链表

算法基础——用数组模拟实现单链表和双向链表

这里写目录标题铺垫基本思想初始化向头节点插入在任意节点之后插入一个x删除任意位置之后的一个节点单链表题目代码实现双向链表题目代码实现铺垫 在学这个之前&#xff0c;小伙伴们最好先要了解下如何用结构体形成单链表&#xff0c;因为如果理解了那个&#xff0c;这儿就很好…
阅读更多...
【Leetcode】旋转系列（数组、矩阵、链表、函数、字符串）

【Leetcode】旋转系列（数组、矩阵、链表、函数、字符串）

【Leetcode】旋转系列题目总结如下&#xff1a; 文章目录旋转系列问题189. 轮转数组面试题 01.07. 旋转矩阵剑指 Offer 24. 反转链表61. 旋转链表396. 旋转函数796. 旋转字符串旋转系列问题 189. 轮转数组 1.题目描述 leetcode链接&#xff1a;189. 轮转数组 2.思路分析 …
阅读更多...
LeetCode C++16-合并K个升序链表

LeetCode C++16-合并K个升序链表

题目描述 给你一个链表数组&#xff0c;每个链表都已经按升序排列。请你将所有链表合并到一个升序的链表中&#xff0c;返回合并后的链表。 示例1&#xff1a; 输入&#xff1a; lists: 1->4->5, 1->3->4, 2->6 输出&#xff1a; 1->1->2->3->4-…
阅读更多...
非科班进大厂必备算法

非科班进大厂必备算法

基础数据结构的融合是成为庞大系统的基石。比如 Redis 中的跳跃表&#xff0c;数据库索引 B树等&#xff0c;只有对基础的数据结构足够的熟悉才能更容易去理解稍微复杂的结构&#xff0c;就仿佛我们闯关打怪一样&#xff0c;一步一步解锁直到结局。今天想和大家一起分享的是常见…
阅读更多...
算法通关村第五关-白银挑战实现队列

算法通关村第五关-白银挑战实现队列

大纲 队列基础队列的基本概念和基本特征实现队列队列的基本操作Java中的队列 队列基础 队列的基本概念和基本特征 队列的特点是节点的排队次序和出队次序按入队时间先后确定&#xff0c;即先入队者先出队&#xff0c;后入队者后出队&#xff0c;即我们常说的FIFO(first in fi…
阅读更多...
Leetcode-每日一题【剑指 Offer 24. 反转链表】

Leetcode-每日一题【剑指 Offer 24. 反转链表】

题目 定义一个函数&#xff0c;输入一个链表的头节点&#xff0c;反转该链表并输出反转后链表的头节点。 示例: 输入: 1->2->3->4->5->NULL输出: 5->4->3->2->1->NULL 限制&#xff1a; 0 < 节点个数 < 5000 解题思路 1.题目要求我们反转…
阅读更多...
Java实现创建链表与打印链表元素（可作为模板）

Java实现创建链表与打印链表元素（可作为模板）

1、通过数组元素值&#xff0c;构造一个单向链表&#xff1b; 2、将链表元素以数组的形式打印出来&#xff0c;如“[1, 2, 3, 4]” package listnodes;//创建节点类 class ListNode {int val;ListNode next;ListNode() {}ListNode(int val) { this.val val; }ListNode(int v…
阅读更多...
【数据结构OJ题】链表分割

【数据结构OJ题】链表分割

原题链接&#xff1a;https://www.nowcoder.com/practice/0e27e0b064de4eacac178676ef9c9d70?tpId8&&tqId11004&rp2&ru/activity/oj&qru/ta/cracking-the-coding-interview/question-ranking 目录 1. 题目描述 2. 思路分析 3. 代码实现 1. 题目描述 2…
阅读更多...
检测链表中是否存在环

检测链表中是否存在环

题目、解析和代码 题目&#xff1a;给定一个单链表&#xff0c;判断其中是否有环的存在 解析&#xff1a;这里使用两个遍历速度不一样的结点进行判断&#xff0c;一个慢结点从首结点开始遍历&#xff0c;这个结点每次只遍历一个结点&#xff1b;一个快结点从第二个结点进行遍历…
阅读更多...
leetcode92 反转链表II

leetcode92 反转链表II

题目 给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 示例 输入&#xff1a;head [1,2,3,4,5], left 2, right 4 输出&#xff1a;[1,4,3,2,5] 解…
阅读更多...
数据结构与算法（五）--链表概念以及向链表添加元素

数据结构与算法（五）--链表概念以及向链表添加元素

一、前言 今天我们学习另一种非常重要的线性数据结构–链表&#xff0c;之前我们已经学习了三种线性数据结构&#xff0c;分别是动态数组&#xff0c;栈和队列。其中队列我们额外学习了队列的另一种实现方式–循环队列。其实我们自己实现过前三个数据结构就知道&#xff0c;它…
阅读更多...
【数据结构】堆的应用+TOP-K问题+二叉树遍历

【数据结构】堆的应用+TOP-K问题+二叉树遍历

欢迎来到我的&#xff1a;世界 希望作者的文章对你有所帮助&#xff0c;有不足的地方还请指正&#xff0c;大家一起学习交流 ! 目录 前言堆的时间复杂度向下调整算法的时间复杂度向上调整算法的时间复杂度 堆的应用堆排序TOP—K问题链式二叉树二叉树的节点&#xff1a;初始化节…
阅读更多...
第一课数组、链表、栈、队列

第一课数组、链表、栈、队列

第一课数组、链表、栈、队列 acwing136 邻值查找---中等题目描述代码展示 lc20.有效的括号--简单题目描述代码展示 lc25.K 个一组翻转链表--困难题目描述代码展示 lc26.删除有序数组中的重复项--简单题目描述代码展示 lc88.合并两个有序数组--简单题目描述代码展示 lc141.环形链…
阅读更多...
【数据结构】树与二叉树（十七）：二叉树的基础操作：删除指定结点及其左右子树（算法DST）

【数据结构】树与二叉树（十七）：二叉树的基础操作：删除指定结点及其左右子树（算法DST）

文章目录 5.2.1 二叉树二叉树性质引理5.1&#xff1a;二叉树中层数为i的结点至多有 2 i 2^i 2i个&#xff0c;其中 i ≥ 0 i \geq 0 i≥0。引理5.2&#xff1a;高度为k的二叉树中至多有 2 k 1 − 1 2^{k1}-1 2k1−1个结点&#xff0c;其中 k ≥ 0 k \geq 0 k≥0。引理5.3&…
阅读更多...
数据结构 2.2 单循环链表

数据结构 2.2 单循环链表

2.单循环链表 data|next——>data|next——>data|next——>头节点 1.初始化链表 2.增加节点&#xff08;头插法、尾插法&#xff09; 3.删除节点 4.遍历链表 定义一个结构体&#xff0c;存放data域和指针域&#xff1a; typedef struct Node {//定义一个结构体&…
阅读更多...
算法-链表-简单-相交、反转、回文、环形、合并

算法-链表-简单-相交、反转、回文、环形、合并

记录一下算法题的学习5 在写关于链表的题目之前&#xff0c;我们应该熟悉回忆一下链表的具体内容 什么是链表&#xff1a; 链表&#xff08;Linked list&#xff09;是一种常见的基础数据结构&#xff0c;是一种线性表&#xff0c;但是并不会按线性的顺序存储数据&#xff0c…
阅读更多...
[每日算法 - 阿里机试] leetcode19. 删除链表的倒数第 N 个结点

[每日算法 - 阿里机试] leetcode19. 删除链表的倒数第 N 个结点

入口 力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台备战技术面试&#xff1f;力扣提供海量技术面试资源&#xff0c;帮助你高效提升编程技能&#xff0c;轻松拿下世界 IT 名企 Dream Offer。https://leetcode.cn/problems/remove-nth-node-from-end…
阅读更多...
【算法刷题】【链表】链表内指定区间反转：将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)，空间复杂度)O(1)。

【算法刷题】【链表】链表内指定区间反转：将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)，空间复杂度)O(1)。

题目 解题 import java.util.*;/** public class ListNode {* int val;* ListNode next null;* public ListNode(int val) {* this.val val;* }* }*/public class Solution {/*** 代码中的类名、方法名、参数名已经指定&#xff0c;请勿修改&#xff0c;直接返回…
阅读更多...
c语言练习88：：移除链表元素

c语言练习88：：移除链表元素

移除链表元素 力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 代码&#xff1a; /*** Definition for sing…
阅读更多...
华为OD机试 - 判断一组不等式是否满足约束并输出最大差（Java 2023 B卷 100分）

华为OD机试 - 判断一组不等式是否满足约束并输出最大差（Java 2023 B卷 100分）

目录 专栏导读一、题目描述二、输入描述三、输出描述四、Java算法源码五、效果展示1、输入2、输出3、说明 华为OD机试 2023B卷题库疯狂收录中&#xff0c;刷题点这里 专栏导读 本专栏收录于《华为OD机试&#xff08;JAVA&#xff09;真题&#xff08;A卷B卷&#xff09;》。 …
阅读更多...
#力扣：21. 合并两个有序链表@FDDLC

#力扣：21. 合并两个有序链表@FDDLC

21. 合并两个有序链表 一、Java class Solution {public ListNode mergeTwoLists(ListNode list1, ListNode list2) {if (list1 null) return list2;if (list2 null) return list1;if (list1.val < list2.val) {list1.next mergeTwoLists(list1.next, list2);return li…
阅读更多...
力扣每日一题86：分隔链表

力扣每日一题86：分隔链表

题目描述&#xff1a; 给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你应当 保留 两个分区中每个节点的初始相对位置。 示例 1&#xff1a; 输入&#xff1a;head [1,4,…
阅读更多...
数据结构——双向链表的实现

数据结构——双向链表的实现

一、双向链表的结构 注意&#xff1a;双向链表又称带头双向循环链表 这⾥的“带头”跟前⾯我们说的“头节点”是两个概念&#xff0c;实际前⾯的在单链表阶段称呼不严 谨&#xff0c;但是为了同学们更好的理解就直接称为单链表的头节点。 带头链表⾥的头节点&#xff0c;实际…
阅读更多...
leetcode82删除排序链表中的重复元素

leetcode82删除排序链表中的重复元素

删除链表重复元素 题目描述 思路分析 思路1&#xff1a;采用一次遍历&#xff0c;内部循环判定是否相等 具体分析一下指针移动 外部循环判定卡住的位置 c语言代码&#xff1a; #include <stdio.h> #include <stdlib.h>struct ListNode {int val;struct ListNode …
阅读更多...
拒绝摆烂！C语言练习打卡第二天

拒绝摆烂！C语言练习打卡第二天

&#x1f525;博客主页&#xff1a;小王又困了 &#x1f4da;系列专栏&#xff1a;每日一练 &#x1f31f;人之为学&#xff0c;不日近则日退 ❤️感谢大家点赞&#x1f44d;收藏⭐评论✍️ 目录 一、选择题 &#x1f4dd;1.第一题 &#x1f4dd;2.第二题 &#x1f4dd;…
阅读更多...
奇偶链表问题

奇偶链表问题

奇偶链表问题 作者&#xff1a;Grey 原文地址&#xff1a; 博客园&#xff1a;奇偶链表问题 CSDN&#xff1a;奇偶链表问题 题目描述 给定一个单链表&#xff0c;把所有的奇数节点和偶数节点分别排在一起。请注意&#xff0c;这里的奇数节点和偶数节点指的是节点编号的奇…
阅读更多...
链栈的基本操作C/C++代码实现

链栈的基本操作C/C++代码实现

链栈的结构&#xff1a; 由于栈的主要操作是在栈顶插入和删除&#xff0c; 显然以链表的头部作为栈顶是最方便的&#xff0c;且不需要附加一个头结点。 初始化&#xff1a; 栈顶指针S置空即可。 入栈&#xff1a; 链栈不需要判断栈是否满&#xff01; 出栈&#xff1a; …
阅读更多...
LeetCode230——Kth Smallest Element in a BST

LeetCode230——Kth Smallest Element in a BST

Given a binary search tree, write a function kthSmallest to find the kth smallest element in it. Note: You may assume k is always valid, 1 ≤ k ≤ BSTs total elements. Follow up: What if the BST is modified (insert/delete operations) often and you need …
阅读更多...
【每天学习亿点点系列】——OJ203题：移除链表元素

【每天学习亿点点系列】——OJ203题：移除链表元素

&#x1f4a5;【每天学习亿点点系列】——OJ203题&#xff1a;移除链表元素题目思路代码实现注意点1. 不要以为cur就是head节点反例2.特殊情况找第一个不为val节点时当nnext为空指针时&#xff0c;不能再对它访问了3.在你找第一个不为val的节点时要一起移动题目 思路 有了前面顺…
阅读更多...
青岛大学_王卓老师【数据结构与算法】Week04_03_双向链表_学习笔记

青岛大学_王卓老师【数据结构与算法】Week04_03_双向链表_学习笔记

本文是个人学习笔记&#xff0c;素材来自青岛大学王卓老师的教学视频。 一方面用于学习记录与分享&#xff0c;另一方面是想让更多的人看到这么好的《数据结构与算法》的学习视频。 如有侵权&#xff0c;请留言作删文处理。 课程视频链接&#xff1a; 数据结构与算法基础–…
阅读更多...
链表（链式存储结构）及创建（C语言详解版）

链表（链式存储结构）及创建（C语言详解版）

前面详细地介绍了顺序表，本节给大家介绍另外一种线性存储结构——链表。 链表，别名链式存储结构或单链表，用于存储逻辑关系为 "一对一" 的数据。与顺序表不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素，其物理存储位置是随机的。 例如，…
阅读更多...
数据结构——图解单链表的初始化、赋值和遍历输出C语言

数据结构——图解单链表的初始化、赋值和遍历输出C语言

一、单链表存储结构解释说明 typedef struct node{int data;struct node *next; }Node,*Link;1.typedef&#xff1a;是将结构体struct node重新定义了新的名称Node和*Link。 2.struct node *next&#xff1a;是让成员next指向struct node这样一个类型的指针。如下图 3.Node&a…
阅读更多...
2021 大数据应用开发Java 1+x中级实操题答案汇总--含3篇

2021 大数据应用开发Java 1+x中级实操题答案汇总--含3篇

2021 大数据应用开发Java 1x中级实操题答案汇总–含3篇 2021实操题答案 20211030 1X 中级实操考试样题20211127 1X 中级实操考试样题20210620 1X 中级实操考试样题 结语 2021实操题答案 食用须知&#xff1a; 答案是我自己试过运行了的&#xff0c;不能说是最正确的答案&a…
阅读更多...
[JavaScript]合并两个排序的链表

[JavaScript]合并两个排序的链表

合并两个排序的链表描述示例1代码非递归做法递归做法描述 输入两个单调递增的链表&#xff0c;输出两个链表合成后的链表&#xff0c;当然我们需要合成后的链表满足单调不减规则。 示例1 输入&#xff1a; {1,3,5},{2,4,6}返回值&#xff1a; {1,2,3,4,5,6}代码 非递归做法…
阅读更多...
【数据结构】线性表（四）双向链表的各种操作（插入、删除、查找、修改、遍历打印）

【数据结构】线性表（四）双向链表的各种操作（插入、删除、查找、修改、遍历打印）

目录 线性表的定义及其基本操作&#xff08;顺序表插入、删除、查找、修改&#xff09; 四、线性表的链接存储结构 1. 单链表 2. 循环链表 3. 双向链表 a. 双向链表节点结构 b. 创建一个新的节点 c. 在链表末尾插入节点 d. 在指定位置插入节点 e. 删除指定位置的节点…
阅读更多...
[剑指offer]JT36---两个链表的第一个公共结点(与数组找相同值何异？)

[剑指offer]JT36---两个链表的第一个公共结点(与数组找相同值何异？)

剑指offer第三十六题题目如下思路与代码题目如下 思路与代码 我看到了往上有一种计算两个链表长度的做法&#xff0c;没看懂&#xff0c;我直接map存一个&#xff0c;另一个来查&#xff0c;我肤浅了。。。直接冲把&#xff01; /* struct ListNode {int val;struct ListNode…
阅读更多...
83. 删除排序链表中的重复元素 26. 删除排序数组中的重复项(双指针)【S】

83. 删除排序链表中的重复元素 26. 删除排序数组中的重复项(双指针)【S】

83. 删除排序链表中的重复元素 本文&#xff0c;仅用作自我记录&#xff0c;方便查看 本题有多种解法。 我的解法是最容易想到的&#xff0c;也是最简单的——单指针法&#xff08;和后面的做区分&#xff09; 1. 单指针法 由于该链表已经是有序的&#xff08;按照val排序…
阅读更多...
大一实验室C语言考核反思

大一实验室C语言考核反思

文章目录前言1、结构体2、转义字符3、双向链表二、简答题1、指针2、逗号运算符三、简答题1、简述结构体和共用体的区别。2、下述三个定义有什么区别?总结前言 上周进行了一次实验室考核&#xff0c;因为粗心大意&#xff0c;导致很多不该错的题出错了&#xff0c;所以特别做一…
阅读更多...
Leetcode-每日一题【328.奇偶链表】

Leetcode-每日一题【328.奇偶链表】

题目 给定单链表的头节点 head &#xff0c;将所有索引为奇数的节点和索引为偶数的节点分别组合在一起&#xff0c;然后返回重新排序的列表。 第一个节点的索引被认为是 奇数 &#xff0c; 第二个节点的索引为 偶数 &#xff0c;以此类推。 请注意&#xff0c;偶数组和奇数组…
阅读更多...
python 剑指offer系列：反转链表

python 剑指offer系列：反转链表

题目&#xff1a;输入一个链表&#xff0c;反转链表后&#xff0c;输出链表的所有元素。 代码&#xff1a; # -*- coding:utf-8 -*- # class ListNode: # def __init__(self, x): # self.val x # self.next None class Solution:# 返回ListNodedef Rev…
阅读更多...
每天一道leetcode：剑指 Offer 36. 二叉搜索树与双向链表（中等深度优先遍历递归）

每天一道leetcode：剑指 Offer 36. 二叉搜索树与双向链表（中等深度优先遍历递归）

今日份题目&#xff1a; 输入一棵二叉搜索树&#xff0c;将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点&#xff0c;只能调整树中节点指针的指向。 示例 我们希望将这个二叉搜索树转化为双向循环链表。链表中的每个节点都有一个前驱和后继指针。对于…
阅读更多...
leetcode146.手撸 LRU 算法(java)

leetcode146.手撸 LRU 算法(java)

LRU 缓存 LRU 缓存题目描述LRU 介绍LRU 算法设计代码实现 单调栈算法 LRU 缓存 来源&#xff1a;力扣&#xff08;LeetCode&#xff09; 链接&#xff1a;https://leetcode.cn/problems/lru-cache 题目描述 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实…
阅读更多...
LeetCode算法解析之对链表进行插入排序

LeetCode算法解析之对链表进行插入排序

对链表进行插入排序。 插入排序算法&#xff1a; 插入排序是迭代的&#xff0c;每次只移动一个元素&#xff0c;直到所有元素可以形成一个有序的输出列表。每次迭代中&#xff0c;插入排序只从输入数据中移除一个待排序的元素&#xff0c;找到它在序列中适当的位置&#xff0…
阅读更多...
剑指offer(JavaScript)刷题记录04——从尾到头打印链表

剑指offer(JavaScript)刷题记录04——从尾到头打印链表

剑指 Offer 06. 从尾到头打印链表 难度&#xff1a;简单 输入一个链表的头节点&#xff0c;从尾到头反过来返回每个节点的值&#xff08;用数组返回&#xff09;。 示例 1&#xff1a; 输入&#xff1a;head [1,3,2] 输出&#xff1a;[2,3,1] 限制&#xff1a; 0 < 链表…
阅读更多...
数据结构与算法（C++）--链表

数据结构与算法（C++）--链表

线性表的链性存储结构 线性表中的数据元素&#xff08;结点&#xff09;在存储器的位置是任意的&#xff0c;即逻辑上相邻的数据元素在物理位置上不一定相邻 结点 链表 n个结点由指针链组成一个链表 单链表的基本操作 单链表的初始化 构造一个空表 步骤&#xff1a; 生成…
阅读更多...
2023河南萌新联赛第（六）场：河南理工大学-F 爱睡大觉的小C

2023河南萌新联赛第（六）场：河南理工大学-F 爱睡大觉的小C

2023河南萌新联赛第&#xff08;六&#xff09;场&#xff1a;河南理工大学-F 爱睡大觉的小C https://ac.nowcoder.com/acm/contest/63602/F 文章目录 2023河南萌新联赛第&#xff08;六&#xff09;场&#xff1a;河南理工大学-F 爱睡大觉的小C题意解题思路 题意 新学期的概…
阅读更多...
链表之第二回

链表之第二回

欢迎来到我的&#xff1a;世界 该文章收入栏目&#xff1a;链表 希望作者的文章对你有所帮助&#xff0c;有不足的地方还请指正&#xff0c;大家一起学习交流 ! 目录 前言第一题&#xff1a;反转一个链表第二题&#xff1a;链表内指定区间反转第三题&#xff1a;判断一个链表…
阅读更多...
【数据结构】 链表简介与单链表的实现

【数据结构】 链表简介与单链表的实现

文章目录 ArrayList的缺陷链表链表的概念及结构链表的分类单向或者双向带头或者不带头循环或者非循环 单链表的实现创建单链表遍历链表得到单链表的长度查找是否包含关键字头插法尾插法任意位置插入删除第一次出现关键字为key的节点删除所有值为key的节点回收链表 总结 ArrayLi…
阅读更多...
链表的创建及相应操作 C语言

链表的创建及相应操作 C语言

数据结构c语言 链表 通过上篇对线性表顺序存储表示的了解&#xff0c;今天进一步对线性表的链式表示进行尝试。本人小白&#xff0c;不喜勿喷。如有错误之处&#xff0c;还请原谅&#xff01; 完整代码如下&#xff1a; #include <stdio.h> #include <stdlib.h>…
阅读更多...
c语言线性表-顺序表（完整版）

c语言线性表-顺序表（完整版）

c语言线性表顺序存储表示 这几天我尝试写写c语言顺序表&#xff0c;我是这样想的&#xff1a;在学链表之前&#xff0c;先搞懂顺序表。 不喜勿喷&#xff0c;本人新手&#xff0c;大多代码借鉴书上。如有错误之处&#xff0c;请原谅&#xff01; 首先创建一个结构体&#xff1…
阅读更多...
农村农产品信息展示网站的设计与实现(论文+源码)_kaic

农村农产品信息展示网站的设计与实现(论文+源码)_kaic

摘　要 随着软件技术的迅速发展,农产品信息展示的平台越来越多,传统的农产品显示方法将被计算机图形技术取代。这种网站技术主要把农产品的描述、农产品价格、农产品图片等内容&#xff0c;通过计算机网络的开发技术&#xff0c;在互联网上进行展示&#xff0c;然后通过计算机网…
阅读更多...
字节美团题库之重排链表

字节美团题库之重排链表

文章目录 题目详情题目分析完整实现Java代码总结 题目详情 注&#xff1a;面试真实遇到&#xff0c;对于面试遇到算法时要冷静分析 LCR 026 给定一个单链表 L 的头节点 head &#xff0c;单链表 L 表示为&#xff1a; L0 → L1 → … → Ln-1 → Ln 请将其重新排列后变为&am…
阅读更多...
美团笔试题之合并 K 个升序链表

美团笔试题之合并 K 个升序链表

文章目录 题目详情分析暴力求解两两合并链表 Java完整实现代码总结 题目详情 23 美团笔试真题 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 分析 暴力求解 将所有数值存入一个数组&#xff…
阅读更多...
Leetcode Top 100 Liked Questions（序号75~104）

Leetcode Top 100 Liked Questions（序号75~104）

75. Sort Colors 题意&#xff1a;红白蓝的颜色排序&#xff0c;使得相同的颜色放在一起&#xff0c;不要用排序 我的思路 哈希 代码 Runtime 4 ms Beats 28.23% Memory 8.3 MB Beats 9.95% class Solution { public:void sortColors(vector<int>& nums) {vector…
阅读更多...
数据结构与算法8 - 双向链表

数据结构与算法8 - 双向链表

文章目录概念双向链表 - 添加节点到尾部代码实现测试代码双向链表 - 删除节点代码实现测试代码双向链表 - 逻辑有序添加到链表测试代码概念 检索起点跟单向链表一样 每个节点有指向上一个节点、以及下一个节点的指针 双向链表 - 添加节点到尾部 代码实现 class DoubleLinke…
阅读更多...
数据结构day06（单向循环链表、双向链表）

数据结构day06（单向循环链表、双向链表）

双向链表的练习代码 head.h #ifndef __HEAD_H__ #define __HEAD_H__ #include <stdio.h> #include <stdlib.h> #include <string.h> typedef int database; typedef struct double_link_list{union{database data;int len;};struct double_link_list* pre;…
阅读更多...
二叉树的存储

二叉树的存储

1.二叉树的顺序存储 2.二叉树的链接存储 ①.二叉链表的存储 ②三叉链表的存储 二叉链表法建立二叉树 #include <stdio.h> #include <bits/stdc.h> #define maxsize 10 //#define NULL 0 using namespace std; typedef struct node {char data;struct node *…
阅读更多...
【Python数据结构】双向链表、单向循环链表、栈、队列、双端队列

【Python数据结构】双向链表、单向循环链表、栈、队列、双端队列

双向链表的实现 class Node(object):def __init__(self,item):self.elem itemself.next Noneself.prev Noneclass DoubleLinkList(obejct):def __init__(self,node None):self._head Nonedef is_empty(self):#判断链表是否为空return self.__head Nonedef length(self):…
阅读更多...
操作系统--freeRTOS 双向链表解读（list）

操作系统--freeRTOS 双向链表解读（list）

1、简介 本文依据的freeRTOS版本是V9.0.0版本&#xff0c;本文将分析链表文件的结构体&#xff0c;主要根据其list.c和list.h文件; 2、list.h文件解析 /** FreeRTOS Kernel V9.0.0a* Copyright (C) 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.** Permi…
阅读更多...
【算法小抄】递归训练之反转链表

【算法小抄】递归训练之反转链表

文章目录前言一、反转整个链表代码解析二、反转链表前 N 个节点代码解析三、反转链表区间节点代码解析总结前言 前言&#xff1a;阅读《算法小抄》的实时记录&#xff0c;通过自己画图&#xff0c;自己敲一次代码来理解总结一波 《算法小抄》&#xff1a;递归反转链表 一、反转…
阅读更多...
无关(relationship)——容斥原理+二进制枚举 *

无关(relationship)——容斥原理+二进制枚举 *

problem nowcoder 真没想到这题用容斥原理来做&#xff0c;感觉很新颖 这种求区间[l,r]的问题若用[1,r]-[1,l-1]&#xff0c;记得把 l-1 // Decline is inevitable, // Romance will last forever. #include <bits/stdc.h> using namespace std; //#define mp make_pair…
阅读更多...
c++ 双向链表

c++ 双向链表

#include <iostream> using std::cout; using std::endl; struct Node {int data;struct Node * next;struct Node * pre; };一、创建双向链表 Node * createList() {Node * head new Node;if (NULL head)exit(-1);head->next head;head->pre head;return hea…
阅读更多...
leetcode（237）：Delete a node in a Linked list

leetcode（237）：Delete a node in a Linked list

今天开始刷题&#xff0c;这是准备找工作刷的第一题&#xff0c;之前做了几道string的题&#xff0c;并没有觉得很难&#xff0c;有点不熟悉做题的模式&#xff0c;因为&#xff0c;总觉得前后不连贯&#xff0c;自己的思路受到了限制&#xff0c;现在又要重新进行克服&#xf…
阅读更多...
算法执行机制

算法执行机制

算法执行机制是指算法在计算机系统中被执行的方式和过程。下面是一般算法执行的基本机制&#xff1a; 编写算法&#xff1a;首先需要根据问题描述和需求&#xff0c;使用某种编程语言编写算法的逻辑和步骤。算法可以用伪代码或特定的编程语言来表示。 选择执行环境&#xff1a…
阅读更多...
链表系列参数构造完整代码

链表系列参数构造完整代码

本题以环形链表II为例&#xff1a; package main// 定义链表节点结构 type ListNode struct {Val intNext *ListNode }func detectCycle(head *ListNode) *ListNode {// 定义快慢指针slow : headfast : head// 判断是否有环for fast ! nil && fast.Next ! nil {slow …
阅读更多...
[JavaScript]两个链表生成相加链表

[JavaScript]两个链表生成相加链表

两个链表生成相加链表描述示例代码描述 假设链表中每一个节点的值都在 0 - 9 之间&#xff0c;那么链表整体就可以代表一个整数。 给定两个这种链表&#xff0c;请生成代表两个整数相加值的结果链表。 例如&#xff1a;链表 1 为 9->3->7&#xff0c;链表 2 为 6->3&…
阅读更多...
链表数据结构讲解 --数据结构与算法之美读书笔记

链表数据结构讲解 --数据结构与算法之美读书笔记

链表&#xff08;上&#xff09; 1、数组和链表区别 数组需要一块连续的内存空间来存储&#xff0c;链表恰好相反&#xff0c;并不需要一块连续的内存空间&#xff0c;通过“指针”将一组零散的内存卡串联起来使用。 2、常见的链表结构 单链表&#xff1a; 第一个点叫作头…
阅读更多...
LeetCode 143. 重排链表（双指针、快慢指针）

LeetCode 143. 重排链表（双指针、快慢指针）

题目&#xff1a; 链接&#xff1a;LeetCode 143. 重排链表 难度&#xff1a;中等 给定一个单链表 L 的头节点 head &#xff0c;单链表 L 表示为&#xff1a; L0 → L1 → … → Ln-1 → Ln 请将其重新排列后变为&#xff1a; L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → … 不…
阅读更多...
HashMap 原理源码分析

HashMap 原理源码分析

HashMap 原理源码分析 1.原理概述 首先呢HashMap 是哈希表的数据结构&#xff1b;(数组和链表的组合)&#xff1b; Map 接口下的实现类 都有 Keyvalue 的存储特点 &#xff0c; HashMap也不例外&#xff0c; 它的Key是不可重复的&#xff1b; 上面讲HashSet的时候 已经表明…
阅读更多...
手撕无头单链表

手撕无头单链表

&#x1f493; 博客主页&#xff1a;江池俊的博客⏩ 收录专栏&#xff1a;数据结构探索&#x1f449;专栏推荐&#xff1a;✅C语言初阶之路 ✅C语言进阶之路&#x1f4bb;代码仓库&#xff1a;江池俊的代码仓库&#x1f525;编译环境&#xff1a;Visual Studio 2022&#x1f38…
阅读更多...
【数据结构初阶】双链表

【数据结构初阶】双链表

双链表 1.双链表的实现1.1结口实现1.2申请结点1.3初始化双链表1.4打印双链表1.5尾插1.6尾删1.7头插1.8头删1.9计算大小1.10查找1.11pos位置插入1.12删除pos位置1.12删除双链表 全部码源 1.双链表的实现 1.1结口实现 #include<stdio.h> #include<stdlib.h> #inclu…
阅读更多...
Leetcode160 两个链表是否相交

Leetcode160 两个链表是否相交

leetcode 160题&#xff0c;判断两个链表是否相交 此题可以说是算法界第一深情&#xff0c;如果我走过你走过的路&#xff0c;那么我们就可能会相遇。 具体解决思路如下 两个链表是否相交有两种可能&#xff0c;一种不相交&#xff0c;一种相交&#xff0c;首先来看下相交的…
阅读更多...
ASP.NET Core Middleware抽丝剥茧

ASP.NET Core Middleware抽丝剥茧

一. 中间件的概念和数据结构ASP.NET Core Middleware是在ASP.NET Core处理管道中处理特定业务逻辑的组件。ASP.NET Core处理管道由一系列请求委托组成&#xff0c;一环接一环的调用特定的中间件。上图示例&#xff1a;处理管道包含四个中间件&#xff0c;每个中间件都包含后续中…
阅读更多...
剑指offer --- 从尾到头打印链表

剑指offer --- 从尾到头打印链表

目录 前言 一、读懂题目 二、思路分析 三、代码呈现 总结 前言 当我们需要访问单向链表中特定位置值时&#xff0c;算法复杂度往往是O(n)&#xff0c;在得到靠后节点的值时不可避免地从前向后遍历访问链表&#xff0c;那么当应题目要求从尾到头打印链表时&#xff0c;至少…
阅读更多...
数据结构与算法—双链表

数据结构与算法—双链表

前言 前面有很详细的讲过线性表(顺序表和链表)&#xff0c;当时讲的链表以单链表为主&#xff0c;但在实际应用中双链表有很多应用场景&#xff0c;例如大家熟知的LinkedList。 双链表与单链表区别 单链表和双链表都是线性表的链式实现&#xff0c;它们的主要区别在于节点结构…
阅读更多...
数据结构与算法-(11)---有序表(OrderedList)

数据结构与算法-(11)---有序表(OrderedList)

&#x1f308;个人主页: Aileen_0v0 &#x1f525;系列专栏:PYTHON学习系列专栏 &#x1f4ab;"没有罗马,那就自己创造罗马~" 目录 知识回顾及总结 有序表的引入 ​编辑 实现有序表 1.有序表-类的构造方法 2.有序表-search方法的实现 3.有序表-add方法的实现…
阅读更多...
循环链表的设计与基本操作的实现

循环链表的设计与基本操作的实现

目录 一.循环链表的设计 二.循环链表的实现 三.循环链表的总结 一.循环链表的设计 1.循环链表的结构设计: typedef struct CNode{int data;struct CNode* next;}CNode ,*CList; 2.循环链表的示意图: 3.循环链表和单链表的区别: 唯一区别,没有空指针,尾节点的后继为头,为循…
阅读更多...
LeetCode算法练习top100：（4）链表

LeetCode算法练习top100：（4）链表

package top100.top链表;import top100.ListNode; import top100.Node;import java.util.ArrayDeque; import java.util.ArrayList; import java.util.HashMap;public class TOP {//160. 相交链表//hashmap方法太low了//判断链表是否相交//双指针遍历两个相交链表,如果有相遇点…
阅读更多...
牛客——OR36 链表的回文结构（C语言，配图，快慢指针）

牛客——OR36 链表的回文结构（C语言，配图，快慢指针）

本题是没有对C的支持的&#xff0c;但因为Cpp支持C&#xff0c;所以这里就用C写了&#xff0c;可以面向更多用户 链表的回文结构_牛客题霸_牛客网 (nowcoder.com) 思路一&#xff1a;链表翻转 简单的想想整形我们怎么比较&#xff0c;就是将整形A 依次取尾&#xff0c;放到整形…
阅读更多...
排序链表【链表】

排序链表【链表】

Problem: 148. 排序链表 文章目录 思路 & 解题方法复杂度Code 思路 & 解题方法 不想用归并排序&#xff0c;干脆用数组做了。 复杂度 时间复杂度: 添加时间复杂度, 示例&#xff1a; O ( n l o g n ) O(nlogn) O(nlogn) 空间复杂度: 添加空间复杂度, 示例&#xff1a…
阅读更多...
234. 回文链表、Leetcode的Python实现

234. 回文链表、Leetcode的Python实现

博客主页&#xff1a;&#x1f3c6;看看是李XX还是李歘歘 &#x1f3c6; &#x1f33a;每天分享一些包括但不限于计算机基础、算法等相关的知识点&#x1f33a; &#x1f497;点关注不迷路&#xff0c;总有一些&#x1f4d6;知识点&#x1f4d6;是你想要的&#x1f497; ⛽️今…
阅读更多...
map底层、unorder_map底层，二者区别，为什么这样设计

map底层、unorder_map底层，二者区别，为什么这样设计

文章目录一、unorder_map底层实现二、map与unorder_map的相同点与不同点1.map的优点与缺点1.map优点2.map缺点3.map适用场景1.unordered_map的优点与缺点1.unordered_map的优点2.unordered_map的缺点3.unordered_map的适用场景三、什么时候需要用unorder_map&#xff0c;什么时…
阅读更多...
Java集合类——ArrayList（扩容机制）

Java集合类——ArrayList（扩容机制）

线性表 线性表是n个相同类型元素的有限序列&#xff0c;逻辑上连续物理上不一定是连续的&#xff0c;存储结构上分为顺序存储和链式存储&#xff0c;常见的线性表有&#xff1a;顺序表&#xff0c;链表&#xff0c;栈&#xff0c;队列…… ArrayList 数据结构 ArrayList&am…
阅读更多...
基于标签的推荐系统算法实现

基于标签的推荐系统算法实现

# -*-coding:utf-8-*-"""Author: ThinkgamerDesc:代码6-2 实例19 利用标签推荐算法实现艺术家的推荐 """import pandas as pd import mathclass RecBasedTag:# 由于从文件读取为字符串&#xff0c;统一格式为整数&#xff0c;方便后续计算def __…
阅读更多...
【LeetCode刷题-链表】--876.链表的中间结点

【LeetCode刷题-链表】--876.链表的中间结点

876.链表的中间结点 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* ListNode(int val, ListNode next) { this.val val; this.next next; }* }*…
阅读更多...
【算法】合并K个升序链表

【算法】合并K个升序链表

这道题主要考察的是归并排序&#xff0c;因为已经升序过了&#xff0c;更好理解了。 当然也可以采用分治的思路&#xff1b;或采用最小堆的思路&#xff1b;面试中校招同学写出一种即可&#xff0c;如果能全概览讲一下&#xff0c;就更加分了。 #############################…
阅读更多...
算法通关村第一关—白银挑战—链表高频面试算法题—查找两个链表的第一个公共子节点

算法通关村第一关—白银挑战—链表高频面试算法题—查找两个链表的第一个公共子节点

文章目录 查找两个链表的第一个公共子节点&#xff08;1&#xff09;暴力求解法&#xff08;2&#xff09;使用哈希Hash⭐&#xff08;3&#xff09;使用集合⭐ - 与Hash类似&#xff08;4&#xff09;使用栈⭐&#xff08;5&#xff09;仍有更多方法&#xff0c;作者尚未理解&…
阅读更多...
P1 什么是链表 C语言简单易懂

P1 什么是链表 C语言简单易懂

目录 前言 01 什么是链表 02 数组的特点 03 数组的缺点 3.1 删除数组其中一个元素 3.2 数组增加某个节点 04 链表 前言 &#x1f3ac; 个人主页&#xff1a;ChenPi &#x1f43b;推荐专栏1: 《 C 》✨✨✨ &#x1f525; 推荐专栏2: 《 Linux C应用编程&#xff08;概念…
阅读更多...
leetcode-160-相交链表（C语言实现）

leetcode-160-相交链表（C语言实现）

题目&#xff1a; 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c;…
阅读更多...
【LeetCode刷题日志】160.相交链表

【LeetCode刷题日志】160.相交链表

&#x1f388;个人主页&#xff1a;库库的里昂 &#x1f390;C/C领域新星创作者 &#x1f389;欢迎 &#x1f44d;点赞✍评论⭐收藏✨收录专栏&#xff1a;LeetCode 刷题日志&#x1f91d;希望作者的文章能对你有所帮助&#xff0c;有不足的地方请在评论区留言指正&#xff0c;…
阅读更多...
回文链表(递归方法)

回文链表(递归方法)

首先关于链表,有两种常用的实现,分别是数组列表和链表,若想在链表中存储值是如何做到的呢? 数组列表底层是使用数组存储值&#xff0c;我们可以通过索引在 O(1)O(1)O(1) 的时间访问列表任何位置的值&#xff0c;这是由基于内存寻址的方式。链表存储的是称为节点的对象&#x…
阅读更多...
手写C++ 实现链表的反转、删除、合并

手写C++ 实现链表的反转、删除、合并

目录 一、手写List成员方法 1.1 打印链表 1.2 删除链表节点 1.3 链表中倒数第k个节点 1.4 反转链表 1.5 合并两个排序链表 二、完整代码 一、C实现链表成员方法 在上一篇博客《手写链表C》&#xff0c;实现了基本的List类。在面试中&#xff0c;经常被问到List如何反转、…
阅读更多...
初级数据结构（二）——链表

初级数据结构（二）——链表

文中代码源文件已上传&#xff1a;数据结构源码 <-上一篇 初级数据结构&#xff08;一&#xff09;——顺序表 | NULL 下一篇-> 1、链表特征 与顺序表数据连续存放不同&#xff0c;链表中每个数据是分开存放的&#xff0c;而且存放的位置尤其零散&#…
阅读更多...
数据结构-链表习题（C++）

数据结构-链表习题（C++）

程序设计题: 单链表实验 1.从键盘输入若干大于0的整数&#xff0c;用这些整数构造一个单链表.当用户输入小于等于0的值时创建链表结束并在终端打印输出这个链表。 2.在链表中查找某结点&#xff0c;如果能找到输出这个结点是第几个结点&#xff0c;如果找不到&#xff0c;输出:…
阅读更多...
力扣每日一道系列 --- LeetCode 160. 相交链表

力扣每日一道系列 --- LeetCode 160. 相交链表

&#x1f4f7; 江池俊&#xff1a; 个人主页 &#x1f525;个人专栏&#xff1a; ✅数据结构探索 ✅LeetCode每日一道 &#x1f305; 有航道的人&#xff0c;再渺小也不会迷途。 文章目录 LeetCode 160. 相交链表 思路&#xff1a; 首先计算两个链表的长度&#xff0c;然后判…
阅读更多...
C语言数据结构-双向链表

C语言数据结构-双向链表

文章目录 1 双向链表的结构2 双向链表的实现2.1 定义双向链表的数据结构2.2 打印链表2.3 初始化链表2.4 销毁链表2.5 尾插,头插2.6 尾删,头删2.7 根据头次出现数据找下标2.8 定点前插入2.9 删除pos位置2.10 定点后插入 3 完整代码3.1 List.h3.2 Lish.c3.3 test.c 1 双向链表的结…
阅读更多...
链表oj题（第一弹）

链表oj题（第一弹）

通过前两篇博客我们了解了链表的实现&#xff0c;那么今天我们来看看链表的oj题是如何完成的。 1、移除链表元素 题目要求我们删掉与val相同的节点。 方法一&#xff1a;我们可以写一个循环&#xff0c;首先创建两个节点&#xff0c;一个头节点&#xff0c;一个尾节点&#x…
阅读更多...
golang 基于数组、切片、链表实现队列

golang 基于数组、切片、链表实现队列

数组 package mainimport ("errors""fmt" )func main() {// 创建一个简单队列// 如果head tail 队列空// 如果tail len(array) - 1// 整体做迁移 如果head 0 队列满stack1 : createQueue[int]()err : stack1.push(1)// 处理错误 后面的就不处理了if er…
阅读更多...
单链表详解(附图解，结尾附全部源码)

单链表详解(附图解，结尾附全部源码)

下面开始带大家对单链表的增删查改进行图解 首先给大家介绍一下链表 链表就是每一个结构体中包含一个数据和一个结构体指针&#xff0c;这个指针就相当于锁链的作用将下一个结构体给锁住&#xff0c;但是每个结构体的空间是相对独立的。 图解&#xff1a; 1 首先实现尾插 如果…
阅读更多...
各种线性表（单链表，双链表，循环链表）的基本运算（初始化，插入，删除，销毁，输出，按元素查找等） 都有给源码

各种线性表（单链表，双链表，循环链表）的基本运算（初始化，插入，删除，销毁，输出，按元素查找等） 都有给源码

各种线性表&#xff08;单链表&#xff0c;双链表&#xff0c;循环链表&#xff09;的基本运算 1.InitList() 初始化线性表 2.void CreateListF(LinkNode* L, ElemType a[], int n) 头插法创建链表 3. void CreateListR(LinkNode* L, ElemType a[], int n) 尾插法创建链表…
阅读更多...
【链表OJ—链表的回文结构】

【链表OJ—链表的回文结构】

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、pandas是什么&#xff1f;二、使用步骤 1.引入库2.读入数据总结 前言 提示&#xff1a;这里可以添加本文要记录的大概内容&#xff1a; 例如&#xff1a;…
阅读更多...
【leetcode100-026】【链表/快慢指针】环形链表II

【leetcode100-026】【链表/快慢指针】环形链表II

【题干】 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统…
阅读更多...
leetcode第206题反转链表❤

leetcode第206题反转链表❤

一&#xff1a;题目&#xff1a; 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1] 题目链接&#xff1a;力扣&#xff08;LeetCode&#xff09;官网…
阅读更多...
数据结构与算法（九）--链表与递归

数据结构与算法（九）--链表与递归

一、前言 之前的文链表的学习我们学习了链表的定义&#xff0c;以及链表的CRUD操作。并且通过链表去自定义了我们的栈和队列。但是链表还有很多很重要的性质&#xff0c;例如链表本身具有天然的递归性&#xff0c;我们可以利用链表的这些性质去完成一些需求。 二、链表和递归…
阅读更多...
【面试题】循环队列队列实现栈栈实现队列

【面试题】循环队列队列实现栈栈实现队列

1️⃣设计循环队列OJ链接 2️⃣用队列实现栈OJ链接 3️⃣用栈实现队列OJ链接 这几道面试题需要栈和队列的知识&#xff0c;它们的相关知识可以看我的上一篇文章 1️⃣设计循环队列 先来了解一下环形队列&#xff0c;这也是循环队列的思想&#xff0c;空间是固定的&#xff0c;数…
阅读更多...
【数据结构】链表简介及单链表的实现

【数据结构】链表简介及单链表的实现

简单不先于复杂&#xff0c;而是在复杂之后。 文章目录 1. 链表1.1 链表的概念及结构1.2 链表的分类1.3 无头单向非循环链表的实现 1. 链表 1.1 链表的概念及结构 概念&#xff1a;链表是一种物理存储结构上非连续&#xff0c;非顺序的存储结构&#xff0c;数据元素的逻辑顺序…
阅读更多...
栈和队列的初始化，插入，删除，销毁。

栈和队列的初始化，插入，删除，销毁。

目录 题外话 顺序表和链表优缺点以及特点 一.栈的特点 二. 栈的操作 2.1初始化 2.2 栈的销毁 2.3 栈的插入 2.3 输出top 2.4 栈的删除 2.5 输出栈 题外话 顺序表和链表优缺点以及特点 特点&#xff1a;顺序表&#xff0c;逻辑地址物理地址。可以任意访问&#xff0c…
阅读更多...
『力扣刷题本』:链表分割

『力扣刷题本』:链表分割

一、题目 现有一链表的头指针 ListNode* pHead&#xff0c;给一定值x&#xff0c;编写一段代码将所有小于x的结点排在其余结点之前&#xff0c;且不能改变原来的数据顺序&#xff0c;返回重新排列后的链表的头指针。 二、思路解析 首先&#xff0c;让我们列出我们需要做的事情&…
阅读更多...
常用链表算法——快慢指针法

常用链表算法——快慢指针法

快慢指针法 1.引言 链表是一种常见的数据结构&#xff0c;用于存储数据元素的集合。与数组不同&#xff0c;链表中的每个元素都包含一个指向下一个元素的指针&#xff0c;这样就可以通过指针将所有元素连接起来&#xff0c;形成一个链式结构。 链表问题的常见性质包括&#…
阅读更多...
设计循环链表C语言——力扣622题

设计循环链表C语言——力扣622题

题目地址->设计循环链表 题目 设计你的循环队列实现。 循环队列是一种线性数据结构&#xff0c;其操作表现基于 FIFO&#xff08;先进先出&#xff09;原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。 循环队列的一个好处是我们可以利用这个队列之…
阅读更多...
14-链表练习-剑指 Offer II 021. 删除链表的倒数第 n 个结点

14-链表练习-剑指 Offer II 021. 删除链表的倒数第 n 个结点

题目 给定一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] 示例 2&#xff1a; 输入&#xff1a;head [1], n 1 输出&#xff1a;[] 示例 3&…
阅读更多...
73、介绍下 HashMap 的底层数据结构

73、介绍下 HashMap 的底层数据结构

73、介绍下 HashMap 的底层数据结构 我们现在用的都是 JDK 1.8&#xff0c;底层是由“数组链表红黑树”组成&#xff0c;如下图&#xff0c;而在 JDK 1.8 之前是由“数组链表”组成。 1.Hash Hash叫做”散列表“&#xff0c;就是把任意长度的输入&#xff0c;通过散列算法&am…
阅读更多...
环形链表 II（力扣142）（快慢指针）

环形链表 II（力扣142）（快慢指针）

142.环形链表—力扣 题目描述&#xff1a; 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给…
阅读更多...
10.线性表代码实战

10.线性表代码实战

10.1 与408关联解析及本节内容介绍 链表比顺序表出现的顺序更加的频繁。 10.2线性表地顺序表示原理解析 线性表的特点&#xff1a; &#xff08;1&#xff09;表中的元素的个数是有限的 &#xff08;2&#xff09;表中元素的数据类型相同。意味着每一个元素占用相同大小的空…
阅读更多...
LeetCode【92】翻转链表II

LeetCode【92】翻转链表II

题目&#xff1a; 思路&#xff1a; https://blog.csdn.net/DarkAndGrey/article/details/122146216 public ListNode reverseBetween(ListNode head, int left, int right) {if(head null || right left){return head;// 头节点为null&#xff0c;链表为空&#xff0c;反…
阅读更多...
1868_C语言单向链表的实现

1868_C语言单向链表的实现

Grey 全部学习内容汇总&#xff1a; GitHub - GreyZhang/c_basic: little bits of c. 1868_C语言中简单的链表实现 简单整理一下链表的实现&#xff0c;这一次结合前面看到的一些代码简单修改做一个小结。 主题由来介绍 以前工作之中链表的使用其实不多&#xff0c;主要是…
阅读更多...
【华为OD题库-029】恢复数字序列-java

【华为OD题库-029】恢复数字序列-java

题目 对于一个连续正整数组成的序列&#xff0c;可以将其拼接成一个字符串&#xff0c;再将字符串里的部分字符打乱顺序。如序列89101112, 拼接成的字符串19810112,打乱部分字符后得908112111。原来的正整数10就被拆成了0和1.现给定一个按如上规则得到的打乱字符的字符串&#…
阅读更多...
数据结构体进阶链表【带头双向循环链表，单向链表的优化，从根部解决了顺序表的缺点】一文带你深入理解链表

数据结构体进阶链表【带头双向循环链表，单向链表的优化，从根部解决了顺序表的缺点】一文带你深入理解链表

前言&#xff1a; 对于链表&#xff0c;上一篇的单链表解决了顺序表的一部分缺陷&#xff0c;但并没有彻底的解决顺序表的问题&#xff0c;比如在进行单链表尾插尾删的时候还是需要进行遍历找尾&#xff0c;并没有达到全部的O(1)&#xff0c;并且在头插的时候还要分情况来考虑&…
阅读更多...
每日一题(LeetCode)----链表--两数相加

每日一题(LeetCode)----链表--两数相加

每日一题(LeetCode)----链表–两数相加 1.题目&#xff08;2. 两数相加&#xff09; 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返…
阅读更多...
单链表实现【队列】

单链表实现【队列】

目录 队列的概念及其结构 队列的实现 数组队列 链式队列 队列的常见接口的实现 主函数Test.c 头文件&函数声明Queue.h 头文件 函数声明 函数实现Queue.c 初始化QueueInit 创建节点Createnode 空间释放QueueDestroy 入队列QueuePush 出队列QueuePop 队头元…
阅读更多...
单链表相关面试题--7.链表的回文结构

单链表相关面试题--7.链表的回文结构

7.链表的回文结构 链表的回文结构_牛客题霸_牛客网 (nowcoder.com) /* 解题思路&#xff1a; 此题可以先找到中间节点&#xff0c;然后把后半部分逆置&#xff0c;最近前后两部分一一比对&#xff0c;如果节点的值全部相同&#xff0c;则即为回文。 */ class PalindromeList…
阅读更多...
leetcode：环形链表的入环点

leetcode：环形链表的入环点

题目描述 题目链接:力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 题目分析 我们假设起点到环的入口点的距离是L&#xff0c;入口点到相遇点的距离是X&#xff0c;环的长度是C 那么画图我们可以得知&#xff1a; 从开始到相遇时slow走的距离是LX从…
阅读更多...
leetcode：随机链表的复制

leetcode：随机链表的复制

题目描述 题目链接&#xff1a;138. 随机链表的复制 - 力扣&#xff08;LeetCode&#xff09; 题目分析 这个题目很长&#xff0c;但是意思其实很简单&#xff1a;就是一个单链表&#xff0c;每个结点多了一个指针random随机指向链表中的任意结点或者NULL&#xff0c;我们血需…
阅读更多...
王道p150 14.假设二叉树采用二叉链表存储结构，设计一个算法，求非空二叉树 b的宽度(即具有结点数最多的那一层的结点个数) （c语言代码实现）

王道p150 14.假设二叉树采用二叉链表存储结构，设计一个算法，求非空二叉树 b的宽度(即具有结点数最多的那一层的结点个数) （c语言代码实现）

采用层次遍历的方法求出所有结点的层次&#xff0c;并将所有结点和对应的层次放在一个队列中。然后通过扫描队列求出各层的结点总数&#xff0c;最大的层结点总数即为二叉树的宽度。 /* A B C D E F …
阅读更多...
LeetCode.707设计链表（链表相关操作一篇就够了）

LeetCode.707设计链表（链表相关操作一篇就够了）

LeetCode.707设计链表 1.问题描述2.解题思路3.代码 1.问题描述 你可以选择使用单链表或者双链表&#xff0c;设计并实现自己的链表。 单链表中的节点应该具备两个属性&#xff1a;val 和 next 。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。 如果是双…
阅读更多...
编程题 ：简单的洗牌算法的实现

编程题 ：简单的洗牌算法的实现

&#x1f4d1;打牌 &#xff1a; da pai ge的个人主页 &#x1f324;️个人专栏 &#xff1a; da pai ge的博客专栏 ☁️宝剑锋从磨砺出&#xff0c;梅花香自苦寒来 目录 &#x1f324;️简单的洗牌算法…
阅读更多...
带头双向循环链表的增删改查

带头双向循环链表的增删改查

目录&#x1f921;前言&#x1f60a;带头双向循环链表&#x1f44d;链表实现&#x1f620;插入-头插&#xff0c;尾插&#xff0c;随机插✅删除-头删&#xff0c;尾删&#xff0c;随机删&#x1f602;链表搜索和链表修改&#x1f4a1;总结&#x1f921;前言 本篇博客主要是介绍…
阅读更多...
【数据结构】循环链表和双向链表

【数据结构】循环链表和双向链表

【循环链表】 (有头结点) pR1->next; R1->nextR2->next->next; free(R2->next); R2->nextp; 例&#xff1a;对于两个单循环链表a&#xff0c;b&#xff0c;将其连接起来&#xff0c;变成一个单循环链表 #include<stdio.h> #include<stdlib.h> …
阅读更多...
单链表简单实现

单链表简单实现

单链表实现一、为什么会存在单链表&#xff1f;二、什么是单链表&#xff1f;三、单链表结构定义四、单链表的基本操作1、 创建结点2、 销毁链表3、 打印链表4、 尾插节点5、 头插结点6、 尾结点的删除7、 头结点的删除8、 单链表的查找9、 单链表在pos位置之后插入10、单链表在…
阅读更多...
【新2023】华为OD机试 - 寻找链表的中间结点（Python）

【新2023】华为OD机试 - 寻找链表的中间结点（Python）

寻找链表的中间结点 题目 给定一个单链表 L，请编写程序输出 L 中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。 例如：给定 L 为 1→7→5，则输出应该为 7；给定 L 为 1→2→3→4，则输出应该为 3。 输入 每个输入包含 11 个测试用例。 每个测…
阅读更多...
【第二章 - 线性表之单链表】- 数据结构

【第二章 - 线性表之单链表】- 数据结构

目录 一、单链表的定义和表示 二、单链表基本操作的实现 2.1 - 不设头结点的单链表 2.2 - 设头结点的单链表 一、单链表的定义和表示 线性表的链式存储结构的特点是&#xff1a;用一组任意的存储单元存储线性表的数据元素&#xff08;这组存储单元可以是连续的&#xff0c…
阅读更多...
C++知识精讲14 | 算法篇之二分查找算法

C++知识精讲14 | 算法篇之二分查找算法

博主主页&#xff1a;Cool Kid~Yu仙笙_C领域博主&#x1f984; 目录 二分查找定义 二分查找效率 二分查找与遍历的对比 二分查找的限制性 二分查找的限制性&#xff08;总结&#xff09; 二分查找搭建 循环实现二分查找 循环二分查找基本框架&#xff1a; 循环二分查找源码&am…
阅读更多...
循环链表2

循环链表2

循环链表的实现 对于数据结构中所有的结构而言&#xff0c;每一次都是用之前初始化&#xff08;处理一开始的随机值&#xff09;一下&#xff0c; 用完销毁&#xff08;不管有没有malloc都能用&#xff0c;用了可以保证没有动态内存泄漏了&#xff09;一下 而在C里面&#x…
阅读更多...
每日一题(LeetCode)----链表--两两交换链表中的节点

每日一题(LeetCode)----链表--两两交换链表中的节点

每日一题(LeetCode)----链表–两两交换链表中的节点 1.题目&#xff08;[24. 两两交换链表中的节点](https://leetcode.cn/problems/spiral-matrix/)&#xff09; 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内…
阅读更多...
【数据结构OJ题】相交链表

【数据结构OJ题】相交链表

原题链接&#xff1a;https://leetcode.cn/problems/intersection-of-two-linked-lists/description/ 目录 1. 题目描述 2. 思路分析 3. 代码实现 1. 题目描述 2. 思路分析 看到这道题&#xff0c;很容易想到的方法就是暴力求解&#xff0c;就是将一个链表的每个结点的地址…
阅读更多...
【数据结构入门指南】二叉树

【数据结构入门指南】二叉树

【数据结构入门指南】二叉树 一、二叉树的概念二、现实中的二叉树三、特殊的二叉树四、二叉树的性质五、二叉树的存储结构5.1 顺序结构5.2 链式结构 一、二叉树的概念 二叉树是一棵特殊的树。一棵二叉树是结点的一个有限集合&#xff0c;该节点&#xff1a; ①&#xff1a;或者…
阅读更多...
反转链表II

反转链表II

江湖一笑浪滔滔&#xff0c;红尘尽忘了 题目 示例 思路 链表这部分的题&#xff0c;不少都离不开单链表的反转&#xff0c;参考&#xff1a;反转一个单链表 这道题加上哨兵位的话会简单很多&#xff0c;如果不加的话&#xff0c;还需要分情况一下&#xff0c;像是从头节点开始…
阅读更多...
【数据结构】 LinkedList的模拟实现与使用

【数据结构】 LinkedList的模拟实现与使用

文章目录 &#x1f340;什么是LinkedList&#x1f334;LinkedList的模拟实现&#x1f6a9;创建双链表&#x1f6a9;头插法&#x1f6a9;尾插法&#x1f6a9;任意位置插入&#x1f6a9;查找关键字&#x1f6a9;链表长度&#x1f6a9;打印链表&#x1f6a9;删除第一次出现关键字为…
阅读更多...
LinkedList的顶级理解

LinkedList的顶级理解

目录 1.LinkedList的介绍 LinkedList的结构 2.LinkedList的模拟实现 2.1创建双链表 2.2头插法 2.3尾插法 2.4任意位置插入 2.5查找关键字 2.6链表长度 2.7遍历链表 2.8删除第一次出现关键字为key的节点 2.9删除所有值为key的节点 2.10清空链表 2.11完整代码 3.…
阅读更多...
【算法】链表-20231127

【算法】链表-20231127

这里写目录标题 一、面试题 02.02. 返回倒数第 k 个节点二、82. 删除排序链表中的重复元素 II三、141. 环形链表 一、面试题 02.02. 返回倒数第 k 个节点 提示 简单 130 相关企业 实现一种算法&#xff0c;找出单向链表中倒数第 k 个节点。返回该节点的值。 注意&#xff1a;本…
阅读更多...
代码随想录训练营二刷第三天 | 203.移除链表元素 707.设计链表 206.反转链表

代码随想录训练营二刷第三天 | 203.移除链表元素 707.设计链表 206.反转链表

代码随想录训练营二刷第三天 | 203.移除链表元素 707.设计链表 206.反转链表 一、203.移除链表元素 题目链接&#xff1a;https://leetcode.cn/problems/remove-linked-list-elements/ 思路&#xff1a;使用虚拟头结点&#xff0c;两个指针&#xff0c;一个是遍历指针&#x…
阅读更多...
数据结构双向链表

数据结构双向链表

Hello&#xff0c;好久不见&#xff0c;今天我们讲链表的双向链表&#xff0c;这是一个很厉害的链表&#xff0c;带头双向且循环&#xff0c;学了这个链表&#xff0c;你会发现顺序表的头插头删不再是一个麻烦问题&#xff0c;单链表的尾插尾删也变得简单起来了&#xff0c;那废…
阅读更多...
【LeetCode】 160. 相交链表

【LeetCode】 160. 相交链表

相交链表 题目题解 题目 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&am…
阅读更多...
常见链表的操作题+代码

常见链表的操作题+代码

文章目录 leetcode 2 两数相加leetcode 19删除链表中的倒数第N个节点leetcode 21合并两个有序链表leetcode 24两两交换链表中的节点leetcode 25k个一组链表反转leetcode 61旋转链表 leetcode 2 两数相加 两个链表对应的值进行相加&#xff0c;如何计算呢&#xff1f; 考虑点&…
阅读更多...
链表例题小总结：

链表例题小总结：

链表&#xff1a; 第一种题型&#xff1a;双指针 力扣203&#xff1a;移除链表元素 力扣题目链接 题意&#xff1a;删除链表中等于给定值 val 的所有节点。示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5]示例 2&#xff1…
阅读更多...
13链表-简单思路练习

13链表-简单思路练习

目录 LeetCode之路——876. 链表的中间结点 分析&#xff1a; 解法一&#xff1a;常规思路 解法二&#xff1a;快慢指针 LeetCode之路——876. 链表的中间结点 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回…
阅读更多...
数据结构之手撕链表（讲解➕源代码）

数据结构之手撕链表（讲解➕源代码）

0.引言 我们在学习过顺序表之后&#xff0c;会发现两点不是很优秀的操作&#xff1a; 1.顺序表的头插和中间的插入&#xff1a; 非常麻烦&#xff0c;需要不断的覆盖数据。 2.动态开辟空间&#xff1a; a.一般动态开辟的空间都是以2倍的形式开辟&#xff0c;当…
阅读更多...
彻底理解链表

彻底理解链表

数组和链表的关系可以类比卡车和火车的关系。 接下来看看数组以及链表在内存中是怎么表示的。 首先我们来看数组&#xff0c;假设你要装载的货物是16个字节&#xff0c;那么如果你想用数组来装载数据的话该怎么办呢&#xff1f; 很显然&#xff0c;你需要从内存中申请16个字节&…
阅读更多...
玩数据结构和算法-实现属于自己的链表

玩数据结构和算法-实现属于自己的链表

文章目录链表的实现使用链表实现栈带有尾指针的链表&#xff1a;使用链表实现队列参考&#xff1a;https://blog.csdn.net/hongxue8888/article/details/107665599https://blog.csdn.net/hongxue8888/article/details/107588793https://blog.csdn.net/hongxue8888/article/deta…
阅读更多...
玩数据结构和算法-实现属于自己的栈

玩数据结构和算法-实现属于自己的栈

文章目录1 使用数组实现栈2 使用链表实现栈3 完整的动态数组代码动态数组的实现参照&#xff1a; https://blog.csdn.net/hongxue8888/article/details/107665599 栈也是一种线性结构相比数组&#xff0c;栈对应的操作时数组的子集只能从一端添加元素&#xff0c;也只能从一端…
阅读更多...
双指针解决链表问题（python）

双指针解决链表问题（python）

双指针技巧&#xff1a;左右指针和快慢指针 左右指针&#xff1a;两个指针相向而行或相背而行 快慢指针&#xff1a;两个指针同向而行&#xff0c;一快一慢 1、合并两个有序链表 class ListNode:def __init__(self, val0, nextNone):self.val valself.next next class Solut…
阅读更多...
Python3，区区5行代码，制作期待的图表，这技能值得拥有(一)。

Python3，区区5行代码，制作期待的图表，这技能值得拥有(一)。

5行代码制作图表&#xff08;一&#xff09; 1、引言2、matplotlib介绍2.1 基本功能2.1.1 定义2.1.2 常用方法 2.2 示例2.2.1 安装2.2.2 代码示例-折线图2.2.2 代码示例-柱状图 3、总结 1、引言 小屌丝&#xff1a;鱼哥&#xff0c;干啥嘞&#xff1f; 小鱼&#xff1a;啥也没…
阅读更多...
【LeetCode刷题-链表】--328.奇偶链表

【LeetCode刷题-链表】--328.奇偶链表

328.奇偶链表 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* ListNode(int val, ListNode next) { this.val val; this.next next; }* }*/ clas…
阅读更多...
移除两个双向链表中的重复元素，每个链表中的元素不重复

移除两个双向链表中的重复元素，每个链表中的元素不重复

移除两个双向链表中的重复元素&#xff0c;每个链表中的元素不重复&#xff0c;请给出算法。 ans: 该问题比单向链表要更加复杂一些&#xff0c;必须考虑并更新前向节点的指向情况&#xff0c;具体编码中存在一些难度&#xff0c;加上链表调试相对不容易&#xff0c;因此难度系…
阅读更多...
C/C++实现：使用单向循环链表实现：编写相关函数来完成两个超长正整数的加法 某知名公司笔试题

C/C++实现：使用单向循环链表实现：编写相关函数来完成两个超长正整数的加法 某知名公司笔试题

目录 题目描述: 题目分析： 代码实现： 完整代码： 运行结果： 题目描述: 请编写相关函数来完成两个超长正整数的加法，超长
阅读更多...
链表OJ--下

链表OJ--下

文章目录 前言一、链表分割二、环形链表I三、环形链表II四、链表的回文结构五、随机链表的复制 前言 一、链表分割 牛客网CM11&#xff1a;链表分割- - -点击此处传送 题解&#xff1a; 思路图&#xff1a; 代码&#xff1a; 二、环形链表I 力扣141&#xff1a;环形链表…
阅读更多...
代码随想录-刷题第五天

代码随想录-刷题第五天

链表题目总结 链表基本操作 对链表进行增删改查等基本操作。注意&#xff0c;很多链表的题目使用虚拟头结点操作起来会更加方便。每次对应头结点的情况都要单独处理&#xff0c;所以使用虚拟头结点的技巧&#xff0c;就可以解决这个问题。 反转链表 可以使用头插法&#xf…
阅读更多...
链表的反转—c++版本

链表的反转—c++版本

一、迭代反转法 过程分析&#xff1a; 代码实现&#xff1a; #include <iostream>struct LinkNode{ //创建一个结构体做为链表的结点int data; //数据域LinkNode* next; //指针域 };void Print_Link(LinkNode* phead) //打印链表 {while (phead ! nu…
阅读更多...
堆的实现（C语言版）

堆的实现（C语言版）

文章目录 概述堆的实现初始化销毁插入删除取堆顶元素求堆的长度判断堆是否为空 完整代码 概述 如果有一个关键码的集合K {k0,k1,k2…kn-1}&#xff0c;把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中&#xff0c;并满足&#xff1a;Ki <K2*i1 且 Ki<K2…
阅读更多...
Leetcode—83.删除排序链表中的重复元素【简单】

Leetcode—83.删除排序链表中的重复元素【简单】

2023每日刷题&#xff08;四十&#xff09; Leetcode—83.删除排序链表中的重复元素 实现代码 /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/ struct ListNode* deleteDuplicates(struct ListNode* head) {i…
阅读更多...
《算法通关村——解析堆在合并K个排序链表的应用》

《算法通关村——解析堆在合并K个排序链表的应用》

《算法通关村——解析堆在合并K个排序链表的应用》 23. 合并 K 个升序链表 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 示例 1&#xff1a; 输入&#xff1a;lists [[1,4,5],[1,3,4],[2…
阅读更多...
卡码网语言基础课 | 14. 链表的基础操作Ⅱ

卡码网语言基础课 | 14. 链表的基础操作Ⅱ

题目&#xff1a; 构建一个单向链表&#xff0c;链表中包含一组整数数据&#xff0c;输出链表中的第 m 个元素&#xff08;m 从 1 开始计数&#xff09;。 要求&#xff1a; 1. 使用自定义的链表数据结构 2. 提供一个 linkedList 类来管理链表&#xff0c;包含构建链表、输出…
阅读更多...
p11 第60题 设计一个算法，逆序单链表中的数据 电子科技大学2014年数据结构（c语言代码实现）

p11 第60题 设计一个算法，逆序单链表中的数据 电子科技大学2014年数据结构（c语言代码实现）

通过头插法可以实现单链表的逆置 下方博客有图解&#xff1a; 王道p40 5.将带头结点的单链表就地逆置&#xff0c;所谓“就地”是指辅助空间复杂度为O&#xff08;1&#xff09;-CSDN博客 单链表的逆置可以通过遍历链表&#xff0c;逐个将节点取出并插入到新链表的头部来实现…
阅读更多...
【数据结构】树与二叉树（廿五）：树搜索给定结点的父亲（算法FindFather）

【数据结构】树与二叉树（廿五）：树搜索给定结点的父亲（算法FindFather）

文章目录 5.3.1 树的存储结构5. 左儿子右兄弟链接结构 5.3.2 获取结点的算法1. 获取大儿子、大兄弟结点2. 搜索给定结点的父亲a. 算法FindFatherb. 算法解析c. 代码实现 3. 代码整合 5.3.1 树的存储结构 5. 左儿子右兄弟链接结构 【数据结构】树与二叉树&#xff08;十九&…
阅读更多...
北邮22信通：（5）实验1 题目二：有序链表合并

北邮22信通：（5）实验1 题目二：有序链表合并

北邮22信通一枚~ 跟随课程进度每周更新数据结构与算法的代码和文章 持续关注作者 解锁更多邮苑信通专属代码~ 上一篇文章&#xff1a; 北邮22信通&#xff1a;&#xff08;4&#xff09;实验1 题目一 &#xff1a;线性表的实现_青山如墨雨如画的博客-CSDN博客 下一篇…
阅读更多...
leetcode -- 21. 合并两个有序链表

leetcode -- 21. 合并两个有序链表

&#x1f428;目录&#x1f4d1;1. 题目&#x1f6f6;2. 解法- 头插到新链表&#x1f42c;2.1 思路&#x1f42c;2.1 代码实现⛵3. 解法优化 - 带哨兵位&#x1f40b;3.1 思路&#x1f40b;3.2 代码实现&#x1f6a4;4. 题目链接&#x1f4d1;1. 题目 将两个升序链表合并为一个…
阅读更多...
单向链表中间节点

单向链表中间节点

单向链表中间节点 求单向链表中间的节点值&#xff0c;如果奇数个节点取中间&#xff0c;偶数个取偏右边的那个值。 输入描述&#xff1a; 第一行 链表头节点地址path后续时输入的节点数n 后续输入每行表示一个节点&#xff0c;格式&#xff1a;“节点地址 节点值 下一个节点地…
阅读更多...
[LeetCode] 19. 删除链表的倒数第 N 个结点

[LeetCode] 19. 删除链表的倒数第 N 个结点

题目&#xff1a;给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 &#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5]解题思路&#xff1a; 使用一趟扫描实现。这里就是双指针的经典应用。如果要…
阅读更多...
【LeetCode刷题笔记】160.相交链表

【LeetCode刷题笔记】160.相交链表

创作不易&#xff0c;本篇文章如果帮助到了你&#xff0c;还请点赞 关注支持一下♡>&#x16966;<)!! 主页专栏有更多知识&#xff0c;如有疑问欢迎大家指正讨论&#xff0c;共同进步&#xff01; 更多算法知识专栏&#xff1a;算法分析&#x1f525; 给大家跳段街舞感谢…
阅读更多...
第72讲：MySQL数据库锁机制剖析：行级锁、间隙锁与临键锁详解及应用指南

第72讲：MySQL数据库锁机制剖析：行级锁、间隙锁与临键锁详解及应用指南

文章目录 1.行级锁的概念2.行锁的概念以及基本使用2.1.行锁的概念2.2.常见的SQL语句所对应的行锁类别2.3.行锁的基本使用 3.间隙锁和临键锁的概念以及基本使用3.1.间隙锁和临键锁的概念3.2.间隙锁和临键锁的基本使用 1.行级锁的概念 行级锁指的是&#xff0c;每次操作锁住的是…
阅读更多...
树与二叉树堆：经典OJ题集

树与二叉树堆：经典OJ题集

目录 查找值为x的结点&#xff1a; 思路分析&#xff1a; 单值二叉树&#xff1a; 示例&#xff1a; 思路分析&#xff1a; 相同的树&#xff1a; 示例&#xff1a; 思路分析&#xff1a; 二叉树的前序遍历&#xff1a;——使用前序遍历把结点元素放入数组中 题…
阅读更多...
寻找链表的中间节点

寻找链表的中间节点

问题描述&#xff1a; 给定一个头结点为head的非空单链表&#xff0c;返回链表的中间结点。如果有两个中间节点&#xff0c;则返回第二个中间结点&#xff0c;个数为奇数返回一个值&#xff0c;个数为偶数返回两个中间结点的第二个值。 思路&#xff1a; 用快慢指针来寻找中间…
阅读更多...
C实现的双向链表队列

C实现的双向链表队列

如下代码所示&#xff0c;一个头文件实现的双向链表&#xff0c;用c代码实现&#xff1a; #ifndef _LINUX_LIST_H #define _LINUX_LIST_H#include "stddef.h" #include "poison.h"#ifndef ARCH_HAS_PREFETCH #define ARCH_HAS_PREFETCH static inline voi…
阅读更多...
【LeeCode】链表总结

【LeeCode】链表总结

理论基础 链表的种类主要为&#xff1a;单链表&#xff0c;双链表&#xff0c;循环链表 链表的存储方式&#xff1a;链表的节点在内存中是分散存储的&#xff0c;通过指针连在一起。 链表是如何进行增删改查的。 数组和链表在不同场景下的性能分析。 经典题目 虚拟头节点 …
阅读更多...
剑指 Offer II 029. 排序的循环链表

剑指 Offer II 029. 排序的循环链表

题目链接 剑指 Offer II 029. 排序的循环链表 mid 题目描述 给定循环单调非递减列表中的一个点&#xff0c;写一个函数向这个列表中插入一个新元素 insertVal&#xff0c;使这个列表仍然是循环升序的。 给定的可以是这个列表中任意一个顶点的指针&#xff0c;并不一定是这个列…
阅读更多...
【算法基础】数据结构| 单链表+双链表 代码实现+图解+原理

【算法基础】数据结构| 单链表+双链表 代码实现+图解+原理

博主简介&#xff1a;努力学习的预备程序媛一枚~博主主页&#xff1a; 是瑶瑶子啦所属专栏: Java岛冒险记【从小白到大佬之路】 前言 因为瑶瑶子正在备战蓝桥杯和校内ACM选拔赛&#xff0c;最近在学习算法相关的知识。我是借助AcWing网站来学习的&#xff0c;这篇文章是我学习…
阅读更多...
leetcode刷题记录07（2023-04-30）【二叉树展开为链表 | 买卖股票的最佳时机 | 二叉树中的最大路径和(递归) | 最长连续序列(并查集)】

leetcode刷题记录07（2023-04-30）【二叉树展开为链表 | 买卖股票的最佳时机 | 二叉树中的最大路径和(递归) | 最长连续序列(并查集)】

114. 二叉树展开为链表 给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左子指针始终为 null 。 展开后的单链表应该与二叉树 先序遍历 顺…
阅读更多...
【leetcode100-028】【链表】两数相加

【leetcode100-028】【链表】两数相加

【题干】 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0c;这两个数都…
阅读更多...
力扣2807.在链表中插入最大公约数

力扣2807.在链表中插入最大公约数

思路&#xff1a;遍历链表&#xff0c;对于每一个结点求出它与下一个结点的最大公约数并插入到俩个结点之间 代码&#xff1a; /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}…
阅读更多...
Golang每日一练(leetDay0009)

Golang每日一练(leetDay0009)

目录 25. K 个一组翻转链表 Reverse-nodes-in-k-group &#x1f31f;&#x1f31f;&#x1f31f; 26. 删除有序数组中的重复项 Remove-duplicates-from-sorted-array &#x1f31f; 27. 移除元素 Remove Element &#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1…
阅读更多...
LeetCode 206 - 反转链表

LeetCode 206 - 反转链表

LeetCode 206 - 反转链表 题目描述 给定一个单链表的头节点 head&#xff0c;反转该链表并返回反转后的链表。 解题思路 我们可以使用迭代或递归的方式来反转链表。 迭代法 初始化三个指针 cur、pre 和 next。遍历链表&#xff0c;将 cur.next 指向 pre&#xff0c;然后将…
阅读更多...
数据结构：链表

数据结构：链表

1.单链表的逻辑结构与存储结构1.1逻辑结构逻辑结构&#xff1a;数据元素之间的逻辑关系集合、线性结构&#xff08;一对一&#xff09;、树形结构&#xff08;一对多&#xff09;、图结构&#xff08;多对多&#xff09;1.2存储结构存储结构&#xff1a;顺序存储、链式存储、索…
阅读更多...
HJ51 输出单向链表中倒数第k个结点

HJ51 输出单向链表中倒数第k个结点

描述 输入一个单向链表&#xff0c;输出该链表中倒数第k个结点&#xff0c;链表的倒数第1个结点为链表的尾指针。 链表结点定义如下&#xff1a; struct ListNode { int m_nKey; ListNode* m_pNext; }; 正常返回倒数第k个结点指针&#xff0c;异常返回空指针. 要求&#xff1…
阅读更多...
第34篇：Java集合框架API案例

第34篇：Java集合框架API案例

目录 1、容器Collection派生类代码示例 1.1 Vector ​​​​​​​1.2 ArrayList 1.3 LinkedList 1.4 HashSet
阅读更多...
详细介绍栈和队列，适合零基础小白反复使用【数据结构】

详细介绍栈和队列，适合零基础小白反复使用【数据结构】

文章目录栈栈的初始化压栈销毁出栈栈中有效元素个数判断栈是否为空拿到栈顶数据完整代码队列队列的初始化队尾入队列队列的销毁获取队列中有效元素个数判断队列是否为空获取队列头部元素获取队列尾部元素完整代码栈 栈&#xff1a;一种特殊的线性表&#xff0c;其只允许在固定的…
阅读更多...
【数据结构】11道LeetCode链表OJ练习

【数据结构】11道LeetCode链表OJ练习

文章目录1. 移除链表元素2. 反转链表3. 链表的中间节点4. 链表中倒数第k个节点5. 合并两个有序链表6. 链表分割7. 链表的回文结构8. 相交链表9. 环形链表10. 环形链表II11. 复制带随机指针的链表补充内容&#xff1a;浅谈顺序表和链表的区别1. 移除链表元素 移除链表元素OJ链接…
阅读更多...
Java集合

Java集合

一、集合概述 1、数组的特点 数组的大小是固定的&#xff0c;一旦创建后&#xff0c;数组的大小是无法改变的。数组只能存储相同类型的数据。数组查询效率高(有索引&#xff0c;元素内存连续分配)&#xff0c;增删效率低(不断的扩容)。 2、数组和集合的区别 相同点&#xff1…
阅读更多...
HashMap 正解

HashMap 正解

HashMap 实现原理 以及扩容机制 HashMap 的 put 以及扩容基本实现 数据结构 上述截图是 HashMap 的内部存储的数据结构。大体上是通过 hash 值来获取到对应的下标。如果当前下标为 null 的话&#xff0c;直接创建并设置一个新的节点&#xff0c;反之就是添加到该链表的最后 pu…
阅读更多...
【数据结构】7.2 线性表的查找

【数据结构】7.2 线性表的查找

文章目录7.2.1 顺序查找&#xff08;线性查找&#xff09;顺序查找算法设置监视哨的顺序查找顺序查找算法分析7.2.2 折半查找&#xff08;二分或对分查找&#xff09;折半查找算法折半查找性能分析 - 判定树7.2.3 分块查找分快查找算法分块查找算法分析及比较查找方法比较7.2.1…
阅读更多...
数据结构与算法——二叉树遍历、查找、删除、顺序存储二叉树、线索化二叉树

数据结构与算法——二叉树遍历、查找、删除、顺序存储二叉树、线索化二叉树

一、树的存储方式1.1 为什么需要树这种数据结构1.1.1 数组存储方式分析&#xff1a;优点&#xff1a;通过下标方式访问&#xff0c;速度快。对于有序数组&#xff0c;还可以使用二分查找提高检索效率缺点&#xff1a;如果要检索某个集体之或者插入值会整体移动&#xff0c;效率…
阅读更多...
Leetcode刷题之反转链表Ⅱ

Leetcode刷题之反转链表Ⅱ

业精于勤而荒于嬉&#xff0c;行成于思而毁于随。 ——韩愈目录 前言&#xff1a; &#x1f341;一.反转链表Ⅱ &#x1f352;1.left和right中间链表反转&#xff0c;再把反转链表和剩下的链接起来 &#x1f5fc;2.left和right中间链表头插 题目描述…
阅读更多...
【链表应用】| 一元多项式的操作

【链表应用】| 一元多项式的操作

目录 一. &#x1f981; 要求:二. 代码实现&#xff08;Java & c&#xff09;1. Java实现2.C语言实现 三. &#x1f981; 总结 一. &#x1f981; 要求: 设有两个一元多项式: p(x)p0p1xp2x2pnxn q(x)q0q1xq2x2qmxm 多项式项的系数为实数&#xff0c;指数为整数&#xff0c…
阅读更多...
【数据结构】-学习链表所需要的预备知识

【数据结构】-学习链表所需要的预备知识

知识点收集于网络&#xff0c;我会加以总结&#xff0c;如果把预备知识学好了。那么后面的操作就不难了 用节或者结都可以&#xff0c;不要在意字的差别 目录 一、头指针与头结点的概念 二、链表带头结点和不带头节点的区别 三、八大链表类型&#xff1a; 四、链表节点为…
阅读更多...
Python|Leetcode刷题日寄Part02

Python|Leetcode刷题日寄Part02

Python|Leetcode刷题日寄Part0101&#xff1a;探索插入位置02&#xff1a;整数反转03&#xff1a;在排序数组中查找元素的第一个和最后一个位置04&#xff1a;合并两个有序链表05&#xff1a;寻找两个正序数组的中位数06&#xff1a;最大子数组和07&#xff1a;最长公共前缀08&…
阅读更多...
【数据结构】Java实现队列与循环队列

【数据结构】Java实现队列与循环队列

目录 1. 概念 2. 队列的使用 3. 自己动手实现队列 3.1 MyQueue接口 3.2 LinkedQueue类 3.3 入队列 3.4 出队列 3.5 获取队头元素 3.6 获取队列中有效元素个数与检测队列是否为空 3.7 toString方法 4. 整体实现 4.1 LinkedQueue类 4.2 Test类 4.3 测试结果 5. 循…
阅读更多...
C语言自定义数据类型（四）用指针处理链表

C语言自定义数据类型（四）用指针处理链表

目录 一、什么是链表 1.1引入 1.2定义 二、建立简单的静态链表 2.1举例说明 三、建立动态链表 3.1举例说明 四、输出链表 4.1举例说明 一、什么是链表 1.1引入 链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。由前面的介绍中已知&#xff1a;用…
阅读更多...
浅谈HashTable, HashMap, ConcurrentHashMap 之间的区别

浅谈HashTable, HashMap, ConcurrentHashMap 之间的区别

大家好,今天为大家带来新的知识, HashTable, HashMap, ConcurrentHashMap 之间的区别 目录: &#x1f338;1.回忆hashmap &#x1f338; 2.比较HashTable,ConcurrentHashMap &#x1f338;3.总结HashTable, ConcurrentHashMap的区别 &#x1f338;4.一个历史小问题 &#x…
阅读更多...
静态链表常用操作（节点计数/查找/增加/删除）

静态链表常用操作（节点计数/查找/增加/删除）

1.封装计算链表节点个数的API 代码心得&#xff1a; cnt是count的缩写&#xff0c;用来计数。节点&#xff0c;我们一般指的是链表中数据的地址&#xff08;指针&#xff09;。比如节点1就是第一个结构体的地址&#xff0c;节点2就是第2个结构体的地址&#xff0c;以此类推。…
阅读更多...
【快乐手撕LeetCode题解系列】——环形链表

【快乐手撕LeetCode题解系列】——环形链表

【【快乐手撕LeetCode题解系列】——移除链表元素&#x1f60e;前言&#x1f64c;环形链表&#x1f64c;画图分析&#xff1a;&#x1f60d;思路分析&#xff1a;&#x1f60d;源代码分享&#xff1a;&#x1f60d;总结撒花&#x1f49e;&#x1f60e;博客昵称&#xff1a;博客…
阅读更多...
代码随想录算法训练营第四天|24 两两交换链表中的节点 19 删除链表的倒数第N个节点 面试题 02.07 链表相交 142 环形链表II

代码随想录算法训练营第四天|24 两两交换链表中的节点 19 删除链表的倒数第N个节点 面试题 02.07 链表相交 142 环形链表II

文章目录24 两两交换链表中的节点思路代码总结19 删除链表的倒数第N个节点思路代码总结面试题 02.07 链表相交思路代码总结142 环形链表II思路代码总结24 两两交换链表中的节点 思路 画图就可以明确实现思路 重点是如果只用一个指针会更方便更新位置&#xff0c;用多个指针可…
阅读更多...
【MySQL】InnoDB数据页结构

【MySQL】InnoDB数据页结构

一、页是什么 InnoDB 管理数据的基本单位&#xff0c;一个页大小一般是 16 KB 。 1. InnoDB 页的类型&#xff1a; 存放表空间头部的页、Insert Buffer 信息的页、 INODE 信息的页、undo 日志信息的页 、索引页&#xff08;数据页&#xff09; 二、页结构 也结构被分为 7 …
阅读更多...
HashMap的源码分析（基于JDK1.8）

HashMap的源码分析（基于JDK1.8）

HashMap的源码分析&#xff08;基于JDK1.8&#xff09; Java中的HashMap是一种常用的数据结构&#xff0c;它是基于哈希表的数据结构&#xff0c;可以用来存储键值对。在HashMap中&#xff0c;每个键值对被称作一个Entry&#xff0c;每个Entry包含一个键和一个值。HashMap的实…
阅读更多...
[C语言实现]带你手撕带头循环双链表

[C语言实现]带你手撕带头循环双链表

目录 什么是双链表&#xff1f; 带头结点的优势: 双链表的实现: 什么是循环双链表&#xff1f; 众所周知&#xff0c;顺序表的插入和删除有时候需要大量移动数据&#xff0c;并且每次开辟空间都可能会浪费大量内存和CPU资源&#xff0c;于是我们有了链表&#xff0c;我们之…
阅读更多...
leetcode 2.两数相加（链表操作）

leetcode 2.两数相加（链表操作）

题目描述跳转到leetcode 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0…
阅读更多...
【链表OJ题(一)】移除链表元素

【链表OJ题(一)】移除链表元素

​ ​&#x1f4dd;个人主页&#xff1a;Sherry的成长之路 &#x1f3e0;学习社区&#xff1a;Sherry的成长之路&#xff08;个人社区&#xff09; &#x1f4d6;专栏链接&#xff1a;数据结构 &#x1f3af;长路漫漫浩浩&#xff0c;万事皆有期待 文章目录链表OJ题(一)1. 移除…
阅读更多...
Java——》线性数据结构

Java——》线性数据结构

推荐链接&#xff1a; 总结——》【Java】 总结——》【Mysql】 总结——》【Redis】 总结——》【Kafka】 总结——》【Spring】 总结——》【SpringBoot】 总结——》【MyBatis、MyBatis-Plus】 总结——》【Linux】 总结——》【MongoD…
阅读更多...
【链表Linked List】力扣-82 删除链表中的重复元素II

【链表Linked List】力扣-82 删除链表中的重复元素II

目录 问题描述 解题过程 官方题解 问题描述 给定一个已排序的链表的头 head &#xff0c; 删除原始链表中所有重复数字的节点&#xff0c;只留下不同的数字 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,3,4,4,5] 输出&#xff1a;[1,2,5]示例…
阅读更多...
单链表详解

单链表详解

单链表一.概念二.一些类型的创建三.尾插四.头插五.头删尾删六.打印链表七.单链表查找,任意位置插入&#xff0c;任意位置删除八.源代码一.概念 该篇链表博客是按照工程项目的格式来记录的&#xff0c;与平常的算法链表有些许不同&#xff0c;注意区分。 二.一些类型的创建 三.尾…
阅读更多...
Java 数据结构篇-用链表、数组实现队列（数组实现：循环队列）

Java 数据结构篇-用链表、数组实现队列（数组实现：循环队列）

&#x1f525;博客主页&#xff1a; 【小扳_-CSDN博客】 ❤感谢大家点赞&#x1f44d;收藏⭐评论✍ 文章目录 1.0 队列的说明 1.1 队列的几种常用操作 2.0 使用链表实现队列说明 2.1 链表实现队列 2.2 链表实现队列 - 入栈操作 2.3 链表实现队列 - 出栈操作 2.4 链表实现队列 …
阅读更多...
条件语句（分支语句）——“Python”

条件语句（分支语句）——“Python”

各位CSDN的uu们你们好呀&#xff0c;最近总是感觉特别特别忙&#xff0c;但是却又不知道到底干了些什么&#xff0c;好像啥也没有做&#xff0c;还忙得莫名其妙&#xff0c;言归正传&#xff0c;今天&#xff0c;小雅兰的内容还是Python呀&#xff0c;介绍一些顺序结构的知识点…
阅读更多...
Hash冲突及解决办法

Hash冲突及解决办法

目录开放定址法线性探测再散列二次探测再散列伪随机探测再散列再哈希法链地址法&#xff08;拉链法&#xff09;建立公共溢出区开放定址法 这种方法也称再散列法&#xff0c;其基本思想是&#xff1a;当关键字key的哈希地址pH&#xff08;key&#xff09;出现冲突时&#xff0…
阅读更多...
【力扣】234.回文链表

【力扣】234.回文链表

嗯&#xff0c;今天这道题是我自己写的哦~&#xff0c;哒哒哒。今天还是很不错滴~ 234.回文链表 说一下我的解题思路&#xff0c;首先我的想法很简单就是将这个链表反转&#xff0c;然后将反转之后的链表与原链表进行对比。相等就返回true,不相等就返回false。所以我就想到了昨…
阅读更多...
【链表OJ题(七)】链表的回文结构

【链表OJ题(七)】链表的回文结构

​ ​&#x1f4dd;个人主页&#xff1a;Sherry的成长之路 &#x1f3e0;学习社区&#xff1a;Sherry的成长之路&#xff08;个人社区&#xff09; &#x1f4d6;专栏链接&#xff1a;数据结构 &#x1f3af;长路漫漫浩浩&#xff0c;万事皆有期待 文章目录链表OJ题(七)7. 链表…
阅读更多...
LeetCode - #82 删除排序链表中的重复元素 II

LeetCode - #82 删除排序链表中的重复元素 II

文章目录 前言1. 描述2. 示例3. 答案关于我们 前言 我们社区陆续会将顾毅&#xff08;Netflix 增长黑客&#xff0c;《iOS 面试之道》作者&#xff0c;ACE 职业健身教练。&#xff09;的 Swift 算法题题解整理为文字版以方便大家学习与阅读。 LeetCode 算法到目前我们已经更新…
阅读更多...
【带头学C++】----- 九、类和对象 ---- 9.12 C++之友元函数（9.12.5---9.12.7）

【带头学C++】----- 九、类和对象 ---- 9.12 C++之友元函数（9.12.5---9.12.7）

❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️创做不易&#xff0c;麻烦点个关注❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️ ❤️❤️❤️❤️❤️❤️❤️❤️❤️文末有惊喜&#xff01;献舞一支&#xff01;❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️ 补充上一节中…
阅读更多...
HOT24-回文链表

HOT24-回文链表

leetcode原题链接&#xff1a;回文链表 题目描述 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,2,1] 输出&#xff1a…
阅读更多...
数据结构 严蔚敏 版 线性链表c语言实现

数据结构 严蔚敏 版 线性链表c语言实现

LinkList.h typedef int ElemType; typedef int Status;typedef struct LNode {ElemType data;struct LNode * next;}LNode,*LinkList;//当第i个元素存在 把值 通过e返回 Status GetElem_L(LinkList, int, ElemType *);//元素插入 2.8 Status ListInsert_L(LinkList,int ,ElemT…
阅读更多...
力扣（203.1）补9.2

力扣（203.1）补9.2

203.移除链表元素 第二次做这题&#xff0c;会做&#xff0c;上次做还用的C语言呢。。。 class Solution { public ListNode removeElements(ListNode head, int val) { ListNode head2new ListNode(); ListNode pnew ListNode(); ListNode p2new ListNode(); phead; p2head2; …
阅读更多...
【Java 数据结构】双向链表

【Java 数据结构】双向链表

篮球哥温馨提示&#xff1a;编程的同时不要忘记锻炼哦&#xff01;圆圆的脑袋&#xff0c;大大耳朵&#xff0c;天天敲代码&#xff0c;找找找bug 目录 1、什么是双向链表 2、实现一个双向链表 2.1 实现前的约定 2.2 addFirst 方法 2.3 addLast 方法 2.4 addIndex 方法…
阅读更多...
【Java集合框架】篇四：Set接口

【Java集合框架】篇四：Set接口

1. Set及主要实现类特点 Set&#xff1a;无序、不可重复&#xff08;去重&#xff09;、存储value HashSet&#xff1a;底层使用HashMap&#xff0c;即使用 数组单项链表红黑树 结构进行存储。&#xff08;jkd8中&#xff09; LinkedHashSet&#xff1a;是HashSet的子类&…
阅读更多...
笔试中对链表题的总结

笔试中对链表题的总结

前言：链表中环的分析 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4iOeojOe-1677858146436)(…/…/data/images/circle.png)] 对于链表环的问题，潜在的一个结论是从快慢指针的相遇点到环的入口节点 B 的距离和头节点到环的入口节点 B 的距离是…
阅读更多...
【数据结构】从头到尾全解析双向链表

【数据结构】从头到尾全解析双向链表

在之前我们已经讲过< 单链表 >了,单链表查找上一个结点的时间复杂度为O&#xff08;n&#xff09;&#xff0c;尾插时也要遍历一次链表也是O&#xff08;n&#xff09;&#xff0c;因为我们每次都要从头开始遍历找,为了克服这单向性的缺点&#xff0c;我们就有了双向链表…
阅读更多...
队列的基本操作详细介绍 看了就会！！！

队列的基本操作详细介绍 看了就会！！！

文章目录 队列的介绍队列的概念队列的结构生活中队列的运用实例 队列的实现初始化队列队尾入队列队头出队列获取队列头部元素获取队列尾部元素判断队列是否为空获取队列中有效元素个数销毁队列 队列的介绍 队列的概念 队列&#xff1a;只允许在一端进行插入数据操作&#xff…
阅读更多...
【数据结构与算法】数据结构有哪些？算法有哪些？

【数据结构与算法】数据结构有哪些？算法有哪些？

1. 算法与数据结构总览图 2.常用的数据结构 2.1.数组&#xff08;Array&#xff09; 数组是一种聚合数据类型&#xff0c;它是将具有相同类型的若干变量有序地组织在一起的集合。数组可以说是最基本的数据结构&#xff0c;在各种编程语言中都有对应。一个数组可以分解为多个数…
阅读更多...
【STL】模拟实现list

【STL】模拟实现list

目录 1、list介绍 所要实现类及其成员函数接口总览 2、结点类的模拟实现 基本框架 构造函数 3、迭代器类的模拟实现 迭代器类存在的意义 3.1、正向迭代器 基本框架 默认成员函数 构造函数 运算符重载 --运算符重载 !运算符重载 运算符重载 *运算符重载 …
阅读更多...
LeetCode-旋转链表问题

LeetCode-旋转链表问题

旋转链表 题目描述&#xff1a; 给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 思路&#xff1a; 这里向右移动k个位置&#xff0c;相当于从链表的倒数第k个节点处断开&#xff0c;之后再将断开的两个子链表按照相反顺序链…
阅读更多...
【数据结构】双向带头循环链表

【数据结构】双向带头循环链表

本文总结讲解【双向带头循环链表】如何实现&#xff0c;以及各种功能的具体步骤详细过程。Ⅰ表的分类1.1单向或者双向1.2带头或者不带头1.3循环或者非循环Ⅱ.双向循环链表2.1生成一个新结点2.2初始化链表2.3链表尾插2.4链表尾删2.5链表的打印2.6链表的头插2.7链表的头删2.8链表…
阅读更多...
12、Go语言数据结构

12、Go语言数据结构

目录一、链表1 - 单向链表2 - 双向链表3 - 双向循环链表二、栈三、堆1 - 堆的概念2 - 堆的应用3 - 堆的实现一、链表 1 - 单向链表 单向链表 package mainimport "fmt"type Node struct {Info intNext *Node }type List struct {Head *NodeLen int }func (list …
阅读更多...
复制带随机指针的链表C语言——力扣138题

复制带随机指针的链表C语言——力扣138题

题目&#xff1a; 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节…
阅读更多...
顺序表和链表的优缺点

顺序表和链表的优缺点

这里说的链表是&#xff08;带头循环双向链表&#xff09;&#xff0c;下面我们就说一下他们的优缺点 首先顺序表 优点 1.支持随机访问 2.在O(1)的时间复杂度内&#xff0c;访问下标为i的位置。 3.很多算法的都必须用顺序表例如sort 4.缓存命中率高 缺点 1.每次容量满了…
阅读更多...
顺序表和链表的优缺点

顺序表和链表的优缺点

这里说的链表是&#xff08;带头循环双向链表&#xff09;&#xff0c;下面我们就说一下他们的优缺点 首先顺序表 优点 1.支持随机访问 2.在O(1)的时间复杂度内&#xff0c;访问下标为i的位置。 3.很多算法的都必须用顺序表例如sort 4.缓存命中率高 缺点 1.每次容量满了…
阅读更多...
算法小抄9-快慢指针

算法小抄9-快慢指针

在上一节我们已经讲过了怎么使用快慢指针去寻找链表的中点,这一节我们继续学习快慢指针的进阶用法,快慢指针不仅仅用在链表中,而是一种代码思想哦,好好体会吧 为了测试的方便我们先创建ListNode类,补充创建方法和打印方法: class ListNode:def __init__(self, val0, nextNone…
阅读更多...
跳表

跳表

文章目录跳表概念跳表的优点模拟实现跳表概念 跳表&#xff08;Skip List&#xff09;是一种基于链表实现的数据结构&#xff0c;它允许快速地查找、插入和删除元素&#xff0c;时间复杂度为 O(log n)。 跳表通过在链表中建立多级索引来实现快速查找。每一级索引中的元素都是前…
阅读更多...
二叉树和堆

二叉树和堆

二叉树和堆什么是树树的一些专业术语树的表示二叉树的概念什么是二叉树特殊的二叉树二叉树的性质堆的概念堆的表示方式堆的实现堆的初始化及销毁堆的插入堆的删除堆的判空与获取堆顶元素堆的主要应用堆排序利用堆数据结构建堆利用向上调整算法来建堆利用向下调整算法建堆TopK问…
阅读更多...
单链表反转-算法题0001

单链表反转-算法题0001

笔记 单链表反转最正规的解法是牛客网的官方解法的方法二。时间复杂度O(N),空间复杂度O(1)。第一遍读解法晕头转向&#xff0c;自己梳理了一遍&#xff0c;将重点用红字批注出来。 题想考察的是&#xff1a;如何调整链表指针&#xff0c;来达到反转链表的目的。 初始化&#xf…
阅读更多...
Qt之天气预报——界面优化篇（含源码+注释）

Qt之天气预报——界面优化篇（含源码+注释）

一、界面优化效果 下方为界面优化完成和优化前的效果对比。 优化前&#xff1a; 优化后&#xff1a; 二、优化内容 添加标题栏添加图片&#xff08;图图标素材源自阿里巴巴矢量图标库&#xff09;更新UI内容&#xff08;微调大小、布局比例&#xff09;添加鼠标事件函数&…
阅读更多...
算法提升 （三）基础数据结构

算法提升 （三）基础数据结构

作者&#xff1a;小萌新 专栏&#xff1a;算法提升 作者简介&#xff1a;大二学生 希望能够和大家一起进步&#xff01; 内容简介&#xff1a;简单介绍基本数据结构的简单面试题 不负韶华 链表 阅读这篇文章之前需要有初阶数据结构的基础 关于链表的结构如果还有不了解的同学…
阅读更多...
链表的学习：链表的头插法和尾插法以及HashMap中链表结点的插入方式

链表的学习：链表的头插法和尾插法以及HashMap中链表结点的插入方式

链表的学习&#xff1a;链表的头插法和尾插法以及HashMap中链表结点的插入方式 链表是一种常用的数据结构&#xff0c;它采用链式存储结构存储数据&#xff0c;相对于数组具有更灵活的操作和更高的效率。链表插入元素的方式有头插法和尾插法。 头插法 头插法是将新的结点插入…
阅读更多...
什么是跳表

什么是跳表

什么是跳表 跳表全称为跳跃列表&#xff0c;它允许快速查询&#xff0c;插入和删除一个有序连续元素的数据链表。跳跃列表的平均查找和插入时间复杂度都是O(logn)。快速查询是通过维护一个多层次的链表&#xff0c;且每一层链表中的元素是前一层链表元素的子集&#xff08;见右…
阅读更多...
北邮22信通：复习补充：双向链表的实现

北邮22信通：复习补充：双向链表的实现

北邮22信通一枚~ 跟随课程进度每周更新数据结构与算法的代码和文章 持续关注作者 解锁更多邮苑信通专属代码~ 获取更多文章 请访问专栏&#xff1a; 北邮22信通_青山如墨雨如画的博客-CSDN博客 **说明** 最近复习看到书后有双向链表的题目&#xff0c;编出来供大家…
阅读更多...
Java数据结构中栈和队列深度解析

Java数据结构中栈和队列深度解析

栈和队列使用的范围很广&#xff0c;本篇用来深度解析Java数据结构中的栈和队列的深度解析&#xff0c;栈和队列都能用单向或双向链表来实现哦&#xff0c;希望可以帮助各位&#xff01; 文章目录 目录 一、栈 1.1栈的概念 1.2栈的使用 1.3栈的自定义顺序栈实现 1.4栈的练习题…
阅读更多...
LeetCode 203. 移除链表元素

LeetCode 203. 移除链表元素

原题链接 难度&#xff1a;easy\color{Green}{easy}easy 题目描述 给你一个链表的头节点 headheadhead 和一个整数 valvalval &#xff0c;请你删除链表中所有满足 Node.valvalNode.val valNode.valval 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&a…
阅读更多...
golang 实现链表爽不爽？

golang 实现链表爽不爽？

犹记得刚学 C 语言的时候&#xff0c;学到指针这一章&#xff0c;就会有让我们写链表的需求&#xff0c;头插法&#xff0c;尾插法&#xff0c;翻转链表&#xff0c;合并链表&#xff0c;约瑟夫环等等 学的不亦乐乎&#xff0c;但是 对于指针刚学的时候&#xff0c;真是摸不着…
阅读更多...
数据结构：图的插入和删除

数据结构：图的插入和删除

线性表中我们把数据元素叫元素&#xff0c;树中将数据元素叫结点&#xff0c;在图中的数据元素我们称之为顶点&#xff08;Vertex&#xff09;。 线性表中可以没有数据元素&#xff0c;称之为空表。树中可以没有结点&#xff0c;叫做空树。但图没有空图。 线性表中&#xff0c;…
阅读更多...
【刷题之路】LeetCode 21. 合并两个有序链表

【刷题之路】LeetCode 21. 合并两个有序链表

【刷题之路】LeetCode 21. 合并两个有序链表 1、题目描述二、解题1、方法1——直接合并1.1、思路分析1.2、代码实现 2、方法2——递归2.1、思路分析2.2、代码实现 1、题目描述 原题连接&#xff1a; 21. 合并两个有序链表 题目描述&#xff1a; 将两个升序链表合并为一个新的 …
阅读更多...
ArrayList和LinkedList区别

ArrayList和LinkedList区别

List<TreeNode> list new ArrayList<TreeNode>(); List<TreeNode> allTrees new LinkedList<TreeNode>(); 这两行代码都是用来创建一个存储多个 TreeNode 对象的列表&#xff0c;但是它们使用的底层实现不同。 ArrayList 是一种数组实现的动态数组&…
阅读更多...
[失业前端恶补算法]JavaScript leetcode刷题top100（三）：相交链表、多数元素、反转链表、翻转二叉树、回文链表

[失业前端恶补算法]JavaScript leetcode刷题top100（三）：相交链表、多数元素、反转链表、翻转二叉树、回文链表

专栏声明&#xff1a;只求用最简单的&#xff0c;容易理解的方法通过&#xff0c;不求优化&#xff0c;不喜勿喷 今天更新五个 easy 难度题目&#xff1a; 相交链表 题面 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个…
阅读更多...
【拳打蓝桥杯】一眼看破五花八门的链表结构

【拳打蓝桥杯】一眼看破五花八门的链表结构

文章目录&#x1f4d5;一&#xff1a;五花八门的链表结构&#x1f4d6;链表与数组的简单对比&#x1f4d6;单链表&#x1f4d6;循环链表&#x1f4d6;双向链表&#x1f4d5;二&#xff1a;链表VS数组性能大比拼&#x1f47f;最后说一句&#x1f431;‍&#x1f409;作者简介&am…
阅读更多...
双向链表的增删改查

双向链表的增删改查

1.双向链表的定义 单向链表特点&#xff1a;   1.我们可以轻松的到达下一个节点, 但是回到前一个节点是很难的.   2.只能从头遍历到尾或者从尾遍历到头(一般从头到尾) 双向链表特点   1.每次在插入或删除某个节点时, 需要处理四个节点的引用, 而不是两个. 实现起来要困难…
阅读更多...
C语言实现单链表（超多配图，这下不得不学会单链表了）

C语言实现单链表（超多配图，这下不得不学会单链表了）

目录 一&#xff1a;什么是链表&#xff1f; 二&#xff1a;创建源文件和头文件 (1)头文件 (2)源文件 三&#xff1a;实参和形参 四&#xff1a;一步步实现单向链表 &#xff08;1&#xff09;建立一个头指针并置空 &#xff08;2&#xff09;打印链表&#xff0c;便于…
阅读更多...
【数据结构】二叉排序树大题（二叉排序树的构建，及平均查找长度ASL）

【数据结构】二叉排序树大题（二叉排序树的构建，及平均查找长度ASL）

记录一下数据结构大题啊&#xff0c;在大题里面经常会有一个二叉排序树。题目中会给出一组结点&#xff0c;然后让你写出二叉排序树的构建过程&#xff0c;计算查找成功平均查找长度&#xff08;asl&#xff09;和查找成功平均查找长度。 二叉排序树**二叉排序树****二叉排序树…
阅读更多...
C语言--自定义类型详解

C语言--自定义类型详解

目录结构体结构体的声明特殊的声明结构的自引用typedef的使用结构体变量的定义和初始化结构体的内存对齐为什么存在内存对齐&#xff1f;修改默认对齐数结构体传参位段位段的内存分配位段的跨平台问题枚举联合联合类型的定义联合在内存中开辟空间联合大小的计算结构体 结构体的…
阅读更多...
算法练习-堆

算法练习-堆

1. 堆的定义和存储 堆必须是一个完全二叉树堆中的每个节点的值必须大于等于或者小于等于子树中每个节点的值 如果堆中每个节点的值都大于等于子树中每个节点的值&#xff0c;这种堆叫做大根堆 如果堆中每个节点的值都小于等于子树中每个节点的值&#xff0c;这种堆叫做小根堆…
阅读更多...
【算法基础】(二)数据结构 --- 单链表

【算法基础】(二)数据结构 --- 单链表

✨个人主页&#xff1a;bit me ✨当前专栏&#xff1a;算法基础 &#x1f525;专栏简介&#xff1a;该专栏主要更新一些基础算法题&#xff0c;有参加蓝桥杯等算法题竞赛或者正在刷题的铁汁们可以关注一下&#xff0c;互相监督打卡学习 &#x1f339; &#x1f339; &#x1f3…
阅读更多...
73-归并排序练习-LeetCode148排序链表

73-归并排序练习-LeetCode148排序链表

题目 给你链表的头结点 head &#xff0c;请将其按升序排列并返回排序后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [4,2,1,3] 输出&#xff1a;[1,2,3,4] 示例 2&#xff1a; 输入&#xff1a;head [-1,5,3,4,0] 输出&#xff1a;[-1,0,3,4,5] 示例 3&#xff…
阅读更多...
C和指针（九）链表和指向指针的指针

C和指针（九）链表和指向指针的指针

链表 1&#xff0c;链表是包含数据的独立数据结构的集合&#xff0c;链表中每个节点通过指针连接在一起&#xff0c;通常节点是动态分配的。 1&#xff09;单链表中每个节点包含一个指向下一节点的指针&#xff0c;链表最后一个节点的指针为NULL。 2&#xff09;链表中的节点可…
阅读更多...
Java基础之LinkedList

Java基础之LinkedList

文章目录一、LinkedList介绍二、LinkedList特有方法 LinkedList应知应会2.1 调用addFirst() 方法在集合头部插入数据2.2 调用addLast() 方法在集合尾部追加数据2.3 调用getFirst() 方法获取集合第一个元素并返回元素值2.4 调用getLast() 方法获取集合最后一个元素并返回元素值2…
阅读更多...
Set是如何保证元素不重复的

Set是如何保证元素不重复的

Set是如何保证元素不重复的Set是如何保证元素不重复的典型回答知识扩展HashSet&#xff0c;TreeSet&#xff0c;LinkedHashSet&#xff0c;BitSet有何区别什么是BitSet&#xff1f;有什么作用&#xff1f;Set是如何保证元素不重复的 典型回答 在Java的Set体系中&#xff0c;根…
阅读更多...
LeetCode 1019. Next Greater Node In Linked List【单调栈模板】中等

LeetCode 1019. Next Greater Node In Linked List【单调栈模板】中等

本文属于「征服LeetCode」系列文章之一&#xff0c;这一系列正式开始于2021/08/12。由于LeetCode上部分题目有锁&#xff0c;本系列将至少持续到刷完所有无锁题之日为止&#xff1b;由于LeetCode还在不断地创建新题&#xff0c;本系列的终止日期可能是永远。在这一系列刷题文章…
阅读更多...
代码随想录算法训练营总结篇

代码随想录算法训练营总结篇

通过本次为期两个月的算法训练使自己对于算法中一些名词有了更加深刻的理解。接下来我将按照这段时间的算法题目做一个总结。 在进入算法训练之前首先应对时间复杂度和空间复杂度有一个认识&#xff0c;我们在完成一道代码题后&#xff0c;对其进行优化的前提是可以从目前已完…
阅读更多...
【Java数据结构——环形链表】判断链表成环与寻找链表成环的入口节点(经典)

【Java数据结构——环形链表】判断链表成环与寻找链表成环的入口节点(经典)

判断链表是否成环https://leetcode.cn/problems/linked-list-cycle/description/ 解题核心思路&#xff1a; 定义快慢指针初始引用指向链表的头节点&#xff0c;快指针每向后走两步&#xff0c;慢指针走一步。如果链表中存在环&#xff0c;则快慢指针一定会在某次移动后相遇。 …
阅读更多...
一文了解Java ArrayList （源码逐行解析）

一文了解Java ArrayList （源码逐行解析）

介绍 ArrayList 是最常用的 List 实现类&#xff0c;内部是通过数组实现的&#xff0c;它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔&#xff0c;当数组大小不满足时需要增加存储能力&#xff0c;就要将已经有数组的数据复制到新的存储空间中。当从 Arr…
阅读更多...
ACM模式的C++反转链表【键盘输入】

ACM模式的C++反转链表【键盘输入】

反转链表 206. 反转链表 - 力扣&#xff08;LeetCode&#xff09; 题目描述 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&#xff1a; 输…
阅读更多...
【代码随想录】刷题Day14

【代码随想录】刷题Day14

递归实现的一些理解 1.如果是链表的遍历其实不需要怎么思考&#xff1b;无非就是先定参数然后考虑是先操作后遍历还是先走到底再操作。 包括我之前在写链表的节点删除其实核心思路就是由于链表前面删除后面找不到的原理&#xff0c;以至于我们需要走到链表的底部再进行操作。 2…
阅读更多...
LeetCode第2题——两数相加（Java）

LeetCode第2题——两数相加（Java）

题目描述&#xff1a; ​ 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 ​ 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 ​ 你可以假设除了数字 0 之外…
阅读更多...
数据结构初阶--链表OJ

数据结构初阶--链表OJ

目录 前言移除链表元素思路分析代码实现 链表的中间节点思路分析代码实现 反转链表思路分析代码实现 链表分割思路分析代码实现 合并两个有序链表思路分析代码实现 前言 本篇文章将对部分单链表的OJ题进行讲解 移除链表元素 我们先来看题 思路分析 我们可以采用双指针的方…
阅读更多...
list_for_each_entry()函数分析

list_for_each_entry()函数分析

在Linux内核源码中&#xff0c;经常要对链表进行操作&#xff0c;其中一个很重要的宏是list_for_each_entry&#xff1a; /*** list_for_each_entry - iterate over list of given type* pos: the type * to use as a loop cursor.* head: the head for your list.* member: t…
阅读更多...
LeetCode 链表OJ分享

LeetCode 链表OJ分享

目录 删除排序链表中的重复元素回文链表剑指Offer 06.从尾到头打印链表复制带随机指针的链表 删除排序链表中的重复元素 链接: link 题目描述&#xff1a; 题目思路&#xff1a; 本题思路使用双指针&#xff0c;以示例二为例如下图&#xff1a; 如果head->val等于next-&…
阅读更多...
数据结构——带头双向循环链表实现

数据结构——带头双向循环链表实现

目录 前言 一、结构介绍 二、增删查改的实现 1.在某一位置前插入数据 2.头插 3.尾插 4.删除某一位置的节点 5.头删 6.尾删 7.查找 8.打印 9.销毁 三、完整项目代码 1.头文件(List.h) 2.函数文件(List.c) 3.主函数测试文件(test.c) 前言 在学习数据结构过程中&…
阅读更多...
图解LeetCode——142. 环形链表 II

图解LeetCode——142. 环形链表 II

一、题目 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统…
阅读更多...
【数据结构】--单链表力扣面试题②反转链表

【数据结构】--单链表力扣面试题②反转链表

目录 法一&#xff1a;直接反转法 法二&#xff1a;头插法 题述&#xff1a;给你单链表的头结点head&#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 题目已知链表创建&#xff0c;并给了reverseList的函数头。 struct ListNode* reverseList(struct ListNode* he…
阅读更多...
队列——“数据结构与算法”

队列——“数据结构与算法”

各位CSDN的uu们你们好呀&#xff0c;又好久不见啦&#xff0c;最近有点摆烂&#xff0c;甚是惭愧&#xff01;&#xff01;&#xff01;&#xff01;今天&#xff0c;小雅兰的内容是队列&#xff0c;下面&#xff0c;让我们进入队列的世界吧&#xff01;&#xff01;&#xff0…
阅读更多...
Leetcode.1019 链表中的下一个更大节点

Leetcode.1019 链表中的下一个更大节点

题目链接 Leetcode.1019 链表中的下一个更大节点 Rating &#xff1a; 1571 题目描述 给定一个长度为 n 的链表 head 对于列表中的每个节点&#xff0c;查找下一个 更大节点 的值。也就是说&#xff0c;对于每个节点&#xff0c;找到它旁边的第一个节点的值&#xff0c;这个节…
阅读更多...
实现链表与哈希表相结合的快速表

实现链表与哈希表相结合的快速表

设计可以变更的缓存结构&#xff1a;该结构在构造时确定大小&#xff0c;假设长度 len&#xff0c;且有两个功能&#xff1a; int set&#xff08;string key&#xff0c;int value&#xff09;&#xff1a;将记录&#xff08;key&#xff0c;value&#xff09;插入该结构 int …
阅读更多...
力扣每日一题：61. 旋转链表

力扣每日一题：61. 旋转链表

目录题目&#xff1a;61. 旋转链表示例1示例2提示解题思路解题代码解题感悟题目&#xff1a;61. 旋转链表 难度&#xff1a; 中等 题目&#xff1a; 给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 示例1 输入&#xff1a;h…
阅读更多...
双指针算法的高级用法及示例

双指针算法的高级用法及示例

双指针是一种常用的算法技巧&#xff0c;通常用于数组或链表的操作中。在一些情况下&#xff0c;我们可能需要使用双指针的高级用法来解决问题。在本文中&#xff0c;我将介绍双指针的高级用法&#xff0c;并提供一些 JavaScript 示例代码来帮助你理解。 快慢指针 快慢指针是…
阅读更多...
C语言学习笔记—链表（二）链表的静态添加及动态遍历

C语言学习笔记—链表（二）链表的静态添加及动态遍历

链表的静态添加及动态遍历 我们知道数组中的数据存储是有序的&#xff0c;而链表中的数据是无序的但是存在某种联系使之组成链表。 那么我们如果向一组数据中添加一个数据元素&#xff0c;对与数组来说比较的费劲&#xff0c;若是越界还得需要重新申请空间等方式满足数据元素的…
阅读更多...
【牛客算法BM2】 链表内指定区间反转

【牛客算法BM2】 链表内指定区间反转

​ 你好&#xff0c;欢迎来到我的博客&#xff01;作为一名程序员&#xff0c;我经常刷LeetCode题目来提升自己的编程能力。在我的博客里&#xff0c;我会分享一些我自己做过的题目和解题思路&#xff0c;希望能够帮助到大家。今天&#xff0c;我想和大家分享一道挑战性较高的题…
阅读更多...
【Leetcode -817.链表组件 -1019.链表中的下一个更大节点】

【Leetcode -817.链表组件 -1019.链表中的下一个更大节点】

Leetcode Leetcode -817.链表组件Leetcode -1019.链表中的下一个更大节点 Leetcode -817.链表组件 题目&#xff1a;给定链表头结点 head&#xff0c;该链表上的每个结点都有一个 唯一的整型值 。同时给定列表 nums&#xff0c;该列表是上述链表中整型值的一个子集。 返回列表…
阅读更多...
LeetCode单链表OJ题目做题思路分享

LeetCode单链表OJ题目做题思路分享

目录 移除链表元素链表的中间节点链表中倒数第K个节点合并两个有序链表 移除链表元素 链接: link 题目描述&#xff1a; 思路分享&#xff1a; 我们上个博客分享了第一种方法&#xff0c;下面我们分析第二种方法&#xff1a;思路就是将每一个不等于我们要删除的值的节点依次尾…
阅读更多...
两个链表相加

两个链表相加

描述 假设链表中每一个节点的值都在 0 - 9 之间&#xff0c;那么链表整体就可以代表一个整数。 给定两个这种链表&#xff0c;请生成代表两个整数相加值的结果链表。 数据范围&#xff1a;0≤n,m≤1000000&#xff0c;链表任意值 0≤val≤9 要求&#xff1a;空间复杂度 O(n)…
阅读更多...
Leetcode刷题之回文链表和交换链表中的结点

Leetcode刷题之回文链表和交换链表中的结点

竭力履行你的义务&#xff0c;你应该就会知道&#xff0c;你到底有多大的价值。 --列夫.托尔斯泰 目录 &#x1fab4;一.回文链表 &#x1f33b;1.快慢指针 &#x1f341;2.把值存入数组中&#xff0c;然后使用双指针 &#x1f33c;二.交换链表中的结点 &#x1…
阅读更多...
5ATM防水等级是什么意思？手表防水等级讲解

5ATM防水等级是什么意思？手表防水等级讲解

防水等级定义适用范围IPX7可承受意外接触深达 1 米的水流长达 30 分钟溅湿、雨雪、淋浴IPX6可承受强力水流喷射。通过 12.5 毫米喷嘴以 100 升/分钟的流速在 100 千牛/平方米的压力下从距离 3 米的位置向各个角度持续喷射水流 3 分钟坚冻喷雾、倾盆大雨、洗船、恶劣海况下户外使…
阅读更多...
模板类封装(1)——单链表

模板类封装(1)——单链表

加入了ReverseList函数&#xff0c;逆转单链表操作 改了个bug&#xff0c;逆转链表时特判一个结点的情况 又改了N个bug&#xff0c;特判空链表的情况 试试模板类加上数据结构 肯定还是会有遗漏的地方的&#xff0c;欢迎指正 不多说&#xff0c;上代码 ps:nullptr是c11特性&…
阅读更多...
LeetCode刷题笔记 Java 腾讯 链表突击 二叉搜索树的最近公共祖先

LeetCode刷题笔记 Java 腾讯 链表突击 二叉搜索树的最近公共祖先

题目 官解 给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。 百度百科中最近公共祖先的定义为&#xff1a;“对于有根树 T 的两个结点 p、q&#xff0c;最近公共祖先表示为一个结点 x&#xff0c;满足 x 是 p、q 的祖先且 x 的深度尽可能大&#xff08;一个节点也…
阅读更多...
队列：数据结构中的排队之道

队列：数据结构中的排队之道

本篇博客会讲解队列这种数据结构&#xff0c;并使用C语言实现。 概况 什么是队列呢&#xff1f;队列是一种先进先出的数据结构&#xff0c;即First In First Out&#xff0c;简称FIFO。队列有2端&#xff0c;分别是队头和队尾&#xff0c;规定只能在队尾插入数据&#xff08;…
阅读更多...
循环队列(C++)

循环队列(C++)

循环队列是一种特殊的队列实现&#xff0c;在顺序队列的基础上进行了优化。通常&#xff0c;循环队列使用固定长度的数组来表示队列元素&#xff0c;头和尾指针挂钩形成循环的维度感知队列长度&#xff0c;并提高队列操作效率&#xff0c;因为这种结构需要的内存量比链表数据结…
阅读更多...
【JavaSE】Java基础语法(十三)：Java 中的集合（十分全面）

【JavaSE】Java基础语法(十三)：Java 中的集合（十分全面）

文章目录 List, Set, Queue, Map 四者的区别&#xff1f;集合框架底层数据结构总结ArrayList 和 Vector 的区别ArrayList 与 LinkedList 区别补充内容:RandomAccess 接⼝ArrayList 的扩容机制comparable 和 Comparator 的区别比较 HashSet、LinkedHashSet 和 TreeSet 三者的异同…
阅读更多...
【数据结构与算法】3、虚拟头节点、动态数组的缩容、动态数组和单链表的复杂度、数组的随机访问

【数据结构与算法】3、虚拟头节点、动态数组的缩容、动态数组和单链表的复杂度、数组的随机访问

目录 一、虚拟头节点二、数组的随机访问三、动态数组、链表复杂度分析四、动态数组 add(E element) 复杂度分析五、动态数组的缩容 一、虚拟头节点 &#x1f33c; 为了让代码更加精简&#xff0c;统一所有节点的处理逻辑&#xff0c;可以在最前面增加一个虚拟的头节点&#xf…
阅读更多...
判断B链表是否为A链表的子序列

判断B链表是否为A链表的子序列

判断B链表是否为A链表的子序列 类似与字符串中判断是否为子串问题,从两个链表的第一个结点开始,若对应数据相等,则指针后移,若对应数据不等,则A链表从上次开始比较结点后继开始,B仍然从第一个结点开始比较 实现代码 #include <stdio.h> #include <stdlib.h> #incl…
阅读更多...
链表重构(两个经典例题)

链表重构(两个经典例题)

题目一 将链表{a1,b1,a2,b2,a3,b3…an,bn}转换为{a1,a2…an}、{bn,bn-1…b1}b为逆序(逆序使用头插法) 解题思路 #include <stdio.h> #include <stdlib.h> #include<stdbool.h>typedef int Elemtype;typedef struct LNode {Elemtype data;struct LNode *next…
阅读更多...
递归删除链表中值为X的结点

递归删除链表中值为X的结点

递归删除链表中值为X的结点 在递归方法中传入,当前结点,和它的前驱结点pre,如果当前结点cur的值data为x,则删除当前结点,pre->nextcur->next,不然继续向下递归 实现代码 #include <stdio.h> #include <stdlib.h> #include<stdbool.h>typedef int Elem…
阅读更多...
单链表操作大全(C语言)

单链表操作大全(C语言)

#include <stdio.h> #include <stdlib.h> #include<stdbool.h>typedef int Elemtype;//单链表typedef struct LNode {Elemtype data;//存放数据struct LNode *next; //指向LNode的一个指针} LNode,*LinkList; //相当于取别名,LNode代表一个节点,LinkList代表…
阅读更多...
数据结构--耿国华版（课设2）---单链表的遍历、逆置、排序、合并、插入删除

数据结构--耿国华版（课设2）---单链表的遍历、逆置、排序、合并、插入删除

要求&#xff1a; 1.编写函数,实现随机产生或键盘输入一组元素,建立一个带头结点的单链表&#xff08;无序&#xff09; 2.编写函数,实现遍历单链表 3.编写函数,实现把单向链表中元素逆置 4.编写函数,建立一个非递减有序单链表 5.编写函数,利用以上算法&#xff0c;建立两个非…
阅读更多...
第三期：那些年，我们一起经历过的链表中的浪漫

第三期：那些年，我们一起经历过的链表中的浪漫

PS&#xff1a;每道题解题方法不唯一&#xff0c;欢迎讨论&#xff01;每道题后都有解析帮助你分析做题&#xff0c;答案在最下面&#xff0c;关注博主每天持续更新。 1. 两个链表的第一个公共节点 “我走过我的世界&#xff0c;再从你的世界走一遍” “你走过你的世界&#x…
阅读更多...
顺序表 链表 队列 堆 栈 二叉搜索树 哈希表 图 这些数据结构 的应用场景

顺序表 链表 队列 堆 栈 二叉搜索树 哈希表 图 这些数据结构 的应用场景

顺序表&#xff1a;一种线性表&#xff0c;用一组连续的存储单元依次存储数据元素 顺序表可以用于实现数组&#xff0c;支持随机访问&#xff0c;但插入和删除操作需要移动大量元素&#xff0c;效率较低 顺序表适用于元素个数比较稳定的场景&#xff0c;不适用于元素个数经常变…
阅读更多...
java 删除链表中所有的重复元素

java 删除链表中所有的重复元素

牛客题目链接 1. 题目考点 使用哑结点链表节点删除 2. 考点解析 public ListNode deleteDuplicates (ListNode head) {// write code hereif (head null) return null;ListNode newHead new ListNode(0);newHead.next head;ListNode p head, pre newHead;while (p ! n…
阅读更多...
java 合并 k 个已排序的链表

java 合并 k 个已排序的链表

牛客题目链接 1. 题目考点 归并排序merge 函数三种形式PriorityQueue 2. 考点解析 使用 ArrayList&#xff0c;排序再插入 &#xff08;投机取巧&#xff0c;面试千万不可&#xff09; public ListNode mergeKLists(ArrayList<ListNode> lists) {ArrayList<Integ…
阅读更多...
进阶实验2-3.3 两个有序链表序列的交集

进阶实验2-3.3 两个有序链表序列的交集

已知两个非降序链表序列S1与S2&#xff0c;设计函数构造出S1与S2的交集新链表S3。 输入格式: 输入分两行&#xff0c;分别在每行给出由若干个正整数构成的非降序序列&#xff0c;用−1表示序列的结尾&#xff08;−1不属于这个序列&#xff09;。数字用空格间隔。 输出格式:…
阅读更多...
LeetCode 面试题 02.07. 链表相交

LeetCode 面试题 02.07. 链表相交

原题目&#xff1a;https://leetcode-cn.com/problems/intersection-of-two-linked-lists-lcci/ 思路&#xff1a; 按引用相等&#xff0c;可以使用判别。 代码&#xff1a; class Solution { public:ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {List…
阅读更多...
LeetCode 24. Swap Nodes in Pairs

LeetCode 24. Swap Nodes in Pairs

原题目&#xff1a;https://leetcode-cn.com/problems/swap-nodes-in-pairs/ 思路&#xff1a; 尾插法修改指针。 没次保持修改的子链表状态为prev->head->tail->nex。交换head和tail&#xff0c;然后在接入到prev和nex之间。 更新上面四个指针&#xff0c;因为要从…
阅读更多...
删除单链表中最后一个与给定值相等的结点

删除单链表中最后一个与给定值相等的结点

本题要求在链表中删除最后一个数据域取值为x的节点。L是一个带头结点的单链表&#xff0c;函数ListLocateAndDel_L(LinkList L, ElemType x)要求在链表中查找最后一个数据域取值为x的节点并将其删除。例如&#xff0c;原单链表各个节点的数据域依次为1 3 1 4 3 5&#xff0c;则…
阅读更多...
递增的整数序列链表的插入

递增的整数序列链表的插入

链表插入 编程实现&#xff1a;输入一个正整数 n(0<n<9)和一组(n个)升序的整数&#xff0c;建立单向链表&#xff0c;再输入一个整数 x&#xff0c;把 x 插入到这组数据中&#xff0c;使该组数据仍然有序。 输入样例&#xff1a; 5 (数据的个数n5) 1 2 4 5 7 (5个有序整…
阅读更多...
数据结构与算法之链表: Leetcode 83. 删除排序链表中的重复元素 (Typescript版)

数据结构与算法之链表: Leetcode 83. 删除排序链表中的重复元素 (Typescript版)

删除排序链表中的重复元素 https://leetcode.cn/problems/remove-duplicates-from-sorted-list/ 描述 给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的链表 示例 1 输入&#xff1a;head [1,1,2] 输出&…
阅读更多...
算法刷题-关于链表，你该了解这些！

算法刷题-关于链表，你该了解这些！

关于链表&#xff0c;你该了解这些&#xff01; 什么是链表&#xff0c;链表是一种通过指针串联在一起的线性结构&#xff0c;每一个节点由两部分组成&#xff0c;一个是数据域一个是指针域&#xff08;存放指向下一个节点的指针&#xff09;&#xff0c;最后一个节点的指针域…
阅读更多...
统计二叉树节点

统计二叉树节点

用C语言或C给出二叉树的二叉链表存储结构的定义&#xff0c;并设计一个在链式存储结构上统计二叉树中节点个数的递归算法。 (就是个二叉树遍历) typedef int ElemType; typedef struct Node {struct Node *lchild;ElemType data;struct Node *rchild; /* data */ }Tree;void…
阅读更多...
FreeRTOS使用总结

FreeRTOS使用总结

序言 在实际开发中&#xff0c;如果程序等待一个事件发生&#xff0c;传统的无RTOS情况下&#xff0c;要么在原地一直等待而不能执行其它任务&#xff0c;要么使用状态机机制处理。而RTOS提供事件驱动型设计方式&#xff0c;只是在处理实际任务时才会运行&#xff0c;这能够更合…
阅读更多...
顺序表知识点

顺序表知识点

目录 本章重点 一 线性表 二 顺序表 2.1 概念和结构 2.2 接口实现 2.3 数组相关面试题 2.4 顺序表的问题 行动是打败焦虑最好的方法 本章重点 &#xff08;1&#xff09;线性表&#xff08;2&#xff09;顺序表 一 线性表 线性表 &#xff08; linear list &#xff09…
阅读更多...
优先队列的详解（包含优先队列的初级实现以及堆的实现方式）

优先队列的详解（包含优先队列的初级实现以及堆的实现方式）

优先队列一、优先队列的概念二、优先队列的API三、优先队列的初级实现&#xff08;一&#xff09;、数组实现&#xff08;无序&#xff09;&#xff08;二&#xff09;、数组实现&#xff08;有序&#xff09;&#xff08;三&#xff09;、链表表示法&#xff08;四&#xff09…
阅读更多...
《代码随想录》(7)设计链表

《代码随想录》(7)设计链表

LeeCode题号&#xff1a; 707 【题目描述】 你可以选择使用单链表或者双链表&#xff0c;设计并实现自己的链表。 单链表中的节点应该具备两个属性&#xff1a;val 和 next 。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。 如果是双向链表&#xff0c;则…
阅读更多...
C语言实现双向链表和迭代器

C语言实现双向链表和迭代器

目录 概述 访问接口定义 创建和销毁链表 创建和销毁链表结点 顺序访问链表 逆序访问链表 插入和删除结点 链表反序 数据结构定义 迭代器 链表结点 链表 用户结点 用户使用代码 使用示例&#xff1a; 运行结果&#xff1a; 用户数据代码&#xff1a; 接口定义…
阅读更多...
Java实现单链表及其基本操作

Java实现单链表及其基本操作

目录 什么是单链表&#xff1f; 带头结点的单链表 不带头结点的单链表 模拟实现不带头结点的单链表 定义结点类 初始化 头插法创建单链表 尾插法创建单链表 打印单链表 单链表的查找 获取单链表的长度 按位置寻找前驱结点 单链表的插入 修改指定位置的值 按…
阅读更多...
力扣刷题记录（一）剑指Offer（第二版）

力扣刷题记录（一）剑指Offer（第二版）

1、本栏用来记录社招找工作过程中的内容，包括基础知识学习以及面试问题的记录等，以便于后续个人回顾学习； 暂时只有2023年3月份，第一次社招找工作的过程； 2、个人经历： 研究生期间课题是SLAM在无人机上的应用，有接触SLAM、Linux、ROS、C/C++、DJI OSDK等； 3、参加工作后…
阅读更多...
C语言/C++实现链表的详细教程

C语言/C++实现链表的详细教程

C语言/C实现链表的详细教程 1. 什么是链表 链表是一种常用的数据结构&#xff0c;它由一系列节点组成&#xff0c;每个节点包含两部分内容&#xff1a;数据和指向下一个节点的指针,最后一个节点指向空。链表的节点可以动态添加和删除&#xff0c;因此可以方便地进行插入、删除…
阅读更多...
408数据结构第二章

408数据结构第二章

线性表 定义和基本操作顺序表的定义和操作线性表的链式表示顺序表和链表的比较 定义和基本操作 线性表是具有相同数据类型的n个数据元素的有限序列 每个元素有且仅有一个直接前驱直接后继 线性表是一种逻辑结构&#xff0c;表示元素之间一对一的相邻关 顺序表和链表是指存储结…
阅读更多...
list的模拟实现

list的模拟实现

第一步&#xff1a;看源代码 类的框架&#xff1a; 成员函数&#xff1a; 基本可以确定list是一个带头双向循环链表&#xff0c;end()的迭代器指向头节点&#xff0c;begin()的迭代器指向头结点的下一个节 list的迭代器&#xff1a;&#xff08;稍显复杂&#xff09; 库中的迭代…
阅读更多...
C语言学习笔记集合

C语言学习笔记集合

C语言学习笔记—环境搭建、基础框架解释 C语言学习笔记—变量、C程序的输入输出 C语言学习笔记—表达式、选择语句&#xff08;分支、分支嵌套、多分支&#xff09; C语言学习笔记—循环控制语句&#xff08;while、for、do…while&#xff09; C语言学习笔记—函数的定义、调用…
阅读更多...
哈希表-linux链表-7

哈希表-linux链表-7

哈希表是一种单链表&#xff0c;但是比单链表多了个pprev。 这个pprev是二级指针&#xff0c;用于保存前一个节点->next的地址。 这样就有点类似双链表了。姑且当做1.5链表吧。。。。 pprev用法&#xff1a; *本节点->pprev &前一节点->next 理解了pprev&…
阅读更多...
LIST_POISON1 LIST_POISON2-linux链表-4

LIST_POISON1 LIST_POISON2-linux链表-4

static inline void list_del(struct list_head *entry) {__list_del(entry->prev, entry->next);entry->next LIST_POISON1;entry->prev LIST_POISON2; } 摘录如下&#xff1a; 删除就是把某一节点从链表中删除。entry->next LIST_POISON1; entry->pre…
阅读更多...
数据结构与算法思维导图（学习笔记）

数据结构与算法思维导图（学习笔记）

版本 数据结构与算法思维导图V1.0 V1.0分享版本这个可以直接看&#xff0c;不需要下载。 说明 1、free 2、目前内容主要包含内容包含&#xff1a; 数据结构与算法思维导图 包含&#xff1a;线性表、顺序结构、链式结构&#xff0c;栈与队列&#xff0c;串&#xff0c;二叉树…
阅读更多...
剑指offer 圆圈中最后剩下的数字 python实现

剑指offer 圆圈中最后剩下的数字 python实现

每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然…
阅读更多...
数据结构和算法（九）哈希表 HashTable

数据结构和算法（九）哈希表 HashTable

1、哈希表&#xff08;Hash Table&#xff09;&#xff08;散列&#xff09;简介 哈希表&#xff08;Hash table&#xff0c;也叫散列表&#xff09;是一个数据结构&#xff0c;是根据关键码值&#xff08;key - value&#xff09;而直接访问在内存存储位置的数据结构。 哈希表…
阅读更多...
LeetCode刷题笔记 Java 腾讯 链表突击 删除链表中的节点

LeetCode刷题笔记 Java 腾讯 链表突击 删除链表中的节点

题目 官解 请编写一个函数&#xff0c;用于 删除单链表中某个特定节点 。在设计函数时需要注意&#xff0c;你无法访问链表的头节点 head &#xff0c;只能直接访问 要被删除的节点 。 题目数据保证需要删除的节点 不是末尾节点 把自己变成儿子&#xff0c;再把儿子删了&…
阅读更多...
LeetCode刷题笔记 Java 腾讯 链表突击 相交链表

LeetCode刷题笔记 Java 腾讯 链表突击 相交链表

题目 官解 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c;函数…
阅读更多...
Java实现双向链表增删改查

Java实现双向链表增删改查

双向链表带头节点的双向链表模拟结点双向链表的增删改查测试带头节点的双向链表 什么是双向链表&#xff1a; 双链表是链表的一种&#xff0c;由节点组成&#xff0c;每个数据结点中都有两个指针&#xff0c;分别指向直接后继和直接前驱。 模拟结点 //模拟双向链表的结点 publ…
阅读更多...
王道数据结构习题代码5.3.3(树与二叉树)

王道数据结构习题代码5.3.3(树与二叉树)

第三题(二叉树非递归后序遍历) #include <stdio.h> #include <stdlib.h> #include<stdbool.h>#define MaxSize 50typedef int Elemtype;typedef struct BiTNode {Elemtype data;struct BiTNode * lchild,*rchild; } BiTNode,*BiTree;typedef struct Stack …
阅读更多...
Java集合框架：队列、Queue和Deque详解

Java集合框架：队列、Queue和Deque详解

目录 一、普通队列 1. 概念 2. Queue&#xff08;Java集合框架的接口&#xff09; 3. Queue中的方法 4. 方法使用演示 5. 队列的模拟实现 6. 顺序普通队列的缺点&#xff1a; 二、循环队列 1. 循环队列也是一种数据结构。基于上述队列的缺点&#xff0c;此时就有了循环…
阅读更多...
java 重排链表

java 重排链表

牛客题目链接 1. 题目考点 找链表中间节点的两种方式翻转链表的两种方式 2. 考点解析 原地构造两个链表 list1 和 list2&#xff0c;list2 采用头插法翻转原链表 public ListNode reorderList(ListNode head) {ListNode l1 new ListNode(0);ListNode l2 new ListNode(0)…
阅读更多...
java 链表的奇偶重排

java 链表的奇偶重排

牛客题目链接 1. 题目考点 链表原地划分为两个链表 2. 考点解析 方法一&#xff1a;划分链表 public ListNode oddEvenList (ListNode head) {// write code hereListNode odd new ListNode(0);ListNode even new ListNode(0);ListNode r1 odd, r2 even, p head;whil…
阅读更多...
单链表模拟栈（数据结构）

单链表模拟栈（数据结构）

package stack;public class Linkdemostack {Linkeddemo top;//初始化栈顶public static void main(String[] args) {Linkdemostack linkdemostacknew Linkdemostack();linkdemostack.push(1);linkdemostack.push(2);linkdemostack.push(3);linkdemostack.list();System.out.pr…
阅读更多...
数据结构之环形链表

数据结构之环形链表

数据结构之环形链表 环形链表 提示&#xff1a; 博主&#xff1a;来自火星的萨满_906285288 博客地址&#xff1a;http://blog.csdn.net/qq_29924041 概念&#xff1a; 前面两篇博客主要讲的是单向链表和双向链表&#xff0c;但是有没有发现&#xff0c;双向链表其实是在单…
阅读更多...
ArrayList LindedList HashMap等数据结构分析

ArrayList LindedList HashMap等数据结构分析

ArrayList 的数据结构为顺序表&#xff0c;物理上连续&#xff0c;一旦增加元素&#xff0c;则所增加位置索引后面的元素全部进行后移操作&#xff0c;如果频繁增加数据则会极大的消耗性能 LindedList的数据结构为链表&#xff0c;物理上不连续&#xff0c;每个元素是通过指向…
阅读更多...
C语言链表的创建，遍历，加入，删除，完整代码

C语言链表的创建，遍历，加入，删除，完整代码

创建 首先链表这个数据结构的结构体由两个部分组成&#xff0c;分别是数据域和指针域&#xff0c;也就是存放数据的变量和指针 struct student{char name[30]; //数据域float number; //数据域struct student *pNext; //指针域 };链表的创建&#xff0c;就是在创建节点…
阅读更多...
牛客 剑指Offer反转链表 代码和解释

牛客 剑指Offer反转链表 代码和解释

题目 输入一个链表&#xff0c;反转链表后&#xff0c;输出新链表的表头。 代码和解释 /* struct ListNode {int val;struct ListNode *next;ListNode(int x) :val(x), next(NULL) {} };*/ class Solution { public:ListNode* ReverseList(ListNode* pHead) {if(!pHead){ret…
阅读更多...
剑指offer 求两个链表的第一个公共节点 代码和解释

剑指offer 求两个链表的第一个公共节点 代码和解释

题目 输入两个链表&#xff0c;找出它们的第一个公共结点。&#xff08;注意因为传入数据是链表&#xff0c;所以错误测试数据的提示是用其他方式显示的&#xff0c;保证传入数据是正确的&#xff09; 思路 &#xff08;来自于官方解答。&#xff09;这里面求的是两个链表的…
阅读更多...
【排序9：排序链表】

【排序9：排序链表】

给你链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [4,2,1,3] 输出&#xff1a;[1,2,3,4] 示例 2&#xff1a; 输入&#xff1a;head [-1,5,3,4,0] 输出&#xff1a;[-1,0,3,4,5] 示例 3&#xff1a; 输…
阅读更多...
从零开始，使用JS一步步理解并实现链表

从零开始，使用JS一步步理解并实现链表

文章首发于 www.shaotianyu.com 一、数组和链表优缺点 1.1、数组(Array) 1.1.1 数组的优点 线性表的一种。高级数据语言中&#xff0c;对数组内部的元素类型没有严格的要求&#xff0c;这在语言中称为泛型&#xff0c;可以放入任何单元类型。数组的底层的硬件实现&#xff0…
阅读更多...
LWN: Lockless编程模式 - 介绍compare-and-swap！

LWN: Lockless编程模式 - 介绍compare-and-swap！

关注了就能看到更多这么棒的文章哦&#xff5e;Lockless patterns: an introduction to compare-and-swapMarch 12, 2021This article was contributed by Paolo BonziniLockless patternsDeepL assisted translationhttps://lwn.net/Articles/847973/系列文章之一&#xff1a;…
阅读更多...
第二章算法设计题2

第二章算法设计题2

第二章算法设计题2 问题描述 将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中允许有重复的数据。 代码实现 #pragma once #include <iostream> #include<string> #define MAXSI…
阅读更多...
Linux内核中的常用数据结构-双向链表(1)

Linux内核中的常用数据结构-双向链表(1)

Linux的内核代码&#xff0c;网上很多&#xff0c;例如http://docs.huihoo.com/doxygen/linux/kernel/3.7/include_2linux_2types_8h_source.html 或者 http://lxr.free-electrons.com/source/drivers/gpu/drm/radeon/mkregtable.c 这个文件中基本上定义了大多数的双向链表操…
阅读更多...
力扣上面两道线性表的算法题

力扣上面两道线性表的算法题

077. 链表排序 给定链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [4,2,1,3] 输出&#xff1a;[1,2,3,4] 示例 2&#xff1a; 输入&#xff1a;head [-1,5,3,4,0] 输出&#xff1a;[-1,0,3,4,5] 示例…
阅读更多...
HOT35-LRU缓存

HOT35-LRU缓存

leetcode原题链接&#xff1a;LRU缓存 题目描述 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类&#xff1a; LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存int get(int key) 如果关键字 key 存在于缓存中&…
阅读更多...
第二章 链表_707.设计链表

第二章 链表_707.设计链表

文章目录 707.设计链表一、题目你可以选择使用单链表或者双链表&#xff0c;设计并实现自己的链表。二、问题1. 头结点和虚拟头结点的关系&#xff1f;2. 链表的元素个数是多少&#xff1f;3. 链表的位置是从几开始的&#xff1f; 三、需要注意的地方1. 插入删除节点需要有返回…
阅读更多...
Copy List with Random Pointer 复制带随机指针的链表

Copy List with Random Pointer 复制带随机指针的链表

文章目录Copy List with Random Pointer 复制带随机指针的链表Description思路:Copy List with Random Pointer 复制带随机指针的链表 Description A linked list of length n is given such that each node contains an additional random pointer, which could point to an…
阅读更多...
牛客剑指offer笔记（上）

牛客剑指offer笔记（上）

文章目录1.在一个二维数组中&#xff08;每个一维数组的长度相同&#xff09;&#xff0c;每一行都按照从左到右递增的顺序排序&#xff0c;每一列都按照从上到下递增的顺序排序。请完成一个函数&#xff0c;输入这样的一个二维数组和一个整数&#xff0c;判断数组中是否含有该…
阅读更多...
HashMap 源码深度分析

HashMap 源码深度分析

HashMap 源码分析 在Map集合中&#xff0c; HashMap 则是最具有代表性的&#xff0c;也是我们最常使用到的 Map 集合。由于 HashMap 底层涉及了很多的知识点&#xff0c;可以比较好的考察一个人的Java的基本功&#xff0c;所以HashMap颇受面试官的青睐&#xff0c;所以我们接下…
阅读更多...
Leetcode876.链表的中间结点（快慢指针习题，C++）

Leetcode876.链表的中间结点（快慢指针习题，C++）

题目描述&#xff1a; 给定一个头结点为 head 的非空单链表&#xff0c;返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结点。 知识点&#xff1a;快慢指针 思路&#xff1a;设两个指针&#xff0c;一个移动快&#xff0c;一个移动慢&#xff0c;当快…
阅读更多...
Linux下的C语言学习笔记(3)

Linux下的C语言学习笔记(3)

------------------------------day12---动态数据结构-静态链表-动态链表--------------------------------------- 1&#xff0c;静态链表&#xff1a;#include<stdio.h>struct weapon{int price;int atk;struct weapon * next;};int main(){struct weapon a,b,c,*head;…
阅读更多...
C++笔记 STL vector容器 详解及基本用法

C++笔记 STL vector容器 详解及基本用法

1、vector是可变长的动态数组 1、Vector是可变长的动态数组&#xff0c;支持随机访问迭代器&#xff0c;所有STL算法都能对vector进行操作。 使用时需包含头文件vector。 2、vector与普通数组区别 2、 vector 数据结构和数组非常相似&#xff0c;也被称之为单端数组 // vector…
阅读更多...
剑指offor刷题---java版

剑指offor刷题---java版

面试题03. 数组中重复的数字 找出数组中重复的数字。 在一个长度为 n 的数组 nums 里的所有数字都在 0&#xff5e;n-1 的范围内。数组中某些数字是重复的&#xff0c;但不知道有几个数字重复了&#xff0c;也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。 示例…
阅读更多...
牛客 剑指Offer从未到头打印链表 三种方法

牛客 剑指Offer从未到头打印链表 三种方法

题目 输入一个链表&#xff0c;按链表从尾到头的顺序返回一个ArrayList。 方法一 直接反转整个链表&#xff0c;然后输出里面的val值。还是定义三个指针来做整个的逆序的过程。 /** * struct ListNode { * int val; * struct ListNode *next; * List…
阅读更多...
第四章算法设计题6

第四章算法设计题6

第四章算法设计题6 题目描述 代码实现 #pragma once #include <iostream> using namespace std;//交换 void swap(int& a, int& b) {int temp a;a b; b temp; }//正数前置 void sort(int A[], int n) {int left 0;int right n - 1;while (left < right…
阅读更多...
第三章算法设计题6

第三章算法设计题6

第三章算法设计题6 题目描述 代码实现 #pragma once #include <iostream>using namespace std;//队列的链式存储结构 //结点类型的定义 typedef struct QNode {int data;struct QNode* next; }QNode,*Queueptr;//只设一个指向队尾元素的指针 typedef struct {Queueptr …
阅读更多...
Leetcode 算法面试冲刺 实战 一（链表）（八）

Leetcode 算法面试冲刺 实战 一（链表）（八）

文章目录练习题219 在排序链表中插入一个节点452 删除链表中的元素511 交换链表当中两个节点228 链表的中点170 旋转链表99 重排链表练习题 219 在排序链表中插入一个节点 在链表中插入一个节点。 写了一个&#xff0c;但是爆了一个错&#xff0c;不知道是什么错误 de…
阅读更多...
1. 数据结构与算法——栈

1. 数据结构与算法——栈

数据结构与算法 数据结构是计算机中存储、组织数据的方式 算法通俗理解就是解决问题的方法/步骤逻辑 定义&#xff1a;1.一个有限的指令集&#xff0c;每条指令的描述不依赖与语言2.接受一些输入(也可能不需要输入)&#xff0c;产生输出3.一定在有限步骤之后终止数据结构的实…
阅读更多...
面试题32：从上到下打印二叉树（广度优先搜索）

面试题32：从上到下打印二叉树（广度优先搜索）

面试题32&#xff1a;从上到下打印二叉树&#xff08;广度优先搜索&#xff09; 从上到下打印出二叉树的每个节点&#xff0c;同一层的节点按照从左到右的顺序打印。 class Solution { public:vector<int> levelOrder(TreeNode* root) {if(root nullptr)return {};que…
阅读更多...
面试题23：链表中环的入口位置

面试题23：链表中环的入口位置

面试题23&#xff1a;链表中环的入口位置 给定一个链表&#xff0c;返回链表开始入环的第一个节点。 从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环&#xff0c;则返回 null。 class Solution { public:ListNode *detectCycle(ListNode *…
阅读更多...
面试题18：删除链表的结点

面试题18：删除链表的结点

面试题18&#xff1a;删除链表的结点 给定单向链表的头指针和一个要删除的节点的值&#xff0c;定义一个函数删除该节点。返回删除后的链表的头节点。 class Solution { public:ListNode* deleteNode(ListNode* head, int val) {if(head->val val)return head->next;L…
阅读更多...
java 环形/循环链表的实现（tail）（基本功能+mintofirst将最小元素移到最前+merge将两个环形链表合并）

java 环形/循环链表的实现（tail）（基本功能+mintofirst将最小元素移到最前+merge将两个环形链表合并）

目录 完整代码&#xff1a; 分解部分&#xff1a; 图解&#xff1a; 属性&#xff1a; Node类&#xff1a; 构造方法&#xff1a; isEmpty、size、indexof、get方法&#xff1a; add、clear方法&#xff1a; remove方法&#xff1a; mintofirst将最小的元素移动到最前…
阅读更多...
数据结构与算法学习---数据结构篇（线性表）（默然回首，夯实基础）

数据结构与算法学习---数据结构篇（线性表）（默然回首，夯实基础）

昨晚看了某B站主播的讲解&#xff0c;原来数据结构与算法才是校招面试的重点&#xff1b;在目前比较迷茫的准备中&#xff0c;也算是一盏明灯告诉我以后的这段时间该怎么准备了&#xff1b;接下来就是&#xff0c;重点复习一下数据结构与算法的基础知识&#xff0c;做一下leetc…
阅读更多...
2021-11-13

2021-11-13

题目描述 题目链接 代码实现 #pragma once #include <iostream>using namespace std;//单链表的存储结构 typedef struct ListNode {int val;ListNode* next; }ListNode,*LinkList;//头插法创建单链表 void CreateList_H(LinkList& L, int n) {//创建带头结点的…
阅读更多...
4.2 移除链表元素

4.2 移除链表元素

203 移除链表元素题目给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。思路具体代码实现(C)题目 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.va…
阅读更多...
203.移除链表元素

203.移除链表元素

203.移除链表元素 题目描述 题目链接 代码实现 #pragma once #include <iostream>using namespace std;/*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNod…
阅读更多...
LeetCode 83 删除排序链表中的重复元素

LeetCode 83 删除排序链表中的重复元素

题目描述&#xff1a; 存在一个按升序排列的链表&#xff0c;给你这个链表的头节点 head &#xff0c;请你删除所有重复的元素&#xff0c;使每个元素 只出现一次 。 返回同样按升序排列的结果链表。 示例&#xff1a; 输入&#xff1a;head [1, 1, 2] 输出&#xff1a;[1,…
阅读更多...
第二章算法设计题1

第二章算法设计题1

第二章算法设计题1 题目描述 将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中不允许有重复的数据。 代码实现 #pragma once #include <iostream> #include<string> #define MAXSIZE…
阅读更多...
HashMap知识点和红黑树知识点

HashMap知识点和红黑树知识点

HashMap知识点 初始容量 16 装载因子 0.75 默认限制扩容数 64 转换红黑树阈值 8 转换链表阈值 6当链表长度大于8 链表转为红黑树&#xff08;前提是HashMap容量达到64&#xff09; 当红黑树中的元素个数小于6 再转回链表&#xff08;前提是根节点或者子节点为空&#xff09;。…
阅读更多...
数据结构-----蓦然回首，夯实基础

数据结构-----蓦然回首，夯实基础

1. 栈 &#xff08;stack &#xff09; 栈&#xff08;stack&#xff09;是限制插入和删除只能在一个位置上进行的表&#xff0c;该位置是表的末端&#xff0c;叫做栈顶&#xff08;top&#xff09;。它是后进先出&#xff08;LIFO&#xff09;的。对栈的基本操作只有 push&am…
阅读更多...
【LeetCode热题100】打卡第30天：从前序遍历与中序遍历序列构造二叉树二叉树展开为链表

【LeetCode热题100】打卡第30天：从前序遍历与中序遍历序列构造二叉树二叉树展开为链表

文章目录 【LeetCode热题100】打卡第30天&#xff1a;从前序遍历与中序遍历序列构造二叉树&二叉树展开为链表⛅前言 从前序与中序遍历构造二叉树&#x1f512;题目&#x1f511;题解 从中序与后序遍历构造二叉树&#x1f512;题目&#x1f511;题解 二叉树展开为链表&#…
阅读更多...
接口和断言

接口和断言

一.go语言的面向对象 例子&#xff1a;银行的取款和存款代码&#xff1a; package mainimport ("fmt" )type Yinghang struct {Account stringPwd stringBalance int }func (p *Yinghang) qukuan(Account string, Pwd string, Balance int) {if p.Account ! Acc…
阅读更多...
数据结构与算法：链表、树、图、堆、散列表

数据结构与算法：链表、树、图、堆、散列表

1 链表 链表是线性数据结构&#xff08;数据元素之间存在着“一对一”关系&#xff09;&#xff0c;链表中的每个元素是一个包含数据data和引用字段的对象&#xff0c;引用字段只有next为单向链表&#xff0c;同时又prev和next为双向链表。 1.1 链表基本操作 链表读取第 i 个…
阅读更多...
数据结构-链表学习java实现

数据结构-链表学习java实现

1、链表初识&#xff08;类型固定 容量固定&#xff09; 链表是线性表中常见的两种表现方式之一 数据储存在节点&#xff08;Node&#xff09;中 Node一般来说包括&#xff1a;元素、前驱、后继 第一个节点的前驱是Null&#xff0c;最后一个节点的后继是Null 真正的实现了…
阅读更多...
leetcode-061-旋转链表

leetcode-061-旋转链表

题目及测试 package pid061; /*61. 旋转链表 给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。示例 1&#xff1a;输入&#xff1a;head [1,2,3,4,5], k 2 输出&#xff1a;[4,5,1,2,3] 示例 2&#xff1a;输入&#xff1a;he…
阅读更多...
判断一个链表是否有环

判断一个链表是否有环

给定一个单链表&#xff0c;只给出头指针h&#xff1a; 1、如何判断是否存在环&#xff1f; 2、如何知道环的长度&#xff1f; 3、如何找出环的连接点在哪里&#xff1f; 4、带环链表的长度是多少&#xff1f; 解法&#xff1a; 1、对于问题1&#xff0c;使用追赶的方法&#x…
阅读更多...
118、数据结构中数组、链表、哈希

118、数据结构中数组、链表、哈希

一、数组 在内存中&#xff0c;数组是一块连续的区域。数组需要预留空间&#xff0c;在使用前要先申请占内存的大小&#xff0c;可能会浪费内存空间。插入数据和删除数据效率低。除了在尾部的插入删除。插入数据时&#xff0c;这个位置后面的数据在内存中都要向后移。删除数据…
阅读更多...
秒懂单链表及其反转(reverse)

秒懂单链表及其反转(reverse)

什么是链表&#xff0c;这种数据结构是由一组Node组成的&#xff0c;这群Node一起表示了一个序列。链表是最普通&#xff0c;最简单的数据结构&#xff0c;它是实现其他数据结构如stack, queue等的基础。 链表比起数组来&#xff0c;更易于插入&#xff0c;删除。 Node可以定义…
阅读更多...
【JUC系列】并发容器之ConcurrentLinkedQueue(JDK1.8版)

【JUC系列】并发容器之ConcurrentLinkedQueue(JDK1.8版)

ConcurrentLinkedQueue 文章目录ConcurrentLinkedQueue类图组成数据结构内部类类的属性类的构造函数核心方法入队列 boolean offer(E e)出队列 E poll()移除操作remove(Object o)first()isEmpty()size()状态说明类图 组成 数据结构 一个头结点和一个尾结点 每个结点Node包含i…
阅读更多...
【JUC系列】并发容器之ConcurrentHashMap(JDK1.8版)

【JUC系列】并发容器之ConcurrentHashMap(JDK1.8版)

ConcurrentHashMap&#xff08;JDK1.8&#xff09; 文章目录ConcurrentHashMap&#xff08;JDK1.8&#xff09;组成内部类NodeForwardingNodeTreeNodeTreeBin数据结构核心方法int spread(int h)计算hash值构造函数PUT过程putVal(K key, V value, boolean onlyIfAbsent)initTabl…
阅读更多...
【假捻报工数据导入报错--生产计划下达量出错】

【假捻报工数据导入报错--生产计划下达量出错】

今天在生产报工明细菜单中导入假捻报工数据的时候&#xff0c;意外报错了。 我按照订单明细ID进行筛选&#xff0c;发现有一个ID导入的时候报错。 773118147568873472 在生产报工明细里能查到2条生产订单号&#xff0c;分别是RSCD20221108013和 RSCD20221104005。 在假捻包装…
阅读更多...
Leetcode206.反转链表

Leetcode206.反转链表

Leetcode206.反转链表题目描述&#xff1a;给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。思路&#xff1a;思路&#xff1a;将指针反转。题目描述&#xff1a;给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后…
阅读更多...
栈的建立【包括入栈出栈显示】（基于单链表实现）

栈的建立【包括入栈出栈显示】（基于单链表实现）

一般来说&#xff0c;c有专门的STL&#xff0c;可以直接调用接口。怕自己忘记&#xff0c;我还是po出来了 C标准库&#xff08;STL&#xff09;栈&#xff08;stack&#xff09;、队列&#xff08;queue&#xff09;、双向队列&#xff08;deque&#xff09;、容器&#xff08…
阅读更多...
TreeMap分析

TreeMap分析

TreeMap分析 TreeMap和HashMap不同点 TreeMap的数据结构和HashMap不一样&#xff0c;TreeMap是基于红黑树实现的。而HahsMap是数组 链表&#xff08;红黑树&#xff09;来实现的。 TreeMap不需要调用Hash方法来算hash值。 TreeMap一开始就是红黑树&#xff0c;不像HashMap一…
阅读更多...
7.3 用队列实现栈

7.3 用队列实现栈

225 用队列实现栈题目请你仅使用两个队列实现一个后入先出&#xff08;LIFO&#xff09;的栈&#xff0c;并支持普通栈的全部四种操作&#xff08;push、top、pop 和 empty&#xff09;。思路具体代码实现(C) (用一个队列实现栈)模型&#xff08;知识点&#xff09;题目 请你仅…
阅读更多...
4.5 删除链表的倒数第 N 个结点

4.5 删除链表的倒数第 N 个结点

19 删除链表的倒数第 N 个结点题目给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。思路具体代码实现(C)模型&#xff08;知识点&#xff09;题目 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。…
阅读更多...
重排链表(Java)

重排链表(Java)

给定一个单链表 L 的头节点 head &#xff0c;单链表 L 表示为&#xff1a; L0 → L1 → … → Ln - 1 → Ln 请将其重新排列后变为&#xff1a; L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → ... 不能只是单纯的改变节点内部的值&#xff0c;而是需要实际的进行节点交换。 …
阅读更多...
69.删除链表的节点

69.删除链表的节点

文章目录题目思路代码题目 给定单向链表的头指针和一个要删除的节点的值&#xff0c;定义一个函数删除该节点。 返回删除后的链表的头节点。 思路 注意以下几种情形&#xff1a; 1.链表是否存在 2.第一个节点是否是需要删除的节点 3.设置右表指针p&#xff0c;一直找到要删除…
阅读更多...
数据结构与算法-3

数据结构与算法-3

单向链表 单向链表也叫单链表&#xff0c;是链表中最简单的一种形式&#xff0c;它的每个节点包含两个域&#xff0c;一个信息域&#xff08;元素域&#xff09;和一个链接域。这个链接指向链表中的下一个节点&#xff0c;而最后一个节点的链接域则指向一个空值。 表元素域ele…
阅读更多...
Design LRU Least Recently Used 设计最近最少使用算法

Design LRU Least Recently Used 设计最近最少使用算法

文章目录LRU Least Recently Used 最近最少使用算法思路TagLRU Least Recently Used 最近最少使用算法 LRU可以算是书本中比较熟悉的算法了&#xff0c;有缓存存在的场景下&#xff0c;基本都会有它的身影。它的作用就是在空间一定的缓存中&#xff0c;淘汰掉最近最少使用的数…
阅读更多...
Linked List Cycle has cycle 环形链表是否有环

Linked List Cycle has cycle 环形链表是否有环

文章目录Linked List Cycle 环形链表哈希表双指针Linked List Cycle 环形链表 哈希表 利用哈希特性&#xff0c;在遍历的同时将节点插入hash&#xff1b;如果插入失败代表链表有环。 /*** Definition for singly-linked list.* class ListNode {* int val;* ListNod…
阅读更多...
1097 Deduplication on a Linked List (25分)

1097 Deduplication on a Linked List (25分)

00100 5 99999 -7 87654 23854 -15 00000 87654 15 -1 00000 -15 99999 00100 21 23854输出&#xff1a; 00100 21 23854 23854 -15 99999 99999 -7 -1 00000 -15 87654 87654 15 -1啊 要说这个题有意思的点可能在于排序8 利用order我想到了 但是一开始就分区是我没想到的 nod…
阅读更多...
*UVA 11988 破损的键盘 Broken Keyboard (a.k.a. Beiju Text)

*UVA 11988 破损的键盘 Broken Keyboard (a.k.a. Beiju Text)

题目描述 用数组模拟链表&#xff0c;对于每一个字符存一个next值表示下一个元素的下标 对于字符[&#xff0c;将当前下标改为0 对于字符]&#xff0c;将当前下标改为last就是我们存的最后的下标 对于其他字符&#xff0c;更新next即可 #include <bits/stdc.h> using…
阅读更多...
ArrayList 和 LinkedList 到底有哪些区别？

ArrayList 和 LinkedList 到底有哪些区别？

ArrayList 和 LinkedList 到底有哪些区别&#xff1f;ArrayList 和 LinkedList底层数据结构不同操作集合的底层实现不同插入操作删除操作按照索引查找关于线程安全ArrayList 和 LinkedList ArrayList 和 LinkedList 之前有那些区别&#xff1f;这个是面试中最常见的一个问题之…
阅读更多...
堆和栈的区别（附实例）

堆和栈的区别（附实例）

堆和栈在不同场景&#xff0c;堆与栈代表不同的含义。一般情况下&#xff0c;有两层含义&#xff1a; 程序内存布局场景下&#xff0c;堆与栈表示两种内存管理方式&#xff08;本文介绍的&#xff09;&#xff1b;数据结构场景下&#xff0c;堆与栈表示两种常用的数据结构&…
阅读更多...
C学习记录8——复合类型

C学习记录8——复合类型

C学习记录8——复合类型一、结构体1.结构体的定义与使用2.结构体数组3.结构体嵌套4.结构体赋值5.结构体指针二、共用体&#xff08;联合体&#xff09;三、枚举一、结构体 1.结构体的定义与使用 将不同类型数据组合成一个有机整体 struct student //student为结构体类型名 …
阅读更多...
数据结构-哈希表应用

数据结构-哈希表应用

数据结构-哈希表 哈希表是在基于数组的基础上加入链表或者二叉树组成的新数据结构、为了显著提升查找效率/ leetcode每日一题中出现了需要滑动数据块解决的问题&#xff1a;将一个字符串中长度为10重复出现的子串导出&#xff1a; 如ABCCCABCCCABCCCABCCC导出ABCCCABCCC和CC…
阅读更多...
cubemx stm32 按键key 支持单、双、三、四击以及长按 链表实现 驱动代码

cubemx stm32 按键key 支持单、双、三、四击以及长按 链表实现 驱动代码

cubemx配置 打开串口配置按键的 gpio口为 up input 模式配置时钟树 代码 yxy_open_key.c #include "yxy_open_key.h" #include "stdlib.h" #include "string.h" #include "yxy_debug.h"/* // 按键实现思路&#xff1a;用户需要使用…
阅读更多...
字节奋战 8 年，回头一看只剩下这份 1857 页的算法笔记了

字节奋战 8 年，回头一看只剩下这份 1857 页的算法笔记了

计算机专业的应届生想进大厂做开发有多难呢&#xff1f; 我们来看一组网上的数据&#xff1a; 据统计&#xff0c;互联网公司笔试是最难的关卡之一&#xff0c;平均通过率只有 10%~20%。滴滴出行笔试通过率为 18.2%&#xff1b;腾讯秋招笔试通过率不足 15%&#xff1b;字节跳动…
阅读更多...
野指针和free总结超有用

野指针和free总结超有用

在C语言项目中&#xff0c;经常会遇到需要程序员手动分配内存的地方。这样做能够节省大量的内存空间&#xff0c;也让程序更加灵活。只要你有一定的基础&#xff0c;那么肯定用过 malloc 或者 ralloc和free的组合。这个组合使用起来有一个需要注意的地方&#xff0c;不知道你有…
阅读更多...
C语言中都有哪些常见的数据结构你都知道几个？？

C语言中都有哪些常见的数据结构你都知道几个？？

上次在面试时被面试官问到学了哪些数据结构&#xff0c;那时简单答了栈、队列/(ㄒoㄒ)/~~其它就都想不起来了&#xff0c;今天有空整理了一下几种常见的数据结构&#xff0c;原来我们学过的数据结构有这么多~ 首先&#xff0c;先来回顾下C语言中常见的基本数据类型吧O(∩_∩)O …
阅读更多...
leetcode61. 旋转链表(链表)【S】

leetcode61. 旋转链表(链表)【S】

61. 旋转链表 主要是用来自我记录的&#xff0c;方便归类和查看。 典型链表题 思路&#xff1a;旋转链表&#xff0c;其实就是将后面的结点移动到前面来&#xff0c;所以需要有一点点的数学技巧 思考过程&#xff1a; 先根据示例&#xff0c;模拟了旋转的过程&#xff0c;发…
阅读更多...
数据结构算法与应用-C++语言描述 stack链表的实现

数据结构算法与应用-C++语言描述 stack链表的实现

//数据结构算法与应用-C语言描述 stack链表的实现 //链表描述 main.cpp #include <iostream> #include <sstream> #include <iterator> using namespace std; //数据结构算法与应用-C语言描述 chain 单链表//一个线性表的抽象类 template <class T> cl…
阅读更多...
邓俊辉数据结构学习笔记2

邓俊辉数据结构学习笔记2

列表 typedef int Rank; //秩 #define ListNodePosi(T) ListNode<T>* //列表节点位置template<typename T>struct ListNode//列表节点模板类&#xff08;以双向链表形式实现&#xff09; {// 成员T data;ListNodePosi(T) pred;ListNodePosi(T) succ;//数值、前驱、…
阅读更多...
【剑指offer】链表中环的入口结点

【剑指offer】链表中环的入口结点

题目描述 给一个链表&#xff0c;若其中包含环&#xff0c;请找出该链表的环的入口结点&#xff0c;否则&#xff0c;输出null。 解题思路 给定一个单链表&#xff0c;判断其中是否有环&#xff0c;是一个比较经典的问题。简单归纳一下&#xff0c;单链表中环的问题包括&#…
阅读更多...
LeetCode50天刷题计划第二季（Day 24 — LRU 缓存（8.00- 8.50）对链表进行插入排序（11.30-11.50）

LeetCode50天刷题计划第二季（Day 24 — LRU 缓存（8.00- 8.50）对链表进行插入排序（11.30-11.50）

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录前言一、题目LRU 缓存示例提示二、思路三、代码四、题目对链表进行插入排序示例提示五、思路六、代码前言 今天补两天 一、题目 LRU 缓存 请你设计并实现一个满足…
阅读更多...
「思考」为什么现在面试总是面试造火箭？

「思考」为什么现在面试总是面试造火箭？

很多人总是抱怨面试官问一些平时不常用的知识点&#xff0c;比如算法呀&#xff0c;网络(TCP)等等&#xff0c;也就是大家常说的&#xff1a;面试造火箭&#xff0c;工作拧螺丝。但是有没有想过为什么整个前端圈&#xff0c;或者绝大部分面试&#xff0c;不仅是前端&#xff0c…
阅读更多...
单向链表 反转链表_反转单个链表

单向链表 反转链表_反转单个链表

单向链表 反转链表Problem statement: Given a linked list reverse it without using any additional space (In O(1) space complexity). 问题陈述&#xff1a;给定的链表在不使用任何额外空间的情况下将其反向(O(1)空间复杂度)。 Solution: 解&#xff1a; Reversing a si…
阅读更多...
PAT乙级1025

PAT乙级1025

1025. 反转链表 (25) 时间限制300 ms内存限制65536 kB代码长度限制8000 B判题程序Standard作者CHEN, Yue给定一个常数K以及一个单链表L&#xff0c;请编写程序将L中每K个结点反转。例如&#xff1a;给定L为1→2→3→4→5→6&#xff0c;K为3&#xff0c;则输出应该为3→2→1→6…
阅读更多...
重学数据结构：双向链表的各种操作（C语言）

重学数据结构：双向链表的各种操作（C语言）

文章目录双向链表定义初始化双向链表&#xff08;前插值&#xff09;打印双向链表在p节点后插入s节点删除当前节点的后继节点删除整个链表双向链表定义 #define bool int #define true 1 #define false 0 typedef struct DLNode {struct DLNode *next;struct DLNode *prior;i…
阅读更多...
顺序表和链表3

顺序表和链表3

目录 4、双向链表&#xff08;带头双向循环链表&#xff09;的实现&#xff1a; 4.1、test.c源文件&#xff1a; 4.2、List.c源文件&#xff1a; 4.3、List.h头文件&#xff1a; 5、顺序表和链表的区别&#xff1a; 4、双向链表&#xff08;带头双向循环链表&#xff09;的…
阅读更多...
递减双向循环队列插入元素，并保持递减性

递减双向循环队列插入元素，并保持递减性

设有一个带头结点的、按元素值递减有序排列的双向循环链表&#xff0c;编写算法&#xff0c;插入一个元素并保持其有序性。 双向链表结点的类型定义如下&#xff1a; typedef struct DuLNode{int data;struct DuLNode *prior;//指向前驱的指针struct DuLNode *next;//指向后继…
阅读更多...
D2-读论文D2算法题D2（复习：单链表、双链表、模拟栈）

D2-读论文D2算法题D2（复习：单链表、双链表、模拟栈）

---------0702读了4篇论文~现在做一下算法题&#xff0c;然后去干饭&#xff01;&#xff01;&#xff01; 826单链表&#xff08;复习&#xff09; 注意删除头结点时&#xff0c;h已经指向第一个节点了&#xff0c;只需要将h赋值为ne[h]&#xff08;第二个节点即可&#xff…
阅读更多...
java.net.BindException Address already in use JVM_Bind解决方案

java.net.BindException Address already in use JVM_Bind解决方案

在开发的时候我们开启了服务器&#xff08;tomcat or jetty&#xff09;。然后我们没有关闭服务器&#xff0c;而直接关闭了eclipse或者idea&#xff0c;这时当你再启动容器的时候就可能出现下面这个异常&#xff1a; java.net.BindException: Address already in use: JVM_Bin…
阅读更多...
【LeetCode】—— 在LeetCode下怎样确定bug的位置

【LeetCode】—— 在LeetCode下怎样确定bug的位置

LeetCode设计链表的实现 您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性&#xff1a;val 和 next。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。如果要使用双向链表&#xff0c;则还需要一个属性 prev 以指示链表中的上一个节点。假设链…
阅读更多...
leetcode 147.对链表进行插入排序|数据结构-链表

leetcode 147.对链表进行插入排序|数据结构-链表

leetcode 147. 对链表进行插入排序 难度&#xff1a;中等 题目&#xff1a;对给定的链表进行插入排序。 插入排序的步骤&#xff1a; 链表的第一个元素可以被认为已经部分排序&#xff1b;每次只从输入数据中移除一个待排序的元素&#xff0c;找到它在已经排序的序列中适当的位…
阅读更多...
leetcode 25.K个一组翻转链表|数据结构-链表

leetcode 25.K个一组翻转链表|数据结构-链表

leetcode 25. K个一组翻转链表 难度&#xff1a;困难 题目&#xff1a;给定一个链表&#xff0c;每 k 个节点一组进行翻转&#xff0c;请返回翻转后的链表。 说明&#xff1a;k 是一个正整数&#xff0c;它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍&#xff0c;那…
阅读更多...
C语言实现带头结点的单链表的创建以及简单使用

C语言实现带头结点的单链表的创建以及简单使用

其功能实现有 创建链表 头插法尾插法 中间插入 链表的显示 节点的删除 链表的清空以及销毁 链表的转置 链表的排序 等功能 代码如下 //链表的创建以及使用 //带头节点的链表#include<stdio.h> #include<stdlib.h>typedef struct LNode{int num;struct L…
阅读更多...
第二章--线性表之双链表

第二章--线性表之双链表

目录一、定义双链表二、双链表的初始化二、双链表的插入三、双链表的删除四、双链表的遍历五、知识点回顾一、定义双链表 代码实现&#xff1a; #include<stdio.h> typedef int ElemType; typedef struct DNode { //定义双链表结点类型ElemType data; //数据域struct D…
阅读更多...
50 链表排序（Sort List）

50 链表排序（Sort List）

文章目录1 题目2 解决方案2.1 思路2.2 时间复杂度2.4 空间复杂度3 源码1 题目 题目&#xff1a;链表排序&#xff08;Sort List&#xff09; 描述&#xff1a;在 O(nlogn) 时间复杂度和常数级的空间复杂度下给链表排序。 lintcode题号——98&#xff0c;难度——medium 样例1&…
阅读更多...
单链表-不带头结点（创建，插入）

单链表-不带头结点（创建，插入）

为什么要使用链表&#xff0c;因为链表可以连接数据类型不一样的数据&#xff0c;而一个数组中只能使用一种数据类型。 以学生为例&#xff1a; 一个学生有学号&#xff0c;姓名&#xff0c;年龄&#xff0c;性别&#xff0c;等&#xff0c;先拿这四个用着。开始下面的内容&…
阅读更多...
44 K组翻转链表（Reverse Nodes in k-Group）

44 K组翻转链表（Reverse Nodes in k-Group）

文章目录1 题目2 解决方案2.1 思路2.2 时间复杂度2.3 空间复杂度3 源码1 题目 题目&#xff1a;K组翻转链表&#xff08;Reverse Nodes in k-Group&#xff09; 描述&#xff1a;给定一个链表&#xff0c;一次反转链表 k 的节点并返回其修改后的列表。如果节点的数量不是k的倍…
阅读更多...
静态链表基本操作（C语言实现）详解

静态链表基本操作（C语言实现）详解

上节，我们初步创建了一个静态链表，本节学习有关静态链表的一些基本操作，包括对表中数据元素的添加、删除、查找和更改。 本节是建立在已能成功创建静态链表的基础上，因此我们继续使用上节中已建立好的静态链表学习本节内容，建立好的静态链表如图 1 所示： …
阅读更多...
JavaScript——反转链表

JavaScript——反转链表

题目描述 输入一个链表&#xff0c;反转链表后&#xff0c;输出新链表的表头。 例如&#xff1a; 输入&#xff1a;a->b->c->d->e 输出&#xff1a;a<-b<-c<-d<-e 反转链表示意图如下&#xff0c;链表的最后一个元素next指向null。 /*function Li…
阅读更多...
【算法】链表算法题思路

【算法】链表算法题思路

做了很多链表相关的算法题&#xff0c;感觉解题思路不外乎下面三种&#xff1a; 1. 一快一慢双指针 比如&#xff0c;倒数第k个节点问题&#xff0c;判断有环链表的入环节点 2. 使用栈结构 比如&#xff0c; 3. pre&#xff0c;cur&#xff0c;next三指针同时出击。 比如…
阅读更多...
人懵了！面试官灵魂一问，并发下的 HashMap 为什么会引起死循环？

人懵了！面试官灵魂一问，并发下的 HashMap 为什么会引起死循环？

今天研读Java并发容器和框架时&#xff0c;看到为什么要使用ConcurrentHashMap时&#xff0c;其中有一个原因是&#xff1a;线程不安全的HashMap, HashMap在并发执行put操作时会引起死循环&#xff0c;是因为多线程会导致HashMap的Entry链表形成环形数据结构&#xff0c;查找时…
阅读更多...
分析Collection常用的实现类

分析Collection常用的实现类

通过源代码分析CollectionConllection&#xff08;集合&#xff09;概念集合与数组的差别数据结构集合框架之间的关系Collection 下的接口&#xff08;常用的&#xff09;1.ListArrayList数据结构优点缺点LinkedList数据结构优点缺点Vector2.SetHashSetTreeSetCollection中定义…
阅读更多...
链表--LeetCode 203、移除链表元素

链表--LeetCode 203、移除链表元素

1、题目 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5]2、解答 直接遍历法&#xff1a;链表遍历即可递…
阅读更多...
JavaDS - LinkedList与链表

JavaDS - LinkedList与链表

一、ArrayList的缺陷 通过源码知道&#xff0c;ArrayList底层使用数组存储元素。由于其底层是一段连续存储空间&#xff0c;当ArrayList任意位置插入或者删除元素时&#xff0c;就需要将后序元素整体往前或者往后搬移&#xff0c;时间复杂度为O(N)&#xff0c;效率较低&#…
阅读更多...
循环链表的创建、插入、删除、逆序、显示（C++实现）

循环链表的创建、插入、删除、逆序、显示（C++实现）

对于单链表，由于每个结点只存储了向后的指针。到了尾标志就停止了向后链的操作，这样，当中某一结点就无法找到它的前驱结点了。 对于单链表的操作大家可以看我的这篇博客http://blog.csdn.net/zxnsirius/article/details/51183055 我们将单链表中终端结点的指针端由空指针改…
阅读更多...
大二 数据结构 期末复习自用（仅供参考）

大二 数据结构 期末复习自用（仅供参考）

课本&#xff1a;数据结构&#xff08;C语言版&#xff09; 严蔚敏 数据结构期中考试&#xff0c;重点考查内容 1.时间复杂度的计算 2.语句的执行频度 3.顺序表的删除、插入、查找的算法与分析 4.单链表的删除、插入算法与分析 5.单链表的头插法与尾插法 6.线性表的合并&#x…
阅读更多...
力扣02. 两数相加

力扣02. 两数相加

给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0c;这两个数都不会以 0 …
阅读更多...
【C语言】链表的操作——增删改查——一文详解

【C语言】链表的操作——增删改查——一文详解

1.什么是链表 1.1什么是链表 链表是一种物理存储单元上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点&#xff08;链表中每一个元素称为结点&#xff09;组成&#xff0c;结点可以在运行时动态生成。每个结点包…
阅读更多...
C语言数据结构-链表

C语言数据结构-链表

C语言数据结构-链表 前言 个人博客原文地址&#xff1a;C语言数据结构-链表 更多更好的博客欢迎前往个人博客浏览&#xff01; 这篇博客属于学习笔记&#xff0c;是博主在学习链表时的一些笔记&#xff0c;所以不保证内容的完全正确性和严谨性以及简洁等。 此外由于属于学习…
阅读更多...
第二章--顺序表和链表的比较

第二章--顺序表和链表的比较

目录一、逻辑结构二、存储结构三、基本操作1.创建2.销毁3.插入删除操作4.查找四、用顺序表还是链表&#xff1f;一、逻辑结构 各数据元素之间有一对一的关系 二、存储结构 三、基本操作 1.创建 2.销毁 3.插入删除操作 4.查找 四、用顺序表还是链表&#xff1f;
阅读更多...
链表是否有环，是否相交

链表是否有环，是否相交

1. 有环单链表 1.1 判断单链表是否有环 快慢指针法&#xff1a; 使用两个指针slow&#xff0c;fast同时指向头结点&#xff0c;然后slow每次走一步&#xff0c;fast每次走两步&#xff0c;若二者相遇(指向相同结点)&#xff0c;则有环。 def is_ring(head):if not head:retu…
阅读更多...
双向链表及其创建（C语言）详解

双向链表及其创建（C语言）详解

目前我们所学到的链表，无论是动态链表还是静态链表，表中各节点中都只包含一个指针（游标），且都统一指向直接后继节点，通常称这类链表为单向链表（或单链表）。 虽然使用单链表能 100% 解决逻辑关系为 "一对一" 数据的存储问题，但在解决某些特殊问题时，单链表并…
阅读更多...
实现单链表各种基本运算的算法

实现单链表各种基本运算的算法

#include <iostream> #include <stdio.h> #include <stdlib.h> using namespace std;//单链表节点定义 typedef struct LNode {int data;struct LNode* next; }LNode, * LinkList; LinkList L;//1.前插法初始化单链表 void CreatList_head(LinkList& L, …
阅读更多...
数据结构及算法之链表讲解

数据结构及算法之链表讲解

1&#xff0c;普通实现方式 package com.dream21th.algorithmicdatastructure.linkedlist;/*** Auther: hp* Date: 2019/9/13 16:07* Description:*/ public class LinkList<E> {private class Node{public E e;public Node next;public Node(E e, Node next) {this.e e…
阅读更多...
unity应用实例——电梯模拟系统

unity应用实例——电梯模拟系统

电梯模拟系统是很多计算机专业的大学生必做的题目，整个系统有着复杂严谨的逻辑。而unity作为一个强大的游戏引擎，除了开发游戏外，也可以作为一个可视化软件，用来模拟电梯的运行再好不过。这篇博客就给大家介绍一个用unity可视化的电梯系统，下面先上效果图。 …
阅读更多...
C语言 -- 链表（企业级，侵入式链表）

C语言 -- 链表（企业级，侵入式链表）

目录 节点结构体的实现 初始化链表 插入链表 遍历链表 删除节点、销毁链表 用户test 侵入式链表&#xff0c;内核链表 普通单链表和侵入式单链表的区别在于&#xff1a; 普通的单链表的结点指针域指向的是下一个结点的内存首地址&#xff1b;侵入式单链表的结点指针域指…
阅读更多...
递归的优化策略

递归的优化策略

目录 目标 实战&#xff08;以斐波那契数列为例&#xff09; 什么是斐波那契数列 实现 目标 熟悉递归的几种优化策略&#xff08;转化为非递归方法、保存已经存在的值的方法、尾递归方法&#xff09;。实战&#xff08;以斐波那契数列为例&#xff09; 什么是斐波那契数列…
阅读更多...
算法-链表算法总结

算法-链表算法总结

1 哨兵节点 思路&#xff1a;在单链表中移除或添加头结点 和 其他节点的操作方式是不一样&#xff0c;其实在写代码的时候也会发现&#xff0c;需要单独写一段逻辑来处理头结点的情况。遇到需要移除和添加节点时&#xff0c;可以设置一个虚拟头结点&#xff0c;这样原链表的所有…
阅读更多...
汇编程序设计-27-栈的设置

汇编程序设计-27-栈的设置

上图是一个栈在内存中的示意图&#xff0c;在cpu中栈顶指针是通过SS寄存器和SP寄存器的组合来表示栈顶指针所指地址的。 在内存中&#xff0c;修改2000:0000的值&#xff0c;既然是通过SS、SP寄存器来设置栈顶指针的&#xff0c;那我们可以改变栈顶的指向&#xff0c;从而决定…
阅读更多...
C语言：L2-022 重排链表 (25 分)

C语言：L2-022 重排链表 (25 分)

文章目录一、题目二、方法11、思路2、代码一、题目 给定一个单链表 L1 → L2 →⋯→ Ln−1 → Ln &#xff0c;请编写程序将链表重新排列为 Ln → L1 → Ln−1 → L2 →⋯。例如&#xff1a;给定L为1→2→3→4→5→6&#xff0c;则输出应该为6→1→5→2→4→3。 输入格式&#…
阅读更多...
C语言：程序设计综合训练

C语言：程序设计综合训练

文章目录综合实验二&#xff1a;学生成绩管理系统1、要求2、代码综合实验五 &#xff1a;万年历系统1、要求2、代码综合实验八&#xff1a;职工信息管理系统1、要求2、代码综合实验二&#xff1a;学生成绩管理系统 1、要求 &#xff08;一&#xff09;程序运行时&#xff0c;…
阅读更多...
链表（14）----合并两个有序链表

链表（14）----合并两个有序链表

1、链表定义 typedef struct ListElement_t_ {void *data;struct ListElement_t_ *next; } ListElement_t;typedef struct List_t_{int size;int capacity;ListElement_t *head;ListElement_t *tail; } List_t;2、合并两个有序链表 ListElement_t * MergeList( ListElement_t *…
阅读更多...
链表（1）----单链表基本操作

链表（1）----单链表基本操作

1、单链表定义 单链表元素定义&#xff1a; typedef struct ListElement_t_{void *data;struct ListElement_t_ *next; } ListElement_t;单链表定义&#xff1a; typedef struct List_t_{int size;int (*match)(const void *key1, const void *key2);int (*destroy)(vo…
阅读更多...
哈希表的创建、添加、查询、显示（删除还不会。。。）

哈希表的创建、添加、查询、显示（删除还不会。。。）

package HashTable;import java.util.Scanner;public class HashTableDemo {public static void main(String[] args) {//创建哈希表HashTable hashTable new HashTable(7);//写一个简单菜单来测试String key "";Scanner scanner new Scanner(System.in);while(tr…
阅读更多...
环形链表解决Josephu环

环形链表解决Josephu环

package linkedlist; //单向环形链表完成Josephu问题 public class Josephu {public static void main(String[] args) {//测试一把&#xff0c;看构建环形链表&#xff0c;黑暗里是否oKCircleSingleLinkedList circleSingleLinkedList new CircleSingleLinkedList();circleSi…
阅读更多...
初学双向链表

初学双向链表

package linkedlist;public class DoubleLinkedListDemo {public static void main(String[] args) {//测试&#xff0c;System.out.println("双向链表的测试");//先创建节点HeroNode2 hero01 new HeroNode2(1, "宋江", "及时雨");HeroNode2 he…
阅读更多...
第四十期-ARM Linux内核的中断（10）

第四十期-ARM Linux内核的中断（10）

作者&#xff1a;罗宇哲&#xff0c;中国科学院软件研究所智能软件研究中心 上一期中我们介绍了ARM Linux内核中添加工作项的关键函数&#xff0c;这一期我们继续介绍其他与工作队列相关的关键函数。 一、ARM Linux内核与工作队列相关的关键函数 从第38期我们可以知道&#…
阅读更多...
【Python数据结构】单链表的实现

【Python数据结构】单链表的实现

单链表的节点实现 class SingleNode(object):def __init__(self,elem):self.elem elem #item存放数据元素self.next None #next指向下一个结点的标识单链表的实现 class SingleLinkList(object):def __init__(self,node None):self.__head Nonedef is_empty(self):#判断链…
阅读更多...
LeeCode刷题-II DataWhale 天池

LeeCode刷题-II DataWhale 天池

创建于&#xff1a;20220215 文章目录1、Task01 数组15. 三数之和26. 删除有序数组中的重复项27. 移除元素2、Task02 链表21. 合并两个有序链表160. 相交链表82. 删除排序链表中的重复元素 II3、Task03 栈155. 最小栈844. 比较含退格的字符串227. 基本计算器 II4、字符串680. 验…
阅读更多...
Leetcode-每日一题【234.回文链表】

Leetcode-每日一题【234.回文链表】

题目 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,2,1]输出&#xff1a;true 示例 2&#xff1a; 输入&#xff1a;head…
阅读更多...
测试开发学习

测试开发学习

网易&#xff1a; 1.TCP的三次握手和四次挥手 中断连接端可以是Client端&#xff0c;也可以是Server端。 假设Client端发起中断连接请求&#xff0c;也就是发送FIN报文。Server端接到FIN报文后&#xff0c;意思是说"我Client端没有数据要发给你了"&#xff0c;但是…
阅读更多...
队列概念及代码实现

队列概念及代码实现

目录 队列概念 队列分类 具体实现 队列概念 FIFO在队首出队&#xff0c;队尾入队&#xff0c;是一种先进先出的数据结构。 举例&#xff1a;元素添加1&#xff0c;2&#xff0c; 3&#xff0c;出队顺序按照排队顺序还是1&#xff0c;2&#xff0c;3就比如生活中的排队&…
阅读更多...
51 合并排序数组（Merge Two Sorted Arrays）

51 合并排序数组（Merge Two Sorted Arrays）

文章目录1 题目2 解决方案2.1 思路2.3 时间复杂度2.4 空间复杂度3 源码1 题目 题目&#xff1a;合并排序数组&#xff08;Merge Two Sorted Arrays&#xff09; 描述&#xff1a;将按升序排序的整数数组A和B合并&#xff0c;新数组也需有序。 lintcode题号——6&#xff0c;难…
阅读更多...
数据结构与算法 — 双向链表

数据结构与算法 — 双向链表

双向链表定义 双向链表也叫双链表&#xff0c;是链表的一种&#xff0c;它的每个数据结点中都有两个指针&#xff0c;分别指向直接后继和直接前驱。所以&#xff0c;从双向链表中的任意一个结点开始&#xff0c;都可以很方便地访问它的前驱结点和后继结点。 双向链表与单链表…
阅读更多...
47 带环链表II（Linked List Cycle II）

47 带环链表II（Linked List Cycle II）

文章目录1 题目2 解决方案2.1 思路2.2 时间复杂度2.3 空间复杂度3 源码1 题目 题目&#xff1a;带环链表II&#xff08;Linked List Cycle II&#xff09; 描述&#xff1a;给定一个链表&#xff0c;如果链表中存在环&#xff0c;则返回到链表中环的起始节点&#xff0c;如果没…
阅读更多...
leetcode 环形链表 II

leetcode 环形链表 II

142. 环形链表 II 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测…
阅读更多...
leetcode 删除链表的倒数第 N 个结点

leetcode 删除链表的倒数第 N 个结点

19. 删除链表的倒数第 N 个结点 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] 示例 2&#xff1a; 输入&#xff1a;head [1], n 1 输出&a…
阅读更多...
链表中倒数第k个结点(快慢指针问题)

链表中倒数第k个结点(快慢指针问题)

⭐️ 往期相关文章 &#x1f4ab;链接1&#xff1a;leetcode 876.链表的中间结点(快慢指针问题) &#x1f4ab;链接2&#xff1a;leetcode 206.反转链表 &#x1f4ab;链接3&#xff1a;leetcode 203.移除链表元素 &#x1f4ab;链接4&#xff1a;数据结构-手撕单链表代码详解…
阅读更多...
合并两个链表

合并两个链表

题目描述&#xff1a; 给你两个链表 list1 和 list2 &#xff0c;它们包含的元素分别为 n 个和 m 个。 请你将 list1 中第 a 个节点到第 b 个节点删除&#xff0c;并将list2 接在被删除节点的位置。 下图中蓝色边和节点展示了操作后的结果&#xff1a; 链接&#xff1a;htt…
阅读更多...
LeetCode 876、链表的中间结点

LeetCode 876、链表的中间结点

LeetCode 876、链表的中间结点 题目 题解 方法1 先遍历一次链表计算出中间结点的位置&#xff0c;第二次遍历指向中间结点。 class Solution { public:ListNode* middleNode(ListNode* head) {ListNode* node head;int count 0;// 遍历&#xff0c;计算结点个数while (no…
阅读更多...
LeetCode 019、删除链表的倒数第N个结点

LeetCode 019、删除链表的倒数第N个结点

LeetCode 019、删除链表的倒数第N个结点 题目 题解 设置快慢指针解决 class Solution { public:ListNode* removeNthFromEnd(ListNode* head, int n) {ListNode* dummy new ListNode(-1);dummy->next head;ListNode* slow dummy, *fast head;while (--n) {fast fast…
阅读更多...
*剑指offer 055、 链表中环的入口结点

*剑指offer 055、 链表中环的入口结点

剑指offer 055、 链表中环的入口结点 题目 题解 利用快慢指针&#xff0c;从头结点开始出发&#xff0c;fast指针每次移动两个节点&#xff0c;slow每次移动一个节点&#xff0c;如果 fast 和 slow指针在途中相遇 &#xff0c;说明这个链表有环。 相遇时&#xff1a; slow指针…
阅读更多...
LeetCode第177场周赛

LeetCode第177场周赛

第177场周赛 第一次参加周赛&#xff0c;菜的一批&#xff0c;只做出BC 5169.日期之间隔几天 请你编写一个程序来计算两个日期之间隔了多少天。 日期以字符串形式给出&#xff0c;格式为 YYYY-MM-DD&#xff0c;如示例所示。 示例 1&#xff1a; 输入&#xff1a;date1 …
阅读更多...
寄！最能体现迭代思想的一道题，反转链表！【C++】

寄！最能体现迭代思想的一道题，反转链表！【C++】

读完本文&#xff0c;你可以去力扣拿下如下题目&#xff1a; 92.反转链表II 反转单链表的迭代实现不是一个困难的事情&#xff0c;但是递归实现就有点难度了&#xff0c;如果再加一点难度&#xff0c;让你仅仅反转单链表中的一部分&#xff0c;你是否能够递归实现呢&#xff1…
阅读更多...
*剑指offer 026、二叉搜索树与双向链表

*剑指offer 026、二叉搜索树与双向链表

剑指offer 026、二叉搜索树与双向链表 题目 题解 解法1 第一种解法是违背题目要求&#xff08;不得创建新的结点&#xff09;的做法&#xff1a; 将二叉搜索进行中序遍历即可得到由小到大的顺序排列&#xff0c;通过中序遍历将二叉树元素存储下来&#xff0c;然后将数组中的…
阅读更多...
82. 删除排序链表中的重复元素 II（不保留重复的）

82. 删除排序链表中的重复元素 II（不保留重复的）

第一次尝试 给定一个排序链表&#xff0c;删除所有含有重复数字的节点&#xff0c;只保留原始链表中没有重复出现的数字。链表为无头结点、单向、不循环。&#xff08;由于涉及到结构体&#xff0c;所以写不了完整的测试代码&#xff0c;下面展示的代码为LeetCode中写的代码&am…
阅读更多...
邻接表无向图的广度优先遍历C/C++代码实现

邻接表无向图的广度优先遍历C/C++代码实现

广度优先遍历&#xff1a; 与深度优先遍历不同&#xff0c;广度优先遍历还需要一个辅助队列&#xff0c;用来按顺序存储遍历过的顶点以便出队的顶点总是先被遍历的顶点。 以该图为例&#xff1a; 代码如下&#xff1a; #include<stdio.h>#define MVNum 100 typedef …
阅读更多...
如何合并两个有序链表？

如何合并两个有序链表？

如何 合并两个有序链表 &#xff1f; 假设链表 a 和 b 的长度都是 n&#xff0c;要在 O(n) 的时间代价以及 O(1) 的空间代价完成合并。我们的宗旨是 [原地调整链表元素的 next 指针完成合并]。 首先需要一个变量 head 来保存合并之后链表的头部&#xff0c;可以将 head 设置为…
阅读更多...
142. 环形链表 II（找循环点）

142. 环形链表 II（找循环点）

第一次尝试 给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 NULL。表为无头结点、单向。&#xff08;由于涉及到结构体&#xff0c;所以写不了完整的测试代码&#xff0c;下面展示的代码为LeetCode中写的代码&#xff09;(LeetCode链…
阅读更多...
数据结构 链队列的各种操作 c/c++代码（连更）

数据结构 链队列的各种操作 c/c++代码（连更）

#include<iostream> using namespace std;typedef struct Lnode{ // 每一个结点 ElemType data;struct Lnode *next; // 下一个结点的地址 }Lnode;typedef struct LinkQueue{ // 链队列 Lnode *front, *rear; }LinkQueue;// 初始化链表 void InitQueue(LinkQueue &…
阅读更多...
数据结构 链表各种操作 c/c++代码（连更）

数据结构 链表各种操作 c/c++代码（连更）

#include<iostream> #include <stdlib.h> using namespace std;//结果状态码 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2typedef struct{ // 首先定义一个学生结构体&#xff0c;作为链表的数据域类…
阅读更多...
【链表】Banana带你一起学链表，看了不吃亏，看了不上当！！！

【链表】Banana带你一起学链表，看了不吃亏，看了不上当！！！

目录在这里哦~0 勇士救主的故事1 链表的介绍2 链表的特点2.1 优点2.2 缺点2.3 复杂度3 单链表的增操作和删操作3.1 单链表节点的数据结构3.2 增3.3 删4 双链表的增操作和删操作4.1 双链表节点的数据结构4.2 增4.3 删5 实现链表5.1 链表的几个方法5.2 code6 双指针问题 - 环形链…
阅读更多...
【LeetCode】 445. 两数相加 II 链表头插法

【LeetCode】 445. 两数相加 II 链表头插法

题目 题目传送门&#xff1a;传送门&#xff08;点击此处&#xff09; 题解 思路 思考好使用什么样的数据结构&#xff0c;这道题目不是很难 由给出的demo可知&#xff0c;链表开始是高位&#xff0c;候面是低位&#xff0c;要考虑进位的问题直接向下进行相加是不合适的&…
阅读更多...
刷题笔记----每日一题：力扣876. 链表的中间结点

刷题笔记----每日一题：力扣876. 链表的中间结点

如果知道链表的大小就会变得很简单&#xff0c;要只知道大小&#xff0c;我们就要遍历一遍链表&#xff0c;然后在便利一遍求出中间节点。 其实可以用快慢指针来解决这个问题&#xff0c;慢指针走一步&#xff0c;块指针走两步&#xff0c;这样当快指针走到了末尾&#xff0c;慢…
阅读更多...
C语言 创建二叉树及对二叉树的操作

C语言 创建二叉树及对二叉树的操作

代码都是书上的。 需要注意的是怎么输入。 第一行 为自己输入的数据&#xff0c;在创建的二叉树中数据域为char型&#xff0c;故空格和enter键也会被存入二叉树数据中。‘#’号总比二叉树数据结点多一个&#xff0c;不然一直在输入&#xff0c;无法进入输出。输出是中序遍历打…
阅读更多...
无头单链表的增删查改

无头单链表的增删查改

我们之前接触过顺序表&#xff08;如果没有了解的童鞋可以看看我的另一篇Blog&#xff09; 数据结构&#xff1a;顺序表 顺序表的优点与缺点&#xff1a; 我们知道顺序表存储数据可以很容易的对数据进行访问&#xff08;即随机下标访问&#xff09;时间复杂度O&#xff08;1&a…
阅读更多...
链表是否有环，求交点

链表是否有环，求交点

链表是否有环 private static class ListNode {private int val;private ListNode next;public ListNode() {}public ListNode(int val) {this.val val;}Overridepublic String toString() {return val "";}}public static ListNode meetingNode(ListNode head) {L…
阅读更多...
力扣算法 Java 刷题笔记【链表篇】hot100（四）如何判断回文链表（简单） 3

力扣算法 Java 刷题笔记【链表篇】hot100（四）如何判断回文链表（简单） 3

文章目录1. 寻找回文串2. 判断一个字符串是否为回文串3. 判断回文单链表&#xff08;简单&#xff09;优化空间复杂度1. 寻找回文串 地址: https://labuladong.gitee.io/algo/2/17/19/ string palindrome(string s, int l, int r) 2021/11/26 /** 1、length() 方法是针对字符…
阅读更多...
标题：错误票据（sstream读取多行字符串）

标题：错误票据（sstream读取多行字符串）

标题&#xff1a;错误票据 某涉密单位下发了某种票据&#xff0c;并要在年终全部收回。 每张票据有唯一的ID号。全年所有票据的ID号是连续的&#xff0c;但ID的开始数码是随机选定的。 因为工作人员疏忽&#xff0c;在录入ID号的时候发生了一处错误&#xff0c;造成了某个ID…
阅读更多...
链表的创建及基本操作（增、删、改、查）

链表的创建及基本操作（增、删、改、查）

一、链表概述 链表是一种物理存储结构上非连续&#xff0c;非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接次序实现的。与数组区别&#xff1a; 链表是链式的存储结构&#xff0c;数组是顺序的存储结构。 链表通过指针来连接元素与元素&#xff0c;数…
阅读更多...
学习笔记-双向链表与环形链表

学习笔记-双向链表与环形链表

双向链表 在单链表的基础上&#xff0c;每个节点增加了一个pre属性指向前一个节点。 因为单链表只有next指针&#xff0c;因此只能单向遍历。而双向链表可以从前或从后遍历。另外也可以自我删除&#xff0c;也就是不用借助被删节点的前一个节点进行删除&#xff0c;直接靠自己…
阅读更多...
数据结构-双向链表的实现

数据结构-双向链表的实现

[1].[文件] DoubleNodeList.java ~ 4KB 下载(8) 跳至 [1] view source print?001 /** 002 * 双向链表的实现<br> 003 * 时间:2014.3.18 004 * author Skip 005 * version 1.0 006 */ 007 public class DoubleNodeList<T> { 008 //节点类 009 priv…
阅读更多...
双向 链表

双向 链表

目录 一、双向链表的实现 二、顺序表和带头双向循环链表的区别 愿你熬过万丈孤苦&#xff0c;藏下星辰大海。 一、双向链表的实现 带头、双向、循环 头部的prev指向尾部&#xff0c; List.h #pragma once #include <stdio.h> #include <stdlib.h> #include …
阅读更多...
LRU缓存机制的两种实现：LInkedHashMap实现、自己构建双链表+HashMap实现

LRU缓存机制的两种实现：LInkedHashMap实现、自己构建双链表+HashMap实现

问题描述&#xff1a;运用你所掌握的数据结构&#xff0c;设计和实现一个 LRU (最近最少使用) 缓存机制 。 实现 LRUCache 类&#xff1a; LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中&#xff0c;则返回…
阅读更多...
Java集合源码分析（十五）：HashMap（1.7版本和1.8版本）

Java集合源码分析（十五）：HashMap（1.7版本和1.8版本）

HashMap集合是Map这个接口下的实现类中最为常用的一种&#xff0c;也是面试中经常会被问到的问题之一。由于HashMap用到的数据结构较为复杂&#xff0c;与其相关的问题通常不好回答&#xff0c;尤其是在jdk1.8之后&#xff0c;又引入了红黑树结构&#xff0c;其数据结构变得更加…
阅读更多...
Java集合源码分析（七）：Iterable接口

Java集合源码分析（七）：Iterable接口

遍历集合我相信大部分coder都会遇到&#xff0c;也经常使用&#xff0c;而Java给我们提供了多种选择&#xff0c;接下来就让我们一起来看看吧&#xff01; 这里我们给定一个集合strings 写法1–循环 for (int i 0, len strings.size(); i < len; i) {System.out.printl…
阅读更多...
Java集合源码分析（四）：二叉排序树

Java集合源码分析（四）：二叉排序树

解决查询速度慢的方案除了我们之前讲的哈希表外&#xff0c;还可以使用二叉排序树。我们知道&#xff0c;查询慢主要是因为不知道元素的位置&#xff0c;使用hash函数映射虽然解决了相关问题&#xff0c;但其并不稳定&#xff0c;如果出现大量的哈希碰撞&#xff0c;其表现其实…
阅读更多...
Java集合源码分析（二）：哈希表

Java集合源码分析（二）：哈希表

在Java集合源码分析&#xff08;一&#xff09;&#xff1a;数组和链表的讨论中&#xff0c;我们知道数组和链表在查询方面都表现得很吃力&#xff0c;想要知道一个元素是否在数组中&#xff0c;只能一个一个去遍历对比。这个问题的根源就在于我们没有办法根据一个元素去找到他…
阅读更多...
java集合源码分析（一）：数组与链表

java集合源码分析（一）：数组与链表

数组和链表是数据结构中最基本的部分&#xff0c;也是众多数据结构的基础。在Java中这两种结构的使用也很广泛。今天就让我们来进行简要分析。 一、数组 在Java中&#xff0c;数组是被定为一种基本类型&#xff0c;其可以通过下标获取到对应位置的数据。 那么这边结构在内存中…
阅读更多...
AbstractQueuedSynchronizer原理及应用

AbstractQueuedSynchronizer原理及应用

目录 AQS- 抽象队列同步器 AQS- 抽象队列链表结构 AQS- 核心方法入队出队 AQS- 具体实现及应用场景 AQS- 抽象队列同步器 AQS是抽象队列同步器&#xff1b;是一个抽象类&#xff0c;通过继承的方式使用&#xff1b;内部实现CLH队列&#xff0c;是一个FIFO的双向链表&#x…
阅读更多...
LinkedList for 和 forEach遍历分析

LinkedList for 和 forEach遍历分析

Java中LinkenList数据结构->链表 链式存储&#xff0c;Sequential Access&#xff1a; 这种方式&#xff0c;每一个数据元素&#xff0c;在内存中都不要求处于相邻的位置&#xff0c;每个数据元素包含他的下一个元素的内存地址&#xff0c;不可以根据元素的位置直接计算出内…
阅读更多...
HashMap keySet与entrySet遍历分析

HashMap keySet与entrySet遍历分析

keySet(): 返回的是只存放key值的Set集合&#xff0c;使用迭代器方式遍历该Set集合&#xff0c;在迭代器中再使用get方法获取每一个键对应的值 代码案例&#xff1a; keySet遍历代码 /*** 通过keySet遍历* param map*/ public static void keySetTest(Map<String ,Objec…
阅读更多...
合并两个及以上有序链表问题

合并两个及以上有序链表问题

合并两个及以上有序链表问题 作者&#xff1a;Grey 原文地址: 博客园&#xff1a;合并两个及以上有序链表问题 CSDN&#xff1a;合并两个及以上有序链表问题 题目一&#xff1a;合并两个有序链表 题目链接 题目一思路 设置两个指针&#xff0c;一个指针&#xff08;t1&…
阅读更多...
后端学习----java11集合框架list的使用

后端学习----java11集合框架list的使用

byte、int、short、long、double、float、boolean、char&#xff1b; 对应的包装类型也有八种&#xff1a;Byte、Integer、Short、Long、Double、Float、Character、Boolean;(已final&#xff0c;不可重写) list接口实现的方法&#xff1a;get 、remove 、subList(first,…
阅读更多...
C++复习之路：算法与数据结构相关 8：快慢指针

C++复习之路：算法与数据结构相关 8：快慢指针

快慢指针主要用于链表相关的问题 1.寻找链表中部 思路&#xff1a;设置慢指针步长为1&#xff0c;快指针步长为2&#xff0c;同时出发&#xff0c;当快指针到尾部时&#xff0c;慢指针到了中部&#xff1b;需要注意链表个数是奇数还是偶数 ListNode * searchMid(ListNode * …
阅读更多...
链表倒数第k个节点衍生之「删除链表中倒数第 k 个节点」

链表倒数第k个节点衍生之「删除链表中倒数第 k 个节点」

相对于「链表中倒数第 k 个节点」&#xff0c;需要时刻维护一个前置节点&#xff0c;最终left指向的节点就是需要删除的节点&#xff1b; 当然&#xff0c;也可以不用维护&#xff0c;通过设置哨兵的方式&#xff0c;使得最终left.next就是需要删除的节点&#xff0c;最后让le…
阅读更多...
剑指Offer系列之「合并两个排序的链表」

剑指Offer系列之「合并两个排序的链表」

输入两个单调递增的链表&#xff0c;输出两个链表合成后的链表&#xff0c;当然我们需要合成后的链表满足单调不减规则。 初始化&#xff1a;定义 cur 指向新链表的头结点 操作&#xff1a; 如果list1指向的结点值小于list2指向的结点值&#xff0c;则将l1指向的结点值链接到c…
阅读更多...
C Primer Plus 第六版(中文版)第十七章(完美修订版)编程练习答案

C Primer Plus 第六版(中文版)第十七章(完美修订版)编程练习答案

//本博主所写的代码仅为阅读者提供参考&#xff1b; //附上课后编程练习题目&#xff1b; //若是对您有用的话请点赞或分享提供给它人&#xff1b; //此书最复杂的数据结构章节&#xff0c;需注意分成不同编译单元进行处理&#xff1b; //此文可能是全网能找到的C Primer P…
阅读更多...
二叉树系列之「二叉树的下一个节点」

二叉树系列之「二叉树的下一个节点」

给定一个二叉树和其中的一个结点&#xff0c;请找出中序遍历顺序的下一个结点并且返回。注意&#xff0c;树中的结点不仅包含左右子结点&#xff0c;同时包含指向父结点的指针。 public class TreeLinkNode {int val;TreeLinkNode left null;TreeLinkNode right null;TreeLin…
阅读更多...
牛客网------KY223二叉排序树（BST的建树、递归遍历）

牛客网------KY223二叉排序树（BST的建树、递归遍历）

题目描述 输入一系列整数&#xff0c;建立二叉排序树&#xff0c;并进行前序&#xff0c;中序&#xff0c;后序遍历。 输入描述: 输入第一行包括一个整数n(1<n<100)。 接下来的一行包括n个整数。输出描述: 可能有多组测试数据&#xff0c;对于每组数据&#xff0c;将…
阅读更多...
LeetCode第180场周赛

LeetCode第180场周赛

5356. 矩阵中的幸运数 暴力解法&#xff1a; 时间复杂度&#xff1a;O&#xff08;mn&#xff09; class Solution {public List<Integer> luckyNumbers (int[][] matrix) {int m matrix.length;int n matrix[0].length;List<Integer> res new ArrayList<…
阅读更多...
快慢指针求解 链表环路问题

快慢指针求解 链表环路问题

一个链表没有环&#xff0c;则遍历一遍会指向最后一个节点然后停下&#xff0c;如果一个存在环路则在遍历的时候会一直循环遍历环的各个节点&#xff0c;那么判断是否有环即判断否当前指针重复指向同一段内存单元&#xff0c;我们可以利用快慢指针来判断&#xff0c;如果遇到的…
阅读更多...
[Leetcode] - 141. 环形链表

[Leetcode] - 141. 环形链表

题目链接 题目&#xff1a; 给定一个链表&#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;我们使用整数 pos 来表示链表尾连接到链表中的位置&#xf…
阅读更多...
Java 手动实现单链表（尾插法和头插法）

Java 手动实现单链表（尾插法和头插法）

原文&#xff1a;https://blog.csdn.net/joob000/article/details/81196165 头插法&#xff1a; 头插法的实现相对简单 思路是将新形成的节点的下一个赋值为header 再把新形成的节点地址传给header即将header向前移动 import java.util.Random; import java.util.Scanner;pub…
阅读更多...
C的数据结构---循环链表

C的数据结构---循环链表

1.插入结点的思想 2. 头删
阅读更多...
链表常见操作：有序链表合并去重

链表常见操作：有序链表合并去重

两个升序链表合并&#xff0c;并要求去掉重复元素 。 分析&#xff1a; 如何使链表本身是有序的&#xff0c;这个我们可以在加入元素的过程中做到合并&#xff0c;并去掉重复元素&#xff0c;这个是难点 思路&#xff1a;主要思想类似于直接插入排序和归并排序。指针p指向list…
阅读更多...
【每天学习亿点点系列】——栈和队列OJ题

【每天学习亿点点系列】——栈和队列OJ题

&#x1f4a5;【每天学习亿点点系列】——栈和队列OJ题1.用队列实现栈图解代码实现2.用栈实现队列图解代码实现这两题的对比3.循环队列用数组还是链表实现注意点1.如果判断为空还是为满了&#xff1f;2.注意索引越界的问题解决方法代码实现1.用队列实现栈 图解 既然要用两个队列…
阅读更多...
【每天学习亿点点系列】——重温栈和队列

【每天学习亿点点系列】——重温栈和队列

&#x1f4a5;【每天学习亿点点系列】——重温栈和队列栈的实现顺序表实现栈头文件以及测试部分代码各个接口的实现1.初始化2.栈的插入3.栈的删除4.栈顶取出数据5.栈里面元素的打印6.记录栈中元素个数7.判空8.栈的销毁单链表实现头文件以及测试部分代码各个接口的实现1.栈的插入…
阅读更多...
【每天学习亿点点系列】——环形链表这些点你思考过吗？

【每天学习亿点点系列】——环形链表这些点你思考过吗？

&#x1f4a5;【每天学习亿点点系列】——环形链表这些点你思考过吗&#xff1f;题目证明方法一&#xff1a;利用证明的猜想来实现代码实现代码二&#xff1a;转化为两个链表找相交节点的问题代码实现题目 在写这题之前&#xff0c;最好先要知道如果判断一个链表是不是环形链表…
阅读更多...
⭐顺序表和链表的这些细节你都注意到了吗？⭐

⭐顺序表和链表的这些细节你都注意到了吗？⭐

⭐顺序表和链表的这些细节你都注意到了吗&#xff1f;⭐顺序表的细节单链表的细节双向带头循环链表的细节栈的细节几者之间的对比链接这几种数据结构完整的代码&#xff0c;都在我其他的博客里面&#xff0c;这篇博客主要的目的是分析其各自的一些细节&#xff0c;以及他们之间…
阅读更多...
力扣题之两数相加

力扣题之两数相加

2.两数相加&#xff08;传送门&#xff09; 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数…
阅读更多...
哈希表基于数组和链表java数据结构篇

哈希表基于数组和链表java数据结构篇

本章学习目录 页内目录 一&#xff0c;哈希表的介绍 二&#xff0c;哈希表的图解 三&#xff0c;哈希表的链表部分 四&#xff0c;哈希表的实现类 五&#xff0c;结果测试与展示 一&#xff0c;哈希表的介绍 哈希表&#xff1a;散列表&#xff08;Hash table&#xff0c;也叫…
阅读更多...
《数据结构与算法》- 线性结构复习题 6-1 有序数组的插入 (10 分)

《数据结构与算法》- 线性结构复习题 6-1 有序数组的插入 (10 分)

分了几种情况&#xff0c;判满&#xff0c;x是表里最大的数&#xff0c;X是最小的数&#xff0c;x和表里某个数相等了&#xff0c;x在中间。 AC代码&#xff1a; bool Insert( List L, ElementType X ) {//判满if(L->Last1MAXSIZE){return false;}//x最大if(L->Data[0]…
阅读更多...
剑指Offer_06 从头到尾打印链表两种方法任你挑选

剑指Offer_06 从头到尾打印链表两种方法任你挑选

⭐欢迎来到剑指offer好题精选专栏&#xff0c;一起学习&#xff0c;一起进步⭐ 题目信息&#xff1a; 输入一个链表的头节点&#xff0c;按链表从尾到头的顺序返回每个节点的值&#xff08;用数组返回&#xff09;。 如输入{1,2,3}的链表如下图: 返回一个数组为[3,2,1] 0 &l…
阅读更多...
k个一组翻转链表 哔哩哔哩2020校园招聘笔试题/LeetCode_25（困难）讲解

k个一组翻转链表 哔哩哔哩2020校园招聘笔试题/LeetCode_25（困难）讲解

目录标题一、题目信息二、解题思路三、代码实现四、其他精选题目分享一、题目信息 LeetCode版本 牛客网版本 下面我以牛客网为例写代码 题目需要先输入一组数字代表链表的值&#xff0c;以#代表结尾。 下一行输入K代表每组个数 问题来了&#xff0c;怎么翻转&#xff1f; …
阅读更多...
刷题笔记----每日一题：力扣23. 合并K个升序链表

刷题笔记----每日一题：力扣23. 合并K个升序链表

思路&#xff1a;看到排序&#xff0c;我就很自然的想到最大最小堆&#xff0c;本题适用于最小堆的优先队列&#xff0c;依次从队列中取出队顶元素即可&#xff0c;当然也可以像合并两条链表&#xff08;力扣21题刷题笔记----每日一题&#xff1a;力扣21. 合并两个有序链表&…
阅读更多...
【LeetCode】 141. 环形链表

【LeetCode】 141. 环形链表

题目 题目传送门&#xff1a;传送门&#xff08;点击此处&#xff09; 题解 思路 一个指针作为快指针&#xff0c;另外一个指针作为慢指针&#xff0c;两个指针总会相遇 拿题目中的示例1做例子&#xff0c;每次 slow指针 移动 一 格&#xff0c;fast指针 移动 两 格 cod…
阅读更多...
刷题笔记----每日一题：力扣86. 分隔链表

刷题笔记----每日一题：力扣86. 分隔链表

第一种思路就是比较每个节点与x的大小&#xff0c;分别放在两个链表中&#xff0c;最后将两个链表合并就行了&#xff1a; /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* …
阅读更多...
刷题笔记----每日一题：力扣21. 合并两个有序链表

刷题笔记----每日一题：力扣21. 合并两个有序链表

思想很简单&#xff1a;比较两个链表数值的大小&#xff0c;构建新的链表即可&#xff1a; /*** Definition for singly-linked list->* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(int x) : val(x)…
阅读更多...
redis list ( 链表 )

redis list ( 链表 )

list类型其实就是一个双向链表。通过push,pop操作从链表的头部或者尾部添加删除元素。 这使得list既可以用作栈&#xff0c;也可以用作队列。 上进上出是 栈 &#xff0c;特点&#xff1a;数据 先进后出 下进上出是 队列&#xff0c;特点&#xff1a;数据 先进先出 从时间复杂…
阅读更多...
判断一个链表是否为回文结构

判断一个链表是否为回文结构

题目描述 给定一个链表的头节点head&#xff0c;请判断该链表是否为回文结构。 例如: 1->2->1&#xff0c;返回true。 1->2->2->1&#xff0c;返回true。 15->6->15&#xff0c;返回true。 1->2->3&#xff0c;返回false。 进阶: 如果链表长度为N&…
阅读更多...
详解双向带头循环链表

详解双向带头循环链表

今天给大家分享的数据结构中的链表的双向带头循环链表结构&#xff01;听到这个链表大家可能心中一颤&#xff0c;其实他就是个纸老虎&#xff0c;看着比较难搞&#xff0c;实际上非常简单易懂&#xff0c;创建该结构链表的大佬可谓是真的牛&#xff0c;因为该结构比起单链表要…
阅读更多...
9月2号数据结构学习笔记

9月2号数据结构学习笔记

在2.9节&#xff0c;我写了一个明显错误的代码&#xff0c;是在双链表后初始化头节点后又初始化2个节点&#xff0c;并且分别命名为1&#xff0c;2后&#xff0c;删除第2个节点。然后重新显示这个链表中的每一个元素&#xff0c;我这个display是个死循环&#xff0c;但是也不该…
阅读更多...
9月1号数据结构的学习笔记

9月1号数据结构的学习笔记

看了王道的2.7节关于尾插法创建单链表 完整代码如下&#xff1a; #include<stdio.h> #include<stdlib.h> typedef struct LNode{int data;struct LNode *next; }LNode,*LinkList; LinkList List_Tailinsrt(LinkList&L){int x;L(LinkList)malloc(sizeof(LNode)…
阅读更多...
8.30王道书数据结构学习笔记

8.30王道书数据结构学习笔记

每日考研数据结构的学习笔记&#xff0c;有得地方有错误&#xff0c;大家不要都看。 我想实现头插法建立单链表没有解决 错误的版本 #include<stdio.h> #include<stdlib.h> typedef struct LNode{int data;struct LNode*next; }LNode,*LinkList; LinkList* head(…
阅读更多...
剑指Offer系列之「两个链表的第一个公共节点」

剑指Offer系列之「两个链表的第一个公共节点」

两个链表的第一个公共节点 Java 实现如下&#xff1a; /* public class ListNode {int val;ListNode next null;ListNode(int val) {this.val val;} }*/ public class Solution {public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {if(pHead1 null …
阅读更多...
链表相关面试题第一篇

链表相关面试题第一篇

系列文章目录 文章目录系列文章目录前言一、移除链表元素1.题目描述2.解题思路二、反转单链表1.题目描述2.解题思路三、链表的中间节点1.题目描述2.解题思路四、链表的倒数第k个节点1.题目描述2.解题思路总结前言 一、移除链表元素 移除链表元素 1.题目描述 给你一个链表的头…
阅读更多...
【数据结构从青铜到王者】第三篇:数据结构之双向带头循环链表

【数据结构从青铜到王者】第三篇:数据结构之双向带头循环链表

系列文章目录 文章目录系列文章目录前言一、链表的概念及结构1.链表的概念2.双向带头循环链表结构二、双向带头循环链表实现1.定义链表节点struct ListNode2.创建链表节点BuyListNode函数3.链表初始化ListInit函数4.链表尾部插入数据ListPushBack函数5.链表头部插入数据ListPus…
阅读更多...
数据结构与算法 - 线性表之顺序表与链表结构

数据结构与算法 - 线性表之顺序表与链表结构

线性表&#xff0c;全名为线性存储结构。 简介&#xff1a;将具有“一对一”关系的数据“线性”地存储到物理空间中&#xff0c;这种存储结构就称为线性存储结构&#xff08;简称线性表&#xff09;。 注意&#xff1a;使用线性表的数据所使用的数据类型必须是一致的。 有两种…
阅读更多...
求最大值最小值

求最大值最小值

现给出一串数据&#xff08;313, 89, 123, 323, 313, 15, 90, 56, 39&#xff09;求出最大值和最小值并输出。 import java.util.Arrays; public class MaxAndMin { public static void main(String[] args) { int[] data {313, 89, 123, 323, 313, 15, 90, 56, 39}; // …
阅读更多...
leetcode(21)：Merge Two Sort Lists

leetcode(21)：Merge Two Sort Lists

题目&#xff1a;Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists. Example: Input: 1->2->4, 1->3->4 Output: 1->1->2->3->4->4 分析题目&…
阅读更多...
链表常见操作：环、倒数第k个、是否相交

链表常见操作：环、倒数第k个、是否相交

链表常见操作&#xff1a;判断是否有环 链表中很常见的一问题是&#xff0c;是否有环&#xff1f;如下图&#xff1a; 怎么办呢&#xff1f;正常链表的尾节点的链域是NULL&#xff0c;有环就不存在NULL了&#xff01;对了&#xff0c;用一指针轮询&#xff0c;不断地 pp->n…
阅读更多...
专插本 计算机基础与程序设计 2020届考生纯手敲 C语言与数据结构学习中遇到的所有问题都在这里了，建议直接三连

专插本 计算机基础与程序设计 2020届考生纯手敲 C语言与数据结构学习中遇到的所有问题都在这里了，建议直接三连

文章说明 我考的还可以接受&#xff0c;2b学校应该是能让我随意选了&#xff0c;毕竟也就准备了八十来天&#xff0c;时间不长&#xff0c;成绩我也欣然接受&#xff0c;我把我的专插本专门设立了一个分类&#xff0c;有需要的可以去分类里看&#xff0c;需要可以资料可以私信…
阅读更多...
力扣算法 Java 刷题笔记【链表篇】hot100（二）递归反转链表的一部分 4

力扣算法 Java 刷题笔记【链表篇】hot100（二）递归反转链表的一部分 4

文章目录1. 反转链表&#xff08;简单&#xff09;解法一&#xff1a;递归解法二&#xff1a;迭代2. 反转链表前 N 个节点3. 反转链表前 N 个节点4. 反转链表 II&#xff08;中等&#xff09;1. 反转链表&#xff08;简单&#xff09; 题目描述&#xff1a;递归 迭代 反转整个…
阅读更多...
力扣算法 Java 刷题笔记【链表篇】hot100（一）合并 K 个升序链表（困难） 删除链表的倒数第 N 个结点（中等） 7

力扣算法 Java 刷题笔记【链表篇】hot100（一）合并 K 个升序链表（困难） 删除链表的倒数第 N 个结点（中等） 7

文章目录1. 合并两个有序链表&#xff08;简单&#xff09;2. 合并 K 个升序链表&#xff08;困难&#xff09;3. 环形链表&#xff08;简单&#xff09;4. 环形链表 II &#xff08;中等&#xff09;5. 链表的中间结点&#xff08;简单&#xff09;6. 相交链表&#xff08;简单…
阅读更多...
合并两个有序的单链表，合并之后的链表依然有序

合并两个有序的单链表，合并之后的链表依然有序

定义节点 class ListNode {var next: ListNode _var x: Int _def this(x: Int) {thisthis.x x}override def toString: String s"x>$x" } 定义方法 class LinkedList {var head new ListNode(0)def getHead(): ListNode this.headdef add(listNode: Li…
阅读更多...
从造轮子开始彻底理解LRU缓存机制

从造轮子开始彻底理解LRU缓存机制

Leetcode146. LRU缓存机制 造轮子 在面试中&#xff0c;面试官一般会期望读者能够自己实现一个简单的双向链表&#xff0c;而不是使用语言自带的、封装好的数据结构。所以&#xff0c;造轮子还是很有必要的。 LRU 缓存淘汰算法就是一种常用策略。LRU 的全称是 Least Recentl…
阅读更多...
数据结构--5.1图的存储结构（十字链表、邻接多重表、边集数组）

数据结构--5.1图的存储结构（十字链表、邻接多重表、边集数组）

目录 一、十字链表&#xff08;Orthogonal List&#xff09; 二、邻接多重表 三、边集数组 四、深度优先遍历 一、十字链表&#xff08;Orthogonal List&#xff09; 重新定义顶点表结点结构&#xff1a; datafirstInfirstOut 重新定义边表结构结点&#xff1a; tailV…
阅读更多...
剑指Offer系列之「链表中环的入口节点」

剑指Offer系列之「链表中环的入口节点」

给一个单链表&#xff0c;若其中包含环&#xff0c;请找出该链表的环的入口结点&#xff0c;否则&#xff0c;输出null。 例如&#xff1a; #mermaid-svg-K6fNfoNx4awtZIsY .label{font-family:trebuchet ms, verdana, arial;font-family:var(--mermaid-font-family);fill:#333…
阅读更多...
算法（Java）——链表

算法（Java）——链表

链表是除数组外&#xff0c;另一个常用的数据结构&#xff0c;算法中经常会对链表进行处理&#xff0c;主要是指针的用法。 链表 什么是链表 链表是一种物理存储单元上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针连接次序实现的。每一个链表…
阅读更多...
合并两个排序的链表（入门算法25）

合并两个排序的链表（入门算法25）

题目&#xff1a;输入两个递增排序的链表&#xff0c;合并这两个链表并使新链表中的节点仍然是递增排序的。 示例&#xff1a; 输入&#xff1a;1->2->4, 1->3->4 输出&#xff1a;1->1->2->3->4->4 解题思路&#xff1a; 定义两个head和p对象&…
阅读更多...
数据结构第一天--预备知识

数据结构第一天--预备知识

前言 文章记录每天的学习记录&#xff0c;仅用于温习使用&#xff0c;今天为第一天。 一、基本概念与术语 1.数据元素&#xff1a;数据的基本单位。也简称为元素或者节点。 2.数据项&#xff1a;构成数据元素的不可分割的最小单位&#xff08;属性列&#xff09; 3.数据对…
阅读更多...
删除链表的中间节点

删除链表的中间节点

题目&#xff1a; 示例&#xff1a; 思路&#xff1a; 这个题类似于寻找链表中间的数字&#xff0c;slow和fast都指向head&#xff0c;slow走一步&#xff0c;fast走两步&#xff0c;也许你会有疑问&#xff0c;节点数的奇偶不考虑吗&#xff1f;while执行条件写成fast&&…
阅读更多...
【剑指offer】链表03-JZ25 合并两个排序的链表

【剑指offer】链表03-JZ25 合并两个排序的链表

题目 JZ25 合并两个排序的链表 输入两个递增的链表&#xff0c;单个链表的长度为n&#xff0c;合并这两个链表并使新链表中的节点仍然是递增排序的。 数据范围&#xff1a; 0 ≤ n ≤ 1000&#xff0c;−1000≤节点值≤1000 要求&#xff1a;空间复杂度 O(1)&#xff0c;时间…
阅读更多...
javascript数据结构——链表

javascript数据结构——链表

//Node类 class Node {constructor(element) {this.element element; //加入链表元素的值this.next undefined; //指向链表中下一个元素的指针 } } //模拟链表 class LinkedList {constructor() {this.count 0; //存储链表中元素数量this.head undefined; //指…
阅读更多...
Springboot短信验证码（无需企业商户认证）

Springboot短信验证码（无需企业商户认证）

1、进入阿里云市场购买第三方短信接口 先进入阿里云市场 注意是云市场 搜索&#xff0c;短信 在下方选择一个短信服务&#xff0c;因为是第三方云市场而不是个人商户认证&#xff0c;所以短信的模板不是自己随心所欲的定义的 购买短信服务&#xff08;0元5次体验&#xff0…
阅读更多...
链表排序之快排与归并

链表排序之快排与归并

链表排序之快排与归并 1.对链表进行快速排序 以【4&#xff0c;2&#xff0c;5&#xff0c;3&#xff0c;7&#xff0c;9&#xff0c;0&#xff0c;1】为例&#xff0c;我们来模拟一趟快排的过程。 1、 初始化时&#xff0c;i指向链表首元素4&#xff1b;j i 1&#xff0c;指向…
阅读更多...
[剑指offer]JT26---二叉搜索树与双向链表(琢磨了几天，挺抽象一题)

[剑指offer]JT26---二叉搜索树与双向链表(琢磨了几天，挺抽象一题)

剑指offer第二十六题题目如下思路与代码如下题目如下 输入一棵二叉搜索树&#xff0c;将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点&#xff0c;只能调整树中结点指针的指向 多么简单的题目哦&#xff0c;却将我伤得那么深&#xff01; 思路与代码如下…
阅读更多...
[剑指offer]JT16---合并两个排序的链表(不忘初心，方得始终)

[剑指offer]JT16---合并两个排序的链表(不忘初心，方得始终)

剑指offer第十六题题目如下思路和代码题目如下 思路和代码 输出是一个链表&#xff0c;我创建的这个链表&#xff0c;在赋值的过程中&#xff0c;表头会改变&#xff0c;所以要记录下最初的表头&#xff0c;这就是不忘初心&#xff0c;方得始终呀&#xff01; p->next赋值就…
阅读更多...
散列表数据接口详解

散列表数据接口详解

1、基本概念 散列表的英文叫做“Hash Table”&#xff0c;我们平时也叫它“哈希表”或“Hash表”&#xff0c;散列表用的是数组支持按照下标随机访问的特性&#xff0c;所以散列表其实就是数组的一种扩展&#xff0c;由数组演化而来。可以说是没有数组就没有散列表。 将关键词…
阅读更多...
python剑指offer 链表倒数第k个结点

python剑指offer 链表倒数第k个结点

题目&#xff1a;输入一个链表&#xff0c;输出该链表中倒数第k个结点。 思想&#xff1a;利用两个指针&#xff0c;第一个指针f到达k之后&#xff0c;新建一个指针sencond&#xff0c;遍历最后一个时sencond则为倒数第k个结点 # -*- coding:utf-8 -*- # class ListNode: # …
阅读更多...
LC-相交链表（解法1）

LC-相交链表（解法1）

LC-相交链表&#xff08;解法1&#xff09; 链接&#xff1a;https://leetcode.cn/problems/intersection-of-two-linked-lists/description/ 描述&#xff1a;给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在…
阅读更多...
LeetCode 0023. 合并 K 个升序链表

LeetCode 0023. 合并 K 个升序链表

【LetMeFly】23.合并 K 个升序链表 力扣题目链接&#xff1a;https://leetcode.cn/problems/merge-k-sorted-lists/ 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 示例 1&#xff1a; 输入&…
阅读更多...
c语言算法用数组模拟单链表

c语言算法用数组模拟单链表

由于昨天上算法课的时候实在无聊&#xff0c;突然想出——能不能用数组来模拟链表&#xff0c;于是经过我的尝试&#xff0c;果真成功了&#xff01; 思路&#xff1a; 数组和单链表一样&#xff0c;既有数据域又有指针域&#xff0c;而且数组的指针域是固定指向后一个元素的。…
阅读更多...
特殊链表（循环单链表，循环双链表，静态链表）

特殊链表（循环单链表，循环双链表，静态链表）

目录 1.循环单链表的初始化 2.循环双链表 3. 静态链表 (1)静态链表的初始化 (2)静态链表的插入 1.循环单链表的初始化 typedef int ElemType; typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;bool InitList(LinkList &L) {L(LNode*)malloc(…
阅读更多...
poj2653：Pick-up sticks（链表）

poj2653：Pick-up sticks（链表）

传送门 题意&#xff1a; 按照先后顺序给出线段&#xff0c;求最后在最上面的线段&#xff08;没有在他后面放且与他相交的线段&#xff09;。保证任何时刻最上面的线段不超过1000。(n≤100000)题解&#xff1a; 因为每个时刻不超过1000根&#xff0c;那么维护一个当前位于最…
阅读更多...
两个链表合成需要注意的问题

两个链表合成需要注意的问题

1: 注意有两个链表cur1, cur2, 将cur1.nextcur2; 如果两个链表结合到一起会形成环状, 则会改变cur2, 使cur2成为一个环. 例子1 public class Test02 {public static class ListNode{public int value;public ListNode next;public ListNode(int value){this.value value;}}p…
阅读更多...
leetcode-链表类题目

leetcode-链表类题目

文章目录 链表&#xff08;Linked List&#xff09; 链表&#xff08;Linked List&#xff09; 定义&#xff1a;链表&#xff08;Linked List&#xff09;是一种线性表数据结构&#xff0c;他用一组任意的存储单元来存储数据&#xff0c;同时存储当前数据元素的直接后继元素所…
阅读更多...
【数据结构】链表的回文结构

【数据结构】链表的回文结构

文章目录 &#x1f30f;引言&#x1f9ed;[链表的回文结构](https://www.nowcoder.com/practice/d281619e4b3e4a60a2cc66ea32855bfa?tpId49&&tqId29370&rp1&ru/activity/oj&qru/ta/2016test/question-ranking)&#x1f6a9;&#x1f6a9;题目描述&#xf…
阅读更多...
LeetCode 面试题 03.03. 堆盘子

LeetCode 面试题 03.03. 堆盘子

文章目录 一、题目二、C# 题解 一、题目 堆盘子。设想有一堆盘子&#xff0c;堆太高可能会倒下来。因此&#xff0c;在现实生活中&#xff0c;盘子堆到一定高度时&#xff0c;我们就会另外堆一堆盘子。请实现数据结构 SetOfStacks&#xff0c;模拟这种行为。SetOfStacks 应该由…
阅读更多...
数据结构：二叉树及相关操作

数据结构：二叉树及相关操作

文章目录 前言一、树的概念及结构1.什么是树2. 树的相关概念3.树的表示 二、二叉树概念及结构1.二叉树概念2.特殊的二叉树3.二叉树的性质4.二叉树的存储结构 三、平衡二叉树实现1.创建树和树的前中后遍历1.前中后遍历2.创建树且打印前中后遍历 2.转换为平衡二叉树和相关操作1.转…
阅读更多...
Java中LinkList的基本介绍和细节讨论。双向链表的代码和LinkList的源码。LinkList和ArrayList的比较与选择。

Java中LinkList的基本介绍和细节讨论。双向链表的代码和LinkList的源码。LinkList和ArrayList的比较与选择。

LinkedList 是 Java 中的一个双向链表实现的类&#xff0c;它实现了 List 接口&#xff0c;同时也实现了 Deque 接口&#xff0c;因此可以用作列表、队列或双端队列。下面是关于 LinkedList 的基本介绍和细节讨论&#xff1a; 基本介绍&#xff1a; LinkedList 是一个双向链表…
阅读更多...
【算法-Java实现】合并两个有序链表

【算法-Java实现】合并两个有序链表

【算法-Java实现】合并两个有序链表 一.问题描述&#xff1a; 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 二.问题解答&#xff1a; 方法&#xff1a;递归 如果 l1 或者 l2 一开始就是空链表 &#xff0c;那么没有…
阅读更多...
剑指offer 24. 反转链表

剑指offer 24. 反转链表

剑指 Offer 24. 反转链表 - 力扣&#xff08;LeetCode&#xff09; (leetcode-cn.com) 目录 方案1 非递归 运行结果 代码 递归 运行结果 代码 方案2 运行结果 代码 方案1 链表节点依次进栈&#xff0c;出栈时调整指针。 非递归 运行结果 代码 class Solution { #…
阅读更多...
52.模块化编程的准备2（链表）

52.模块化编程的准备2（链表）

c语言链表详解&#xff08;超详细&#xff09;_Endeavor_G的博客-CSDN博客_c 链表 C语言链表各类操作详解 - HappyEDay - 博客园 要点 1. typedef struct student{int score;struct student *next; } LinkList; 这里不是顶一个类型为student名为LinkList的结构体&#xff0c…
阅读更多...
算法入门（七，数据结构，单向链表与双链表，python）

算法入门（七，数据结构，单向链表与双链表，python）

链表结构 什么是链表&#xff1f; 链表是一种物理存储单元上非连续&#xff0c;非顺序的存储结构&#xff08;数据元素的逻辑顺序是通过链表中的指针链就接次序实现的&#xff09;链表由一系列结点组成&#xff0c;结点可以在运行时动态生成。 什么是结点&#xff1f; 结点…
阅读更多...
链表中涉及“快慢指针”的编程题—“返回中间节点”

链表中涉及“快慢指针”的编程题—“返回中间节点”

链表中涉及”快慢指针“的编程题—“返回中间节点” 业务要求&#xff1a; 给一个带有头节点 head 的非空单链表&#xff0c;返回链表的中间节点&#xff0c;如果有两个中间节点&#xff0c;则返回第二个中间节点。 一般思路 &#xff1a; 可以遍历完一遍链表&#xff0c;获得…
阅读更多...
Set接口及实现类

Set接口及实现类

1. 概述 Set接口中元素无序&#xff0c;并且都会以某种规则保证存入的元素不出现重复。 特点 不允许存储重复的元素没有索引,没有带索引的方法,也不能使用普通的for循环遍历Set集合取出元素的方式可以采用&#xff1a;迭代器、增强for。普通for不行&#xff01; Set集合有多个…
阅读更多...
【例9-7】链表

【例9-7】链表

(一)单链表 链表是一种常见的数据结构&#xff0c;它是一组结点(node)的序列。线性结构的链表除了单链表外&#xff0c;还有循环链表、双向链表。 《C语言程序设计.主编&#xff1a;衡军山 马晓晨》中只是简单的讲述了单链表&#xff0c; 想了解更多链表知识可以去找《数据结构…
阅读更多...
青岛大学_王卓老师【数据结构与算法】Week04_07_双向链表的删除_学习笔记

青岛大学_王卓老师【数据结构与算法】Week04_07_双向链表的删除_学习笔记

本文是个人学习笔记&#xff0c;素材来自青岛大学王卓老师的教学视频。 一方面用于学习记录与分享&#xff0c;另一方面是想让更多的人看到这么好的《数据结构与算法》的学习视频。 如有侵权&#xff0c;请留言作删文处理。 课程视频链接&#xff1a; 数据结构与算法基础–…
阅读更多...
顺序表链表OJ题(1)——【LeetCode】

顺序表链表OJ题(1)——【LeetCode】

W...Y的主页 &#x1f60a; 代码仓库分享 &#x1f495; 前言&#xff1a; 今天我们来回顾一下顺序表与链表&#xff0c;针对这一块我们也有许多OJ题目供大家参考。当我们学习完顺序表链表后避免不了一些习题的练习&#xff0c;这样才能巩固我们学习的内容。 话不多说&#xf…
阅读更多...
【数据结构】手撕单链表

【数据结构】手撕单链表

目录 一&#xff0c;链表的概念及结构 二&#xff0c;接口实现 1&#xff0c;单链表的创建 2&#xff0c;接口函数 3&#xff0c;动态创立新结点 4&#xff0c;打印 5&#xff0c;头插 6&#xff0c;头删 7&#xff0c;尾插 8&#xff0c;尾删 9&#xff0c;查找 10&#xff…
阅读更多...
7-2 两个有序链表序列的交集 (20分)

7-2 两个有序链表序列的交集 (20分)

7-2 两个有序链表序列的交集 (20分) 已知两个非降序链表序列S1与S2&#xff0c;设计函数构造出S1与S2的交集新链表S3。 输入格式: 输入分两行&#xff0c;分别在每行给出由若干个正整数构成的非降序序列&#xff0c;用−1表示序列的结尾&#xff08;−1不属于这个序列&#…
阅读更多...
LeetCode150道面试经典题-- 合并两个有序链表(简单)

LeetCode150道面试经典题-- 合并两个有序链表(简单)

1.题目 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 2.示例 示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4] 示例 2&#xff1a; 输入&#xff1a;l1 [], l2 [] 输…
阅读更多...
平衡二叉树AVLTree的实现与应用(难度5/10)

平衡二叉树AVLTree的实现与应用(难度5/10)

这是目前难度最高的一个作业&#xff0c;主要难点在于树的平衡&#xff0c;树的平衡依赖于调试输出的图形化&#xff0c;也就是输出二叉树的实现&#xff0c;二叉树的输出技巧性比较强&#xff0c;一般人很难直接想到控制台可以打印二叉树。后面的测试结果显示本文实现的AVLTre…
阅读更多...
C语言之练习题

C语言之练习题

欢迎来到我的&#xff1a;世界 希望作者的文章对你有所帮助&#xff0c;有不足的地方还请指正&#xff0c;大家一起学习交流 ! 目录 前言填空题&#xff1a;第一题第二题第三题第四题 编程题&#xff1a;第一题&#xff1a;第二题&#xff1a; 总结 前言 填空题&#xff1a; …
阅读更多...
4.2 实现基于栈的表达式求值计算器(难度4/10)

4.2 实现基于栈的表达式求值计算器(难度4/10)

本作业主要考察&#xff1a;解释器模式的实现思想/栈结构在表达式求值方面的绝对优势 C数据结构与算法夯实基础作业列表 通过栈的应用&#xff0c;理解特定领域设计的关键作用&#xff0c;给大家眼前一亮的感觉。深刻理解计算机语言和人类语言完美结合的杰作。是作业中的上等…
阅读更多...
Leetcode-每日一题【86.分隔链表】

Leetcode-每日一题【86.分隔链表】

题目 给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你应当 保留 两个分区中每个节点的初始相对位置。 示例 1&#xff1a; 输入&#xff1a;head [1,4,3,2,5,2], x 3输…
阅读更多...
【力扣】707. 设计链表 ＜链表指针＞

【力扣】707. 设计链表 ＜链表指针＞

【力扣】707. 设计链表 【力扣】707. 设计链表原题链接 实现 MyLinkedList 类&#xff1a; MyLinkedList() 初始化 MyLinkedList 对象。int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效&#xff0c;则返回 -1 。void addAtHead(int val) 将一个值为 va…
阅读更多...
LRU cache的实现细节优化——伪结点的技巧

LRU cache的实现细节优化——伪结点的技巧

LRU cache的实现是面试常见的题目&#xff0c;思路比较简单&#xff0c;可以参考思路 这个题目在实际面试中容易出错&#xff0c;主要是npe和头节点与尾节点的更新&#xff0c;有没有办法避免这一点呢&#xff0c;这时可以发现伪节点的好处&#xff0c;永远不用更新头尾节点&am…
阅读更多...
数据结构（Java实现）LinkedList与链表（上）

数据结构（Java实现）LinkedList与链表（上）

链表 逻辑结构 无头单向非循环链表&#xff1a;结构简单&#xff0c;一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构&#xff0c;如哈希桶、图的邻接表等等。 无头双向链表&#xff1a;在Java的集合框架库中LinkedList底层实现就是无头双向循环链表。 链表的…
阅读更多...
【华为OD机试】按单词下标区间翻转文章内容【2023 B卷|100分】

【华为OD机试】按单词下标区间翻转文章内容【2023 B卷|100分】

【华为OD机试】-真题 !!点这里！！ 【华为OD机试】真题考点分类 !!点这里 !! 题目描述： 输入一个英文文章片段，翻转指定区间的单词顺序，标点符号和普通字母一样处理。 例如输入字符串 “I am a developer.”，区间[0,3]则输出 “developer. a am I”。 输入描述： 使用换…
阅读更多...
数据结构学习系列之两个单向链表的合并

数据结构学习系列之两个单向链表的合并

两个单向链表的合并&#xff1a;创建两个单向链表p1和p2&#xff0c;合并p1和p2即可&#xff0c;代码如下&#xff1a;示例代码&#xff1a; int merge_2_link_list(node_t *p1,node_t **p2){if(NULL p1 || NULL p2 || NULL *p2){printf("入参合理性检查\n");ret…
阅读更多...
【数据结构】3000字剖析链表及双向链表

【数据结构】3000字剖析链表及双向链表

文章目录 &#x1f490; 链表的概念与结构&#x1f490;链表的介绍&#x1f490;链表的模拟实现 &#x1f490;双向链表&#x1f490;双向链表的模拟实现 &#x1f490;链表常用的方法&#x1f490;链表及顺序表的遍历&#x1f490;ArrayList和LinkedList的差异 &#x1f490; …
阅读更多...
第 2 章 线性表 （设立尾指针的单循环链表（链式存储结构）实现）

第 2 章 线性表 （设立尾指针的单循环链表（链式存储结构）实现）

1. 背景说明 循环链表(circular linked list)&#xff0c;是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点&#xff0c; 整个链表形成一个环。由此&#xff0c;从表中任一结点出发均可找到表中其他结点 。 2. 示例代码 1) status.h /* DataStruct…
阅读更多...
【牛客面试必刷TOP101】Day2.判断链表中是否有环和链表中倒数最后k个结点

【牛客面试必刷TOP101】Day2.判断链表中是否有环和链表中倒数最后k个结点

作者简介&#xff1a;大家好&#xff0c;我是未央&#xff1b; 博客首页&#xff1a;未央.303 系列专栏&#xff1a;笔试强训选择题 每日一句&#xff1a;人的一生&#xff0c;可以有所作为的时机只有一次&#xff0c;那就是现在&#xff01;&#xff01;&#xff01;&#xff…
阅读更多...
LeetCode 热题 HOT 100：链表专题

LeetCode 热题 HOT 100：链表专题

LeetCode 热题 HOT 100&#xff1a;https://leetcode.cn/problem-list/2cktkvj/ 文章目录 2. 两数相加19. 删除链表的倒数第 N 个结点21. 合并两个有序链表23. 合并 K 个升序链表141. 环形链表142. 环形链表 II148. 排序链表160. 相交链表206. 反转链表234. 回文链表 2. 两数相…
阅读更多...
【剑指Offer】6.从尾到头打印链表

【剑指Offer】6.从尾到头打印链表

题目 输入一个链表的头节点&#xff0c;从尾到头反过来返回每个节点的值&#xff08;用数组返回&#xff09;。 示例 1&#xff1a; 输入&#xff1a;head [1,3,2] 输出&#xff1a;[2,3,1] 解答 源代码 /*** Definition for singly-linked list.* public class ListNode…
阅读更多...
《算法通关村第二关——终于学会链表反转了》

《算法通关村第二关——终于学会链表反转了》

《算法通关村第二关——终于学会链表反转了》 今天学习链表反转 为什么反转这么重要呢&#xff1f;因为反转链表涉及结点的增加、删除等多种操作&#xff0c;能非常有效考察思维能力和代码驾驭能力。另外很多题目也都要用它来做基础&#xff0c; 例如指定区间反转、链表K个一…
阅读更多...
【数据结构】线性表（六）堆栈：顺序栈及其基本操作（初始化、判空、判满、入栈、出栈、存取栈顶元素、清空栈）

【数据结构】线性表（六）堆栈：顺序栈及其基本操作（初始化、判空、判满、入栈、出栈、存取栈顶元素、清空栈）

文章目录 一、堆栈1. 定义2. 基本操作 二、顺序栈0. 顺序表1. 头文件和常量2. 栈结构体3. 栈的初始化4. 判断栈是否为空5. 判断栈是否已满6. 入栈7. 出栈8. 查看栈顶元素9. 清空栈10. 主函数11. 代码整合 堆栈Stack 和 队列Queue是两种非常重要的数据结构&#xff0c;两者都是特…
阅读更多...
【LeetCode力扣】86. 分隔链表

【LeetCode力扣】86. 分隔链表

目录 1、题目介绍 2、解题思路 2.1、双链表双指针 2.2、代码描述 1、题目介绍 原题链接&#xff1a;86. 分隔链表 - 力扣&#xff08;LeetCode&#xff09; 示例 1&#xff1a; 输入&#xff1a;head [1,4,3,2,5,2], x 3 输出&#xff1a;[1,2,2,4,3,5] 示例 2&#xff…
阅读更多...
Leetcode 24 两两交换链表中的节点（链表） null类型是无法调用null.next的，所以一定要在限制条件里面设置好

Leetcode 24 两两交换链表中的节点（链表） null类型是无法调用null.next的，所以一定要在限制条件里面设置好

Leetcode 24 两两交换链表中的节点&#xff08;链表&#xff09; :red_circle:null类型是无法调用null.next的&#xff0c;所以一定要在限制条件里面设置好&#xff0c;限制死:red_circle:null类型是无法调用null.next的&#xff0c;所以一定要在限制条件里面设置好&#xff0c…
阅读更多...
数据结构 每日一练：选择 + 编程

数据结构 每日一练：选择 + 编程

目录 选择 编程 选择 1、 设对n&#xff08;n>1&#xff09;个元素的线性表的运算只有4种&#xff1a;删除第一个元素&#xff0c;删除最后一个元素&#xff0c;在第一个元素之前插入新元素&#xff0c;在最后一个元素之后插入新元素&#xff0c;则最好使用&#xff08;&a…
阅读更多...
【华为OD机试】单词接龙【2023 B卷|100分】

【华为OD机试】单词接龙【2023 B卷|100分】

【华为OD机试】-真题 !!点这里！！ 【华为OD机试】真题考点分类 !!点这里 !! 题目描述： 单词接龙的规则是：可用于接龙的单词首字母必须要前一个单词的尾字母相同； 当存在多个首字母相同的单词时，取长度最长的单词，如果长度也相等， 则取字典序最小的单词；已经参与接龙…
阅读更多...
第 3 章 栈和队列 （使用线性链表和队列实现银行业务模拟）

第 3 章 栈和队列 （使用线性链表和队列实现银行业务模拟）

1. 背景说明 该模拟业务基于时间线来确定&#xff0c;当事件发生时&#xff0c;通过插入升序链表来模拟时间线记录事件发生时间、类型&#xff0c;类似于记事本&#xff0c;由于 时间是单向的&#xff0c;正好符合队列的先进先出特性&#xff0c;类似于我们生活中的排队行为。…
阅读更多...
最短路Dijkstra，spfa，图论二分图算法AYIT---ACM训练(模板版)

最短路Dijkstra，spfa，图论二分图算法AYIT---ACM训练(模板版)

文章目录 前言A - Dijkstra Algorithm0x00 算法题目0x01 算法思路0x02 代码实现 B - 最长路0x00 算法题目0x01 算法思路0x02 代码实现 C - 二分图最大匹配0x00 算法题目0x01 算法思路0x02 代码实现 D - 搭配飞行员0x00 算法题目0x01 算法思路0x02 代码实现 E - The Perfect Sta…
阅读更多...
Java基础面试题精选：深入探讨哈希表、链表和接口等

Java基础面试题精选：深入探讨哈希表、链表和接口等

目录 1.ArrayList和LinkedList有什么区别&#xff1f;&#x1f512; 2.ArrayList和Vector有什么区别&#xff1f;&#x1f512; 3.抽象类和普通类有什么区别&#xff1f;&#x1f512; 4.抽象类和接口有什么区别&#xff1f;&#x1f512; 5.HashMap和Hashtable有什么区别&…
阅读更多...
链表编程题题解

链表编程题题解

文章目录 写在前面反转链表代码实现&#xff1a; 链表内指定区间反转代码实现&#xff1a; 链表中的节点每k个一组翻转代码实现&#xff1a; 合并两个排序的链表代码实现&#xff1a; 合并k个已排序的链表代码实现&#xff1a; 判断链表中是否有环代码实现&#xff1a; 链表中环…
阅读更多...
长度最小的子数组[中等]

长度最小的子数组[中等]

优质博文&#xff1a;IT-BLOG-CN 一、题目 给定一个含有n个正整数的数组和一个正整数target。找出该数组中满足其总和大于等于target的长度最小的连续子数组[numsl, numsl1, ..., numsr-1, numsr]&#xff0c;并返回其长度。如果不存在符合条件的子数组&#xff0c;返回0。 示…
阅读更多...
数据结构与算法-单链表小练习

数据结构与算法-单链表小练习

&#x1f388;类定义 typedef int ElemType; typedef struct LNode {ElemType data;LNode* next; }LNode; class LinkList { private:LNode* head;public:LinkList();~LinkList();int deletelist(int x);void CreatList_h(int n);void print_evennode();void divide_LinkList(…
阅读更多...
【（数据结构）— 单链表的实现】

【（数据结构）— 单链表的实现】

&#xff08;数据结构&#xff09;— 单链表的实现 一.链表的概念及结构二.单链表的实现2.1单链表头文件——功能函数的定义2.2单链表源文件——功能函数的实现2.3 单链表源文件——功能的测试2.4单链表测试结果运行展示 3. 链表的分类 一.链表的概念及结构 概念&#xff1a; …
阅读更多...
大厂真题：【链表】大疆2023秋招-链表合并

大厂真题：【链表】大疆2023秋招-链表合并

题目描述与示例 题目描述 现在有一个链表数组&#xff0c;每个链表内都已经是升序的排序现在请你将所有的链表进行合并&#xff0c;返回合并后的升序链表。 输入描述 一共 n 1行数据 第1行&#xff1a;一共有 n 个链表 第2~n1行&#xff1a;所有的链表 输出描述 合并后的链表的…
阅读更多...
十天学完基础数据结构-第四天（链表（Linked List））

十天学完基础数据结构-第四天（链表（Linked List））

链表的基本概念 链表是一种线性数据结构&#xff0c;与数组不同&#xff0c;链表的元素&#xff08;节点&#xff09;之间通过指针相互连接。链表有以下基本概念&#xff1a; 节点&#xff1a;链表中的每个数据项称为节点&#xff0c;每个节点包含数据和一个指向下一个节点的指…
阅读更多...
剑指offer——JZ25 合并两个排序的链表 解题思路与具体代码【C++】

剑指offer——JZ25 合并两个排序的链表 解题思路与具体代码【C++】

一、题目描述与要求 两个链表的第一个公共结点_牛客题霸_牛客网 (nowcoder.com) 题目描述 输入两个无环的单向链表&#xff0c;找出它们的第一个公共结点&#xff0c;如果没有公共节点则返回空。&#xff08;注意因为传入数据是链表&#xff0c;所以错误测试数据的提示是用其…
阅读更多...
【刷题笔记10.5】LeetCode：排序链表

【刷题笔记10.5】LeetCode：排序链表

LeetCode&#xff1a;排序链表 一、题目描述 给你链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 二、分析 这题咱们默认要求&#xff1a;空间复杂度为O(1)。所以这把咱们用自底向上的方法实现归并排序&#xff0c;则可以达到O(1) 的空间复杂…
阅读更多...
牛客: BM4 合并两个排序的链表

牛客: BM4 合并两个排序的链表

牛客: BM4 合并两个排序的链表 文章目录 牛客: BM4 合并两个排序的链表题目描述题解思路题解代码 题目描述 题解思路 以链表一为主链表,遍历两条链表 若当前链表二的节点val小于当前链表一的下一个节点val,则将链表链表二的该节点连到链表一的节点的下一个,链表一的当前节点往…
阅读更多...
链表oj题 链表与LinkedList 栈的概念 队列的概念 树和二叉树

链表oj题 链表与LinkedList 栈的概念 队列的概念 树和二叉树

第 1 题&#xff08;编程题&#xff09; 题目名称&#xff1a; 求环的入口点 题目内容&#xff1a; 求环的入口点https://leetcode-cn.com/problems/linked-list-cycle-ii/description/ 第 2 题&#xff08;编程题&#xff09; 题目名称&#xff1a; 判断链表带环 题目…
阅读更多...
数据结构---链表(java)

数据结构---链表(java)

目录 1. 链表 2. 创建Node 3. 增加 4. 获取元素 5. 删除 6. 遍历链表 7. 查找元素是否存在 8. 链栈的实现 9. 链队的实现 1. 链表 数据存放在"Node"结点中 优点&#xff1a;不用考虑扩容和缩容的问题&#xff0c;实现了动态存储数据 缺点&#xff1a;没有…
阅读更多...
详解链表oJ＜反转链表，链表的中间节点及链表的回文＞

详解链表oJ＜反转链表，链表的中间节点及链表的回文＞

hello&#xff0c;大家好&#xff0c;这里是Dark FlameMaster,今天和大家分享的是有关数据结构链表的几道题目&#xff0c;链表的中间节点&#xff0c;反转链表及判断链表是否为回文结构&#xff0c;放在一起讲解会印象更加深刻。 文章目录 一&#xff0c;链表的中间节点二&…
阅读更多...
面试算法23：两个链表的第1个重合节点

面试算法23：两个链表的第1个重合节点

题目 输入两个单向链表&#xff0c;请问如何找出它们的第1个重合节点。例如&#xff0c;图4.5中的两个链表的第1个重合节点的值是4。 分析 首先遍历两个链表得到它们的长度&#xff0c;这样就能知道哪个链表比较长&#xff0c;以及长的链表比短的链表多几个节点。在第2次遍…
阅读更多...
【数据结构】双链表的相关操作(声明结构体成员、初始化、判空、增、删、查)

【数据结构】双链表的相关操作(声明结构体成员、初始化、判空、增、删、查)

双链表 双链表的特点声明双链表的结构体成员双链表的初始化带头结点的双链表初始化不带头结点的双链表初始化调用双链表的初始化 双链表的判空带头结点的双链表判空不带头结点的双链表判空 双链表的插入&#xff08;按值插入&#xff09;头插法建立双链表带头结点的头插法每次调…
阅读更多...
31.链表练习题（2）（王道2023数据结构2.3.7节16-25题）

31.链表练习题（2）（王道2023数据结构2.3.7节16-25题）

【前面使用的所有链表的定义在第29节】 试题16&#xff1a;两个整数序列A&#xff0c;B存在两个单链表中&#xff0c;设计算法判断B是否是A的连续子序列。 bool Pattern(LinkList L1,LinkList L2){ //此函数实现比较L1的子串中是否有L2LNode *p, *q; //工作在L1,p记录L1子串…
阅读更多...
数据结构与算法(C语言版)P7---串、数组、广义表

数据结构与算法(C语言版)P7---串、数组、广义表

串、数组、广义表大体了解 我们知道前面学过的__顺序表、链表、栈、队列__&#xff0c;这些都属于线性表。 其中__栈、队列__是操作受限的线性表。 比如&#xff1a; 栈&#xff0c;先进后出&#xff0c;只能在栈顶插入和删除数据。队列&#xff1a;先进先出&#xff0c;只…
阅读更多...
LeetCode讲解篇之138. 随机链表的复制

LeetCode讲解篇之138. 随机链表的复制

LeetCode讲解篇之138. 随机链表的复制 文章目录 LeetCode讲解篇之138. 随机链表的复制题目描述题解思路题解代码 题目描述 题解思路 先遍历一遍链表&#xff0c;用哈希表保存原始节点和克隆节点的映射关系&#xff0c;先只克隆节点的Val&#xff0c;然后再次遍历链表&#xff…
阅读更多...
c语言练习89：链表的使用

c语言练习89：链表的使用

链表的使用 虽然有这么多的链表的结构&#xff0c;但是我们实际中最常⽤还是两种结构&#xff1a; 单链表 和 双向带头循环链表 1. ⽆头单向⾮循环链表&#xff1a;结构简单&#xff0c;⼀般不会单独⽤来存数据。实际中更多是作为其他数据结 构的⼦结构&#xff0c;如哈希桶、…
阅读更多...
2023-9-26 JZ52 两个链表的第一个公共节点

2023-9-26 JZ52 两个链表的第一个公共节点

题目链接&#xff1a;两个链表的第一个公共节点 import java.util.*; /* public class ListNode {int val;ListNode next null;ListNode(int val) {this.val val;} }*/ public class Solution {public ListNode FindFirstCommonNode(ListNode head1, ListNode head2) {ListNo…
阅读更多...
力扣刷题-链表-链表相交

力扣刷题-链表-链表相交

02.07. 链表相交 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c;函数返…
阅读更多...
【数据结构与算法】通过双向链表和HashMap实现LRU缓存 详解

【数据结构与算法】通过双向链表和HashMap实现LRU缓存 详解

这个双向链表采用的是有伪头节点和伪尾节点的 与上一篇文章中单链表的实现不同&#xff0c;区别于在实例化这个链表时就初始化了的伪头节点和伪尾节点&#xff0c;并相互指向&#xff0c;在第一次添加节点时&#xff0c;不需要再考虑空指针指向问题了。 /*** 通过链表与HashMa…
阅读更多...
C++标准模板库STL——list的使用及其模拟实现

C++标准模板库STL——list的使用及其模拟实现

1.list的介绍 list的文档介绍 1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器&#xff0c;并且该容器可以前后双向迭代。 2. list的底层是双向链表结构&#xff0c;双向链表中每个元素存储在互不相关的独立节点中&#xff0c;在节点中通过指针指向 其前一个…
阅读更多...
算法通关村第一关-链表白银经典问题笔记

算法通关村第一关-链表白银经典问题笔记

大家好今天来写第一关的白银挑战-链表经典问题. 两个链表的第一个公共结点 这是一道经典的链表问题 : 输入两个无环的单向链表&#xff0c;找出它们的第一个公共结点&#xff0c;如果没有公共节点则返回空。 牛客NC66 : 剑指offer56 : 分析 : 屡试不爽的方法: 将常用数据…
阅读更多...
《算法通关村第一关——链表经典问题之两个链表的第一个公共子节点问题笔记》

《算法通关村第一关——链表经典问题之两个链表的第一个公共子节点问题笔记》

《算法通关村第一关——链表经典问题之两个链表的第一个公共子节点问题笔记》 问题描述 输入两个链表&#xff0c;找出他们的第一个公共节点。 例如下面的两个链表 两个链表的头节点都是已知的&#xff0c;相交之后成为一个单链表&#xff0c;但是相交的位置未知&#xff0c…
阅读更多...
链表增删操作问题及解决方法

链表增删操作问题及解决方法

目录 链表增加元素首部中间尾部 链表删除元素首部中间尾部 链表是一种常用的数据结构&#xff0c;用于存储和组织数据。在链表中&#xff0c;增加和删除元素是常见的操作。然而&#xff0c;在进行链表的增删操作时&#xff0c;对于首部、中间和尾部位置的元素&#xff0c;都存在…
阅读更多...
算法通关村第一关——链表经典问题之合并有序链表三种方法一层一层优化

算法通关村第一关——链表经典问题之合并有序链表三种方法一层一层优化

算法通关村第一关——链表经典问题之合并有序链表三种方法一层一层优化 题目描述 将两个升序的链表合并为一个新的升序链表并返回&#xff0c;新链表是通过拼接两个给定的两个链表的所有节点组成的。 解题思路 第一种 新建一个链表&#xff0c;然后分别遍历两个链表&#…
阅读更多...
数据结构：简单记录顺序表、链表、栈、队列

数据结构：简单记录顺序表、链表、栈、队列

初学者很容易认为顺序表、链表、栈、队列是四种并列的数据结构&#xff0c;其实仔细想想并不是。 注意区分&#xff1a; 顺序表和链表是指数据的存储结构&#xff0c;是线性表的一种&#xff0c;顺序表一般指的就是数组&#xff0c;数据存储的逻辑顺序和物理顺序都是连续的&a…
阅读更多...
【LeetCode热题100】--19.删除链表的倒数第N个结点

【LeetCode热题100】--19.删除链表的倒数第N个结点

19.删除链表的倒数第N个结点 注意&#xff1a;先声明一个头结点&#xff0c;它的next指针指向链表的头节点&#xff0c;这样就不需要对头节点进行特殊的判断 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListN…
阅读更多...
数据结构： 数组与链表

数据结构： 数组与链表

目录 1 数组 1.1 数组常用操作 1. 初始化数组 2. 访问元素 3. 插入元素 4. 删除元素 5. 遍历数组 6. 查找元素 7. 扩容数组 1.2 数组优点与局限性 1.3 数组典型应用 2 链表 2.1 链表常用操作 1. 初始化链表 2. 插入节点 3. 删除…
阅读更多...
移除元素（简单）

移除元素（简单）

优质博文&#xff1a;IT-BLOG-CN 一、题目 给你一个数组nums和一个值val&#xff0c;你需要"原地"移除所有数值等于val的元素&#xff0c;并返回移除后数组的新长度。不要使用额外的数组空间&#xff0c;你必须仅使用O(1)额外空间并"原地"修改输入数组。元…
阅读更多...
剑指offer——JZ35 复杂链表的复制 解题思路与具体代码【C++】

剑指offer——JZ35 复杂链表的复制 解题思路与具体代码【C++】

一、题目描述与要求 复杂链表的复制_牛客题霸_牛客网 (nowcoder.com) 题目描述 输入一个复杂链表&#xff08;每个节点中有节点值&#xff0c;以及两个指针&#xff0c;一个指向下一个节点&#xff0c;另一个特殊指针random指向一个随机节点&#xff09;&#xff0c;请对此链…
阅读更多...
链表加法与节点交换:数据结构的基础技能

链表加法与节点交换:数据结构的基础技能

目录 两两交换链表中的节点单链表加一链表加法使用栈实现使用链表反转实现 两两交换链表中的节点 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点…
阅读更多...
随机链表的复制（C++解法）

随机链表的复制（C++解法）

题目 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节点的值。新节…
阅读更多...
leetcodetop100 (22) 反转链表

leetcodetop100 (22) 反转链表

给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表 简单的用一个动态数组Arraylist记录&#xff0c;然后倒序遍历赋值给一个新的链表&#xff0c;这种空间复杂度是o(n),估计需要优化。 采用双指针&#xff1b; 我们可以申请两个指针&#xf…
阅读更多...
leetcodeTop100(25)合并两个有序链表

leetcodeTop100(25)合并两个有序链表

合并两个有序链表 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4] package TOP21_30;import Util.ListNode;import java.util.ArrayList; import…
阅读更多...
【简单】206. 反转链表

【简单】206. 反转链表

题目 206. 反转链表 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1] 示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&#xff1a;[2,1] 示…
阅读更多...
LeetCode | 876. 链表的中间结点

LeetCode | 876. 链表的中间结点

LeetCode | 876. 链表的中间结点 OJ链接 我们这里有一个很好的思路&#xff0c;我们定义两个变量&#xff0c;第一个变量走两步&#xff0c;第二个变量走一步&#xff0c;一直循环&#xff0c;当第一个变量走到最后的时候停下来&#xff0c;这个时候第二个变量就是中间的那个…
阅读更多...
【LeetCode刷题-链表】--146.LRU缓存

【LeetCode刷题-链表】--146.LRU缓存

146.LRU缓存 方法一&#xff1a;哈希表双向链表 使用一个哈希表和一个双向链表维护所有在缓存中的键值对 双向链表按照被使用的顺序存储了这些键值对&#xff0c;靠近头部的键值对是最近使用的&#xff0c;而靠近尾部的键值对是最久使用的哈希表即为普通的哈希映射&#xff0…
阅读更多...
leetcode-链表经典题

leetcode-链表经典题

1.反转单链表 206. 反转链表https://leetcode.cn/problems/reverse-linked-list/这里我们使用创建一个变量cur来遍历原链表&#xff0c;再创建一个新节点newnode&#xff0c;首先使用一个循环来遍历原链表&#xff0c;cur为NULL是循环结束&#xff0c;每次进入循环将cur的下一…
阅读更多...
数据结构哈希表（散列）Hash，手写实现（图文推导）

数据结构哈希表（散列）Hash，手写实现（图文推导）

目录 一、介绍 二、哈希数据结构 三、✍️实现哈希散列 1. 哈希碰撞&#x1f4a5; 2. 拉链寻址⛓️ 3. 开放寻址⏩ 4. 合并散列 一、介绍 哈希表&#xff0c;也被称为散列表&#xff0c;是一种重要的数据结构。它通过将关键字映射到一个表中的位置来直接访问记录&#…
阅读更多...
华为OD机考算法题：磁盘容量排序

华为OD机考算法题：磁盘容量排序

题目部分 题目磁盘容量排序难度易题目说明磁盘的容量单位常用的有 M、G、T 三个等级&#xff0c;他们之间的换算关系为 1T 1024G&#xff0c;1G1024M。 现在给定 n 块磁盘的容量&#xff0c;请对他们按从小到大的顺序进行稳定排序。 例如&#xff0c;给定 5 块盘的容量&#x…
阅读更多...
双向链表相关代码

双向链表相关代码

DLinkList.h // // DLinkList.hpp // FirstP // // Created by 赫赫 on 2023/10/31. // 双向链表相关代码&#xff1a;双向链表、循环双向链表#ifndef DLinkList_hpp #define DLinkList_hpp #include <stdio.h> #include <stdlib.h> #include <iostream>…
阅读更多...
【双向链表的插入和删除】

【双向链表的插入和删除】

文章目录 双向链表双向链表的插入双向链表的删除操作 双向链表 双向链表的结构定义如下&#xff1a; //双向链表的结构定义 typedef struct DuLNode {ElemType data;struct DuLNode* prior, * next; }DuLNode,*DuLinkList;双向链表的结点有两个指针域&#xff1a;prior&#…
阅读更多...
JZ23链表中环的入口结点

JZ23链表中环的入口结点

JZ23链表中环的入口结点 思路: 采用双指针&#xff0c;设定快指针fast_p是慢指针slow_p的2倍&#xff0c;如果有环&#xff0c;则当两指针第一次相遇时慢指针一定不可能在环中走超过一圈&#xff0c;因此假设头结点到环的开头距离为a,环开头到第一次相遇节点的距离为b&#xf…
阅读更多...
C++递归解决两两交换链表中节点

C++递归解决两两交换链表中节点

文章目录 C递归解决两两交换链表中节点题目描述解题思路代码复杂度分析 C递归解决两两交换链表中节点 题目描述 24. 两两交换链表中的节点 - 力扣&#xff08;LeetCode&#xff09; 解题思路 这一题的思路和上一道题反转链表的思路十分类似&#xff1a; 首先我们编写递归终止的…
阅读更多...
【Leetcode】【数据结构】【C语言】判断两个链表是否相交并返回交点地址

【Leetcode】【数据结构】【C语言】判断两个链表是否相交并返回交点地址

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {struct ListNode *tailAheadA;struct ListNode *tailBheadB;int count10;int count20;//分别找尾节点&#xff0c;并顺便统计节点数量&#xff1a;while(tailA){tailAtailA->next;c…
阅读更多...
【理解链表指针赋值】链表中cur-＞next = cur-＞next-＞next-＞next与cur =cur-＞next-＞next的区别

【理解链表指针赋值】链表中cur-＞next = cur-＞next-＞next-＞next与cur =cur-＞next-＞next的区别

最近在做链表的题目的时候&#xff0c;对于所定义的cur链表指针产生了一些疑惑&#xff0c;查阅资料后整理一下我的理解&#xff1a; /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode(int x) : val(x), next(n…
阅读更多...
LeetCode |142. 环形链表 II

LeetCode |142. 环形链表 II

LeetCode |142. 环形链表 II OJ链接 一个指针从相遇点开始走&#xff0c;一个指针从头开始走&#xff0c;它们会在入口点相遇~~ struct ListNode *detectCycle(struct ListNode *head) {struct ListNode* slow,*fast;slow fast head;while(fast && fast->next…
阅读更多...
带头+双向+循环链表

带头+双向+循环链表

前言&#xff1a; 前面我们已经学习了单链表的结构及其功能特点&#xff0c;也了解了单链表在实现一些功能时出现的一些缺点&#xff0c;比如在删除某个节点前面一个节点时就需要再开一个变量来存放前面一个节点的信息&#xff0c;这样就显得不灵活&#xff0c;为了使链表实现功…
阅读更多...
AQS 为什么要使用双向链表？

AQS 为什么要使用双向链表？

双向链表 双向链表的特点是它有两个指针&#xff0c;一个指针指向前置节点&#xff0c;一个指针指向后继节点。所以&#xff0c;双向链表可以支持 常量 O(1) 时间复杂度的情况下找到前驱结点&#xff0c;基于这样的特点。双向链表在插入和删除操作的时候&#xff0c;要比单向链…
阅读更多...
【20年扬大真题】试写一算法在带头结点的单链表结构上实现线性表操作LENGTH（L）

【20年扬大真题】试写一算法在带头结点的单链表结构上实现线性表操作LENGTH（L）

【20年扬大真题】 试写一算法在带头结点的单链表结构上实现线性表操作LENGTH&#xff08;L&#xff09;。 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdbool.h> #include<malloc.h> //单链表定义 //链表结点 int A[10] { 1,2,3,4,5,6,…
阅读更多...
力扣114. 二叉树展开为链表（java，用树模拟链表）

力扣114. 二叉树展开为链表（java，用树模拟链表）

Problem: 114. 二叉树展开为链表 文章目录 题目描述思路解题方法复杂度Code 题目描述 给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 1.展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左…
阅读更多...
【数据结构实验】查找（二）基于线性探测法的散列表

【数据结构实验】查找（二）基于线性探测法的散列表

文章目录 1. 引言2. 实验原理2.1 散列表2.2 线性探测法 3. 实验内容3.1 实验题目&#xff08;一&#xff09;输入要求&#xff08;二&#xff09;输出要求 3.2 算法实现三、实验设计3.3 代码整合 4. 实验结果 1. 引言 本实验将通过C语言实现基于线性探测法的散列表 2. 实验原理…
阅读更多...
leetcode-234-回文链表（C语言实现）

leetcode-234-回文链表（C语言实现）

题目&#xff1a; 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,2,1] 输出&#xff1a;true示例 2&#xff1a; 输入&…
阅读更多...
数据结构——图解链表OJ题目

数据结构——图解链表OJ题目

学完了单链表之后&#xff0c;我们对其基本结构已经有了一定的了解&#xff0c;接下来我们通过一些题目强化对链表的理解&#xff0c;同时学习一些面试笔试题目的新思路以及加强对数据结构单链表的掌握。 目录 题目一.876. 链表的中间结点 - 力扣&#xff08;LeetCode&#x…
阅读更多...
数据结构第二课 -----线性表之单向链表

数据结构第二课 -----线性表之单向链表

作者前言 &#x1f382; ✨✨✨✨✨✨&#x1f367;&#x1f367;&#x1f367;&#x1f367;&#x1f367;&#x1f367;&#x1f367;&#x1f382; ​&#x1f382; 作者介绍&#xff1a; &#x1f382;&#x1f382; &#x1f382; &#x1f389;&#x1f389;&#x1f389…
阅读更多...
leetcode-141-环形链表（C语言实现）

leetcode-141-环形链表（C语言实现）

题目&#xff1a; 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的…
阅读更多...
【数据结构】面试OJ题——带环链表（数学推论）

【数据结构】面试OJ题——带环链表（数学推论）

目录 1.环形链表Ⅰ ​编辑 思路 &#xff1a; 思路拓展 问题一&#xff1a; 问题二&#xff1a; 总结&#xff1a; 问题三&#xff1a; 证明总结第三点 总结&#xff1a; 2. 环形链表Ⅱ 思路一 思路二 3.相交链表 思路&#xff1a; 1.环形链表Ⅰ 141. 环形链…
阅读更多...
数据结构与算法【链表：一】Java实现

数据结构与算法【链表：一】Java实现

目录 链表 单向链表 哨兵链表 双向链表 环形链表 链表 链表是数据元素的线性集合&#xff0c;其每个元素都指向下一个元素&#xff0c;元素存储上并不连续。 随机访问性能 根据 index 查找&#xff0c;时间复杂度 O(n) 插入或删除性能 起始位置&#xff1a;O(1)结束位…
阅读更多...
【考研复习】二叉树的特殊存储｜三叉链表存储二叉树、一维数组存储二叉树、线索二叉树

【考研复习】二叉树的特殊存储｜三叉链表存储二叉树、一维数组存储二叉树、线索二叉树

文章目录 三叉链表存储二叉树三叉链表的前序遍历&#xff08;不使用栈&#xff09;法一三叉链表的前序遍历&#xff08;不使用栈&#xff09;法二 一维数组存储二叉树一维数组存储二叉树的先序遍历 线索二叉树的建立真题演练 三叉链表存储二叉树 三叉链表结构体表示如下图所示…
阅读更多...
《LeetCode力扣练习》代码随想录——链表（移除链表元素---Java）

《LeetCode力扣练习》代码随想录——链表（移除链表元素---Java）

《LeetCode力扣练习》代码随想录——链表&#xff08;移除链表元素—Java&#xff09; 刷题思路来源于 代码随想录 203. 移除链表元素 虚拟头结点 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* …
阅读更多...
python数据结构与算法-03_链表

python数据结构与算法-03_链表

链式结构 上一节讲到了支持随机访问的线性结构&#xff0c;这次我们开始讲链式结构, 视频里我会说下这两种结构的区别&#xff0c;然后讲解最常见的单链表和双链表。 之前在专栏文章那些年&#xff0c;我们一起跪过的算法题[视频]里实现过一个 lru_cache&#xff0c; 使用到的…
阅读更多...
Java 数据结构篇-用链表、数组实现栈

Java 数据结构篇-用链表、数组实现栈

&#x1f525;博客主页&#xff1a; 【小扳_-CSDN博客】 ❤感谢大家点赞&#x1f44d;收藏⭐评论✍ 文章目录 1.0 栈的说明 2.0 用链表来实现栈 2.1 实现栈 - 入栈方法&#xff08;push&#xff09; 2.2 实现栈 - 出栈&#xff08;pop&#xff09; 2.3 实现栈 - 查看栈顶元素…
阅读更多...
数据结构第三课 -----线性表之双向链表

数据结构第三课 -----线性表之双向链表

作者前言 &#x1f382; ✨✨✨✨✨✨&#x1f367;&#x1f367;&#x1f367;&#x1f367;&#x1f367;&#x1f367;&#x1f367;&#x1f382; ​&#x1f382; 作者介绍&#xff1a; &#x1f382;&#x1f382; &#x1f382; &#x1f389;&#x1f389;&#x1f389…
阅读更多...
python链表_递归求和_递归求最大小值

python链表_递归求和_递归求最大小值

创建一个单链表&#xff1a; class LinkNode: #设置属性def __init__(self,data None):self.data dataself.next None class LinkList: #设置头结点def __init__(self):self.head LinkNode()self.head.next Nonedef CreateListR(self,a): …
阅读更多...
LeetCode反转链表的五种Java实现方式

LeetCode反转链表的五种Java实现方式

给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&#xff1a;[2,1]示例 3&#xff1a; 输入&a…
阅读更多...
循环链表1

循环链表1

循环链表的结构设计 循环链表就是——链表的头和尾连在一起 即最后一个数据&#xff08;尾巴结点&#xff09;的next由单链表的NULL&#xff0c;变为现在循环链表的存储头结点plist的地址200&#xff0c;尾巴结点指向头结点 现在来建立循环链表clist 先写结构设计 现在看对于…
阅读更多...
leetcode刷题日记:160. Intersection of Two Linked Lists（相交链表）

leetcode刷题日记:160. Intersection of Two Linked Lists（相交链表）

给出两个单链表的头结点headA与headB&#xff0c;让我们找出两个链表相接的起始节点&#xff0c;如果两个链表不存在相交结点返回null。 我们就先假设存在这样两个链表&#xff0c;链表1与链表2&#xff0c;假设链表1的长度为 L 1 L_1 L1​和 L 2 L_2 L2​,假设对于两个链表&am…
阅读更多...
数据结构-双向链表

数据结构-双向链表

1.带头双向循环链表&#xff1a; 前面我们已经知道了链表的结构有8种&#xff0c;我们主要学习下面两种&#xff1a; 前面我们已经学习了无头单向非循环链表&#xff0c;今天我们来学习带头双向循环链表&#xff1a; 带头双向循环链表&#xff1a;结构最复杂&#xff0c;一般用…
阅读更多...
线性表操作的实现--单链表（链式存储结构）

线性表操作的实现--单链表（链式存储结构）

本文参考朱战力老师的数据结构与算法--使用C语言一书 目录 文章目录 前言 一、链表是什么&#xff1f; 二、具体实现 1.单链表的定义 2.初始化ListInitiate&#xff08;SLNode **head&#xff09; 3.求当前元素的个数ListLength&#xff08;SLNode *head&#xff09; 4.插入Lis…
阅读更多...
C语言每日一题（25）链表的中间结点

C语言每日一题（25）链表的中间结点

力扣 876. 链表的中间结点 题目描述 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结点。 思路分析 快慢指针法 用一慢一快指针遍历整个链表&#xff0c;每次遍历&#xff0c;快指针都会比慢指针多…
阅读更多...
C语言每日一题（32）环形链表

C语言每日一题（32）环形链表

力扣网 141.环形链表 题目描述 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾…
阅读更多...
C语言每日一题（33）随机链表的复制

C语言每日一题（33）随机链表的复制

力扣138 随机链表的复制 题目描述 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都…
阅读更多...
LeetCode148.排序链表

LeetCode148.排序链表

看完题目的想法是&#xff0c;直接把所有节点的值都遍历出来放进优先队列里面&#xff0c;然后从头节点遍历一次&#xff0c;每次把优先队列poll()的值赋给节点的val即可&#xff0c;说实话&#xff0c;想完还觉得估计有问题怎么可能这么简单&#xff0c;但是不管了&#xff0c…
阅读更多...
反转链表 --- 递归回溯算法练习三

反转链表 --- 递归回溯算法练习三

目录 1. 分析题意 2. 分析算法原理 2.1. 递归思路&#xff1a; 1. 挖掘子问题&#xff1a; 3. 编写代码 3.1. step 1&#xff1a; 3.2. step 2&#xff1a; 3.3. step 3&#xff1a; 3.4. 递归代码&#xff1a; 1. 分析题意 力扣原题链接如下&#xff1a; 206. 反转链…
阅读更多...
【代码随想录03】203.移除链表元素 707.设计链表 206. 反转链表

【代码随想录03】203.移除链表元素 707.设计链表 206. 反转链表

203. 移除链表元素 题目描述 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 做题思路 由于涉及头结点的删除&#xff0c;所以可以在头结点之前设置一个虚拟头结点&#xff0c;这样的…
阅读更多...
基于面向对象编程，C++实现单链表

基于面向对象编程，C++实现单链表

链表&#xff1a;在内存空间中是非连续存储 组成&#xff1a;链表是由一个个节点组成的&#xff0c;每个节点都包含两个元素&#xff1a;数据和指针 节点头文件&#xff1a; 建立一个ListNode.h头文件 #pragma once class ListNode { public:int value;ListNode* next;Lis…
阅读更多...
面试150-61（Leetcode138随机链表的复制）

面试150-61（Leetcode138随机链表的复制）

代码&#xff1a; /* // Definition for a Node. class Node {int val;Node next;Node random;public Node(int val) {this.val val;this.next null;this.random null;} } */class Solution {public Node copyRandomList(Node head) {if(headnull)return null;Node n1 new…
阅读更多...
经典OJ题：重排链表

经典OJ题：重排链表

题目&#xff1a; 给定一个链表&#xff0c;在进行重排前&#xff1a; 进行重排链表后&#xff1a; 如上图所示&#xff0c;所谓的重拍链表&#xff0c;就是将第一个节点连接第倒数第一个节点&#xff0c;第二个节点连接倒数第二个节点&#xff0c;以此类推&#xff0c;最后在连…
阅读更多...
C语言——贪吃蛇

C语言——贪吃蛇

一. 游戏效果 贪吃蛇 二. 游戏背景 贪吃蛇是久负盛名的游戏&#xff0c;它也和俄罗斯⽅块&#xff0c;扫雷等游戏位列经典游戏的⾏列。 贪吃蛇起源于1977年的投币式墙壁游戏《Blockade》&#xff0c;后移植到各种平台上。具体如下&#xff1a; 起源。1977年&#xff0c;投币式…
阅读更多...
链表之带头双向循环链表（C语言版）

链表之带头双向循环链表（C语言版）

我们之前已经介绍过链表的知识了&#xff0c;这里我们直接开始实现带头双向循环链表 数据结构之单链表&#xff08;不带头单向非循环链表&#xff09;-CSDN博客 第一步&#xff1a;定义结构体 //定义结构体 typedef int SLTDateType; typedef struct Listnode {SLTDateType d…
阅读更多...
深入理解数据结构：链表

深入理解数据结构：链表

文章目录 &#x1f330;导语&#x1f330;链表的定义及基本结构&#x1f330;单链表&#x1f955;单链表特点 &#x1f330;双向链表&#x1f955;双链表特点 &#x1f330;循环链表&#x1f955;循环链表特点 &#x1f330;链表的操作&#x1f346;链表的插入&#x1fad8;链头…
阅读更多...
牛客网刷题笔记四 链表节点k个一组翻转

牛客网刷题笔记四 链表节点k个一组翻转

NC50 链表中的节点每k个一组翻转 题目&#xff1a; 思路&#xff1a; 这种题目比较习惯现在草稿本涂涂画画链表处理过程。整体思路是赋值新的链表&#xff0c;用游离指针遍历原始链表进行翻转操作&#xff0c;当游离个数等于k时&#xff0c;就将翻转后的链表接到新的链表后&am…
阅读更多...
【双向链表的实现】

【双向链表的实现】

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 目录 前言 1. 双向链表的结构 2. 双向链表的实现 2.1 头文件 ——双向链表的创建及功能函数的定义 2.2 源文件 ——双向链表的功能函数的实现 2.3 源文件 ——双向链表功能的…
阅读更多...
【leetcode100-023】【链表】反转链表

【leetcode100-023】【链表】反转链表

【题干】 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 【思路】 太经典了&#xff0c;感觉也没什么必要用文字来描述了&#xff0c;今天实在太累了&#xff0c;直接代码吧。 【题解】 class Solution { public:ListNode* reverseL…
阅读更多...
数据结构期末复习（2）链表

数据结构期末复习（2）链表

链表 链表&#xff08;Linked List&#xff09;是一种常见的数据结构&#xff0c;用于存储一系列具有相同类型的元素。链表由节点&#xff08;Node&#xff09;组成&#xff0c;每个节点包含两部分&#xff1a;数据域&#xff08;存储元素值&#xff09;和指针域&#xff08;指…
阅读更多...
【数据结构和算法】独一无二的出现次数

【数据结构和算法】独一无二的出现次数

其他系列文章导航 Java基础合集数据结构与算法合集 设计模式合集 多线程合集 分布式合集 ES合集 文章目录 其他系列文章导航 文章目录 前言 一、题目描述 二、题解 2.1 哈希类算法题注意事项 2.2 方法一&#xff1a;判断长度 2.3 方法二&#xff1a; set 判断 2.4 方法…
阅读更多...
华为OD机试真题-最长子字符串的长度（一）-2023年OD统一考试（C卷）

华为OD机试真题-最长子字符串的长度（一）-2023年OD统一考试（C卷）

题目描述&#xff1a; 给你一个字符串 s&#xff0c;字符串s首尾相连成一个环形 &#xff0c;请你在环中找出 o 字符出现了偶数次最长子字符串的长度。 输入描述&#xff1a; 输入是一串小写字母组成的字符串 输出描述&#xff1a; 输出是一个整数 补充说明&#xff1a; 1 <…
阅读更多...
【数据结构实验】查找（一）基于散列表的查找算法

【数据结构实验】查找（一）基于散列表的查找算法

文章目录 1. 引言2. 实验原理2.1 散列表2.2 线性探测法2.3 冲突解决 3. 实验内容3.1 实验题目&#xff08;一&#xff09;输入要求&#xff08;二&#xff09;输出要求 3.2 算法实现3.3 代码整合 4. 实验结果 1. 引言 本实验将通过C语言实现基于散列表的查找算法 2. 实验原理 …
阅读更多...
XOR 链表 – 内存高效的双向链表(二)-原理讲解及C++/Python/JAVA等实现源码

XOR 链表 – 内存高效的双向链表(二)-原理讲解及C++/Python/JAVA等实现源码

在上一篇文章中，我们讨论了如何使用每个节点的地址字段仅使用一个空间来创建双向链接。在这篇文章中，我们将讨论内存高效的双向链表的实现。我们主要讨论以下两个简单的功能。 在开头插入新节点的函数。向前遍历列表的函数。在以下代码中，insert()函数在开头插入一个新节点。…
阅读更多...
从头到尾的数据之旅

从头到尾的数据之旅

目录 引言 链表介绍 单向链表的接口实现 结构 创建节点 头插 尾插 头删 尾删 打印 节点查找 节点前插入 节点删除 内存释放 总结 引言 在前面的学习中&#xff0c;我们深入了解了顺序表&#xff0c;通过其增删查改的操作&#xff0c;我们发现了顺序表在某些情况…
阅读更多...
剑指 Offer（第2版）面试题 25：合并两个排序的链表

剑指 Offer（第2版）面试题 25：合并两个排序的链表

剑指 Offer&#xff08;第2版&#xff09;面试题 25&#xff1a;合并两个排序的链表 剑指 Offer&#xff08;第2版&#xff09;面试题 25&#xff1a;合并两个排序的链表解法1&#xff1a;递归解法2&#xff1a;迭代 剑指 Offer&#xff08;第2版&#xff09;面试题 25&#xf…
阅读更多...
【PTA刷题】求链式线性表的倒数第K项（代码+详解）

【PTA刷题】求链式线性表的倒数第K项（代码+详解）

文章目录 题目代码详解 题目 给定一系列正整数&#xff0c;请设计一个尽可能高效的算法&#xff0c;查找倒数第K个位置上的数字。 输入格式: 输入首先给出一个正整数K&#xff0c;随后是若干非负整数&#xff0c;最后以一个负整数表示结尾&#xff08;该负数不算在序列内&#…
阅读更多...
Java中的链表

Java中的链表

文章目录 前言一、链表的概念及结构二、单向不带头非循坏链表的实现2.1打印链表2.2求链表的长度2.3头插法2.4尾插法2.5任意位置插入2.6查找是否包含某个元素的节点2.7删除第一次出现这个元素的节点2.8删除包含这个元素的所以节点2.9清空链表单向链表的测试 三、双向不带头非循坏…
阅读更多...
剑指 Offer（第2版）面试题 36：二叉搜索树与双向链表

剑指 Offer（第2版）面试题 36：二叉搜索树与双向链表

剑指 Offer&#xff08;第2版&#xff09;面试题 36&#xff1a;二叉搜索树与双向链表 剑指 Offer&#xff08;第2版&#xff09;面试题 36&#xff1a;二叉搜索树与双向链表解法1&#xff1a;中序遍历 - 递归解法2&#xff1a;中序遍历 - 迭代 剑指 Offer&#xff08;第2版&am…
阅读更多...
面试常问-如何判断链表有环、？

面试常问-如何判断链表有环、？

如何判断链表有环 题目&#xff1a;解决方案一&#xff1a;解决方案二&#xff1a;解决方案三&#xff1a; 题目&#xff1a; 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;…
阅读更多...
LeetCode Hot100 23.合并K个升序链表

LeetCode Hot100 23.合并K个升序链表

题目&#xff1a; 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 方法&#xff1a;分治&#xff0c;类似于归并 class Solution {public ListNode mergeKLists(ListNode[] lists) {return mer…
阅读更多...
C++ //习题 7.9 写一个函数insert，用来向动态链表插入一个结点。

C++ //习题 7.9 写一个函数insert，用来向动态链表插入一个结点。

C程序设计 &#xff08;第三版&#xff09; 谭浩强 习题7.9 习题 7.9 写一个函数insert&#xff0c;用来向动态链表插入一个结点。 IDE工具&#xff1a;VS2010 Note: 使用不同的IDE工具可能有部分差异。 代码块 方法&#xff1a;使用指针&#xff0c;结构体&#xff0c;自定…
阅读更多...
Leetcode: 203. 移除链表元素

Leetcode: 203. 移除链表元素

题目 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 难度&#xff1a;简单 题目链接&#xff1a;203. 移除链表元素 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val …
阅读更多...
Linux | 数据结构之内核链表

Linux | 数据结构之内核链表

Linux | 数据结构之内核链表 时间：2023年12月20日15:42:45 文章目录 Linux | 数据结构之内核链表1.参考2.内核链表2-1.源码2-2.节点类型2-3.内核链表相关算法2-3-1.初始化`2-3-1-1`.宏的实现2-3-1-2.内联函数的实现2-3-2.插入`2-3-2-1`.将new指向的结点插入到head指向的结点后…
阅读更多...
面试 Java 算法高频题五问五答第二期

面试 Java 算法高频题五问五答第二期

面试 Java 算法高频题五问五答第二期 作者&#xff1a;程序员小白条&#xff0c;个人博客 相信看了本文后&#xff0c;对你的面试是有一定帮助的&#xff01; ⭐点赞⭐收藏⭐不迷路&#xff01;⭐ 寻找峰值: 主要思想&#xff1a;二分查找&#xff0c;利用get函数&#xff0…
阅读更多...
每日一题——LeetCode160.相交链表

每日一题——LeetCode160.相交链表

个人主页&#xff1a;白日依山璟 专栏&#xff1a;Java|数据结构与算法|每日一题 文章目录 1. 题目描述示例1&#xff1a;示例2&#xff1a;提示&#xff1a; 2. 思路3. 代码 1. 题目描述 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的…
阅读更多...
力扣（leetcode）第80题删除有序数组中的重复项 II（Python）

力扣（leetcode）第80题删除有序数组中的重复项 II（Python）

80. 删除有序数组中的重复项 II 题目链接&#xff1a;80. 删除有序数组中的重复项 II 给你一个有序数组 n u m s nums nums &#xff0c;请你原地删除重复出现的元素&#xff0c;使得出现次数超过两次的元素只出现两次 &#xff0c;返回删除后数组的新长度。 不要使用额外的…
阅读更多...
MySQL undo日志精讲3-从回滚段中申请 Undo 页面链表

MySQL undo日志精讲3-从回滚段中申请 Undo 页面链表

回滚段-Rollback Segment Header 页面 回滚段的概念 我们现在知道一个事务在执行过程中最多可以分配4个 Undo 页面链表&#xff0c;在同一时刻不同事务拥有的 Undo 页面链表是不一样的&#xff0c;所以在同一时刻系统里其实可以有许许多多个 Undo 页面链表存在。为了更好的管…
阅读更多...
双向循环链表实现C语言关键字中英翻译机 ฅ( ̳• · • ̳ฅ)

双向循环链表实现C语言关键字中英翻译机 ฅ( ̳• · • ̳ฅ)

目录 1.双向循环链表的声明与定义&#xff1a; 2. 创建链表并对节点中的数据赋初值 3. 插入节点并链接 4.中英翻译 5. 小游戏的实现 6.菜单的实现 7. 释放内存 8.在主函数中用刚才定义的函数实现各种代码 输入样例&#xff1a; 实现方法&#xff1a;双向循环链表来实…
阅读更多...
链表精选题集

链表精选题集

目录 1 链表翻转 题目链接&#xff1a; 解题&#xff1a; 试错版&#xff1a; 2 找中间节点 题目链接: 题解&#xff1a; 3 找倒数第k个节点 题目链接&#xff1a; 题解&#xff1a; 4 将两个升序链表合并为一个升序链表 题目链接&#xff1a; 题解&#xff1a; …
阅读更多...
【数据结构】链式家族的成员——循环链表与静态链表

【数据结构】链式家族的成员——循环链表与静态链表

循环链表与静态链表 导言一、循环链表1.1 循环单链表1.2 循环双链表 二、静态链表2.1 静态链表的创建2.2 静态链表的初始化2.3 小结 结语 导言 大家好&#xff01;很高兴又和大家见面啦&#xff01;&#xff01;&#xff01; 经过前面的介绍&#xff0c;相信大家对链式家族的…
阅读更多...
王道计算机考研 数据结构C语言复现-第二章-单链表

王道计算机考研 数据结构C语言复现-第二章-单链表

这篇文章收录了王道考研课程中涉及的数据结构的所有代码。此外&#xff0c;本博客可能会添加一些额外的代码&#xff08;不仅限于王道考研&#xff09;&#xff0c;因为408考试中会频繁考察一些冷门的知识点&#xff0c;所以这篇博客会涵盖所有相关的代码。这也是我数据结构的第…
阅读更多...
链表--141.环形链表/easy C级理解

链表--141.环形链表/easy C级理解

141.环形链表 1、题目2、题目分析3、解题步骤4、复杂度最优解代码示例5、抽象与扩展 1、题目 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链…
阅读更多...
leetcode 876.链表的中间结点

leetcode 876.链表的中间结点

补充上次的环形链表没细讲的快慢指针&#xff08;这三道题现在可以连起来看&#xff09;&#xff0c;希望对你做题思路有帮助 876.链表的中间结点 题目 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结…
阅读更多...
【leetcode100-30】【链表】两两交换链表节点

【leetcode100-30】【链表】两两交换链表节点

【题干】 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 【思路】 先说递归的&#xff0c;退出条件很明显&#xff0c;当剩…
阅读更多...
leetcode2487.从链表中移除节点

leetcode2487.从链表中移除节点

文章目录 题目思路复杂度Code 题目 给你一个链表的头节点 head 。 移除每个右侧有一个更大数值的节点。 返回修改后链表的头节点 head 。 示例 1&#xff1a; 输入&#xff1a;head [5,2,13,3,8] 输出&#xff1a;[13,8] 解释&#xff1a;需要移除的节点是 5 &#xff0…
阅读更多...
手撕单链表（单向，不循环，不带头结点）的基本操作

手撕单链表（单向，不循环，不带头结点）的基本操作

&#x1d649;&#x1d65e;&#x1d658;&#x1d65a;!!&#x1f44f;&#x1f3fb;‧✧̣̥̇‧✦&#x1f44f;&#x1f3fb;‧✧̣̥̇‧✦ &#x1f44f;&#x1f3fb;‧✧̣̥̇:Solitary-walk ⸝⋆ ━━━┓ - 个性标签 - &#xff1a;来于“云”的“羽球人”。…
阅读更多...
C++之链表list

C++之链表list

1. 双向链表list * 1.1 list的基本特性 C的list是一种双链表&#xff0c;这意味着每个元素都有一个指向前一个和后一个元素的指针。相比于单链表&#xff0c;双链表在插入和删除操作中更为高效&#xff0c;因为它不需要遍历链表来找到插入或删除的位置。 list支持常见的序列操…
阅读更多...
剑指offer面试题5 从尾到头打印链表

剑指offer面试题5 从尾到头打印链表

考察点 链表知识点 数组和链表都属于线性表。线性表在计算机中有俩种存储方式&#xff0c;按照顺序存储的就是数组&#xff0c;按照链式存储的就是链表&#xff0c;二者最大的区别在于一个是顺序存储(地址空间连续)一个是链式存储(地址空间不连续)。因此数组元素只包含元素值…
阅读更多...
【leetcode100-035】【链表/哈希链表】LRU缓存

【leetcode100-035】【链表/哈希链表】LRU缓存

【题干】 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类&#xff1a; LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存int get(int key) 如果关键字 key 存在于缓存中&#xff0c;则返回关键字的值&#xff0c;…
阅读更多...
两两交换链表中的节点【链表】

两两交换链表中的节点【链表】

Problem: 24. 两两交换链表中的节点 文章目录 思路 & 解题方法复杂度Code 思路 & 解题方法 假如要交换1号节点和2号节点&#xff1a; 0->1->2->3变成 0->2->1->3就行了。 复杂度 时间复杂度: O ( n ) O(n) O(n) 空间复杂度: O ( 1 ) O(1) O(1) Code…
阅读更多...
【LeetCode每日一题】82. 删除排序链表中的重复元素 II

【LeetCode每日一题】82. 删除排序链表中的重复元素 II

2024-1-15 文章目录 [82. 删除排序链表中的重复元素 II](https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii/) 82. 删除排序链表中的重复元素 II 思路&#xff1a; 创建一个虚拟节点 dummy 作为头节点的前置节点。使用两个指针 pre 和 cur 分别指向前一个非…
阅读更多...
力扣83-删除排序链表中的重复元素

力扣83-删除排序链表中的重复元素

删除排序链表中的重复元素 题目链接 解题思路 1.遍历整个链表&#xff0c;遇见重复元素&#xff0c;直接删除即可 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNod…
阅读更多...
LeetCode 0082.删除排序链表中的重复元素 II：模拟

LeetCode 0082.删除排序链表中的重复元素 II：模拟

【LetMeFly】82.删除排序链表中的重复元素 II&#xff1a;模拟 力扣题目链接&#xff1a;https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii/ 给定一个已排序的链表的头 head &#xff0c; 删除原始链表中所有重复数字的节点&#xff0c;只留下不同的数字…
阅读更多...
数据结构入门到入土——链表（1）

数据结构入门到入土——链表（1）

目录 一&#xff0c;顺序表表/ArrayList的缺陷 二&#xff0c;链表 三&#xff0c;链表的实现 四&#xff0c;与链表有关的题目练习&#xff08;1&#xff09; 1.删除链表中等于给定值 val 的所有节点 2.反转一个单链表 3.给定一个带有头结点 head 的非空单链表&#xf…
阅读更多...
数据结构第六弹---带头双向循环链表

数据结构第六弹---带头双向循环链表

双向循环链表 1、带头双向循环链表概念2、带头双向循环链表的优势3、带头双向循环链表的实现3.1、头文件包含和结构定义3.2、创建新结点3.3、打印3.4、初始化3.5、销毁3.6、尾插3.7、头插3.8、头删3.9、尾删3.10、查找3.11、在pos之前插入3.12、删除pos位置3.13、判断是否为空3…
阅读更多...
代码随想录 Leetcode160. 相交链表

代码随想录 Leetcode160. 相交链表

题目&#xff1a; 代码(首刷看解析 2024年1月13日&#xff09;&#xff1a; class Solution { public:ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {ListNode *A headA, *B headB;while (A ! B) {A A ! nullptr ? A->next : headB;B B ! nullpt…
阅读更多...
【OJ】环形链表

【OJ】环形链表

目录 1. 环形链表||&#xff08;142&#xff09;1.1 题目描述1.2 题目分析1.3 代码 2. 环形链表&#xff08;141&#xff09;2.1 题目描述2.2 题目分析2.3 代码 1. 环形链表||&#xff08;142&#xff09; 1.1 题目描述 1.2 题目分析 带环链表&#xff1a;尾节点的next指向链…
阅读更多...
【leetcode】力扣算法之删除链表中倒数第n个节点【中等难度】

【leetcode】力扣算法之删除链表中倒数第n个节点【中等难度】

删除链表中倒数第n个节点 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 用例 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] 输入&#xff1a;head [1], n 1 输出&#xff1a;[] 输入&#xff1a;head …
阅读更多...
Linux C语言开发（九）链表

Linux C语言开发（九）链表

目录 一.前言 二.链表构建 一.前言 C语言的链表是一种常见且实用的数据结构，它用于存储和管理数据元素。链表由一系列节点组成，每个节点包含两个部分：数据域和指针域。数据域用于存储实际的数据元素，而指针域则用于指向链表中的下一个节点。 链表的主要特点是其存储空间的…
阅读更多...
不带头单向不循环链表的实现

不带头单向不循环链表的实现

前言 不带头单向不循环链表是一种数据结构&#xff0c;它由一系列的节点组成&#xff0c;每个节点包含两部分&#xff1a;数据域和指针域。在这种类型的链表中&#xff1a; 不带头&#xff08;无头结点&#xff09;&#xff1a;意味着链表的第一个节点直接存储数据&#xff0…
阅读更多...
数据结构——lesson2线性表和顺序表

数据结构——lesson2线性表和顺序表

目录 前言 一、顺序表是什么&#xff1f; 1. 静态顺序表&#xff1a;使用定长数组存储元素 2. 动态顺序表&#xff1a;使用动态开辟的数组存储。 二、接口实现 1.动态顺序表存储 2.基本增删查改接口 (1)初始化顺序表 (2)顺序表摧毁 (3)检查空间 (4)顺序表打印 (5)顺…
阅读更多...
2024.1.15力扣每日一题——删除排序链表中的重复元素 II

2024.1.15力扣每日一题——删除排序链表中的重复元素 II

2024.1.15 题目来源我的题解方法一 三指针虚拟头结点 题目来源 力扣每日一题&#xff1b;题序&#xff1a;82 我的题解 方法一 三指针虚拟头结点 先构建一个带虚拟头结点的链表&#xff0c;然后使用三个指针p,left,right&#xff0c;分别指向最右非重复节点&#xff0c;可能…
阅读更多...
盖子的c++小课堂：第二十六讲：双向链表

盖子的c++小课堂：第二十六讲：双向链表

前言 谢谢各位粉丝的支持，望我早日突破1000粉 双向链表 干货！单链表从原理到实现——附python和C++两个版本 - 知乎单链表是链表家族中的一员，每个节点依旧由 数据域（data）和指针域（next）组成，链表的具体概念下面有介绍： 机器学习入坑者：程序员基本功——链表的基…
阅读更多...
链表OJ-----链表反转

链表OJ-----链表反转

1、链表局部反转 https://leetcode.cn/problems/reverse-linked-list-ii/ 1、1初级要求&#xff1a;时间复杂度为O(n),空间复杂度为O(n) 对于这个要求&#xff0c;我们可以想到&#xff0c;用一个数组&#xff0c;来记录反转区间中各结点的值&#xff0c;然后我们将数组中的值…
阅读更多...
【数据结构和算法】奇偶链表

【数据结构和算法】奇偶链表

其他系列文章导航 Java基础合集数据结构与算法合集 设计模式合集 多线程合集 分布式合集 ES合集 文章目录 其他系列文章导航 文章目录 前言 一、题目描述 二、题解 2.1 方法一&#xff1a;分离节点后合并 三、代码 3.1 方法一&#xff1a;分离节点后合并 四、复杂度分…
阅读更多...
【LeetCode】206. 反转链表（简单）——代码随想录算法训练营Day03

【LeetCode】206. 反转链表（简单）——代码随想录算法训练营Day03

题目链接&#xff1a;206. 反转链表 题目描述 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1] 示例 2&#xff1a; 输入&#xff1a;head [1,2] 输…
阅读更多...
leetcode 141 判断链表中是否存在环

leetcode 141 判断链表中是否存在环

leetcode 141 判断链表中是否存在环 题目描述 给定一个单链表的头节点 head&#xff0c;判断链表中是否存在环。如果链表中存在环&#xff0c;则返回 true&#xff0c;否则返回 false。 注意&#xff1a; 链表节点定义如下&#xff1a; class ListNode {int val;ListNode n…
阅读更多...
链表回文结构

链表回文结构

链表回文结构 编写一个函数&#xff0c;检查输入的链表是否是回文的。 示例 1&#xff1a; 输入&#xff1a; 1->2 输出&#xff1a; false 示例 2&#xff1a; 输入&#xff1a; 1->2->2->1 输出&#xff1a; true 链表的回文结构&#xff0c;应该先找到中间节…
阅读更多...
【C++笔试强训】第二十一天

【C++笔试强训】第二十一天

&#x1f387;C笔试强训 博客主页&#xff1a;一起去看日落吗分享博主的C刷题日常&#xff0c;大家一起学习博主的能力有限&#xff0c;出现错误希望大家不吝赐教分享给大家一句我很喜欢的话&#xff1a;夜色难免微凉&#xff0c;前方必有曙光 &#x1f31e;。 &#x1f4a6;&a…
阅读更多...
【数据结构】链表OJ面试题4(题库+解析)

【数据结构】链表OJ面试题4(题库+解析)

1.前言 前五题在这http://t.csdnimg.cn/UeggB 后三题在这http://t.csdnimg.cn/gbohQ 给定一个链表&#xff0c;判断链表中是否有环。http://t.csdnimg.cn/Rcdyc 记录每天的刷题&#xff0c;继续坚持&#xff01; 2.OJ题目训练 10. 给定一个链表&#xff0c;返回链表开始…
阅读更多...
Java顺序表和链表

Java顺序表和链表

Java顺序表和链表1. 线性表2. 顺序表2.1 概念及结构2.2 接口实现2.3 顺序表的问题及思考3. 链表3.1 链表的概念及结构3.2 链表的实现3.2.1无头单向非循环链表的实现3.2.2无头双向非循环链表实现&#xff1a;3.3 链表面试题3.3.1反转链表&#xff1a;3.3.2找到链表的中间结点&am…
阅读更多...
数据结构 - 线索树

数据结构 - 线索树

一、 为什么要用到线索二叉树&#xff1f; 我们先来看看普通的二叉树有什么缺点。下面是一个普通二叉树&#xff08;链式存储方式&#xff09;&#xff1a; 乍一看&#xff0c;会不会有一种违和感&#xff1f;整个结构一共有 7 个结点&#xff0c;总共 14 个指针域&#xff0c…
阅读更多...
[LeetCode周赛复盘] 「天池 X LeetCode」在线编程专场选拔赛20221015

[LeetCode周赛复盘] 「天池 X LeetCode」在线编程专场选拔赛20221015

[LeetCode周赛复盘] 「天池 X LeetCode」在线编程专场选拔赛20221022 一、本周周赛总结二、 [Easy] 221021天池-01. 统计链表奇数节点1. 题目描述2. 思路分析3. 代码实现三、[Medium] 221021天池-02. 光线反射1. 题目描述2. 思路分析3. 代码实现四、[Medium] 221021天池-03. 整…
阅读更多...
力扣hot100 合并两个有序链表 递归 双指针

力扣hot100 合并两个有序链表 递归 双指针

Problem: 21. 合并两个有序链表 文章目录 &#x1f496; 递归思路 &#x1f496; 双指针 &#x1f496; 递归 思路 &#x1f468;‍&#x1f3eb; 参考地址 n , m n,m n,m 分别为 list1 和 list2 的元素个数 ⏰ 时间复杂度: O ( n m ) O(nm) O(nm) &#x1f30e; 空间复杂…
阅读更多...
力扣经典题：链表合并

力扣经典题：链表合并

解决链表合并问题需要有特定的思路&#xff1a; 、链表合并 王赫辰/c语言 - Gitee.com 简述思路&#xff1a;首先先处理特殊情况&#xff0c;将空指针时的情况进行提前处理 然后再创建新的链表&#xff0c;此时使用尾插比较法&#xff1a; 循环条件&#xff1a;当两个链表中…
阅读更多...
力扣hot100 K 个一组翻转链表 双指针 满注释版

力扣hot100 K 个一组翻转链表 双指针 满注释版

Problem: 25. K 个一组翻转链表 文章目录 思路复杂度Code 思路 &#x1f469;‍&#x1f3eb; 参考 复杂度 时间复杂度: O ( n ∗ k ) O(n*k) O(n∗k) 空间复杂度: O ( n ) O(n) O(n) Code /*** Definition for singly-linked list.* public class ListNode {* in…
阅读更多...
【LeetCode: 148. 排序链表 + 链表 + 归并排序】

【LeetCode: 148. 排序链表 + 链表 + 归并排序】

&#x1f680; 算法题 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;…
阅读更多...
【王道数据结构】【chapter2线性表】【P43t13】

【王道数据结构】【chapter2线性表】【P43t13】

设有一头指针为L的带有表头结点的非循环双向链表&#xff0c;其每个结点中除有prior&#xff08;前驱指针&#xff09;&#xff0c;data&#xff08;数据&#xff09;和next&#xff08;后继指针&#xff09;域外&#xff0c;还有一个访问频度域freq。在链表被起用前&#xff0…
阅读更多...
数据结构——用链表实现Map

数据结构——用链表实现Map

目录 一、映射&#xff08;Map&#xff09; 二、代码实现 1.建立接口 2.方法实现 &#xff08;1&#xff09;映射的建立 键&#xff08;key&#xff09;和值&#xff08;val&#xff09;的建立 重写toString方法 &#xff08;2&#xff09;构造方法 &#xff08;3&…
阅读更多...
C语言进阶——数据结构之链表（续）

C语言进阶——数据结构之链表（续）

前言 hello&#xff0c;大家好呀&#xff0c;我是Humble&#xff0c;本篇博客承接之前的C语言进阶——数据结构之链表 的内容&#xff08;没看过的小伙伴可以从我创建的专栏C语言进阶之数据结构 找到那篇文章并阅读后在回来哦~&#xff09;&#xff0c;上次我们重点说了链表中…
阅读更多...
C语言数据结构——链表

C语言数据结构——链表

&#xff08;图像由AI生成&#xff09; 0.前言 在计算机科学中&#xff0c;数据结构是存储和组织数据的一种方式&#xff0c;它不仅影响数据的存储&#xff0c;也影响数据的检索和更新效率。C语言&#xff0c;作为一种经典的编程语言&#xff0c;提供了灵活的方式来处理数据…
阅读更多...
休息日的思考与额外题——链表

休息日的思考与额外题——链表

文章目录 前言链表知识点 一、 92. 反转链表 II二、21. 合并两个有序链表总结 前言 一个本硕双非的小菜鸡&#xff0c;备战24年秋招&#xff0c;计划二刷完卡子哥的刷题计划&#xff0c;加油&#xff01; 二刷决定精刷了&#xff0c;于是参加了卡子哥的刷题班&#xff0c;训练…
阅读更多...
数据结构28TI

数据结构28TI

首先&#xff0c;又来到分享知识点的时候到了&#xff0c;也将数据化就行调节出已及将内容进行调节出来&#xff0c; 也慢慢将类型进行对等关系进行一一遍历出来&#xff0c;也将其他将类型进行换&#xff0c;最近学遍历存储结构进行分享给大家进行调节关系链&#xff0c;也把…
阅读更多...
【数据结构】ArrayList与顺序表

【数据结构】ArrayList与顺序表

目录 1.线性表 2.顺序表 2.1接口的实现 3. ArrayList简介 ​编辑 4.ArrayList使用 4.1 ArrayList的构造 4.2ArraysList常见操作 1.线性表 线性表&#xff08;linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构&a…
阅读更多...
C语言应用实例——贪吃蛇

C语言应用实例——贪吃蛇

&#xff08;图片由AI生成&#xff09; 0.贪吃蛇游戏背景 贪吃蛇游戏&#xff0c;最早可以追溯到1976年的“Blockade”游戏&#xff0c;是电子游戏历史上的一个经典。在这款游戏中&#xff0c;玩家操作一个不断增长的蛇&#xff0c;目标是吃掉出现在屏幕上的食物&#xff0c…
阅读更多...
从[redis:LinkedList]中学习链表

从[redis:LinkedList]中学习链表

文章目录 adlistlistNodelistmacros[宏定义]listCreatelistInitNodelistEmptylistReleaselistAddNodeHeadlistLinkNodeHeadlistAddNodeTaillistLinkNodeTaillistInsertNodelistDelNodelistUlinkNodelistIndexredis3.2.100quicklistredis7.2.2quicklist redis的基本数据类型之一…
阅读更多...
双指针：环形链表II

双指针：环形链表II

题目&#xff1a;142. 环形链表 II 我们知道&#xff0c;判断一个链表是否为环是这样的&#xff1a; public boolean hasCycle(ListNode head) {ListNode slow head,quickly head;while(quickly ! null && quickly.next ! null){slow slow.next;quickly quickly.n…
阅读更多...
链表——C语言——day17

链表——C语言——day17

链表 链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。在用数组存放数据时&#xff0c;必须事先定义固定的长度&#xff08;即元素个数&#xff09;。链表则没有这种缺点&#xff0c;它根据需要开辟内存单元。 链表有一个“头指针“变量&#xff0c;图中…
阅读更多...
Leetcode—203. 移除链表元素【简单】

Leetcode—203. 移除链表元素【简单】

2024每日刷题&#xff08;一零九&#xff09; Leetcode—203. 移除链表元素 实现代码 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(int x) : val(x), next(n…
阅读更多...
LeetCode：2.两数相加

LeetCode：2.两数相加

目录 题目&#xff1a;​编辑2. 两数相加 - 力扣&#xff08;LeetCode&#xff09; 分析问题&#xff1a; 官方的优秀代码博主的注释&#xff1a; 博主的辣眼代码&#xff0c;无注释&#xff0c;拉出来拷打自己&#xff1a; 每日表情包&#xff1a; 2. 两数相加 - 力扣&am…
阅读更多...
数据结构与算法：稀疏数组（java）

数据结构与算法：稀疏数组（java）

稀疏数组 需求案例 常见五子棋程序中&#xff0c;有黑子和蓝子棋子&#xff0c;使用二维数组来表示 0表示默认值&#xff0c;可以发现的是记录了很多没有意义的数据。那么我们思考&#xff0c;如何能够把数据记录优化至最小呢。 介绍 压缩条件&#xff1a; 原数组中存在大…
阅读更多...
【数据结构】(牛客)链表中倒数第k个结点，(LeetCode)合并两个有序链表，(牛客)CM11 链表分割

【数据结构】(牛客)链表中倒数第k个结点，(LeetCode)合并两个有序链表，(牛客)CM11 链表分割

目录 一、链表中倒数第k个结点 1、题目说明 2、题目解析 二、合并两个有序链表 1、题目说明 2、题目解析 三、CM11 链表分割 1、题目说明 2、题目解析 一、链表中倒数第k个结点 1、题目说明 题目链接&#xff1a;链表中倒数第k个结点 输入一个链表&#xff0c;输出该链表中倒…
阅读更多...
线索化二叉树的实现(思路分析) [数据结构与算法]

线索化二叉树的实现(思路分析) [数据结构与算法]

线索化二叉树的实现(思路分析) 线索二叉树: Threaded BinaryTree 我们先来看一个问题:(通过这个问题我们来引入我们将要进行讲解的线索化二叉树): 问题: 将数列{1,3,6,8,10,14}构成一颗二叉树(如下图) [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(…
阅读更多...
数据结构——B/顺序表和链表

数据结构——B/顺序表和链表

1.线性表 线性表&#xff08;linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使 用的数据结构&#xff0c;常见的线性表&#xff1a;顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构&#xff0c;也就说是连续的一条直线…
阅读更多...
算法面试题：合并两个有序链表

算法面试题：合并两个有序链表

描述&#xff1a;给定两个按非递减顺序排列的链表&#xff0c;合并两个链表&#xff0c;并将结果按非递减顺序排列。 例如&#xff1a; # 链表 1: 1 -> 2 -> 4 # 链表 2: 1 -> 3 -> 4合并后的链表应该是&#xff1a;1 -> 1 -> 2 -> 3 -> 4 -> 4 …
阅读更多...
C语言中链栈的表示和实现

C语言中链栈的表示和实现

下面是 C 语言中链接堆栈的实现和表示&#xff1a; c #include <stdio.h> #include <stdlib.h> struct Node { int data; struct Node* next; }; struct Stack { struct Node* top; }; void initializeStack(struct Stack* stack) { stack->top NULL; } in…
阅读更多...
【OJ】牛客链表刷题

【OJ】牛客链表刷题

题目 1. 链表分割1.1 题目分析1.2 代码 2. 链表的回文结构2.1 题目分析2.2 代码 这里两道与链表有关的题目均来自牛客。 1. 链表分割 1.1 题目分析 因为这里代码不能选择用c语言写&#xff0c;所以选择用c,因为c兼容c。 题目要求分割链表&#xff0c;我们可以直接弄成两个带哨…
阅读更多...
【数据结构】单链表

【数据结构】单链表

文章目录单链表链表的概念及结构链表的分类链表的实现动态申请一个节点创建链表单链表打印单链表尾插单链表尾删单链表头插单链表头删单链表 链表的概念及结构 概念&#xff1a;链表是一种物理存储结构上连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序 是通过链表中的…
阅读更多...
相交链表~环形链表

相交链表~环形链表

环形链表前言相交链表环形链表Ⅰ环形链表Ⅱ前言 我们在解决环形链表问题之前呢&#xff0c;先做一道简单题做做铺垫&#xff1b; 环形链表的方法很简单&#xff0c;但是想要弄懂其中的原理&#xff0c;就不得不花费一番力气&#xff01;&#xff01;&#xff01;&#x1f60a;…
阅读更多...
栈的简单实现及应用

栈的简单实现及应用

栈的简单实现及其应用什么是栈&#xff1f;栈的分类栈的数据结构栈的基本操作栈的初始化栈的销毁入栈操作出栈和栈空的判断获取栈顶元素获取栈的元素个数头文件总结栈的应用什么是栈&#xff1f; 栈&#xff1a;一种特殊的线性表&#xff0c;其只允许在固定的一端进行插入和删除…
阅读更多...
【数据结构初阶】手撕单链表

【数据结构初阶】手撕单链表

目录一.链表概念和结构二.单链表功能的实现1.打印单链表内容2.申请单链表节点3.头插和尾插4.头删和尾删5.单链表查找6.pos位置前后插入7.pos位置删除三.链表面试题剖析一.链表概念和结构 概念&#xff1a;链表是一种物理存储结构上非连续、非顺序的存储结构&#xff0c;数据元素…
阅读更多...
【代码题】链表面试题

【代码题】链表面试题

目录 1.链表分割 2.相交链表 3.环形链表 4.环形链表 II 1.链表分割 点击进入该题 现有一链表的头指针 ListNode* pHead&#xff0c;给一定值x&#xff0c;编写一段代码将所有小于x的结点排在其余结点之前&#xff0c;且不能改变原来的数据顺序&#xff0c;返回重新排列后的…
阅读更多...
【数据结构】认清带头双向循环链表的庐山真面目

【数据结构】认清带头双向循环链表的庐山真面目

目录前言一、带头双向循环链表的介绍二、带头双向循环链表的类型重定义1.对数据类型进行重定义2.链表结点结构3.结点类型重定义三、常见函数操作的实现1.声明2.定义1. 申请新节点2. 初始化3. 销毁链表4. 打印链表5. 尾插数据6. 尾删数据7. 头插结点8.头删结点9. 在指定的位置前…
阅读更多...
剑指offer----C语言版----第十七天----面试题23：链表中环的入口节点

剑指offer----C语言版----第十七天----面试题23：链表中环的入口节点

目录 1. 链表中环的入口节点 1.1 环形链表Ⅰ 1.1.1 题目描述 1.1.2解题思路 1.1.3 扩展问题 1.2 环形链表Ⅱ 1.2.1 题目描述 1.2.2 思路分析 1. 链表中环的入口节点 在leetcode上的剑指offer专栏没有收录这道题目&#xff0c;但Leetcode上是有这道题目的&#xff0c;环…
阅读更多...
【数据结构】双向链表

【数据结构】双向链表

1.双向链表的结构2.双向链表的实现首先在VS里面的源文件建立test.c和List.c,在头文件里面建立List.hList.h:#pragma once #include <stdio.h> #include <stdlib.h> #include <assert.h> typedef int LTDateType; typedef struct ListNode {LTDateType data;s…
阅读更多...
linux 内核链表详解

linux 内核链表详解

目录 1. 老生常谈的两个宏&#xff08;Linux&#xff09; offset 测试demo container_of ({}) Typeof 推算结构体起始地址 测试demo 2. Linux内核链表剖析 移植linux内核链表&#xff0c;使其适用于非GNU编译器 Linux内核链表的位置和依赖 移植时的注意事项 移植好…
阅读更多...
链表OJ题+牛客题

链表OJ题+牛客题

目录 206.反转链表 876.链表的中间节点 链表中倒数第k个节点 CM11链表分割 OR36 链表的回文 206.反转链表 给你单链表的头节点head,请你反转链表&#xff0c;并返回反转后的链表。 实现如下结果&#xff1a; 思路&#xff1a; 取链表中的节点头插&#xff1a; 代码&#…
阅读更多...
「链表」简析

「链表」简析

前言 前言&#xff1a;研究一个数据结构的时候&#xff0c;首先讲的是增删改查。 文章目录前言一、链表简介1. 含义2. 节点组成3. 存储方式1&#xff09;数据在内存中的存储方式2&#xff09;单链表在内存中的存储方式3&#xff09;双链表在内存中的存储方式4&#xff09;循环链…
阅读更多...
【数据结构和算法】了解认识栈，并实现栈的相关函数

【数据结构和算法】了解认识栈，并实现栈的相关函数

到现在我们了解并认识了线性表的概念&#xff0c;动态、静态顺序表的建立&#xff0c;以及两种链表的实现&#xff0c;接下来我们要认识一个新的内容&#xff0c;新的概念&#xff0c;栈&#xff0c;是基于顺序表或者链表的一种新型数据结构。 目录 一、栈是什么&#xff1f; …
阅读更多...
【数据结构】二叉树的实现OJ练习

【数据结构】二叉树的实现OJ练习

文章目录前言(一) 二叉树的接口实现构建二叉树前序遍历中序遍历后序遍历层序遍历二叉树的节点个数二叉树叶子节点个数二叉树第K层节点个数二叉树的高度查找指定节点判断完全二叉树销毁二叉树(二) 二叉树基础OJ练习单值二叉树相同的树另一棵树的子树二叉树的前序遍历二叉树的最大…
阅读更多...
Leetcode.1669 合并两个链表

Leetcode.1669 合并两个链表

题目链接 Leetcode.1669 合并两个链表 Rating : 1428 题目描述 给你两个链表 list1和 list2&#xff0c;它们包含的元素分别为 n个和 m个。 请你将 list1中下标从 a到 b的全部节点都删除&#xff0c;并将list2接在被删除节点的位置。 示例 1&#xff1a; 输入&#xff1a;li…
阅读更多...
【数据结构】动图详解单向链表

【数据结构】动图详解单向链表

目录 1.什么是链表 1.问题引入 2. 链表的概念及结构 3. 问题解决 2.单向链表接口的实现 1.接口1&#xff0c;2---头插&#xff0c;尾插 2. 接口3&#xff0c;4---头删&#xff0c;尾删 3. 接口5---查找 4. 接口6&#xff0c;7---插入&#xff0c;删除 5. 接口8---打印 6. 注意…
阅读更多...
【c语言】数据结构-带头双向循环链表

【c语言】数据结构-带头双向循环链表

主页&#xff1a;114514的代码大冒险 qq:2188956112&#xff08;欢迎小伙伴呀hi✿(。◕ᴗ◕。)✿ &#xff09; Gitee&#xff1a;庄嘉豪 (zhuang-jiahaoxxx) - Gitee.com 目录 共八种链表&#xff1a; 前言 一、结构简图与分析 二、链表操作详解&#xff08;附代码实现&am…
阅读更多...
【数据结构】顺序表

【数据结构】顺序表

文章目录引入顺序表概念分类静态的顺序表动态的顺序表函数增头插尾插在指定下标位置插入删头删尾删指定下标位置删除查补充初始化释放顺序表打印顺序表总结引入 学习数据结构有什么意义呢&#xff1f; 我们很疑惑在以后的实际工作中可能根本用不到这些东西&#xff0c;但实际上…
阅读更多...
Python数据结构-----链表1.0（单链表的增删改查以及反转）

Python数据结构-----链表1.0（单链表的增删改查以及反转）

目录 前言&#xff1a; 1.单链表 1.1简介 1.2 对比列表 2.单链表的创建 3.单链表的遍历 4.链表元素的查询 5.节点的删除 6.节点的插入 7.链表元素的修改 8.链表的反转 9.全部代码 前言&#xff1a; 前面我们在C语言学习过了数据结构中的链表&#xff0c;既然说到数据…
阅读更多...
两数相加-力扣2-java高效方案

两数相加-力扣2-java高效方案

一、题目描述给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外&#xff0c;这两个数都不…
阅读更多...
JAVA集合专题3 —— vector + LinkedList + Set

JAVA集合专题3 —— vector + LinkedList + Set

目录vector的特点LinkedList底层结构模拟双向链表比较ArrayList和LinkedListSet接口基本介绍Set接口的遍历方式vector的特点 Vector底层是一个对象数组Vector是线程同步的&#xff0c;即线程安全的&#xff0c;Vector类的操作方法带有synchronize(带锁也就意味着效率有所降低)…
阅读更多...
图解数据结构：盘点链表与栈和队列的那些血缘（单双链表模拟实现栈和队列）

图解数据结构：盘点链表与栈和队列的那些血缘（单双链表模拟实现栈和队列）

写在前面 Hello&#xff0c;各位盆友们&#xff0c;我是黄小黄。关于前一段时间为什么拖更这件事&#xff0c;这里给大家说一句抱歉。笔者前段时间忙于ddl和一些比赛相关的事件&#xff0c;当然还有些隐藏任务&#xff0c;所以博文更新就放缓了。  这里还需要做一下对以后博文…
阅读更多...
【数据结构初阶】详解链表OJ题

【数据结构初阶】详解链表OJ题

目录一.删除链表中等于给定值的节点二.合并有序链表并返回三.链表的回文结构1.反转单链表2.返回非空链表的中间节点四.输出链表倒数第K个节点五.基于给定值x分割单链表六.返回两个链表的第一个中间节点一.删除链表中等于给定值的节点 我们先来看第一题(题目链接): 因为我们需…
阅读更多...
力扣(LeetCode)142. 环形链表 II(C++)

力扣(LeetCode)142. 环形链表 II(C++)

哈希表 最直观的思想&#xff0c;哈希表记录遍历的结点&#xff0c;如果结点重复出现&#xff0c;则有环。如果遍历到空结点&#xff0c;无环。 class Solution { public:ListNode *detectCycle(ListNode *head) {unordered_set<ListNode *> ad;auto tail head;while(…
阅读更多...
【顺序表和链表的对比】

【顺序表和链表的对比】

前言&#xff1a; 我们已经学习过了顺序表和链表的一些知识&#xff0c;在实际运用中我们不能笼统的说哪种存储结构更好&#xff0c;由于它们各有优缺点&#xff0c;选择哪种存储结构&#xff0c;则应该根据具体问题作出具体的分析&#xff0c;通常从空间性能和时间性能上作比较…
阅读更多...
python数据结构：数组、链表、栈、队列、树

python数据结构：数组、链表、栈、队列、树

目录1.数组1.1 数组的数据结构1.1.1 数组的定义1.1.2 随机访问和连续内存1.1.3 静态内存和动态内存1.1.4 物理大小和逻辑大小1.2 数组的操作1.2.1 增加数组大小1.2.2 减小数组大小1.2.3 插入一项1.2.4 删除一项1.2.5 复杂度权衡1.3 二维数组2.链表2.1 链表分类2.2 链表特点2.3 …
阅读更多...
LeetCode刷题--- 138. 复制带随机指针的链表（哈希表+迭代）

LeetCode刷题--- 138. 复制带随机指针的链表（哈希表+迭代）

文章目录一、编程题&#xff1a;430. 扁平化多级双向链表&#xff08;双指针&#xff09;1.题目描述2.示例1&#xff1a;3.示例2&#xff1a;4.示例3&#xff1a;5.提示&#xff1a;二、解题思路1. 题目分析2. 方法1&#xff08;哈希表&#xff09;思路&#xff1a;复杂度分析&…
阅读更多...
4.5.4 LinkedList

4.5.4 LinkedList

文章目录1.特点2.常用方法3.练习:LinkedList测试1.特点 链表,两端效率高,底层就是链表实现的 List接口的实现类&#xff0c;底层的数据结构为链表&#xff0c;内存空间是不连续的 元素有下标&#xff0c;有序允许存放重复的元素在数据量较大的情况下&#xff0c;查询慢&am…
阅读更多...
数据结构——重点代码汇总

数据结构——重点代码汇总

顺序表 设计算法&#xff0c;从顺序表L中删除值为x的元素。要求算法的时间复杂度为O(n)&#xff0c;空间复杂度为O(1)。设计算法&#xff0c;判断一个字符串是否是回文。如abc3cba是回文序列&#xff0c;而1331不是回文序列。从顺序存储结构的线性表a中删除第i个元素起的k个元…
阅读更多...
LeetCode 82. 删除排序链表中的重复元素 II

LeetCode 82. 删除排序链表中的重复元素 II

原题链接 难度&#xff1a;middle\color{orange}{middle}middle 题目描述 给定一个已排序的链表的头 headheadhead &#xff0c; 删除原始链表中所有重复数字的节点&#xff0c;只留下不同的数字 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,…
阅读更多...
HashMap原理详解

HashMap原理详解

一、hashmap简介 hashmap是Java当中一种数据结构&#xff0c;是一个用于存储Key-Value键值对的集合&#xff0c;每一个键值对也叫作Entry。 二、JDK7的HashMap1、JDK7时HashMap的数据结构 1、在JDK7之前&#xff0c;hashmap底层采用数组链表的数据结构来存储数据 2、插入数据采…
阅读更多...
Java中的链表实现介绍

Java中的链表实现介绍

Java中的链表实现介绍 学习数据结构的的链表和树时&#xff0c;会遇到节点&#xff08;node&#xff09;和链表&#xff08;linked list&#xff09;这两个术语&#xff0c;节点是处理数据结构的链表和树的基础。节点是一种数据元素&#xff0c;包括两个部分&#xff1a;一个是…
阅读更多...
C++学习笔记-数据抽象

C++学习笔记-数据抽象

简单的说&#xff0c;数据抽象是用来描述数据结构的。数据抽象就是 ADT。一个 ADT 主要表现为它支持的一些操作&#xff0c;比方说 stack.push、stack.pop&#xff0c;这些操作应该具有明确的时间和空间复杂度。另外&#xff0c;一个 ADT 可以隐藏其实现细节&#xff0c;比方说…
阅读更多...
随想录二刷Day06——链表

随想录二刷Day06——链表

文章目录链表6. 删除链表的倒数第 N 个结点7. 链表相交8. 环形链表 II链表 6. 删除链表的倒数第 N 个结点 19. 删除链表的倒数第 N 个结点 思路&#xff1a; 用双指针的方法&#xff0c;fast 和 slow 之间保持距离为 n&#xff0c;只需要遍历一次即可完成删除任务。 为了方便…
阅读更多...
（五十五）大白话更新数据的时候，自动维护的聚簇索引到底是什么？

（五十五）大白话更新数据的时候，自动维护的聚簇索引到底是什么？

上一次我们给大家讲了一下基于主键如何组织一个索引&#xff0c;然后建立索引之后&#xff0c;如何基于主键在索引中快速定位到那行数据所在的数据页&#xff0c;再如何进入数据页快速到定位那行数据&#xff0c;大家看下面的图。 我们今天就先基于上面的图&#xff0c;把按照主…
阅读更多...
【Java集合框架】篇五：Map接口

【Java集合框架】篇五：Map接口

1. Map及实现类特点 Map&#xff1a;存储key-value HashMap&#xff1a;线程不安全&#xff0c;效率高&#xff0c;key和value都可以为null&#xff0c;底层使用 数组单向链表红黑树 结构&#xff08;jdk8&#xff09;。 LinkedHashMap&#xff1a;是HashMap的子类&#xff0…
阅读更多...
对跳表的深入理解

对跳表的深入理解

一&#xff0c;如何理解跳表 简单说跳表&#xff08;Skip list&#xff09;就是链表的“二分查找”。redis 的有序集合用的就是跳表算法。跳表是一种各方面性能都比较优秀的动态数据结构&#xff0c;可以支持快速地插入、删除、查找操作&#xff0c;写起来也不复杂&#xff0c…
阅读更多...
数据结构之二叉树（上）

数据结构之二叉树（上）

文章目录前言一、二叉树的定义二、二叉树的几种情况三、特殊的二叉树1. 满二叉树2. 完全二叉树四、二叉树的存储结构1. 顺序存储2. 链式存储五、二叉树的性质总结前言 本文主要介绍了二叉树的基本概念以及二叉树的存储结构 一、二叉树的定义 一棵二叉树是结点的一个有限集合&…
阅读更多...
【id:24】【20分】E. DS线性表—多项式相加

【id:24】【20分】E. DS线性表—多项式相加

题目描述对于一元多项式 p(x)p0p1xp2x2 … pnxn &#xff0c;每个项都有系数和指数两部分&#xff0c;例如p2x2的系数为p2,指数为2。编程实现两个多项式的相加。例如5x2x23x3&#xff0c;-5-x6x24x4&#xff0c;两者相加结果&#xff1a;8x23x34x4其中系数5和-5都是x的0次方的…
阅读更多...
【数据结构入门】-链表之双向循环链表

【数据结构入门】-链表之双向循环链表

个人主页&#xff1a;平行线也会相交 欢迎 点赞&#x1f44d; 收藏✨ 留言✉ 加关注&#x1f493;本文由 平行线也会相交 原创 收录于专栏【数据结构初阶&#xff08;C实现&#xff09;】 文章目录链表初始化打印链表尾插尾删新建一个节点头插头删查找在pos之前插入*删除pos位…
阅读更多...
【HashSet】| 深度剥析Java SE 源码合集Ⅲ

【HashSet】| 深度剥析Java SE 源码合集Ⅲ

目录一. &#x1f981; HashSet介绍1.1 特点1.2 底层实现二. &#x1f981; 结构以及对应方法分析2.1 结构组成2.1.1 源码实现2.1.2 成员变量及构造方法2.2 常用的方法2.2.1 添加add(E e)方法2.2.2 删除remove(Object o)方法三. 最后想说一. &#x1f981; HashSet介绍 1.1 特…
阅读更多...
专项攻克——二叉树

专项攻克——二叉树

文章目录一、二叉树定义、分类二、二叉树的存储结构三、创建二叉树四、遍历方式一、二叉树定义、分类 二叉树&#xff1a;是N个结点的有序集合&#xff0c;该集合或者为空集&#xff0c;或者由一个根节点跟两棵互不相交的、分别称为根节点的左子树或者右子树的二叉树组成。每个…
阅读更多...
第八章：C语言数据结构与算法初阶之树

第八章：C语言数据结构与算法初阶之树

系列文章目录 文章目录系列文章目录前言一、什么是树1、树的概念2、非树树的子节点之间没有联系树的子节点有且仅有一个父节点3、树的术语4、树的表示——孩子兄弟表示法二、二叉树1、满二叉树2、完全二叉树三、二叉树的性质总结前言 树是一种非常重要的数据结构。 一、什么是…
阅读更多...
操作系统内核与安全分析课程笔记【2】进程管理与调度

操作系统内核与安全分析课程笔记【2】进程管理与调度

文章目录基本概念与关键数据结构进程管理进程生命周期进程的关系进程家族树线程组进程组与会话进程的创建与终止Linux中的线程基本概念与关键数据结构 进程&#xff1a;静态的&#xff0c;存储在磁盘上的代码与数据。 程序&#xff1a;动态的&#xff0c;执行程序的动态过程&am…
阅读更多...
Java集合常见面试题（五）

Java集合常见面试题（五）

Map 接口 ConcurrentHashMap 的实现原理 JDK 1.7 JDK1.7中的ConcurrentHashMap 是由 Segment 数组结构和 HashEntry 数组结构组成&#xff0c;即ConcurrentHashMap 把哈希桶切分成小数组&#xff08;Segment &#xff09;&#xff0c;每个小数组有 n 个 HashEntry 组成。 其…
阅读更多...
环形链表的判定与其拓展延伸---LeetCode OJ题详解

环形链表的判定与其拓展延伸---LeetCode OJ题详解

&#x1f493;问题&#xff1a; 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾…
阅读更多...
[Leetcode]删除链表中等于val 的所有结点

[Leetcode]删除链表中等于val 的所有结点

力扣链接方法一:使用前后两个指针,cur指向当前位置,prev指向前一个位置,通过改变指向和释放结点来删除val初步代码,还存在问题:/*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/struct ListNode* removeElements(…
阅读更多...
46-两个链表的第一个公共节点

46-两个链表的第一个公共节点

剑指 Offer 52. 两个链表的第一个公共节点 输入两个链表&#xff0c;找出它们的第一个公共节点。 如下面的两个链表&#xff1a; 在节点 c1 开始相交。 示例 1&#xff1a; 输入&#xff1a;intersectVal 8, listA [4,1,8,4,5], listB [5,0,1,8,4,5], skipA 2, skipB …
阅读更多...
ZSet的底层实现原理

ZSet的底层实现原理

文章目录1、zset底层数据结构&#xff1f;简单说说跳表底层数据结构&#xff1f;2、什么时候采用压缩列表、什么时候采用跳表&#xff1f;3、跳表的时间复杂度&#xff1f;4、简单描述一下跳表如何查找某个元素5、zset为什么用跳表而不用二叉树或者红黑树&#xff1f;6、zset的…
阅读更多...
java LinkedList 源码分析（通俗易懂)

java LinkedList 源码分析（通俗易懂)

目录 一、前言 二、LinkedList类简介 三、LinkedList类的底层实现 四、LinkedList类的源码解读 1.add方法解读 : 〇准备工作 。 ①跳入无参构造。 ②跳入add方法。 ③跳入linkList方法。 ④增加第一个元素成功。 ⑤向链表中添加第二个元素。 2.remove方法解读 : 〇准备工…
阅读更多...
数据结构---栈

数据结构---栈

专栏&#xff1a;数据结构 个人主页&#xff1a;HaiFan. 专栏简介&#xff1a;这里是HaiFan.的数据结构专栏&#xff0c;今天的内容是栈&#xff0c;一个特殊的数据结构。 栈前言栈的概念栈的接口实现STKInit初始化STKDestory销毁空间STKPush压栈STKPop出栈STKEmpty判断栈是否为…
阅读更多...
链表LeetCode总结

链表LeetCode总结

LeetCode题目 203.移除链表元素206.反转链表160.相交链表707.设计链表24.两两交换链表中的节点19.删除链表的倒数第 N 个结点142.环形链表 II 链表题目需要注意的点 ListNode结构体要会背 struct ListNode {int val;ListNode* next;ListNode(int _val 0, ListNode* _next nul…
阅读更多...
LeetCode题目笔记——24. 两两交换链表中的节点

LeetCode题目笔记——24. 两两交换链表中的节点

文章目录题目描述题目链接题目难度——中等方法一&#xff1a;迭代代码/C代码/python方法二&#xff1a;递归代码/C总结题目描述 或许这也是个经典的面试题&#xff0c;记录一手 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在…
阅读更多...
LeetCode 83. 删除排序链表中的重复元素

LeetCode 83. 删除排序链表中的重复元素

原题链接 难度&#xff1a;easy\color{Green}{easy}easy 题目描述 给定一个已排序的链表的头 headheadhead &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,1,2] 输出&#xff1a;…
阅读更多...
图解LeetCode——剑指 Offer 22. 链表中倒数第k个节点

图解LeetCode——剑指 Offer 22. 链表中倒数第k个节点

一、题目 输入一个单向链表&#xff0c;输出该链表中倒数第k个节点。为了符合大多数人的习惯&#xff0c;本题从1开始计数&#xff0c;即&#xff1a;链表的尾节点是倒数第1个节点。 例如&#xff0c;一个链表有 6 个节点&#xff0c;从头节点开始&#xff0c;它们的值依次是…
阅读更多...
【哈希表】使用方法总结

【哈希表】使用方法总结

1. uthash简介开源的第三方头文件&#xff0c;这只是一个头文件&#xff1a;uthash.h。uthash还包括三个额外的头文件&#xff0c;主要提供链表&#xff0c;动态数组和字符串。utlist.h为C结构提供了链接列表宏。utarray.h使用宏实现动态数组。utstring.h实现基本的动态字符串。…
阅读更多...
【数据结构】排序之冒泡排序和快速排序

【数据结构】排序之冒泡排序和快速排序

简单不先于复杂&#xff0c;而是在复杂之后。 文章目录 1. 交换排序1.1 冒泡排序1.2 快速排序1.3 快速排序优化1.4 快速排序非递归 1. 交换排序 基本思想&#xff1a;所谓交换&#xff0c;就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置&#xff0c;交换…
阅读更多...
11-链表练习-LeetCode206反转链表

11-链表练习-LeetCode206反转链表

题目 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1] 示例 2&#xff1a; 输入&#xff1a;head [1] 输出&#xff1a;[1] 示例 3&#xff1a; …
阅读更多...
关于一个大学生写一个题目写一天

关于一个大学生写一个题目写一天

到了学校之后发现自己啥都不会&#xff0c;有点伤心了&#xff0c;罢了&#xff0c;开始进入正题&#xff1a; 设计算法实现将两个递增的带头结点有序链表合并为一个递增的有序链表&#xff0c;要求结果链表仍 然使用原来两个链表的存储空间&#xff0c;表中不允许有重复的数…
阅读更多...
C++ 实现对单链表的反转算法

C++ 实现对单链表的反转算法

有个时候&#xff0c;我们需要对单链表进行反转操作&#xff0c;如下代码实现了对单链表的反转操作。 #include "iostream" using namespace std;struct node{int x;struct node *next;node(int x){this->xx;this->next nullptr;} }; typedef struct node Nod…
阅读更多...
掌握顺序表，成为数据结构和算法的高手

掌握顺序表，成为数据结构和算法的高手

文章目录1. 线性结构与线性表2. 线性表的顺序存储3. 顺序表的基础操作&#x1f351; 顺序表接口总览&#x1f351; 初始化顺序表&#x1f351; 销毁链表&#x1f351; 插入操作&#x1f351; 删除操作&#x1f351; 获取元素操作&#x1f345; 按位置获取&#x1f345; 按元素值…
阅读更多...
数据结构、数据、数据元素、数据项的区别

数据结构、数据、数据元素、数据项的区别

场景&#xff1a; 数据、数据元素、数据项、数据对象、数据类型、数据结构的区别 数据 数据&#xff1a;是描述客观事物的符号&#xff0c;是计算机中可以操作的对象&#xff0c;是能被计算机识别&#xff0c;并输入给计算机处理的符号集合。 数据不仅仅包括整型&#xff0c;…
阅读更多...
力扣热题100Day06:20. 有效的括号，21. 合并两个有序链表，22. 括号生成

力扣热题100Day06:20. 有效的括号，21. 合并两个有序链表，22. 括号生成

20. 有效的括号 题目链接&#xff1a;20. 有效的括号 - 力扣&#xff08;Leetcode&#xff09; 思路&#xff1a;使用栈 &#xff08;1&#xff09;遇到左括号就将其对应的右括号压入到栈中 &#xff08;2&#xff09;如果遇到右括号 a. 如果弹出的元素与当前不等&#xff…
阅读更多...
【数据结构】队列的接口实现（附图解和源码）

【数据结构】队列的接口实现（附图解和源码）

队列的接口实现&#xff08;附图解和源码&#xff09; 文章目录队列的接口实现&#xff08;附图解和源码&#xff09;前言一、定义结构体二、接口实现&#xff08;附图解源码&#xff09;1.初始化队列2.销毁队列3.队尾入队列4.判断队列是否为空5.队头出队列6.获取队列头部元素7…
阅读更多...
CSAPP-Lab2-Bomb

CSAPP-Lab2-Bomb

实验主页 Tips&#xff1a;实验前最好先把 bomp 反汇编到一个文件中&#xff0c;方便在调试时查看 开启调试器&#xff0c;以汇编的形式展示程序&#xff1a; $ gdb --silent bomb Reading symbols from bomb... (gdb) layout asmphase_1 第一个炸弹是一道开胃小菜&#xf…
阅读更多...
leetcode刷题-环形链表（判断链表是否有环）

leetcode刷题-环形链表（判断链表是否有环）

环形链表1.题目2.画图理解3.代码的实现1.题目 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 po…
阅读更多...
软件设计师笔记-----数据结构与算法基础

软件设计师笔记-----数据结构与算法基础

六、数据结构与算法基础 6.1、数组与矩阵 6.1.1、概述 数组下标的转化问题 稀疏矩阵 上三角 下三角等类型的矩阵 6.1.2、数组 存储地址的计算问题&#xff0c;以及在二维数组当中按行存储和按列存储的区别 主要是去了解 按行 和 按列 进行存储的时候 地址的计算问题 6…
阅读更多...
数据结构2——线性表1：基本概念

数据结构2——线性表1：基本概念

1、线性表的概念 线性表是具有相同特性的数据元素的一个有限序列。就像用细线串珠子&#xff0c;一个接着一个串起来。 2、线性表的逻辑特征 ① 在非空的线性表中有且只有一个开始结点a1&#xff0c;他没有直接前驱&#xff0c;而仅有一个直接后继a2&#xff0c;相当于a1是…
阅读更多...
【LeetCode——排序链表】

【LeetCode——排序链表】

文章目录排序链表二、解题思路&#xff1a;二.实现的代码总结&#xff1a;排序链表 一道链表排序题&#xff0c;链接在这里 二、解题思路&#xff1a; 解题思路&#xff1a;使用归并排序&#xff08;用递归实现&#xff09; 第一步&#xff1a;先找到链表的中间节点 第二步…
阅读更多...
研究链表空间销毁问题

研究链表空间销毁问题

&#x1f4af;&#x1f4af;&#x1f4af; 1.研究链表空间销毁问题 当链表使用完后&#xff0c;需要将链表销毁&#xff0c;那么该如何销毁呢&#xff1f; void SLTDestroy(SLTNode* phead)//销毁单链表 {SLTNode* cur phead;while(cur){free(cur);cur cur->next;} }你…
阅读更多...
【数据结构】解决顺序表题的基本方法

【数据结构】解决顺序表题的基本方法

&#x1f680;write in front&#x1f680; &#x1f4dc;所属专栏&#xff1a;> 初阶数据结构 &#x1f6f0;️博客主页&#xff1a;睿睿的博客主页 &#x1f6f0;️代码仓库&#xff1a;&#x1f389;VS2022_C语言仓库 &#x1f3a1;您的点赞、关注、收藏、评论&#xff0…
阅读更多...
c++ 一些常识 2

c++ 一些常识 2

前言 今天主要讲类相关概念。 构造和析构函数是否可以抛出异常 在构造函数中抛出异常&#xff0c;控制权会转出构造函数之外&#xff0c;对象的析构函数不会被调用&#xff0c;造成内存泄漏。 如果析构函数中抛出异常&#xff0c;而且没有在当地捕捉&#xff0c;析构函数便执…
阅读更多...
牛客--反转链表

牛客--反转链表

描述 给定一个单链表的头结点pHead(该头节点是有值的&#xff0c;比如在下图&#xff0c;它的val是1)&#xff0c;长度为n&#xff0c;反转该链表后&#xff0c;返回新链表的表头。 数据范围&#xff1a; 0\leq n\leq10000≤n≤1000 要求&#xff1a;空间复杂度 O(1)O(1) &a…
阅读更多...
栈和队列（stack和queue）

栈和队列（stack和queue）

目录一、栈1.1 什么是栈&#xff1f;1.2 栈的相关操作1.2.1 结构体变量的声明1.2.2 栈的初始化1.2.3 栈的销毁1.2.4 元素入栈1.2.5 元素出栈1.2.6 取栈顶元素1.2.7 求栈顶元素的数目1.2.8 判断栈是否为空1.3 栈的代码汇总1.3.1 Stack.h1.3.2 Stack.c1.3.3 test.c二、队列2.1 什…
阅读更多...
数据结构和算法学习记录——线性表之双向链表（下）-头插函数、头删函数、查找函数、pos位置之前插入结点、pos位置删除结点及其复用、销毁链表函数

数据结构和算法学习记录——线性表之双向链表（下）-头插函数、头删函数、查找函数、pos位置之前插入结点、pos位置删除结点及其复用、销毁链表函数

线性表之双向链表&#xff08;上&#xff09;头插函数头插的思路比较简单&#xff0c;创建一个新结点&#xff0c;在哨兵位结点和第一个结点之间链接起来就可以。头插函数在链表为空时不会出问题&#xff0c;所以不需要多加断言。void ListPushFront(LTNode* phead, LTDataType…
阅读更多...
常见树的数据结构

常见树的数据结构

时间复杂度 O(1) 表示一次操作即可直接取得目标元素&#xff08;比如字典或哈希表&#xff09;&#xff0c; O(n) 意味着先要检查 n 个元素来搜索目标 常见的时间复杂度有&#xff1a; 常数阶O(1),对数阶O(log2n),线性阶O(n),线性对数阶O(nlog2n),平方阶O(n2),立方阶O(n3),k次…
阅读更多...
二十二、任务通知详解

二十二、任务通知详解

文章目录1、基本概念&#xff08;核心是关中断&#xff09;2、使用场景&#xff1a;一个任务唤醒另一个任务&#xff08;即任务间的数据传输&#xff09;3、休眠唤醒功能与前面说到的内核对象的区别4、优势及限制5、通知的三种状态6、任务通知的两套函数&#xff08;最好还是使…
阅读更多...
哈希桶的实现

哈希桶的实现

文章目录1. 开散列1.1 开散列概念1.2 插入函数1.3 析构函数1.4 查找函数1.5 删除函数1.6 拷贝构造和赋值函数1. 开散列 1.1 开散列概念 开散列法又叫链地址法(开链法)&#xff0c;首先对关键码集合用散列函数计算散列地址&#xff0c;具有相同地址的关键码归于同一子集合&…
阅读更多...
【C++】面经101，删除有序链表中重复的元素-II，动态规划解决斐波那契，二分查找-I，二维数组中的查找，寻找峰值

【C++】面经101，删除有序链表中重复的元素-II，动态规划解决斐波那契，二分查找-I，二维数组中的查找，寻找峰值

目录 1.删除有序链表中重复的元素-II 2. 动态规划解决斐波那契 3. 二分查找-I 4.二维数组中的查找 5.寻找峰值 1.删除有序链表中重复的元素-II 这个题是删除所有重复项&#xff0c;所以不方便用之前的方法&#xff08;所有重复的项留一个&#xff09;&#xff0c;因为即使…
阅读更多...
双向链表基本操作

双向链表基本操作

欢迎来到 Claffic 的博客 &#x1f49e;&#x1f49e;&#x1f49e; 前言&#xff1a; 往期给大家介绍了单链表&#xff0c; 单链表在 OJ 中出现频率较高&#xff0c;但实际使用的不多&#xff1b;而双链表是存储数据常用的表&#xff0c;它的全名是 带头双向循环链表 &#xf…
阅读更多...
【基础算法】单链表的OJ练习(6) # 复制带随机指针的链表 #

【基础算法】单链表的OJ练习(6) # 复制带随机指针的链表 #

文章目录&#x1f347;前言&#x1f34e;复制带随机指针的链表&#x1f351;写在最后&#x1f347;前言 本章的链表OJ练习&#xff0c;是最后的也是最难的。对于本题&#xff0c;我们不仅要学会解题的思路&#xff0c;还要能够通过这个思路正确的写出代码&#xff0c;也就是思路…
阅读更多...
LeetCode：707. 设计链表（链表系列）

LeetCode：707. 设计链表（链表系列）

题目描述&#xff1a;你可以选择使用单链表或者双链表&#xff0c;设计并实现自己的链表。 单链表中的节点应该具备两个属性&#xff1a;val 和 next 。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。 如果是双向链表&#xff0c;则还需要属性 prev 以指…
阅读更多...
STL——list详解

STL——list详解

一、list基本使用 1.1 初始化 在C11之前&#xff0c;std::list容器没有提供初始化列表的构造函数&#xff0c;因此需要使用push_back或push_front函数向列表中添加元素。以下是一些常见的std::list初始化方式&#xff1a; 使用默认构造函数创建空列表 std::list<int> m…
阅读更多...
数据结构复习（七）模板类封装实现不带头结点的单链表

数据结构复习（七）模板类封装实现不带头结点的单链表

一、代码 二、总结 一、代码 #include<iostream> using namespace std;template<class T> struct ListNode {T _data;ListNode* next;ListNode(const T& data T()){_data data;next nullptr;}~ListNode(){next nullptr;} };template<class T> class…
阅读更多...
剑指 Offer II 028. 展平多级双向链表

剑指 Offer II 028. 展平多级双向链表

题目链接 剑指 Offer II 028. 展平多级双向链表 mid 题目描述 多级双向链表中&#xff0c;除了指向下一个节点和前一个节点指针之外&#xff0c;它还有一个子链表指针&#xff0c;可能指向单独的双向链表。这些子列表也可能会有一个或多个自己的子项&#xff0c;依此类推&…
阅读更多...
list接口介绍

list接口介绍

list部分接口介绍 文章目录list部分接口介绍resizeeraseoperation系列接口removesort迭代器种类uniquemergereservesplice总结resize 这个一旦小于原先的大小就会释放掉空间&#xff01; erase 这个会直接导致迭代器失效&#xff01; operation系列接口 remove 就是find …
阅读更多...
leetcode 链表专题 10道题

leetcode 链表专题 10道题

做题要点 画图 加入虚拟头节点&#xff08;删除节点的时候&#xff09; auto dummy new ListNode(-1); dummy->next head;以10道题目为例 leetcode19. 删除链表的倒数第N个节点 题目描述 题目分析 单链表只能单向走&#xff08;尽可能在遍历一次的基础上找到答案&am…
阅读更多...
LinkedList源码解析

LinkedList源码解析

Java源码系列&#xff1a;下方连接 http://t.csdn.cn/Nwzed 文章目录前言一、LinkedList底层结构二、LinkedList的remove&#xff08;&#xff09;方法总结前言 提示&#xff1a;本文总结发文三个工作日后放入前言部分 提示&#xff1a;以下是本篇文章正文内容&#xff0c;下…
阅读更多...
【数据结构】顺序表详解

【数据结构】顺序表详解

本章要分享到内容是数据结构线性表的内容&#xff0c;那么学习他的主要内容就是对数据的增删查改的操作。 以下为目录方便阅读 目录 1.线性表中的顺序表和顺序表 2.顺序表 2.1概念和结构 2.2动态顺序表使用场景 比如我们看到的所显示出来的群成员的列表这样所展示出来的数…
阅读更多...
代码随想录刷题-链表-环形链表II

代码随想录刷题-链表-环形链表II

文章目录环形链表 II习题我的解法双指针环形链表 II 本节对应代码随想录中&#xff1a;代码随想录&#xff0c;讲解视频&#xff1a;把环形链表讲清楚&#xff01; 如何判断环形链表&#xff1f;如何找到环形链表的入口&#xff1f; LeetCode&#xff1a;142.环形链表II_哔哩哔…
阅读更多...
3.JavaScript数据结构与算法（链表）

3.JavaScript数据结构与算法（链表）

1.链表数据结构 链表存储有序的元素集合&#xff0c;但是不同于数组&#xff0c;链表中的元素在内存中并不是连续放置的&#xff0c;每个元素由一个元素本身的节点和一个指向下一个元素的引用&#xff08;也称指针或链接&#xff09;组成 相对于传统的数组&#xff0c;链表在添…
阅读更多...
LinkedList集合源码解析

LinkedList集合源码解析

Java源码系列&#xff1a;下方连接 http://t.csdn.cn/Nwzed 文章目录前言一、LinkedList底层结构二、LinkedList的remove&#xff08;&#xff09;方法三、LinkedList的get&#xff08;index&#xff09;方法四、LinkedList.set(index,element)修改方法底层五、LinkedList继承…
阅读更多...
数据结构和算法_双向链表

数据结构和算法_双向链表

一、双向链表 1、双向链表结点结构&#xff1a; priordatanext2、双向循环链表 和单链表循环相似&#xff0c;双向链表也可以有循环表&#xff1a; 让头结点的前驱指针指向链表的最后一个结点 让最后一个结点后继指针指向头结点 3、双向链表的对称性&#xff1a; P…
阅读更多...
Golang每日一练(leetDay0038) 二叉树专题（7）

Golang每日一练(leetDay0038) 二叉树专题（7）

目录 112. 路径总和 Path Sum &#x1f31f; 113. 路径总和 II Path Sum II &#x1f31f;&#x1f31f; 114. 二叉树展开为链表 Flatten Binary Tree to Linked-list &#x1f31f;&#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Golang每日一练 专栏 …
阅读更多...
Java数据结构和算法之第五章、LinkedList与链表

Java数据结构和算法之第五章、LinkedList与链表

一、ArrayList的缺陷 public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable {// ... // 默认容量是10private static final int DEFAULT_CAPACITY 10;//... // 数组&#xff1a;用来存储…
阅读更多...
线性表，栈和队列

线性表，栈和队列

什么是线性表&#xff1f; 线性表是由n个相同类型的数据元素组成的有限序列&#xff0c;它是最基本的一种线性结构。顾名思义&#xff0c;线性表就像是一条线&#xff0c;不会分叉。线性表有唯一的开始和结束&#xff0c;除了第一个元素外&#xff0c;每个元素都有唯一的直接前…
阅读更多...
【LeetCode】两数相加（链表）

【LeetCode】两数相加（链表）

目录 1.题目要求&#xff1a;给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 方法一&#xff1a;利用迭代的方法&#xff0c;遍历两条链表&#xff0c;将答案存储到一条新的链表中…
阅读更多...
【leetocde】MapSet的应用

【leetocde】MapSet的应用

1. 复制带随机指针的链表 OJ&#xff1a;复制带随机指针的链表 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的深拷贝。深拷贝应该正好由 n 个 全新 节点组成&#xff…
阅读更多...
牛客top100 - 自刷打卡day1 - 链表

牛客top100 - 自刷打卡day1 - 链表

top100-打卡day1链表BM1反转链表BM2链表内指定区间反转BM3链表中的节点每k个一组翻转BM4合并两个排序的链表BM5合并k个已排序的链表BM6判断链表中是否有环BM7链表中环的入口结点BM8链表中倒数最后k个结点BM9删除链表的倒数第n个节点BM10两个链表的第一个公共结点BM11链表相加(二…
阅读更多...
LeetCode23.合并k个有序链表

LeetCode23.合并k个有序链表

LeetCode刷题记录 文章目录&#x1f4dc;题目描述&#x1f4a1;解题思路⌨C代码&#x1f4dc;题目描述 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。。 示例1 输入&#xff1a;lists [[1,4,5]…
阅读更多...
十七、队列

十七、队列

文章目录1、基本概念&#xff08;队列实际上就是一个结构体&#xff0c;可以理解为就是一个数组&#xff09;2、使用场景&#xff1a;任务间或任务与中断间传递数据3、使用队列的好处&#xff08;1&#xff09;休眠唤醒&#xff08;2&#xff09;提高CPU利用率4、队列的核心5、…
阅读更多...
线性表——顺序表

线性表——顺序表

文章目录一&#xff1a;线性表二&#xff1a;顺序表1&#xff1a;概念与结构1&#xff1a;静态顺序表2&#xff1a;动态顺序表2&#xff1a;动态顺序表的代码实现1&#xff1a;结构2&#xff1a;接口实现1&#xff1a;初始化2&#xff1a;释放内存3&#xff1a;检查容量4&#…
阅读更多...
python 实现二叉搜索树的方法有哪些？

python 实现二叉搜索树的方法有哪些？

树的介绍 树不同于链表或哈希表&#xff0c;是一种非线性数据结构&#xff0c;树分为二叉树、二叉搜索树、B树、B树、红黑树等等。 树是一种数据结构&#xff0c;它是由n个有限节点组成的一个具有层次关系的集合。用图片来表示的话&#xff0c;可以看到它很像一棵倒挂着的树。…
阅读更多...
顺序栈和非循环队列来咯！！！

顺序栈和非循环队列来咯！！！

前言&#xff1a;通过上几篇文章&#xff0c;我们一直在学习我们的线性表&#xff0c;我们学习了我们的顺序表&#xff0c;链表等相关线性表&#xff0c;那么我们今天来学习一下栈和队列这两种线性表叭&#xff01;当然我们今天只介绍我们的顺序栈和非循环的队列。可能有小伙伴…
阅读更多...
详解c++---list介绍

详解c++---list介绍

目录标题 list介绍list定义list遍历list数据插入push_backpush_frontinsert list删除pop_backpop_fronterase list排序list去重list合并list转移list其他函数emptysizefrontbackassignswapresizeclear list排序效率问题 list介绍 list是可以在常数范围内在任意位置进行插入和删…
阅读更多...
8-数据结构-给两个有序链表A,B合成一个非递减的有序链表C

8-数据结构-给两个有序链表A,B合成一个非递减的有序链表C

问题&#xff1a; 给两个有序链表A,B合成一个非递减的有序链表C。 思路&#xff1a; 先在tupedef struct lnode{int data; lnode *next}lnode,*linklist;定义单链表 lnode(表示结点)以及*linklist &#xff08;表示整个链表&#xff09;&#xff1b;随后定义a&#xff0c;b&a…
阅读更多...
算法小抄10-二叉树的遍历方式

算法小抄10-二叉树的遍历方式

上节中我们学到了链表,这一节中学习一个新的数据结构二叉树,对于链表它拥有的属性时值val,和下一个链表节点指针next,而二叉树其实就比他多一个属性,它的形状看起来是下面这样的: class TreeNode:def __init__(self, val0, leftNone,rightNone):self.val valself.left lefts…
阅读更多...
LeetCode个人题解

LeetCode个人题解

LeetCode个人题解20230408[876. 链表的中间结点](https://leetcode.cn/problems/middle-of-the-linked-list/)[142. 环形链表 II](https://leetcode.cn/problems/linked-list-cycle-ii/)20230408 876. 链表的中间结点 给你单链表的头结点 head &#xff0c;请你找出并返回链表…
阅读更多...
C 单链表及其相关算法 万字详解（通俗易懂）

C 单链表及其相关算法 万字详解（通俗易懂）

目录 一、前言 : 二、线性结构 1.介绍 2.分类 3.数组和链表的区别 : 三、链表 [离散存储] 1.定义 2.相关概念 3.如何确定一个链表&#xff1f; 4.如何表示链表中的一个结点&#xff1f; 5.链表的分类 四、链表的相关算法 1.链表的创建和遍历 ①准备工作 : ②创建链表 :…
阅读更多...
阿里巴巴春招的后端面经来啦~

阿里巴巴春招的后端面经来啦~

操作系统 一个操作系统&#xff0c;我们在衡量它的内存占用的时候&#xff0c;它一般会有哪些内存的部分&#xff1f; 读者答&#xff1a;堆和栈 补充&#xff1a; 这个其实是问你对free命令的理解。 主机的内存做一些清理的动作。你知道这里面会涉及到对哪些内存区域进行操…
阅读更多...
每日一练2829——反转部分单向链表猴子分桃求正数数组的最小不可组成和（难）有假币

每日一练2829——反转部分单向链表猴子分桃求正数数组的最小不可组成和（难）有假币

文章目录反转部分单向链表方法一&#xff1a;代码&#xff1a;方法二&#xff1a;代码&#xff1a;猴子分桃思路&#xff1a;代码&#xff1a;求正数数组的最小不可组成和思路&#xff1a;代码&#xff1a;有假币思路&#xff1a;代码&#xff1a;反转部分单向链表 题目链接&a…
阅读更多...
146. LRU 缓存

146. LRU 缓存

146. LRU 缓存 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类&#xff1a; LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中&#xff0c;则返回关键字的值&#xff…
阅读更多...
链表 链表之报数问题(循环链表)_46+链表之节点删除_47+链表删除练习_48

链表 链表之报数问题(循环链表)_46+链表之节点删除_47+链表删除练习_48

链表之报数问题 题目描述 有n个人围成一圈&#xff0c;顺序从1开始排号。从第1个人开始报数&#xff08;从1到3报数&#xff09;&#xff0c;凡报到3的人退出圈子&#xff0c;问最后留下的是原来第几号的那位。要求用循环链表实现。 输入格式 只有一个正整数n&#xff0c;保证…
阅读更多...
自定义类型 (结构体）

自定义类型 (结构体）

文章目录&#x1f4ec;结构体的声明&#x1f50e;1.结构的基础知识&#x1f50e;2.结构的声明&#x1f50e;3.特殊的声明&#x1f50e;4.结构的自引用&#x1f50e;5.结构体变量的定义和初始化&#x1f50e;6.结构体内存对齐&#x1f50e;7.修改默认对齐数&#x1f50e;8.结构体…
阅读更多...
9-数据结构-单链表头插法尾插法

9-数据结构-单链表头插法尾插法

问题&#xff1a; 单链表头插法与尾插法 思路&#xff1a; 头插法&#xff0c;类似于前面的在末位置前&#xff0c;插入元素。最后创建完为逆序&#xff1b;尾插法&#xff0c;则是定一个尾指针r&#xff0c;每次接入新的结点s&#xff0c;随后rs(即r往后移位) 详解&#xf…
阅读更多...
B 树的简单认识

B 树的简单认识

理解 B 树的概念 B 树是一种自平衡的查找树&#xff0c;能够保持数据有序。这种数据结构能够让查找数据、顺序访问、插入数据及删除数据的动作&#xff0c;都能在对数时间内完成。 同一般的二叉查找树不同&#xff0c;B 树是一棵多路平衡查找树&#xff0c;其特性是&#xff…
阅读更多...
HashMap,HashTable和ConcurrentHashMap之间有什么区别?

HashMap,HashTable和ConcurrentHashMap之间有什么区别?

前言 在之前HashMap的学习中,我们可以知道HashMap是线程不安全的数据结构,它存储的一般是数据的键值对(Key-Value模型),其中Key允许为null,它底层是数组链表的实现,当单个链表的数据元素过多时,会转变为红黑树,在多线程环境下,对某个HashMap对象进行操作,是无法保证线程安全的,…
阅读更多...
剑指 Offer 52. 两个链表的第一个公共节点 / LeetCode 160. 相交链表（双指针 / 哈希集合）

剑指 Offer 52. 两个链表的第一个公共节点 / LeetCode 160. 相交链表（双指针 / 哈希集合）

题目&#xff1a; 链接&#xff1a;剑指 Offer 52. 两个链表的第一个公共节点&#xff1b;LeetCode 160. 相交链表 难度&#xff1a;简单 输入两个链表&#xff0c;找出它们的第一个公共节点。 如下面的两个链表&#xff1a; 在节点 c1 开始相交。 示例 1&#xff1a; 输入…
阅读更多...
循环队列、双端队列 C和C++

循环队列、双端队列 C和C++

队列 目录 概念 实现方式 顺序队列 循环队列 队列的数组实现 用循环链表实现队列 STL 之 queue 实现队列 STL 之 dequeue 实现双端队列 概念 队列是一种特殊的线性表&#xff0c;它只允许在表的前端&#xff08;称为队头&#xff0c;front&#xff09;进行删除操作…
阅读更多...
经典缓存淘汰算法 LRU实现

经典缓存淘汰算法 LRU实现

LRU 146. LRU 缓存 解题思路 法一&#xff1a;利用 LinkedHashMap 当 accessOrder 为 true 时&#xff0c;内部链表就会按照访问顺序构建&#xff08;该方式太过于简单&#xff0c;省略不写&#xff09; 法二&#xff1a;HashMap 手写双链表 map 存储链表节点地址&#x…
阅读更多...
反转链表问题（递归/迭代）

反转链表问题（递归/迭代）

递归写法 反转整条单链表 可以借助这个写法深入理解递归的精髓 > &#xff08;总结一下&#xff09;进入下一层 下一层可以看作一条链表长度 - 1的新链表 ListNode* reverseList(ListNode* head) { // 这里if > 既是递归的base&#xff0c;返回最后一个结点 // …
阅读更多...
数据结构2：顺序表和链表

数据结构2：顺序表和链表

目录 1.线性表 2.顺序表 2.1概念及结构 2.2接口实现 2.3数据相关面试题 2.4顺序表的问题及思考 3.链表 3.1链表的概念及结构 3.2链表的分类 3.3链表的实现 3.4链表面试题 3.5双向链表的实现 4.顺序表和链表的区别 1.线性表 线性表&#xff08;linear list&#x…
阅读更多...
(链表专题) 21. 合并两个有序链表 ——【Leetcode每日一题】

(链表专题) 21. 合并两个有序链表 ——【Leetcode每日一题】

21. 合并两个有序链表 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#xff1a;l1l1l1 [1,2,4], l2l2l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4] 示例 2&#xff1a; 输入&#xff1a;l1l1l…
阅读更多...
链表与邻接表|栈与队列|kmp

链表与邻接表|栈与队列|kmp

目录 单链表&#xff08;邻接表&#xff09; 双链表 数组模拟栈、队列 单调栈 单调队列&#xff08;滑动窗口&#xff09; KMP 一、KMP算法基本概念与核心思想 二、next数组的含义 三、匹配的思路 四、求next数组 单链表&#xff08;邻接表&#xff09; #include &…
阅读更多...
leetcode刷题（3）

leetcode刷题（3）

各位朋友们大家好&#xff0c;今天是我leedcode刷题系列的第三篇&#xff0c;废话不多说&#xff0c;直接进入主题。 文章目录分割链表题目要求用例输入提示做题思路c语言代码实现Java代码实现相交链表题目要求用例输入提示做题思路c语言实现代码Java代码实现分割链表 leetcod…
阅读更多...
LinkedHashMap源码分析以及LRU的应用

LinkedHashMap源码分析以及LRU的应用

LinkedHashMap源码分析以及LRU的应用 LinkedHashMap简介 LinkedHashMap我们都知道是在HashMap的基础上&#xff0c;保证了元素添加时的顺序&#xff1b;除此之外&#xff0c;它还支持LRU可以当做缓存中心使用 源码分析目的 分析保持元素有序性是如何实现的 LRU是如何实现的…
阅读更多...
epoll准备就绪列表保护机制，引发的锁问题讨论

epoll准备就绪列表保护机制，引发的锁问题讨论

文章目录epoll 就绪队列应该使用什么数据结构&#xff1f;为什么?关于如何使用互斥锁或读写锁来保护链表的操作读写锁的粒度是不是比互斥锁的粒度会更小一些&#xff1f;还有什么比较优势的锁机制吗&#xff1f;自旋锁资源开销还是比较大的&#xff0c;虽然减少了上线文切换&a…
阅读更多...
双向链表--C语言实现数据结构

双向链表--C语言实现数据结构

本期带大家一起用C语言实现双向链表&#x1f308;&#x1f308;&#x1f308; 文章目录 一、链表的概念&#x1f30e;二、链表中数据元素的构成&#x1f30e; &#x1f30d;三、链表的结构&#x1f30e; &#x1f30d; &#x1f30f;四、 双向带哨兵位循环链表的实现&#x1f3…
阅读更多...
链表详解 - C语言描述

链表详解 - C语言描述

目录 认识链表 链表的分类 链表的实现 单链表的增删查改 增操作 删操作 查操作 改操作 带头双向循环链表 认识链表 链表是一种物理存储上非连续&#xff0c;数据元素的逻辑顺序通过链表中的指针链接次序&#xff0c;实现的一种线性存储结构。链表由一系列节点(结点)组…
阅读更多...
[Data structure]双链表 | 一文带你了解线性数据结构之一的双链表

[Data structure]双链表 | 一文带你了解线性数据结构之一的双链表

⭐作者介绍&#xff1a;大二本科网络工程专业在读&#xff0c;持续学习Java&#xff0c;努力输出优质文章 ⭐作者主页&#xff1a;逐梦苍穹 ⭐所属专栏&#xff1a;数据结构 双链表 1、简介2、常见操作3、时间复杂度4、代码实现思路总览5、Node6、DoubleLinkedList6.1、添加节点…
阅读更多...
《链》接未来：力扣“复制带随机指针的链表”题解

《链》接未来：力扣“复制带随机指针的链表”题解

本篇博客会讲解力扣“138. 复制带随机指针的链表”的解题思路&#xff0c;这是题目链接。 先来审题&#xff1a; 以下是输出示例&#xff1a; 以下是提示&#xff1a; 本题要实现复杂链表的深拷贝。复杂链表&#xff0c;是正常的单链表&#xff0c;每个结点中多存了一个指针…
阅读更多...
【面试宝典】聊聊ConcurrentHashMap的存储流程

【面试宝典】聊聊ConcurrentHashMap的存储流程

ConcurrentHashMap的存储流程如下: 根据key的hash值得到数组索引ConcurrentHashMap底层是由一个数组构成的,数组的每个元素是一个链表。第一个步骤是根据key的hash值通过hash算法得到在这个数组中的索引。 CAS插入数组元素使用CAS(比较和交换)操作尝试将这个key-value插入到得…
阅读更多...
【数据结构 -- C语言】 双向带头循环链表的实现

【数据结构 -- C语言】 双向带头循环链表的实现

目录 1、双向带头循环链表的介绍 2、双向带头循环链表的接口 3、接口实现 3.1 开辟结点 3.2 创建返回链表的头结点 3.3 判断链表是否为空 3.4 打印 3.5 双向链表查找 3.6 双向链表在pos的前面进行插入 3.6.1 头插 3.6.2 尾插 3.6.3 更新头插、尾插写法 3.7 双向链…
阅读更多...
【数据结构】堆（笔记总结）

【数据结构】堆（笔记总结）

&#x1f466;个人主页&#xff1a;Weraphael ✍&#x1f3fb;作者简介&#xff1a;目前学习C和算法 ✈️专栏&#xff1a;数据结构 &#x1f40b; 希望大家多多支持&#xff0c;咱一起进步&#xff01;&#x1f601; 如果文章对你有帮助的话 欢迎 评论&#x1f4ac; 点赞&…
阅读更多...
队列的实现（附含两道经典例题）

队列的实现（附含两道经典例题）

&#x1f349;文章主页&#xff1a;阿博历练记 &#x1f4d6;文章专栏&#xff1a;数据结构与算法 &#x1f68d;代码仓库&#xff1a;阿博编程日记 &#x1f365;欢迎关注&#xff1a;欢迎友友们点赞收藏关注哦&#x1f339; 文章目录 &#x1f33e;前言&#x1f3ac;队列&…
阅读更多...
刷题_28：反转部分单向链表 and 猴子分桃

刷题_28：反转部分单向链表 and 猴子分桃

一.反转部分单向链表 题目链接&#xff1a; 反转部分单向链表 题目描述&#xff1a; 给定一个单链表&#xff0c;在链表中把第 L 个节点到第 R 个节点这一部分进行反转。 输入描述&#xff1a; n 表示单链表的长度。 val 表示单链表各个节点的值。 L 表示翻转区间的左端点。 R…
阅读更多...
PTA：C课程设计（7）

PTA：C课程设计（7）

山东大学&#xff08;威海&#xff09;2022级大一下C习题集&#xff08;7&#xff09;函数题7-6-1 递增的整数序列链表的插入7-6-2 查找学生链表7-6-3 统计专业人数7-6-4 建立学生信息链表编程题7-7-1 查找书籍7-7-2 找出总分最高的学生函数题 7-6-1 递增的整数序列链表的插入…
阅读更多...
链表方式实现栈和队列（C语言）

链表方式实现栈和队列（C语言）

目录 栈 队列 栈 栈&#xff08;Stack&#xff09;是一种常见的数据结构&#xff0c;它是一种线性数据结构&#xff0c;具有后进先出&#xff08;Last In First Out, LIFO&#xff09;的特点。栈可以看作是一个容器&#xff0c;只能在容器的一端进行插入和删除操作&#xff0c…
阅读更多...
【LeetCode刷题笔记】反转链表、移除链表元素、两两交换链表中的节点、删除链表的倒数第N个结点

【LeetCode刷题笔记】反转链表、移除链表元素、两两交换链表中的节点、删除链表的倒数第N个结点

&#x1f4dd;个人主页&#xff1a;爱吃炫迈 &#x1f48c;系列专栏&#xff1a;数据结构与算法 &#x1f9d1;‍&#x1f4bb;座右铭&#xff1a;道阻且长&#xff0c;行则将至&#x1f497; 文章目录 反转链表移除链表元素两两交换链表中的节点删除链表的倒数第 N 个结点&…
阅读更多...
单链表C语言实现 （不带头 带头两个版本）

单链表C语言实现 （不带头 带头两个版本）

链表就是许多节点在逻辑上串起来的数据存储方式 是通过结构体中的指针将后续的节点串联起来 typedef int SLTDataType;//数据类型 typedef struct SListNode//节点 {SLTDataType data;//存储的数据struct SListNode* next;//指向下一个节点地址的指针 }SLTNode;//结构体类型的…
阅读更多...
Python每日一练(20230411)

Python每日一练(20230411)

目录 1. 环形链表 &#x1f31f; 2. 比较版本号 &#x1f31f;&#x1f31f; 3. 基本计算器 &#x1f31f;&#x1f31f;&#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Golang每日一练 专栏 Python每日一练 专栏 C/C每日一练 专栏 Java每日一练 专栏…
阅读更多...
【刷题之路Ⅱ】LeetCode 61. 旋转链表

【刷题之路Ⅱ】LeetCode 61. 旋转链表

【刷题之路Ⅱ】LeetCode 61. 旋转链表 一、题目描述二、解题1、方法1——移动部分链表1.1、思路分析1.2、代码实现 2、方法1——闭合为环2.1、思路分析2.2、代码实现 一、题目描述 原题连接&#xff1a; 61. 旋转链表 题目描述&#xff1a; 给你一个链表的头节点 head &#x…
阅读更多...
【数据结构】图笔记

【数据结构】图笔记

树是一种特殊的图。 &#xff08;单链表树有向&#xff0c;双链表树无向&#xff09;无环&#xff0c;每条路径权重均为1&#xff0c;每个节点最多只有两条路径连通别的点。 不抽象来看&#xff0c;一棵树里的连通其实完全可以用矩阵来表示&#xff0c;但由于树每个节点只有两…
阅读更多...
双向链表及双向链表的常见操作和用js封装一个双向链表

双向链表及双向链表的常见操作和用js封装一个双向链表

书接上回&#xff0c;上一篇文章讲了单向链表以及用 js 封装一个单向链表&#xff0c;所以这节将介绍双向链表以及用 js 封装一个双向链表。待会我也会继续在文章后面附上视频学习链接地址&#xff0c;大家想学习的可以去看看 一、认识双向链表 首先来认识一下什么是双向链表&…
阅读更多...
【刷题之路Ⅱ】LeetCode 143. 重排链表

【刷题之路Ⅱ】LeetCode 143. 重排链表

【刷题之路Ⅱ】LeetCode 143. 重排链表 一、题目描述二、解题1、方法1——线性表辅助1.1、思路分析1.2、代码实现 2、方法2——中间节点反转链表合并链表2.1、思路分析2.2、代码实现 一、题目描述 原题连接&#xff1a; 143. 重排链表 题目描述&#xff1a; 给定一个单链表 L …
阅读更多...
单链表——单链表的定义及基本操作（初始化、头插法尾插法建表、查找、插入、删除、判空等）

单链表——单链表的定义及基本操作（初始化、头插法尾插法建表、查找、插入、删除、判空等）

单链表的定义 由于顺序表存在以下缺陷&#xff0c;所以衍生出了链表&#xff0c;而链表种类有很多种&#xff0c;今天我们讲的是单链表。 顺序表存在的问题如下 1.中间/头部的插入删除&#xff0c;时间复杂度为O(N) 2. 增容需要申请新空间&#xff0c;拷贝数据&#xff0c;释…
阅读更多...
ChatGPT实现用C语言写一个学生成绩管理系统

ChatGPT实现用C语言写一个学生成绩管理系统

随着ChatGPT爆火&#xff0c;大家都在使用ChatGPT来帮助自己提高效率&#xff0c;对于程序员来说使用它来写代码怎么样呢&#xff1f;今天尝试让ChatGPT&#xff0c;写了一个学生成绩管理系统。 问题是&#xff1a;使用C语言写一个学生成绩管理系统&#xff0c;要求使用链表&a…
阅读更多...
【Java数据结构】链表OJ提交小记

【Java数据结构】链表OJ提交小记

目录 1.删除链表中所有值为val的节点 2.反转单链表 3.返回链表的中间节点 4.返回链表倒数第k个节点 5.按次序合并链表 6.按值分割链表 7.判断链表是否为回文 1.删除链表中所有值为val的节点 1. 删除链表中所有值为val的节点https://leetcode.cn/problems/remove…
阅读更多...
算法：链表和数组哪个实现队列更快

算法：链表和数组哪个实现队列更快

背景 对于这个问题&#xff0c;我们先来思考一下数组和链表各有什么特点。 数组&#xff1a;连续存储&#xff0c;push 很快&#xff0c;shift 很慢。 链表&#xff1a;非连续存储&#xff0c;add、delete 都很快&#xff0c;但是查找很慢。 所以&#xff0c;我们可以得出结论…
阅读更多...
使用js封装一个循环链表

使用js封装一个循环链表

直接不说废话&#xff0c;直接上代码&#xff0c;这里继承了单向链表的类LinkList &#xff0c;可以查看之前的文章&#xff0c;点这里 class Node {constructor(element) {this.element element;this.next null;} }class CirularLinkedList extends LinkList {constructor(…
阅读更多...
炫技操作--递归实现翻转链表（java）

炫技操作--递归实现翻转链表（java）

递归实现链表的逆序 leetcode 206题。 翻转链表递归解法普通方式实现链表翻转链表专题 leetcode 206题。 翻转链表 leetcode链接用于测试 题目&#xff1a;描述 将一个链表翻转&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1] 递归解法 解题思路…
阅读更多...
深入理解Java中的HashMap：工作原理、实现方式与使用案例分析

深入理解Java中的HashMap：工作原理、实现方式与使用案例分析

HashMap是一种非常常见和实用的数据结构&#xff0c;它被广泛应用于Java编程中。在本文中&#xff0c;我们将深入探讨HashMap的工作原理、实现方式和使用案例&#xff0c;以帮助读者更好地理解和应用这一数据结构。 一、HashMap的工作原理 HashMap是一种基于哈希表实现的数据…
阅读更多...
数据结构入门-9-线段树字典树并查集

数据结构入门-9-线段树字典树并查集

文章目录一、线段数Segment Tree1.1 线段树的优势1.1.2 数组实现线段树1.2 线段树结构1.2.1 创建线段树1.2.2 线段树中的区间查询1.2.3 线段树的更新二、字典树 Trie1.2 字典树结构1.2.1 创建Trie1.2.2 Trie查询三、并查集3.1 并查集的实现3.1.1 QuickFind3.1.1 QuickUnion初始…
阅读更多...
channel 源码解析(5问)

channel 源码解析(5问)

目录 1.channel底层数据结构是什么 2.channel创建的底层实现 3.channel 的发送过程 4.channel的接受过程 5.关闭 channel 1.channel底层数据结构是什么 channel底层的数据结构是hchan,包括一个循环链表和2个双向链表 type hchan struct {qcount uint // tota…
阅读更多...
C++链表解析：从基础原理到高级应用，全面掌握链表的使用

C++链表解析：从基础原理到高级应用，全面掌握链表的使用

C链表解析&#xff1a;从基础原理到高级应用&#xff0c;全面掌握链表的使用一、引言数据结构与算法的重要性链表的概念与作用链表在现代C编程中的应用场景二、链表基础概念单链表与双链表链表节点的定义与创建链表的头节点与尾节点三、C标准链表容器std::list简介std::list的基…
阅读更多...
【数据结构】和栈一样简单的结构——队列

【数据结构】和栈一样简单的结构——队列

【数据结构】和栈一样简单的结构——队列 一、前言1、什么是队列&#xff1f;2、使用什么结构实现&#xff1f; 二、目标三、实现1、初始化工作2、入队2.1、图解思路2.2、代码实现 3、出队3.1、图解思路3.2、代码实现 4、打印队列(用于测试)5、返回队头元素6、返回队尾元素7、返…
阅读更多...
双向链表的功能实现

双向链表的功能实现

前言&#xff1a;我们已经学习并知道了单链表的实现&#xff0c;链表的实现方式不只是单链表一种&#xff0c;今天我们就来介绍一种新的结构&#xff0c;就是双链表结构&#xff0c;本质上是将节点间进行双向链接&#xff0c;从而使一些操作更加容易实现。 目录 1.双向链表的简…
阅读更多...
【刷题之路】LeetCode24——详解两两交换链表中的结点的细节

【刷题之路】LeetCode24——详解两两交换链表中的结点的细节

一、题目描述 原题链接&#xff1a;https://leetcode.cn/problems/swap-nodes-in-pairs/comments/ 题目描述&#xff1a;给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&am…
阅读更多...
外强中干——双向带头循环链表

外强中干——双向带头循环链表

前言&#xff1a;众所周知&#xff0c;链表有八种结构&#xff0c;由单向或双向&#xff0c;有头或无头&#xff0c;循环或不循环构成。在本篇&#xff0c;将介绍8种链表结构中最复杂的——双向带头循环链表。听着名字或许挺唬人的&#xff0c;但实际上双向带头循环链表实现起来…
阅读更多...
来领略一下带头双向循环链表的风采吧

来领略一下带头双向循环链表的风采吧

&#x1f349; 博客主页&#xff1a;阿博历练记 &#x1f4d6;文章专栏&#xff1a;数据结构与算法 &#x1f68d;代码仓库&#xff1a;阿博编程日记 &#x1f339;欢迎关注&#xff1a;欢迎友友们点赞收藏关注哦 文章目录 &#x1f344;前言&#x1f37c;双向循环链表&#x1…
阅读更多...
链表--part 1--链表基础理论（概括）

链表--part 1--链表基础理论（概括）

文章目录 单链表双链表循环链表链表链表的定义删除节点增加节点 首先什么是链表&#xff0c;链表是一种通过指针串联在一起的线性结构&#xff0c;每一个节点由两部分组成&#xff0c;一个是数据域一个是指针域&#xff08;存放指向下一个节点的指针&#xff09;&#xff0c;最…
阅读更多...
Java中链表的实现(超详细)

Java中链表的实现(超详细)

在Java中&#xff0c;链表可以通过创建节点和链接节点来实现。以下是一个简单的链表实现示例&#xff1a; public class LinkedList {Node head; // 头结点// 节点类class Node {int data;Node next;Node(int d) {data d;next null;}}// 在链表头部插入节点public void push…
阅读更多...
快乐数链表篇

快乐数链表篇

编写一个算法来判断一个数 n 是不是快乐数。 「快乐数」 定义为&#xff1a; 对于一个正整数&#xff0c;每一次将该数替换为它每个位置上的数字的平方和。 然后重复这个过程直到这个数变为 1&#xff0c;也可能是 无限循环 但始终变不到 1。 如果这个过程 结果为 1&#xff…
阅读更多...
数据结构（数组、链表、栈、队列、树）

数据结构（数组、链表、栈、队列、树）

文章目录 1.数组1.1数组的特点1.2自定义数组 2.链表2.1链表的特点2.2自定义链表2.2.1自定义单向链表2.2.2自定义双向链表 3.栈3.1栈的特点3.2 Stack使用举例3.3 自定义栈 4. 队列5. 树与二叉树5.1 树的理解5.2 二叉树的基本概念5.3 二叉树的遍历5.4 经典二叉树和红黑树5.5 二叉…
阅读更多...
数据结构与算法02：数组和链表

数据结构与算法02：数组和链表

目录 【数组】 为什么Go语言的切片是成倍扩容&#xff1f; 【链表】 单链表 循环链表 双向链表 双向循环链表 数组和链表如何选择&#xff1f; 如何使用链表实现 LRU 缓存淘汰算法&#xff1f; 链表的一些操作 【每日一练】 【数组】 数组&#xff08;Array&#…
阅读更多...
合并两个有序链表（java）

合并两个有序链表（java）

leetcode 21题&#xff1a;合并两个有序链表 题目描述解题思路&#xff1a;链表的其它题型。 题目描述 leetcode21题&#xff1a;合并两个有序链表 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例&#xff1a; 输入&…
阅读更多...
js对链表的处理方法

js对链表的处理方法

什么是链表&#xff1f; 链表是一种常见的数据结构&#xff0c;用于存储一系列元素&#xff0c;并按照一定顺序连接它们。在链表中&#xff0c; 元素被存储在独立的节点中&#xff0c;每个节点都包含一个值和一个指向下一个节点的指针。 通过这些指针&#xff0c;链表的一部分…
阅读更多...
[链表OJ题 2] 链表的中间结点 -- 快慢指针找链表的中间节点

[链表OJ题 2] 链表的中间结点 -- 快慢指针找链表的中间节点

目录 题目来源&#xff1a; 代码实现 思路分析&#xff1a; 1.当链表个数为奇数 2.当链表个数为偶数 总结&#xff1a; 题目来源&#xff1a; 876. 链表的中间结点 - 力扣&#xff08;LeetCode&#xff09; (leetcode-cn.com) 题目描述&#xff1a; 代码实现 struct Li…
阅读更多...
BM14 链表的奇偶重排

BM14 链表的奇偶重排

链表的奇偶重排_牛客题霸_牛客网 (nowcoder.com) 双指针解决 /*** struct ListNode {* int val;* struct ListNode *next;* ListNode(int x) : val(x), next(nullptr) {}* };*/ class Solution { public:/*** 代码中的类名、方法名、参数名已经指定&#xff0c;请勿修改&#x…
阅读更多...
单链表—C语言实现数据结构

单链表—C语言实现数据结构

本期带大家一起用C语言实现单链表&#x1f308;&#x1f308;&#x1f308; 文章目录 一、链表的概念&#x1f30e;二、链表中数据元素的构成&#x1f30e; &#x1f30d;三、链表的结构&#x1f30e; &#x1f30d; &#x1f30f;四、 单链表的实现✅✅二、接口的实现✅✅1.单…
阅读更多...
有序表2：跳表

有序表2：跳表

跳表是一个随机化的数据结构&#xff0c;可以被看做二叉树的一个变种&#xff0c;它在性能上和红黑树&#xff0c;AVL树不相上下&#xff0c;但是跳表的原理非常简单&#xff0c;目前在Redis和LeveIDB中都有用到。 它采用随机技术决定链表中哪些节点应增加向前指针以及在该节点…
阅读更多...
单链表OJ题：LeetCode--203.移除链表元素

单链表OJ题：LeetCode--203.移除链表元素

朋友们、伙计们&#xff0c;我们又见面了&#xff0c;今天给大家带来的是LeetCode中203题&#xff1a;移除链表元素 数据结构&#xff1a;数据结构专栏 作 者&#xff1a;stackY、 C 语 言 &#xff1a;C语言专栏 LeetCode--203.移除链表元素&#xff1a;https://leetco…
阅读更多...
Leetcode刷题之两两交换链表中的结点和相交链表

Leetcode刷题之两两交换链表中的结点和相交链表

只有把抱怨环境的心情&#xff0c;化为上进的力量&#xff0c;才是成功的保证。 ——罗曼罗兰目录 &#x1f349;一.相交链表 &#x1f490;1.双指针 &#x1f34d;2.计算长度加双指针 &#x1f352;二.两两交换链表中的结点 &#x1f34c;1.迭代 &#x1f349;一…
阅读更多...
【算法与数据结构】链表——题目详解

【算法与数据结构】链表——题目详解

题目详解 Leetcode-206. 反转链表 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1] 示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&#x…
阅读更多...
JS 循环链表

JS 循环链表

文章目录 导文循环链表的概念循环链表具有以下几个特点&#xff1a;实现一个循环列表 导文 循环链表是一种特殊的链表数据结构&#xff0c;其中最后一个节点指向链表的头节点&#xff0c;形成一个循环的环状结构。与普通链表不同&#xff0c;循环链表没有明确的结束点&#xff…
阅读更多...
链表刷题(4~8)

链表刷题(4~8)

目录 反转链表 返回中间节点 倒数k个节点 链表分割 判断回文 反转链表 单链表刷题时我们遇到过一个反转链表&#xff0c;那时我们采用的是头插的方式达到反转的效果&#xff0c;那能不能把指针反过来呢&#xff1f;答案是可以的。 这里用三个指针是为了记录后面节点的数据&…
阅读更多...
HOT23-反转链表

HOT23-反转链表

leetcode原题链接&#xff1a;反转链表 题目描述 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&#xff1a; 输入&#xff1a;head [1,2] 输…
阅读更多...
刷题日记《链表02》

刷题日记《链表02》

题目描述 给定两个 非空链表 l1和 l2 来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。 可以假设除了数字 0 之外&#xff0c;这两个数字都不会以零开头。 解题思路 面对这种求和相加的题目&#xff0c;不知道…
阅读更多...
数据结构：单链表增、删、查、改的实现

数据结构：单链表增、删、查、改的实现

1.概念 链表是一种 物理存储结构上非连续 、非顺序的存储结构&#xff0c;数据元素的 逻辑顺序 是通过链表 中的 指针链接 次序实现的 。 2.形式 我们使用链表一般都是创建一个结构体。 typedef int SLTDataType; typedef struct SListNode {SLTDataType data;struct SListN…
阅读更多...
C/C++每日一练(20230508) 链表专题2

C/C++每日一练(20230508) 链表专题2

目录 1. 相交链表 &#x1f31f;&#x1f31f; 2. 排序链表 &#x1f31f;&#x1f31f; 3. 重排链表 &#x1f31f;&#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Golang每日一练 专栏 Python每日一练 专栏 C/C每日一练 专栏 Java每日一练 专栏 1. …
阅读更多...
栈和队列：理解与使用

栈和队列：理解与使用

目录 栈 顺序栈结构 链式栈结构 中缀表达式和后缀表达式 顺序栈四则运算 链式栈四则运算 队列 顺序队列结构 链式队列结构 总结 栈和队列是计算机科学中常见的数据结构&#xff0c;它们都是一种线性数据结构&#xff0c;可以对元素进行快速的插入、删除和查找操作。栈…
阅读更多...
数据结构(二叉树)

数据结构(二叉树)

文章目录 一、树的基础概念1.1 树型结构1.2 树型的概念 二、二叉树2.1 概念 性质2.2 二叉树的存储2.2 二叉树的基本操作&#xff08;1&#xff09;遍历&#xff08;2&#xff09;其他 2.3 二叉树练习 一、树的基础概念 1.1 树型结构 树是一种非线性的数据结构&#xff0c;它…
阅读更多...
you dont always get all the things in the bag

you dont always get all the things in the bag

you dont always get all the things in the bag. 你并不能得到所有你想要的东西。 that you selected from the menu in the delivsry surface. That is life 这就是生活&#xff0c; you get what you get.命里有时终须有&#xff0c;命里无时莫强求 especially if you t…
阅读更多...
《数据结构与算法（java版）》第六章 链表结构

《数据结构与算法（java版）》第六章 链表结构

链表结构 6.1 表节点 1.一个表节点只包含一个元素&#xff0c;但是它还包含另一个表节点(实际上是包含指向这个表节点的引用)。 2.创建节点的方式 先创建节点&#xff0c;再链接。 A)ListNode node1 new ListNode(“A”); ListNodenode2 new ListNode(“B”); ListNodenode3…
阅读更多...
【剑指offer专项突破版】链表篇——“C“

【剑指offer专项突破版】链表篇——“C“

文章目录 前言一.删除链表的倒数第 n 个结点题目分析思路分析细节分析步骤代码 二.链表中环的入口节点题目分析思路分析写法①代码写法②代码: 三.两个链表的第一个重合节点题目分析思路分析代码 四.反转链表题目分析思路分析法①代码法②代码法③代码 五.链表中的两数相加题目…
阅读更多...
Java集合框架：ArrayList详解

Java集合框架：ArrayList详解

目录 一、ArrayList简介 二、ArrayList源码介绍&#xff08;动态扩容以及构造方法是如何实现的&#xff09; 1. 扩容机制&#xff1a; 源码&#xff1a; 源码详解&#xff1a; ​编辑 如何扩容&#xff1a; 2. 扩容源码详解&#xff1a; 三、ArrayList的构造方法 四、ArrayL…
阅读更多...
redis中的 adlist链表实现

redis中的 adlist链表实现

adlist源码解读(基于redis 6.2.7) 1丶打开源码 adlist.h typedef struct listNode {struct listNode *prev;struct listNode *next;void *value; } listNode;//迭代时 使用 typedef struct listIter {listNode *next;int direction; 迭代方向 } listIter;typedef struct lis…
阅读更多...
707.设计链表

707.设计链表

707.设计链表 https://leetcode.cn/problems/design-linked-list/description/ 单链表实现 单链表的创建需要一个头节点&#xff0c;它不存储值但指向第一个元素&#xff0c;便于后续的增删改查操作的实现 注意&#xff1a; 复用 addAtIndex 函数实现添加头尾节点的功能 …
阅读更多...
单链表经典面试题 (动图解析)

单链表经典面试题 (动图解析)

&#x1f389;&#x1f389;&#x1f389;点进来你就是我的人了 博主主页&#xff1a;&#x1f648;&#x1f648;&#x1f648;戳一戳,欢迎大佬指点!人生格言&#xff1a;当你的才华撑不起你的野心的时候,你就应该静下心来学习! 欢迎志同道合的朋友一起加油喔&#x1f9be;&am…
阅读更多...
17 标准模板库STL之list

17 标准模板库STL之list

基础知识 1、list是由双向链表实现的，这也意味着，其内存空间是不连续的。因此，list不支持随机访问，没有提供[]操作符重载和at()函数，迭代器只能进行++和--操作，不能进行+n和-n操作。由于底层使用链表实现，list在任意位置插入和移除元素都非常高效。list适用于需要经常进…
阅读更多...
栈实现(通过数组和链表)

栈实现(通过数组和链表)

栈 栈是一种只允许在一端进行插入或删除的线性表。 1、栈的操作端通常被称为栈顶&#xff0c;另一端被称为栈底。 2、栈的插入操作称为进栈&#xff08;压栈|push&#xff09;&#xff1b;栈删除操作称为出栈&#xff08;弹栈|pop&#xff09;。 定义一个栈接口&#xff1a; …
阅读更多...
【leetcode】-关于复制带随机指针的链表

【leetcode】-关于复制带随机指针的链表

作者&#xff1a;小树苗渴望变成参天大树 作者宣言&#xff1a;认真写好每一篇博客 作者gitee:gitee 如 果 你 喜 欢 作 者 的 文 章 &#xff0c;就 给 作 者 点 点 关 注 吧&#xff01; 文章目录前言前言 hello,各位友友们&#xff0c;今天我们不讲新的知识点&#xff0c;…
阅读更多...
什么是关联式容器和序列时容器?二者的区别是什么？

什么是关联式容器和序列时容器?二者的区别是什么？

关联式容器和序列容器都是C STL中的容器&#xff0c;它们主要的区别在于其存储内部元素的方式不同。 序列容器是按照元素插入的顺序来存储元素的&#xff0c;也就是说&#xff0c;元素在容器中的位置与其被插入的先后顺序是一致的。例如&#xff0c;vector、list 和deque都是序…
阅读更多...
力扣---LeetCode21. 合并两个有序链表(链表经典题)

力扣---LeetCode21. 合并两个有序链表(链表经典题)

文章目录 前言21. 合并两个有序链表链接&#xff1a;方法一&#xff1a;取小尾插1.1代码&#xff1a;1.2 流程图&#xff1a;1.3 注意&#xff1a; 方法二&#xff1a;带哨兵位2.1代码&#xff1a;2.2流程图&#xff1a; 总结 前言 焦虑不会消除明天的悲伤 只会让你今天的力量…
阅读更多...
【数据结构】原来你叫“带头结点的双向循环链表”啊

【数据结构】原来你叫“带头结点的双向循环链表”啊

&#x1f9d1;‍&#x1f4bb;作者&#xff1a; 情话0.0 &#x1f4dd;专栏&#xff1a;《数据结构》 &#x1f466;个人简介&#xff1a;一名双非编程菜鸟&#xff0c;在这里分享自己的编程学习笔记&#xff0c;欢迎大家的指正与点赞&#xff0c;谢谢&#xff01; 带头结点的…
阅读更多...
[杂记]算法: 快慢指针

[杂记]算法: 快慢指针

打算以后记录一些比较有代表性的算法. 仅从初学者角度对算法进行简单解读, 以力扣题为例. 0. 快慢指针 快慢指针是双指针的一种. 一般来说, 在判断存不存在环结构的时候比较有用. 通常来讲, 我们通过指针进行遍历, 快指针一次走两步, 慢指针一次走一步, 快慢指针相遇往往就意味…
阅读更多...
平衡二叉树（AVL树）

平衡二叉树（AVL树）

平衡二叉树(AVL) 问题引入: 在二分搜索树(二叉排序树)中如果面对一个有序序列的插入,则会造成二分搜索树退化成为链表。例如对于序列&#xff1a;3&#xff0c;4&#xff0c;5&#xff0c;6&#xff0c;7依次插入二分搜索树时会形成一个单链表。 此时虽然二分搜索树的插入与删…
阅读更多...
LeetCode刷题---142. 环形链表 II（双指针-快慢指针）

LeetCode刷题---142. 环形链表 II（双指针-快慢指针）

文章目录一、编程题&#xff1a;142. 环形链表 II&#xff08;双指针-快慢指针&#xff09;1.题目描述2.示例1&#xff1a;3.示例2&#xff1a;4.示例3&#xff1a;5.提示&#xff1a;6.提示&#xff1a;二、解题思路1.思路2.复杂度分析&#xff1a;3.算法图解三、代码实现总结…
阅读更多...
Java 中的集合框架有哪些？（十四）

Java 中的集合框架有哪些？（十四）

Java 中的集合框架包含了各种不同类型的集合和数据结构&#xff0c;用于存储和处理数据。这些集合和数据结构可以提高程序的性能和可读性&#xff0c;并且可以方便的进行数据操作和算法实现。本文将介绍 Java 中的集合框架&#xff0c;以及各种不同类型的集合和数据结构。 Jav…
阅读更多...
React 的源码与原理解读（二）：Fiber 与 Fiber 链表树

React 的源码与原理解读（二）：Fiber 与 Fiber 链表树

写在专栏开头&#xff08;叠甲&#xff09; 作者并不是前端技术专家&#xff0c;也只是一名喜欢学习新东西的前端技术小白&#xff0c;想要学习源码只是为了应付急转直下的前端行情和找工作的需要&#xff0c;这篇专栏是作者学习的过程中自己的思考和体会&#xff0c;也有很多参…
阅读更多...
C语言学习笔记—链表（五）链表的动态创建

C语言学习笔记—链表（五）链表的动态创建

头插法 也就是说头结点就是最新的节点&#xff0c;新节点一进来就是头节点。 #include <stdio.h> //定义结构体 struct Test {int data;struct Test *next; }; //输出链表数据 void printLink(struct Test *head) {struct Test *piont head;while(piont ! NULL){prin…
阅读更多...
C语言学习笔记—链表（三）链表的插入

C语言学习笔记—链表（三）链表的插入

从指定节点后方插入新节点 假设我们已有五个节点&#xff0c;我们要把一个新节点new插入到3后边。 需要三个步骤&#xff1a; 找到 3 这个节点。把新节点指向3这个节点的下一个节点&#xff08;3->next new->next&#xff09;。把3指向新节点。&#xff08;3->next…
阅读更多...
list_cut_position-linux链表-5

list_cut_position-linux链表-5

注解&#xff1a; 对于list_cut_position的用法不能理解&#xff0c;看了实际的例子才知道如何用的。 主要是对于list、entry和head的关系没搞太明白。 list&#xff1a;是一个空链表头&#xff0c;可以是head也可以不是 entry&#xff1a;是head链表的任意一个节点 这样就…
阅读更多...
LRU缓存机制（包含流程图分析以及各操作的解析详解）

LRU缓存机制（包含流程图分析以及各操作的解析详解）

LRU缓存机制一、题目需求二、LRU缓存机制的概念三、LRU缓存机制的代码示例四、LRU缓存机制的分析&#xff08;一&#xff09;、内部类CacheNode&#xff08;二&#xff09;、内部变量&#xff08;三&#xff09;、get&#xff08;&#xff09;操作&#xff08;四&#xff09;、…
阅读更多...
复制带随机指针的链表的题型分析（包含流程图分析）

复制带随机指针的链表的题型分析（包含流程图分析）

复制带随机指针的链表一、题目要求二、使用HashMap的解法三、使用添加节点的解法四、测试用例五、流程图&#xff08;一&#xff09;、使用HashMap的流程图&#xff08;二&#xff09;、添加节点的流程图一、题目要求 给定一个链表&#xff0c;每个节点包含一个额外增加的随机…
阅读更多...
画图以及代码分析结合的循环队列的实现

画图以及代码分析结合的循环队列的实现

循环队列的实现 概念以及结构实现初始化判空判满入队出队从队头获得元素从队尾获得元素释放 概念以及结构 循环队列是一种线性数据结构&#xff0c;其操作表现基于 FIFO&#xff08;先进先出&#xff09;原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”…
阅读更多...
Day02剑指offer-链表

Day02剑指offer-链表

视频地址&#xff1a;帅地玩编程 剑指 Offer 06. 从尾到头打印链表 输入一个链表的头节点&#xff0c;从尾到头反过来返回每个节点的值&#xff08;用数组返回&#xff09;。 概念 .val()方法 .val()无参数&#xff0c;获取匹配的元素集合中第一个元素的当前值.val( value…
阅读更多...
【地铁上的Redis与C#】数据类型（七）--List类型

【地铁上的Redis与C#】数据类型（七）--List类型

我们这篇文章开始讲解list类型。 什么是list list是一个存储空间保存多个数据&#xff0c;底层使用双向链表存储结构实现的一种Redis数据类型&#xff0c;。list类型一般用在存储多个数据&#xff0c;并需要对数据进入存储空间的顺序进行区分的情况下。list的存储方式是一个存…
阅读更多...
LeetCode刷题笔记 Java 腾讯 链表突击 二叉树中的最大路径和

LeetCode刷题笔记 Java 腾讯 链表突击 二叉树中的最大路径和

题目 官解 路径 被定义为一条从树中任意节点出发&#xff0c;沿父节点-子节点连接&#xff0c;达到任意节点的序列。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点&#xff0c;且不一定经过根节点。 路径和 是路径中各节点值的总和。 给你一个二叉树…
阅读更多...
HashMap底层实现原理和扩容机制

HashMap底层实现原理和扩容机制

一、底层原理 HashMap底层是基于哈希表数组实现的&#xff0c;它依赖hashCode方法和equals方法保证"键"的唯一 jdk1.8之前&#xff1a;数组链表头插法 jdk1.8之后&#xff1a;数组链表红黑数尾插法 树化和反树化&#xff1a;当链表长度大于8时&#xff0c;链表会…
阅读更多...
中序线索二叉树

中序线索二叉树

#include <stdio.h> #include <stdlib.h> #include<stdbool.h>#define MaxSize 50typedef int Elemtype;//线索二叉树的定义 typedef struct ThreadNode {Elemtype data;struct TreadNode *lchild,*rchild;int ltag,rtag; } ThreadNode,*ThreadTree;ThreadT…
阅读更多...
双向链表Locate按访问频率排序

双向链表Locate按访问频率排序

双向链表Locate按访问频率排序 1、首先找到该元素第一个值 2、拿出前面结点,用来寻找合适位置插入(根据频率比较,如果小于当前频率就向前移动) 3、找到合适位置插入 实现代码 #include <stdio.h> #include <stdlib.h> #include<stdbool.h>//双向链表 typede…
阅读更多...
判断单链表是否环化和寻找环的起点

判断单链表是否环化和寻找环的起点

首先判断链表是否环化 我们可以使用一对"快慢指针",快指针每次走两步,慢指针每次走一步,同时从起点出发,依次向后遍历链表,如果两个指针相遇则一定存在环,如果不能相遇则不存在环 实现代码 LNode *fastL->next,*slowL->next;//使用快慢指针while(fast!NULL&…
阅读更多...
插入排序使得链表有序

插入排序使得链表有序

#include <stdio.h> #include <stdlib.h> #include<stdbool.h>typedef int Elemtype;//单链表typedef struct LNode {Elemtype data;//存放数据struct LNode *next; //指向LNode的一个指针} LNode,*LinkList; //相当于取别名,LNode代表一个节点,LinkList代表…
阅读更多...
反向打印链表(递归)

反向打印链表(递归)

反向打印链表(递归) 每次向下递归直到链表为空,向上返回,依次输出当前结点的值 代码实现 #include <stdio.h> #include <stdlib.h> #include<stdbool.h>typedef int Elemtype;//单链表typedef struct LNode {Elemtype data;//存放数据struct LNode *next; /…
阅读更多...
FreeRTOS：列表和列表项

FreeRTOS：列表和列表项

要想看懂 FreeRTOS 源码并学习其原理&#xff0c;有一个东西绝对跑不了&#xff0c;那就是 FreeRTOS 的列表和列表项。列表和列表项是FreeRTOS的一个数据结构&#xff0c; FreeRTOS 大量使用到了列表和列表项&#xff0c;它是 FreeRTOS 的基石。要想深入学习并理解 FreeRTOS&am…
阅读更多...
栈——“数据结构与算法”

栈——“数据结构与算法”

各位uu们&#xff0c;好久不见&#xff01;&#xff01;&#xff01;甚是想念&#xff01;&#xff01;&#xff01; 好久没有更新我们的数据结构与算法专栏啦&#xff0c;最近小雅兰新学了很多知识&#xff0c;第一时间就想迫不及待地和C站的小伙伴们分享呢&#xff0c;下面&a…
阅读更多...
C语言对链表的基本操作（1、创建表 2、创建节点 3、表头插入 4、表尾插入 5、打印表）

C语言对链表的基本操作（1、创建表 2、创建节点 3、表头插入 4、表尾插入 5、打印表）

1. 链表的结构体定义&#xff08;结点定义&#xff09; 链表的一个结点首先肯定包含一个数据域和一个指针域&#xff0c;数据域用来存放结点数据&#xff0c;指针域存放的是指向下一个结点的地址。当然&#xff0c;头节点例外&#xff0c;其实&#xff0c;头结点和普通结点一样…
阅读更多...
一问读懂链表结构，及应用场景

一问读懂链表结构，及应用场景

Java中的链表结构是指&#xff0c;将一组数据按照指定规则连接起来的数据结构。它由多个节点组成&#xff0c;每个节点包含一个数据元素和一个指向下一个节点的引用。在Java中&#xff0c;这种数据结构被封装成了一个链表类&#xff0c;常见的有单向链表、双向链表和循环链表等…
阅读更多...
数据结构与算法—二分查找

数据结构与算法—二分查找

目录 二分查找 时间复杂度 程序设计要点 局限性 二分查找的变形 实例分析 二叉搜索实现&#xff08;不考虑重复条件&#xff09; 二分查找 针对的是一个有序的数据集合&#xff0c;查找思想类似于分治思想。 每次通过跟区间中的元素对比&#xff0c;将待查找的区间缩小…
阅读更多...
HashMap源码详解

HashMap源码详解

文章目录 简单介绍提出问题流程说明及验证put元素的流程怎样找到要存储的下标位置的?什么时候会扩容? 加载因子、阈值这些有什么含义?怎样扩容的?扩容的流程.链表可以转成红黑树, 那会从红黑树转成链表吗?什么时候会从链表转成红黑树 小总结 简单介绍 HashMap是Java中最最…
阅读更多...
牛客 剑指Offer 删除链表中重复的节点

牛客 剑指Offer 删除链表中重复的节点

题目 \qquad在一个排序的链表中&#xff0c;存在重复的结点&#xff0c;请删除该链表中重复的结点&#xff0c;重复的结点不保留&#xff0c;返回链表头指针。 例如&#xff0c;链表1->2->3->3->4->4->5 处理后为 1->2->5 代码和解释 \qquad这道题目要…
阅读更多...
数据结构与算法04：队列

数据结构与算法04：队列

目录 什么是队列&#xff1f; 循环队列 双端队列 阻塞队列 队列的应用场景 每日一练 什么是队列&#xff1f; 在 上一篇文章 中讲述了栈&#xff1a;先进后出就是栈&#xff0c;队列刚好相反&#xff0c;先进先出的数据结构就是队列&#xff0c;还是拿纸箱子来举例&…
阅读更多...
PixiJS 源码深入解读：用于循环渲染的 Ticker 模块

PixiJS 源码深入解读：用于循环渲染的 Ticker 模块

大家好&#xff0c;我是前端西瓜哥。这次来看看 PixiJS 的 Ticker 模块源码。 Ticker 的作用是 在下一帧绘制前调用监听器&#xff0c;PixiJS 使用它来不断对画面进行重绘。 版本为 7.2.4。 使用 在我们 实例化 PIXI.Application 时&#xff0c;PIXI.Application 内部注册的…
阅读更多...
第五十七天学习记录：C语言进阶：结构体链表的自学

第五十七天学习记录：C语言进阶：结构体链表的自学

先展示一段代码&#xff1a; #define _CRT_SECURE_NO_WARNINGS 1#include <stdio.h> #include <stdlib.h>// 定义链表节点结构体 typedef struct Node {int value;struct Node* next; } Node;int main() {// 创建链表头指针Node* head (Node*)malloc(sizeof(Node…
阅读更多...
【牛客刷题专栏】0x0E:JZ6 从尾到头打印链表(C语言编程题)

【牛客刷题专栏】0x0E:JZ6 从尾到头打印链表(C语言编程题)

前言 个人推荐在牛客网刷题(点击可以跳转)&#xff0c;它登陆后会保存刷题记录进度&#xff0c;重新登录时写过的题目代码不会丢失。个人刷题练习系列专栏&#xff1a;个人CSDN牛客刷题专栏。 题目来自&#xff1a;牛客/题库 / 在线编程 / 剑指offer&#xff1a; 目录前言问题…
阅读更多...
面试题76：删除链表中重复的节点

面试题76：删除链表中重复的节点

面试题76&#xff1a;删除链表中重复的节点 在一个排序的链表中&#xff0c;存在重复的结点&#xff0c;请删除该链表中重复的结点&#xff0c;重复的结点不保留&#xff0c;返回链表头指针。 例如&#xff0c;链表 1->2->3->3->4->4->5 处理后为 1->2-&…
阅读更多...
算法刷题-链表-删除链表的倒数第N个节点

算法刷题-链表-删除链表的倒数第N个节点

删除链表的倒数第N个节点 19.删除链表的倒数第N个节点思路其他语言版本 19.删除链表的倒数第N个节点 力扣题目链接 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 进阶&#xff1a;你能尝试使用一趟扫描实现吗&#xff1f; 示例 1…
阅读更多...
从malloc到跑路

从malloc到跑路

当我还是一个懵懂无知的少年时&#xff0c;内心也曾升起这样的疑问这内存咋来的捏❓ 有个帅气的小哥哥给我甩了一篇博客&#xff1a;对&#xff0c;就是这篇&#xff0c;看完后总感觉意犹未尽&#xff0c;似乎少了点什么的样子。。。 还是从malloc开始 如果申请的内存小于64B…
阅读更多...
反转链表相关的练习（下）

反转链表相关的练习（下）

目录 一、回文链表 二、 重排链表 三、旋转链表 一、回文链表 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,2,1] 输…
阅读更多...
【Java】Java 链表类详记

【Java】Java 链表类详记

本文仅供学习参考&#xff01; 相关文章链接&#xff1a; https://www.runoob.com/java/java-linkedlist.html https://www.developer.com/java/java-linkedlist-class/ https://www.w3schools.com/java/java_linkedlist.asp Java 中链表的类型 从最基本的角度来说&#xff0c…
阅读更多...
4.8日报

4.8日报

25. ArrayList 和 LinkedList 的区别是什么&#xff1f; 数据结构实现&#xff1a;ArrayList 是动态数组的数据结构实现&#xff0c;而 LinkedList 是双向链表的数据结构实现。 随机访问效率&#xff1a;ArrayList 比 LinkedList 在随机访问的时候效率要高&#xff0c;因为 Lin…
阅读更多...
带头结点的单链表就地逆置

带头结点的单链表就地逆置

本题要求实现一个函数&#xff0c;对带有头结点的单链表进行就地逆置。 函数接口定义&#xff1a; void reverse ( LinkList L ); L是带头结点的单链表的头指针。 裁判测试程序样例&#xff1a; #include <stdio.h> #include <stdlib.h> typedef int ElemType; t…
阅读更多...
链表带环之双指针，入口节点问题

链表带环之双指针，入口节点问题

目录 写在前面的话 一&#xff0c;为什么fast一次走两步&#xff0c;slow一次走一步 1.1结论 1.2走两步证明 第一步&#xff1a; 第二步&#xff1a; 第三步&#xff1a; 1.3走三步&#xff0c;甚至多步证明 1.4带环问题实现方法 二&#xff0c;入环第一个节点 2.1入…
阅读更多...
单链表中二级指针的使用以及单链表的增删查改操作

单链表中二级指针的使用以及单链表的增删查改操作

前言&#xff1a;在链表的构建中,链表的初始化和销毁为何需要使用一个二级指针,而不是只需要传递一个指针就可以了,其问题的关键就在于c语言的参数传递的方式是值传递 那么,这篇文章就来聊一聊在链表的初始化中一级指针的传递和二级指针的区别&#xff0c;并总结给出单链表的C语…
阅读更多...
链表和树的leetcode题

链表和树的leetcode题

基础新手 链表 注意事项 注意保存上下文环境。注意gc&#xff0c;不要有垃圾变量。换头结点注意考虑头 对于链表不要在乎是O(n)还是O(2n) 长短链表互换 习题 K个节点的组内逆序调整 ? leetcode&#xff1a;K 个一组翻转链表 找n函数 逆转函数 第一组是否找齐 之后每组处理…
阅读更多...
[LeetCode]21. 合并两个有序链表

[LeetCode]21. 合并两个有序链表

合并两个有序链表 将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例&#xff1a; 输入&#xff1a;1->2->4, 1->3->4 输出&#xff1a;1->1->2->3->4->4思路 1.先创建一个节点作为链表头&a…
阅读更多...
数据结构《链表》无头单向非循环-动图详解

数据结构《链表》无头单向非循环-动图详解

前言 前面学习了顺序表发现&#xff0c;顺序表虽然好&#xff0c;但也有很多不足的地方&#xff0c;比方说&#xff0c;顺序表是一块连续的物理空间&#xff0c;如果头插或者头删&#xff0c;那么整个数组的数据都要移动。但是链表不一样&#xff0c;链表是通过指针访问或者调…
阅读更多...
初阶数据结构之栈的实现（五）

初阶数据结构之栈的实现（五）

文章目录 &#x1f60f;专栏导读&#x1f916;文章导读&#x1f640;什么是栈&#xff1f;&#x1f640;画图描述 &#x1f633;栈的代码实现及其各类讲解&#x1f633;栈的初始化代码实现及其讲解&#x1f633;栈的初始化 &#x1f633;栈的销毁代码实现及其讲解&#x1f633;…
阅读更多...
二叉树的非递归遍历2

二叉树的非递归遍历2

2023.6.12 三个是统一的遍历思路&#xff0c;只需要修改顺序即可完成遍历 每个节点第一次被添加到堆栈里面&#xff0c;是作为某个节点的左右节点&#xff0c;此时只是在堆栈中记下其处理顺序。 第二次被添加到堆栈里面&#xff0c;是被pop()处理以后&#xff0c;被打上None标记…
阅读更多...
赋值带随机指针的链表

赋值带随机指针的链表

给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节点的值。新节点的 n…
阅读更多...
【每日算法】【160. 相交链表】

【每日算法】【160. 相交链表】

☀️博客主页&#xff1a;CSDN博客主页 &#x1f4a8;本文由 我是小狼君 原创&#xff0c;首发于 CSDN&#x1f4a2; &#x1f525;学习专栏推荐&#xff1a;面试汇总 ❗️游戏框架专栏推荐&#xff1a;游戏实用框架专栏 ⛅️点赞 &#x1f44d; 收藏 ⭐留言 &#x1f4dd;&…
阅读更多...
基础知识学习---链表基础

基础知识学习---链表基础

1、本栏用来记录社招找工作过程中的内容&#xff0c;包括基础知识学习以及面试问题的记录等&#xff0c;以便于后续个人回顾学习&#xff1b; 暂时只有2023年3月份&#xff0c;第一次社招找工作的过程&#xff1b; 2、个人经历&#xff1a; 研究生期间课题是SLAM在无人机上的应…
阅读更多...
LinkedList基本操作

LinkedList基本操作

LinkedList基本操作 LinkedList是Java中的一个双向链表实现&#xff0c;它提供了对链表的基本操作。在LinkedList中&#xff0c;每个元素都被包装在一个节点中&#xff0c;并且每个节点都包含指向前一个节点和后一个节点的引用。这种结构使得在LinkedList中插入、删除和访问元…
阅读更多...
浙江大华后端开发一面面经

浙江大华后端开发一面面经

目录 1.SpringBuffer和SpringBuilder的区别是什么&#xff1f;2.常用的集合类有哪些&#xff1f;HashMap的底层数据结构&#xff1f;推荐一下线程安全的Map&#xff1f;3.TCP和UDP的差异是什么&#xff1f;4.MySQL的左连接和右连接的区别&#xff1f;5.MySQL慢查询如何排查&…
阅读更多...
【每日一题Day234】LC1171从链表中删去总和值为零的连续节点 | 链表模拟 哈希表+前缀和

【每日一题Day234】LC1171从链表中删去总和值为零的连续节点 | 链表模拟 哈希表+前缀和

从链表中删去总和值为零的连续节点【LC1171】 给你一个链表的头节点 head&#xff0c;请你编写代码&#xff0c;反复删去链表中由 总和 值为 0 的连续节点组成的序列&#xff0c;直到不存在这样的序列为止。 删除完毕后&#xff0c;请你返回最终结果链表的头节点。 你可以返回任…
阅读更多...
代码随想录复习 707设计链表 翻转链表，两两交换节点

代码随想录复习 707设计链表 翻转链表，两两交换节点

代码如下 type Node struct { //定义一个节点 &#xff0c;包含一个数据变量一个指针 Val int Next *Node } type MyLinkedList struct { //定义一个链表 &#xff0c;链表里面有一个虚拟头节点&#xff0c;和大小 Dummayhead *Node Size int } func Constructor(…
阅读更多...
数据结构--不带头的单向链表

数据结构--不带头的单向链表

不带头的单向链表 链表的结构注意点&#xff08;贯穿于整个链表的注意事项&#xff09;结点类型的定义申请新结点函数链表的打印链表的尾插链表的头插链表的尾删链表的头删链表的查找和修改在pos之前插入在pos位置删除在pos之后插入&#xff08;通过交换值&#xff0c;达到在po…
阅读更多...
C语言课程设计项目——职工信息管理系统

C语言课程设计项目——职工信息管理系统

名人说：一花独放不是春，百花齐放花满园。——《增广贤文》 作者：Code_流苏(CSDN)（一个喜欢古诗词和编程的Coder😊） 目录 一、整体框架1、整体模块2、系统说明3、数据类型说明二、主要功能函数分析1、注册登录2、录入职工信息3、显示职工信息4、修改职工信息5、删除职工信…
阅读更多...
Flutter 进度条

Flutter 进度条

Flutter 进度条&#xff0c;详细介绍 Flutter 提供了多种类型的进度条&#xff0c;可以用于展示应用程序中的长时间运行任务的进度。进度条可以是线性或圆形&#xff0c;可以显示确定进度或不确定进度&#xff0c;可以按照应用程序的主题进行自定义。 线性进度条 线性进度条…
阅读更多...
143. 重排链表——寻找链表中点 + 链表逆序 + 合并链表

143. 重排链表——寻找链表中点 + 链表逆序 + 合并链表

class Solution { public:void reorderList(ListNode* head) {if(!head || !head -> next || ! head -> next -> next) //长度小于2都不用处理return;ListNode *slow head, *fast head, *sec;while(fast && fast -> next){ //快慢指针找到中间的节…
阅读更多...
顺序表---栈

顺序表---栈

栈 &#xff1a;只能在表尾进行插入(入栈)和删除(出栈)的数据结构(受到限制的线性表&#xff09; 表尾比较特殊&#xff0c;我们一般把这个表尾叫做栈顶&#xff0c;另一端栈底&#xff0c;没有数据节点&#xff0c;则叫做空栈。 特点:后进先出 &#xff08;LIFO&#xff09;…
阅读更多...
＜单链表＞题目练习《数据结构(C语言版)》

＜单链表＞题目练习《数据结构(C语言版)》

目录 题目&#xff1a; 【编程题】 1.单链表的增删查改 2.移除链表元素 OJ链接 3.反转一个单链表。 OJ链接 4.链表的中间结点 5.链表中倒数第k个结点 6.合并两个有序数组 7.CM11 链表分割 8.链表的回文结构。OJ链接 9.相交链表OJ链接 10.环形链表 II 12.复制带随机…
阅读更多...
队列实现（MyArrayQueue、MyLinkedQueue）

队列实现（MyArrayQueue、MyLinkedQueue）

队列 像栈一样&#xff0c;队列也是表。然而&#xff0c;使用队列时插入在一端进行而删除则在另一端进行。 队列模型 队列的基本操作是enqueue&#xff08;入队&#xff09;&#xff0c;它是在表的末端&#xff08;叫作队尾&#xff08;rear&#xff09;&#xff09;插入一个…
阅读更多...
带头双向链表解析

带头双向链表解析

目录 写在前面的话 一&#xff0c;初识带头双向循环链表 1.1无头单向单链表 1.2带头双向循环链表 二&#xff0c;基本功能实现 2.1创建带头双向循环链表 2.2链表的初始化和节点的新增 2.3头插&#xff0c;尾插 2.3.1尾插 代码实现&#xff1a; 2.3.2头插 代码实现&am…
阅读更多...
力扣每日一题：92. 反转链表 II

力扣每日一题：92. 反转链表 II

目录题目&#xff1a;92. 反转链表 II示例1示例2提示解题思路解题代码&#xff08;1&#xff09;暴力法&#xff08;2&#xff09;头插法一次遍历解题感悟题目&#xff1a;92. 反转链表 II 难度&#xff1a; 中等 题目&#xff1a; 给你单链表的头指针 head 和两个整数 left …
阅读更多...
链表合并

链表合并

题目&#xff1a;输入两个单调递增的链表&#xff0c;输出两个链表合成后的链表&#xff0c;当然我们需要合成后的链表满足单调不减规则。 解题&#xff1a;本题可有循环也可由递归实现&#xff0c;代码给出了递归实现的方式。 代码&#xff1a; class Solution { public: …
阅读更多...
剑指offer 合并两个排序的链表 python2实现

剑指offer 合并两个排序的链表 python2实现

# -*- coding:utf-8 -*- # class ListNode: # def __init__(self, x): # self.val x # self.next None class ListNode:def __init__(self, x):self.val xself.next Noneclass Solution:# 返回合并后列表def Merge(self, pHead1, pHead2):merge_next …
阅读更多...
线性表的链式存储

线性表的链式存储

文章目录单链表&#xff08;带头结点&#xff09;单链表&#xff08;不带头结点&#xff09;循环链表单链表&#xff08;带头结点&#xff09; #include<stdio.h> #include<malloc.h>typedef int ElemType; typedef struct Node {ElemType data;struct Node *next…
阅读更多...
经验贴-linux链表-8

经验贴-linux链表-8

看list.h时候&#xff0c;两次遇到不太理解的接口&#xff0c;百度搜到了同一个人的帖子。 感觉这个人不简单啊&#xff0c;进了他的github空间。里面有很多内核API接口的例子 list相关例子&#xff08;双链表、单链表、哈希链表&#xff09;&#xff1a;list路径 内核其他例…
阅读更多...
二叉树相关OJ练习题（1、锯齿形层序遍历 2、二叉搜索子树的最大键值和 3、验证二叉树 4、剑指 Offer II 047. 二叉树剪枝）

二叉树相关OJ练习题（1、锯齿形层序遍历 2、二叉搜索子树的最大键值和 3、验证二叉树 4、剑指 Offer II 047. 二叉树剪枝）

接上次博客&#xff1a;https://mp.csdn.net/mp_blog/creation/editor/130934670​​​​​​ 目录 1、锯齿形层序遍历 2、二叉搜索子树的最大键值和 3、验证二叉树 4、剑指 Offer II 047. 二叉树剪枝 最近临近期末&#xff0c;忙得焦头烂额的…… 天天都是高数、微观经济…
阅读更多...
LWN：将kernel迁移到现代C语言标准！

LWN：将kernel迁移到现代C语言标准！

关注了就能看到更多这么棒的文章哦&#xff5e;Moving the kernel to modern CBy Jonathan CorbetFebruary 24, 2022DeepL assisted translationhttps://lwn.net/Articles/885941/尽管 Linux kernel 项目总体上是在快速发展的&#xff0c;但它还是依赖于一些旧工具。虽然批评者…
阅读更多...
【C/C++数据结构与算法】C语言链表

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

目录 一、单链表 二、双向循环链表 三、判断链表是否带环 四、链表的回文结构判断 五、复制带随机指针的链表 一、单链表 优点&#xff1a;头部增删效率高&#xff0c;动态存储无空间浪费 缺点&#xff1a;尾部增删、遍历效率低&#xff0c;不支持随机访问节点 头结点&…
阅读更多...
ADT: LinkedList 链表

ADT: LinkedList 链表

ADT: LinkedList 链表 文章目录ADT: LinkedList 链表简介参考正文链表结构抽象接口实现要素单向链表双向链表Java 实现链表接口单向链表双向链表结语简介 几乎所有高级语言都提供数组(Array)作为基础数据结构&#xff0c;从存储的角度来看数组就是一个连续的存储单元&#xff…
阅读更多...
[驱动] 隐藏进程 驱动级 摘链 任务管理器看不到

[驱动] 隐藏进程 驱动级 摘链 任务管理器看不到

闲着蛋疼写来玩玩练练手 没啥技术含量 只是个简单的摘链 任务管理器看不到 测试环境 Win7 x86 typedef struct {DWORD_PTR EProcess;UCHAR* ImageName;ULONG ProcessID; }_Process_Info;NTSTATUS HideProcess() {DWORD_PTR CurrentEProcess (DWORD_PTR)PsGetCurrentProce…
阅读更多...
数据结构 单链表总结（c/c++）

数据结构 单链表总结（c/c++）

有关动态内存分配的函数 1、malloc函数 函数原型为void *malloc(unsigned int size); 作用是在内存的动态存储区中分配一个长度为size的连续空间。此函数的值&#xff08;即“返回值”&#xff09;是一个指向分配域起始地址的针&#xff08;类型为void&#xff09;。如果此函数…
阅读更多...
MOOC浙大数据结构课后题记录——PTA数据结构题目集(全)

MOOC浙大数据结构课后题记录——PTA数据结构题目集(全)

目录第一周——最大子列和算法、二分查找01-复杂度1 最大子列和问题 (20分)01-复杂度2 Maximum Subsequence Sum (25分)01-复杂度3 二分查找 (20分)第二周——线性结构02-线性结构1 两个有序链表序列的合并 (15分)02-线性结构2 一元多项式的乘法与加法运算 (20分)02-线性结构3 …
阅读更多...
编程题汇总-反转链表

编程题汇总-反转链表

1)反转单链表 初始化一个prev做为上一个值&#xff0c;cur为当前值&#xff0c;tmp为下一个值。 public class Solution {public ListNode ReverseList(ListNode head) {ListNode cur head;ListNode prev null;while(cur ! null){ListNode tmp cur.next;//记录下一个节点cu…
阅读更多...
一学就会---移除链表相同元素

一学就会---移除链表相同元素

文章目录 题目描述思路一&#xff1a;思路二&#xff1a; 题目描述 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例&#xff1a; 思路一&#xff1a; 要移除链表中值为val的结…
阅读更多...
【链表的分类】

【链表的分类】

链表是一种常用的数据结构&#xff0c;它由一系列节点组成&#xff0c;每个节点包含一个数据元素和指向下一个节点的指针。根据节点的连接方式和节点的性质&#xff0c;链表可以分为多种类型。 单向链表&#xff08;Singly Linked List&#xff09; 单向链表是最基本的链表类…
阅读更多...
116. 填充每个节点的下一个右侧节点指针——广度搜索、队列

116. 填充每个节点的下一个右侧节点指针——广度搜索、队列

方法一 使用队列 class Solution { public:Node* connect(Node* root) {if(!root)return root;queue<Node*> que;Node* ptr root;que.push(root);while(!que.empty()){int size que.size();Node *left que.front(); //先获取每层最左侧的节点if(left -> left) …
阅读更多...
链表----栈

链表----栈

链栈&#xff1a; 单链表的基础上实现即可 用单链表的头插和头删代替表尾进行插入和删除 push(头插&#xff09; pop&#xff08;头删&#xff09; 入栈操作&#xff08;相当于单链表的头插函数&#xff09; bool Push(PLStack ps,ELEM_TYPE val) {assert(ps ! NULL);…
阅读更多...
【链表part02】| 24.两两交换链表中的节点、19.删除链表的倒数第N个节点、02.07.链表相交、142.环形链表

【链表part02】| 24.两两交换链表中的节点、19.删除链表的倒数第N个节点、02.07.链表相交、142.环形链表

目录 ✿LeetCode24.两两交换链表中的节点❀ ✿LeetCode19.删除链表的倒数第N个节点❀ ✿LeetCode面试题 02.07. 链表相交❀ ✿LeetCode142.环形链表||❀ ✿LeetCode24.两两交换链表中的节点❀ 链接&#xff1a;24.两两交换链表中的节点 给你一个链表&#xff0c;两两交换其…
阅读更多...
判断单链表是否存在回文

判断单链表是否存在回文

回文即就是 “123454321”&#xff0c;“abcba"满足这样的数据链表&#xff0c;需要两个指针&#xff0c;一个指向头&#xff0c;一个指向尾,一个向后走&#xff0c;一个向前走&#xff0c;判断数据是否相等。但是单链表无法从后节点指向前节点&#xff0c;因此将单链表中…
阅读更多...
线性表---循环链表

线性表---循环链表

循环链表&#xff1a;循环链表的特点是可以通过尾结点的指向找到头结点的地址&#xff1b; 结构体设计与单链表相同&#xff1a; typedef int ELEM_TYPE;typedef struct Clist {ELEM_TYPE data; //数据域 struct Clist* next; //指针域 } Clist, * PClist;主要功…
阅读更多...
leetcode每日一道（4）：在O(n log n)的时间内使用常数级空间复杂度对链表进行排序

leetcode每日一道（4）：在O(n log n)的时间内使用常数级空间复杂度对链表进行排序

题目描述 在O(n log n)的时间内使用常数级空间复杂度对链表进行排序。 Sort a linked list in O(n log n) time using constant space complexity. 思路 既然是在常数的空间复杂度,即o(1)的空间复杂度内&#xff0c;那么递归是不能考虑了&#xff0c;这种情况下&#xff0c;只…
阅读更多...
图解LeetCode——24. 两两交换链表中的节点

图解LeetCode——24. 两两交换链表中的节点

一、题目 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 二、示例 2.1> 示例 1&#xff1a; 【输入】head [1,2,3,4] 【…
阅读更多...
java原生LinkedList详解

java原生LinkedList详解

java原生LinkedList详解 实际上在IDEA,JDK环境下的LinkList底层就是一个双向链表&#xff0c;由于链表没有将元素存储在连续的空间中&#xff0c;元素存储在单独的节点中&#xff0c;然后通过引用将节点连接起来了&#xff0c;因此在在任意位置插入或者删除元素时&#xff0c;…
阅读更多...
集合框架底层数据结构

集合框架底层数据结构

Collection 1. List Arraylist : Object 数组 Vector : Object 数组 LinkedList : 双向循环链表 2.Set HashSet (无序&#xff0c;唯一) : 基于HashMap 实现的&#xff0c;底层采用HashMap 来保存元素 LinkedHashSet : LinkedHashSet 继承于 HashSet , 并且其内部是通过Linked…
阅读更多...
数据结构——实现单向链表

数据结构——实现单向链表

文章目录 :cow:前言:banana:单链表与顺序表的对比:orange:单链表的初始操作及结构体:watermelon:申请一个节点:carrot:打印:strawberry:销毁:apple:尾插:pear:尾删:grapes:头插:peach:头删:pineapple:数据的查找:lemon:数据的修改:tomato:在pos位置之后插入节点:potato:在pos位…
阅读更多...
C语言数据结构——循环链表

C语言数据结构——循环链表

如果人生会有很长,愿有你的荣耀永不散场。——《全职高手》 一 . 循环单链表 循环单链表是单链表的另一种形式&#xff0c;其结构特点是&#xff0c;链表中最后一个结点的指针域不再是结束标记&#xff0c;而是指向整个链表的第一个结点&#xff0c;从而使链表形成一个环。 和单…
阅读更多...
LeetCode19:删除链表的倒数第N个节点

LeetCode19:删除链表的倒数第N个节点

/*给定一个链表&#xff0c;删除链表的倒数第 n 个节点&#xff0c;并且返回链表的头结点。示例&#xff1a;给定一个链表: 1->2->3->4->5, 和 n 2.当删除了倒数第二个节点后&#xff0c;链表变为 1->2->3->5. */ class Solution { public:ListNode* rem…
阅读更多...
12. AbstractQueuedSynchronizer之AQS

12. AbstractQueuedSynchronizer之AQS

12.1 前置知识 ● 公平锁和非公平锁 ○ 公平锁&#xff1a;锁被释放以后&#xff0c;先申请的线程先得到锁。性能较差一些&#xff0c;因为公平锁为了保证时间上的绝对顺序&#xff0c;上下文切换更频繁 ○ 非公平锁&#xff1a;锁被释放以后&#xff0c;后申请的线程可能会先获…
阅读更多...
LeetCode203：删除链表值为val的元素

LeetCode203：删除链表值为val的元素

/*删除链表中等于给定值 val 的所有节点。 示例: 输入: 1->2->6->3->4->5->6, val 6 输出: 1->2->3->4->5*/ /* 方法二&#xff1a;为了防止要删除的节点为头结点而使得我们考虑不周的情况&#xff0c;我们可以给这个链表head加一个虚拟的头结点…
阅读更多...
LeetCode328：奇偶链表

LeetCode328：奇偶链表

/* 给定一个单链表&#xff0c;把所有的奇数节点和偶数节点分别排在一起。请注意&#xff0c;这里的奇数节点和偶数节点指的是节点编号的奇偶性&#xff0c;而不是节点的值的奇偶性。请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)&#xff0c;时间复杂度应为 O(nodes…
阅读更多...
LeetCode86：分隔链表

LeetCode86：分隔链表

/*给定一个链表和一个特定值 x&#xff0c;对链表进行分隔&#xff0c;使得所有小于 x 的节点都在大于或等于 x 的节点之前。你应当保留两个分区中每个节点的初始相对位置。示例:输入: head 1->4->3->2->5->2, x 3 输出: 1->2->2->4->3->5 */ …
阅读更多...
[链表OJ题 8] 用栈实现队列，没想到你小子的基础这么好，这么快就做对了

[链表OJ题 8] 用栈实现队列，没想到你小子的基础这么好，这么快就做对了

目录 题目来源&#xff1a; 代码实现&#xff1a; 思路分析&#xff1a; 实现过程&#xff1a; 题目来源&#xff1a; 力扣 - 232.用栈实现队列 题目描述&#xff1a; 代码实现&#xff1a; 我们这里的栈已经写好了&#xff0c;如果对栈还不是很懂的可以看看这篇文章&am…
阅读更多...
2.链表的实现：带哨兵

2.链表的实现：带哨兵

1.带哨兵的单链表的定义 /*** 单向链表----带哨兵*/ public class SinglyLinked {/*** 节点类* 数据域和地址域*/private static class Node {int value; //值Node next; // 指向下一个节点public Node() {}public Node(int value, Node next) {this.value value;this.next …
阅读更多...
LeetCode —— 206. 反转链表

LeetCode —— 206. 反转链表

LeetCode —— 206. 反转链表 一、题目描述&#xff1a; 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1] 示例 2&#xff1a; 输入&#xff1a;head …
阅读更多...
leetcode_删除排序链表中的重复元素

leetcode_删除排序链表中的重复元素

存在一个按升序排列的链表&#xff0c;给你这个链表的头节点 head &#xff0c;请你删除所有重复的元素&#xff0c;使每个元素只出现一次 。 返回同样按升序排列的结果链表。 输入&#xff1a;head [1,1,2] 输出&#xff1a;[1,2]输入&#xff1a;head [1,1,2,3,3] 输出&am…
阅读更多...
【leetcode】合并两个有序表05.11

【leetcode】合并两个有序表05.11

接着昨天的帖子写了有序表的合并问题&#xff0c;顺便温习了一下头插法和尾插法。 头插法 链表结构 struct listnode{int val;//值listnode *next;//下个元素指针listnode(int r_val,listnode *r_nextnullpptr){val r_val;next r_next;} }具体代码 头插法顾名思义&#xf…
阅读更多...
剑指offer 合并两个有序的单链表 代码和解释

剑指offer 合并两个有序的单链表 代码和解释

题目 输入两个单调递增的链表&#xff0c;输出两个链表合成后的链表&#xff0c;当然我们需要合成后的链表满足单调不减规则。 代码1 新建一个链表&#xff0c;将排序后的结果放在新链表中。 /* struct ListNode {int val;struct ListNode *next;ListNode(int x) :val(x), …
阅读更多...
【leetcode刷题】剑指offer基础版（完结）

【leetcode刷题】剑指offer基础版（完结）

leetcode刷题笔记—剑指offer 剑指 Offer 05. 替换空格 class Solution { public:string replaceSpace(string s) {int len s.size();string g;for(int i 0; i < len; i){if(s[i] ){g "%20";continue;}g s[i];}return g;} };剑指 Offer 58 - II. 左旋转字…
阅读更多...
原地逆转链表的多种方案 |数据结构

原地逆转链表的多种方案 |数据结构

//原地逆转链表的多种方案 #include<stdio.h> #include<time.h> #include<stdlib.h> #include<conio.h>//用于链表个数 #define Max 20 typedef struct node {int data;struct node* next; }linklist;//菜单显示 void Menu() {printf("■■■■■…
阅读更多...
代码随想录算法训练营15期 Day 3 | 203.移除链表元素 、707.设计链表 、206.反转链表

代码随想录算法训练营15期 Day 3 | 203.移除链表元素 、707.设计链表 、206.反转链表

今日任务 链表理论基础 203.移除链表元素 707.设计链表 206.反转链表 链表理论基础 链表是一种通过指针串联在一起的线性结构&#xff0c;每一个节点由两部分组成&#xff0c;一个是数据域一个是指针域&#xff08;存放指向下一个节点的指针&#xff09;&#xff0c;最后…
阅读更多...
数据结构与算法之队列

数据结构与算法之队列

队列 队列概念队列的操作队列概念 队列是一种线性数据结构，它是一种先进先出（FIFO）的数据结构。队列可以看作是一种特殊的线性表，它只允许在队列的一端进行插入操作，并且只允许在队列的另一端进行删除操作。 队列有两个基本操作：入队和出队。入队操作将元素插入到队列的…
阅读更多...
leetcode--删除链表的倒数第N个节点（java）

leetcode--删除链表的倒数第N个节点（java）

删除链表的倒数第N个节点 Leetcode 19 题解题思路代码演示链表专题 Leetcode 19 题 19 删除链表的倒数第N个节点 -可以测试 题目描述&#xff1a; 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点 示例1&#xff1a; 输入&#xff1a;he…
阅读更多...
面试题24：反转链表

面试题24：反转链表

面试题24&#xff1a;反转链表 定义一个函数&#xff0c;输入一个链表的头节点&#xff0c;反转该链表并输出反转后链表的头节点。 class Solution {// 三个指针&#xff1b; public:ListNode* reverseList(ListNode* head) {ListNode *cur head,*pre nullptr;while(cur ! …
阅读更多...
C++常用STL容器--list

C++常用STL容器--list

C常用STL容器--list list基本概念list构造函数list赋值、交换list大小操作list插入、删除list数据获取list反转、排序 list基本概念 功能&#xff1a; 将数据进行链式存储 链表(list) 是一种物理存储单元上非连续的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针…
阅读更多...
每日算法（第十期）

每日算法（第十期）

2023年5月26日 先来回顾一下昨天的面试题及答案&#xff1a; 「合并两个有序链表」&#xff08;Merge Two Sorted Lists&#xff09;。 题目描述&#xff1a;将两个升序链表合并为一个新的升序链表并返回。新链表应该通过拼接给定的两个链表的节点组成。 例如&#xff0c;给定链…
阅读更多...
1. 如果将学生的百分制成绩分为5个等级：0-59分为不及格（E），60-69分为及格（D），70-79分为一般（C），80-89分为良好（B），90-100分为优秀（A）。在实际中，学生的成绩在五个

1. 如果将学生的百分制成绩分为5个等级：0-59分为不及格（E），60-69分为及格（D），70-79分为一般（C），80-89分为良好（B），90-100分为优秀（A）。在实际中，学生的成绩在五个

## 树的应用题&#xff1a; 数据结构分为线性结构和非线性结构两大类。树和二叉树是非线性结构中非常重要的一员&#xff0c;它适合描述具有层次结构的数据。 如果将学生的百分制成绩分为5个等级&#xff1a;0-59分为不及格&#xff08;E&#xff09;&#xff0c;60-69分为及格…
阅读更多...
删除链表任意一个节点（不包括尾结点）

删除链表任意一个节点（不包括尾结点）

删除链表任意一个节点&#xff08;不包括尾结点&#xff09; 已知条件&#xff1a;要删除的节点的地址 如何实现&#xff1a; 由于链表的每个节点只保存了下一个节点的地址&#xff0c;如果直接将其删除&#xff0c;那么要删除的节点后面的数据将会直接丢失&#xff0c;因为…
阅读更多...
判断两个单链表是否相交，若相交并找出相交的第一个点

判断两个单链表是否相交，若相交并找出相交的第一个点

链表的正确相交情况如下&#xff1a; 判断两个链表是否相交 //确定两个单链表是否相交 (用两个指针跑到两个单链表的尾结点&#xff0c;然后判断是否是同一个尾结点) bool Intersect(PNode plist1, PNode plist2) {//assertPNode p1 plist1;PNode p2 plist2;for(p1; p1->…
阅读更多...
线性表--双向链表

线性表--双向链表

双向链表:相比于单链表&#xff0c;双向链表有两个指针域&#xff0c;既可以保存右边的节点地址(后继)&#xff0c;也可以保存左边的节点地址(前驱)。如果指针域指向一个不存在的节点&#xff0c;则将其指针置为NULL。 。 如果一个空的双向链表&#xff0c;则它的next和prior同…
阅读更多...
代码随想录二刷 day04 | 链表之 24两两交换链表中的节点 19删除链表的倒数第N个节点 面试题 02.07. 链表相交 142.环形链表II

代码随想录二刷 day04 | 链表之 24两两交换链表中的节点 19删除链表的倒数第N个节点 面试题 02.07. 链表相交 142.环形链表II

24. 两两交换链表中的节点 题目链接 解题思路&#xff1a; 先将一些可能会改变的节点保存一下&#xff0c;然后再按照三个步骤就行修改 注意 要使用改变以后节点的指针&#xff08;这个地方一刷的时候没注意到&#xff0c;稀里糊涂的过去了&#xff09; 代码如下&#xff1a;…
阅读更多...
五十行代码教你写一个简单的内存池（二级指针的应用）

五十行代码教你写一个简单的内存池（二级指针的应用）

固定大小内存的内存池实现 该内存池是一个很简单的内存池&#xff0c;只能申请固定大小的内存&#xff0c;仅供学习 要点&#xff1a; 构造隐式链表二级指针 存储结构 typedef struct mempool_s{int block_size; // 每一块的大虚哎int free_count; // 剩余有多少块是可以…
阅读更多...
leetcode -- 23 mark

leetcode -- 23 mark

文章目录23.合并k个有序链表&#xff08;hard&#xff09;题目描述解题方法23.合并k个有序链表&#xff08;hard&#xff09; 应该属于hard里面的easy题吧 题目描述 合并 k 个排序链表&#xff0c;返回合并后的排序链表。请分析和描述算法的复杂度。 示例: 输入: [ 1->4-…
阅读更多...
yallist 源码解析(Npm library)

yallist 源码解析(Npm library)

yallist 源码解析(Npm library) 文章目录yallist 源码解析(Npm library)正文0. 基本信息1. 源码解析1.0 类型 & 接口1.1 类型定义1.2 增&#xff1a;push、pushNode、unshift、unshiftNode1.3 删&#xff1a;pop、shift、splice1.4 查&#xff1a;get、getReverse、toArray…
阅读更多...
数据结构与算法 | 双链表的基本操作

数据结构与算法 | 双链表的基本操作

1024G 嵌入式资源大放送&#xff01;包括但不限于C/C、单片机、Linux等。关注微信公众号【嵌入式大杂烩】&#xff0c;回复1024&#xff0c;即可免费获取&#xff01; 什么是双链表&#xff1f; 双链表是在操作系统中常用的数据结构&#xff0c;它的每个数据结点中都有两个指针…
阅读更多...
力扣之复杂链表的复制

力扣之复杂链表的复制

1.复制一个复杂链表。在复杂链表中&#xff0c;每个节点除了有一个 next 指针指向下一个节点&#xff0c;还有一个 random 指针指向链表中的任意节点或者 null。 代码展示&#xff1a; class Solution {public Node copyRandomList(Node head) {if(head null){return head;}N…
阅读更多...
力扣之旋转链表

力扣之旋转链表

1.给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置 例1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], k 2 输出&#xff1a;[4,5,1,2,3] 例2&#xff1a; 输入&#xff1a;head [0,1,2], k 4 输出&#xff1a;[2,0,1] c…
阅读更多...
LeetCode之删除链表的倒数第k个节点

LeetCode之删除链表的倒数第k个节点

给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点 首先我们可以在这里定义新的傀儡节点。然后定义一个快指针fast&#xff0c;一个慢指针slow&#xff0c;让两个指针都指向傀儡节点的位置。再让快指针走n步&#xff0c;此时再和slow一起走&…
阅读更多...
【C语言进阶】从入门到入土（自定义类型详解 — 结构体）

【C语言进阶】从入门到入土（自定义类型详解 — 结构体）

前言&#xff1a; 我们知道&#xff0c;为了提高程序的可读性&#xff0c;C语言里支持用户自定义类型&#xff0c;或者叫改造类型。然而自定义类型最常见的就是结构体、枚举和联合体这三种类型。所以我们来详细理解一下自定义类型。本篇先介绍结构体。 自定义类型详解:一.结构体…
阅读更多...
Redis学习之dict字典源码分析

Redis学习之dict字典源码分析

字典&#xff0c;又叫映射&#xff0c;是一种用于保存键值对的抽象数据结构 划重点&#xff1a;抽象数据结构 Redisd字典使用哈希表作为底层实现&#xff0c;一个哈希表里面可以有多个哈希表结点&#xff0c;而每个哈希表结点就保存了字典中的一个键值对 一.哈希表结构 // dict…
阅读更多...
数据结构实验报告——约瑟夫问题（循环链表）

数据结构实验报告——约瑟夫问题（循环链表）

1.实验目的 &#xff08;1&#xff09;熟悉上机环境&#xff0c;掌握上机操作方法和步骤&#xff1b; &#xff08;2&#xff09;掌握线性表的特点、逻辑结构和物理实现&#xff1b; &#xff08;3&#xff09;掌握单向链表的建立、插入、删除等基本操作的实现&#xff1b; …
阅读更多...
《程序设计基础》 第十一章 指针进阶 6-13 链表逆置 (20 分)

《程序设计基础》 第十一章 指针进阶 6-13 链表逆置 (20 分)

本题要求实现一个函数&#xff0c;将给定单向链表逆置&#xff0c;即表头置为表尾&#xff0c;表尾置为表头。链表结点定义如下&#xff1a; struct ListNode {int data;struct ListNode *next; };函数接口定义&#xff1a; struct ListNode *reverse( struct ListNode *head…
阅读更多...
GetElem单链表实现

GetElem单链表实现

Status GetElem L(LinkList, int i, ElemType &e) {p L->next;j 1;while(p&&j<i){p p->next;j;}if(!p||j > i) return ERROR;e p->data;return OK; }
阅读更多...
java-玩转链表-1

java-玩转链表-1

之前的文章中介绍了线性表中的顺序表 JAVA初阶必学-线性表-顺序表 这几节内容中我们来认识线性表中的链表&#xff0c;并通过LeetCode中的例题来彻底掌握链表。 废话不说&#xff0c;进入正题 链表 目录 定义&#xff1a; 基础操作 遍历打印 1&#xff0c;头插 2, 头…
阅读更多...
力扣25. K 个一组翻转链表

力扣25. K 个一组翻转链表

class Solution { public:ListNode* reverseKGroup(ListNode* head, int k) {if (head nullptr) return head;auto tail head;for(int i 0; i < k; i) //先让tail移动k个节点{if(tail nullptr) return head; //不足k个时tail tail->next;}ListNode* cur hea…
阅读更多...
《程序设计基础》 第十一章 指针进阶 6-8 学生成绩链表处理 (20 分)

《程序设计基础》 第十一章 指针进阶 6-8 学生成绩链表处理 (20 分)

本题要求实现两个函数&#xff0c;一个将输入的学生成绩组织成单向链表&#xff1b;另一个将成绩低于某分数线的学生结点从链表中删除。 函数接口定义&#xff1a; struct stud_node *createlist(); struct stud_node *deletelist( struct stud_node *head, int min_score );…
阅读更多...
《程序设计基础》 第十一章 指针进阶 6-7 建立学生信息链表 (20 分)

《程序设计基础》 第十一章 指针进阶 6-7 建立学生信息链表 (20 分)

本题要求实现一个将输入的学生成绩组织成单向链表的简单函数。 函数接口定义&#xff1a; void input(); 该函数利用scanf从输入中获取学生的信息&#xff0c;并将其组织成单向链表。链表节点结构定义如下&#xff1a; struct stud_node {int num; /*学号…
阅读更多...
Leetcode234.回文链表（快慢指针+翻转，C++）

Leetcode234.回文链表（快慢指针+翻转，C++）

题目描述&#xff1a;给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 知识点&#xff1a;快慢指针翻转 思路&#xff1a;先找到链表的中间结点&#xff0c;找到中间结点之后&…
阅读更多...
【2022---计算机考研】数据结构之基础算法背诵版

【2022---计算机考研】数据结构之基础算法背诵版

文章目录一、线性表1. 逆转顺序表中的所有元素2. 删除线性链表中数据域为 item 的所有结点3. 逆转线性链表4. 复制线性链表&#xff08;递归&#xff09;5. 将两个按值有序排列的非空线性链表合并为一个按值有序的线性链表二、树1. 二叉树的先序遍历&#xff08;递归算法&#…
阅读更多...
C++实现LRU（最久未使用）缓存算法

C++实现LRU（最久未使用）缓存算法

LRU缓存算法也叫LRU页面置换算法&#xff0c;是一种经典常用的页面置换算法&#xff0c;本文将用C实现一个LRU算法。 LRU算法实现并不难&#xff0c;但是要高效地实现却是有难度的&#xff0c;要想高效实现其中的插入、删除、查找&#xff0c;第一想法就是红黑树&#xff0c;但…
阅读更多...
LeetCode24:两两交换链表中的节点

LeetCode24:两两交换链表中的节点

/*给定一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后的链表。你不能只是单纯的改变节点内部的值&#xff0c;而是需要实际的进行节点交换。示例:给定 1->2->3->4, 你应该返回 2->1->4->3. */ /* 先声明一个虚拟节点dummyhead指向头结…
阅读更多...
LeetCode83:删除排序链表中的重复元素

LeetCode83:删除排序链表中的重复元素

/*给定一个排序链表&#xff0c;删除所有重复的元素&#xff0c;使得每个元素只出现一次。示例 1:输入: 1->1->2 输出: 1->2 示例 2:输入: 1->1->2->3->3 输出: 1->2->3 */class Solution { public:ListNode* deleteDuplicates(ListNode* head) {if…
阅读更多...
LeetCode92：反转链表II

LeetCode92：反转链表II

/*反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。说明: 1 ≤ m ≤ n ≤ 链表长度。示例:输入: 1->2->3->4->5->NULL, m 2, n 4 输出: 1->4->3->2->5->NULL*//**/ class Solution { public:ListNode* reverseBetween(ListNode* head, int…
阅读更多...
线性表(2)双向链表

线性表(2)双向链表

链表 1.前言 上一篇博客说了普通线性表&#xff0c;我们发现了该表的缺陷是在插入数据或添加数据的时候会大量移动数组元素&#xff0c;从而造成时间复杂度的提升&#xff0c; 为了解决这个问题&#xff0c;需要使用链表&#xff0c;链表是相对于数组更加先进的一种数据结构…
阅读更多...
leetcode之链表

leetcode之链表

理论基础 单链表、双链表、循环链表链表的存储方式&#xff1a;链表的节点在内存中是分散存储的&#xff0c;通过指针连在一起。如何进行增删改查 一些技巧&#xff1a;虚拟头结点 反转链表 删除倒数第N个节点&#xff1a;双指针法&#xff0c;两个指针中间隔N 链表相交&am…
阅读更多...
用链表实现学生信息系统

用链表实现学生信息系统

#include<stdio.h> #include<string.h> typedef struct student {int num;char name[10];float score[3]; }DataType; typedef struct LNode {DataType data;struct LNode *next; }LNode,*LinkList; //建立带头链表-头插法 1 LNode* Creat_LinkList1() {LinkList …
阅读更多...
什么是链表（C语言）（2020.11）

什么是链表（C语言）（2020.11）

前言 之前写了一篇博客什么是链表&#xff08;Java&#xff09;是用Java解释的链表&#xff0c;收获了对我个人而言还算不错的阅读和收藏。但还有一些解释的不太清晰的地方&#xff0c;这几天在学C&#xff0c;感觉用C来解释一些问题更清晰一些&#xff0c;另外就是对上一篇中…
阅读更多...
Leetcode系列----「Remove Duplicates from Sorted List」

Leetcode系列----「Remove Duplicates from Sorted List」

题解&#xff1a; public class RemoveDuplicatesFromSortedList {/*** 解法一&#xff1a;逻辑解法&#xff0c;直接把链表当成数组一样来处理就可以了* param head* return*/public ListNode deleteDuplicates(ListNode head) {if (head null) return head;int pre head.va…
阅读更多...
面试题6：从头到尾打印链表

面试题6：从头到尾打印链表

面试题6&#xff1a;从头到尾打印链表 输入一个链表的头节点&#xff0c;从尾到头反过来返回每个节点的值&#xff08;用数组返回&#xff09;。 // 栈方法 class Solution { public:vector<int> reversePrint(ListNode* head) {stack<int> nodes; // stack:堆ve…
阅读更多...
数据结构--队列的链表实现

数据结构--队列的链表实现

数据结构–队列的链表实现 队列的链表实现代码定义 typedef struct LinkNode {ElemType data;struct LinkNode* next; }LinkNode;typedef struct {LinkNode *front, *rear; }LinkQueue;带头结点 初始化 void InitQueue(LinkQueue &Q) {Q.front Q.rear (LinkNode*)malloc…
阅读更多...
C# 相交链表

C# 相交链表

160 相交链表 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c;…
阅读更多...
【备战秋招】每日一题:2023.05.24-华为OD机试(第一题)-连续内存合并

【备战秋招】每日一题:2023.05.24-华为OD机试(第一题)-连续内存合并

为了更好的阅读体检&#xff0c;可以查看我的算法学习博客 在线评测链接:P1300 题目描述 塔子哥最近对在开发一个简单的操作系统&#xff0c;今天他的任务是为操作系统的动态内存管理模块实现内存块的合并功能。 介绍一下操作系统的内存管理模块:操作系统的动态内存管理模块…
阅读更多...
数据结构--队列的基本概念

数据结构--队列的基本概念

数据结构–队列的基本概念 队列的定义 队列其实是一种受限制的线性表 队列(Queue)&#xff1a;是 只允许在一端进行插入或删除操作 \color{red}只允许在一端进行插入或删除操作 只允许在一端进行插入或删除操作的线性表 重要术语: 队头、队尾、空队列 队列的特点: 先进先出 \…
阅读更多...
Leetcode-每日一题【206.反转链表】

Leetcode-每日一题【206.反转链表】

题目 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5]输出&#xff1a;[5,4,3,2,1] 示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&#xff1a;[2,1] 示例 3&#xff1a; 输…
阅读更多...
HOT34-合并K个升序链表

HOT34-合并K个升序链表

leetcode原题链接&#xff1a;合并K个升序链表 题目描述 给你一个链表数组&#xff0c;每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 示例 1&#xff1a; 输入&#xff1a;lists [[1,4,5],[1,3,4],[2,6]] 输出&#xff1a…
阅读更多...
LinkedList(极客时间)

LinkedList(极客时间)

上次说了链表相关的基础知识。这次总结一些写链表代码的技巧&#xff0c;如果能熟练掌握这些技巧&#xff0c;就可以应对大多数链表的问题。 技巧一&#xff1a;理解引用的含义 事实上&#xff0c;看懂链表的结构并不是很难&#xff0c;但是一旦把它和面向对象的概念套在一起…
阅读更多...
【Java实现】链表的回文结构

【Java实现】链表的回文结构

&#x1f388;目录&#x1f388; 问题描述&#x1f512; 输入输出案例&#xff1a; 解题分析&#x1f511; 第一步实现&#xff1a; 第二步实现&#xff1a; 第三步实现&#xff1a; 代码实现&#x1f513; 题目入口&#x1f4cc;:链表的回文结构 问题描述 对于一个链表…
阅读更多...
【Java实现】链表分割

【Java实现】链表分割

&#x1f388;目录&#x1f388; 问题描述&#x1f512; 解题分析&#x1f511; 代码实现&#x1f513; 题目入口&#x1f4cc;&#xff1a;链表分割 问题描述 现有一链表的头指针 ListNode* pHead&#xff0c;给一定值x&#xff0c;编写一段代码将所有小于x的结点排在其余结…
阅读更多...
【Java实现】链表中倒数第k个结点

【Java实现】链表中倒数第k个结点

&#x1f388;目录&#x1f388; 问题描述&#x1f512; 输入输出实例&#xff1a; 解题分析&#x1f511; 代码实现&#x1f513; 题目入口&#x1f4cc;&#xff1a;链表中倒数第k个结点 问题描述 输入一个链表&#xff0c;输出该链表中倒数第k个结点。 输入输出示例&am…
阅读更多...
数据结构 顺序表总结（c++）

数据结构 顺序表总结（c++）

#include <bits/stdc.h> using namespace std; #define MAXSIZE 10000 typedef int Elemtype; typedef struct {Elemtype *elem;int length; } Sqlist; Elemtype initlist(Sqlist &l); //创建一个空的顺序表 Elemtype creatlist(Sqlist &l)…
阅读更多...
LeetCode刷题笔记 Java 腾讯 排序搜索 排序链表

LeetCode刷题笔记 Java 腾讯 排序搜索 排序链表

给你链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 自底向上归并 1.获取当前链表长度 2.归并 首先子串长度分组 1、2、4、8、16、32.. 选两个子串&#xff1a;选完一个子串记得断开它和后面的连接&#xff0c;pre.nextmerged 3.有序链表合并算…
阅读更多...
LeetCode刷题笔记 Java 腾讯 数组字符串 旋转链表

LeetCode刷题笔记 Java 腾讯 数组字符串 旋转链表

给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 1.获取数组长度 2.连接成环 3.适当位置切断 class Solution {public ListNode rotateRight(ListNode head, int k) {if(k0||headnull||head.nextnull){return head;}ListNode…
阅读更多...
LeetCode刷题笔记 Java 腾讯 链表 两数相加

LeetCode刷题笔记 Java 腾讯 链表 两数相加

给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0c;这两个数都不会以 0 …
阅读更多...
链表-反转链表 C++

链表-反转链表 C++

学习链接&#xff1a;https://blog.csdn.net/FX677588/article/details/72357389 题目&#xff1a;输入一个链表&#xff0c;反转链表后&#xff0c;输出链表的所有元素。 Method1:非递归、双指针 class Solution { public:ListNode* ReverseList(ListNode* pHead) {if( pHea…
阅读更多...
Golang-链表

Golang-链表

一.链表的实现 1.1 代码 package Algorithmimport (_ "container/list""errors""fmt" ) type Node struct {data interface{}pre *Nodenext *Node }type List struct {head *Nodetail *Nodelength uint64 }func GetList() *List{list : &…
阅读更多...
数据结构与算法：链表

数据结构与算法：链表

题目来自LeetBook 系列&#xff1a;《链表》——https://leetcode-cn.com/leetbook/read/linked-list/x6ybqh/ 文章目录单链表No.707 设计链表双指针技巧No.141 环形链表No.142 环形链表2No.160 相交链表No.19 删除链表倒数第N个结点经典问题No.206 反转链表No.203 移除链表元素…
阅读更多...
算法篇：链表之反转链表

算法篇：链表之反转链表

算法&#xff1a;反转链表的基本操作可以拆分成下面四步&#xff1a;1.保存前序节点&#xff0c; 2.保存后续节点&#xff0c; 3.当前节点指向前序节点 4.偏移前序节点和当前节点其他的变形题目&#xff0c;主要围绕两个关键点&#xff1a;1.反转之后的前序节点的处理 2.反转之…
阅读更多...
算法篇：链表之倒数第k个节点

算法篇：链表之倒数第k个节点

算法&#xff1a;该类型的题目&#xff0c;核心点在于如何找到倒数第k个节点的位置&#xff0c;典型的操作办法是&#xff0c;双指针的方法。第一个指针先偏移k个位置&#xff0c;第二个指针才开始执行 然后两个指针同时往后移动&#xff0c;第一个指针到链表尾部&#xff0c;第…
阅读更多...
C贪吃蛇代码详解(ncurse)

C贪吃蛇代码详解(ncurse)

#include<curses.h> //使用 ncurses 必须调用它的函数库 #include<stdlib.h> #include<time.h>#define UP 1 //宏定义 UP 与 1 等效 #define DOWN -1 #define LEFT 2 #define RIGHT -2 struct Snake //结构体 {int hang;int lie;struct Snake…
阅读更多...
C/C++中链表举例

C/C++中链表举例

1.头插法创建单链表。 #include <iostream> using namespace std; typedef int elemtype; //《头 插 法》创建单链表 struct lnode { //lnode为单链表结点类型elemtype data; //数据域lnode* next; //指针域&#xff1a;指向后继结点 }; typedef lnode* …
阅读更多...
Leetcode160.相交链表（哈希集合/双指针，C++）

Leetcode160.相交链表（哈希集合/双指针，C++）

*此题借鉴Leetcode官方题解 题目描述&#xff1a; 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 思路1&#xff1a;哈希集…
阅读更多...
牛客 走出迷宫＜每日一题分享＞（bfs基础题目）

牛客 走出迷宫＜每日一题分享＞（bfs基础题目）

题目链接&#xff1a;登录—专业IT笔试面试备考平台_牛客网 题目 代码详解&#xff1a; #include<iostream> using namespace std; #include<queue> #include<string.h> int m, n, endx, endy; char map[503][503];//存储迷宫 struct fx {int x;int y; }ar…
阅读更多...
56.删除链表中重复的节点

56.删除链表中重复的节点

文章目录1.题目2.思路3.代码1.题目 在一个排序的链表中&#xff0c;存在重复的结点&#xff0c;请删除该链表中重复的结点&#xff0c;重复的结点不保留&#xff0c;返回链表头指针。 例如&#xff0c;链表1->2->3->3->4->4->5 处理后为 1->2->5。 2…
阅读更多...
java - 23. 合并K个升序链表 - 优先级队列PriorityQueue

java - 23. 合并K个升序链表 - 优先级队列PriorityQueue

一 思路 1 和合并2个升序链表类似&#xff0c;先对比链表头的k个数&#xff0c;这里用优先级队列(二叉树堆)来保存。 2 每次拿出二叉树堆中的最小值(即k个数中的最小值)&#xff0c;然后把当前链表的下一个节点入堆&#xff0c;始终保证是k个链表头&#xff0c;依次取最小值&am…
阅读更多...
java - 142. 环形链表 II - 通俗易懂题解

java - 142. 环形链表 II - 通俗易懂题解

1 思路 1、 首先设置快慢指针&#xff0c;慢指针走一步&#xff0c;快指针走两步2、 两者如果相遇说明有环&#xff0c;假设慢指针走了k步&#xff0c;则快指针走了2k步。慢指针从头走到相遇点为k&#xff0c;那么从相遇点再走k步就会再次走到相遇点&#xff0c;也就是快指针的…
阅读更多...
LinkedList（链表列表）

LinkedList（链表列表）

LinkedList主要有两种形式&#xff1a;单向链表和双向链表&#xff08;一般会用 双向链表&#xff09; 根据&#xff21;&#xff30;&#xff29;&#xff11;.&#xff16;中可以知道&#xff1a; &#xff11;.和&#xff21;&#xff52;&#xff52;&#xff41;&#x…
阅读更多...
数据结构之单链表反转

数据结构之单链表反转

public void reverseNode(){//判断链表是否有节点,或者只有一个节点if (head.next null || head.next.next null){return;}//创建一个辅助变量存储节点HeroNode cur head.next;//创建一个辅助变量存储原始链表的下一个节点HeroNode next null;//创建一个新链表HeroNode rev…
阅读更多...
链表虚拟头节点的好处

链表虚拟头节点的好处

1 使用了虚拟头结点的技巧&#xff0c;也是为了防止出现空指针的情况。 比如说链表总共有 5 个节点&#xff0c;题目就让你删除倒数第 5 个节点&#xff0c;也就是第一个节点&#xff0c;那按照算法逻辑&#xff0c;应该首先找到倒数第 6 个节点。但第一个节点前面已经没有节点…
阅读更多...
java - 82. 删除排序链表中的重复元素 II

java - 82. 删除排序链表中的重复元素 II

1、解题思路 注意&#xff1a;这种可能会删除第一个节点的链表&#xff0c;最好加上头节点 1 因为要比较当前指针的下个和下下个节点&#xff0c;因此要在这2个节点均不为空的情况下循环删除 2 当前指针的下个和下下个相等就开始执行删除操作&#xff1b;当前指针的下个和下下…
阅读更多...
双向链表代码实现

双向链表代码实现

双向链表代码实现C语言代码实现C语言代码实现 #include<stdio.h> #include<stdlib.h> #include <string.h> typedef struct dlnode {char data;//data为结点的数据信息struct dlnode *prior,*next;//prior和next分别为指向直接前驱和直接后继结点的指针 }D…
阅读更多...
【学习笔记】Redis中有序集合zset的实现原理——跳表

【学习笔记】Redis中有序集合zset的实现原理——跳表

面试的时候被问到了有序集合zset的实现原理&#xff0c;本以为是基于红黑树实现的&#xff0c;其实是基于跳表&#xff08;skipList&#xff09;实现的。本文主要讲解什么是跳表&#xff0c;它是怎么查找、插入和删除元素的&#xff0c;相比于红黑树它有哪些优劣。 本文参考了…
阅读更多...
Design Front Middle Back Queue 设计前中后队列

Design Front Middle Back Queue 设计前中后队列

文章目录Design Front Middle Back Queue 设计前中后队列Description思路Design Front Middle Back Queue 设计前中后队列 Description Design a queue that supports push and pop operations in the front, middle, and back. Pushing 6 into the middle of [1, 2, 3, 4, …
阅读更多...
java - 21. 合并两个有序链表

java - 21. 合并两个有序链表

题目&#xff1a;力扣21题 思路 1 定义3个指针&#xff0c;p是新链表的尾指针&#xff0c;list1和list2是两个链表当前的头指针 2 分别比较2个链表头节点&#xff0c;每选出一个较小值&#xff0c;就给新链表接上去&#xff0c;该较小值尾指针往后走 3 比完一个后把剩下的不为…
阅读更多...
【java笔记】java中HashMap的原理介绍

【java笔记】java中HashMap的原理介绍

本文参考了知乎用户“creep”的HashMap原理详解&#xff0c;看不懂算我输&#xff08;附面试题&#xff09;。 1. HashMap概述 (1) 版本更迭 JDK 1.7 &#xff1a; Table数组 Entry链表 JDK1.8 : Table数组 Entry链表/红黑树 其中Table数组是Node<K,V>类型的&#xff…
阅读更多...
每日n刷：leetcode2. 两数相加

每日n刷：leetcode2. 两数相加

2. 两数相加 链表模拟 模拟O(n) 因为给的链表就是逆序的&#xff0c;输出也是逆序的&#xff0c;而且在进位的时候需要关注&#xff0c;所以直接从链表头遍历。 需要关注进位的问题&#xff0c;在遍历结束之后如果进位还存在&#xff0c;那么需要把进位放在最后一位。 clas…
阅读更多...
PAT 甲 1074 反转链表 Reversing Linked List

PAT 甲 1074 反转链表 Reversing Linked List

Given a constant K and a singly linked list L, you are supposed to reverse the links of every K elements on L. For example, given L being 1→2→3→4→5→6, if K3, then you must output 3→2→1→6→5→4; if K4, you must output 4→3→2→1→5→6. Input Specif…
阅读更多...
ConcurrentHashMap简介

ConcurrentHashMap简介

一、jdk1.8之前的数据结构&#xff1a; 1.默认情况下会有16个区段 Segment数组 Segment[16] 2.每次每个区段Segment中会保存若干个散列桶&#xff0c;每次散列桶长度扩容成2^n次方的长度。 多个散列桶相连就构成了散列表。 3.存入元素&#xff1a; key带入到hashcode方法众获…
阅读更多...
第二章--线性表之静态链表

第二章--线性表之静态链表

目录一、什么是静态链表二、用代码定义一个静态链表代码实现三、静态链表的插入和查找一、什么是静态链表 游标标明下一个结点的位置 比如头结点的下一个结点是存放在数组下标为2的位置 也就是这个结点 然后再下一个结点就是数组下标为1的结点 如果要表示这是静态链表的最后…
阅读更多...
算法学习之链表

算法学习之链表

# 算法学习之链表 一、基础知识 0x1 为什么链表很重要 链表——真正的动态数据结构最简单的动态数据结构更深入的理解引用(或者指针)更深入的理解递归辅助组成其他数据结构 0x2 链表 数据存储在“节点”中 优点:真正的动态&#xff0c;不需要处理固定容量的问题缺点:丧失…
阅读更多...
【Java实现】反转链表

【Java实现】反转链表

&#x1f388;目录&#x1f388; 问题描述&#x1f512; 输入输出实例&#xff1a; 解题分析 &#x1f511; 代码实现&#x1f513; 题目入口&#x1f4cc;:反转链表 问题描述 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 输入输出…
阅读更多...
【Java实现】移除链表元素

【Java实现】移除链表元素

&#x1f388;目录&#x1f388; 问题描述&#x1f512; 输入输出实例&#xff1a; 解题分析&#x1f511; 代码实现&#x1f513; 题目入口&#x1f4cc;&#xff1a;移除链表元素 问题描述 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足…
阅读更多...
《数据结构与算法之美》 笔记六 链表 下

《数据结构与算法之美》 笔记六 链表 下

文章目录前言技巧一&#xff1a;理解指针或引用的含义技巧二&#xff1a;警惕指针丢失和内存泄漏技巧三&#xff1a;利用哨兵简化实现难度技巧四&#xff1a;重点留意边界条件处理技巧五&#xff1a;举例画图&#xff0c;辅助思考技巧六&#xff1a;多写多练&#xff0c;没有捷…
阅读更多...
数据结构错题整理

数据结构错题整理

错题来源——数据结构经典十套卷试题及错误修正版答案 一、选择题 用 链接方式存储的队列 &#xff0c;在进行 插入 运算时( ). A. 仅修改头指针   B. 头、尾指针都要修改 C. 仅修改尾指针   D.头、尾指针可能都要修改对 n 个记录的文件进行 快速排序 &#xff0c;所需要的…
阅读更多...
C++简单实现双链表

C++简单实现双链表

首先&#xff0c;来了解一下什么是双向链表。官方解释是这样的&#xff1a;双向链表也叫双链表&#xff0c;是链表的一种&#xff0c;它的每个数据结点中都有两个指针&#xff0c;分别指向直接后继和直接前驱。所以&#xff0c;从双向链表中的任意一个结点开始&#xff0c;都可…
阅读更多...
剑指offer 刷题 十一 双指针（18 22）

剑指offer 刷题 十一 双指针（18 22）

剑指 Offer 18. 删除链表的节点 给定单向链表的头指针和一个要删除的节点的值&#xff0c;定义一个函数删除该节点。 返回删除后的链表的头节点。 注意&#xff1a;此题对比原题有改动 双指针&#xff1a; def deleteNode(self, head: ListNode, val: int) -> ListNode:cu…
阅读更多...
二叉树（递归应用+建树）

二叉树（递归应用+建树）

由上一个部分可知二叉树基础&#xff0c;现在看看二叉树的一些应用&#xff1b; 目录 计算root为根的二叉树结点个数(了解后序遍历的基础) 求树的高度或深度(后序遍历) 如何把前、中、后序递归算法的最后一条递归调用语句消除呢&#xff1f;教材习题248的25题 寻找树的先序…
阅读更多...
数据结构-------链表（递归）操作

数据结构-------链表（递归）操作

希望能继续坚持下去 这篇博客应该是为菜鸡&#xff08;本人&#xff09;听课听的疑惑点进行知识梳理&#xff08;如有错误请指正&#xff09; 数据结构中的链表估计很多人会觉得简单&#xff0c;我也是怕记不住所以就尝试整理一下笔记吧 目录 1.创建链表&#xff08;初始化&…
阅读更多...
链表中环的入口结点 — C++实现

链表中环的入口结点 — C++实现

题目描述 给一个链表&#xff0c;若其中包含环&#xff0c;请找出该链表的环的入口结点&#xff0c;否则&#xff0c;输出null。 牛客网题目链接 解题思路 使用快慢两个指针实现&#xff0c;若存在环&#xff0c;则两指针会在环内相遇&#xff0c;然后让快指针指向头结点&a…
阅读更多...
链表中倒数第k个结点 — C++实现

链表中倒数第k个结点 — C++实现

题目描述 输入一个链表&#xff0c;输出该链表中倒数第k个结点。 牛客网题目链接 解题思路 直接思路是遍历链表&#xff0c;遍历的时候压栈&#xff0c;遍历完后出栈&#xff0c;倒数出k个就行。但这样肯定是拿不到Offer的。 可以这么做&#xff0c;拿两个指针从头遍历&am…
阅读更多...
第三章算法设计题10

第三章算法设计题10

第三章算法设计题10 题目描述 代码实现 #pragma once #include <iostream>using namespace std;//单链表的存储结构 typedef struct Lnode {int data;struct Lnode* next; }Lnode,*LinkList;//单链表的初始化 void InitList(LinkList& L) {L new Lnode;L->next…
阅读更多...
图的邻接多重表，c/c++描述

图的邻接多重表，c/c++描述

由主函数中图的顶点数组和邻接矩阵&#xff0c;给出图的已知信息&#xff0c;据此建立无向图的邻接多重表。   因为对于无向图的邻接链表来说&#xff0c;一条边对应的顶点间的连接关系会在两个顶点的邻接链表里各出现一次&#xff0c;造成存储上的资源浪费。而且&#xff0c…
阅读更多...
数据结构学习——链表（C语言版）

数据结构学习——链表（C语言版）

数据结构学习——链表的简单解析一、何为链表&#xff08;1&#xff09;概念&#xff1a;&#xff08;2&#xff09;特点&#xff1a;二、链表的简单实现&#xff08;1&#xff09;头插法&#xff1a;&#xff08;2&#xff09;尾插法&#xff08;3&#xff09;模拟学生管理系统…
阅读更多...
70.树的子结构

70.树的子结构

文章目录题目思路代码题目 输入两棵二叉树A和B&#xff0c;判断B是不是A的子结构。(约定空树不是任意一个树的子结构) B是A的子结构&#xff0c; 即 A中有出现和B相同的结构和节点值。 注意同[17.树的子结构]题目区分&#xff0c;此处结构和值包含即可&#xff0c;不必相等&a…
阅读更多...
求链表的中间节点

求链表的中间节点

题目 求链表的中间节点 思路 双指针&#xff0c;设立快指针和慢指针。 代码 class Node:def __init__(self, data, nextNone):self.data dataself.next nextdef find_middle_node(head):求单链表的中间结点slow, fast head, headfast fast.next if fast else Nonewhil…
阅读更多...
[C++] Hash_map 实现原理和源码[散列表][散列映射][泛式数据支持][STL]

[C++] Hash_map 实现原理和源码[散列表][散列映射][泛式数据支持][STL]

Hash_map 作为非线性数据结构. 在阅读前,你需要确定你已经真正的理解了什么是指针. 并且在不看任何源码的情况下,通过原理实现出链表数据结构. 如果不太确定的话,建议以下文章: [C/C]指针的原理和对指针的运用及理解(包括函数指针和多级指针) [C]什么是引用,以及引用和指针的关…
阅读更多...
[C++]迭代器iterator的实现(支持编译器for块简易写法)

[C++]迭代器iterator的实现(支持编译器for块简易写法)

什么是迭代器? 以下是维基百科的简介. 迭代器&#xff08;iterator&#xff09;&#xff0c;是确使用户可在容器对象&#xff08;container&#xff0c;例如链表或数组&#xff09;上遍访的对象[1][2][3]&#xff0c;设计人员使用此接口无需关心容器对象的内存分配的实现细节。…
阅读更多...
【无标题】1月10日学习总结---单向链表的排序、插入和删除

【无标题】1月10日学习总结---单向链表的排序、插入和删除

今天白天学会了链表的排序&#xff08;选择和冒泡&#xff09;、合并、插入、删除 链表的合并 题目描述 知L1、L2分别为两循环单链表的头结点指针&#xff0c;m,n分别为L1、L2表中数据结点个数。要求设计一算法&#xff0c;用最快速度将两表合并成一个带头结点的循环单链表。…
阅读更多...
2021-11-07

2021-11-07

第七天总结 线性表&#xff1a; 数组&#xff08;Array&#xff09;&#xff1a;连续&#xff0c;大小固定的内存结构 栈&#xff08;Stack&#xff09;&#xff1a;先进后出&#xff0c;后进先出 队列&#xff08;Queue&#xff09;&#xff1a;先进先出 链表&#xff08;Lis…
阅读更多...
JavaScript数据结构-2-链表

JavaScript数据结构-2-链表

main(); //声明结点类 function Lnode() { this.data; //数据 this.next; //指针 } //头插法建立单链表 function List_HeadInsert() { var L new Lnode(); //头节点 L.next null; for (i 1; i < 10; i) { var s new Lnode(); //新建节点 …
阅读更多...
实验二 链表的基本操作

实验二 链表的基本操作

ZZU的学弟学妹们不要抄作业哦~(｀Д) 一、实验目的 1．掌握线性表的链式存储结构的表示和实现方法。 2．掌握链表基本操作的算法实现。 二、实验内容 1．建立单链表，并在单链表上实现插入、删除和查找操作（验证性内容）。 2．计算已知一个单链表中数据域值为一个指定值x的结…
阅读更多...
数据结构与算法(数组、链表、栈、队列、树)

数据结构与算法(数组、链表、栈、队列、树)

数据结构与算法 时间复杂度 只关注循环次数最多的一段代码总循环度等于最高阶项的复杂度嵌套代码的复杂度等于嵌套内外代码复杂度的乘积 O(1)<O(log n)<O(n)<O(nlog n)<O(n)<O(n)<O(2n)<O(n!)<O(nn) 递归 使用递归的条件 一个问题的解可以分解为…
阅读更多...
重学数据结构：静态链表的各种操作（C语言）

重学数据结构：静态链表的各种操作（C语言）

文章目录静态链表定义初始化链表打印链表根据序号获取对应的值在对应序号节点后增加节点在对应序号节点后删除节点测试输出结果静态链表定义 #include <stdio.h> #include <string.h>#define maxSize 50typedef struct {int index;int data; }StaticLink[maxSize]…
阅读更多...
重学数据结构：循环链表的各种操作（C语言）

重学数据结构：循环链表的各种操作（C语言）

文章目录循环单链表定义初始化判断节点p是否是尾节点判断链表是否为空在节点p后插入节点s循环双链表定义初始化判断节点p是否尾结点判断链表是否为空在节点p后加入节点s删除节点p的后节点循环单链表定义 其实这里定义的结构跟单链表的没什么区别&#xff0c;只不过在初始化或操…
阅读更多...
数据结构之队列(数组实现)

数据结构之队列(数组实现)

使用场景 银行排队&#xff0c;头部的人先完成业务,给每个人一个编号 先进先出&#xff0c;通过指针指定到编号介绍 1.队列是一个有序列表&#xff0c;可以用数组或是链表来实现 2.遵循先入先出原则数组模拟队列 思路分析 1.队列本身是有序列表&#xff0c;若使用数组来存…
阅读更多...
栈实现队列，链表实现栈

栈实现队列，链表实现栈

栈实现队列&#xff1a; #include<iostream> #include<stack>template<class T>class Queue {std::stack<T> st1, st2; public:void enqueue(T head){st1.push(head);}T pop(){while (!st1.empty()){st2.push(st1.top());st1.pop();}T tail st2.top()…
阅读更多...
有序表的查找——折半查找分析

有序表的查找——折半查找分析

折半查找一、折半查找的查找过程1、折半查找(Binary Search)2、二分查找的基本思想二、折半查找的实现三、折半查找的性能分析四、总结一、折半查找的查找过程 1、折半查找(Binary Search) 折半查找又称二分查找&#xff0c;它是一种效率较高的查找方法。 二分查找要求&…
阅读更多...
22计算机408考研—数据结构—线性表、栈、队列、数组

22计算机408考研—数据结构—线性表、栈、队列、数组

2022计算机考研408—数据结构—线性表、栈、队列、数组 手把手教学考研大纲范围内的线性表、栈、队列、数组 22考研大纲数据结构要求的是C/C&#xff0c;笔者以前使用的都是Java&#xff0c;对于C还很欠缺&#xff0c; 如有什么建议或者不足欢迎大佬评论区或者私信指出 Talk is…
阅读更多...
数据结构与算法学习---数据结构篇（树b）（默然回首，夯实基础）

数据结构与算法学习---数据结构篇（树b）（默然回首，夯实基础）

一、平衡树 之前我们学习过二叉查找树&#xff0c;发现它的查询效率比单纯的链表和数组的查询效率要高很多&#xff0c;大部分情况下&#xff0c;确实是这样的&#xff0c;但不幸的是&#xff0c;在最坏情况下&#xff0c;二叉查找树的性能还是很糟糕。 例如我们依次往二叉查找…
阅读更多...
JAVA集合学习总结-----蓦然回首，夯实基础

JAVA集合学习总结-----蓦然回首，夯实基础

1.接口继承关系和实现 集合类存放于 Java.util 包中&#xff0c;主要有 3 种&#xff1a;set(集&#xff09;、list(列表包含 Queue&#xff09;和 map(映射)。 Collection&#xff1a;Collection 是集合 List、Set、Queue 的最基本的接口。Iterator&#xff1a;迭代器&#…
阅读更多...
数组和链表的常用算法

数组和链表的常用算法

有趣的约瑟夫环问题 问题描述 著名的约瑟夫问题&#xff1a;编号为 1-N 的 N 个士兵围坐在一起形成一个圆圈&#xff0c;从编号为 1 的士兵开始依次报数&#xff08;1&#xff0c;2&#xff0c;3… 这样依次报数&#xff09;&#xff0c;数到 m 的 士兵会被淘汰出列&#xff…
阅读更多...
剑指offer35---复杂链表的复制

剑指offer35---复杂链表的复制

解决思路&#xff1a; ①节点value 的复制&#xff0c;只需要 new Node(value)即可 ②节点指针的复制&#xff0c;&#xff08;next,random&#xff09;的复制 1.通过HashMap 存储师徒之间的关系&#xff0c;遍历师傅&#xff0c;创建相同节点的徒弟。 2. 再次遍历&#xff0c…
阅读更多...
剑指offer--24. 反转链表

剑指offer--24. 反转链表

①迭代解法 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode(int x) { val x; }* }*/class Solution {ListNode pre;ListNode cur;ListNode next;public ListNode reverseList(ListNode head) {curhead;…
阅读更多...
Sort List —— 归并排序

Sort List —— 归并排序

问题描述 Sort a linked list in O(n log n) time using constant space complexity. 算法分析 1、要求时间复杂度为 O(n log n)&#xff0c;可以考虑归并与快排&#xff1b; 2、本文使用归并&#xff0c;每次将链表从中间位置切断&#xff0c;一分为二&#xff1b; 3、递…
阅读更多...
常见排序算法——桶排序(箱子排序)bucket Sort

常见排序算法——桶排序(箱子排序)bucket Sort

桶排序是一个经典的排序算法&#xff0c;特点是速度快&#xff0c;算法复杂度为O(n)&#xff0c;且是稳排&#xff0c;当然也是最耗空间的一种算法。 例如&#xff1a; 1&#xff09;排序一组数[7&#xff0c;3&#xff0c;19&#xff0c;11&#xff0c;6&#xff0c;8&#…
阅读更多...
linux内核数据结构之链表

linux内核数据结构之链表

linux内核数据结构之链表 1、前言 最近写代码需用到链表结构&#xff0c;正好公共库有关于链表的。第一眼看时&#xff0c;觉得有点新鲜&#xff0c;和我之前见到的链表结构不一样&#xff0c;只有前驱和后继指针&#xff0c;而没有数据域。后来看代码注释发现该代码来自linux内…
阅读更多...
LeetCode206——Reverse Linked List 反转链表

LeetCode206——Reverse Linked List 反转链表

Reverse a singly linked list. 实现&#xff1a; class Solution { public: ListNode* reverseList(ListNode* head) { if (head NULL) return NULL; ListNode* pfirst head; ListNode* pcurr head; while (pcurr->next) { …
阅读更多...
【链表】24. 两两交换链表中的节点

【链表】24. 两两交换链表中的节点

题目&#xff1a; 给定一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后的链表。 你不能只是单纯的改变节点内部的值&#xff0c;而是需要实际的进行节点交换。 代码&#xff1a; 初始时&#xff0c;cur指向虚拟头结点&#xff0c;然后进行如下三步&…
阅读更多...
数据结构——字符串与数组知识点总结

数据结构——字符串与数组知识点总结

字符串理论 字符串是数据元素为单个字符的线性表&#xff0c;一般采用顺序存储。在主串S中寻找字串T的过程称为模式匹配&#xff0c;T称为模式。主要的算法有BF算法&#xff0c;KMP算法。 BF算法 数组理论 数组是由类型相同的数据元素构成的有序集合。一维数组可以看作一个…
阅读更多...
Leetcode 实战笔记 一（1, 2, 20, 21, 22, 24, 27, 35）

Leetcode 实战笔记 一（1, 2, 20, 21, 22, 24, 27, 35）

目录&#xff1a; No.1 两数之和No.2 两数相加No.20 有效的括号No.21 合并两个有序链表No.22 括号生成No.24 两两交换链表中的节点No.27 移除元素No.35 搜索插入位置 1. 两数之和 给定一个整数数组 nums 和一个整数目标值 target&#xff0c;请你在该数组中找出 和为目标值 t…
阅读更多...
从尾到头打印链表及应用

从尾到头打印链表及应用

文章目录题目描述解题思路C求解拓展应用--两数相加题目描述 输入一个链表&#xff0c;按链表从尾到头的顺序返回一个ArrayList。 题目牛客网链接 解题思路 链表的遍历是从头节点开始的&#xff0c;而栈是先进后出的&#xff0c;因此我们可以将遍历到的数据先进行压栈操作&…
阅读更多...
队列的链表实现（C语言）

队列的链表实现（C语言）

队列 目录队列队列的操作入队出队遍历查找队列的C语言链表实现为了阅读方便和保持内容的完整性&#xff0c;这部分使用了队列的数组实现&#xff08;C语言&#xff09;中的内容队列是一种允许在一端&#xff08;队尾&#xff0c;rear&#xff09;进行插入操作&#xff0c;另一端…
阅读更多...
单链表及C语言实现

单链表及C语言实现

本博文介绍单链表&#xff0c;及其C语言的实现 目录单链表单链表操作插入头结点插入尾结点插入指定位置插入删除头结点删除尾结点删除指定位置删除遍历查找单链表C语言的实现单链表 单链表是一种链式存取的数据结构&#xff0c;由每个结点单元连接而成。 每个结点单元由两部分…
阅读更多...
双链表及C语言实现

双链表及C语言实现

本博文介绍双链表&#xff0c;及其C语言的实现 目录双链表双链表的操作插入头结点插入尾结点插入指定位置插入删除头结点删除尾结点删除指定位置删除遍历查找双链表的C语言实现双链表 双链表也叫双向链表&#xff0c;如下图所示&#xff0c;不同于单链表&#xff0c;对于任意一…
阅读更多...
华为机试(python)：链表

华为机试(python)：链表

HJ48 从单向链表中删除指定值的节点 输入一个单向链表和一个节点的值&#xff0c;从单向链表中删除等于该值的节点&#xff0c;删除后如果链表中无节点则返回空指针。 链表的值不能重复。 构造过程&#xff0c;例如输入一行数据为: 6 2 1 2 3 2 5 1 4 5 7 2 2 则第一个参数…
阅读更多...
LeetCode 24 两两交换链表中的节点

LeetCode 24 两两交换链表中的节点

题目描述&#xff1a; 给定一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后的链表。 你不能只是单纯的改变节点内部的值&#xff0c;而是需要实际的进行节点交换。 示例&#xff1a; 输入&#xff1a;head [1, 2, 3, 4] 输出&#xff1a;[2, 1, 4, 3] …
阅读更多...
【剑指offer】链表中倒数第 k 个结点

【剑指offer】链表中倒数第 k 个结点

题目描述 输入一个链表&#xff0c;输出该链表中倒数第 k 个结点。 解题思路 思路一&#xff1a; 这个思路比较简单粗暴&#xff0c;因为要找倒数第 k 个结点&#xff0c;可以利用栈“先进后出”的特性&#xff0c;首先&#xff0c;遍历链表所有的结点&#xff0c;存储到栈内…
阅读更多...
【剑指offer】合并两个排序链表

【剑指offer】合并两个排序链表

题目描述 输入两个单调递增的链表&#xff0c;输出两个链表合成后的链表&#xff0c;当然我们需要合成后的链表满足单调不减规则。 解题思路 思路一&#xff1a; 创建一个新的链表&#xff0c;一起遍历链表 1 和链表 2&#xff0c;哪个值小&#xff0c;就插入到新链表中。 实…
阅读更多...
删除单向链表的头节点

删除单向链表的头节点

1、使用pTemp保存头节点的指针域&#xff08;第二个节点的首地址&#xff09;&#xff0c; 2、删除&#xff08;free&#xff09;头节点&#xff0c; 3、再将pTemp传给新的pHead进而指向新的头节点。 /* *copyright(c) 2018,HH *All rights reserved. *作 者&#xff1a;HH *…
阅读更多...
C++中函数传参 * x 和 x 的区别 使用链表举例说明 看完就懂

C++中函数传参 * x 和 x 的区别 使用链表举例说明 看完就懂

我们用头插法建立单链表来说明函数参数中LNode* &L和LNode* L的区别: LNode* &L不仅可以访问L指向的区域&#xff0c;而且可以直接改变L的内容&#xff1b;但是LNode* L只能访问L指向的区域 下面直接看例子 LNode* L #include<stdio.h> #include<stdlib.h&…
阅读更多...
单个pdf文件合并_合并单个链接列表的排序

单个pdf文件合并_合并单个链接列表的排序

单个pdf文件合并Problem statement: Write a C program to sort two single linked lists using merge sort technique. 问题陈述&#xff1a;编写一个C 程序&#xff0c;以使用合并排序技术对两个单个链表进行排序。 Solution: Merge sort is an efficient technique for sor…
阅读更多...
力扣114. 二叉树展开为链表

力扣114. 二叉树展开为链表

给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左子指针始终为 null 。 展开后的单链表应该与二叉树 先序遍历 顺序相同。 输入&#xff1…
阅读更多...
两个序列是否对应相同搜索树的判别（浙--建议采用“调试”体会函数的调用过程）

两个序列是否对应相同搜索树的判别（浙--建议采用“调试”体会函数的调用过程）

#include <stdio.h> #include <stdlib.h> typedef struct TreeNode *Tree; struct TreeNode{int v;Tree Left,Right;int flag;//设立标志判断是否为找过的函数&#xff0c;为函数check()与Judge()做准备 };//如何建立搜索树 Tree MakeTree (int N);//根据首个元素…
阅读更多...
第四天——24.两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 142.环形链表II

第四天——24.两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 142.环形链表II

24.两两交换链表中的节点 有点开心的这道题&#xff0c;手动写出了一道中等难度的题目&#xff0c;自信心1 两个技巧&#xff1a;第一个是使用了两个虚拟头节点&#xff0c;省去发现头节点的分情况讨论步骤 第二个是使用tmp变量去保存临时节点 # Definition for singly-link…
阅读更多...
刷题第三天——203.移除链表元素 707.设计链表 206.反转链表

刷题第三天——203.移除链表元素 707.设计链表 206.反转链表

● 203.移除链表元素 虚拟头指针的思想和循环条件是重中之重 第一种方法&#xff1a; 分两种情况&#xff1a; 如果是头节点的话&#xff0c;就把head head.next 如果不是头节点就定义一个指针 head&#xff0c;指针代表检测的节点的前一个节点。 class Solution(object):d…
阅读更多...
leetcode 876.链表的中间结点|数据结构-链表

leetcode 876.链表的中间结点|数据结构-链表

leetcode 876. 链表的中间结点 难度&#xff1a;简单 题目&#xff1a;给定一个带有头结点 head 的非空单链表&#xff0c;返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结点。 代码如下&#xff1a; struct ListNode* middleNode(struct ListNode* h…
阅读更多...
leetcode 142.环形链表 II|数据结构-链表

leetcode 142.环形链表 II|数据结构-链表

142. 环形链表 II 难度&#xff1a;中等 题目&#xff1a;给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 说明&#xff1a;为了表示给定链表中的环&#xff0c;我们使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;…
阅读更多...
数据结构与算法 — 单链表

数据结构与算法 — 单链表

一、链式结构 线性表的链式存储结构成为链表&#xff0c;每个存储节点不仅包含元素本身的信息(数据域)&#xff0c;而且还包含着元素之间的逻辑关系(指针域)。 二、单链表 1.定义 每一个结点只含有一个指针域的链式结构称为单链表&#xff0c;也就是只能单方向去得到别的节…
阅读更多...
C++单链表的初始化，插入，删除，反转操作

C++单链表的初始化，插入，删除，反转操作

链表的性质&#xff1a; 1.元素不能随机访问 2.链表只有一个表头 3.元素相互依赖&#xff0c;串联而成 链表的初始化&#xff1a; #include<iostream> using namespace std; //节点类 class Node{ public:int data; //数据域Node *next; //指向下一个节点…
阅读更多...
C语言：L2-025 分而治之 (25 分) —— 模拟图

C语言：L2-025 分而治之 (25 分) —— 模拟图

文章目录一、题目二、方法11、思路2、代码一、题目 分而治之&#xff0c;各个击破是兵家常用的策略之一。在战争中&#xff0c;我们希望首先攻下敌方的部分城市&#xff0c;使其剩余的城市变成孤立无援&#xff0c;然后再分头各个击破。为此参谋部提供了若干打击方案。本题就请…
阅读更多...
链表实现多项式的加法和乘法

链表实现多项式的加法和乘法

基本思路是做一个链表&#xff0c;然后给个add函数&#xff0c;add函数用于相加&#xff0c;同时也可以用来插入新元素&#xff0c;相乘即系数相乘&#xff0c;次数相加add到新的链表即可&#xff1a; LinkList.h: #include <malloc.h> #define TYPE1 int #define TYPE…
阅读更多...
【万字总结】数据结构与算法简述和CS综合，保姆级一文打包

【万字总结】数据结构与算法简述和CS综合，保姆级一文打包

数据结构与算法简述和CS综述整理。本文非基础的教程&#xff0c;本文会列出大量学习和参考网站。老惯例&#xff0c;一个文章是一个集大成&#xff08;本文借助了语音输入&#xff08;PC 版 讯飞输入法&#xff09;由此加速码字&#xff0c;但仍保持简洁的文风&#xff09;。 …
阅读更多...
ReentrantLock源码原理解释

ReentrantLock源码原理解释

ReentrantLock 原理解释 这种东西就是心中有个大概就好了&#xff0c;尝试看看源码也听有意思的。 多几次debug就好了 注意&#xff1a;这个就是一个 state 在加一个双向链表 只要记住这个情况&#xff0c;后面debug起来就顺利了。 ReentrantLock lock new ReentrantLock()…
阅读更多...
Day_15 链表体系结构和红黑树

Day_15 链表体系结构和红黑树

文章目录LinkedHashSet数据结构之树结构树结构常识红黑树结构红黑树添加元素的规律(了解)TreeSet比较器接口Comparable绑定比较器Comparator独立比较器数组排序和List集合排序Collections双列集合的概述双列集合的体系结构HashMapLinkedHashSet LinkedHashSet<E> : 元素…
阅读更多...
线性表（linear_list）

线性表（linear_list）

文章目录线性表 linear_list定义线性结构的特点线性表的表示顺序表示链式表示单链表双向链表循环链表静态链表链式表示与顺序表示对比链式优缺点顺序式优缺点线性表 linear_list 定义 一个线性表是N个数据元素的有序序列。一个数据元素可以是若干个数据项组成的。数据元素可以…
阅读更多...
剑指offer 刷题 二十一 位运算（15 65）

剑指offer 刷题 二十一 位运算（15 65）

剑指 Offer 15. 二进制中1的个数 编写一个函数&#xff0c;输入是一个无符号整数&#xff08;以二进制串的形式&#xff09;&#xff0c;返回其二进制表达式中数字位数为 ‘1’ 的个数&#xff08;也被称为 汉明重量).&#xff09;。 这题在上一章做过类似的处理&#xff0c;所…
阅读更多...
剑指offer 刷题 二十 分治（07 16 33）

剑指offer 刷题 二十 分治（07 16 33）

剑指 Offer 07. 重建二叉树 输入某二叉树的前序遍历和中序遍历的结果&#xff0c;请构建该二叉树并返回其根节点。 假设输入的前序遍历和中序遍历的结果中都不含重复的数字。 这道题要用到递归的思想&#xff0c;用pre找到根&#xff0c;用in找到左右两个子树。下面是我画的示…
阅读更多...
算法通关40讲 笔记二（数组 链表）

算法通关40讲 笔记二（数组 链表）

数组&#xff1a; 连续存储&#xff0c;通过右边的内存管理器&#xff0c;可以按照索引可以访问任意元素。 插入与删除&#xff1a;O(n)的时间复杂度。 查询是O(1)的 链表&#xff1a; 优点&#xff1a;插入和删除都是O(1)。查找是O(n)的。 不知道有多少元素会插入进来。所以…
阅读更多...
python实现基本数据结构第一篇（线性表：顺序表，单、双链表，单、双循环链表）

python实现基本数据结构第一篇（线性表：顺序表，单、双链表，单、双循环链表）

数据结构是编程的基础&#xff0c;类似于学习数学&#xff0c;首先要认识数字一样。所以数据结构学的如何&#xff0c;就意味着编程基础是否牢固&#xff0c;下面介绍数据结构中的基本数据结构&#xff1a;线性表&#xff08;顺序表&#xff0c;链表&#xff09; 讲到数据结构&…
阅读更多...
C的几个小程序和概念(常见操作)（上）

C的几个小程序和概念(常见操作)（上）

C的几个小程序和概念(常见操作)&#xff08;上&#xff09; 1、条件编译中&#xff0c; #if 常量表达式 源程序 #endif 其中&#xff0c;常量表达式一般是使用defined运算符对标识符是否被定义进行判断。defined运行符仅用于编译预处理&#xff0c;语法格式如下&#xff1a…
阅读更多...
javahashmap中的添加问题

javahashmap中的添加问题

javahashmap添加时遇到的问题 引入&#xff1a;为什么hashmap中添加时用了hashcode()还要用equals()去判断桶内部是否键对象相等&#xff0c;相等时替换旧值&#xff0c;而不相等时用头插法在链表头部插入新对象。哈希码由于只有2 ^ 32个不同的整数&#xff0c;并且在任何VM实…
阅读更多...
c链表实现简单的通讯录系统

c链表实现简单的通讯录系统

功能包括增删改查排序和显示 //用链表实现简单通讯录#include<stdio.h> #include<stdlib.h> #include<string.h>#define NAME_SIZE 20 #define ADDR_SIZE 30 #define TELE_SIZE 12typedef struct Data{int age; //年龄int sex; /…
阅读更多...
LeetCode学习-第十三天

LeetCode学习-第十三天

第十天 我使用的C&#xff0c;错误的地方请见谅&#xff0c;文章初衷仅用来督促本人学习&#xff0c;如果恰巧能够给你带来帮助&#xff0c;我会十分开心。 文章目录第十天一、876. 链表的中间结点二、19. 删除链表的倒数第 N 个结点一、876. 链表的中间结点 给定一个头结点为…
阅读更多...
归并排序（merge_sort）:从二路到多路

归并排序（merge_sort）:从二路到多路

归并排序基础思想就是 分治 左边处理一下&#xff0c;得到左边的信息&#xff1b;右边处理一下&#xff0c;得到右边的信息&#xff1b;最后再处理&#xff0c;横跨左右两边的信息。 代码演示&#xff1a; cpp //二路归并 void merge_sort(int *arr,int l,int r){if(l>r) …
阅读更多...
c++容器链表list的使用

c++容器链表list的使用

链表和list 咳咳&#xff0c;不是每一朵鲜花都能代表爱情&#xff0c;但是玫瑰做到了&#xff1b;不是每一颗树都能耐的住干渴&#xff0c;但是白杨做到了&#xff1b;也不是每一个人都会追求上进&#xff0c;挑战自我&#xff0c;但是我相信我们也能做到。今天给大家带来的是c…
阅读更多...
HashMap夺命14问，你能坚持到第几问？

HashMap夺命14问，你能坚持到第几问？

1. HashMap的底层数据结构是什么&#xff1f;在JDK1.7中和JDK1.8中有所区别&#xff1a;在JDK1.7中&#xff0c;由”数组链表“组成&#xff0c;数组是HashMap的主体&#xff0c;链表则是主要为了解决哈希冲突而存在的。在JDK1.8中&#xff0c;有“数组链表红黑树”组成。当链表…
阅读更多...
java常用集合框架

java常用集合框架

集合框架 集合 集合是java提供的一种容器&#xff0c;用来储存多个数据集合与数组的区别 数组的长度是固定的&#xff0c;集合的长度是可变的数组中存储的是同一类型的元素&#xff0c;可以存储基本数据类型集合中存储的都是对象&#xff0c;而且对象的类型可以不一致在开发中…
阅读更多...
数据结构-手撕单链表+代码详解

数据结构-手撕单链表+代码详解

⭐️ 往期相关文章 ✨ 链接1&#xff1a;数据结构-手撕顺序表(动态版)代码详解 ✨ 链接2&#xff1a;数据结构和算法的概念以及时间复杂度空间复杂度详解 ⭐️ 链表 &#x1f320; 什么是链表&#xff1f; 链表是一种物理存储结构上非连续、非顺序的存储结构&#xff0c;数据…
阅读更多...
普里姆算法_最小代价生成树_邻接链表表示法

普里姆算法_最小代价生成树_邻接链表表示法

额&#xff0c;教科书上的案例是错误的&#xff0c;Prim算法没有那么简单&#xff0c;短短的几行代码根本实现不了。不过仍然向它致敬&#xff0c;因为理论讲的很透彻&#xff0c;我也是根据理论写出来这个复杂代码的&#xff0c;本算法的基本数据结构是邻接表。 Prim算法简介&…
阅读更多...
链表随机节点

链表随机节点

给你一个单链表&#xff0c;随机选择链表的一个节点&#xff0c;并返回相应的节点值。每个节点 被选中的概率一样 。 实现 Solution 类&#xff1a; Solution(ListNode head) 使用整数数组初始化对象。 int getRandom() 从链表中随机选择一个节点并返回该节点的值。链表中所有…
阅读更多...
面试问我HashMap原理，我从源码详细分析hashMap的实现原理

面试问我HashMap原理，我从源码详细分析hashMap的实现原理

HashMap源码系列 文章目录HashMap源码系列前言一、HashMap介绍&#xff1f;1.首先了解什么是HashMap&#xff1f;二、源码分析1.Map接口&#xff1f;2.AbstractMap类&#xff1f;3.HashMap&#xff1f;核心一&#xff1a;容量核心二&#xff1a;加载因子核心三&#xff1a;链树…
阅读更多...
Mybatis开发提高效率插件之mybatisx，mybatis-plus使用

Mybatis开发提高效率插件之mybatisx，mybatis-plus使用

mybatisx安装和使用 mybatisx主要作用： 自动生成代码功能，包含自动生成数据库实体和XML配置文件，根据Mapper的接口方法名自动生成xml配置Mapper接口与xml自动跳转功能mybatisx需要配合mybatis-plus一起使用，工程需要引入mybatis-plus，引入了mybatis-plus后就无须单独myba…
阅读更多...
C#关于JSON的使用

C#关于JSON的使用

Json和实体对象的转换 注意： （1）一般情况不使用加密，若要使用加密请进行验证以免出现错误； （2）大量数据时尽量少用Json存储数据，Json适用于轻量级数据； （3）使用Json时需要添加依赖包，并引进命名空间； 1.安装依赖包 从包管理器添加Json依赖包， 2.引用Json的D…
阅读更多...
leetcode94-每日刷题档

leetcode94-每日刷题档

给定一个二叉树的根节点 root &#xff0c;返回它的 中序 遍历。 使用dfs 也是 终止条件 深度遍历 递归 public List<Integer> inorderTraversal(TreeNode root) {ArrayList<Integer> arr new ArrayList<>();dfs(arr,root);return arr;}private void dfs(…
阅读更多...
leetcode100相同的树-每日刷题档

leetcode100相同的树-每日刷题档

给你两棵二叉树的根节点 p 和 q &#xff0c;编写一个函数来检验这两棵树是否相同。 如果两个树在结构上相同&#xff0c;并且节点具有相同的值&#xff0c;则认为它们是相同的。 //递归终止条件public boolean isSameTree(TreeNode p, TreeNode q) {if(p null && q …
阅读更多...
leetcode19-每日刷题档

leetcode19-每日刷题档

删除链表的倒数地N个结点 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 public ListNode removeNthFromEnd(ListNode head, int n) {ListNode dummy new ListNode();dummy.next head;ListNode fast dummy, slow dummy;for (int …
阅读更多...
leetcode21经典题目-每日刷题档

leetcode21经典题目-每日刷题档

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 合并两个有序链表 思路&#xff1a; 使用递归 一个个进行比较移动 谁小谁移动 public ListNode mergeTwoLists(ListNode l1, ListNode l2) {if (l1 null) {return l2;} el…
阅读更多...
国庆节也来刷刷题！力扣:148. 排序链表

国庆节也来刷刷题！力扣:148. 排序链表

题目&#xff1a;力扣 题目要求nlgn的时间复杂度完成排序。 那么时间复杂度为nlgn的排序算法大概有三种&#xff1a; 1.快排 2.堆排 3.归并 快排不怎么合适&#xff0c;需要不停地交换结点&#xff0c;而且还需要维护双指针&#xff0c;可能不太合适 堆排更不太合适了&am…
阅读更多...
力扣：142. 环形链表 II

力扣：142. 环形链表 II

题目转载自&#xff1a;力扣 分析&#xff1a; 这一题题目要求使用O&#xff08;1&#xff09;的时间复杂度来解。 然后大概有两种解法来做&#xff0c;下面分别来介绍一下&#xff1a; 首先判断链表是否有环&#xff0c;如果有环的话&#xff0c;先将指针定位到环内&#…
阅读更多...
【数据结构】—— 无头单向不循环链表相关接口实现

【数据结构】—— 无头单向不循环链表相关接口实现

一、链表基本概念 1、链表的分类&#xff08;8种&#xff09; 单向 | 双向有头 | 没有头有循环 | 无循环可随机组合 2、顺序表与链表的区别 3、相关接口介绍 接口功能void SListInit(SList* plist)初始化链表void SListDstory(SList* plist)销毁链表SListNode* BuySListNod…
阅读更多...
链表实现多项式加法与乘法

链表实现多项式加法与乘法

链表实现加法与乘法 构建一个链表 typedef struct LinkNode{int coef;//系数int expn;//幂指数LinkNode *next; }LinkNode,*LinkList;为了使得直接可以更好的查看输出结果&#xff0c;顺便写一个show函数用来展示结果 void show(LinkList L){//输出多项式链表结点&#xff…
阅读更多...
【leetcode】高频题目整理_链表篇( High Frequency Problems, Linked List )

【leetcode】高频题目整理_链表篇( High Frequency Problems, Linked List )

截止至今LeetCode题目总量已经有1582题&#xff0c;估计将来每年平均增长300题左右&#xff0c;大部分人肯定是刷不完的&#xff0c;所以得有选择地刷LeetCode。 一种公认的刷题策略是按类别刷题&#xff0c;可是每个类别也有许多题&#xff0c;在有限的时间里到底该刷哪些题呢…
阅读更多...
java实现双链表

java实现双链表

文章目录1. 结点类2. 定义DoubleLinkedList类 操作链表方法3. 测试双链表1. 结点类 //定义HeroNode&#xff0c;每个HeroNode对象就是一个结点 class HeroNode2 {public int no;public String name;public String nickname;public HeroNode2 next; // 指向下一个结点public H…
阅读更多...
双向循环链表简单的插入、删除、修改以及查找功能的实现

双向循环链表简单的插入、删除、修改以及查找功能的实现

1“ include include define T 1 define F 0 typedef int ElementType; typedef int Boolean; typedef struct node* Node; struct node //定义双向的结构体 { struct node* prior; ElementType value; struct node* next; }; Boolean make(Node *head);//创建…
阅读更多...
Leetcode链表题目总结

Leetcode链表题目总结

刷题是应届生找工作不可缺少的部分&#xff0c;一种公认的刷题策略是按类别刷题&#xff0c;可是每个类别也有许多题&#xff0c;在有限的时间里到底该刷哪些题呢&#xff1f;个人根据LeetCode官方给出的每个题目的出现频率&#xff0c;整理并收录了每个类别里高频出现的题目&a…
阅读更多...
剑指offer输出链表的倒数第k个节点JAVA

剑指offer输出链表的倒数第k个节点JAVA

输入一个键表&#xff0c;输出该链表中倒数第k个结点 * 本题从1开始计数&#xff0c;即链表的尾结点是倒数第1个结点&#xff0e;例如一个链表有6个结点&#xff0c; * 从头结点开始它们的值依次是1、2、3、4、5 6。这个链表的倒数第3个结点是值为4的结点&#xff0e; */public…
阅读更多...
栈概念及代码实现

栈概念及代码实现

目录 栈的引入 概念 栈的引入 undo操作&#xff0c; 浏览器页面回退到上一层&#xff0c; 或者大家平时用的ctrlz都是栈顶元素出栈操作&#xff0c;恢复上一个状态 概念 栈是一个线性表&#xff0c;底层既可以用数组&#xff0c;也可以用链表 基于数组实现的栈——顺序栈…
阅读更多...
49 合并两个排序链表（Merge Two Sorted Lists）

49 合并两个排序链表（Merge Two Sorted Lists）

文章目录1 题目2 解决方案2.1 思路2.2 时间复杂度2.3空间复杂度3 源码1 题目 题目&#xff1a;合并两个排序链表&#xff08;Merge Two Sorted Lists&#xff09; 描述&#xff1a;将两个排序&#xff08;升序&#xff09;链表合并为一个新的升序排序链表。 lintcode题号——1…
阅读更多...
46 带环链表（Linked List Cycle）

46 带环链表（Linked List Cycle）

文章目录1 题目2 解决方案2.1 思路2.3 时间复杂度2.4 空间复杂度3 源码1 题目 题目&#xff1a;带环链表&#xff08;Linked List Cycle&#xff09; 描述&#xff1a;给定一个链表&#xff0c;判断它是否有环。 链表长度不超过10000 lintcode题号——102&#xff0c;难度——…
阅读更多...
43 翻转链表II（Reverse Linked List II）

43 翻转链表II（Reverse Linked List II）

文章目录1 题目2 解决方案2.1 思路2.2 时间复杂度2.3 空间复杂度3 源码1 题目 题目&#xff1a;翻转链表II&#xff08;Reverse Linked List II&#xff09; 描述&#xff1a;翻转链表中第 m 个节点到第 n 个节点的部分。m&#xff0c;n满足1 ≤ m ≤ n ≤ 链表长度 lintcode题…
阅读更多...
剑指offer头插法反转链表JAVA实现

剑指offer头插法反转链表JAVA实现

头插法实现链表的反转 定义一个新的root节点作为新链表的头&#xff0c;然后定义一个next记录当前节点的next域&#xff0c;然后遍历链表&#xff0c;next记录head的下一节点&#xff0c;头节点指向root的next节点&#xff0c;root的next节点执相头节点&#xff0c;然后再把头…
阅读更多...
Java 对LinkedList进行遍历的方法性能比较

Java 对LinkedList进行遍历的方法性能比较

Java 对LinkedList进行遍历的方法性能比较测试代码&#xff1a;运行结果&#xff1a;分析&#xff1a;总结&#xff1a;测试代码&#xff1a; 分别使用了①iterator迭代器、②普通的for循环get方法、③增强型的for循环对list进行遍历 package club.jming.test;import java.ut…
阅读更多...
【阿里云训练营】python查漏补缺 1

【阿里云训练营】python查漏补缺 1

文章来自微信公众号&#xff1a;【机器学习炼丹术】。欢迎大家关注&#xff0c;是我的个人学习干活分享基地。干货文章100 文章目录1 注释2 is 与 3 运算优先级4 查找所有属性和方法5 type和isinstance36 位运算6.1 原码、反码和补码6.2 按位运算6.3 利用位运算实现快速计算6.4…
阅读更多...
力扣203题---反转链表

力扣203题---反转链表

给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&#xff1a;[2,1]示例 3&#xff1a; 输…
阅读更多...
复制带随机指针的链表-链表138-python

复制带随机指针的链表-链表138-python

算法思想 哈希表Mydic映射原有节点->新的节点原节点为空&#xff0c;则返回空原节点在哈希表中可以找到&#xff0c;则说明新的节点已生成&#xff0c;直接返回根据原有节点的值&#xff0c;创建新的节点root Node(node.val)将原有节点和新节点的对应关系添加到哈希表中My…
阅读更多...
第三十四期-ARM Linux内核的中断（4）

第三十四期-ARM Linux内核的中断（4）

作者&#xff1a;罗宇哲&#xff0c;中国科学院软件研究所智能软件研究中心 上一期中我们介绍了ARM Linux内核中外设中断处理的部分流程&#xff0c;这一期我们将继续介绍ARM Linux内核的外设中断处理流程中与中断描述符相关的部分。 一、ARM Linux内核的中断描述符 上一期我…
阅读更多...
线性表的链式存储--单链表

线性表的链式存储--单链表

Java之线性表的链式存储——单链表 我们都知道&#xff0c;线性表的存储结构分为两种&#xff0c;顺序存储结构和链式存储结构&#xff0c;线性表的分类可以参考下图来学习记忆。今天我们主要来学习一下链式存储结构。 一、链式存储介绍 “链式存储结构&#xff0c;地址可以连…
阅读更多...
leetcode 22 括号生成

leetcode 22 括号生成

题目&#xff1a;数字 n 代表生成括号的对数&#xff0c;请你设计一个函数&#xff0c;用于能够生成所有可能的并且 有效的 括号组合。 示例 1&#xff1a; 输入&#xff1a;n 3 输出&#xff1a;["((()))","(()())","(())()","()(())&qu…
阅读更多...
c语言（链表）

c语言（链表）

链表比数组的优点是&#xff0c;方便增删&#xff1b;因为数组中的元素都是连续的&#xff0c;增删起来非常不便。 #include <stdio.h>struct Students {int score;struct Students *p; };int main() {struct Students stu1 {29,NULL};struct Students stu2 {69,NULL}…
阅读更多...
PHP数组和链表的区别

PHP数组和链表的区别

PHP 数组和链表是两种不同的数据结构&#xff0c;它们有以下区别&#xff1a; 1、存储方式&#xff1a;数组是一种连续的内存块&#xff0c;每个元素的位置都可以通过索引来计算得到&#xff0c;而链表则是一种非连续的数据结构&#xff0c;每个节点存储了指向下一个节点的指针…
阅读更多...
数据结构——链表实现两个多项式加减乘除

数据结构——链表实现两个多项式加减乘除

任务概述&#xff1a; 使用链表实现两个多项式的基本操作。初级要求&#xff1a;实现加法、减法和微分操作。高级要求&#xff1a;实现乘法和除法操作。&#xff08;除法操作中&#xff0c;当不能除尽时还要求列出余式。&#xff09; 要点&#xff1a; 链表中的每个结点形式如…
阅读更多...
cJSON的使用

cJSON的使用

cJSON是一个仅有一个.h文件&#xff0c;一个.c文件组成的JSON解析器&#xff0c;它是由纯C(ANSI C89)实现的&#xff0c;跨平台性较好。cJSON是采用链表存储的。 表示&#xff1a; 以"{“开始&#xff0c;以”}"结束 数据在键/值对中&#xff1b; 数据由逗号分开&…
阅读更多...
C语言：L2-002 链表去重 (25 分)

C语言：L2-002 链表去重 (25 分)

文章目录一、题目二、方法11、思路2、代码一、题目 给定一个带整数键值的链表 L&#xff0c;你需要把其中绝对值重复的键值结点删掉。即对每个键值 K&#xff0c;只有第一个绝对值等于 K 的结点被保留。同时&#xff0c;所有被删除的结点须被保存在另一个链表上。例如给定 L 为…
阅读更多...
leetcode 203.移除链表元素

leetcode 203.移除链表元素

⭐️ 题目描述 &#x1f31f; leetcode链接&#xff1a;移除链表元素 1️⃣ 代码&#xff1a; /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*//*思路1&#xff1a;遍历链表&#xff0c;同时用另一个指针记录当…
阅读更多...
java 题库

java 题库

用最有效的方法算出2乘以8等于几 2<<<3 Math.round(11.5)和Math.round(-11.5)的值是多少&#xff1f; 12 -11 两个对象a和b,请问ab和a.equals(b)有什么区别 ab比较对象地址值 a.equals(b) 比较对象地址值 a重写了就按重写的规则比较switch是否能作用在byte上 ,市否…
阅读更多...
环形链表操作（c++）

环形链表操作（c++）

给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;索引从 0 开始&#xff09;&#xff0c;如果 pos 是 -1&#xff0c;则在该链表中没有环。 &#xff08;1&#xff09…
阅读更多...
【数据结构】前缀树

【数据结构】前缀树

前缀树的定义 前缀树是N叉树的特殊形式&#xff0c;用于存储字符串。前缀树的每个节点代表一个字符串/前缀。每个节点拥有几个子节点&#xff0c;子节点的值由该结点的值和通往该节点路径上所有的字符组成。 特性: 节点的后代都与该节点相关的字符串具有相同的前缀。 前缀树的…
阅读更多...
算法竞赛中的常用JAVA API ：ArrayList(Vector) 和 LinkedList

算法竞赛中的常用JAVA API ：ArrayList(Vector) 和 LinkedList

文章目录摘要&#xff1a;ArrayList构造方法增加元素删除元素修改元素查找元素容器大小判空转化为数组转化为字符串拷贝实例LinkedListArrayList的遍历stack和queue了解其他JAVA 常用API和算法点这里 >> https://blog.csdn.net/GD_ONE/article/details/104061907 摘要&a…
阅读更多...
简单实现双链表---学习

简单实现双链表---学习

链表的创立过程&#xff0c;其实即位小朋友玩的“手拉手”游戏&#xff0c;你拉着我&#xff0c;我拉着你&#xff0c;这样循环下去。 链表的创立&#xff1a;--数据类型 这里以‘#’来表示结束 Node * CreateList() { Node *temp,*p; p(Node*)malloc(sizeof(Node)); tempp; …
阅读更多...
C语言课程设计——学生信息管理系统

C语言课程设计——学生信息管理系统

学生信息管理系统——课程设计 使用C语言结构体&#xff0c;链表编写&#xff0c;实现了txt文本的读入和输出。角色分为普通用户和管理员 。系统初始化则到如用户数据 结构体设计及部分代码如下&#xff1a; #include<stdio.h> #include<string.h> #include<m…
阅读更多...
删除链表相邻重复的节点

删除链表相邻重复的节点

删除链表相邻重复的节点 private static class ListNode {private int val;private ListNode next;public ListNode() {}public ListNode(int val) {this.val val;}Overridepublic String toString() {return val "";}}private static ListNode deleteDuplication…
阅读更多...
给定单向链表的头指针和一个结点指针，定义一个函数在0(1)时间删除该结点,

给定单向链表的头指针和一个结点指针，定义一个函数在0(1)时间删除该结点,

给定单向链表的头指针和一个结点指针&#xff0c;定义一个函数在0(1)时间删除该结点,​​​​​​​public static ListNode deleteNode(ListNode head, ListNode toBeDeleted) {// 如果输入参数有空值就返回表头结点if (head null || toBeDeleted null) {return head;}// 如…
阅读更多...
C语言_链表_建一个链表

C语言_链表_建一个链表

# include <stdio.h> # include <malloc.h> # include <stdlib.h>struct Node {int data; //数据域struct Node * pNext; //指针域 };//函数声明 struct Node * create_list(void); void traverse_list(struct Node *);int main(void) {struct Node * pHead…
阅读更多...
Python数据结构与算法——线性结构总结

Python数据结构与算法——线性结构总结

文章目录线性结构总结栈 Stack队列 queue双端队列 dequeue链表线性结构总结 栈、队列、双端队列、链表以及其应用 文章收录于公众号&#xff1a;<小杨的python之路>Github&#xff1a;Python数据结构与算法 栈 Stack 栈stack维持了数据项后进先出LIFO的次序 书写表达式…
阅读更多...
链表增删元素原理详解

链表增删元素原理详解

通过使用链表&#xff0c;可以更加高效地对数组数据&#xff08;元素&#xff09;进行追加和删除处理。而通过使用二叉查找树&#xff0c;则可以更加高效地对数组数据进行检索。 在数组的各个元素中&#xff0c;除了数据的值之外&#xff0c;通过为其附带上下一个元素的索引&a…
阅读更多...
排序链表-链表148-python

排序链表-链表148-python

算法思想 考察合并两个有序链表和将链表平均拆分成两组(归并需要)&#xff0c;再利用归并思想进行排序即可。 python # Definition for singly-linked list. # class ListNode: # def __init__(self, val0, nextNone): # self.val val # self.next ne…
阅读更多...
设计链表-链表707-C++

设计链表-链表707-C++

算法思想&#xff1a; 没看答案&#xff0c;用单链表实现的&#xff0c;考察的是对链表的增删插入基本操作。 C class MyLinkedList { private:struct ListNode{int val;ListNode* next;ListNode(int a, ListNode* next) : val(a), next(next){};ListNode(int a) : val(a), …
阅读更多...
移除链表元素-链表203-C++python

移除链表元素-链表203-C++python

算法思想&#xff1a; 没看答案&#xff1a; 先声明哨兵节点pre防止head头节点的值等于val的情况&#xff1b;声明快慢指针slow和fast&#xff0c;当fast不等于val时&#xff0c;slow fast&#xff0c; fast前进到fast->next&#xff1b;当fast等于val时&#xff0c;slow…
阅读更多...
重排链表-链表143-C++

重排链表-链表143-C++

算法思想&#xff1a; 线性表&#xff1a; /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(int x) : val(x), next(nullptr) {}* ListNode(int x, ListNode…
阅读更多...
奇偶链表-链表328-pythonC++

奇偶链表-链表328-pythonC++

没看答案 不理解的可以画图&#xff0c;按步骤用图解去理解。 但该方法在OJ上效果很差。 class Solution:def oddEvenList(self, head):len curr headlength 0# 遍历一遍链表&#xff0c;记录链表长度while len:len len.nextlength 1for i in range(length//2):temp cu…
阅读更多...
#Linux中的GCC编程# 学生系统

#Linux中的GCC编程# 学生系统

C 学生管理系统&#xff08;MVC架构&#xff09; 1、代码获取 代码下载地址&#xff1a;https://github.com/Kshine2017/My_GCC/tree/student 2、代码结构 [rootlocalhost Kshine]# tree student student ├── bin │ └── main ├── include │ ├── include…
阅读更多...
Java数据结构习题：(该程序用递归实现)编写一个RecursionMax（)，返回链表中数值最大的结点的值（假设所有数据都是正整数，如果链表为空则返回0）

Java数据结构习题：(该程序用递归实现)编写一个RecursionMax（)，返回链表中数值最大的结点的值（假设所有数据都是正整数，如果链表为空则返回0）

(该程序用递归实现)编写一个RecursionMax&#xff08;)&#xff0c;返回链表中数值最大的结点的值&#xff08;假设所有数据都是正整数&#xff0c;如果链表为空则返回0&#xff09; 核心代码&#xff1a; // (该程序用递归实现)编写一个RecursionMax&#xff08;)&#xff0c…
阅读更多...
严蔚敏数据结构 P36页 算法2.18——双向链表的插入

严蔚敏数据结构 P36页 算法2.18——双向链表的插入

严蔚敏数据结构 P36页——双向链表的插入 /* 严蔚敏数据结构 P36页——双向链表的插入 *///头文件 #include<stdio.h> #include<stdlib.h>//结构 typedef struct st { int data; //数据域struct st *TOP; //前置指针struct st *NEXT…
阅读更多...
严蔚敏数据结构C语言版的静态链表的更改功能（采用严书思想自行敲写出的程序）——中职

严蔚敏数据结构C语言版的静态链表的更改功能（采用严书思想自行敲写出的程序）——中职

本程序采用 严蔚敏数据结构C语言版的思想进行编写的程序 是书中没有的 静态链表的更改程序 由于是本人根据自己的思想理解单独敲出的&#xff0c;所以会有漏洞&#xff0c;仅供参考理解。 /* 本程序采用 严蔚敏数据结构C语言版的思想进行编写的程序是书中没有的静态链表的更…
阅读更多...
3.2栈和队列——链栈基本操作的实现

3.2栈和队列——链栈基本操作的实现

注意&#xff1a;以下内容均省略思路&#xff0c;只有代码。此内容为本人学习过程中的一些学习记录&#xff0c;如有错误&#xff0c;恳请各位指正、建议&#xff0c;末学将感激不尽&#xff01; 目录 1.链栈的表示 2.链栈的初始化 3.判断链栈是否为空 4.链栈的入栈&#x…
阅读更多...
2.2线性表——单链表基本操作的实现

2.2线性表——单链表基本操作的实现

注意&#xff1a;以下内容均省略思路&#xff0c;只有代码和时间复杂度。此内容为本人学习过程中的一些学习记录&#xff0c;如有错误&#xff0c;恳请各位指正、建议&#xff0c;末学将感激不尽&#xff01; 目录 用结构指针描述单链表 初始化链表 判断空表 销毁单链表 清…
阅读更多...
严蔚敏数据结构C语言版的静态链表的查找（建立、分配、输出、查找）——中职

严蔚敏数据结构C语言版的静态链表的查找（建立、分配、输出、查找）——中职

严蔚敏数据结构C语言版 P32-33 算法2.13-2.15 静态链表的查找&#xff08;建立、分配、查找&#xff09;&#xff0c;因为执行查找的过程需要用到算法2.14-2.15,所以合并在一起 &#xff01;&#xff01;&#xff01;&#xff08;因为程序为自己理解打&#xff0c;思想差不多但…
阅读更多...
严蔚敏数据结构-单链表的增删改查即整表删除（综合程序（理解为主））——中职

严蔚敏数据结构-单链表的增删改查即整表删除（综合程序（理解为主））——中职

严蔚敏数据结构-单链表的增删改查即整表删除 (基于个人思想上的理解敲出的) 综合程序&#xff08;理解为主&#xff09; /* 严蔚敏数据结构-单链表的增删改查即整表删除 (基于个人思想上的理解敲出的)综合程序&#xff08;理解为主&#xff09; *///头文件 #include<stdio…
阅读更多...
单链表的整表建立__尾插法（推荐使用的方法）——中职

单链表的整表建立__尾插法（推荐使用的方法）——中职

本程序为提供可执行链表的必要环节&#xff0c;所以单独拎出来。 理解即可 尾插法&#xff08;推荐使用的方法&#xff09; /* 本程序为提供可执行链表的必要环节&#xff0c;所以单独拎出来。 理解即可尾插法&#xff08;推荐使用的方法&#xff09; *///头文件 #include<…
阅读更多...
链表基本概念

链表基本概念

目录 一、链表 二、链表的分类 2.1 链表分为&#xff1a;静态链表和动态链表 2.2 带头和不带头链表 2.3 单向链表、双向链表、循环链表 三、链表总结 一、链表 链表是一种常用的数据结构&#xff0c;它通过指针将一些列数据结点&#xff0c;连接成一个数据链。相对于数…
阅读更多...
【每日一题】环形链表-4种解法（3种击败100%的人）

【每日一题】环形链表-4种解法（3种击败100%的人）

文章目录题目描述示例&#xff1a;方法一&#xff1a;快慢指针方法二&#xff1a;删除自身结点方法三&#xff1a;利用循环链表反转后的头节点不变的特性题目描述 示例&#xff1a; 方法一&#xff1a;快慢指针 这把方法是同时建立两个指针&#xff0c;开始都指向头结点&#…
阅读更多...
数据结构基础：链式有序表的合并

数据结构基础：链式有序表的合并

链式有序表的合并 1.简单描述&#xff1a; 线性表LA和LB中的数据元素按值非递减有序排列&#xff0c;现要求将LA和LB归并为一个新的线性表LC&#xff0c;且LC中的数据元素仍按值非递减有序排序。 A&#xff08;3&#xff0c;5&#xff0c;8&#xff0c;11&#xff09; B&…
阅读更多...
Kubernetes扩展插件 Cluster DNS安装

Kubernetes扩展插件 Cluster DNS安装

Kubernetes扩展插件 Cluster DNS安装 回到master机器 10.99.0.10 skydns配置文件所在目录(本例子使用getting-started-guides目录下的文件) [rootvultr ~]# find -name *skydns* ./kubernetes/cluster/libvirt-coreos/skydns-rc.yaml ./kubernetes/cluster/libvirt-coreos/skyd…
阅读更多...
CCF——202012-5星际旅行

CCF——202012-5星际旅行

加法没超限&#xff0c;取模貌似会浪费时间 70分代码 #include <bits/stdc.h> using namespace std; typedef long long ll; const ll mod1e97; int n,m; struct stu{ll x0,y0,z0;}node[100005]; int main() { cin>>n>>m;ll r,l,op,k,a,b,c;for(int i0;i<…
阅读更多...
循环链表实现约瑟夫问题 数据结构 C/C++

循环链表实现约瑟夫问题 数据结构 C/C++

循环链表实现约瑟夫问题1.打印序列2.主函数3.循环链表基本操作1.打印序列 void PrintCList(CLinkList &L,int n){//约瑟夫问题 叫n出列int i L->data; //获取长度int j 0;CLinkList p L->next; //设置初始指针指向第一个元素CLinkList t L; //指向p的前一元素CL…
阅读更多...
循环链表实现及基本操作 数据结构C语言版

循环链表实现及基本操作 数据结构C语言版

循环链表实现0.初始定义1.尾插法创建循环链表并输入数据2.遍历输出3.获取元素值4.插入操作5.删除操作6.判断是否为空0.初始定义 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 typedef int Status; typedef int El…
阅读更多...
LeetcCode146之LRU 缓存机制（相关话题：双向链表，哈希表）

LeetcCode146之LRU 缓存机制（相关话题：双向链表，哈希表）

目录 题目描述 解题思路 代码实现 python版代码 相关知识点总结 题目描述 运用你所掌握的数据结构&#xff0c;设计和实现一个 LRU (最近最少使用) 缓存机制 。实现 LRUCache 类&#xff1a; LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存 int ge…
阅读更多...
循环单链表区间删除 C语言版（PTA）

循环单链表区间删除 C语言版（PTA）

** 本题要求实现带头结点的循环单链表的创建和单链表的区间删除。L是一个带头结点的循环单链表&#xff0c;函数ListCreate_CL用于创建一个循环单链表&#xff0c;函数ListDelete_CL用于删除取值大于min小于max的链表元素。** 函数接口定义&#xff1a; Status ListCreate_CL(…
阅读更多...
链表力扣203题---移除链表元素

链表力扣203题---移除链表元素

203 移除链表元素 题目&#xff1a;给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 解法一 虚拟头结点 删除一个节点你要想到的代码&#xff1a;head.nexthead.next.next; 即找到该结…
阅读更多...
[JAVA]ArrayList,LinkedList的特性

[JAVA]ArrayList,LinkedList的特性

ArrayList: 底层数据结构是数组&#xff0c;特点是长度可变&#xff0c;通过索引访问&#xff0c;有序&#xff0c;根据下标遍历元素&#xff0c;效率高。 LinkedList: 是一个双向链表&#xff0c;当数据量大或者很频繁的情况下&#xff0c;添加和删除元素时具有比ArrayList更好…
阅读更多...
Java数据结构与算法之链表删除操作

Java数据结构与算法之链表删除操作

一、链表的定义 链表是数据结构中线性结构中最为重要的数据结构&#xff0c;关于Java链表的定义以及数据实例化&#xff0c;请查看数据结构之数组和链表&#xff08;Java语言描述&#xff09;。 二、删除元素操作 在介绍删除元素之前&#xff0c;我先对数据进行进行节点实例…
阅读更多...
Java数据结构与算法之链表插入操作

Java数据结构与算法之链表插入操作

一、链表的定义 链表是数据结构中线性结构中最为重要的数据结构&#xff0c;关于Java链表的定义以及数据实例化&#xff0c;请查看数据结构之数组和链表&#xff08;Java语言描述&#xff09;。 二、插入元素操作 在介绍插入元素之前&#xff0c;我先对数据进行进行节点实例…
阅读更多...
Java数据结构的实现

Java数据结构的实现

文章目录一、Java数据结构二、数据结构之数组和链表&#xff08;Java语言描述&#xff09;1、Java数组1.初始化数组2.直接赋值3.可变数组2、链表1.节点定义2.实例化节点三、数据结构之树和图&#xff08;Java语言描述&#xff09;1、树和图2、树1.树的节点创建2.创建树3、图1.邻…
阅读更多...
C++实现链式栈

C++实现链式栈

#include <stdio.h> #include <malloc.h>typedef struct SNode {int data;struct SNode *next; } * PNode, Node;typedef struct SStack {PNode pBottom;PNode pTop; } * PStack, Stack;//初始化栈 void init(PStack); // 压栈 void push(PStack, int); // 出栈 bo…
阅读更多...
剑指 offer acwing 36 合并两个排序的链表

剑指 offer acwing 36 合并两个排序的链表

题面 题解 本题考查两路归并&#xff0c;我们可以用两个指针&#xff0c;新开一个虚拟节点&#xff0c;通过比较两个链表值的大小来移动指针&#xff0c;最后肯定有一个链表的指针到最后&#xff0c;然后将剩下一个链表的值复制即可 代码 /*** Definition for singly-linked l…
阅读更多...
剑指 offer acwing 35. 反转链表

剑指 offer acwing 35. 反转链表

题面 题解 我们可以新定义一个指针&#xff0c;用于指向单链表的前一个节点&#xff0c;初始化为空&#xff0c;每次遍历时&#xff0c;我们让当前节点的next指向pre&#xff08;上一个节点&#xff09;&#xff0c;然后pre变成cur&#xff08;当前节点&#xff09;&#xff0c…
阅读更多...
数据结构之顺序结构：数组、链表

数据结构之顺序结构：数组、链表

顺序数据结构 数据之间的关系可以非为&#xff1a;一对一&#xff1b;一对多&#xff1b;多对一和多对多。对于一般数据结构关系中&#xff0c;一对一的对应关系最多。而一对一的数据结构关系&#xff0c;我们通常定义其为数据的顺序结构或者数据的顺序储存方式。最常见的数据…
阅读更多...
2.22--【线性表】应用—一元多项式的表示及相加

2.22--【线性表】应用—一元多项式的表示及相加

【线性表】应用—一元多项式的表示及相加 typedef struct polynode {int coef;int exp;polynode* next; }polynode,*polylist;例&#xff1a;建立一元多项式链式存储算法 【算法思想】通过键盘输入一组多项式的系数和指数&#xff0c;用尾插法建立一元多项式的链表。以输入系数…
阅读更多...
剑指 offer acwing 29 删除链表中重复的节点

剑指 offer acwing 29 删除链表中重复的节点

题面 题解 对于可能删除头节点的链表&#xff0c;我们一般先定义一个虚拟的头节点来处理边界问题 然后从前往后扫描整个链表&#xff0c;每次扫描元素相同的一段&#xff0c;如果这段中的元素个数多于1个&#xff0c;则将整段元素直接删除。 O(n) 代码 /*** Definition for si…
阅读更多...
关于CAS等原子操作

关于CAS等原子操作

#关于CAS等原子操作 在开始说无锁队列之前&#xff0c;我们需要知道一个很重要的技术就是CAS操作——Compare & Set&#xff0c;或是 Compare & Swap&#xff0c;现在几乎所有的CPU指令都支持CAS的原子操作&#xff0c;X86下对应的是 CMPXCHG 汇编指令。有了这个原子操…
阅读更多...
2.12-静态链表基本操作详解

2.12-静态链表基本操作详解

静态链表基本操作详解 静态链表&#xff0c;也是线性存储结构的一种&#xff0c;它兼顾了顺序表和链表的优点于一身&#xff0c;可以看做是顺序表和链表的升级版 使用静态链表存储数据&#xff0c;数据全部存储在数组中&#xff08;和顺序表一样&#xff09;&#xff0c;但存储…
阅读更多...
2.11-俩个有序链表并为一个有序链表

2.11-俩个有序链表并为一个有序链表

俩个有序链表并为一个有序链表 LinkList Union(LinkList &A,LinkList& B, LinkList& C)//链表的合并函数{LinkList a, b,c;a A->next;b B->next;cC;while (a && b){if (a->data > b->data) {c->next b;c b;b b->next;}else {c-…
阅读更多...
数据结构之栈和队列(双向链表及数组实现)

数据结构之栈和队列(双向链表及数组实现)

数据结构之栈和队列(双向链表及数组实现) 逻辑概念&#xff1a; 栈&#xff1a;数据先进先出&#xff0c;犹如弹匣队列&#xff1a;数据先进先出&#xff0c;好似排队 1. 栈和队列的实现&#xff08;Java&#xff09; 双向链表实现&#xff08;对链表不熟悉的可以看我的另一篇…
阅读更多...
数据结构之单向链表与双向链表-简单介绍与练习

数据结构之单向链表与双向链表-简单介绍与练习

数据结构之单向链表与双向链表-简单介绍与练习 1. 单向链表 单向链表中&#xff0c;前一个节点保存着下一个节点的内存地址&#xff0c;下一个节点保存着下下个节点的内存地址&#xff0c;… &#xff0c;最后一个节点后指向null 单向链表在数据的搜寻过程中&#xff0c;只能按…
阅读更多...
剑指Offer系列之「删除链表中重复的节点」

剑指Offer系列之「删除链表中重复的节点」

在一个排序的链表中&#xff0c;存在重复的结点&#xff0c;请删除该链表中重复的结点&#xff0c;重复的结点不保留&#xff0c;返回链表头指针。 例如&#xff0c;链表1->2->3->3->4->4->5 处理后为 1->2->5 这是一个双指针问题&#xff0c;在遍历单…
阅读更多...
剑指Offer系列之「链表中倒数第 k 个节点」

剑指Offer系列之「链表中倒数第 k 个节点」

方法一&#xff1a;普遍解法 首先先遍历链表&#xff0c;求得链表的长度 len 链表的倒数第k个节点&#xff0c;其实就是正向索引为len-k的节点 此外需要考虑k的值&#xff0c;当k的值大于链表的长度&#xff0c;返回null 时间复杂度&#xff1a;O(n)&#xff0c;需要遍历数组…
阅读更多...
实验室第一次考核

实验室第一次考核

实验室第一次考核 这次考核过后发现了自己暴露了一些问题&#xff0c;在二维数组这一部分掌握的不是很好&#xff0c;无论是二维数组指针还是做二维数组螺旋矩阵的编程题&#xff0c;掌握的都不是特别好&#xff0c;还是查漏补缺&#xff0c;继续努力吧&#xff01; 一&#x…
阅读更多...
单向链表（数据防止误操作）

单向链表（数据防止误操作）

C/CLinux服务器开发/后台架构师【零声教育】-学习视频教程-腾讯课堂 防止用户能在主程序对链表内数据进行修改&#xff1a;用void* 修饰数据&#xff0c;回调函数来遍历数据。 代码如下&#xff1a; LinkList.h #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #…
阅读更多...
单链表的整表建立__头插法(逆序输出)（不推荐）——中职

单链表的整表建立__头插法(逆序输出)（不推荐）——中职

本程序为提供可执行链表的必要环节&#xff0c;所以单独拎出来。 理解即可 头插法(逆序输出)&#xff08;不推荐&#xff09; /* 本程序为提供可执行链表的必要环节&#xff0c;所以单独拎出来。 理解即可头插法(逆序输出)&#xff08;不推荐&#xff09; *///头文件 #includ…
阅读更多...
严蔚敏数据结构C语言版（两个有序链表并为一个有序链表）(用户自己输入有序的链表！)(功能体系较为完善建议认真理解本程序)——中职

严蔚敏数据结构C语言版（两个有序链表并为一个有序链表）(用户自己输入有序的链表！)(功能体系较为完善建议认真理解本程序)——中职

严蔚敏数据结构C语言版 P31 算法2.11 两个有序链表并为一个有序链表(用户自己输入有序的链表&#xff01;)(功能体系较为完善建议认真理解本程序) /* 严蔚敏数据结构C语言版 P31 算法2.11两个有序链表并为一个有序链表(用户自己输入有序的链表&#xff01;)(功能体系较为完善…
阅读更多...
【每天学习亿点点系列】——单链表OJ题

【每天学习亿点点系列】——单链表OJ题

&#x1f4a5;【每天学习亿点点系列】——单链表OJ题1. 链表的回文结构题目方法一&#xff1a;翻转后半段&#xff0c;与前半段对比代码实现方法二&#xff1a;数组法&#xff08;不推荐&#xff09;代码实现2.相交链表题目解决方法代码实现3.环形链表解决方法代码实现1. 链表的…
阅读更多...
严蔚敏数据结构C语言版的单链表头插法（逆序输出）（纯敲代码）——中职

严蔚敏数据结构C语言版的单链表头插法（逆序输出）（纯敲代码）——中职

严蔚敏数据结构C语言版的头插法&#xff08;逆序输出&#xff09; /* 严蔚敏数据结构C语言版 P31 算法2.11 逆位序输入n个元素的值&#xff0c;建立带表头结点的单链线性表L因与尾插法的区别不大&#xff0c;所以初始化的过程搬运过来。重点在于头插法&#xff08;逆序输出&am…
阅读更多...
严蔚敏C语言版的单链表删除操作（纯敲代码）——中职

严蔚敏C语言版的单链表删除操作（纯敲代码）——中职

严蔚敏C语言版的删除操作 /* 严蔚敏数据结构C语言版 P30 算法2.10 在带头结点的单链线性表L中&#xff0c;删除第i个元素 *///头文件 #include<stdio.h> #include<malloc.h> #include<stdlib.h>//结构 typedef struct LIST //该链表的结构 {int …
阅读更多...
leetcode 876.链表的中间结点(快慢指针问题)

leetcode 876.链表的中间结点(快慢指针问题)

⭐️ 往期相关文章 &#x1f4ab; 链接1&#xff1a;leetcode 206.反转链表 &#x1f4ab; 链接2&#xff1a;leetcode 203.移除链表元素 &#x1f4ab; 链接3&#xff1a;数据结构-手撕单链表代码详解 ⭐️ 题目描述 &#x1f31f; leetcode链接&#xff1a;链表的中间结点 …
阅读更多...
严蔚敏数据结构C语言版的单链表的查找功能（纯敲代码）——中职

严蔚敏数据结构C语言版的单链表的查找功能（纯敲代码）——中职

严蔚敏数据结构C语言版&#xff08;链表的查找功能&#xff09; /* 严蔚敏数据结构C语言版 P29 算法2.8 查找第 i 个位置的单链表数据 *///头文件 #include<stdio.h> #include<stdlib.h>//结构 typedef struct List {int data; //数据域struct List * Ne…
阅读更多...
刷题笔记----每日一题：力扣142. 环形链表 II

刷题笔记----每日一题：力扣142. 环形链表 II

思路&#xff1a;还是用快慢指针&#xff0c;首先判断链表是否有环&#xff0c;如果fast->next为空&#xff0c;说明没环&#xff0c;如果有环&#xff0c;当两个指针相遇时&#xff0c;快指针比慢指针多在环里转了一圈&#xff08;这样他们才能相遇&#xff09; 如下图&…
阅读更多...
刷题笔记----每日一题：力扣19. 删除链表的倒数第 N 个结点

刷题笔记----每日一题：力扣19. 删除链表的倒数第 N 个结点

看到题目&#xff0c;我们立马可以想到链表中size-n的位置就是要删除的节点&#xff0c;所以可以先遍历一边链表找到size的值&#xff0c;然后在遍历到size-n的位置&#xff0c;将其删除即可&#xff0c;但是这种方法遍历了两次链表&#xff0c;能不能只遍历一次链表呢&#xf…
阅读更多...
将单向链表按某值划分成左边小、中间相等、右边大的形式

将单向链表按某值划分成左边小、中间相等、右边大的形式

题目描述 给定一个单向链表的头节点head&#xff0c;节点的值类型是整型&#xff0c;再给定一个整数pivot。实现一个调整链表的函数&#xff0c;将链表调整为左部分都是值小于 pivot 的节点&#xff0c;中间部分都是值等于pivot的节点&#xff0c;右部分都是值大于 pivot的节点…
阅读更多...
严蔚敏数据结构C语言版 线性表的增删改查功能（中职学习记录篇）（纯敲代码：完全自己敲的）

严蔚敏数据结构C语言版 线性表的增删改查功能（中职学习记录篇）（纯敲代码：完全自己敲的）

严蔚敏数据结构C语言版 线性表的增删改查功能&#xff08;完全自己敲的&#xff09; /* 严蔚敏数据结构C语言版 顺序线性表的综合程序&#xff08;增删改查&#xff09; *///头文件 #include<stdio.h> #include<malloc.h> #include<stdlib.h>//宏区 #define…
阅读更多...
树的存储结构和树森林的遍历

树的存储结构和树森林的遍历

1双亲表示法(用数组进行存储)&#xff1a;双亲表示法(顺序存储)&#xff1a;每个结点中保存指向双亲的指针 #define MAX_TREE_SIZE 100 //树中最多结点数typedef struct{ //树的结点定义ElemType data;int parent; }PTNode;typedef struct{PTNode nodes [ MAX_TREE_SIZE 100…
阅读更多...
栈的练习题

栈的练习题

1 写一个算法&#xff0c;判断所给的操作序列是否合法&#xff08;判断给定栈的出栈和入栈&#xff09;是否合法&#xff0c;合法返回true&#xff0c;不合法返回false bool Stack(&S){//错误代码&#xff0c;我的想法是用栈来进行&#xff0c;从栈的实际while(S!NULL){//…
阅读更多...
链表练习题

链表练习题

1设计一个递归算法&#xff0c;删除不带头节点的单链表&#xff0c;L中所有值为X的节点。 //错误代码没有实现递归栈 //不带头结点需要考虑第一个元素,又因为删除的关系需要考虑最后一个元素 bool DelEete_x(LinkList &*L,ElemType x){LinkList r L;if(r!NULL){return tru…
阅读更多...
双链表的基本操作

双链表的基本操作

双链表结构声明&#xff1a; typedef struct Dnode{int data;struct Dnode *prior,*next; }DNode,*DLinkList; 双链表的按值查找和按位查找的操作与单链表的相同。但在双链表的插入、删除操作与单链表有着不同的操作。 1双链表的初始化&#xff1a; typedef struct …
阅读更多...
合并K个已经排序的链表

合并K个已经排序的链表

class Solution:def mergeKLists(self , lists ):if len(lists)0:return Noneres[]for cur in lists: #将链表元素保存到列表res中while cur!None:res.append(cur.val)curcur.nextres.sort() #对res进行排序tempListNode(res[0])headtempfor i in range(1,len(res)): #遍历列表…
阅读更多...
python链表相邻两个元素翻转(如head-＞1-＞2-＞3-＞4-＞5-＞6-＞7相邻元素翻转后head-＞2-＞1-＞4-＞3-＞6-＞5-＞7)

python链表相邻两个元素翻转(如head-＞1-＞2-＞3-＞4-＞5-＞6-＞7相邻元素翻转后head-＞2-＞1-＞4-＞3-＞6-＞5-＞7)

#链表相邻两个元素翻转(如head->1->2->3->4->5->6->7相邻元素翻转后head->2->1->4->3->6->5->7) class Node:def __init__(self,value,next):self.valuevalueself.nextnext def reverse(head):if headNone or head.nextNone:return …
阅读更多...
腾讯面试题：单链表的反转

腾讯面试题：单链表的反转

要实现单链表的反转&#xff0c;我们首先需要创建一个单链表并实现CRUD操作&#xff0c;因我之前已写过类似的文章&#xff0c;故不再赘述&#xff0c;在此附上链接 创建单链表并实现CRUD 单链表反转的思路&#xff1a; 首先我们创建一个新的辅助链表并获取其头结点&#xf…
阅读更多...
新浪面试题：查找单链表中的倒数第k个结点

新浪面试题：查找单链表中的倒数第k个结点

对于该面试题&#xff0c;首先我们先创建一个单链表实现CRUD操作&#xff0c;由于我之前已写过对应的文章&#xff0c;现在下面附上链接&#xff0c;这里不再赘述。 创建单链表并实现CRUD操作 对于该面试题&#xff0c;我们的思路是&#xff1a; 首先&#xff0c;获取到该单…
阅读更多...
单向链表的定义与CRUD

单向链表的定义与CRUD

链表是由结点的方式来储存的&#xff0c;是链式存储。其的组成需要有data(数据域)&#xff0c;指向下一个结点的next&#xff0c;指向前一个结点的pre(双向链表)。链表可以分为有头结点和无头结点的链表。注意&#xff1a;链表是一种逻辑上的顺序存储结构&#xff0c;而物理上不…
阅读更多...
算法设计 格雷码问题

算法设计 格雷码问题

算法设计 格雷码问题 1. 问题描述 对于给定的正整数n&#xff0c;格雷码为满足如下条件的一个编码序列&#xff1a; (1) 序列由2n个编码组成&#xff0c;每个编码都是长度为n的二进制位串。 (2) 序列中无相同的编码。 (3) 序列中位置相邻的两个编码恰有一位不同。 例如&#x…
阅读更多...
C语言-链队列的基本操作（test）

C语言-链队列的基本操作（test）

创建头结点&#xff0c;初始化。入队。出队。取队头元素。遍历。 注&#xff1a; 根据队列的入队&#xff0c;出队规则&#xff0c;设置头结点便于实现出队操作。头指针front始终指向头结点&#xff0c;尾指针rear指向队列最后一个元素&#xff0c;length用于记录队列中元素个…
阅读更多...
C语言-顺序表、单链表基本操作（Clean）

C语言-顺序表、单链表基本操作（Clean）

单链表基本操作目录&#xff1a; 1.创建头结点 2.链表元素查找 3.插入节点 4.删除节点 5.头插法 6.尾插法 7.排序&#xff08;起泡法排序&#xff09; 8.打印链表 完整源代码 链表&#xff1a; #include<stdio.h> #include<stdlib.h>typedef struct node {int d…
阅读更多...
C语言实现LRU缓存机制——哈希表+双向链表

C语言实现LRU缓存机制——哈希表+双向链表

题目描述 题目来源&#xff1a; https://leetcode-cn.com/problems/lru-cache/ 运用你所掌握的数据结构&#xff0c;设计和实现一个LRU&#xff08;最近最少使用&#xff09;缓存机制。它应该支持以下操作&#xff1a;获取数据get和写入数据 put。 获取数据get&#xff08;key…
阅读更多...
LeetCode:求链表中倒数第k个节点(Python)

LeetCode:求链表中倒数第k个节点(Python)

题目描述&#xff1a; 输入一个链表&#xff0c;输出该链表中倒数第k个节点。为了符合大多数人的习惯&#xff0c;本题从1开始计数&#xff0c;即链表的尾节点是倒数第1个节点。例如&#xff0c;一个链表有6个节点&#xff0c;从头节点开始&#xff0c;它们的值依次是1、2、3、…
阅读更多...
关于链表有环的扩展问题：求环的长度和入环节点

关于链表有环的扩展问题：求环的长度和入环节点

一、求环的长度 二、求入环节点 一、求环的长度 解法&#xff1a;当两个指针首次相遇&#xff0c;说明链表有环&#xff0c;让两个指针从相遇点继续循环前进&#xff0c;并统计前进的次数&#xff0c;直到两个指针再次相遇。具体可参考如下公式&#xff1a; 环长每一次速度差…
阅读更多...
(剑指offer)JZ6 从尾到头打印链表[cpp实现]

(剑指offer)JZ6 从尾到头打印链表[cpp实现]

JZ6 从尾到头打印链表0. 题目链接1. 问题描述2. 运行示例3. 解题思路3.1 方法一3.2 方法二3.3 方法三0. 题目链接 源链接&#xff1a;(剑指offer)>>>JZ6 从尾到头打印链表 1. 问题描述 2. 运行示例 3. 解题思路 3.1 方法一 思路一&#xff1a;使用栈Stack&#xff0c…
阅读更多...
HashSet实现方法介绍

HashSet实现方法介绍

一、HashSet 本专栏的文章超详细的逐句介绍Java高级接口之HashSet底层源码讲解&#xff08;二&#xff09;主要介绍了HashSet的源码&#xff0c;下面我将介绍HashSet的实现方法。 二、实现方法 实现方法功能boolean add(E e)如果没有已存在&#xff0c;则将指定的元素添加到…
阅读更多...
单链表的基本操作（头插法，尾插法，获取长度，遍历打印，插入，删除，清空）

单链表的基本操作（头插法，尾插法，获取长度，遍历打印，插入，删除，清空）

学习完《算法与数据结构》&#xff08;第三版&#xff09;链表部分&#xff0c;我将书上的链表基本操作进行了实现&#xff0c;其中还是发现很多的问题的&#xff0c;还好最后都一一解决。 书上的代码&#xff1a; 1.代码单单只给出了一部分 2.代码中使用了文件的操作&#xff…
阅读更多...
超详细的逐句介绍Java高级接口之LinkedList底层源码讲解（二）

超详细的逐句介绍Java高级接口之LinkedList底层源码讲解（二）

一、LinkedList LinkedList是基于链表结构的一种线性结构存储结构&#xff0c;他和ArrayList的结构类似&#xff0c;两者均可以创建动态数组结构&#xff0c;唯一区别在于ArrayList创建的动态数组在内存上是连续的&#xff0c;而LinkedList是离散的。上一篇文章的超详细的逐句…
阅读更多...
有序单链表合并 数据结构C语言版

有序单链表合并 数据结构C语言版

有序链表合并0.题目分析1.初始定义2.代码实现3.线性表链式基本操作说明0.题目分析 头指针为La Lb的有序单链表&#xff0c;归并两单链表为Lc&#xff0c;保持有序性 La 1,3,4,9,11 Lb 6,7,8,10,12 Lc 1,3,4,6,7,8,9,10,11,12 1.初始定义 #define TRUE 1 #define FALSE 0…
阅读更多...
数据结构及算法之队列（基于链表）讲解

数据结构及算法之队列（基于链表）讲解

1&#xff0c;具体实现 package com.dream21th.algorithmicdatastructure.linkedlist;/*** Auther: hp* Date: 2019/9/13 20:52* Description:*/ public class LinkedListQueue<E> implements Queue<E> {private class Node{public E e;public Node next;public No…
阅读更多...
【数据结构】线性表知识大全

【数据结构】线性表知识大全

1、线性表的定义 线性表是具有相同数据类型的 n&#xff08;n>0&#xff09;个数据元素的有限序列&#xff0c;其中 n 为表长&#xff0c;当 n0 时线性表是一个空表。若用 L 命名线性表&#xff0c;其一般表示为&#xff1a; L (a1,a2,...,ai,ai1,...,an)式中&#xff0c;…
阅读更多...
链表中倒数第k个节点（入门算法24）

链表中倒数第k个节点（入门算法24）

题目&#xff1a;输入一个链表&#xff0c;输出该链表中倒数第k个节点。为了符合大多数人的习惯&#xff0c;本题从1开始计数&#xff0c;即链表的尾节点是倒数第1个节点。 例如&#xff0c;一个链表有 6 个节点&#xff0c;从头节点开始&#xff0c;它们的值依次是 1、2、3、4…
阅读更多...
【中等】两数相加（ListNode）

【中等】两数相加（ListNode）

文章目录题目&#xff1a;两数相加一、链表遍历的方法题目&#xff1a;两数相加 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回…
阅读更多...
剑指offer 015、反转链表

剑指offer 015、反转链表

剑指offer 015、反转链表 题目 题解 自己做的&#xff0c;太太太太low了&#xff0c;虽然思路是对的&#xff0c;也是头插法&#xff0c;但是写的太繁琐了。还是看下面的头插法吧 class Solution { public:ListNode* ReverseList(ListNode* pHead) {if (pHead nullptr) ret…
阅读更多...
剑指offer 014、链表中倒数第k个结点

剑指offer 014、链表中倒数第k个结点

剑指offer 014、链表中倒数第k个结点 题目 题解 自己的解法 /*** struct ListNode {* int val;* struct ListNode *next;* ListNode(int x) : val(x), next(nullptr) {}* };*/ class Solution { public:/*** 代码中的类名、方法名、参数名已经指定&#xff0c;请勿修改&…
阅读更多...
邻接表无向图的深度优先遍历C/C++代码实现

邻接表无向图的深度优先遍历C/C++代码实现

图的链式存储&#xff1a; 图的链式存储有多种&#xff0c;有邻接表、十字链表和邻接多重表&#xff0c;下面注意说明邻接表。 邻接表&#xff1a; 邻接表由两部分组 成&#xff1a;表头结点表和边表。 例&#xff1a; 深度优先遍历&#xff1a; 为了避免同一顶点被访问…
阅读更多...
链队列的基本操作C/C++代码实现

链队列的基本操作C/C++代码实现

链队列的结构&#xff1a; 链队列与单链表相同但与链栈不同的是&#xff0c;链队列需要添加一个头结点&#xff0c;并让头指针始终指向头结点。 入队&#xff1a; 链队列也不需要判断队满。 出队&#xff1a; 链队列队空条件&#xff1a;Q.frontQ.rear &#xff08;与循环…
阅读更多...
单链表的基本操作C/C++代码实现

单链表的基本操作C/C++代码实现

插入&#xff1a; 删除&#xff1a; 线性表的链式存储特点&#xff1a; 链表是一种顺序存取结构&#xff0c;按位置访问链表中第i个元素时&#xff0c;只能从表头开始依次向后遍历链表&#xff0c;直到找到第i个位置上的元素&#xff0c;时间复杂度为O(n), 即取值操作的效率低…
阅读更多...
双链表Java数据结构篇

双链表Java数据结构篇

本章学习目录 页内目录 一&#xff0c;双链表的简单介绍 二&#xff0c;双链表节点类 三&#xff0c;双链表操作类 一&#xff0c;双链表的简单介绍 双向链表&#xff1a;也叫双链表&#xff0c;是链表的一种&#xff0c;它的每个数据结点中都有两个指针&#xff0c;分别指向…
阅读更多...
【LeetCode】 21. 合并两个有序链表

【LeetCode】 21. 合并两个有序链表

题目 题目传送门&#xff1a;传送门&#xff08;点击此处&#xff09; 题解 总的思路吧&#xff0c;两个ListNode比较值的大小&#xff0c;然后要小的那个&#xff0c;剩下的依次向后遍历一直到一个ListNode为空&#xff0c;就直接追加两外一个链表全部的内容这样来做&#…
阅读更多...
数据结构-6.双链表

数据结构-6.双链表

一.双链表的定义&#xff1a; typedef struct DNode{ElemType data;struct DNode *prior,*next; //前驱&#xff0c;后继指针 }DNode,*DLinkList;二.带头结点的双链表的初始化&#xff1a; //初始化一个双链表 bool InitDLinkList(DLinkList &L){L(DNode*)malloc(siz…
阅读更多...
2.5-顺序线性表的查找操作

2.5-顺序线性表的查找操作

顺序线性表的查找操作 线性表的查找操作&#xff1a;线性表l查找第一个与元素e满足compare()元素的位置。若在&#xff0c;返回其在l中的次序。若不存在则输出不存在 。 void LocateElem(Sqlist* L, ElemType e, ElemType(*compare)(ElemType, ElemType))第一步设i1&#xff0…
阅读更多...
双链表定义双链表基本操作

双链表定义双链表基本操作

双向链表定义 在单链表之后&#xff0c;一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接&#xff1a;一个指向前一个节点&#xff08;前驱&#xff09;&#xff0c;当此节点为第一个节点时&#xff0c;前驱指向None&#xff1b;另一个指向下一个节点&#x…
阅读更多...
C语言必会100题(15)。输出5个学生的数据记录/创建一个链表/反向输出一个链表/连接两个链表/放松一下

C语言必会100题(15)。输出5个学生的数据记录/创建一个链表/反向输出一个链表/连接两个链表/放松一下

特此鸣谢&#xff1a;鱼C_小甲鱼&#xff08;B站up主&#xff09;不二如是&#xff08;鱼C论坛大佬&#xff09; 题目来源&#xff1a;https://fishc.com.cn 注&#xff1a;这些题在网上都可以搜到&#xff0c;题下面的代码大多是流传下来的答案&#xff08;我重新排了一下版&a…
阅读更多...
STL中List的模拟实现

STL中List的模拟实现

在C中list底层是由双向队列实现的&#xff0c;其中它的迭代器为了实现出和vector容器的迭代器一样的使用效果&#xff08;vector的空间是连续的&#xff0c;而list的空间是不连续的&#xff09;&#xff0c;因此对list的迭代器进行自定义了一些方法&#xff0c;其中如指针的解引…
阅读更多...
链表结构体定义LinkNode,*LinkList以及typedef

链表结构体定义LinkNode,*LinkList以及typedef

链表&#xff1a;线性表的链式存储结构 链表结构体定义LNode,*LinkList的理解 代码分析&#xff1a; typedef struct node{datatype data;struct node* next; }linknode,*linklist; 以上代码可以分解为&#xff1a; typedef struct node linknode; //将结构体类型struct nod…
阅读更多...
C++栈的基本用法

C++栈的基本用法

PS.更多数据结构知识详见&#xff1a; 八大数据结构 栈的用法 栈的数据结构 ADT 栈 Data和线性表相同&#xff0c;元素具有相同的数据类型&#xff0c;相邻元素具有前驱和后继关系 OpreationInitStack(): //初始化&#xff0c;建立一个空栈DestoryStack(): //若栈存在&am…
阅读更多...
C++链表的基本用法

C++链表的基本用法

PS.更多数据结构知识详见&#xff1a; 八大数据结构 链表的用法 1.链表的数据结构 //节点的定义 struct MyLinkList {int val;MyLinkList* next;MyLinkList(int val 0, MyLinkList* next nullptr) :val(val),next(next){}; };2.构建一个链表 void CreatLinkList(MyLink…
阅读更多...
双指针求解环形链表的入口

双指针求解环形链表的入口

环形链表入口 给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 示例&#xff1a; 输入&#xff1a;head [3,2,0,-4], pos 1 输出&#xff1a;返回索引为 1 的链表节点 解释&#xff1a;链表中有一个环&#xff0c;其尾部连…
阅读更多...
[LeetCode] -160. 相交链表

[LeetCode] -160. 相交链表

题目链接 题目&#xff1a; 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 问题&#xff1a; 判断两个链表是否相交&#xff1f;如果相交&#xff0c;求交点。 思路&#x…
阅读更多...
[LeetCode] - 206. 反转链表

[LeetCode] - 206. 反转链表

题目链接 题目&#xff1a; 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 过程&#xff1a; 1.struct ListNode* next cur->next; 2.cur->next newhead; 3.newhead cur; cur next; 以此类推&#xff1a; 结束while…
阅读更多...
[LeetCode] - 21. 合并两个有序链表

[LeetCode] - 21. 合并两个有序链表

题目链接 题目 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 过程&#xff1a; 当 l2 小于 l1 并且 head 为空时&#xff0c;将head 和 tail 指向 l2。然后l2 指向它的下一个结点。 l1 小于 l2&#xff0c;tail 下一个…
阅读更多...
数据结构---邻接表

数据结构---邻接表

参考书籍&#xff1a;<<大话数据结构>>--邻接表简单的说&#xff1a;用一个结构体存链表头&#xff0c;链表头连接一个链表。 有几条链表&#xff0c;就用几个数组。下面的代码&#xff1a; chainTableHead中firstson存链表头&#xff0c;sonCount记录链表头对应的…
阅读更多...
图的邻接矩阵存储方式下的深度、广度优先遍历算法 （c语言，链队列，图的遍历，深度优先，广度优先）

图的邻接矩阵存储方式下的深度、广度优先遍历算法 （c语言，链队列，图的遍历，深度优先，广度优先）

源代码 /************************** 图的邻接矩阵与深度广度优先 ***********************************/ #include<stdio.h> #define Maxsize 100 typedef struct abc {int vertex[Maxsize];int edges[Maxsize][Maxsize];int v_num,e_num;}MGraph; MGraph *init_graph(…
阅读更多...
C语言实现链表基本操作：建立、插入、删除、转置及输出

C语言实现链表基本操作：建立、插入、删除、转置及输出

链表的基本操作 链表通过系统动态分配内存&#xff0c;并不要求分配的内存是连续的&#xff0c;只要它们在逻辑上连续就行。相较于数组事先固定最大空间&#xff0c;可以有效地节省系统资源。 链表分为两个域&#xff1a;数据域用于存储用户数据&#xff1b;指针域用于存放下…
阅读更多...
数据结构（c语言版）-----单向循环链表的基本操作（初始化、插入、删除、修改、遍历等操作）

数据结构（c语言版）-----单向循环链表的基本操作（初始化、插入、删除、修改、遍历等操作）

单向循环链表基本操作 单向循环链表是头节点和尾结点重合&#xff0c;但无论在插入、查找、删除等都是在同一方向上。 文章目录单向循环链表基本操作创建链表的两种方法头插法尾插法获取单向循环链表的长度在指定位置后插入元素根据下标删除元素根据元素的值删除元素根据下标寻…
阅读更多...
【数据结构】设单链表中的数据元素递增排列，删除表中所有大于min且小于max的元素（用户输入），同时释放被删除节点的空间。

【数据结构】设单链表中的数据元素递增排列，删除表中所有大于min且小于max的元素（用户输入），同时释放被删除节点的空间。

题目&#xff1a; 设单链表中的数据元素递增排列&#xff0c;设计一个算法&#xff0c;删除表中所有大于min且小于max的元素&#xff0c;同时释放被删除节点的空间&#xff0c;并设计算法的时间复杂度。 来源&#xff1a;周桂红,等老师编写的数据结构第五十九页第二题 #inclu…
阅读更多...
链表常见操作：逆置(反转)

链表常见操作：逆置(反转)

链表中的一个很常见的操作是&#xff1a;链表的逆置&#xff0c;也叫链表的反转。 如&#xff1a;1->3->5->7->9 反转后是 9->7->5->3->1 方法一&#xff1a;使用指针 红色的箭头是新的变换&#xff0c;明白了操作原理就很好写代码了。 使用了三个指…
阅读更多...
算法-数组与链表（Java实现）

算法-数组与链表（Java实现）

文章目录链表1.链表的逆置2.在O(1)时间内删除链表节点3.链表中的倒数第k个节点4.合并两个排序的链表5.两个链表的第一个公共节点6.环形链表&#xff08;圆圈中最后剩下的数字&#xff09;判断是否有环(快慢指针&&龟兔赛跑思想)7.二叉搜索树与双向链表8.复杂链表的复制9…
阅读更多...
八股文——java相关问题

八股文——java相关问题

java相关问题(Spring、语法、数据结构、java中间件hashmap的相关问题&#xff1f;Spring 系列问题什么是spring&#xff1f;1、说说Spring 里用到了哪些设计模式?2、谈谈你对IOC 和 AOP 的理解&#xff1f;他们的实现原理是什么&#xff1f;3、 JDK 动态代理和 CGLIB 代理有什…
阅读更多...
哔哩哔哩2020校园招聘 - K个一组翻转链表 一年中的第几天

哔哩哔哩2020校园招聘 - K个一组翻转链表 一年中的第几天

1.K个一组翻转链表 题目描述&#xff1a; 给你一个链表&#xff0c;每 k 个节点一组进行翻转&#xff0c;请返回翻转后的链表。 如果节点总数不是 k 的整数倍&#xff0c;那么请将最后剩余的节点保持原有顺序。 示例 : 给定这个链表&#xff1a;1->2->3->4->5 当…
阅读更多...
LeetCode-从链表中删去总和值为零的连续结点

LeetCode-从链表中删去总和值为零的连续结点

目录 1.题目描述 2.解题思路 2.1 思路一&#xff1a;[前缀和 哈希表] 2.2 思路二&#xff1a;[前缀和"双指针法"] 1.题目描述 &#x1f341;题目要求 &#x1f341;示例分析 &#x1f341;提示 2.解题思路 准备工作&#xff1a; &#x1f343;1.从示例一的输入…
阅读更多...
LeetCode-对链表进行插入排序

LeetCode-对链表进行插入排序

题目内容 示例分析 代码实现 public ListNode insertionSortList(ListNode head) {if(head null) return null;ListNode newHead new ListNode(0);newHead.next head;ListNode SortedLast head;ListNode cur SortedLast.next;while(cur ! null) {if(SortedLast.val < c…
阅读更多...
10道经典链表面试题

10道经典链表面试题

目录 1.删除链表中等于给定值val的所有节点 2.反转一个单链表 3.给定一个带有头结点head的非空单链表&#xff0c;返回链表的中间结点。如果有两个中间结点&#xff0c;则返回第二个中间结点 4.输入一个链表&#xff0c;输出该链表中倒数第k个结点 5.将两个有序链表合并为一…
阅读更多...
算法分析之链表问题

算法分析之链表问题

算法相关数据结构总结&#xff1a; 序号数据结构文章1动态规划动态规划之背包问题——01背包 动态规划之背包问题——完全背包 动态规划之打家劫舍系列问题 动态规划之股票买卖系列问题 动态规划之子序列问题 算法&#xff08;Java&#xff09;——动态规划2数组算法分析之数…
阅读更多...
Springboot登陆页面图片验证码

Springboot登陆页面图片验证码

1、生成验证码的工具类 可以直接用 将随机生成的验证码保存在session中 public class RandomValidateCodeUtil {public static final String RANDOMCODEKEY "RANDOMVALIDATECODEKEY";//放到session中的keyprivate String randString "0123456789";//随…
阅读更多...
面试题：数组和顺序表链表的区别

面试题：数组和顺序表链表的区别

文章目录一、数组(Array)1.数组特点2.数组优点3.数组缺点二、链表(ListNode)1.链表的特点&#xff1a;2.链表的优点3.链表的缺点三、数组、链表总结一、数组(Array) 1.数组特点 所谓数组&#xff0c;就是相同数据类型的元素按一定顺序排列的集合&#xff1b;数组的存储区间是…
阅读更多...
学会链表中LeetCode三道题

学会链表中LeetCode三道题

系列文章目录 文章目录系列文章目录前言一、链表的中间结点1.题目描述2.解题思路二、链表的倒数第k个结点1.题目描述2.解题思路三、合并两个排序的链表1.题目描述2.解题思路总结前言 一、链表的中间结点 链表的中间结点 1.题目描述 给定一个头结点为 head 的非空单链表&…
阅读更多...
弄懂LeetCode三道题

弄懂LeetCode三道题

系列文章目录 文章目录系列文章目录前言一、调整奇偶数顺序1.题目描述2.解题思路二、移除链表元素1.题目描述2.解题思路三、反转链表1.题目描述2.解题思路总结前言 一、调整奇偶数顺序 调整奇偶数顺序使奇数位于偶数前面 1.题目描述 输入一个整数数组&#xff0c;实现一个函…
阅读更多...
LeetCode每日一题【blog00059】-2021/10/06 -删除排序链表中的重复元素

LeetCode每日一题【blog00059】-2021/10/06 -删除排序链表中的重复元素

本文目录如下&#xff1a;题目&#xff1a;删除排序链表中的重复元素题目&#xff1a;删除排序链表中的重复元素 题目描述: 存在一个按升序排列的链表&#xff0c;给你这个链表的头节点 head &#xff0c;请你删除所有重复的元素&#xff0c;使每个元素 只出现一次 。返回同样按…
阅读更多...
【LeetCode】数据结构题解（13）[设计循环链表]

【LeetCode】数据结构题解（13）[设计循环链表]

设计循环链表 &#x1f609; 1.题目来源&#x1f440;2.题目描述&#x1f914;3.解题思路&#x1f973;4.代码展示 所属专栏&#xff1a;玩转数据结构题型❤️ &#x1f680; >博主首页&#xff1a;初阳785❤️ &#x1f680; >代码托管&#xff1a;chuyang785❤️ &…
阅读更多...
【数据结构】‘双向链表’冲冲冲

【数据结构】‘双向链表’冲冲冲

&#x1f490; &#x1f338; &#x1f337; &#x1f340; &#x1f339; &#x1f33b; &#x1f33a; &#x1f341; &#x1f343; &#x1f342; &#x1f33f; &#x1f344;&#x1f35d; &#x1f35b; &#x1f364; &#x1f4c3;个人主页 &#xff1a;阿然成长日记 …
阅读更多...
Day 26 C++ list容器（链表）

Day 26 C++ list容器（链表）

文章目录 list基本概念定义结构双向迭代器优点缺点List和vector区别存储结构内存管理迭代器稳定性随机访问效率 list构造函数——创建list容器函数原型示例 list 赋值和交换函数原型 list 大小操作函数原型示例 list 插入和删除函数原型示例 list 数据存取函数原型注意示例 lis…
阅读更多...
leetcode707. 设计链表(单链表+虚拟头指针+双指针遍历)

leetcode707. 设计链表(单链表+虚拟头指针+双指针遍历)

题目&#xff1a;leetcode707. 设计链表 描述&#xff1a; 你可以选择使用单链表或者双链表&#xff0c;设计并实现自己的链表。 单链表中的节点应该具备两个属性&#xff1a;val 和 next 。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。 如果是双向链…
阅读更多...
链表有无环以及确定入环口详解

链表有无环以及确定入环口详解

142.环形链表 II 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测…
阅读更多...
【数据结构】反转链表、链表的中间节点、链表的回文结构（单链表OJ题）

【数据结构】反转链表、链表的中间节点、链表的回文结构（单链表OJ题）

正如标题所说&#xff0c;本文会图文详细解析三道单链表OJ题&#xff0c;分别为&#xff1a; 反转链表 &#xff08;简单&#xff09; 链表的中间节点 &#xff08;简单&#xff09; 链表的回文结构 &#xff08;较难&#xff09; 把他们放在一起讲的原因是&#xff1a; 反转链…
阅读更多...
【脚踢数据结构】深入理解栈

【脚踢数据结构】深入理解栈

(꒪ꇴ꒪ )&#xff0c;Hello我是祐言QAQ我的博客主页&#xff1a;C/C语言,Linux基础,ARM开发板&#xff0c;软件配置等领域博主&#x1f30d;快上&#x1f698;&#xff0c;一起学习&#xff0c;让我们成为一个强大的攻城狮&#xff01;送给自己和读者的一句鸡汤&#x1f914;&…
阅读更多...
【算法题】23. 合并 K 个升序链表

【算法题】23. 合并 K 个升序链表

题目&#xff1a; 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 示例 1&#xff1a; 输入&#xff1a;lists [[1,4,5],[1,3,4],[2,6]] 输出&#xff1a;[1,1,2,3,4,4,5,6] 解释&#xff1a…
阅读更多...
【每日一题Day292】LC23合并K个升序链表 | K指针 堆排序 归并排序

【每日一题Day292】LC23合并K个升序链表 | K指针 堆排序 归并排序

合并K个升序链表【LC23】 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 K指针 思路&#xff1a; 每次选择链表数组中的最小值&#xff0c;直至所有节点均为空 实现 /*** Definition for singly…
阅读更多...
JZ36二叉搜索树与双向链表

JZ36二叉搜索树与双向链表

题目地址&#xff1a;二叉搜索树与双向链表_牛客题霸_牛客网 题目回顾&#xff1a; 解题思路&#xff1a; 由题目可知&#xff0c;这里的二叉搜索树转成双向链表的符合左根右的逻辑顺序&#xff0c;且是一个递增序列。 创建两个指针&#xff0c;一个指向head&#xff0c;一个…
阅读更多...
【编织时空一：探究顺序表与链表的数据之旅】

【编织时空一：探究顺序表与链表的数据之旅】

本章重点 线性表 顺序表 顺序表OJ题 1.线性表 线性表&#xff08;linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构&#xff0c;常见的线性表&#xff1a;顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结…
阅读更多...
面试热题（回文链表）

面试热题（回文链表）

给定一个链表的 头节点 head &#xff0c;请判断其是否为回文链表。 如果一个链表是回文&#xff0c;那么链表节点序列从前往后看和从后往前看是相同的。 回文链表类似于回文串&#xff0c;正读倒读的顺序是一样的&#xff0c;那么我们怎么去判断一个链表是否是回文链表呢&…
阅读更多...
【从零开始】神奇的链表

【从零开始】神奇的链表

上次我们在双指针部分介绍了一部分链表的题目。 【从零开始】双指针的配合 其实链表的大部分题目确实与双指针有关。而这次我们再补充一些题目&#xff0c;顺便使用一个非常好用的链表技巧&#xff1a;虚头节点 设计链表 这是一道综合性的题目&#xff0c;把所有链表的基本…
阅读更多...
LeetCode每日一题【blog00058】-2021/10/05 -删除排序链表中的重复元素 II

LeetCode每日一题【blog00058】-2021/10/05 -删除排序链表中的重复元素 II

本文目录如下&#xff1a;题目&#xff1a;删除排序链表中的重复元素 II题目&#xff1a;删除排序链表中的重复元素 II 题目描述: 存在一个按升序排列的链表&#xff0c;给你这个链表的头节点 head &#xff0c;请你删除链表中所有存在数字重复情况的节点&#xff0c;只保留原始…
阅读更多...
LWN：为内核继续改善list遍历操作！

LWN：为内核继续改善list遍历操作！

关注了就能看到更多这么棒的文章哦&#xff5e;Toward a better list iterator for the kernelBy Jonathan CorbetMarch 10, 2022DeepL assisted translationhttps://lwn.net/Articles/887097/链表&#xff08;linked list&#xff09;概念很简单&#xff0c;它们往往在入门级数…
阅读更多...
力扣：725. 分隔链表

力扣：725. 分隔链表

目录题目&#xff1a;725. 分隔链表示例1示例2提示&#xff1a;解题思路题目&#xff1a;725. 分隔链表 难度&#xff1a; 中等 题目&#xff1a; 给你一个头结点为 head 的单链表和一个整数 k &#xff0c;请你设计一个算法将链表分隔为 k 个连续的部分。 每部分的长度应该…
阅读更多...
Python每日一练(20230430)

Python每日一练(20230430)

目录 1. 移除元素 &#x1f31f; 2. 删除排序链表中的重复元素 &#x1f31f; 3. 搜索旋转排序数组 II &#x1f31f;&#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Golang每日一练 专栏 Python每日一练 专栏 C/C每日一练 专栏 Java每日一练 专栏 1.…
阅读更多...
二叉树的链式存储——深入了解数据结构代码篇（二）

二叉树的链式存储——深入了解数据结构代码篇（二）

一、关键 需要一个左指针和右指针层序遍历需要队列辅助。每访问一个队头元素&#xff0c;将该元素的左指针和右指针加入其中&#xff08;如果有的话&#xff09;。寻找前驱&#xff0c;其实和普通遍历方式一致&#xff0c;不过visit函数修改&#xff0c;变为判断是否找到当前元…
阅读更多...
力扣每日一题：82. 删除排序链表中的重复元素 II

力扣每日一题：82. 删除排序链表中的重复元素 II

目录题目&#xff1a;82. 删除排序链表中的重复元素 II示例1示例2提示解题思路解题代码解题感悟题目&#xff1a;82. 删除排序链表中的重复元素 II 难度&#xff1a; 中等 题目&#xff1a; 存在一个按升序排列的链表&#xff0c;给你这个链表的头节点 head &#xff0c;请你…
阅读更多...
力扣每日一题：206. 反转链表

力扣每日一题：206. 反转链表

目录题目&#xff1a;206. 反转链表示例进阶解题思路解题代码&#xff08;1&#xff09;迭代法&#xff08;2&#xff09;递归法解题感悟题目&#xff1a;206. 反转链表 难度&#xff1a; 简单 题目&#xff1a; 反转一个单链表。 示例 输入: 1->2->3->4->5-&g…
阅读更多...
考研数据结构--数组与广义表

考研数据结构--数组与广义表

数组与广义表 文章目录 数组与广义表数组数组的基本概念性质数组的存储结构一维数组的存储结构二维数组的存储结构 特殊矩阵的压缩存储对称矩阵上三角矩阵下三角矩阵对角矩阵 稀疏矩阵定义稀疏矩阵的三元组表示稀疏矩阵的存储结构及其基本运算算法定义存入三元组三元组元素赋值…
阅读更多...
[D-OJ练习] 栈的链式存储结构与操作

[D-OJ练习] 栈的链式存储结构与操作

请你定义一个链栈&#xff0c;可以对链栈进行 “将某个元素入栈”、“弹出栈顶元素”、“取栈顶元素&#xff08;不删除&#xff09;”、“判断栈是否为空”、 “清空栈”等操作。键盘输入一些命令&#xff0c;可以执行上述操作。本题中&#xff0c;栈的元素为字符。 输入描述…
阅读更多...
数据结构：双向链表（带头循环）

数据结构：双向链表（带头循环）

朋友们、伙计们&#xff0c;我们又见面了&#xff0c;本期来给大家解读一下数据结构方面有关双向链表的相关知识点&#xff0c;如果看完之后对你有一定的启发&#xff0c;那么请留下你的三连&#xff0c;祝大家心想事成&#xff01; C 语 言 专 栏&#xff1a;C语言&#xff1a…
阅读更多...
LeetCode刷题笔记 字节每日打卡 合并为两个有序链表

LeetCode刷题笔记 字节每日打卡 合并为两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4] 参考&#xff1a;力扣 临时数组储存一个结果 比较两者小者加入链表 注意&…
阅读更多...
java链表——LinkList详解

java链表——LinkList详解

LinkList详解 注&#xff1a;在学习LinkList之前可以先去看一下我的另一篇博客单链表的定义及其模拟实现——java https://editor.csdn.net/md/?articleId130642627&#xff0c;有助于本博客的理解 ArrayList和LinkedList的区别 LinkList模拟实现 定义三个类&#xff1a;MyL…
阅读更多...
( 链表) 142. 环形链表 II——【Leetcode每日一题】

( 链表) 142. 环形链表 II——【Leetcode每日一题】

❓142. 环形链表 II 难度&#xff1a;中等 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定…
阅读更多...
day24—选择题

day24—选择题

文章目录1.将N条长度均为M的有序链表进行合并&#xff0c;合并以后的链表也保持有序&#xff0c;时间复杂度为&#xff08;A&#xff09;2.已知某个哈希表的n个关键字具有相同的哈希值&#xff0c;如果使用二次探测再散列法将这n个关键字存入哈希表&#xff0c;至少要进行&…
阅读更多...
数据结构--队列

数据结构--队列

文章目录 队列基础队列的实现链表实现环形数组实现tail一直加的问题容量处理 队列的使用 队列基础 queue 是以顺序的方式维护的一组数据集合 相对于链表来说&#xff0c;队列操作数据的位置是固定的只能2端操作。 在一端添加数据&#xff0c;从另一端移除数据。习惯来说&#…
阅读更多...
环的检测

环的检测

题目 检测链表环的存在。 思路 设立一个快指针和一个慢指针&#xff0c;快指针一次走一步&#xff0c;慢指针一次走两步。快慢指针第一次相遇时&#xff0c;一定在环中的节点上。 代码 class Node:def __init__(self, data, nextNone):self.data dataself.next nextdef …
阅读更多...
Mysql中联合索引的最左匹配

Mysql中联合索引的最左匹配

联合索引 通过将多个字段组合成一个索引&#xff0c;该索引就被称为联合索引。 比如&#xff0c;将商品表中的 product_no 和 name 字段组合成联合索引(product_no, name)&#xff0c;创建联合索引的方式如下&#xff1a; CREATE INDEX index_product_no_name ON product(pr…
阅读更多...
[4] 实现无头单向非循环链表

[4] 实现无头单向非循环链表

目录 一、框架 二、实现各个方法 三、测试各个方法 四、源码 一、框架 一个单向链表的节点&#xff0c;有数值域和下一个节点的地址 我们可以设计一个链表类&#xff0c;在这个链表类设计一个节点内部类&#xff0c;这里设计成内部类的形式&#xff0c;因为链表是由节点组…
阅读更多...
数据结构与算法03 定义单链表，单链表的有序和无序的插入，修改和删除数据

数据结构与算法03 定义单链表，单链表的有序和无序的插入，修改和删除数据

带头结点的单链表 定义节点类&#xff1a;节点类包含每个节点存储的信息和构造器 这里要注意的是用toString()方法打印输出时对next打印输出的理解 class HeroNode{//每个节点代表一个英雄&#xff0c;存储着英雄信息public int no;public String name;private String ni…
阅读更多...
【每日一题Day233】LC1171从链表中删去总和值为零的连续节点 | 链表模拟 哈希表+前缀和

【每日一题Day233】LC1171从链表中删去总和值为零的连续节点 | 链表模拟 哈希表+前缀和

从链表中删去总和值为零的连续节点【LC1171】 给你一个链表的头节点 head&#xff0c;请你编写代码&#xff0c;反复删去链表中由 总和 值为 0 的连续节点组成的序列&#xff0c;直到不存在这样的序列为止。 删除完毕后&#xff0c;请你返回最终结果链表的头节点。 你可以返回任…
阅读更多...
JDK8 中 ConcurrentHashMap 变化

JDK8 中 ConcurrentHashMap 变化

结构简单&#xff1a;JDK8 抛弃 JDK7 的 Segment 分段锁机制&#xff0c;由 JDK7 的两级数组变回了原来的一级数组。链表长度>8&#xff0c;该链表转换为红黑树。 降低锁的粒度&#xff1a;锁住数组的每个桶的头结点&#xff0c;锁粒度更小。&#xff08;Hashtable 是锁住整…
阅读更多...
合并K个有序链表Merge k Sorted Lists

合并K个有序链表Merge k Sorted Lists

文章目录合并K个有序链表Merge k Sorted Lists思路Tag合并K个有序链表Merge k Sorted Lists 有一个链表数组&#xff0c;每个链表都是有序的【升序排列】。合并所有链表到一个升序链表中。 思路 N路有序链表合并&#xff0c;借助优先队列&#xff0c;维持一个容量为N的队列&…
阅读更多...
【leetcode刷题之路】剑指Offer——字符串+链表+双指针

【leetcode刷题之路】剑指Offer——字符串+链表+双指针

文章目录 1 字符串1.1【字符串】【双指针】剑指 Offer 05 - 替换空格1.2【字符串】剑指 Offer 58 - II. 左旋转字符串1.3 【双指针】【字符串】剑指 Offer 20 - 表示数值的字符串1.4 【双指针】【字符串】剑指 Offer 67 - 把字符串转换成整数 2 链表2.1 【回溯】【链表】剑指 O…
阅读更多...
JAVA并发十二连招

JAVA并发十二连招

1、HashMap 面试第一题必问的 HashMap&#xff0c;挺考验Javaer的基础功底的&#xff0c;别问为啥放在这&#xff0c;因为重要&#xff01;HashMap具有如下特性&#xff1a; HashMap 的存取是没有顺序的。 KV 均允许为 NULL。 多线程情况下该类安全&#xff0c;可以考虑用 Ha…
阅读更多...
【FreeRTOS】——列表与列表项列表相关API函数（初始化、插入、移除）

【FreeRTOS】——列表与列表项列表相关API函数（初始化、插入、移除）

目录 前言&#xff1a; 一、列表与列表项 二、列表相关API函数 ①初始化列表vListInitialise() ②初始化列表项vListInitialise() ③列表插入列表项&#xff08;升序&#xff09;函数vListInsert() ④列表插入列表项&#xff08;无序&#xff09;函数vListInsertEnd() …
阅读更多...
顺序队列及链式队列的函数实现（泛型队列）

顺序队列及链式队列的函数实现（泛型队列）

顺序队列及链式队列的函数实现&#xff08;泛型队列&#xff09; 顺序队列&#xff1a; 给出的结构体以及基本数据 #define MAXQUEUE 10typedef struct Aqueue {void *data[MAXQUEUE]; //数据域int front;int rear;int length; //队列长度 } AQueue;typedef enu…
阅读更多...
单链表的逆置

单链表的逆置

用两种方法实现对单链表的逆置操作 1. 用无线头插的方法实现 //逆置1 无线头插 bool Reverse1(PNode plist) {assert(plist ! NULL);PNode p plist->next;PNode q ;plist->next NULL;while (p!NULL){q p->next;p->next plist->next;plist->next p;p q…
阅读更多...
460. LFU 缓存（哈希表+双向链表）

460. LFU 缓存（哈希表+双向链表）

2021年04月09日 周五 天气晴 【不悲叹过去&#xff0c;不荒废现在&#xff0c;不惧怕未来】 本文目录1. 题目简介2. 哈希表双向链表参考文献1. 题目简介 460. LFU 缓存 2. 哈希表双向链表 本题的思路类似于 146. LRU 缓存机制 &#xff0c;但是要更复杂。 感谢大神 liweiw…
阅读更多...
leetcode(23): 复杂链表的复制

leetcode(23): 复杂链表的复制

文章目录法一&#xff1a;使用unordered_map法二&#xff1a;使用递归总结&#xff1a;法一&#xff1a;使用unordered_map /* // Definition for a Node. class Node { public:int val;Node* next;Node* random;Node(int _val) {val _val;next NULL;random NULL;} }; */ c…
阅读更多...
HOT29-删除链表的倒数第 N 个结点

HOT29-删除链表的倒数第 N 个结点

leetcode原题链接&#xff1a;删除链表的倒数第 N 个结点 题目描述 删除链表的倒数第 N 个结点。 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,…
阅读更多...
用链表实现LinkedList

用链表实现LinkedList

public class myLinkedList implements Iterable {private int thesize; //存储当前链表的长度private int modcount 0;private Node beginMarker; //链表的头节点&#xff0c;其next指向链表的第一个节点private Node endMarker; //链表的尾节点&#xff0c;其prev指…
阅读更多...
学生管理系统 C语言 动态链表 结构体 文件操作 设置密码 输入密码回显星号

学生管理系统 C语言 动态链表 结构体 文件操作 设置密码 输入密码回显星号

C语言 学生管理系统代码 实现功能 功能&#xff1a;学生管理系统设计&#xff0c;每个学生信息作为一条记录&#xff0c;包括姓名、学号、专业、 性别、年龄、 电话、家庭住址。还可以继续拓展 系统要求实现以下功能&#xff1a; 1、输入功能&#xff1a;录入学生信息&am…
阅读更多...
【Leetcode05.13】141.环形链表

【Leetcode05.13】141.环形链表

链表系列重新回归~ 同时也深觉需要时刻关注对边界条件的处理~ 之前就关注到链表判环这个问题&#xff0c;也知道是用快慢指针进行解决的&#xff0c;但是也就自己想了想&#xff0c;今天就借等待面华为的时候写一写~ 关于思路 空链表、只有一个元素或者只有两个元素的链表不可…
阅读更多...
【leetcode05.12】203.移除链表元素

【leetcode05.12】203.移除链表元素

温习链表&#xff0c;学有所得 做链表题目之时&#xff0c;一定记得画图&#xff01;记得画图&#xff01;记得画图&#xff01; 链表元素删除 分为两种情况——如果是头节点&#xff0c;直接后移即可&#xff1b;如果是非头节点&#xff0c;需要用到待删除节点的前一个节点&a…
阅读更多...
面试题43：1~n整数中1出现的次数

面试题43：1~n整数中1出现的次数

面试题43&#xff1a;1~n整数中1出现的次数 输入一个整数 n &#xff0c;求1&#xff5e;n这n个整数的十进制表示中1出现的次数。 class Solution { public:int countDigitOne(int n) {int res0;int cur n%10,highn/10,low0;long digital1;while(cur!0 || high!0){if(cur0)r…
阅读更多...
面试题36：二叉搜索树与双向链表

面试题36：二叉搜索树与双向链表

面试题36&#xff1a;二叉搜索树与双向链表 输入一棵二叉搜索树&#xff0c;将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点&#xff0c;只能调整树中节点指针的指向。 class Solution { public:Node* treeToDoublyList(Node* root) {if(root nullp…
阅读更多...
LC004

LC004

合并两个链表&#xff1a; public class MergeTwoList {int val;MergeTwoList next;MergeTwoList(int val) {this.val val;}MergeTwoList(int val, MergeTwoList next) {this.val val;this.next next;} }class Solution {public MergeTwoList mergeTwoLists(MergeTwoList l1…
阅读更多...
面试题25：合并两个排序的列表

面试题25：合并两个排序的列表

面试题25&#xff1a;合并两个排序的列表 输入两个递增排序的链表&#xff0c;合并这两个链表并使新链表中的节点仍然是递增排序的。 class Solution {// 递归 public:ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {if(l1 nullptr)return l2;if(l2 nullptr)return…
阅读更多...
力扣19. 删除链表的倒数第 N 个结点

力扣19. 删除链表的倒数第 N 个结点

删除链表的倒数第 N 个结点 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] 思路1&#xff1a;双指针 这种链表的第几个结点问题&#xff0c;一般采用双指针的方法…
阅读更多...
面试题22：链表中倒数第k个节点

面试题22：链表中倒数第k个节点

面试题22&#xff1a;链表中倒数第k个节点 输入一个链表&#xff0c;输出该链表中倒数第k个节点。为了符合大多数人的习惯&#xff0c;本题从1开始计数&#xff0c;即链表的尾节点是倒数第1个节点。 class Solution { // 定义两个指针&#xff0c;// 当第一个指针先走k-1步…
阅读更多...
单链表知识点

单链表知识点

目录 1.1 链表的概念以及结构 1.2 链表的分类 1.3 链表的实现 你不会的东西&#xff0c;觉得难得东西&#xff0c;一定不要躲&#xff0c;先搞明白后精湛。 1.1 链表的概念以及结构 链表是一种 物理存储结构上非连续 、非顺序的存储结构&#xff0c;数据元素的 逻辑顺序 是通…
阅读更多...
HOT31-K个一组翻转链表

HOT31-K个一组翻转链表

leetcode原题链接&#xff1a;K个一组翻转链表 题目描述 给你链表的头节点 head &#xff0c;每 k 个节点一组进行翻转&#xff0c;请你返回修改后的链表。 k 是一个正整数&#xff0c;它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍&#xff0c;那么请将最后剩余…
阅读更多...
带头结点的链表的增、删、查、插

带头结点的链表的增、删、查、插

#include <stdio.h> #include <stdlib.h>/**带头结点的单链表* * */struct node {int num;char name;int age;struct node *next; };typedef struct node Hnode; typedef Hnode * Hlink;//创建新节点 void create_new_node(Hlink *new_node) {*new_node (Hlink)ma…
阅读更多...
03双向链表

03双向链表

双向链表 单向链表的缺点 单向链表&#xff0c;只能是一个方向来查找&#xff0c;而双向链表可以向前或者向后查找。单向链表不能自我删除&#xff0c;需要靠辅助结点。而双向链表可以自我删除。所以我们单链表删除结点的时候&#xff0c;总要找到temp&#xff08;待删除结点…
阅读更多...
树的简单理解

树的简单理解

文章目录简介树存储结构的实现二叉树基本定义性质二叉树的树实现二叉树的遍历简介 树是一种树是一种非线性数据结构&#xff0c;所谓非线性数据结构&#xff0c;是指可以元素之间的关系可以一对多或多对一&#xff0c;多对多的数据结构。树是一种典型的非线性数据结构&#xf…
阅读更多...
58、合并两个排序的链表

58、合并两个排序的链表

描述 输入两个单调递增的链表&#xff0c;输出两个链表合成后的链表&#xff0c;当然我们需要合成后的链表满足单调不减规则。 实现&#xff1a; function ListNode(x){this.val x;this.next null; } function Merge(pHead1, pHead2) {//递增if(!pHead1){ return pHead2}if…
阅读更多...
系统内核之堆管理

系统内核之堆管理

相比于栈内存而言&#xff0c;堆这片内存的管理模式更为复杂&#xff0c;因为程序可能随时发出请求&#xff0c;并且申请一段内存&#xff0c;申请内存的大小不固定&#xff0c;释放的时间也不确定。栈在面向过程的程序设计中远远不够&#xff0c;因为栈上的数据在函数返回时就…
阅读更多...
Python leetcode 剑指offer 从尾到头打印链表

Python leetcode 剑指offer 从尾到头打印链表

输入一个链表的头节点&#xff0c;从尾到头反过来返回每个节点的值&#xff08;用数组返回&#xff09;。 示例 1&#xff1a; 输入&#xff1a;head [1,3,2] 输出&#xff1a;[2,3,1] 限制&#xff1a; 0 < 链表长度 < 10000 来源&#xff1a;力扣&#xff08;Lee…
阅读更多...
LeetCode876链表的中间节点

LeetCode876链表的中间节点

这道题还是比较简单的&#xff0c;最开始的思路是求一下链表的长度length&#xff0c;然后从头开始走length/2即可&#xff0c;当感觉不是很好。便想到了快慢指针的解法。 我们定义两个引用fast和slow&#xff08;都等于head开始&#xff09;&#xff0c;我们让fast一次走两步&…
阅读更多...
数据结构—单链表的操作与实现—c++代码（含全部代码）

数据结构—单链表的操作与实现—c++代码（含全部代码）

文章目录 目录 文章目录 前言 一、基本操作 二、代码实现 1.代码 这是test.c部分主要是main函数的部分 这是linklist.c部分主要是函数体内容的部分 这是test.h的部分&#xff0c;主要是头文件的部分 2.显示效果 总结 前言 最近在学习数据结构&#xff…
阅读更多...
用数组方式实现的链表

用数组方式实现的链表

链表是一种常用的线性表&#xff0c;可以快捷的进行插入和删除。但在常规的做法中&#xff0c;这些操作需要有动态内存分配的支持。偏偏有些编程环境&#xff0c;想要动态内存分配的话&#xff0c;需要额外添加一些库文件&#xff0c;比较繁琐。如何在没有动态内存分配函数的情…
阅读更多...
广义表的c/c++描述（下），代码篇

广义表的c/c++描述（下），代码篇

本程序改编自课本例题&#xff0c;包括广义链表的建立&#xff0c;输出&#xff0c;求链表长度&#xff0c;深度&#xff0c;求原子个数和最大原子&#xff08;ascii&#xff09;。大量应用了递归。全部代码如下&#xff1a;&#xff08;感觉学习递归也没啥太好的方法&#xff…
阅读更多...
稀疏矩阵sparse matrix 的十字链表存储，c/c++描述（下）

稀疏矩阵sparse matrix 的十字链表存储，c/c++描述（下）

改写自课本例题。整个程序主要包括主函数main&#xff0c;建立十字链表的函数creatCrossList&#xff0c;和从十字链表里获取数组元素值的函数getValue&#xff0c;和在屏幕显示矩阵的函数display。整个矩阵的行列信息都存储在表头指针ptHead里。从这个指针开始可以获取整个矩阵…
阅读更多...
leetcode------现在有一个这样的链表：链表的每一个节点都附加了一个随机指针，随机指针可能指向链表中的任意一个节点或者指向空。

leetcode------现在有一个这样的链表：链表的每一个节点都附加了一个随机指针，随机指针可能指向链表中的任意一个节点或者指向空。

/*** Definition for singly-linked list with a random pointer.* class RandomListNode {* int label;* RandomListNode next, random;* RandomListNode(int x) { this.label x; }* };*/ /*思路&#xff1a; 1.复制原链表&#xff0c;将复制的每个结点放在原结点…
阅读更多...
失效策略：缓存淘汰策略有哪些？

失效策略：缓存淘汰策略有哪些？

说到失效策略就要知道失效的是什么以及通过什么方式失效&#xff1f; 本文涉及知识比较浅&#xff0c;能让你知道什么是LRU以及类似的共享策略&#xff0c;最后用代码具体实现了LRU策略。 首先我们知道在计算机中内存是有限的&#xff0c;这就导致了我们存储数据时会出现内存过…
阅读更多...
leetcode---对于一个给定的链表，返回环的入口节点，如果没有环，返回null

leetcode---对于一个给定的链表，返回环的入口节点，如果没有环，返回null

/*** Definition for singly-linked list.* class ListNode {* int val;* ListNode next;* ListNode(int x) {* val x;* next null;* }* }*/ public class Solution {public ListNode detectCycle(ListNode head) {//1.链表为空&#xff0c;…
阅读更多...
leetcode------删除给出链表中的重复元素（链表中元素从小到大有序），使链表中的所有元素都只出现一次

leetcode------删除给出链表中的重复元素（链表中元素从小到大有序），使链表中的所有元素都只出现一次

题目描述 删除给出链表中的重复元素&#xff08;链表中元素从小到大有序&#xff09;&#xff0c;使链表中的所有元素都只出现一次 例如&#xff1a; 给出的链表为1->1->2,返回1->2. 给出的链表为1->1->2->3->3,返回1->2->3. public ListNode d…
阅读更多...
leetcode-----将两个有序的链表合并为一个新链表，要求新的链表是通过拼接两个链表的节点来生成的。

leetcode-----将两个有序的链表合并为一个新链表，要求新的链表是通过拼接两个链表的节点来生成的。

题目描述 将两个有序的链表合并为一个新链表&#xff0c;要求新的链表是通过拼接两个链表的节点来生成的。 public ListNode mergeTwoLists (ListNode l1, ListNode l2) {//3种特殊情况if(l1null && l2!null){return l2;}if(l2null && l1!null){return l1;}if…
阅读更多...
leetcode------将给定的链表中每两个相邻的节点交换一次，返回链表的头指针

leetcode------将给定的链表中每两个相邻的节点交换一次，返回链表的头指针

题目描述 将给定的链表中每两个相邻的节点交换一次&#xff0c;返回链表的头指针 例如, 给出1->2->3->4&#xff0c;你应该返回链表2->1->4->3。 你给出的算法只能使用常量级的空间。你不能修改列表中的值&#xff0c;只能修改节点本身。 public ListNode s…
阅读更多...
C++练习实例———成绩管理系统（链表）

C++练习实例———成绩管理系统（链表）

这个学生成绩管理系统是大一时候的课程设计作业&#xff0c;系统没有可视化&#xff0c;具有增删改查几个基础功能&#xff0c;是最简单的控制台代码。 整个程序有三个类&#xff0c;分别是单链表类、学生类和管理类&#xff0c;下面上代码。 首先是单链表类&#xff0c;用来存…
阅读更多...
数据结构——图解求单链表的长度及插入操作C语言

数据结构——图解求单链表的长度及插入操作C语言

单链表的插入属于单链表的基本操作之一&#xff0c;关于单链表的初始化的解释在我的上篇文章中已经详细说明过了。 一、求单链表长度 求单链表长度的操作很简单&#xff0c;其实在初始化赋值或遍历那块就可以实现&#xff0c;但是为了让结构层次独立清楚&#xff0c;我还…
阅读更多...
LinkedBlockingQueue

LinkedBlockingQueue

LinkedBlockingQueue 分析 1. 属性分析 LinkedBlockingQueue 是一个FIFO的队列。采用了两个锁&#xff0c;一个take锁&#xff08;头锁&#xff09;&#xff0c;一个put锁&#xff08;尾锁&#xff09;&#xff0c;为了尽可能的减少获取锁的操作&#xff0c;count&#xff08…
阅读更多...
学习C/C++语言系列（1）双向循环带哨兵位链表

学习C/C++语言系列（1）双向循环带哨兵位链表

虽然双向循环比单链表和循序表结构要复杂&#xff0c;但在我目前看来&#xff0c;它比单链表&#xff0c;顺序表都要好用&#xff0c;都更实用。所以我想在单链表和顺序表之前先讲解一下我学到的双向循环带哨兵位链表。 首先来讲一讲什么是哨兵位。 如图&#xff0c;哨兵位其实…
阅读更多...
LeetCode21合并两个有序链表

LeetCode21合并两个有序链表

分析 首先题目中的关键词是升序&#xff0c;我们可以new一个新节点&#xff08;newHead&#xff09;来当返回链表的头&#xff0c;然后遍历链表A和B&#xff0c;比较其val&#xff0c;将小的节点连接到newHead后面即可。 newHead&#xff08;新返回链表的头&#xff09;tmp&am…
阅读更多...
LeetCode138：复制带随机指针的链表

LeetCode138：复制带随机指针的链表

复制带随机指针的链表问题描述分析AC代码问题描述 问题链接&#xff1a;https://leetcode-cn.com/problems/fu-za-lian-biao-de-fu-zhi-lcof/ 分析 还没有学到哈希&#xff0c;所以官方给的题解不太懂。然后想到了另一种方法。先来分析一下这道题吧。 这道题的关键在于复制随…
阅读更多...
20_JavaSE_LinkedList类

20_JavaSE_LinkedList类

1. LinkedList 的简介 上一节我们说到 ArrayList &#xff0c;这一节我们来讲 LinkedList &#xff0c;LinkedList 同样是一种很常见的数据结构&#xff0c;但与 ArrayList 不同&#xff0c;LinkedList 内部是用链表实现的&#xff0c;因此它的存储空间是不连续的。 因为 Lin…
阅读更多...
12_JavaSE_StringBuffer和StringBuilder类

12_JavaSE_StringBuffer和StringBuilder类

前面讲到 String 对象的值是不能被修改的&#xff0c;当我们为某个对象赋值之后&#xff0c;他的值就不能改变。那么如果我们需要改变呢&#xff1f;我们就需要使用到 StringBuffer 和 StringBuilder 类。 StringBuffer 和 StringBuilder 类的对象存储的字符串是支持被修改的&…
阅读更多...
删除有序链表中重复的元素

删除有序链表中重复的元素

题目描述 删除给出链表中的重复元素&#xff08;链表中元素从小到大有序&#xff09;&#xff0c;使链表中的所有元素都只出现一次 例如&#xff1a; 给出的链表为1\to1\to21→1→2,返回1 \to 21→2. 给出的链表为1\to1\to 2 \to 3 \to 31→1→2→3→3,返回1\to 2 \to 31→2→3…
阅读更多...
【每日一题】反转链表

【每日一题】反转链表

文章目录题目描述&#xff1a;示例&#xff1a;解法一&#xff1a;利用双指针代码&#xff1a;解答二&#xff1a;递归实现代码&#xff1a;题目描述&#xff1a; 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例&#xff1a; 解法一…
阅读更多...
二叉树的层序遍历，c/c++描述

二叉树的层序遍历，c/c++描述

按一层一层&#xff0c;从上往下&#xff0c;从左到右的顺序遍历二叉树。称为层序遍历。这里用到了队列。一端插入&#xff0c;另一端删除。对于二叉树链表&#xff0c;我们易于实现纵向访问&#xff0c;从祖先节点&#xff0c;到父母节点&#xff0c;到子孙节点&#xff0c;但…
阅读更多...
链表常见的5个操作（增删）

链表常见的5个操作（增删）

链表操作的两种方式&#xff1a; &#xff08;1&#xff09;直接对链表进行操作&#xff08;存在判断是否为头结点的问题&#xff09; &#xff08;2&#xff09;添加虚拟头结点进行操作&#xff08;不必判断操作对象是否为头结点&#xff09; 以下使用方式二。 首先定义节…
阅读更多...
Leetcode 刷题必须Review 八 Lintcode（174 219 452 511 228）

Leetcode 刷题必须Review 八 Lintcode（174 219 452 511 228）

文章目录174 删除链表中倒数第n个节点219 在排序链表中插入一个节点452 删除链表中的元素511 交换链表当中两个节点228 链表的中点174 删除链表中倒数第n个节点 给定一个链表&#xff0c;删除链表中倒数第n个节点&#xff0c;返回链表的头节点。 def removeNthFromEnd…
阅读更多...
链表（13）----判断链表是否有环，并返回环入口节点

链表（13）----判断链表是否有环，并返回环入口节点

1、链表定义 typedef struct ListElement_t_ {void *data;struct ListElement_t_ *next; } ListElement_t;typedef struct List_t_{int size;int capacity;ListElement_t *head;ListElement_t *tail; } List_t;2、判断链表是否有环&#xff0c;并返回链表入口节点 &#xff08…
阅读更多...
链表（12）----判断是否有环，如果有环，判断是6型环，还是0型环

链表（12）----判断是否有环，如果有环，判断是6型环，还是0型环

1、链表定义 typedef struct ListElement_t_ {void *data;struct ListElement_t_ *next; } ListElement_t;typedef struct List_t_{int size;int capacity;ListElement_t *head;ListElement_t *tail; } List_t;2、判断链表是否有环&#xff0c;如果有环&#xff0c;判断是6型环…
阅读更多...
链表（9）----判断链表是否有环

链表（9）----判断链表是否有环

1、链表定义 typedef struct ListElement_t_ {void *data;struct ListElement_t_ *next; } ListElement_t;typedef struct List_t_{int size;int capacity;ListElement_t *head;ListElement_t *tail; } List_t;2、判断链表是否有环&#xff0c;使用两个指针&#xff0c;快指针一…
阅读更多...
链表（5）----查找链表倒数第K个节点

链表（5）----查找链表倒数第K个节点

1、链表定义 typedef struct ListElement_t_ {void *data;struct ListElement_t_ *next; } ListElement_t;typedef struct List_t_{int size;int capacity;ListElement_t *head;ListElement_t *tail; } List_t;2、查找链表第K个节点数据 设置快慢指针&#xff0c;快指针超前慢…
阅读更多...
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 字典 — 链表实现

《数据结构、算法与应用 —— C++语言描述》学习笔记 — 字典 — 链表实现

《数据结构、算法与应用 —— C语言描述》学习笔记 — 字典 — 链表实现一、字典二、抽象数据类型三、链表描述1、节点2、接口声明3、拷贝控制接口4、容量接口5、修改接口虽然在n个元素的有序数组上二分查找所需要的时间为 O(logn)O(logn)O(logn)&#xff0c;但是有序链表上查找…
阅读更多...
剑指Offer--026-复杂链表的复制

剑指Offer--026-复杂链表的复制

牛客OJ&#xff1a;复杂链表的复制 九度OJ&#xff1a;http://ac.jobdu.com/problem.php?pid1524 GitHub代码&#xff1a; 026-复杂链表的复制 CSDN题解&#xff1a;剑指Offer–026-复杂链表的复制 牛客OJ九度OJCSDN题解GitHub代码复杂链表的复制1524-复杂链表的复制剑指Off…
阅读更多...
数据结构入门系列链接

数据结构入门系列链接

数据结构入门系列之——基本概念 数据结构入门系列——线性表的基本操作 数据结构入门系列——用顺序表解决实际问题 数据结构入门系列——用链表解决实际问题&#xff08;1&#xff09; 数据结构入门系列——用链表解决实际问题&#xff08;2&#xff09; 数据结构入门系…
阅读更多...
剑指offer 刷题 三 字符串（05 58）

剑指offer 刷题 三 字符串（05 58）

剑指 Offer 05. 替换空格 请实现一个函数&#xff0c;把字符串 s 中的每个空格替换成"%20"。 def replaceSpace(self, s: str) -> str:new_s for cha in s:if cha :new_s %20else:new_s chareturn new_s剑指 Offer 58 - II. 左旋转字符串 字符串的左旋转操…
阅读更多...
LeetCode——链表篇

LeetCode——链表篇

LeetCode——链表篇一、移除链表元素题解代码二、反转链表题解代码三、两两交换链表中的节点题解代码四、删除链表的倒数第 N 个结点题解代码五、相交链表题解代码六、环形链表题解代码七、环形链表 ||题解代码一、移除链表元素 题解 该题其实就只需要遍历一下链表&#xff0c…
阅读更多...
C语言入门之链表

C语言入门之链表

何谓链表&#xff1f; 链式存储的线性表&#xff0c;简称链表。链表由多个链表元素组成&#xff0c;这些元素称为节点。结点之间通过逻辑连接&#xff0c;形成链式存储结构。 存储结点的内存单元&#xff0c;可以是连续的也可以是不连续的。逻辑连接与物理存储次序没有关系 建…
阅读更多...
合并两个排序的链表 — C++实现

合并两个排序的链表 — C++实现

题目描述 输入两个单调递增的链表&#xff0c;输出两个链表合成后的链表&#xff0c;当然我们需要合成后的链表满足单调不减规则。 牛客网题目链接 求解思路 给出两个链表&#xff0c;我们需要先比较两个结点的头结点&#xff0c;将小的结点保存&#xff0c;然后将这个结点…
阅读更多...
迷宫（栈、队列、递归3种方法）和八皇后（栈和递归2种方法）的C/C++描述（上）

迷宫（栈、队列、递归3种方法）和八皇后（栈和递归2种方法）的C/C++描述（上）

***迷宫&#xff1a; 栈是只能在一端进行添加元素和删除元素的表&#xff0c;分顺序栈和链式栈。程序里变量命名应该长一些&#xff0c;做到见名知意。提高程序阅读性。本文用栈的方法存储路径中每一步&#xff0c;栈中每个元素是结构体变量&#xff0c;包含每一步的横坐标&…
阅读更多...
链表中倒数第k个节点-链表(剑指offer22)-C++

链表中倒数第k个节点-链表(剑指offer22)-C++

/*** struct ListNode {* int val;* struct ListNode *next;* ListNode(int x) : val(x), next(nullptr) {}* };*/ class Solution { public:/*** 代码中的类名、方法名、参数名已经指定&#xff0c;请勿修改&#xff0c;直接返回方法规定的值即可** * param pHead ListNode类 …
阅读更多...
Java数据结构习题：编写一个max（），接受首节点作为参数，返回链表中数值最大的结点的值（假设所有数据都是正整数，如果链表为空则返回0）

Java数据结构习题：编写一个max（），接受首节点作为参数，返回链表中数值最大的结点的值（假设所有数据都是正整数，如果链表为空则返回0）

编写一个max&#xff08;&#xff09;&#xff0c;接受首节点作为参数&#xff0c;返回链表中数值最大的结点的值&#xff08;假设所有数据都是正整数&#xff0c;如果链表为空则返回0&#xff09; 核心代码: // 编写一个max&#xff08;&#xff09;&#xff0c;接受首节点作…
阅读更多...
数据结构学习——链式队列解析（C语言版）

数据结构学习——链式队列解析（C语言版）

数据结构——链队列解析过程和简单代码实现&#xff1a;一、简单概念&#xff1a;动图展示&#xff1a;(1)入队&#xff1a;(2)出队&#xff1a;二、顺序队列&#xff1a;思路步奏&#xff1a;&#xff08;1&#xff09;入队操作&#xff1a;&#xff08;2&#xff09;出队操作…
阅读更多...
Java数据结构习题：编写一个delete（）,接受一个int参数k，删除链表的第k个元素（如果它存在的话）

Java数据结构习题：编写一个delete（）,接受一个int参数k，删除链表的第k个元素（如果它存在的话）

核心代码&#xff1a; 重点看删除代码 //编写一个delete&#xff08;&#xff09;,接受一个int参数k&#xff0c;删除链表的第k个元素&#xff08;如果它存在的话&#xff09;public class Node {//链表指针private NODE first null;private NODE lase null;public int getN…
阅读更多...
Redis数据结构——跳跃表

Redis数据结构——跳跃表

0、简介 zset的编码有压缩链表和跳跃表两种。除了当zset保存的元素少于128个或保存的所有元素大小都小于64字节时使用压缩链表&#xff0c;其余情况都是使用跳跃表 跳跃表&#xff0c;又称跳表是Redis提供的有序集合&#xff08;zset&#xff09;类型主要的底层的数据结构。 ty…
阅读更多...
小白日更第八十五天-＞力扣-环形链表

小白日更第八十五天-＞力扣-环形链表

题目描述&#xff1a; 代码&#xff1a; public ListNode detectCycle(ListNode head) {if(headnull) return null;ListNode fast head;ListNode slow head;while(fast!null&&fast.next!null){fast fast.next.next;slow slow.next;if(fastslow) break;}if(fastnul…
阅读更多...
linux链表

linux链表

删除节点 linux代码中在删除链表的节点时&#xff0c;会将删除的节点的prev和next指针分别指向LIST_POISON2和LIST_POISON1。这两个地址都是不可访问的地址&#xff0c;当访问时会发生page fault。基于此&#xff0c;在配置了CONFIG_DEBUG_LIST的情况下&#xff0c;可以利用这…
阅读更多...
严蔚敏数据结构C语言版的单链表插入功能（纯敲代码）——中职

严蔚敏数据结构C语言版的单链表插入功能（纯敲代码）——中职

严蔚敏数据结构C语言版的插入功能 /* 严蔚敏数据结构C语言版 P29 算法2.9 在带头结点的单链线性表L中第i个位置之前插入元素e *///头文件 #include<stdio.h> #include<malloc.h> #include<stdlib.h>//结构 typedef struct List //链表名字 {int data…
阅读更多...
带头结点的顺序栈

带头结点的顺序栈

#include <stdio.h> #include <stdlib.h> #define SIZE 10enum ret_vla{MALLOC_OK 100, MALLOC_NO, CREATE_OK, CREATE_NO, FULL_OK, FULL_NO, EMPTY_OK, EMPTY_NO, PUSH_OK, PUSH_NO, POP_OK, POP_NO};//顺序栈struct stack_node {int stack_data[SIZE];int top;…
阅读更多...
45 克隆带随机指针的链表（Copy List with Random Pointer）

45 克隆带随机指针的链表（Copy List with Random Pointer）

文章目录1 题目2 解决方案2.1 思路2.3 时间复杂度2.4 空间复杂度3 源码1 题目 题目&#xff1a;克隆带随机指针的链表&#xff08;Copy List with Random Pointer&#xff09; 描述&#xff1a;给出一个链表&#xff0c;每个节点包含一个额外增加的随机指针&#xff0c;其可以…
阅读更多...
36两个链表的第一个公共节点

36两个链表的第一个公共节点

文章目录1.题目2.思路3.代码1.题目 编写一个程序&#xff0c;找到两个单链表相交的起始节点。 如下面的两个链表&#xff1a; 在节点 c1 开始相交。 注意&#xff1a; 如果两个链表没有交点&#xff0c;返回 null. 在返回结果后&#xff0c;两个链表仍须保持原有的结构。 可…
阅读更多...
某大厂第一技术面

某大厂第一技术面

1、java容器有哪些&#xff1f;哪些是同步容器&#xff0c;哪些是并发容器&#xff1f; 一、基本概念 Java容器类类库的用途是“持有对象”&#xff0c;并将其划分为两个不同的概念&#xff1a; Collection是一个独立元素的序列&#xff0c;这些元素都服从一条或多条规则。Li…
阅读更多...
26.二叉搜索树与双向链表

26.二叉搜索树与双向链表

文章目录1.题目2.思路3.代码1.题目 输入一棵二叉搜索树&#xff0c;将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点&#xff0c;只能调整树中结点指针的指向。 2.思路 中序遍历&#xff0c;从中序遍历得到的第一个节点开始构造链表&#xff0c;定义两个…
阅读更多...
25.复杂链表的复制

25.复杂链表的复制

文章目录1.题目2.思路3.代码1.题目 输入一个复杂链表&#xff08;每个节点中有节点值&#xff0c;以及两个指针&#xff0c;一个指向下一个节点&#xff0c;另一个特殊指针指向任意一个节点&#xff09;&#xff0c;返回结果为复制后复杂链表的head。&#xff08;注意&#xf…
阅读更多...
数据结构-单链表的实现方式

数据结构-单链表的实现方式

线性表&#xff08;链表&#xff09; 定义&#xff1a;n个数据元素的有限序列&#xff0c;n是表长度 &#xff08;自己写带表头节点的链表&#xff0c;区别带表头结点和不带表头节点的链表&#xff09; 特点&#xff1a; 1、除第一个元素外&#xff0c;其他元素有且只有一个直接…
阅读更多...
java--哈希表（hash）

java--哈希表（hash）

hash哈希的引入哈希冲突避免冲突设计合适的哈希函数负载因子的调节&#xff08;重点&#xff09;解决冲突闭散列&#xff08;开放地址法&#xff09;开散列&#xff08;链地址法&#xff09;重点hash和java类集的关系海量数据处理的问题位图&#xff08;缩小存储空间&#xff0…
阅读更多...
DFA（确定的有穷自动机）的化简

DFA（确定的有穷自动机）的化简

DFA&#xff08;确定的有穷自动机&#xff09;的化简一、 实验目的二、 实验内容三、 实验环境四、 算法与实验原理五、 实验代码六、 实验结论七、 实验遇到的问题八、 实验心得一、 实验目的 通过设计、编写和调试将确定的有穷自动机的状态数变为最少的C程序&#xff0c;使得…
阅读更多...
L2-022 重排链表 (25分)

L2-022 重排链表 (25分)

原题连接 测试点 1 3 1 是没有多余节点的奇数节点样例 3是有多余节点的奇数节点测试样例 最近几道题都是第一遍19分害 链表题其实蛮有固定思路的 我就是总记不住更新有效节点 在输出格式的时候还是会习惯性的使用原始节点个数 AC代码&#xff1a; #include <iostream>…
阅读更多...
剑指offer从头打印链表

剑指offer从头打印链表

从头打印链表题目描述分析AC代码题目描述 分析 题目要求从头到尾反向输出每个节点的值&#xff08;并用数组返回&#xff09;&#xff0c;看到官方的题解是用栈来解决的&#xff08;栈先进后出的特点&#xff09;&#xff0c;但自己目前还没有接触到&#xff0c;所以先用一个时…
阅读更多...
1025 反转链表 (25point(s))

1025 反转链表 (25point(s))

1025 反转链表 (25point(s)) 给定一个常数 K 以及一个单链表 L&#xff0c;请编写程序将 L 中每 K 个结点反转。例如&#xff1a;给定 L 为 1→2→3→4→5→6&#xff0c;K 为 3&#xff0c;则输出应该为 3→2→1→6→5→4&#xff1b;如果 K 为 4&#xff0c;则输出应该为 4→…
阅读更多...
利用环形链表解决-约瑟夫问题

利用环形链表解决-约瑟夫问题

测试类&#xff1a; package com.xurong.linkedList;public class JosepHu {public static void main(String[] args) {CircleSingleLinkedList circleSingleLinkedList new CircleSingleLinkedList();circleSingleLinkedList.addBoy(5);//加入5个节点circleSingleLinkedList…
阅读更多...
C语言 串的链式存储

C语言 串的链式存储

串的链式存储&#xff1a; 顺序串的插入和删除操作不方便&#xff0c;需要移动大量的字符。因此&#xff0c;可采用单链表方式存储串。由于串结构的特殊性一结构中的每个数据元素是 一个字符&#xff0c;则在用链表存储申值时&#xff0c;存在个“结点大小”的问题&#xff0c;…
阅读更多...
十进制转换任意进制--链栈实现

十进制转换任意进制--链栈实现

首先&#xff0c;先了解一下c语言const用法&#xff1a; 修饰局部变量&#xff0c;int const a 9; const int b 8;这两种写法是一样的&#xff0c;表示a和b都是常量&#xff0c;不可改变。需要注意的是&#xff0c;用const修饰变量时&#xff0c;一定要给变量初始化&#xff…
阅读更多...
第二章--线性表之循环链表

第二章--线性表之循环链表

目录一、循环单链表二、循环双链表1.初始化空的循环双链表2.双链表的插入3.双链表的删除三、知识回顾一、循环单链表 二、循环双链表 1.初始化空的循环双链表 2.双链表的插入 参考非循环双链表的插入方法&#xff0c;这段代码如果是非循环的那就是错的&#xff0c;因为到链表尾…
阅读更多...
剑指offer 回文链表

剑指offer 回文链表

分析 我们可以分三步来解决这个问题。 快慢指针找中点反转后半部分判断前半段与翻转后的后半段是否相同 第一步&#xff1a;快慢指针找中间节点 fast&#xff08;快指针一次走两步&#xff09;slow&#xff08;满指针一次走一步&#xff09; 第二步反转后半部分 prev&#…
阅读更多...
SDUT-2134 数据结构实验之栈与队列四：括号匹配

SDUT-2134 数据结构实验之栈与队列四：括号匹配

数据结构实验之栈与队列四&#xff1a;括号匹配Time Limit: 1000MS Memory Limit: 65536KBSubmit StatisticProblem Description给你一串字符&#xff0c;不超过50个字符&#xff0c;可能包括括号、数字、字母、标点符号、空格&#xff0c;你的任务是检查这一串字符中的( ) ,[ …
阅读更多...
LeetCode-归并排序链表

LeetCode-归并排序链表

题目描述 示例分析 题目要求 一看见时间复杂度为O(N*logN)&#xff0c;而处于这个时间复杂度的排序只有三个&#xff1a;堆排、快排、归并排序&#xff0c;快排最坏情况下&#xff0c;是O(N^2)&#xff0c;而堆排不适合链表的排序&#xff0c;所以只剩下归并排序了。 方法一&a…
阅读更多...
No.25 K个一组反转链表

No.25 K个一组反转链表

25. K个一组反转链表 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* ListNode(int val, ListNode next) { this.val val; this.next next; }* …
阅读更多...
青岛大学_王卓老师【数据结构与算法】Week04_04_双向链表的插入_学习笔记

青岛大学_王卓老师【数据结构与算法】Week04_04_双向链表的插入_学习笔记

本文是个人学习笔记&#xff0c;素材来自青岛大学王卓老师的教学视频。 一方面用于学习记录与分享&#xff0c;另一方面是想让更多的人看到这么好的《数据结构与算法》的学习视频。 如有侵权&#xff0c;请留言作删文处理。 课程视频链接&#xff1a; 数据结构与算法基础–…
阅读更多...
【LeetCode】 706. （JAVA） 设计哈希集合 链表实现

【LeetCode】 706. （JAVA） 设计哈希集合 链表实现

总体来讲&#xff0c;这个效果不是很优秀&#xff0c;而且有问题&#xff0c;因为size要设置的很大就可以&#xff0c;设置小了就出错&#xff0c;还没来得及找出来原因&#xff0c;先贴出来吧 题目&#xff1a; 解决&#xff1a; 思路&#xff1a; 使用链表实现的哈希集合…
阅读更多...
数据结构-1.单链表的初始化

数据结构-1.单链表的初始化

一.单链表的定义 代码定义单链表&#xff1a; typedef struct LNode{ElemType data;struct LNode *next; }LNode,*LinkList; 要表示一个单链表时&#xff0c;只需要一个头指针&#xff0c;指向单链表第一个结点。 LNode *L;//声明指向单链表的第一个结点的指针 LinkList L;/…
阅读更多...
FATFS（X）：读写多字节（字）

FATFS（X）：读写多字节（字）

/*-----------------------------------------------------------------------*/ /* 在 FAT结构中 写/读 多字节字*/ /*-----------------------------------------------------------------------*///写字&#xff08;低位优先&#xff09; static WORD l…
阅读更多...
210. 异或运算 ——线性基

210. 异或运算 ——线性基

Link 线性基板子&#xff0c;求一个数列可以得到的第 kkk 小异或值。 int t 0; int n; vector<ull> b; void insert(ull x) {for(auto i : b)x min(x, x ^ i);for(auto& i : b)i min(i, x ^ i);if(x)b.pb(x); } void solve() {printf("Case #%d:\n", t…
阅读更多...
LeetCode系列之「有序链表转换二叉搜索树」

LeetCode系列之「有序链表转换二叉搜索树」

有序链表转换二叉搜索树 给定一个单链表&#xff0c;其中的元素按升序排序&#xff0c;将其转换为高度平衡的二叉搜索树。 本题中&#xff0c;一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 示例&#xff1a; 给定的有序链表&#xff1…
阅读更多...
剑指Offer系列之「复杂链表的复制」

剑指Offer系列之「复杂链表的复制」

请实现 copyRandomList 函数&#xff0c;复制一个复杂链表。在复杂链表中&#xff0c;每个节点除了有一个 next 指针指向下一个节点&#xff0c;还有一个 random 指针指向链表中的任意节点或者 null。 将链表进行拓展&#xff0c;在每个链表结点的旁边拷贝&#xff0c;比如 A-&…
阅读更多...
LeetCode第178场周赛

LeetCode第178场周赛

5344. 有多少小于当前数字的数字 规模很小&#xff0c;暴力 class Solution {public int[] smallerNumbersThanCurrent(int[] nums) {int[] res new int[nums.length];for (int i 0; i < nums.length; i) {int temp nums[i];int dig 0;for (int j 0; j < nums.len…
阅读更多...
C的数据结构---双向链表

C的数据结构---双向链表

1.插入思想 2.删除思想 优点：
阅读更多...
C的数据结构---线性表的链式存储（带头通用链表）

C的数据结构---线性表的链式存储（带头通用链表）

1.链式存储定义 为了表示每个数据元素与其直接后继元素之间的逻辑关系，每个元素除了存储本身的信息外，还需要存储指示其直接后继的信息 n个节点链接成一个链表，即为线性表的链式存储结构，因此链表的每个节点中只包含一个指针域，所以叫单链表。单链表正是通过每个节点的指…
阅读更多...
⭐栈的多种实现，这样传参是否可以实现了？

⭐栈的多种实现，这样传参是否可以实现了？

⭐栈的多种实现方式&#xff0c;这样传参是否可以实现了&#xff1f;顺序表实现单向链表实现这样传参可以实现吗&#xff1f;顺序表实现 Stack.h #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> #include<assert.h> #include<…
阅读更多...
数据结构OJ题——移除链表元素

数据结构OJ题——移除链表元素

数据结构OJ题——移除链表元素方法一&#xff1a;在原链表的基础上遍历方法二&#xff1a;重新创建一个空链表&#xff0c;进行尾插总结对比方法一&#xff1a;在原链表的基础上遍历 struct ListNode* removeElements(struct ListNode* head, int val) {while (head ! NULL &am…
阅读更多...
LeetCode-2两数相加

LeetCode-2两数相加

题目信息&#xff1a; 两数相加 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&a…
阅读更多...
C语言实现 循环链表实现队列

C语言实现 循环链表实现队列

C语言实现 循环链表实现队列 #include <stdio.h> #include "stdlib.h" typedef struct queuenode{int data;struct queuenode * next;}QueueNode; typedef struct {QueueNode * rear;}linkQueue; void insertNode(linkQueue *Q,int x){QueueNode * p malloc…
阅读更多...
【leetcode.876】链表的中间结点

【leetcode.876】链表的中间结点

一、题目描述 给定一个带有头结点 head 的非空单链表&#xff0c;返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结点。 示例 1&#xff1a; 输入&#xff1a;[1,2,3,4,5] 输出&#xff1a;此列表中的结点 3 (序列化形式&#xff1a;[3,4,5]) 返回的结…
阅读更多...
查找算法之查找一维数组中的众数

查找算法之查找一维数组中的众数

算法场景 项目中遇到一个场景&#xff0c;对一个长度为为20的滑动窗进行滤波操作&#xff0c;因为要保证数据平稳不突变&#xff0c;想选取这个滑动窗里的众数作为窗口输出&#xff0c;保证数据的最大平稳性。由于是基于单片机&#xff0c;只能用C实现&#xff0c;没有C的map容…
阅读更多...
7-1 两个有序链表序列的合并 (20分)

7-1 两个有序链表序列的合并 (20分)

7-1 两个有序链表序列的合并 (20分) 已知两个非降序链表序列S1与S2&#xff0c;设计函数构造出S1与S2合并后的新的非降序链表S3。 输入格式: 输入分两行&#xff0c;分别在每行给出由若干个正整数构成的非降序序列&#xff0c;用−1表示序列的结尾&#xff08;−1不属于这个…
阅读更多...
链表排列（线性表）

链表排列（线性表）

感觉这题简单些&#xff0c;我可能就是移动结点搞不太清&#xff0c;这个可以直接用双重while循环按冒泡排序来搞。 直接上代码了 #include<stdio.h> #include<stdlib.h>typedef struct Node { int data;struct Node *next; }LinkList; LinkList *head,*p,*q;in…
阅读更多...
数据结构-树与二叉树篇（更新中）

数据结构-树与二叉树篇（更新中）

20.12.9 寻寻寻寻更新 树与二叉树、树与森林的PTA例题&#xff0c; 树与森林编程题未处理。 差huffman树。 1、树 1、树是n ( n > 0 ) n(n>0)n(n>0)结点的有限集&#xff0c;有且仅有一个特定的称为根的结点&#xff0c;当n>1时&#xff0c;其余结点可分为m个互不…
阅读更多...
2018 “百度之星”程序设计大赛 - 初赛（A） 度度熊学队列【链表的应用】

2018 “百度之星”程序设计大赛 - 初赛（A） 度度熊学队列【链表的应用】

度度熊学队列 Accepts: 958 Submissions: 5545 Time Limit: 3000/1500 MS (Java/Others) Memory Limit: 131072/131072 K (Java/Others) Problem Description 度度熊正在学习双端队列&#xff0c;他对其翻转和合并产生了很大的兴趣。 初始时有 NN 个空的双端队列&#xff0…
阅读更多...
【Leetcode】链表排序（逐步提高时空复杂度）

【Leetcode】链表排序（逐步提高时空复杂度）

面试遇到的一道题&#xff0c;链表排序。 文章目录链表排序1. 题目描述2. 思路分析3. 代码实现链表排序 1. 题目描述 leetcode题目链接&#xff1a;148. 排序链表 进阶&#xff1a;你可以在 O(n log n) 时间复杂度和常数级空间复杂度下&#xff0c;对链表进行排序吗&#xf…
阅读更多...
2022.4.24腾讯笔试记录

2022.4.24腾讯笔试记录

腾讯笔试是五道题目&#xff0c;两个小时。 3道ACM模式&#xff0c;两道核心代码模式。 第1题 题目描述 有n个长度相等由数字组成的字符串&#xff0c;从上往下读&#xff0c;并排序&#xff0c;输出新的数字字符串&#xff0c;去掉前导0。 示例1 输入 3 0123 1234 2345…
阅读更多...
【C++】STL06 -list

【C++】STL06 -list

概念 双向循环列表 特点 任意一端开始遍历&#xff0c;地址不连续&#xff0c;不能通过下标访问元素只能通过迭代器访问链表采用动态存储分配&#xff0c;不会造成内存浪费和溢出。链表执行插入和删除操作&#xff0c;修改指针即可&#xff0c;不需要移动大量元素。链表灵活…
阅读更多...
什么是JWT，JWT与session

什么是JWT，JWT与session

什么是JWT Json web token (JWT), 是为了在网络应用环境间传递声明而执行的一种基于JSON的开放标准&#xff08;(RFC 7519).该token被设计为紧凑且安全的&#xff0c;特别适用于分布式站点的单点登录&#xff08;SSO&#xff09;场景。JWT的声明一般被用来在身份提供者和服务提…
阅读更多...
【LeetCode】86、分隔链表

【LeetCode】86、分隔链表

题目描述 给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你应当 保留 两个分区中每个节点的初始相对位置。 示例1 示例2 题解 我们需要构造两个链表higher和less&#x…
阅读更多...
leetcode-----将给出的链表中的节点每k个一组翻转，返回翻转后的链表

leetcode-----将给出的链表中的节点每k个一组翻转，返回翻转后的链表

题目描述 将给出的链表中的节点每k个一组翻转&#xff0c;返回翻转后的链表 如果链表中的节点数不是k的倍数&#xff0c;将最后剩下的节点保持原样 你不能更改节点中的值&#xff0c;只能更改节点本身。 只允许使用常数级的空间 例如&#xff1a; 给定的链表是1->2-&g…
阅读更多...
《数据结构》| 第二章 线性表

《数据结构》| 第二章 线性表

与你相识 博主介绍&#xff1a; – 本人是普通大学生一枚&#xff0c;每天钻研计算机技能&#xff0c;CSDN主要分享一些技术内容&#xff0c;因我常常去寻找资料&#xff0c;不经常能找到合适的&#xff0c;精品的&#xff0c;全面的内容&#xff0c;导致我花费了大量的时间&a…
阅读更多...
[javascript]复杂链表的复制

[javascript]复杂链表的复制

复杂链表的复制描述代码描述 输入一个复杂链表&#xff08;每个节点中有节点值&#xff0c;以及两个指针&#xff0c;一个指向下一个节点&#xff0c;另一个特殊指针random指向一个随机节点&#xff09;&#xff0c;请对此链表进行深拷贝&#xff0c;并返回拷贝后的头结点。&a…
阅读更多...
[JavaScirpt]链表中的节点每k个一组翻转

[JavaScirpt]链表中的节点每k个一组翻转

链表中的节点每k个一组翻转描述示例1代码描述 将给出的链表中的节点每\ k k 个一组翻转&#xff0c;返回翻转后的链表 如果链表中的节点数不是\ k k 的倍数&#xff0c;将最后剩下的节点保持原样 你不能更改节点中的值&#xff0c;只能更改节点本身。 要求空间复杂度 \ O(1) O…
阅读更多...
数据结构笔记（二）---------- 双向链表的两种实现

数据结构笔记（二）---------- 双向链表的两种实现

双向链表的两种实现 上次我们学习了单链表&#xff0c;这次我们来看双链表&#xff0c;双链表与单链表相比 &#xff0c;我们知道&#xff0c;单链表只能通过索引&#xff08;next指针&#xff09;找到他的后继&#xff0c;而若要找他的前驱就需要从头遍历&#xff0c;非常麻烦…
阅读更多...
Linux内核链表原理和实例

Linux内核链表原理和实例

深入分析Linux链表 链表的实例
阅读更多...
[leetcode刷题]HOT100

[leetcode刷题]HOT100

C leetcode 文章目录Hot 1002两数之和&#xff08;中等&#xff09;19删除链表的倒数第N个节点&#xff08;中等&#xff09;31下一个排序&#xff08;数组&#xff09;&#xff08;中等&#xff09;&#xff08;特殊&#xff09;39组合总和&#xff08;中等&#xff09;&#…
阅读更多...
2023 8 -14链表OJ

2023 8 -14链表OJ

&#x1f495;人面只今何处去&#xff0c;桃花依旧笑春风&#x1f495; 作者&#xff1a;Mylvzi 文章主要内容&#xff1a;详解链表OJ题 题目一&#xff1a;环形链表&#xff08;判断链表是否带环&#xff09; 题目描述&#xff1a; 画图分析&#xff1a; 代码实现&#x…
阅读更多...
【leetcode】第2章 链表

【leetcode】第2章 链表

203. 移除链表元素 方法&#xff1a;添加一个虚拟节点&#xff0c;这不用考虑头节点删除情况 public ListNode removeElements(ListNode head, int val) {// 虚拟节点&#xff0c;指向头节点ListNode dummy new ListNode(0);dummy.next head;ListNode p dummy;// 找到被删…
阅读更多...
LC-链表的中间节点（双指针）

LC-链表的中间节点（双指针）

LC-链表的中间节点&#xff08;双指针&#xff09; 链接&#xff1a;https://leetcode.cn/problems/middle-of-the-linked-list/description/ 描述&#xff1a;给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二…
阅读更多...
142.环形链表2：快慢指针

142.环形链表2：快慢指针

LeetCode.142 环形链表2 &#xff08;Medium&#xff09; 这里分享一个LeetCode上的&#xff1a;图解&#xff0c;非常便于理解。 该题是基于环形链表&#xff1a;判断是否有环&#xff0c;并找到环的具体位置&#xff08;返回环开始的节点&#xff09;。同时本题需要一点数学…
阅读更多...
HashMap的get/put

HashMap的get/put

HashMap结构 JDK1.7及之前&#xff1a;数组链表 JDK1.8&#xff1a;数组链表红黑树 数组链表 当数据通过put()方法插入时 会通过hash散列算法计算得出固定长度的数组下标——> int hash hash(key);如果该数组下标对应的数据是null&#xff0c;则直接插入。如果有数值——…
阅读更多...
c++单向链表

c++单向链表

#include <iostream> #include <time.h> using std::cout; using std::endl; struct Node {int data;struct Node* next; };一、创建链表 Node * createList() {Node *head new Node;if (NULL head)exit(-1);head->next NULL;return head; }二、尾插法 vo…
阅读更多...
栈的实现：链式栈

栈的实现：链式栈

栈的链式存储&#xff0c;即链式栈。它相比于顺序栈&#xff0c; 优点&#xff1a; 插入、删除灵活 (不必移动节点&#xff0c;只要改变节点中的指针指向即可)。 逻辑上相邻的节点物理上不必相邻。 缺点&#xff1a;比顺序存储结构的存储密度小 (每个节点都由值域和链域组成&…
阅读更多...
【剑指offer】链表04-JZ52 两个链表的第一个公共结点

【剑指offer】链表04-JZ52 两个链表的第一个公共结点

文章目录题目描述示例解决题目解析&#xff1a;双指针长度比较法双指针连接法思路题目 描述 输入两个无环的单向链表&#xff0c;找出它们的第一个公共结点&#xff0c;如果没有公共节点则返回空。&#xff08;注意因为传入数据是链表&#xff0c;所以错误测试数据的提示是用…
阅读更多...
数据结构——线性数据结构（数组，链表，栈，队列）

数据结构——线性数据结构（数组，链表，栈，队列）

文章目录 1. 数组2. 链表2.1. 链表简介2.2. 链表分类2.2.1. 单链表2.2.2. 循环链表2.2.3. 双向链表2.2.4. 双向循环链表 2.3. 应用场景2.4. 数组 vs 链表 3. 栈3.1. 栈简介3.2. 栈的常见应用常见应用场景3.2.1. 实现浏览器的回退和前进功能3.2.2. 检查符号是否成对出现3.2.3. 反…
阅读更多...
【数据结构之栈】

【数据结构之栈】

栈的概念及结构 栈的实现 结构选择 分析一下&#xff0c;用哪种结构实现较好&#xff1f;顺序表 or 链表 这么我用的顺序表 代码实现 Stack.h #pragma once#include <stdio.h> #include <stdbool.h> #include <assert.h> #include <stdlib.h>t…
阅读更多...
链表（详解）

链表（详解）

一、链表 1.1、什么是链表 1、链表是物理存储单元上非连续的、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表的指针地址实现&#xff0c;有一系列结点&#xff08;地址&#xff09;组成&#xff0c;结点可动态的生成。 2、结点包括两个部分&#xff1a;&#x…
阅读更多...
LeetCode 热题 100（六）：25. K 个一组翻转链表、230. 二叉搜索树中第K小的元素、199. 二叉树的右视图

LeetCode 热题 100（六）：25. K 个一组翻转链表、230. 二叉搜索树中第K小的元素、199. 二叉树的右视图

题目一&#xff1a; 25. K 个一组翻转链表https://leetcode.cn/problems/reverse-nodes-in-k-group/题目要求&#xff1a; 思路&#xff1a;建立虚拟头结点&#xff0c;并采用头尾节点&#xff0c;使用常规翻转的函数进行翻转。 具体见代码逻辑。 注意&#xff1a;一定注意好…
阅读更多...
【数据结构之双向链表】

【数据结构之双向链表】

前言 上一篇我们已经学过了单链表&#xff0c;了解了其结构&#xff0c;不知道大家有没有发现单链表的缺陷 链表结构 现实中要实现的链表结构非常多样&#xff0c;有8种链表结构&#xff1a; 无头单向非循环链表 结构简单&#xff0c;一把不会单独用来存数据。实际中更…
阅读更多...
【LeetCode75】第三十二题 链表最大孪生和

【LeetCode75】第三十二题 链表最大孪生和

目录 题目: 示例: 分析: 代码: 题目: 示例: 分析: 题目让我们求出链表的最大孪生和&#xff0c;那么什么是孪生和呢&#xff0c;就是对称的节点就是孪生节点&#xff0c;他们的和就是孪生和。 比如第一个节点的孪生节点就是最后一个节点&#xff0c;第二个节点的孪生节点…
阅读更多...
【华为OD机试python】阿里巴巴找黄金宝箱(V)【2023 B卷|100分】

【华为OD机试python】阿里巴巴找黄金宝箱(V)【2023 B卷|100分】

题目描述 一贫如洗的樵夫阿里巴巴在去砍柴的路上&#xff0c;无意中发现了强盗集团的藏宝地&#xff0c; 藏宝地有编号从0~N的箱子&#xff0c;每个箱子上面贴有一个数字。 阿里巴巴念出一个咒语数字k(k<N)&#xff0c;找出连续k个宝箱数字和的最大值&#xff0c; 并输出该最…
阅读更多...
【牛客网题目】反转链表

【牛客网题目】反转链表

目录 描述 解题分析 描述 给定一个单链表的头结点pHead(该头节点是有值的&#xff0c;比如在下图&#xff0c;它的val是1)&#xff0c;长度为n&#xff0c;反转该链表后&#xff0c;返回新链表的表头。 数据范围&#xff1a; 0≤n≤1000 要求&#xff1a;空间复杂度O(1) &a…
阅读更多...
【数据结构】实现栈和队列

【数据结构】实现栈和队列

目录 一、栈1.栈的概念及结构&#xff08;1&#xff09;栈的概念&#xff08;2&#xff09;栈的结构 2.栈的实现&#xff08;1&#xff09;类型和函数的声明&#xff08;2&#xff09;初始化栈&#xff08;3&#xff09;销毁&#xff08;4&#xff09;入栈&#xff08;5&#x…
阅读更多...
二叉查找树（binary search tree）（难度7）

二叉查找树（binary search tree）（难度7）

C数据结构与算法实现&#xff08;目录&#xff09; 答案在此&#xff1a;二叉查找树&#xff08;binary search tree&#xff09;&#xff08;答案&#xff09; 写在前面 部分内容参《算法导论》 基本接口实现 1 删除 删除值为value的第一个节点 删除叶子节点1 删除叶子节…
阅读更多...
算法系列-力扣876-求链表的中间节点

算法系列-力扣876-求链表的中间节点

# 求链表中间节点&#xff0c;如果有两个中间节点取后面那个 链表定义 // lc codestart /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode() {} * ListNode(int val) { this.val val; } * …
阅读更多...
Java里面单向链表实现

Java里面单向链表实现

Java里面单向链表实现 说明代码 说明 这里记录下单向链表实现。并在类里面写了一些新增和删除方法。 代码 package com.example.test;//单向链表类 public class Node {//结点的值public int val;//当前结点的后继结点,当 next null 时&#xff0c;代表这个结点是所在链表的…
阅读更多...
【LeetCode-中等题】236. 二叉树的最近公共祖先

【LeetCode-中等题】236. 二叉树的最近公共祖先

文章目录 题目方法一&#xff1a;后序遍历 回溯 题目 方法一&#xff1a;后序遍历 回溯 解题的核心就是&#xff1a;采用后序遍历 讨论p&#xff0c;q是否在当前的root的两边&#xff0c;如在两边则返回当前节点root 如何不在两边&#xff0c;只要出现一个节点等于p或者q就…
阅读更多...
【LeetCode-中等题】437. 路径总和 III

【LeetCode-中等题】437. 路径总和 III

文章目录 题目方法一&#xff1a;迭代层序 每层节点dfs 维护一个count变量 题目 方法一&#xff1a;迭代层序 每层节点dfs 维护一个count变量 思路&#xff1a; 层序遍历每一个节点遍历一个节点就对这个节点进行dfsdfs的同时&#xff0c;维护一个count变量&#xff0c;并且…
阅读更多...
leetcode---使用插入排序对链表进行排序。

leetcode---使用插入排序对链表进行排序。

import java.util.*;/** public class ListNode {* int val;* ListNode next null;* }*/public class Solution {/*** * param head ListNode类 * return ListNode类思路&#xff1a;每次向已经排序的部分链表中插入节点时&#xff0c;先确定插入位置&#xff0c;需找到其…
阅读更多...
重排链表(C语言)

重排链表(C语言)

题目&#xff1a; 示例&#xff1a; 思路&#xff1a; 这题我们将使用栈解决这个问题&#xff0c;利用栈先进后出的特点&#xff0c;从链表的中间位置进行入栈&#xff0c;寻找链表的中间位置参考&#xff1a;删除链表的中间节点&#xff0c;之后从头开始进行连接。 本题使用…
阅读更多...
leetcode-------合并k个已排序的链表并将其作为一个已排序的链表返回。分析并描述其复杂度。

leetcode-------合并k个已排序的链表并将其作为一个已排序的链表返回。分析并描述其复杂度。

题目描述 合并k个已排序的链表并将其作为一个已排序的链表返回。分析并描述其复杂度。 public ListNode mergeKLists(ArrayList<ListNode> lists) {if(listsnull||lists.size()0){return null;}//遍历链表集合&#xff0c;依次进行合并ListNode first lists.get(0);fo…
阅读更多...
C语言实例_双向链表增删改查

C语言实例_双向链表增删改查

一、双向链表介绍 双向链表&#xff08;Doubly Linked List&#xff09;是一种常见的数据结构&#xff0c;在单链表的基础上增加了向前遍历的功能。与单向链表不同&#xff0c;双向链表的每个节点除了包含指向下一个节点的指针外&#xff0c;还包含指向前一个节点的指针。 作用…
阅读更多...
【刷题笔记8.15】【链表相关】LeetCode：合并两个有序链表、反转链表

【刷题笔记8.15】【链表相关】LeetCode：合并两个有序链表、反转链表

LeetCode&#xff1a;【链表相关】合并两个有序链表 题目1&#xff1a;合并两个有序链表 题目描述 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3…
阅读更多...
数据结构刷题训练：用栈实现队列（力扣OJ）

数据结构刷题训练：用栈实现队列（力扣OJ）

目录 前言 1. 题目&#xff1a;用栈实现队列 2. 思路 3. 分析 3.1 定义 “ 队列 ” 3.2 创建队列 3.3 入队 3.4 队头数据 3.5 出队 3.6 判空和销毁 4.题解 总结 前言 栈和队列是数据结构中的两个重要概念&#xff0c;它们在算法和程序设计中都有着广泛的应用。本文将带你深入了…
阅读更多...
【数据结构OJ题】链表中倒数第k个结点

【数据结构OJ题】链表中倒数第k个结点

原题链接&#xff1a;https://www.nowcoder.com/practice/529d3ae5a407492994ad2a246518148a?tpId13&&tqId11167&rp2&ru/activity/oj&qru/ta/coding-interviews/question-ranking 目录 1. 题目描述 2. 思路分析 3. 代码实现 1. 题目描述 2. 思路分析 …
阅读更多...
LeetCode150道面试经典题-- 环形链表(简单)

LeetCode150道面试经典题-- 环形链表(简单)

1.题目 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&…
阅读更多...
ListNode相关

ListNode相关

目录 2. 链表相关题目 2.1 合并两个有序链表&#xff08;简单&#xff09;&#xff1a;递归 2.2 删除排序链表中的重复元素&#xff08;简单&#xff09;&#xff1a;一次遍历 2.3 两链表相加&#xff08;中等&#xff09;&#xff1a;递归 2.4 删除链表倒数第N个节点&…
阅读更多...
【脚踢数据结构】常见排序算法

【脚踢数据结构】常见排序算法

(꒪ꇴ꒪ )&#xff0c;Hello我是祐言QAQ我的博客主页&#xff1a;C/C语言&#xff0c;Linux基础&#xff0c;ARM开发板&#xff0c;软件配置等领域博主&#x1f30d;快上&#x1f698;&#xff0c;一起学习&#xff0c;让我们成为一个强大的攻城狮&#xff01;送给自己和读者的…
阅读更多...
双向--＞带头--＞循环链表

双向--＞带头--＞循环链表

目录 一、双向带头循环链表概述 1.什么是双向带头循环链表 2.双向带头循环链表的优势 3.双向带头循环链表简图 二、双向带头循环链表的增删查改图解及代码实现 1.双向带头循环链表的头插 2.双向带头循环链表的尾插 3.双向带头循环链表的头删 4.双向带头循环链表的尾删…
阅读更多...
每日一题 141环形链表（快慢指针）

每日一题 141环形链表（快慢指针）

题目 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&#…
阅读更多...
[leetcode] 707 设计链表

[leetcode] 707 设计链表

707. 设L计链表 中等 902 相关企业 你可以选择使用单链表或者双链表&#xff0c;设计并实现自己的链表。 单链表中的节点应该具备两个属性&#xff1a;val 和 next 。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。 如果是双向链表&#xff0c;则还需…
阅读更多...
【脚踢数据结构】查找

【脚踢数据结构】查找

(꒪ꇴ꒪ )&#xff0c;Hello我是祐言QAQ我的博客主页&#xff1a;C/C语言&#xff0c;Linux基础&#xff0c;ARM开发板&#xff0c;软件配置等领域博主&#x1f30d;快上&#x1f698;&#xff0c;一起学习&#xff0c;让我们成为一个强大的攻城狮&#xff01;送给自己和读者的…
阅读更多...
记录力扣热题-100——从链表中找到刷题感觉

记录力扣热题-100——从链表中找到刷题感觉

目录 一. &#x1f981; 前言二. &#x1f981; 解题过程1. 题目2. 思路一3. 思路二 三. &#x1f981; 文末活动内容简介本书结构关于代码 一. &#x1f981; 前言 狮子此前已经很久没有碰过算法题了&#xff0c;对于之前好不容易攒起来的题感又没了…最近准备面试&#xff0…
阅读更多...
【编织时空三：探究顺序表与链表的数据之旅】

【编织时空三：探究顺序表与链表的数据之旅】

本章重点 链表OJ题 1. 删除链表中等于给定值 val 的所有结点。 OJ链接 思路一&#xff1a;删除头结点时另做考虑&#xff08;由于头结点没有前一个结点&#xff09; struct ListNode* removeElements(struct ListNode* head, int val) {assert(head);struct ListNode* cur h…
阅读更多...
数据结构复习笔记

数据结构复习笔记

目录一、线性结构1、串的模式匹配2、利用栈对表达式求值二、非线性结构1、树与二叉树&#xff08;1&#xff09;哈夫曼树&#xff08;2&#xff09;二叉树2、图&#xff08;1&#xff09;图的存储结构&#xff08;2&#xff09;图的遍历&#xff08;3&#xff09;图的最短路径三…
阅读更多...
玩转红黑树：手把手教你实现和理解红黑树

玩转红黑树：手把手教你实现和理解红黑树

玩转红黑树&#xff1a;手把手教你实现和理解红黑树 引言一、红黑树的定义1.1、理论知识1.2、代码实现1.3、代码优化 二、红黑树的旋转2.1、理论知识2.2、代码实现 三、红黑树插入节点3.1、理论知识3.2、代码实现 四、红黑树删除节点4.1、理论知识4.2、代码实现 五、红黑树的查…
阅读更多...
链表之第三回

链表之第三回

欢迎来到我的&#xff1a;世界 该文章收入栏目&#xff1a;链表 希望作者的文章对你有所帮助&#xff0c;有不足的地方还请指正&#xff0c;大家一起学习交流 ! 目录 前言第一题&#xff1a;判断是否为环形链表第二题&#xff1a;找到两条链表的相交点第三题&#xff1a;返回…
阅读更多...
【链表】 61. 旋转链表

【链表】 61. 旋转链表

61. 旋转链表 解题思路 首先计算出链表长度将链表长度进行取余遍历链表 对链表进行分割 得到两个子链表重新连接两个链表比如1 2 3 4 5 k 2 进行分割得到 1 2 3 和 4 5两个子链表 /*** Definition for singly-linked list.* public class ListNode {* int val;* Lis…
阅读更多...
【二叉树】114. 二叉树展开为链表

【二叉树】114. 二叉树展开为链表

114. 二叉树展开为链表 解题思路 后序遍历思路将root的左子树和右子树展平将root的右子树接到左子树下方 然后将整个左子树作为右子树 /*** Definition for a binary tree node.* public class TreeNode {* int val;* TreeNode left;* TreeNode right;* Tree…
阅读更多...
数据结构与算法之栈

数据结构与算法之栈

数据结构与算法之栈 1.栈(Stack)的基本概念 栈是限制仅能在表的一端进行插入和删除操作的线性表。允许插入和删除的一端叫做栈顶&#xff0c;另一端则为栈底。其的特点是后进先出&#xff08;Last in First Out&#xff09;。 2.栈的存储结构 栈的顺序存储结构称为顺序栈。顺…
阅读更多...
反转链表（C++）

反转链表（C++）

1、迭代法的一种写法 ListNode* reverse_linkList(ListNode* head){if(head nullptr || head->next nullptr) return head;ListNode* begin nullptr;ListNode* mid head;ListNode* end head->next;while(true){mid->next begin;if(end nullptr){break;}begin …
阅读更多...
链表的顶级理解

链表的顶级理解

目录 1.链表的概念及结构 2.链表的分类 单向或者双向 带头或者不带头 循环或者非循环 3.无头单向非循环链表的实现 3.1创建单链表 3.2遍历链表 3.3得到单链表的长度 3.4查找是否包含关键字 3.5头插法 3.6尾插法 3.7任意位置插入 3.8删除第一次出现关键字为key的节点 …
阅读更多...
【链表OJ】相交链表 环形链表1

【链表OJ】相交链表 环形链表1

前言: &#x1f4a5;&#x1f388;个人主页:​​​​​​Dream_Chaser&#xff5e; &#x1f388;&#x1f4a5; ✨✨刷题专栏:http://t.csdn.cn/UlvTc ⛳⛳本篇内容:力扣上链表OJ题目 目录 一.leetcode 160. 相交链表 1.问题描述: 2.解题思路: 二.leetcode 141.环形链表 …
阅读更多...
【LeetCode-中等题】114. 二叉树展开为链表

【LeetCode-中等题】114. 二叉树展开为链表

文章目录 题目方法一&#xff1a;前序遍历&#xff08;构造集合&#xff09; 集合&#xff08;构造新树&#xff09;方法二&#xff1a;原地构建方法三&#xff1a;前序遍历--迭代&#xff08;构造集合&#xff09; 集合&#xff08;构造新树&#xff09; 题目 方法一&#x…
阅读更多...
leetcode18. 四数之和（java）

leetcode18. 四数之和（java）

四数之和 题目描述nSum 双指针代码演示 上期经典 题目描述 难度 - 中等 原题链接 - 四数之和 给你一个由 n 个整数组成的数组 nums &#xff0c;和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] &#xff08;若两…
阅读更多...
深入浅出：手把手教你实现单链表

深入浅出：手把手教你实现单链表

一、什么是链表 链表是一种链状数据结构。简单来说&#xff0c;要存储的数据在内存中分别独立存放&#xff0c;它们之间通过某种方式相互关联。 如果我们使用C语言来实现链表&#xff0c;需要声明一个结构体作为链表的结点&#xff0c;结点之间使用指针关联。 二、单向链表的结…
阅读更多...
9.4 【C语言】用指针处理链表

9.4 【C语言】用指针处理链表

9.4.1 什么是链表 它是动态地进行存储分配的一种结构。 链表中各元素在内存中的地址是不连续的。要找某一元素&#xff0c;必须先找到上一个元素&#xff0c;根据它提供的下一元素地址才能找到下一个元素。 如果不提供“头指针”&#xff0c;则整个链表无法访问。 9.4.2 建…
阅读更多...
4.1 链式栈StackT

4.1 链式栈StackT

C关键词&#xff1a;内部类/模板类/头插 C自学精简教程 目录(必读) C数据结构与算法实现&#xff08;目录&#xff09; 栈的内存结构 空栈&#xff1a; 有一个元素的栈&#xff1a; 多个元素的栈&#xff1a; 成员函数说明 0 clear 清空栈 clear 函数负责将栈的对内存释放…
阅读更多...
算法系列-力扣234-回文链表判定

算法系列-力扣234-回文链表判定

回文链表判定 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 方法一&#xff1a;栈反转对比法 解题思路&#xff1a;找到中间节点后用栈辅助反转对比 解题方法&#xff1…
阅读更多...
数据结构（Java实现）LinkedList与链表（下）

数据结构（Java实现）LinkedList与链表（下）

** ** 结论 让一个指针从链表起始位置开始遍历链表&#xff0c;同时让一个指针从判环时相遇点的位置开始绕环运行&#xff0c;两个指针都是每次均走一步&#xff0c;最终肯定会在入口点的位置相遇。 LinkedList的模拟实现 单个节点的实现 尾插 运行结果如下&#xff1a; 也…
阅读更多...
剑指Offer 18. 删除链表的节点

剑指Offer 18. 删除链表的节点

18. 删除链表的节点 题目 官方地址 代码&#xff08;创建一个新链表&#xff09; /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode(int x) { val x; }* }*/ class Solution {public ListNode delete…
阅读更多...
BM3 链表中的节点每k个一组翻转

BM3 链表中的节点每k个一组翻转

这个就是用栈&#xff0c;k个一组判断就好了 /*** struct ListNode {* int val;* struct ListNode *next;* ListNode(int x) : val(x), next(nullptr) {}* };*/ class Solution {public:/*** 代码中的类名、方法名、参数名已经指定&#xff0c;请勿修改&#xff0c;直接返回…
阅读更多...
力扣-复制带随机指针的链表

力扣-复制带随机指针的链表

题目 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节点的值。新节…
阅读更多...
前端需要理解的数据结构与算法知识

前端需要理解的数据结构与算法知识

1 数组 1.1 集合、列表、数组的联系与区别 集合&#xff1a;由一个或多个确定的元素所构成的整体。类型不一定相同、确定、无序、互异。 列表&#xff08;又称线性列表&#xff09;&#xff1a;按照一定的线性顺序&#xff0c;排列而成的数据项的集合。类型不一定相同、有序…
阅读更多...
leetcode分类刷题：链表（二、双指针）

leetcode分类刷题：链表（二、双指针）

1、现在再看链表问题&#xff0c;发现之前对傻傻分不清的cur.next有了更清晰的理解了&#xff1a;以cur变量表示当前节点&#xff0c;cur.next为当前节点的指针或下个节点&#xff0c;以上两个含义是一个意思&#xff0c;但在实际代码里选择其中一个进行理解会在逻辑上更清晰 2…
阅读更多...
Java：HashMap、LinkedHashMap、TreeMap集合的底层原理和集合的嵌套

Java：HashMap、LinkedHashMap、TreeMap集合的底层原理和集合的嵌套

HashMap的底层原理 LinkedHashMap的底层原理 TreeMap集合的底层原理 集合的嵌套
阅读更多...
初阶数据结构（六）队列的介绍与实现

初阶数据结构（六）队列的介绍与实现

&#x1f493;博主csdn个人主页&#xff1a;小小unicorn&#x1f493; ⏩专栏分类&#xff1a;C &#x1f69a;代码仓库&#xff1a;小小unicorn的学习足迹&#x1f69a; &#x1f339;&#x1f339;&#x1f339;关注我带你学习编程知识 栈 队列的介绍队列的概念&#xff1a;队…
阅读更多...
『 LeetCode题解 』203. 移除链表元素

『 LeetCode题解 』203. 移除链表元素

题目链接 : 『 LeetCode题解 』203. 移除链表元素 https://leetcode.cn/problems/remove-linked-list-elements/ 目录 &#x1f31f;题目要求&#x1f31f;解题思路&#xff08;动图解析&#xff09;&#x1f9d0;方案一&#x1f601;方案二 &#x1f31f;代码示列 &#x1f31…
阅读更多...
leetcode做题笔记109. 有序链表转换二叉搜索树

leetcode做题笔记109. 有序链表转换二叉搜索树

给定一个单链表的头节点 head &#xff0c;其中的元素 按升序排序 &#xff0c;将其转换为高度平衡的二叉搜索树。 本题中&#xff0c;一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差不超过 1。 思路一&#xff1a;递归双指针 struct ListNode* getMedi…
阅读更多...
探讨：atof()、atoi()、atol()

探讨：atof()、atoi()、atol()

C语言提供了一些可以将数字字符串转换成数字的一些库函数&#xff0c;例如atof()、atoi()、atol()函数。下面分别介绍这些函数的功能 atof()函数&#xff1a;将字符串转换成double型数据。atoi()函数&#xff1a;将字符串转换成int型数据。atol()函数&#xff1a;将字符串装换…
阅读更多...
【LeetCode-中等题】138. 复制带随机指针的链表

【LeetCode-中等题】138. 复制带随机指针的链表

文章目录 题目解题核心思路&#xff1a;找random指针指向思路一&#xff1a;哈希思路二&#xff1a;迭代构造新链表 方法一&#xff1a;哈希递归方法二&#xff1a;纯哈希方法三&#xff1a;迭代 节点拆分 题目 解题核心思路&#xff1a;找random指针指向 这里的拷贝属于深拷…
阅读更多...
【数据结构OJ题】设计循环队列

【数据结构OJ题】设计循环队列

原题链接&#xff1a;https://leetcode.cn/problems/design-circular-queue/ 1. 题目描述 2. 循环队列的概念和结构 为充分利用向量空间&#xff0c;克服"假溢出"现象的方法是&#xff1a;将向量空间想象为一个首尾相接的圆环&#xff0c;并称这种向量为循环向量。…
阅读更多...
删除有序链表中重复的元素-II（链表）

删除有序链表中重复的元素-II（链表）

乌&#xff01;蒙&#xff01;山&#xff01;连&#xff01;着&#xff01;山&#xff01;外&#xff01;山&#xff01; 题目&#xff1a; 思路&#xff1a; 双指针&#xff0c;slow和fast&#xff0c;并且增加标记flag初始为1。 如果slow指向节点值等于fast指向节点值&…
阅读更多...
链表2-两两交换链表中的节点删除链表的倒数第N个节点链表相交环形链表II

链表2-两两交换链表中的节点删除链表的倒数第N个节点链表相交环形链表II

今天记录的题目&#xff1a; ● 24. 两两交换链表中的节点 ● 19.删除链表的倒数第N个节点 ● 面试题 02.07. 链表相交 ● 142.环形链表II 两两交换链表中的节点 题目链接&#xff1a;24. 两两交换链表中的节点 这题比较简单&#xff0c;记录好两个节点&#xff0c;交换其nex…
阅读更多...
leetcode做题笔记114. 二叉树展开为链表

leetcode做题笔记114. 二叉树展开为链表

给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左子指针始终为 null 。展开后的单链表应该与二叉树 先序遍历 顺序相同。 思路一&#x…
阅读更多...
【数据结构OJ题】环形链表II

【数据结构OJ题】环形链表II

原题链接&#xff1a;https://leetcode.cn/problems/linked-list-cycle-ii/description/ 1. 题目描述 2. 思路分析 如果有小伙伴不了解环形链表&#xff0c;可以先看看这篇文章&#xff1a; https://blog.csdn.net/m0_62531913/article/details/132352203?spm1001.2014.300…
阅读更多...
【算法刷题之链表篇（1）】

【算法刷题之链表篇（1）】

目录 1.leetcode-82. 删除排序链表中的重复元素 II&#xff08;1&#xff09;题目描述&#xff08;2&#xff09;方法及思路&#xff08;一次遍历&#xff09;&#xff08;3&#xff09;代码实现 2.leetcode-19. 删除链表的倒数第 N 个结点&#xff08;1&#xff09;题目描述&a…
阅读更多...
LeetCode算法题：2. 两数相加

LeetCode算法题：2. 两数相加

文章目录 题目描述&#xff1a;通过代码创建新一串新链表&#xff1a; 题目描述&#xff1a; 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以…
阅读更多...
链表的尾删有几种情况要单独处理？

链表的尾删有几种情况要单独处理？

第一种&#xff1a;没有结点 assert(*pphead); 第二种&#xff1a;只有一个结点 if((*pphead)->nextNULL) {free(*pphead);*ppheadNULL; } 第三种&#xff1a;有多个结点 SLTNode* prevNULL; SLTNode* tail*pphead;while(tail->next) {prevtail;tailtail->next; …
阅读更多...
LeetCode LCR 026. 重排链表

LeetCode LCR 026. 重排链表

LCR 026. 重排链表 中等 128 相关企业 给定一个单链表 L 的头节点 head &#xff0c;单链表 L 表示为&#xff1a; L0 → L1 → … → Ln-1 → Ln 请将其重新排列后变为&#xff1a; L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → … 不能只是单纯的改变节点内部的值&#xff0c…
阅读更多...
Java中级编程大师班＜第一篇：初识数据结构与算法-链表(4)＞

Java中级编程大师班＜第一篇：初识数据结构与算法-链表(4)＞

在上一期&#xff0c;我们深入探讨了数组数据结构以及其在编程中的广泛应用&#xff0c;包括了 HashMap、HashTable、ConcurrentHashMap、HashSet、LinkedHashMap 等数据结构。这期&#xff0c;我们将开始介绍链表数据结构以及与之相关的扩展内容。链表是一种基础而强大的数据结…
阅读更多...
leetcode做题笔记141. 环形链表

leetcode做题笔记141. 环形链表

给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;…
阅读更多...
【链表OJ 10】环形链表Ⅱ(求入环节点)

【链表OJ 10】环形链表Ⅱ(求入环节点)

前言: &#x1f4a5;&#x1f388;个人主页:​​​​​​Dream_Chaser&#xff5e; &#x1f388;&#x1f4a5; ✨✨刷题专栏:http://t.csdn.cn/UlvTc ⛳⛳本篇内容:力扣上链表OJ题目 目录 leetcode142. 环形链表 II 1.问题描述 2.代码思路 3.问题分析 leetcode142. 环形链…
阅读更多...
[JDK8下的HashMap类应用及源码分析] 数据结构、哈希碰撞、链表变红黑树

[JDK8下的HashMap类应用及源码分析] 数据结构、哈希碰撞、链表变红黑树

系列文章目录 [Java基础] StringBuffer 和 StringBuilder 类应用及源码分析 [Java基础] 数组应用及源码分析 [Java基础] String&#xff0c;分析内存地址&#xff0c;源码 [JDK8环境下的HashMap类应用及源码分析] 第一篇 空构造函数初始化 [JDK8环境下的HashMap类应用及源码分…
阅读更多...
链表遍历，链表查找和统计节点，链表插入新节点，链表删除节点，链表修改指定节点,链表头插法，尾插法总结

链表遍历，链表查找和统计节点，链表插入新节点，链表删除节点，链表修改指定节点,链表头插法，尾插法总结

1.链表静态增加和动态遍历 #include <stdio.h>struct Test {int data;struct Test *next; };void printflink(struct Test *head) {while(head!NULL){printf("%d\n",head->data);head head->next;} }int main() {struct Test *head NULL;struct Test …
阅读更多...
算法通关村第二关——链表反转（黄金）

算法通关村第二关——链表反转（黄金）

算法通关村第二关——链表反转黄金挑战 K 个一组翻转链表方法一&#xff1a;自己写的方法二&#xff1a;头插法 K 个一组翻转链表 25. K 个一组翻转链表 方法一&#xff1a;自己写的 我自己写的方式有点长&#xff0c;属于一点点一路路解决那种&#xff0c;其实用到的是穿针…
阅读更多...
【数据结构初阶】四、线性表里的链表（带头+双向+循环 链表）

【数据结构初阶】四、线性表里的链表（带头+双向+循环 链表）

相关代码gitee自取&#xff1a; C语言学习日记: 加油努力 (gitee.com) 接上期&#xff1a; 【数据结构初阶】三、 线性表里的链表&#xff08;无头单向非循环链表&#xff09;_高高的胖子的博客-CSDN博客 引言 通过上期对单链表&#xff08;无头单向非循环链表&#xff0…
阅读更多...
链表OJ练习（2）

链表OJ练习（2）

一、分割链表 题目介绍&#xff1a; 思路&#xff1a;创建两个链表&#xff0c;ghead尾插大于x的节点&#xff0c;lhead尾插小于x的节点。先遍历链表。最后将ghead尾插到lhead后面&#xff0c;将大小链表链接。 我们需要在创建两个链表指针&#xff0c;指向两个链表的头节点&…
阅读更多...
LeetCode 面试题 02.06. 回文链表

LeetCode 面试题 02.06. 回文链表

文章目录 一、题目二、C# 题解 一、题目 编写一个函数&#xff0c;检查输入的链表是否是回文的。 点击此处跳转题目。 示例 1&#xff1a; 输入&#xff1a; 1->2 输出&#xff1a; false 示例 2&#xff1a; 输入&#xff1a; 1->2->2->1 输出&#xff1a; true …
阅读更多...
【数据结构】树和二叉树的概念及结构（一）

【数据结构】树和二叉树的概念及结构（一）

目录 一&#xff0c;树的概念及结构 1&#xff0c;树的定义 2&#xff0c;树结点的分类及关系 3&#xff0c;树的表示 二&#xff0c;二叉树的概念及结构 1&#xff0c;二叉树的定义 2&#xff0c;特殊的二叉树 3&#xff0c;二叉树的性质 4&#xff0c;二叉树的存储结构 1&…
阅读更多...
数据结构学习系列之用队列实现栈功能与用栈实现队列功能

数据结构学习系列之用队列实现栈功能与用栈实现队列功能

队列与栈&#xff1a;队列&#xff08;Queue&#xff09;是一种先进先出&#xff08;FIFO&#xff09;的线性表&#xff1b;栈&#xff08;Stack&#xff09;是一种后进先出&#xff08;LIFO&#xff09;的线性表&#xff1b;实例1&#xff1a;用队列实现栈的功能&#xff1b;算…
阅读更多...
C#，《小白学程序》第十一课：双向链表(Linked-List)其二，链表的插入与删除的方法（函数）与代码

C#，《小白学程序》第十一课：双向链表(Linked-List)其二，链表的插入与删除的方法（函数）与代码

1 文本格式 /// <summary> /// 改进的车站信息类 class /// 增加了 链表 需要的两个属性 Last Next /// </summary> public class StationAdvanced { /// <summary> /// 编号 /// </summary> public int Id { get; set; } 0; ///…
阅读更多...
【牛客网题目】合并k个已排序的链表

【牛客网题目】合并k个已排序的链表

目录 描述 题目分析 描述 合并 k 个升序的链表并将结果作为一个升序的链表返回其头节点。 数据范围&#xff1a;节点总数 0≤n≤5000&#xff0c;每个节点的val满足∣val∣<1000 要求&#xff1a;时间复杂度 O(nlogn) 示例1 输入&#xff1a;[{1,2,3},{4,5,6,7}]返回值…
阅读更多...
从零开始学习 Java：简单易懂的入门指南之Collection集合及list集合（二十一）

从零开始学习 Java：简单易懂的入门指南之Collection集合及list集合（二十一）

Collection集合及list集合 1.Collection集合1.1数组和集合的区别1.2集合类体系结构1.3Collection 集合概述和使用1.4Collection集合的遍历1.4.1 迭代器遍历1.4.2 增强for1.4.3 lambda表达式 2.List集合2.1List集合的概述和特点2.2List集合的特有方法2.3List集合的五种遍历方式2…
阅读更多...
代码随想录算法训练营第一天 |142.环形链表II

代码随想录算法训练营第一天 |142.环形链表II

今天是代码随想录的第一天&#xff01;Keep on&#xff01; 做了142.环形链表II这道题目 力扣链接&#xff1a;https://leetcode.cn/problems/linked-list-cycle-ii/ 代码随想录链接 讲解链接 这道题目主要问题在于&#xff1a; 判断链表是否环如果有环&#xff0c;如何找到…
阅读更多...
大厂常见面试题LRU算法实现

大厂常见面试题LRU算法实现

要实现put和get的O(1)时间复杂度 最近最少/最久使用问题 将最近最少使用的数据淘汰 LRU缓存是操作系统常见的页面缓存淘汰机制 实现方式&#xff1a;哈希表 双向链表 哈希表用于存储数据&#xff0c;主要用于实现存取操作put和get的O(1)时间复杂度双向链表用于记录最近最少…
阅读更多...
leetcode(力扣)：203移除链表元素 leetcode(力扣)：206反转链表 leetcode(力扣)：876.链表的中间结点多种解法

leetcode(力扣)：203移除链表元素 leetcode(力扣)：206反转链表 leetcode(力扣)：876.链表的中间结点多种解法

目录 203.移除链表元素 解法一&#xff1a;将目标元素前一个元素存放地址改为下一元素地址 解法二&#xff1a;遍历原链表&#xff0c;把不是val的节点拿出来进行尾插到新链表​编辑 解法三&#xff1a;有哨兵位解法->头节点不存储有效数据​编辑 206.反转链表 方法一…
阅读更多...
10链表-单链表构造LinkedList

10链表-单链表构造LinkedList

目录 LeetCode之路——707. 设计链表 分析&#xff1a; Code&#xff1a; LeetCode之路——707. 设计链表 你可以选择使用单链表或者双链表&#xff0c;设计并实现自己的链表。 单链表中的节点应该具备两个属性&#xff1a;val 和 next 。val 是当前节点的值&#xff0c;n…
阅读更多...
复习Day06：24. 两两交换链表中的节点、19.删除链表的倒数第N个节点

复习Day06：24. 两两交换链表中的节点、19.删除链表的倒数第N个节点

之前的blog链接&#xff1a;https://blog.csdn.net/weixin_43303286/article/details/131700482?spm1001.2014.3001.5501 我用的方法是在leetcode再过一遍例题&#xff0c;明显会的就复制粘贴&#xff0c;之前没写出来就重写&#xff0c;然后从拓展题目中找题目来写。辅以Lab…
阅读更多...
数据结构：线性表之-循环双向链表(万字详解)

数据结构：线性表之-循环双向链表(万字详解)

目录 基本概念 1&#xff0c;什么是双向链表 2&#xff0c;与单向链表的区别 双向链表详解 功能展示&#xff1a; 1. 定义链表 2&#xff0c;创建双向链表 3&#xff0c;初始化链表 4,尾插 5&#xff0c;头插 6&#xff0c;尾删 判断链表是否被删空 尾删代码 7&a…
阅读更多...
11链表-迭代与递归

11链表-迭代与递归

目录 LeetCode之路——206. 反转链表 分析&#xff1a; 解法一&#xff1a;迭代 解法二&#xff1a;递归 LeetCode之路——206. 反转链表 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head […
阅读更多...
链表的注意事项

链表的注意事项

LeetCode 19 删除链表的倒数第N个结点 1、sudo.next head;和head sudo.next; 的区别&#xff1f; 他们是不一样的&#xff0c;前者是将head赋给sudo.next&#xff0c;而后者是将sudo.next赋给head。 首先ab&#xff0c;那么b必须存在 我想要将sudo作为虚拟头节点&#xf…
阅读更多...
顺序表的操作(数据结构)

顺序表的操作(数据结构)

顺序表 #include <stdlib.h> #include <iostream> #include <stdio.h> #define InitSize 10typedef struct{int *data;int MaxSize;int Length; }SeqList;//创建链表 void InitList(SeqList &L){L.data(int *)malloc(InitSize*sizeof(int));L.Length0;…
阅读更多...
【数据结构初阶】六、线性表中的队列（C语言 -- 链式结构实现队列）

【数据结构初阶】六、线性表中的队列（C语言 -- 链式结构实现队列）

相关代码gitee自取&#xff1a; C语言学习日记: 加油努力 (gitee.com) 接上期&#xff1a; 【数据结构初阶】五、线性表中的栈&#xff08;C语言 -- 顺序表实现栈&#xff09;_高高的胖子的博客-CSDN博客 1 . 队列&#xff08;Queue&#xff09; 队列的概念和结构&#xf…
阅读更多...
【华为OD机试python】补种未成活胡杨【2023 B卷|100分】

【华为OD机试python】补种未成活胡杨【2023 B卷|100分】

【华为OD机试】-真题 !!点这里！！ 【华为OD机试】真题考点分类 !!点这里 !! 题目描述 近些年来，我国防沙治沙取得显著成果。某沙漠新种植N棵胡杨（编号1-N），排成一排。 一个月后，有M棵胡杨未能成活。现可补种胡杨K棵，请问如何补种（只能补种，不能新种）， 可以得到最多…
阅读更多...
Rust踩雷笔记（7）——一个链表题例子初识裸指针

Rust踩雷笔记（7）——一个链表题例子初识裸指针

题目在这https://leetcode.cn/problems/palindrome-linked-list/&#xff0c;leetcode 234的回文链表&#xff0c;思路很简单&#xff0c;就是fast和slow两个指针&#xff0c;fast一次移动两个、slow一次一个&#xff0c;最后slow指向的链表反转后和head比较就行了。 很简单一…
阅读更多...
C (1094) : DS双向链表—前驱后继

C (1094) : DS双向链表—前驱后继

Description 在双向链表中&#xff0c;A有一个指针指向了后继节点B&#xff0c;同时&#xff0c;B又有一个指向前驱节点A的指针。这样不仅能从链表头节点的位置遍历整个链表所有节点&#xff0c;也能从链表尾节点开始遍历所有节点。 对于给定的一列数据&#xff0c;按照给定的…
阅读更多...
代码随想录算法训练营第23期day3| 203.移除链表元素 ，707.设计链表，206.反转链表

代码随想录算法训练营第23期day3| 203.移除链表元素 ，707.设计链表，206.反转链表

目录 一、链表 基础操作 二、&#xff08;leetcode 203&#xff09;移除链表元素 1.使用原来的链表 2.设置虚拟头结点 三、&#xff08;leetcode 707&#xff09;设计链表 四、&#xff08;leetcode 206&#xff09;反转链表 1.双指针法 2.递归法 一、链表 单链表定义…
阅读更多...
剑指offer——JZ36 二叉搜索树与双向链表 解题思路与具体代码【C++】

剑指offer——JZ36 二叉搜索树与双向链表 解题思路与具体代码【C++】

一、题目描述与要求 二叉搜索树与双向链表_牛客题霸_牛客网 (nowcoder.com) 题目描述 输入一棵二叉搜索树&#xff0c;将该二叉搜索树转换成一个排序的双向链表。如下图所示 数据范围&#xff1a;输入二叉树的节点数 0≤n≤1000&#xff0c;二叉树中每个节点的值 0≤val≤10…
阅读更多...
头歌平台——C语言之链表练习题

头歌平台——C语言之链表练习题

第1关&#xff1a;建单向链表 任务描述 本关需要你建立一个带头结点的单向链表。 相关知识 什么是链表&#xff1f;链表和二叉树是C语言数据结构的基础和核心。 链表有多种形式&#xff0c;它可以是单链接的或者双链接的&#xff0c;可以是已排序的或未排序的&#xff0c;…
阅读更多...
链表 oj2 (7.31)

链表 oj2 (7.31)

206. 反转链表 - 力扣&#xff08;LeetCode&#xff09; 我们通过头插来实现 将链表上的节点取下来&#xff08;取的时候需要记录下一个节点&#xff09;&#xff0c;形成新的链表&#xff0c;对新的链表进行头插。 /*** Definition for singly-linked list.* struct ListNode…
阅读更多...
Leetcode.19 删除链表的倒数第 N 个结点

Leetcode.19 删除链表的倒数第 N 个结点

题目链接 Leetcode.19 删除链表的倒数第 N 个结点 mid 题目描述 给你一个链表&#xff0c;删除链表的倒数第 n n n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] 示例 2&#xff1a; 输…
阅读更多...
头歌【第2关：有序单链表中值相同的多余结点的删除操作】

头歌【第2关：有序单链表中值相同的多余结点的删除操作】

文章目录 第2关&#xff1a;有序单链表中值相同的多余结点的删除操作任务描述相关知识编程要求说明&#xff1a;测试说明代码示例&#xff1a; 第2关&#xff1a;有序单链表中值相同的多余结点的删除操作 任务描述 本关任务&#xff1a;已知单链表中的元素以值递增有序排列&a…
阅读更多...
【王道代码】【2.3链表】d1

【王道代码】【2.3链表】d1

关键字&#xff1a; 递归删除x&#xff1b;删除所有x&#xff1b;递归反向输出&#xff1b;删除最小结点&#xff08;2组指针&#xff09;&#xff1b;原地逆置&#xff1b;使递增有序
阅读更多...
算法通关村第二关-青铜终于学会链表了

算法通关村第二关-青铜终于学会链表了

大家好我是苏麟 , 今天来学反转链表 . 反转链表 描述 : 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 LeetCode 206.反转链表 : 206. 反转链表 牛客 BM1 反转链表 : 分析 : 本题有两种方法&#xff0c;带头结点和不带头结点&am…
阅读更多...
【数据结构】【C语言】【环形链表约瑟夫问题】

【数据结构】【C语言】【环形链表约瑟夫问题】

1.问题描述及背景&#xff1a; 著名的Josephus问题 据说著名犹太 历史学家 Josephus有过以下的故事&#xff1a;在罗⻢⼈占领乔塔帕特后&#xff0c;39 个犹太⼈与 Josephus及他的朋友躲到⼀个洞中&#xff0c;39个犹太⼈决定宁愿死也不要被⼈抓到&#xff0c;于是决定了⼀个⾃…
阅读更多...
【LeetCode力扣】234 快慢指针 | 反转链表 | 还原链表

【LeetCode力扣】234 快慢指针 | 反转链表 | 还原链表

目录 1、题目介绍 2、解题思路 2.1、暴力破解法 2.2、快慢指针反转链表 1、题目介绍 原题链接&#xff1a; 234. 回文链表 - 力扣&#xff08;LeetCode&#xff09; 示例 1&#xff1a; 输入&#xff1a;head [1,2,2,1]输出&#xff1a;true 示例 2&#xff1a; 输入&am…
阅读更多...
【数据结构】模拟实现LinkedList

【数据结构】模拟实现LinkedList

LinkedList是双向链表结构可以适用于任意插入场景下的插入和删除&#xff0c;效率较高&#xff0c;时间复杂度为O(1)。 模拟实现 public class MyLinkedList {static class ListNode{private int val;//值域private ListNode prev;//前驱private ListNode next;//后继public …
阅读更多...
面试算法22：链表中环的入口节点（1）

面试算法22：链表中环的入口节点（1）

题目 如果一个链表中包含环&#xff0c;那么应该如何找出环的入口节点&#xff1f;从链表的头节点开始顺着next指针方向进入环的第1个节点为环的入口节点。 例如&#xff0c;在如图4.3所示的链表中&#xff0c;环的入口节点是节点3。 分析 第1步&#xff1a;确认是否包含环…
阅读更多...
关于链表指针的深刻理解

关于链表指针的深刻理解

以下列代码为例 //终于给我搞清楚指针的指向究竟是怎么看的了// 按编号对职工记录进行递增排序 void sortById(List* list) {Employee* p, * q, * tail NULL;// tail 变量则是一个边界指针&#xff0c;初始值为 NULL。while (list->head->next ! tail) // tail 变量则是…
阅读更多...
哈希表与有序表

哈希表与有序表

哈希表与有序表 Set结构 key Map结构 key-value 哈希表 哈希表的时间复杂度都是常数项级别的&#xff0c;但常数较大 增删改查的时间都是常数级别的&#xff0c;与数据量无关 当哈希表存储的值是基础数据类型&#xff08;Integer - int&#xff09;&#xff0c;哈希表中内…
阅读更多...
【C++进阶(四)】STL大法--list深度剖析list迭代器问题探讨

【C++进阶(四)】STL大法--list深度剖析list迭代器问题探讨

&#x1f493;博主CSDN主页:杭电码农-NEO&#x1f493;   ⏩专栏分类:C从入门到精通⏪   &#x1f69a;代码仓库:NEO的学习日记&#x1f69a;   &#x1f339;关注我&#x1faf5;带你学习C   &#x1f51d;&#x1f51d; 链表list 1. 前言2. list的使用2.1 list的构造函…
阅读更多...
算法 数据结构 双向环形链表 手撸环形链表 环形链表实现容器 环形链表添加修改删除获取大小 环形链表实现自定义容器 手撸容器 双向环形哨兵链表 数据结构（六）

算法 数据结构 双向环形链表 手撸环形链表 环形链表实现容器 环形链表添加修改删除获取大小 环形链表实现自定义容器 手撸容器 双向环形哨兵链表 数据结构（六）

1. 环形链表&#xff1a; 2. 建议先不要看我写得自己先实现下&#xff0c;只将Node内部类复制自己命名得容器内&#xff0c; 实现方法&#xff1a; a. add方法&#xff08;添加到头部&#xff0c;尾部添加&#xff0c;指定位置添加&#xff09; b. get方法&#xff08;获取首部…
阅读更多...
《代码随想录》刷题笔记——链表篇【java实现】

《代码随想录》刷题笔记——链表篇【java实现】

链表节点定义 public class ListNode {// 结点的值int val;// 下一个结点ListNode next;// 节点的构造函数(无参)public ListNode() {}// 节点的构造函数(有一个参数)public ListNode(int val) {this.val val;}// 节点的构造函数(有两个参数)public ListNode(int val, ListNo…
阅读更多...
数据结构 - 单链表

数据结构 - 单链表

文章目录 目录 文章目录 一、什么是链表? 线性表: 顺序表: 二、链表的分类和实现 分类: 实现: 1.创建节点类 2.创建单链表 1.addTail(尾增) 2.删除节点值为key的第一个节点 3.插入节点(在指定位置) 4.获取链表长度 总结 前言 大家好,这篇博客给大家讲一下什么是…
阅读更多...
数据结构与算法之链表: 基于链表实现js中的原型链原理与算法实现

数据结构与算法之链表: 基于链表实现js中的原型链原理与算法实现

常见数据类型的原型链指向 obj -> Object.prototype -> nullfunc -> Function.prototype -> Object.prototype -> nullarr -> Array.prototype -> Object.prototype -> nullobj是Object实例func是Function实例&#xff0c;也是Object实例arr是Array实…
阅读更多...
数据结构与算法之链表: 使用链表指针获取JSON节点值的算法实现 (Typescript版)

数据结构与算法之链表: 使用链表指针获取JSON节点值的算法实现 (Typescript版)

查找json指定位置的值的算法实现 给定如下json和指定的位置&#xff0c;求最终的值 const json {a: { b: { c: 1} },d: { e: 2 }, }const path [a, b, c];1 &#xff09; 普通算法 let result json; path.forEach(k > {result result[k]; })console.log(result) // 最…
阅读更多...
从零开始学习 Java：简单易懂的入门指南之泛型及set集合（二十二）

从零开始学习 Java：简单易懂的入门指南之泛型及set集合（二十二）

泛型及set集合扩展 1.泛型1.1泛型概述 2.Set集合2.1Set集合概述和特点【应用】2.2Set集合的使用【应用】 3.TreeSet集合3.1TreeSet集合概述和特点【应用】3.2TreeSet集合基本使用【应用】3.3自然排序Comparable的使用【应用】3.4比较器排序Comparator的使用【应用】3.5两种比较…
阅读更多...
leetcode 23. 合并 K 个升序链表

leetcode 23. 合并 K 个升序链表

2023.9.25 本题要合并k个有序链表&#xff0c;最朴素的方法可以联想到之前做的合并两个有序链表。 用一个for循环遍历lists数组&#xff0c;利用合并两个有序链表的代码&#xff0c;不断合并lists中的链表&#xff0c;最后返回头节点即可。 代码如下&#xff1a; /*** Definit…
阅读更多...
【链表】排序链表-力扣148题

【链表】排序链表-力扣148题

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kuan 的首页,持续学…
阅读更多...
【牛客刷题】反转固定区间链表、每k个节点一组反转

【牛客刷题】反转固定区间链表、每k个节点一组反转

链表内指定区间反转_牛客题霸_牛客网 ListNode* reverseList(ListNode* head, ListNode* tail) {ListNode* pre nullptr;ListNode* cur head;while (cur ! tail) { 最后cur就是tailListNode* temp cur->next;cur->next pre;pre cur;cur temp;}return pre;}ListNode…
阅读更多...
leetcodeTop100(32) 合并链表数组

leetcodeTop100(32) 合并链表数组

给你一个链表数组&#xff0c;每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。示例 1&#xff1a;输入&#xff1a;lists [[1,4,5],[1,3,4],[2,6]] 输出&#xff1a;[1,1,2,3,4,4,5,6] package Top31_40;import Util.ListNode;…
阅读更多...
两两交换链表中节点

两两交换链表中节点

给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4] 输出&#xff1a;[2,1,4…
阅读更多...
leetcodetop100(29) K 个一组翻转链表

leetcodetop100(29) K 个一组翻转链表

K 个一组翻转链表 给你链表的头节点 head &#xff0c;每 k 个节点一组进行翻转&#xff0c;请你返回修改后的链表。 k 是一个正整数&#xff0c;它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍&#xff0c;那么请将最后剩余的节点保持原有顺序。 你不能只是单纯的改…
阅读更多...
代码随想录—力扣算法题：07.链表相交. Java版（示例代码与导图详解）

代码随想录—力扣算法题：07.链表相交. Java版（示例代码与导图详解）

版本说明 当前版本号[20230923]。 版本修改说明20230923初版 07. 链表相交 同&#xff1a;160.链表相交 力扣题目链接 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 图示…
阅读更多...
顺序表（7.24）

顺序表（7.24）

1.线性表 线性表 &#xff08; linear list &#xff09; 是 n 个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构&#xff0c;常见的线性表&#xff1a;顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构&#xff0c;也就说是连续的一…
阅读更多...
【牛客刷题】链表专项（合并两个链表、链表是否有环、链表中环的入口、删除链表的倒数第n个节点、找第一个公共节点、链表相加Ⅱ）

【牛客刷题】链表专项（合并两个链表、链表是否有环、链表中环的入口、删除链表的倒数第n个节点、找第一个公共节点、链表相加Ⅱ）

合并两个链表 https://www.nowcoder.com/share/jump/9321389651694162925269 ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {// write code hereListNode* dummy new ListNode(0);ListNode* cur dummy;ListNode* cur1 pHead1;ListNode* cur2 pHead2;while (cur1 …
阅读更多...
数据结构与算法-栈

数据结构与算法-栈

栈和队列是两种常用的线性结构&#xff0c;属于特殊的线性表&#xff0c;是线性表相关运算的一个子集。一般来说&#xff0c;线性表上的插入和删除操作不受任何限制&#xff0c;但栈只能在表的一端进行插入和删除操作&#xff0c;而队列则只能在一端进行插入操作&#xff0c;在…
阅读更多...
链表的实现（c语言）

链表的实现（c语言）

链表分为单链表、双链表和循环链表&#xff0c;这些理论知识在笔记中自然写了&#xff0c;这里我只写出其中的实现&#xff1a; 单链表的实现 #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct Book {char bookname[20];char a…
阅读更多...
【软考】9.4 图的概念/存储/遍历/最小生成树/拓扑/查找

【软考】9.4 图的概念/存储/遍历/最小生成树/拓扑/查找

《图》 图的存储&#xff08;顶点和边&#xff09; 邻接矩阵&#xff1a;适合边数较多的图&#xff0c;不易造成浪费无向图&#xff1a;不分方向&#xff1b;对称矩阵 邻接链表&#xff1a;顶点&#xff0c;边——>&#xff08;编号&#xff0c;权值&#xff09;&#xff1b…
阅读更多...
LetCode刷题[简单题](4)顺序链表的顺序合并

LetCode刷题[简单题](4)顺序链表的顺序合并

在平常的应用场景中很多时候需要将繁杂的信息进行融合&#xff0c;比如零散的时间戳信息进行合并&#xff0c;顺序链表的合并就完美的解决这种问题的痛点。相对于原本的直接合并然后再进行排序&#xff0c;数据结构的复杂度不一样&#xff0c;因此就有类似此题的北京。融合有序…
阅读更多...
【LeetCode刷题（数据结构与算法）】：合并两个有序链表

【LeetCode刷题（数据结构与算法）】：合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的 **思路&#xff1a;定义一个头尾指针置为NULL while循环依次比较两个链表的值的大小 遍历链表 比较完数值大小过后连接到tail的尾部 然后各自的链表的节点的next指针指向下一…
阅读更多...
12链表-双指针

12链表-双指针

目录 LeetCode之路——21. 合并两个有序链表 分析&#xff1a; LeetCode之路——19. 删除链表的倒数第 N 个结点 分析&#xff1a; LeetCode之路——21. 合并两个有序链表 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的…
阅读更多...
单链表经典OJ题：反转链表

单链表经典OJ题：反转链表

题目&#xff1a; 给你单链表的头节点 head &#xff0c;i请你反转链表&#xff0c;并返回反转后的链表。 图例&#xff1a; 分析&#xff1a; 根据链表的特征&#xff0c;反转链表的本质便是改变节点内部的指针方向。 将原先指向下一个节点的指针进行修改&#xff0c;将其的…
阅读更多...
链表的基本操作

链表的基本操作

&#xff08;一&#xff09;实验类型&#xff1a;设计性 &#xff08;二&#xff09;实验目的&#xff1a; 1. 掌握线性表的链式存贮结构及基本操作&#xff0c;深入了解链表的基本特性&#xff0c;以便在实际问题背景下灵活运用它们。 2. 巩固该存贮结构的构造方法&#xff0…
阅读更多...
单链表经典OJ题：合并有序链表

单链表经典OJ题：合并有序链表

目录 ​编辑 题目&#xff1a; 图例&#xff1a; 分析&#xff1a; 解法&#xff1a; 解法1: 解法2: 解法的对比&#xff1a; 解法2&#xff1a; 注意事项&#xff1a; 图例&#xff1a; 代码演示&#xff1a; 代码分析&#xff1a; 代码缺点&#xff1a; 重复…
阅读更多...
C++数据结构X篇_17_C++实现二叉树的非递归遍历（企业链表实现栈，利用栈的先进后出特点实现二叉树的非递归遍历）

C++数据结构X篇_17_C++实现二叉树的非递归遍历（企业链表实现栈，利用栈的先进后出特点实现二叉树的非递归遍历）

本篇参考C实现二叉树的非递归遍历进行整合介绍。 在C数据结构X篇_14_二叉树的递归遍历&#xff08;先序遍历、中序遍历、后续遍历方法介绍&#xff1b;举例&#xff1b;代码实现&#xff09;中我们实现二叉树通过递归遍历实现了先序、中序与后续遍历&#xff0c;那么如何通过非…
阅读更多...
6-3 递增的整数序列链表的插入 分数 5

6-3 递增的整数序列链表的插入 分数 5

List Insert(List L, ElementType X) {//创建结点List node (List)malloc(sizeof(List));node->Data X;node->Next NULL;List head L->Next; //定位real头指针//空链表 直接插入if (head NULL) {L->Next node;node->Next head;return L;}//插入数据比第…
阅读更多...
线性数据—栈、队列、链表

线性数据—栈、队列、链表

一、栈 Stack&#xff08;存取O(1)&#xff09; 先进后出&#xff0c;进去123&#xff0c;出来321。 基于数组&#xff1a;最后一位为栈尾&#xff0c;用于取操作。 基于链表&#xff1a;第一位为栈尾&#xff0c;用于取操作。 1.1、数组栈 /*** 基于数组实现的顺序栈&#…
阅读更多...
算法（二）——数组章节和链表章节

算法（二）——数组章节和链表章节

数组章节 &#xff08;1&#xff09;二分查找 给定一个 n 个元素有序的&#xff08;升序&#xff09;整型数组 nums 和一个目标值 target &#xff0c;写一个函数搜索 nums 中的 target&#xff0c;如果目标值存在返回下标&#xff0c;否则返回 -1。 class Solution {public i…
阅读更多...
算法通关村-----链表中环的问题

算法通关村-----链表中环的问题

环形链表 问题描述 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中…
阅读更多...
老卫带你学---leetcode刷题(114. 二叉树展开为链表)

老卫带你学---leetcode刷题(114. 二叉树展开为链表)

114. 二叉树展开为链表 问题&#xff1a; 给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左子指针始终为 null 。 展开后的单链表应该与…
阅读更多...
链表的概念+MySingleList的实现

链表的概念+MySingleList的实现

文章目录 链表一、 链表的概念1.概念2. 结构 二、MySingleList的实现1 .定义内部类2 .创建链表3. 遍历链表并打印4.查找单链表中是否包含关键字key5.得到链表的长度6.头插法7. 尾插法8.任意位置插入8.删除结点清空 链表 顺序存储&#xff1a;顺序表/ArrayList 优点&#xff1…
阅读更多...
经典链表问题：解析链表中的关键挑战

经典链表问题：解析链表中的关键挑战

这里写目录标题 公共子节点采用集合或者哈希采用栈拼接两个字符串差和双指针 旋转链表 公共子节点 例如这样一道题&#xff1a;给定两个链表&#xff0c;找出它们的第一个公共节点。 具体的题目描述我们来看看牛客的一道题&#xff1a; 这里我们有四种解决办法&#xff1a; …
阅读更多...
单链表的实现（全注释promax版）

单链表的实现（全注释promax版）

目录 前言&#xff1a; 哨兵位&#xff1a; 链表的概念 链表的相关操作&#xff1a; 链表的创建&#xff1a; 打印链表&#xff1a; 申请新节点&#xff1a; 链表的尾插&#xff1a; &#xff01;&#xff01;&#xff01;对于传参中二级指针的解释&#xff1a; 链表的…
阅读更多...
【数据结构】链表--双链表

【数据结构】链表--双链表

目录 一 概念及其结构 二 双向链表的实现 1 List.h 包含一下我们想要的接口 2 初始化&#xff0c;扩容和打印&#xff08;List.c) 3 尾插&#xff08;List.c) 4 尾删&#xff08;List.c) 5 头插&#xff08;List.c) 6 头删&#xff08;List.c) 7 找pos位置&#xff…
阅读更多...
LRU自定义最近最少使用-java实现

LRU自定义最近最少使用-java实现

LRU自定义最近最少使用 一&#xff1a;leetCode 题目二&#xff1a;思路三&#xff1a;上代码3.1&#xff1a;类代码3.2&#xff1a; 测试代码 一&#xff1a;leetCode 题目 题目链接&#xff1a; 题目链接&#xff1a;146.LRU缓存 为什么要写博客记录下呢&#xff1f; 1.这个…
阅读更多...
js中的数据结构：栈，队列，链表，字典哈希表，树

js中的数据结构：栈，队列，链表，字典哈希表，树

栈&#xff1a;先进后出 队列&#xff1a;先进先出 链表&#xff1a; 单链表&#xff1a; 双链表&#xff1a; 环形链表&#xff1a;最后一个数据的next指针不是指向null&#xff0c;指向的是任意之间的一个数据&#xff0c;形成一个环 数组和链表的区别&#xff1a; 字典和哈…
阅读更多...
看一下链表结构

看一下链表结构

序、慢慢来才是最快的方法。 背景 链表(Linked List) 链表是一种常见的基础数据结构&#xff0c;是一种线性表。与顺序表不同的是&#xff0c;链表中的每个节点不是顺序存储的&#xff0c;而是通过节点的指针域指向到下一个节点。 1.链表的优缺点 2.链表的类型 单链表、双链表…
阅读更多...
数据结构与算法(C语言版)P3.2---链表之带头双向循环链表的实现

数据结构与算法(C语言版)P3.2---链表之带头双向循环链表的实现

1、前言 前面一章详细介绍了链表的概念、结构以及分类。并且实现了无头单向非循环链表。 这一篇主要实现带头双向循环链表的。由于需要串联前面的知识&#xff0c;把上一篇至此&#xff1a;链表之无头单向非循环链表的实现 2、带头双向循环链表的特性和结构 2.1、结构 &#x…
阅读更多...
链表-python

链表-python

链表 一、 单链表1. 创建单链表2. 基本操作2.1 头插法2.2 尾插法2.3 遍历链表2.4 删除元素2.5 链表长度2.6 插入元素 一、 单链表 1. 创建单链表 class Node:"""节点"""def __init__(self, item):self.item item # 值self.next None # 指针…
阅读更多...
【数据结构与算法】二叉树的综合运用

【数据结构与算法】二叉树的综合运用

目录 一&#xff0c;层序遍历算法 1-1&#xff0c;队列结构的设立 1-2&#xff0c;逻辑分析 二&#xff0c;判断单值二叉树 三&#xff0c;求二叉树的最大深度 一&#xff0c;层序遍历算法 二叉树的层序遍历是一层一层的从左到右遍历&#xff0c;现在问题是二叉树不支持随…
阅读更多...
LCR 027. 回文链表

LCR 027. 回文链表

LCR 027. 回文链表 题目链接&#xff1a;LCR 027. 回文链表 注&#xff1a;该题与 234. 回文链表完全一样 代码如下&#xff1a; class Solution { public:bool isPalindrome(ListNode* head) {if(headnullptr||head->nextnullptr)return true;//找到中间节点ListNode* s…
阅读更多...
旅游景点咨询系统的设计与实现

旅游景点咨询系统的设计与实现

旅游景点咨询系统的设计与实现 /*** file 旅游景点咨询系统的设计与实现* author jUicE_g2R(qq:3406291309) * * copyright 2023.10* COPYRIGHT 原创技术笔记&#xff1a;转载需获得博主本人同意&#xff0c;且需标明转载源** language …
阅读更多...
算法 之 链表

算法 之 链表

大概说明 链表操作&#xff0c;一般两种方式保存结果&#xff0c;一是新建node作为结果&#xff0c;二是创建dummy虚拟节点&#xff0c;通过temp.next的赋值&#xff0c;修改dummy的链表&#xff0c;然后通过dummy.next返回结果。 学习中&#xff0c;记录备份一下~ 节点结构…
阅读更多...
第 2 章 线性表 （线性表的静态单链表存储结构（一个数组可生成若干静态链表））

第 2 章 线性表 （线性表的静态单链表存储结构（一个数组可生成若干静态链表））

1. 背景说明 静态单链表实现类似于单链表&#xff0c;只是指针域变成了数组下标。 2. 示例代码 1) status.h /* DataStructure 预定义常量和类型头文件 */#ifndef STATUS_H #define STATUS_H/* 函数结果状态码 */ #define TRUE 1 /* 返回值为真 */ #define FALSE …
阅读更多...
链表中环的问题和双向链表

链表中环的问题和双向链表

1.链表中环的问题 先按照快慢指针方法寻找相遇位置&#xff0c;然后将两指针分别放在链表头和相遇位置&#xff0c;并改为相同速度推进&#xff0c;则两指针在环开始位置相遇 Java实现&#xff1a;双指针法 public static ListNode detectCycleByTwoPoint(ListNode head) {if…
阅读更多...
数据结构实验一 线性表

数据结构实验一 线性表

目录 1. 好玩的约瑟夫环-单链表版本 2. 递增有序顺序表的插入 1. 好玩的约瑟夫环-单链表版本 【题目描述】 有M个人&#xff0c;编号分别为1到M&#xff0c;玩约瑟夫环游戏&#xff0c;最初时按编号顺序排成队列&#xff1b;每遍游戏开始时&#xff0c;有一个正整数报数密码…
阅读更多...
华为OD机考算法题：阿里巴巴找黄金宝箱（V）

华为OD机考算法题：阿里巴巴找黄金宝箱（V）

题目部分 题目阿里巴巴找黄金宝箱&#xff08;V&#xff09;难度易题目说明一贫如洗的樵夫阿里巴巴在去砍柴的路上&#xff0c;无意中发现了强盗集团的藏宝地&#xff0c;藏宝地有编号从0-N的箱子&#xff0c;每个箱子上面贴有一个数字。 阿里巴巴念出一个咒语数字 k ( k<N…
阅读更多...
83. 删除排序链表中的重复元素、Leetcode的Python实现

83. 删除排序链表中的重复元素、Leetcode的Python实现

博客主页&#xff1a;&#x1f3c6;看看是李XX还是李歘歘 &#x1f3c6; &#x1f33a;每天分享一些包括但不限于计算机基础、算法等相关的知识点&#x1f33a; &#x1f497;点关注不迷路&#xff0c;总有一些&#x1f4d6;知识点&#x1f4d6;是你想要的&#x1f497; ⛽️今…
阅读更多...
数据结构学习笔记——链式表示中的双链表及循环单/双链表

数据结构学习笔记——链式表示中的双链表及循环单/双链表

一、双链表 &#xff08;一&#xff09;双链表的定义 双链表是在单链表结点上增添了一个指针域prior&#xff0c;指针域prior指向当前结点的前驱结点&#xff0c;即此时链表的每个结点中都有两个指针域prior和next&#xff0c;从而可以很容易通过后继结点找到前驱结点&#x…
阅读更多...
2.数据结构-链表

2.数据结构-链表

概述 目标 链表的存储结构和特点链表的几种分类及各自的存储结构链表和数组的差异刷题(反转链表) 概念及存储结构 先来看一下动态数组 ArrayList 存在哪些弊端 插入&#xff0c;删除时间复杂度高需要一块连续的存储空间&#xff0c;对内存要求比较高&#xff0c;比如要申请…
阅读更多...
华为机试练习题：HJ51 输出单向链表中倒数第k个结点

华为机试练习题：HJ51 输出单向链表中倒数第k个结点

1、Java代码&#xff08;直接运行版&#xff09; package listnodes;import java.util.Scanner;//Definition for singly-linked list. class ListNode {int val;ListNode next;ListNode() {}ListNode(int val) { this.val val; }ListNode(int val, ListNode next) { this.va…
阅读更多...
【算法与数据结构】--常见数据结构--数组和链表

【算法与数据结构】--常见数据结构--数组和链表

一、数组 数组是一种基本的数据结构&#xff0c;它用于存储相同数据类型的元素&#xff0c;并且这些元素在内存中是连续存储的。数组是计算机科学中最常用的数据结构之一&#xff0c;具有许多重要的特性和用途。 数组的特性&#xff1a; 同一类型元素&#xff1a;数组中的元素…
阅读更多...
贪吃蛇项目实践

贪吃蛇项目实践

游戏背景&#xff1a; 贪吃蛇是久负盛名的游戏&#xff0c;它也和俄罗斯⽅块&#xff0c;扫雷等游戏位列经典游戏的⾏列。 实现基本的功能&#xff1a; 贪吃蛇地图绘制 蛇吃⻝物的功能 &#xff08;上、下、左、右⽅向键控制蛇的动作&#xff09; 蛇撞墙死亡 蛇撞⾃⾝死亡 计…
阅读更多...
计算机考研自命题(2)

计算机考研自命题(2)

1、C语言-字符串交替拼接 1、用C编程&#xff0c;将两个字符串数组存储实现交替连接如aaa和bbb两个字符连接成ababab 如aaa和baba 两个字符&#xff0c;连接成 abaaaba #include<stdio.h>/* 解题思路&#xff1a;将两个字符串交替拼接&#xff0c;定义三个数组&#xff0…
阅读更多...
【面试经典150 | 链表】合并两个有序链表

【面试经典150 | 链表】合并两个有序链表

文章目录 Tag题目来源题目解读解题思路方法一&#xff1a;递归方法二&#xff1a;迭代 写在最后 Tag 【递归】【迭代】【链表】 题目来源 21. 合并两个有序链表 题目解读 合并两个有序链表。 解题思路 一种朴素的想法是将两个链表中的值存入到数组中&#xff0c;然后对数组…
阅读更多...
算法通关村-黄金挑战K个一组反转

算法通关村-黄金挑战K个一组反转

大家好我是苏麟 , 今天带来K个一组反转 , K个一组反转 可以说是链表中最难的一个问题了&#xff0c;每k 个节点一组进行翻转&#xff0c;请你返回翻转后的链表。k 是一个正整数&#xff0c;它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍&#xff0c;那么请将最后…
阅读更多...
用Python实现链表---单向循环链表

用Python实现链表---单向循环链表

1 问题 如何利用python实现单向循环链表简化数学问题&#xff1f; 2 方法 add方法&#xff1a;向链表头部添加一个节点dataappend方法&#xff1a;向链表尾部添加一个节点&#xff0c;值为dataremove方法&#xff1a;删除链表中第一个值为data的节点 代码清单 1 class Node: …
阅读更多...
算法通关村第二关-黄金挑战K个一组反转

算法通关村第二关-黄金挑战K个一组反转

大家好我是苏麟 , 今天带来K个一组反转 , K个一组反转 可以说是链表中最难的一个问题了&#xff0c;每k 个节点一组进行翻转&#xff0c;请你返回翻转后的链表。k 是一个正整数&#xff0c;它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍&#xff0c;那么请将最后…
阅读更多...
LeetCode刷题之分隔链表（图解➕代码）

LeetCode刷题之分隔链表（图解➕代码）

首先直接进入主题&#xff0c;题目链接&#x1f517;力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 源代码在最后&#xff0c;有更优解的朋友欢迎在评论里指导我一番&#xff01; 1.题目分析 通过题目分析得出结论&#xff1a; 1. 将链表分为k个子…
阅读更多...
leetcode做题笔记203. 移除链表元素

leetcode做题笔记203. 移除链表元素

给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5]示例 2&#xff1a; 输入&#xff1a…
阅读更多...
环形链表-力扣

环形链表-力扣

一、题目描述 题目链接&#xff1a;力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 二、题解 解题思路&#xff1a; 快慢指针&#xff0c;即慢指针一次走一步&#xff0c;快指针一次走两步&#xff0c;两个指针从链表起始位置开始运行&#xff0c;…
阅读更多...
双向链表的初步练习

双向链表的初步练习

&#x1d649;&#x1d65e;&#x1d658;&#x1d65a;!!&#x1f44f;&#x1f3fb;‧✧̣̥̇‧✦&#x1f44f;&#x1f3fb;‧✧̣̥̇‧✦ &#x1f44f;&#x1f3fb;‧✧̣̥̇: Solitary-walk ⸝⋆ ━━━┓ - 个性标签 - &#xff1a;来于“云”的“羽球人”…
阅读更多...
学习笔记---更进一步的双向链表专题~~

学习笔记---更进一步的双向链表专题~~

目录 1. 双向链表的结构&#x1f98a; 2. 实现双向链表&#x1f41d; 2.1 要实现的目标&#x1f3af; 2.2 创建初始化&#x1f98b; 2.2.1 List.h 2.2.2 List.c 2.2.3 test.c 2.2.4 代码测试运行 2.3 尾插打印头插&#x1fabc; 思路分析 2.3.1 List.h 2.3.2 List.…
阅读更多...
『力扣刷题本』:反转链表

『力扣刷题本』:反转链表

一、题目 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&#xff1a;[2,1]示例 3&#xff1a;…
阅读更多...
【数据结构】数组和字符串（九）：稀疏矩阵的链接存储：十字链表的插入、查找、删除操作

【数据结构】数组和字符串（九）：稀疏矩阵的链接存储：十字链表的插入、查找、删除操作

文章目录 4.2.1 矩阵的数组表示4.2.2 特殊矩阵的压缩存储a. 对角矩阵的压缩存储b~c. 三角、对称矩阵的压缩存储d. 稀疏矩阵的压缩存储——三元组表4.2.3三元组表的转置、加法、乘法、操作4.2.4十字链表0. 十字链表的创建、遍历打印、销毁1. 插入2. 查找3. 删除4. 主函数5. 代码…
阅读更多...
代码随想录算法训练营第4天| 24. 两两交换链表中的节点、19.删除链表的倒数第N个节点、面试题 02.07. 链表相交 、142.环形链表II

代码随想录算法训练营第4天| 24. 两两交换链表中的节点、19.删除链表的倒数第N个节点、面试题 02.07. 链表相交 、142.环形链表II

JAVA语言编写 24. 两两交换链表中的节点 谷歌、亚马逊、字节、奥多比、百度 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。…
阅读更多...
合并两个有序链表（C++)

合并两个有序链表（C++)

题目 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4]示例 2&#xff1a; 输入&#xff1a;l1 [], l2 [] 输出&#xff1…
阅读更多...
经典OJ题：单链表相交

经典OJ题：单链表相交

目录 题目&#xff1a; 链表相交&#x1f34c;的概念&#xff1a; 单链表相交&#x1f34c;主要的问题&#xff1a; 思路的分析&#x1f34c;&#xff1a; 问题的回答&#xff1a; 如何判断相交&#x1f34c;&#xff1a; 如何寻找交点&#x1f34c;&#xff1a; 代码演…
阅读更多...
数组与链表算法-链表与多项式

数组与链表算法-链表与多项式

目录 数组与链表算法-链表与多项式 多项式链表表示法 C代码 数组与链表算法-链表与多项式 使用链表的最大好处就是减少内存的浪费&#xff0c;并且能增加使用上的弹性。例如数学上常用的多项式表示法&#xff0c;虽然可以使用数组方式来处理&#xff0c;但当数据内容变动时…
阅读更多...
代码随想录day4:链表总结

代码随想录day4:链表总结

两两交换链表中的节点 一开始自己的思路只是两两交换&#xff0c;并没有说涉及到前一个节点。实际上两两交换涉及到了三个节点 使用虚拟头结点&#xff0c;这样一次性处理三个节点。且每次组里第一个节点其实数值没变。 class Solution { public:ListNode* swapPairs(ListNod…
阅读更多...
数据结构───链表

数据结构───链表

花费一个周时间学完了链表&#xff08;的一部分&#xff09;&#xff0c;简单总结一下。 链表的学习离不开画图&#xff0c;将其抽象成一种逻辑模型&#xff0c;可以减少思考时间&#xff0c;方便理解。 链表大致分为8种结构&#xff0c;自己学习并实现了两种结构&#xff0c;也…
阅读更多...
LCR 021. 删除链表的倒数第 N 个结点

LCR 021. 删除链表的倒数第 N 个结点

这篇也是凑数的 .... 描述 : 给定一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点 题目 : LeetCode 删除链表的倒数第Nge节点 : LCR 021. 删除链表的倒数第 N 个结点 分析 : 首先创建一个虚拟节点(哨兵节点) , 虚拟节点下一节点指向头节…
阅读更多...
[LeetCode]-138. 随机链表的复制

[LeetCode]-138. 随机链表的复制

目录 题目 解题步骤 1.拷贝节点插入原节点的后面 2.置每个拷贝节点random 3.拷贝节点解下来&#xff0c;尾插到一起&#xff0c;恢复原链表 完整代码 题目 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表…
阅读更多...
三、基础算法精讲：链表-反转系列

三、基础算法精讲：链表-反转系列

目录 1、反转链表2、反转链表 II3、K 个一组翻转链表4、两两交换链表中的节点5、两数相加 II6、翻倍以链表形式表示的数字 1、反转链表 Leetcode 206 python 中&#xff0c;参数注解 optional[ListNode] 的含义是&#xff1a;head 参数的类型可以是 ListNode 或者 None clas…
阅读更多...
LeetCode 热题100——链表专题(一）

LeetCode 热题100——链表专题(一）

一、俩数相加 2.俩数相加&#xff08;题目链接&#xff09; 思路&#xff1a;这题题目首先要看懂&#xff0c;以示例1为例 即 342465807&#xff0c;而产生的新链表为7->0->8. 可以看成简单的从左向右&#xff0c;低位到高位的加法运算&#xff0c;4610&#xff0c;逢…
阅读更多...
[Java/力扣160]相交链表

[Java/力扣160]相交链表

这道题的关键是&#xff0c;使两个链表上的指针同时到达相交点处 方法一&#xff1a;分别遍历两个链表&#xff0c;得到其长度。然后先让较长的链表上的指针走“两链表长度之差”。然后两指针分别一步一步走&#xff0c;就能同时到达相交点处。 方法二&#xff1a;让 p1 遍历…
阅读更多...
树结构及其算法-用链表来实现二叉树

树结构及其算法-用链表来实现二叉树

目录 树结构及其算法-用链表来实现二叉树 C代码 树结构及其算法-用链表来实现二叉树 以链表实现二叉树就是使用链表来存储二叉树&#xff0c;也就是运用动态分配内存和指针的方式来建立二叉树。 使用链表来表示二叉树的好处是节点的增加与删除操作相当容易&#xff0c;缺点…
阅读更多...
160. 相交链表、Leetcode的Python实现

160. 相交链表、Leetcode的Python实现

博客主页&#xff1a;&#x1f3c6;看看是李XX还是李歘歘 &#x1f3c6; &#x1f33a;每天分享一些包括但不限于计算机基础、算法等相关的知识点&#x1f33a; &#x1f497;点关注不迷路&#xff0c;总有一些&#x1f4d6;知识点&#x1f4d6;是你想要的&#x1f497; ⛽️今…
阅读更多...
删除排序链表中的重复节点II（C++解法）

删除排序链表中的重复节点II（C++解法）

题目 给定一个已排序的链表的头 head &#xff0c; 删除原始链表中所有重复数字的节点&#xff0c;只留下不同的数字 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,3,4,4,5] 输出&#xff1a;[1,2,5]示例 2&#xff1a; 输入&#xff1a;head [1…
阅读更多...
LeetCode----25. K 个一组翻转链表

LeetCode----25. K 个一组翻转链表

题目 给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。 k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。 你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。 示…
阅读更多...
【数据结构】单双链表超详解！(图解+源码)

【数据结构】单双链表超详解！(图解+源码)

&#x1f3a5; 屿小夏 &#xff1a; 个人主页 &#x1f525;个人专栏 &#xff1a; 数据结构解析 &#x1f304; 莫道桑榆晚&#xff0c;为霞尚满天&#xff01; 文章目录 &#x1f4d1;前言&#x1f324;️链表概念&#x1f324;️链表的分类☁️单向或双向链表☁️带头或不带…
阅读更多...
图解算法数据结构-LeetBook-链表03_返回倒数第n个数

图解算法数据结构-LeetBook-链表03_返回倒数第n个数

给定一个头节点为 head 的链表用于记录一系列核心肌群训练项目编号&#xff0c;请查找并返回倒数第 cnt 个训练项目编号。 示例 1&#xff1a; 输入&#xff1a;head [2,4,7,8], cnt 1 输出&#xff1a;8 提示&#xff1a; 1 < head.length < 100 0 < head[i] < …
阅读更多...
从lc114. 二叉树展开为链表到lc-LCR 155二叉搜索树转化为排序的双向链表

从lc114. 二叉树展开为链表到lc-LCR 155二叉搜索树转化为排序的双向链表

1 lc114. 二叉树展开为链表 1.1 描述 进阶&#xff1a;你可以使用原地算法&#xff08;O(1) 额外空间&#xff09;展开这棵树吗&#xff1f; 1.2 解法一&#xff1a; 先序遍历这棵树并且将节点加入到一个list中&#xff0c;随后按顺序将list中的每一个元素的left指针置换为…
阅读更多...
链表详讲（附代码）

链表详讲（附代码）

1.什么是链表 链表是一种非常常见的数据结构&#xff0c;在程序设计中经常被使用。它由一系列节点组成&#xff0c;每个节点都有用来存放数据的数据区以及存放下一个节点地址指针的地址区。跟顺序表不同的是&#xff0c;链表的节点之间的空间并非是连续的&#xff0c;依靠地址区…
阅读更多...
【数据结构与算法】二叉树的知识讲解

【数据结构与算法】二叉树的知识讲解

目录 一&#xff0c;二叉树的结构深入认识 二&#xff0c;二叉树的遍历 三&#xff0c;二叉树的基本运算 3-1&#xff0c;计算二叉树的大小 3-2&#xff0c;统计二叉树叶子结点个数 3-3&#xff0c;计算第k层的节点个数 3-4&#xff0c;查找指定值的结点 一&#xff0c;二叉…
阅读更多...
C语言数据结构之链表

C语言数据结构之链表

目录 顺序存储和链式存储 数组—顺序存储 链表—链式存储 单链表 单链表的基本设计 单链表概念&设计 单链表的基本操作 双向链表 双向链表的基本设计 双向链表的基本操作 循环链表 循环链表的介绍及创建 循环链表的基本操作 顺序存储和链式存储 数组—顺序存…
阅读更多...
力扣382.链表随机节点（java利用数组随机返回节点值）

力扣382.链表随机节点（java利用数组随机返回节点值）

Problem: 382. 链表随机节点 文章目录 思路解题方法复杂度Code 思路 注意链表与数组的特性&#xff0c;对于随机访问读取的操作利用数组可以较方便实现&#xff0c;所以我们可以将链表中的节点值先存入到数组中最后再取出随机生成节点位置的值。 解题方法 1.生成List集合与Rand…
阅读更多...
【单链表】无头单项不循环（2）

【单链表】无头单项不循环（2）

目录 Test.c主函数 test5 test6 test7 test8 test9 Test.c总代码 SList.h头文件&函数声明 头文件 函数声明 SList.h总代码 SList.c函数实现 查询SLFind pos前面插入 pos后面插入 pos后面删除 pos删除 空间释放 SList.c总代码 今天链表。 Test.c主函…
阅读更多...
『力扣刷题本』:移除链表元素

『力扣刷题本』:移除链表元素

一、题目 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5]示例 2&#xff1a; 输入&a…
阅读更多...
leetcode_23合并K个升序链表

leetcode_23合并K个升序链表

1. 题意 题意就是题目名字。。。 合并K个升序链表 2. 题解 2.1 分治 归并排序的思想 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(int x) : val(x), next(…
阅读更多...
刷题笔记day04-链表

刷题笔记day04-链表

24. 两两交换链表中的节点 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(int x) : val(x), next(nullptr) {}* ListNode(int x, ListNode *next) : val(x),…
阅读更多...
链表题（1）

链表题（1）

链表题 今天给大家带来道链表题的练习 链表的中间节点 先给大家奉上链接&#xff1a; https://leetcode.cn/problems/middle-of-the-linked-list/description/ 题目描述; 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0…
阅读更多...
【CSDN 每日一练 ★☆☆】【链表】删除排序链表中的重复元素

【CSDN 每日一练 ★☆☆】【链表】删除排序链表中的重复元素

【CSDN 每日一练 ★☆☆】【链表】删除排序链表中的重复元素 链表 递归 题目 存在一个按升序排列的链表&#xff0c;给你这个链表的头节点 head &#xff0c;请你删除所有重复的元素&#xff0c;使每个元素 只出现一次 。 返回同样按升序排列的结果链表。 示例 示例 1&am…
阅读更多...
链表经典OJ题（链表回文结构，链表带环，链表的深拷贝）

链表经典OJ题（链表回文结构，链表带环，链表的深拷贝）

目录 前言 1.反转一个单链表。 2. 给定一个带有头结点 head 的非空单链表&#xff0c;返回链表的中间结点。 3.链表的回文结构。 4.链表带环问题&#xff08;*****&#xff09; 4.1是否带环 4.2 入环的节点 5.随机链表的复制&#xff08;链表的深拷贝&#xff09; 前言…
阅读更多...
链表OJ题【环形链表】（3）

链表OJ题【环形链表】（3）

目录 环形问题的思考 ❓Q1 ❓Q2 &#x1f642;Q2 ❓Q3 ❓Q4 8.环形链表 9.环形链表Ⅱ 今天接着链表的经典问题环形问题。大家一定要自己动手多写写。&#x1f642; 快慢指针&#xff08;保持相对距离/保持相对速度&#xff09;野指针考虑为NULL的情况带环链表&#x…
阅读更多...
精讲双向链表的销毁

精讲双向链表的销毁

相信大家子啊学习双向链表的时候对链表的销毁&#xff0c;都或多或少有些小疑惑&#xff0c;我到底是传一级指针还是传二级指针 木关系&#xff0c;这些都是小意思&#xff0c;今天我将为大家share 一下关于到底如何进行正确传指针 对于链表是销毁其实就是对链表进行一个结点一…
阅读更多...
链表题（2）

链表题（2）

链表题 今天给大家带来道链表题的练习 移除链表元素 这道题上篇文章已经解决过一次&#xff0c;这次我们换一个思路来解决这个问题。 先把链接给大家奉上&#xff1a; https://leetcode.cn/problems/remove-linked-list-elements/description/ 题目描述&#xff1a; 给你一个…
阅读更多...
线索二叉树（存储结构，线索化，寻找前驱/后继）

线索二叉树（存储结构，线索化，寻找前驱/后继）

目录 1.线索二叉树1.中序线索二叉树2.后序线索二叉树3.先序线索二叉树 2.线索二叉树的存储结构3.二叉树的线索化1.中序线索化2.先序线索化3.后序线索化 4.寻找前驱/后继1.中序线索二叉树找后继2.中序线索二叉树找中序前驱3.先序线索二叉树找先序后继4.先序线索二叉树找先序前驱…
阅读更多...
【数据结构与算法】JavaScript实现单向链表

【数据结构与算法】JavaScript实现单向链表

文章目录 一、单向链表简介二、封装单向链表类2.0.创建单向链表类2.1.append(element)2.2.toString()2.3.insert(position,element)2.4.get(position)2.5.indexOf(element)2.6.update(position,element)2.7.removeAt(position)2.8.其他方法2.9.完整实现 一、单向链表简介 链表…
阅读更多...
线性表-双向链表

线性表-双向链表

前面的动态链表或者静态链表的节点都只有一个方向唯一的指针&#xff0c;这种链表也称为单向链表 虽然单链表解决了如何存储关系为“one-to-one”的问题&#xff0c;但是其强项是从前往后访问元素&#xff0c;而不擅长从后往前访问元素&#xff0c;为了这种问题&#xff0c;可…
阅读更多...
数据结构 顺序表和链表

数据结构 顺序表和链表

1.线性表 线性表&#xff08;linear list&#xff09;是n个具有相同特性的数据元素的有限序列 线性表是一种在实际中广泛使用的数据结构&#xff0c;常见的线性表&#xff1a;顺序表、链表、栈、队列、字符串.. 线性表在逻辑上是线性结构&#xff0c;也就说是连续的一条直线…
阅读更多...
leetCode 25.K 个一组翻转链表

leetCode 25.K 个一组翻转链表

给你链表的头节点 head &#xff0c;每 k 个节点一组进行翻转&#xff0c;请你返回修改后的链表。k 是一个正整数&#xff0c;它的值小于 或 等于链表的长度。如果节点总数不是 k 的整数倍&#xff0c;那么请将最后剩余的节点保持原有顺序。你不能只是单纯的改变节点内部的值&a…
阅读更多...
CSDN每日一题学习训练——Java版（数据流的中位数、乘积最大子数组、旋转链表）

CSDN每日一题学习训练——Java版（数据流的中位数、乘积最大子数组、旋转链表）

版本说明 当前版本号[20231113]。 版本修改说明20231113初版 目录 文章目录 版本说明目录数据流的中位数题目解题思路代码思路参考代码 乘积最大子数组题目解题思路代码思路参考代码 旋转链表题目解题思路代码思路参考代码 数据流的中位数 题目 中位数是有序列表中间的数。…
阅读更多...
链表相关部分OJ题

链表相关部分OJ题

&#x1f493;作者简介&#x1f44f;&#xff1a;在校大二迷茫大学生 &#x1f496;个人主页&#x1f389;&#xff1a;小李很执着 &#x1f497;系列专栏&#xff1a;Leetcode经典题 每日分享&#xff1a;人总是在离开一个地方后开始原谅它❣️❣️❣️———————————…
阅读更多...
list的const迭代器的实现

list的const迭代器的实现

要实现const迭代器首先要实现普通迭代器&#xff0c;普通迭代器主要是要实现他的解引用、后置加加等操作符&#xff0c;他的底层是指针&#xff0c;但是不是原生指针&#xff0c;是通过用一个类进行封装&#xff0c;通过对类进行传参数来解决问题&#xff0c;先定义链表的结点 …
阅读更多...
leetcode：141. 环形链表

leetcode：141. 环形链表

一、题目 函数原型&#xff1a; bool hasCycle(struct ListNode *head) 二、算法 判断不是环形链表&#xff0c;只需遍历链表找到空结点即可。 判断是环形链表&#xff0c;由于链表是环形的&#xff0c;遍历不会永远不会结束。所以要设置快慢指针&#xff0c;慢指针一次走一步&…
阅读更多...
【华为OD机试高分必刷题目】生理周期（C++-模拟迭代实现）

【华为OD机试高分必刷题目】生理周期（C++-模拟迭代实现）

🚀你的旅程将在这里启航！本专栏所有题目均包含优质解题思路，高质量解题代码，详细代码讲解，助你深入学习，高分通过！ 文章目录 【华为OD机试高分必刷题目】生理周期（C++-模拟迭代实现）题目描述解题思路java题解代码代码OJ评判结果代码讲解寄语【华为OD机试高分必刷题目…
阅读更多...
【数据结构与算法】链表与队列

【数据结构与算法】链表与队列

&#x1f4e2;&#xff1a;如果你也对机器人、人工智能感兴趣&#xff0c;看来我们志同道合✨ &#x1f4e2;&#xff1a;不妨浏览一下我的博客主页【https://blog.csdn.net/weixin_51244852】 &#x1f4e2;&#xff1a;文章若有幸对你有帮助&#xff0c;可点赞 &#x1f44d;…
阅读更多...
图识单链表

图识单链表

CSDN主页&#xff1a;醋溜马桶圈_C语言进阶,初始C语言,数据结构-CSDN博客 Gitee主页&#xff1a;mnxcc (mnxcc) - Gitee.com 专栏&#xff1a;数据结构_醋溜马桶圈的博客-CSDN博客 我们之前学习了顺序表的有关知识&#xff0c;顺序表存在下面的问题&#xff1a; 尾插效率还不错…
阅读更多...
牛客网：OR36 链表的回文结构

牛客网：OR36 链表的回文结构

一、题目 函数原型&#xff1a; bool chkPalindrome(ListNode* A) 二、思路 判断一个单链表是否为回文结构&#xff0c;由于单链表不能倒序遍历&#xff0c;所以需要找到单链表的后半段&#xff0c;并将其逆置&#xff0c;再与前半段链表进行比较。 如何找到单链表的后半段呢&a…
阅读更多...
C语言——分割单向链表

C语言——分割单向链表

本文的内容是使用C语言分割单向链表&#xff0c;给出一个链表和一个值&#xff0c;要求链表中小于给定值的节点全都位于大于或等于给定值的节点之前&#xff0c;打印原始链表的所有元素和经此操作之后链表的所有元素。 分析&#xff1a;本题只是单向链表的分割&#xff0c;不涉…
阅读更多...
力扣.82删除链表中的重复元素（java语言实现）

力扣.82删除链表中的重复元素（java语言实现）

Problem: 82. 删除排序链表中的重复元素 II 文章目录 思路解题方法复杂度Code 思路 思路类似83题的常规解法和建立虚拟头节点的结合&#xff0c;不同的是本题目要删去所有重复节点&#xff0c;为解决该问题我们再次利用虚拟头节点和尾指针&#xff0c;遍历时若遇到当当前节点值…
阅读更多...
[数据结构]—带头双向循环链表——超详解

[数据结构]—带头双向循环链表——超详解

&#x1f493;作者简介&#x1f389;&#xff1a;在校大二迷茫大学生 &#x1f496;个人主页&#x1f389;&#xff1a;小李很执着 &#x1f497;系列专栏&#x1f389;&#xff1a;数据结构 每日分享✨&#xff1a;旅行是为了迷路&#xff0c;迷路是为了遇上美好❣️❣️❣️ …
阅读更多...
DAY13 链表

DAY13 链表

数组 静态数组 例子 : int nums[5] {0}; struct person ps[5]; 缺点 : 1,无法修改地址 2,无法动态定义长度 3,占用内存过大或过小 4,增删速度慢 优点 数组的内存是连续开辟的, 所以读取速度快 动态数组 例子 : int *nums (int *) calloc(5,sizeof(int)); struct …
阅读更多...
C语言：链表

C语言：链表

首先&#xff0c;什么是链表呢&#xff1f; 链表是由节点组成的一种数据结构&#xff0c;它的每一个节点包含数据和指向下一个节点的引用。 常见的链表有许多种&#xff1a; 单链表&#xff1a;每个节点只有一个指向下一个节点的引用。双链表&#xff1a;每个节点有指向前一…
阅读更多...
队列的实现---超详细

队列的实现---超详细

队列的实现—超详细 文章目录 队列的实现---超详细一、队列的模型二、代码实现以及测试用例①队列初始化②入队③出队④输出队头⑤输出队尾⑥判断队列是否为空⑦队列的长度⑧队列的销毁⑨测试用例 一、队列的模型 队列&#xff1a;只允许在一端进行插入数据操作&#xff0c;在…
阅读更多...
经典OJ题：随机链表的复制

经典OJ题：随机链表的复制

目录 题目&#xff1a; 本题的解图关键在于画图与看图&#xff01; 思路分析&#xff1a; 方法一&#xff1a;暴力求解法。 方法二&#xff1a;插入法 方法解析&#xff1a; 步骤一、插入 步骤二、 处理每一个copy的randdom指针⭐————重点 步骤三、拆卸节点 代码…
阅读更多...
力扣2095.删除链表的中间节点（java快慢指针）

力扣2095.删除链表的中间节点（java快慢指针）

Problem: 2095. 删除链表的中间节点 文章目录 思路解题方法复杂度Code 思路 利用快慢指针&#xff0c;快指针每次走两步&#xff0c;慢指针每次走一步&#xff08;循环退出条件是fast指针不为空同时fast.next不为空&#xff09;&#xff0c;但是我们容易发现这样到最后slow指针…
阅读更多...
[LeetCode]-876.链表的中间结点-206.反转链表-21.合并两个有序链表-203.移除链表元素

[LeetCode]-876.链表的中间结点-206.反转链表-21.合并两个有序链表-203.移除链表元素

目录 876.链表的中间结点 题目 思路 代码 206.反转链表 题目 思路 代码 21.合并两个有序链表 题目 思路 代码 203.移除链表元素 题目 思路 代码 876.链表的中间结点 876. 链表的中间结点 - 力扣&#xff08;LeetCode&#xff09;https://leetcode.cn/problems/mi…
阅读更多...
【算法-链表2】反转链表 和 两两交换链表节点

【算法-链表2】反转链表 和 两两交换链表节点

今天&#xff0c;带来链表相关算法的讲解。文中不足错漏之处望请斧正&#xff01; 理论基础点这里 反转链表 1. 思路 链表操作的本质是修改连接关系&#xff0c;本题我们需要反转链表&#xff0c;也就是每次都让当前节点的next指向自己的上一个。而题目给的是单链表&#xf…
阅读更多...
大厂秋招真题【模拟】阿里蚂蚁20231010秋招T2-奇偶操作

大厂秋招真题【模拟】阿里蚂蚁20231010秋招T2-奇偶操作

题目描述与示例 题目描述 小红有一个长度为n的数组a&#xff0c;她将对数组进行m次操作&#xff0c;每次操作有两种类型&#xff1a; 将数组中所有值为奇数的元素加上x将数组中所有值为偶数的元素加上x 请你输出m次操作后的数组 输入描述 第一行两个整数n和m&#xff0c;…
阅读更多...
手写链表C++

手写链表C++

目录 一、链表基本概念以及注意事项 1.1 构造函数与析构函数 1.2 插入元素 1.3 重载运算符 二、小结 一、链表基本概念以及注意事项 在工作中&#xff0c;链表是一种常见的数据结构&#xff0c;可以用于解决很多实际问题。在学习中&#xff0c;掌握链表可以提高编程能力和…
阅读更多...
链表面试OJ题（1）

链表面试OJ题（1）

今天讲解两道链表OJ题目。 1.链表的中间节点 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结点。 示例 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[3,4,5] 解释&#xff1a;链表只有一个…
阅读更多...
LinkedList概念+MyLinkedList的实现

LinkedList概念+MyLinkedList的实现

文章目录 LinkedList笔记一、 LinkedList1.概念2.LinkedList的构造方法3.LinkedList的遍历 二、MyLinkedList的实现1.定义内部类2.打印链表、求链表长度、判断是否包含关键字3. 头插法和尾插法4.在任意位置插入5.删除结点6.清空链表 LinkedList笔记 一、 LinkedList 1.概念 L…
阅读更多...
138.随机链表的复制（LeetCode）

138.随机链表的复制（LeetCode）

深拷贝&#xff0c;是指将该链表除了正常单链表的数值和next指针拷贝&#xff0c;再将random指针进行拷贝 想法一 先拷贝出一份链表&#xff0c;再对于每个节点的random指针&#xff0c;在原链表进行遍历&#xff0c;找到random指针的指向&#xff0c;最后完成拷贝链表random…
阅读更多...
算法进阶——链表中环的入口节点

算法进阶——链表中环的入口节点

题目 给一个长度为n链表&#xff0c;若其中包含环&#xff0c;请找出该链表的环的入口结点&#xff0c;否则&#xff0c;返回null。 数据范围&#xff1a;1<结点值<10000 要求&#xff1a;空间复杂度O(1)&#xff0c;时间复杂度O(n) 例如&#xff0c;输入{1,2},{3,4,5…
阅读更多...
【数据结构(三)】双向链表（2）

【数据结构(三)】双向链表（2）

文章目录 1. 基本概念2. 管理双向链表的思路3. 代码实现 1. 基本概念 管理单向链表的缺点分析: ①单向链表&#xff0c;查找的方向只能是一个方向&#xff0c;而双向链表可以向前或者向后查找。     ②单向链表不能自我删除&#xff0c;需要靠辅助节点 &#xff0c;而双向…
阅读更多...
【C++干货铺】list的使用 | 模拟实现

【C++干货铺】list的使用 | 模拟实现

个人主页点击直达&#xff1a;小白不是程序媛 C专栏&#xff1a;C干货铺 代码仓库&#xff1a;Gitee 目录 list的介绍及使用 list的介绍 list的使用 list的构造 list迭代器的使用 list的增删查改 list的模拟实现 结点的封装 迭代器的封装 list成员变量 构造函数 …
阅读更多...
代码随想录-刷题第四天

代码随想录-刷题第四天

24. 两两交换链表中的节点 题目链接&#xff1a;24. 两两交换链表中的节点 思路&#xff1a;直接用递归的方式来写&#xff0c;只要搞明白递归函数的定义&#xff0c;然后利用这个定义就可以完成这道题。 class Solution {// 定义&#xff1a;输入以 head 开头的单链表&…
阅读更多...
C语言链表使用

C语言链表使用

目录 双链表增删改查链表带功能函数 双链表增删改查 #include <stdio.h> #include <stdlib.h>// 双链表结点的定义 typedef struct DNode{int data;struct DNode *prev;struct DNode *next; } DNode;// 创建双链表 DNode *createDoublyLinkedList() {int n, i;pri…
阅读更多...
【TypeScript】常见数据结构与算法（二）：链表

【TypeScript】常见数据结构与算法（二）：链表

文章目录 链表结构&#xff08;LinkedList&#xff09;链表以及数组的缺点数组链表的优势 什么是链表?封装链表相关方法源码链表常见面试题237-删除链表中的节点206 - 反转链表 数组和链表的复杂度对比 链表结构&#xff08;LinkedList&#xff09; 链表以及数组的缺点 链表…
阅读更多...
【链表之练习题】

【链表之练习题】

文章目录 翻转链表找到链表的中间节点返回倒数第k个节点合并两个有序链表判断链表是否回文注意 翻转链表 //反转链表//实质上是把每一个节点头插法,原本第一个节点变成最后一个节点public ListNode reverseList(){//链表为空if (head null){return null;}//链表只有一个节点if…
阅读更多...
力扣每日一道系列 --- LeetCode 206. 反转链表

力扣每日一道系列 --- LeetCode 206. 反转链表

&#x1f4f7; 江池俊&#xff1a; 个人主页 &#x1f525;个人专栏&#xff1a; ✅数据结构探索 ✅LeetCode每日一道 &#x1f305; 有航道的人&#xff0c;再渺小也不会迷途。 LeetCode 206. 反转链表 思路一&#xff1a;头插 初始化两个指针&#xff0c;cur 和 newhead。…
阅读更多...
双向链表超详解——连我奶奶都能学会的复杂链表(带头双向循环)

双向链表超详解——连我奶奶都能学会的复杂链表(带头双向循环)

文章目录 前言一、双向链表的概念二、双向链的结构设计三、双链表的基本功能接口四、双向链表接口的实现4.1、创建结点4.2、初始化链表4.3、打印链表4.4、尾插结点4.5、尾删结点4.6、头插结点4.7、头删结点4.8、在pos结点前面插入4.9、删除pos位置的结点4.10、查找链表中的某个…
阅读更多...
python二叉树链树_树的链式存储结构

python二叉树链树_树的链式存储结构

二叉链树是一种树状数据结构&#xff0c;其中每个节点最多有两个子节点&#xff0c;分别称为左子节点和右子节点。每个节点包含一个数据元素和指向其左右子节点的指针。二叉链树可以是空树&#xff0c;也可以是具有以下特点的非空树&#xff1a; 1. 每个节点最多有两个子节点。…
阅读更多...
LeetCode.203移除链表元素（原链表操作、虚拟头结点）

LeetCode.203移除链表元素（原链表操作、虚拟头结点）

LeetCode.203移除链表元素 1.问题描述2.解题思路3.代码 1.问题描述 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val …
阅读更多...
LeetCode Hot100 114.二叉树展开为链表

LeetCode Hot100 114.二叉树展开为链表

题目&#xff1a; 给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左子指针始终为 null 。展开后的单链表应该与二叉树 先序遍历 顺序相同…
阅读更多...
【数据结构实验】图（二）将邻接矩阵存储转换为邻接表存储

【数据结构实验】图（二）将邻接矩阵存储转换为邻接表存储

文章目录 1. 引言2. 邻接表表示图的原理2.1 有向权图2.2 无向权图2.3 无向非权图2.1 有向非权图 3. 实验内容3.1 实验题目&#xff08;一&#xff09;数据结构要求&#xff08;二&#xff09;输入要求&#xff08;三&#xff09;输出要求 3.2 算法实现 4. 实验结果 1. 引言 图是…
阅读更多...
LeetCode——链表（Java）

LeetCode——链表（Java）

链表 简介[简单] 203. 移除链表元素[中等] 707. 设计链表[简单] 206. 反转链表[中等] 24. 两两交换链表中的节点[中等] 19. 删除链表的倒数第 N 个结点 简介 记录一下自己刷题的历程以及代码。写题过程中参考了 代码随想录。会附上一些个人的思路&#xff0c;如果有错误&#…
阅读更多...
JZ22：链表中倒数第k个结点

JZ22：链表中倒数第k个结点

JZ22&#xff1a;链表中倒数第k个结点 题目描述&#xff1a; 输入一个链表&#xff0c;输出该链表中倒数第k个结点。 示例1 输入&#xff1a; 1,{1,2,3,4,5} 返回值&#xff1a; {5} 分析&#xff1a; 快慢指针思想&#xff1a; 需要两个指针&#xff0c;快指针fast&…
阅读更多...
栈和队列的实现及相关面试题

栈和队列的实现及相关面试题

栈和队列 栈概念与结构栈的功能栈的实现头文件Stack.h栈的结构体 Stack 源文件Stack.c初始化 void StackInit(Stack* ps)压栈 void StackPush(Stack* ps, STDataType data)出栈 void StackPop(Stack* ps)返回栈顶的值 STDataType StackTop(Stack* ps)返回栈中元素的个数 int St…
阅读更多...
LeetCode-剑指 Offer 22. 链表中倒数第k个节点（C语言 ）

LeetCode-剑指 Offer 22. 链表中倒数第k个节点（C语言 ）

目录捏 一、题目描述二、示例与提示三、思路四、代码 一、题目描述 给定一个头节点为 head 的链表用于记录一系列核心肌群训练项目编号&#xff0c;请查找并返回倒数第 cnt 个训练项目编号。 二、示例与提示 示例 1&#xff1a; 输入&#xff1a; head [2,4,7,8], cnt 1 输…
阅读更多...
数据结构线性表——带头双向循环链表

数据结构线性表——带头双向循环链表

前言&#xff1a;小伙伴们好久不见啦&#xff0c;上篇文章我们一起学习了数据结构线性表其一的单链表&#xff0c;了解了单链表的不少好处&#xff0c;但是不可能有完美的数据结构&#xff0c;就算是单链表&#xff0c;也会有很多缺点。 那么今天这篇文章&#xff0c;我们就来…
阅读更多...
C语言每日一题（28） 反转链表

C语言每日一题（28） 反转链表

牛客网 BM1 反转链表 题目描述 描述 给定一个单链表的头结点pHead(该头节点是有值的&#xff0c;比如在下图&#xff0c;它的val是1)&#xff0c;长度为n&#xff0c;反转该链表后&#xff0c;返回新链表的表头。 数据范围&#xff1a; 0≤n≤1000 要求&#xff1a;空间复…
阅读更多...
LeetCode | 234. 回文链表

LeetCode | 234. 回文链表

LeetCode | 234. 回文链表 O链接 这里的解法是先找到中间结点然后再将中间节点后面的节点逆序一下然后再从头开始和从中间开始挨个比较如果中间开始的指针到走最后都相等&#xff0c;就返回true&#xff0c;否则返回false 代码如下&#xff1a; struct ListNode* reverseLis…
阅读更多...
C语言每日一题（31）相交链表

C语言每日一题（31）相交链表

力扣160.相交链表 题目描述 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意…
阅读更多...
【华为OD机试高分必刷题目】神奇的卡片（Java-等差数列实现）

【华为OD机试高分必刷题目】神奇的卡片（Java-等差数列实现）

🚀你的旅程将在这里启航！本专栏所有题目均包含优质解题思路，高质量解题代码，详细代码讲解，助你深入学习，高分通过！ 文章目录 【华为OD机试高分必刷题目】神奇的卡片（Java-等差数列实现）题目描述解题思路Java题解代码代码OJ评判结果代码讲解寄语【华为OD机试高分必刷题…
阅读更多...
『力扣刷题本』:链表的回文结构

『力扣刷题本』:链表的回文结构

大家好呀&#xff0c;我是罗根。 大二上学期的课是真的多&#xff0c;最近也一直在学数据结构&#xff0c;忙的事情有点多&#xff0c;所以又拖更几个星期啦。不过这周是学校的素质教育周&#xff0c;一周都没上课&#xff0c;就参加各种活动&#xff0c;刷够 28 个学时就能拿…
阅读更多...
立冬特辑-----链表OJ题优选合集～～

立冬特辑-----链表OJ题优选合集～～

目录 ​​​​​​​前言&#x1f333; 1.链表中倒数第k个结点&#x1f338; 1.1 思路 1.2 代码 2. 链表的回文结构&#x1fab8; 2.1 思路 2.2 代码 3.相交链表&#x1f32a;️ 3.1 思路 3.2 代码 4.环形链表I&#x1f30a;&#x1f6f3;️ 4.1 思路 4.2 代码 4…
阅读更多...
图书馆整理I（从尾到头打印列表），剑指offer，力扣

图书馆整理I（从尾到头打印列表），剑指offer，力扣

目录 题目地址&#xff1a; 我们直接看题解吧&#xff1a; 解题方法&#xff1a; 难度分析&#xff1a; 审题目事例提示&#xff1a; 解题思路(辅助栈)&#xff1a; 代码&#xff08;递归&#xff09;&#xff1a; 代码&#xff08;列表插入&#xff09;&#xff1a; 相似题目对…
阅读更多...
单链表在线OJ题（详解+图解）

单链表在线OJ题（详解+图解）

1.删除链表中等于给定值 val 的所有节点 本题的要求是输入一个val的整形值&#xff0c;若链表中节点存储的值与val相等&#xff0c;则删除这个节点&#xff0c;并最后返回这个删除节点后的链表&#xff0c;思路如下&#xff1a; 我们可以直接使用while循环&#xff0c;并且使用…
阅读更多...
【Python数据结构与算法】——(线性结构)精选好题分享,不挂科必看系列

【Python数据结构与算法】——(线性结构)精选好题分享,不挂科必看系列

&#x1f308;个人主页: Aileen_0v0&#x1f525;系列专栏:<<Python数据结构与算法专栏>>&#x1f4ab;个人格言:"没有罗马,那就自己创造罗马~" 时间复杂度大小比较 1.time complexity of algorithm A is O(n^3) while algorithm B is O(2^n). Which o…
阅读更多...
关于链表的几道算法题

关于链表的几道算法题

1.删除链表的倒数第n个节点 力扣https://leetcode.cn/submissions/detail/482739445/ /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* ListNode(…
阅读更多...
【数据结构与算法】JavaScript实现双向链表

【数据结构与算法】JavaScript实现双向链表

文章目录 一、双向链表简介二、封装双向链表类2.0.创建双向链表类2.1.append(element)2.2.toString()汇总2.3.insert(position,element)2.4.get(position)2.5.indexOf(element)2.7.update(position,element)2.8.removeAt(position)2.9.其他方法2.10.完整实现 三、链表结构总结3…
阅读更多...
力扣23. 合并 K 个升序链表（java，最小堆解法）

力扣23. 合并 K 个升序链表（java，最小堆解法）

Problem: 23. 合并 K 个升序链表 文章目录 题目描述思路解题方法复杂度Code 题目描述 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 思路 1.对于合并k个有序链表&#xff0c;我们较为容易想…
阅读更多...
【追求卓越02】数据结构--链表

【追求卓越02】数据结构--链表

引导 今天我们进入链表的学习&#xff0c;我相信大家对链表都很熟悉。链表和数组一样&#xff0c;作为最基础的数据结构。在我们的工作中常常会使用到。但是我们真的了解到数组和链表的区别吗&#xff1f;什么时候使用数组&#xff0c;什么时候使用链表&#xff0c;能够正确的选…
阅读更多...
单链表OJ题——10.环形链表2

单链表OJ题——10.环形链表2

10.环形链表2 142. 环形链表 II - 力扣&#xff08;LeetCode&#xff09; /* 解题思路&#xff1a; 如果链表存在环&#xff0c;则fast和slow会在环内相遇&#xff0c;定义相遇点到入口点的距离为X,定义环的长度为C,定义头到入口的距离为L,fast在slow进入环之后一圈内追上slow…
阅读更多...
单链表在线OJ题二（详解+图解）

单链表在线OJ题二（详解+图解）

1.在一个排序的链表中&#xff0c;存在重复的结点&#xff0c;请删除该链表中重复的结点&#xff0c;重复的结点不保留&#xff0c;返回链表头指针 本题的意思是要删除链表中重复出现的节点&#xff0c;然后返回删除重复节点后的链表。 我们可以直接用一个哨兵位以便于观察链表…
阅读更多...
【2 线性表】判断链表是否递增。

【2 线性表】判断链表是否递增。

bool judge_ascend(Linklist L){if(!L||!L->next)return true;LNode *preL,*pL->next;while(p&&pre->data<p->data){prep;pp->next;}if(pnull)return true;elsereturn false; }
阅读更多...
算法通关村第一关—青铜挑战—用Java基本实现各种链表操作

算法通关村第一关—青铜挑战—用Java基本实现各种链表操作

文章目录 第一关—链表【青铜挑战】1.1 单链表的概念1.2 链表的相关概念1.3 创建链表 - Java实现1.4 链表的增删改查1.4.1 遍历单链表 - 求单链表长度1.4.2 链表插入 - 三种位置插入&#xff08;1&#xff09;在链表的表头插入&#xff08;2&#xff09;在链表的中间插入&#…
阅读更多...
【算法】链表-20231123

【算法】链表-20231123

这里写目录标题 一、19. 删除链表的倒数第 N 个结点二、21. 合并两个有序链表三、24. 两两交换链表中的节点 一、19. 删除链表的倒数第 N 个结点 提示 中等 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 输入&#xff1a;head [1,…
阅读更多...
卡码网15 .链表的基本操作III

卡码网15 .链表的基本操作III

链表的基础操作III 时间限制&#xff1a;1.000S 空间限制&#xff1a;128MB 题目描述 请编写一个程序&#xff0c;实现以下链表操作&#xff1a;构建一个单向链表&#xff0c;链表中包含一组整数数据。 1. 实现在链表的第 n 个位置插入一个元素&#xff0c;输出整个链表的…
阅读更多...
反转链表的实现

反转链表的实现

题目描述&#xff1a; 给出一个链表的头节点&#xff0c;将其反转&#xff0c;并返回新的头节点 思路1&#xff1a;反转地址 将每个节点里的地址由指向下一个节点变为指向前一个节点 定义三个结构体指针n1,n2,n3,n1表示改后指针的地址&#xff0c;n2表示要修改结构体里next的…
阅读更多...
循环单向链表（详解）

循环单向链表（详解）

循环单向链表原理 循环单项链表项目结构 头文件RecycleLinlList.h 头文件具体代码 #ifndef RECYCLRLINKLIST #define RECYCLRLINKLIST#include <stdio.h> #include <stdlib.h>// 宏定义 #define CIRCLELINKLIST_TRUE 1 #define CIRCLELINKLIST_FALSE 0 // 链表…
阅读更多...
数据结构基础（顺序表）

数据结构基础（顺序表）

顺序表完整代码 SeqList.hSeqList.ctest.c SeqList.h #pragma once#include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h>//#define N 1000 //typedef int SLDataType;静态顺序表 //typedef struct SeqList { // SLDataTy…
阅读更多...
【C++代码】链表

【C++代码】链表

算法&#xff1a;搜索、查找、排序、双指针、回溯、分治、动态规划、贪心、位运算、数学等。 数据结构&#xff1a;数组、栈、队列、字符串、链表、树、图、堆、哈希表等。 数据结构是为实现对计算机数据有效使用的各种数据组织形式&#xff0c;服务于各类计算机操作。不同的…
阅读更多...
链表？细！详细知识点总结！

链表？细！详细知识点总结！

链表 定义&#xff1a;链表是一种递归的数据结构&#xff0c;它或者为空&#xff08;null)&#xff0c;或者是指向一个结点&#xff08;node&#xff09;的引用&#xff0c;该结点含有一个泛型的元素和一个指向另一条链表的引用。 ​ 其实链表就是有序的列表&#xff0c;它在内…
阅读更多...
leetcode设计循环队列（链表方式来实现）

leetcode设计循环队列（链表方式来实现）

上次我们那个设计循环队列的时候用的是数组&#xff0c;因为那个时候还是不太会链表&#xff0c;现在有了链表的思路&#xff0c;我们一起来看看解题步骤吧。 https://leetcode.cn/problems/design-circular-queue/description/ 设计循环队列 那我们其实最主要的就是我们这个…
阅读更多...
设计一个算法，将链表中所有结点的链接方向“原地”逆转，即要求仅利用原表的存储空间，换句话说，要求算法的空间复杂度为O（1）

设计一个算法，将链表中所有结点的链接方向“原地”逆转，即要求仅利用原表的存储空间，换句话说，要求算法的空间复杂度为O（1）

设计一个算法&#xff0c;将链表中所有结点的链接方向“原地”逆转&#xff0c;即要求仅利用原表的存储空间&#xff0c;换句话说&#xff0c;要求算法的空间复杂度为O&#xff08;1&#xff09; 代码思路&#xff1a; 这里要求不用额外空间&#xff0c;那么就要考虑链表自身的…
阅读更多...
【算法萌新闯力扣】：回文链表

【算法萌新闯力扣】：回文链表

力扣题目&#xff1a;回文链表 开篇 今天是备战蓝桥杯的第23天。我加入的编程导航算法通关村也在今天开营啦&#xff01;那从现在起&#xff0c;我的算法题更新会按照算法村的给的路线更新&#xff0c;更加系统。大家也可以关注我新开的专栏“算法通关村”。里面会有更全面的知…
阅读更多...
每日一题--相交链表

每日一题--相交链表

离思五首-元稹 曾经沧海难为水&#xff0c;除却巫山不是云。 取次花丛懒回顾&#xff0c;半缘修道半缘君。 目录 题目描述&#xff1a; 思路分析&#xff1a; 方法及时间复杂度&#xff1a; 法一 计算链表长度(暴力解法) 法二 栈 法三 哈希集合 法四 map或unordered_map…
阅读更多...
单链表原来是这样实现的！

单链表原来是这样实现的！

文章目录 前言1. 链表的概念及结构1.1在链表里&#xff0c;每节“车厢”是什么样的呢&#xff1f;1.2为什么还需要指针变量来保存下⼀个节点的位置&#xff1f; 2. 单链表的实现1. 定义结构体(Seqlist)2. 打印函数(SLTPrint)小插曲&#xff0c;创建节点函数CreateNode3. 尾插函…
阅读更多...
数据结构——带头循环双向链表（List）

数据结构——带头循环双向链表（List）

1、带头双向循环链表介绍 在上一篇博客中我们提到了链表有三个特性&#xff0c;可以组合成为8种不同类型的链表。单链表是其中比较重要的一种&#xff0c;那么这次我们选择和带头双向循环链表会会面&#xff0c;这样我们就见识过了所有三种特性的呈现。 带头双向循环链表&#…
阅读更多...
试写一算法将两个递增有序的带头结点的单链表合并为一个递增有序的带头结点的单链表。（利用原表结点空间）

试写一算法将两个递增有序的带头结点的单链表合并为一个递增有序的带头结点的单链表。（利用原表结点空间）

试写一算法将两个递增有序的带头结点的单链表合并为一个递增有序的带头结点的单链表。 &#xff08;利用原表结点空间&#xff09; 比如现在要将下面两个链表合并&#xff0c;这里是要求利用原表空间 我们先创建一个辅助的链表L3&#xff0c;用p和q分别标记L1和L2的数据元素&…
阅读更多...
Redis链表使用

Redis链表使用

Redis是优秀的非关系型数据库&#xff0c;源码中的链表是很经典&#xff0c;将其提取使用 /* adlist.c - A generic doubly linked list implementation** Copyright (c) 2006-2010, Salvatore Sanfilippo <antirez at gmail dot com>* All rights reserved.** Redistri…
阅读更多...
【nowcoder】BM3 链表中的节点每k个一组翻转

【nowcoder】BM3 链表中的节点每k个一组翻转

题目&#xff1a; 题目分析&#xff1a; 题目解析转载&#xff1a; 代码实现&#xff1a; package BMP3;import java.util.List;class ListNode {int val;ListNode next null;public ListNode(int val) {this.val val;} } public class BM3 {/*** 代码中的类名、方法名、参…
阅读更多...
算法-技巧-中等-寻找重复数，环形链表|，||

算法-技巧-中等-寻找重复数，环形链表|，||

记录一下算法题的学习13 这次代码中运用到的技巧是「Floyd 判圈算法」&#xff08;又称龟兔赛跑算法&#xff09;&#xff0c;它是一个检测链表是否有环的算法 我们想象乌龟tortoise和兔子rabbit在链表上移动&#xff0c;乌龟爬的慢&#xff0c;兔子爬的快&#xff0c;当乌龟和…
阅读更多...
golang 实现单向链表（lru）、双向链表、双向循环链表

golang 实现单向链表（lru）、双向链表、双向循环链表

单向链表实现lru package mainimport "fmt"func main() {// 实现一个lru 淘汰算法// linked 结构体// node 节点 &#xff1a; data prev next// 更新lru// 如果没有满// 将新的数据加入到头结点// 队满 &#xff1a; 删除尾结点// 将新数据加入头结点linkedObj : g…
阅读更多...
【带头学C++】----- 八、C++面向对象编程 ---- 8.10 函数的默认参数

【带头学C++】----- 八、C++面向对象编程 ---- 8.10 函数的默认参数

8.10 函数的默认参数 C在声明函数原型的时可为一个或者多个参数指定默认(缺省)的参数值&#xff0c;当函数调用的时候如果没有指定这个值&#xff0c;编器会自动用默认值代替。 通过为函数参数指定默认值&#xff0c;可以在调用函数时省略相应的参数&#xff0c;而该参数将使用…
阅读更多...
算法通关村第一关——链表经典问题之删除链表元素笔记

算法通关村第一关——链表经典问题之删除链表元素笔记

删除链表节点 总结一下高频常用的删除链表结点的情况&#xff0c;无论对链表进行何种操作&#xff0c;都需要精确查找和精确指向。另外&#xff0c;在删除链表节点时有一个很好用的技巧&#xff1a;虚头结点&#xff0c;将头结点的特殊性转化为一般&#xff0c;在后面具体阐述…
阅读更多...
数据结构：链表应用：第9关：删除链表中满足区间值的结点

数据结构：链表应用：第9关：删除链表中满足区间值的结点

任务描述编程要求 输入输出测试说明来源 任务描述 本关任务&#xff1a;利用单链表表示一个递增的整数序列&#xff0c;删除链表中值大于等于mink且小于等于maxk的所有元素&#xff08;mink和maxk是给定的两个参数&#xff0c;其值可以和表中的元素相同&#xff0c;也可以不同…
阅读更多...
【算法通关村】链表反转经典问题解析

【算法通关村】链表反转经典问题解析

&#x1f6a9;本文已收录至算法学习之旅 一.基础反转 我们通常有两种方法反转链表&#xff0c;一种是直接操作链表实现反转操作&#xff0c;一种是建立虚拟头节点辅助实现反转操作。 力扣习题链接&#xff1a;206. 反转链表 (1) 直接操作实现反转 我们需要一个变量pre来保…
阅读更多...
【数据结构】双向链表中删除节点的方法实现(代码+详解)

【数据结构】双向链表中删除节点的方法实现(代码+详解)

【数据结构】双向链表中删除节点方法的实现(代码详解) 分析 &#x1f495; 在双向链表中&#xff0c;删除一个结点可能出现以下几种情况&#xff0c;取决于待删除的结点在链表中的位置&#xff1a; 删除头结点&#xff1a; 如果待删除的结点是头结点&#xff0c;需要特殊处理…
阅读更多...
算法通关村第一关—链表高频面试题(白银)

算法通关村第一关—链表高频面试题(白银)

链表高频面试题 一、五种方法解决两个链表的第一个公共子节点的问题 面试 02.07.链表相交1.首先想到的是暴力解&#xff0c;将第一个链表中的每一个结点依次与第二个链表的进行比较&#xff0c;当出现相等的结点指针时&#xff0c;即为相交结点。虽然简单&#xff0c;但是时间…
阅读更多...
严蔚敏数据结构p17（2.19）——p18(2.24) (c语言代码实现)

严蔚敏数据结构p17（2.19）——p18(2.24) (c语言代码实现)

目录 2.19已知线性表中的元素以值递增有序排列,并以单链表作存储结构。试写一高效的算法,删除表中所有值大于 mink 且小于 maxk 的元素(若表中存在这样的元素&#xff09;同时释放被删结点空间,并分析你的算法的时间复杂度(注意:mink 和 maxk 是给定的个参变量,它们的值可以和表…
阅读更多...
HashMap详解(扩容机制、底层结构、适用场景)

HashMap详解(扩容机制、底层结构、适用场景)

1、特点 底层是链表数组&#xff0c;JDK1.8开始&#xff0c;当链表长度超过8时&#xff0c;会将链表转换为红黑树。 储存的是key-value类型数据。 key值不允许重复&#xff0c;key重复会被覆盖&#xff0c;value允许重复。 数据储存无序&#xff08;不记录存入的顺序&#x…
阅读更多...
双向链表的结构与基本操作（初始化，头插，尾插，删除，输出，清空，销毁等）

双向链表的结构与基本操作（初始化，头插，尾插，删除，输出，清空，销毁等）

目录 1.双向链表的结构设计 2.双向链表的结构示意图: 3.双向链表的实现 4.双向链表的总结 1.双向链表的结构设计 typedef struct DNode{int data;struct DNode* next;//后继指针struct DNode* prio;//前驱指针}DNode ,*DList; 2.双向链表的结构示意图: 3.双向链表的实现 …
阅读更多...
P5 链表 尾部插入新节点（不是指定点）

P5 链表 尾部插入新节点（不是指定点）

目录 前言 01 链表数据插入之直接在链表尾插入&#xff08;不是指定点&#xff09; 02 尾插创建链表优化 示例代码 前言 &#x1f3ac; 个人主页&#xff1a;ChenPi &#x1f43b;推荐专栏1: 《C》✨✨✨ &#x1f525; 推荐专栏2: 《 Linux C应用编程&#xff08;概念…
阅读更多...
LeetCode刷题---合并两个有序链表

LeetCode刷题---合并两个有序链表

个人主页&#xff1a;元清加油_【C】,【C语言】,【数据结构与算法】-CSDN博客 个人专栏&#xff1a;http://t.csdnimg.cn/ZxuNL http://t.csdnimg.cn/c9twt 前言&#xff1a;这个专栏主要讲述递归递归、搜索与回溯算法&#xff0c;所以下面题目主要也是这些算法做的 我讲述…
阅读更多...
代码随想录day3 203.移除列表元素 707.设计链表 206.反转链表

代码随想录day3 203.移除列表元素 707.设计链表 206.反转链表

数组是在内存中是连续分布的&#xff0c;但是链表在内存中可不是连续分布的。 双链表 单链表中的指针域只能指向节点的下一个节点。 双链表&#xff1a;每一个节点有两个指针域&#xff0c;一个指向下一个节点&#xff0c;一个指向上一个节点。 双链表 既可以向前查询也可以…
阅读更多...
力扣.特定深度节点链表(java BFS解法)

力扣.特定深度节点链表(java BFS解法)

Problem: 面试题 04.03. 特定深度节点链表 文章目录 题目描述思路解题方法复杂度Code 题目描述 思路 根据题意需要取出二叉树每一层节点组成的链表并将其添加到一个数组中。我们将该要求分解成如下的操作&#xff1a; 1.利用BFS获取二叉树每一层的节点 2.利用链表的尾插法将二…
阅读更多...
【算法通关村】链表基础经典问题解析

【算法通关村】链表基础经典问题解析

【算法通关村】链表基础&经典问题解析 一.什么是链表 链表是一种通过指针将多个节点串联在一起的线性结构&#xff0c;每一个节点&#xff08;结点&#xff09;都由两部分组成&#xff0c;一个是数据域&#xff08;用来存储数据&#xff09;&#xff0c;一个是指针域&…
阅读更多...
138. 随机链表的复制 --力扣 --JAVA

138. 随机链表的复制 --力扣 --JAVA

题目 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节点的值。新节点…
阅读更多...
LeetCode刷题---反转链表

LeetCode刷题---反转链表

个人主页&#xff1a;元清加油_【C】,【C语言】,【数据结构与算法】-CSDN博客 个人专栏&#xff1a;http://t.csdnimg.cn/ZxuNL http://t.csdnimg.cn/c9twt 前言&#xff1a;这个专栏主要讲述递归递归、搜索与回溯算法&#xff0c;所以下面题目主要也是这些算法做的 我讲述…
阅读更多...
带头双向循环链表：一种高效的数据结构

带头双向循环链表：一种高效的数据结构

&#x1f493; 博客主页&#xff1a;江池俊的博客⏩ 收录专栏&#xff1a;数据结构探索&#x1f449;专栏推荐&#xff1a;✅cpolar ✅C语言进阶之路&#x1f4bb;代码仓库&#xff1a;江池俊的代码仓库&#x1f525;编译环境&#xff1a;Visual Studio 2022&#x1f389;欢迎大…
阅读更多...
使用栈解决括号匹配问题（详解）

使用栈解决括号匹配问题（详解）

项目结构 项目头文件的代码或截图 头文件代码 #ifndef LINKSTACK_H #define LINKSTACK_H #include <stdio.h> #include <stdlib.h> // 链式栈的节点 typedef struct LINKNODE {struct LINKNODE* next; }LinkNode; // 链式栈 typedef struct LINKSTACK {LinkNode h…
阅读更多...
中缀表达式转后缀表达式与后缀表达式计算（详解）

中缀表达式转后缀表达式与后缀表达式计算（详解）

**中缀表达式转后缀表达式的一般步骤如下&#xff1a; 1&#xff1a;创建一个空的栈和一个空的输出列表。 2&#xff1a;从左到右扫描中缀表达式的每个字符。 3&#xff1a;如果当前字符是操作数&#xff0c;则直接将其加入到输出列表中。 4&#xff1a;如果当前字符是运算符&a…
阅读更多...
【数据结构】链表OJ题（顺序表）（C语言实现）

【数据结构】链表OJ题（顺序表）（C语言实现）

✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅ ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ &#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1f33f;&#x1…
阅读更多...
数据结构：链表应用：第8关：链表的逆转

数据结构：链表应用：第8关：链表的逆转

任务描述编程要求 输入输出测试说明来源 任务描述 本关任务&#xff1a;利用单链表表示一个整数序列&#xff0c;通过一趟遍历&#xff0c;将单链表中所有结点的链接方向逆转。要求空间复杂度为O(1)。 编程要求 输入 多组数据&#xff0c;每组数据有两行&#xff0c;第一行…
阅读更多...
随机链表的复制[中等]

随机链表的复制[中等]

优质博文&#xff1a;IT-BLOG-CN 一、题目 给你一个长度为n的链表&#xff0c;每个节点包含一个额外增加的随机指针random&#xff0c;该指针可以指向链表中的任何节点或空节点。构造这个链表的深拷贝。深拷贝应该正好由n个全新节点组成&#xff0c;其中每个新节点的值都设为…
阅读更多...
234 回文链表

234 回文链表

解题思路&#xff1a; \qquad 由于链表的结构特点&#xff0c;访问链表中的元素的时间复杂度为O(n)。相比较而言&#xff0c;使用数组会方便很多&#xff0c;实现O(1)访问。 \qquad 所以这个题&#xff0c;可以先遍历一遍把数值存到数组中&#xff0c;再使用双指针判断是否是…
阅读更多...
算法通关村第二关—链表反转的拓展问题(白银)

算法通关村第二关—链表反转的拓展问题(白银)

链表反转的拓展问题 一、指定区间反转 LeetCode92&#xff1a;给你单链表的头指针head和两个整数left和right,其中left<right。请你反转从位置left到位置right的链表节点&#xff0c;返回反转后的链表。 1.1 头插法 反转的整体思想是&#xff0c;在需要反转的区间里&…
阅读更多...
设计一算法，对单链表实现就地逆置

设计一算法，对单链表实现就地逆置

对单链表逆置&#xff0c;要联想到单链表的头插性质 举个例子&#xff1a;现在有一个空链表&#xff0c;我们依次对它进行头插123 那么形成的链表是321&#xff0c;这样就形成了逆置 //单链表就地逆置 //思路&#xff1a;把原表接到一个新表上&#xff0c;然后对原表进行头插 …
阅读更多...
数据结构-02-链表

数据结构-02-链表

相比数组&#xff0c;链表是一种稍微复杂一点的数据结构。掌握起来也要比数组稍难一些。这两个非常基础、非常常用的数据结构。 1-链表结构 数组需要一块连续的内存空间来存储&#xff0c;对内存的要求比较高。如果我们申请一个20MB大小的数组&#xff0c;当内存中没有连续的、…
阅读更多...
【链表】160.相交链表

【链表】160.相交链表

题目 法1:写法不简练 public class Solution {public ListNode getIntersectionNode(ListNode headA, ListNode headB) {if (headA null || headB null) {return null;}ListNode curA headA, curB headB;int aMeetNull 0;while (aMeetNull < 2) {if (curA curB) {re…
阅读更多...
【链表】206.反转链表

【链表】206.反转链表

题目 法1:递归写法 class Solution {public ListNode reverseList(ListNode head) {if (head null || head.next null) {return head;}ListNode last reverseList(head.next);head.next.next head;head.next null;return last;} }法2:迭代写法 class Solution {public …
阅读更多...
算法进阶——删除有序链表中重复的元素

算法进阶——删除有序链表中重复的元素

题目 给出一个升序排序的链表&#xff0c;删除链表中的所有重复出现的元素&#xff0c;只保留原链表中只出现一次的元素。 例如&#xff1a; 给出的链表为1→2→3→3→4→4→5, 返回1→2→5。 给出的链表为1→1→1→2→3, 返回2→3。 数据范围&#xff1a;链表长度0≤n≤10…
阅读更多...
【力扣100】141.环形链表

【力扣100】141.环形链表

添加链接描述 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val x # self.next Noneclass Solution:def hasCycle(self, head: Optional[ListNode]) -> bool:# 思路是快慢指针&#xff0c;如果有环的话…
阅读更多...
LeetCode-反转链表问题

LeetCode-反转链表问题

1.反转链表 题目描述&#xff1a; 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 思路&#xff1a; 反转链表也就是链表倒置&#xff0c;我一直以来的办法就是先建立一个头节点&#xff0c;之后再遍历链表来进行头插。 代码&#xff1…
阅读更多...
linux链表应用2

linux链表应用2

以下是根据您的要求对示例代码进行优化的结果&#xff1a; #include <stdio.h> #include <stdlib.h> #include <string.h>// 定义路径节点结构体 typedef struct PathNode {unsigned int fildid;char folderName[100]; // 文件夹名字struct PathNode* next…
阅读更多...
＜习题集＞＜LeetCode＞＜链表＞＜61/83/82/86/92＞

＜习题集＞＜LeetCode＞＜链表＞＜61/83/82/86/92＞

目录 61. 旋转链表 83. 删除排序链表中的重复元素 82. 删除排序链表中的重复元素 II 86. 分隔链表 92. 反转链表 II 61. 旋转链表 https://leetcode.cn/problems/rotate-list/ public ListNode rotateRight(ListNode head, int k) {//k等于0&#xff0c;或者head为空&…
阅读更多...
Leetcode的AC指南 —— 链表：面试题 02.07. 链表相交

Leetcode的AC指南 —— 链表：面试题 02.07. 链表相交

摘要&#xff1a; Leetcode的AC指南 —— 链表&#xff1a;面试题 02.07. 链表相交。题目介绍&#xff1a;给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 文章目录 一、题目二、…
阅读更多...
图灵日记之Leetcode链表中间结点牛客链表中倒数第k个结点Leetcode合并两个有序链表leetcode反转链表

图灵日记之Leetcode链表中间结点牛客链表中倒数第k个结点Leetcode合并两个有序链表leetcode反转链表

题目 链表的中间结点原题入口题目内容题目解析思路一代码实现一思路二代码实现二 链表中倒数第k个结点题目链接题目内容思路代码实现 合并两个有序链表原题入口题目内容思路代码实现 反转链表题目传送入口题目内容思路一代码复现一思路二代码实现二 链表的中间结点 原题入口 …
阅读更多...
【算法Hot100系列】删除链表的倒数第 N 个结点

【算法Hot100系列】删除链表的倒数第 N 个结点

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学…
阅读更多...
C++ //习题 7.10 将以上4个函数组成一个程序，由主程序先后调用这些函数，实现链表的建立、输出、删除和插入，在主程序中指定需要删除和插入的结点。

C++ //习题 7.10 将以上4个函数组成一个程序，由主程序先后调用这些函数，实现链表的建立、输出、删除和插入，在主程序中指定需要删除和插入的结点。

C程序设计 &#xff08;第三版&#xff09; 谭浩强 习题7.10 习题 7.10 将以上4个函数组成一个程序&#xff0c;由主程序先后调用这些函数&#xff0c;实现链表的建立、输出、删除和插入&#xff0c;在主程序中指定需要删除和插入的结点。 IDE工具&#xff1a;VS2010 Note: …
阅读更多...
leetcode-21-合并两个有序链表（C语言实现）

leetcode-21-合并两个有序链表（C语言实现）

题目&#xff1a; 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4]示例 2&#xff1a; 输入&#xff1a;l1 [], l2 [] 输出…
阅读更多...
Java 数据结构篇-实现二叉搜索树的核心方法

Java 数据结构篇-实现二叉搜索树的核心方法

&#x1f525;博客主页&#xff1a; 【小扳_-CSDN博客】 ❤感谢大家点赞&#x1f44d;收藏⭐评论✍ 文章目录 1.0 二叉搜索树的概述 2.0 二叉搜索树的成员变量及其构造方法 3.0 实现二叉树的核心接口 3.1 实现二叉搜索树 - 获取值 get(int key) 3.2 实现二叉搜索树 - 获取最小…
阅读更多...
LeetCode160. Intersection of Two Linked Lists

LeetCode160. Intersection of Two Linked Lists

文章目录 一、题目二、题解 一、题目 Given the heads of two singly linked-lists headA and headB, return the node at which the two lists intersect. If the two linked lists have no intersection at all, return null. For example, the following two linked lists…
阅读更多...
【带头学C++】----- 九、类和对象 ---- 9.12 C++之友元函数（9.12.1---12.4）

【带头学C++】----- 九、类和对象 ---- 9.12 C++之友元函数（9.12.1---12.4）

❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️创做不易&#xff0c;麻烦点个关注❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️ ❤️❤️❤️❤️❤️❤️❤️❤️❤️文末有惊喜&#xff01;献舞一支&#xff01;❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️ 目录 9.12…
阅读更多...
12.11_黑马数据结构与算法笔记Java

12.11_黑马数据结构与算法笔记Java

目录 070 栈 链表实现 概念理清&#xff1a;什么时候是指针的指向&#xff0c;什么时候是元素本身&#xff1f; 071 栈 数组实现 072 栈 e01 有效的括号 072 栈 e02 后缀表达式求值 072 栈 e03 中缀表达式转后缀1 072 栈 e03 中缀表达式转后缀2 072 栈 e03 中缀表达式转…
阅读更多...
【leetcode876】链表的中间结点Java代码讲解

【leetcode876】链表的中间结点Java代码讲解

12.19 链表的中间结点 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[3,4,5] 解释&#xff1a;链表只有一个中间结点&a…
阅读更多...
LeetCode（55）环形链表【链表】【简单】

LeetCode（55）环形链表【链表】【简单】

目录 1.题目2.答案3.提交结果截图 链接&#xff1a; 环形链表 1.题目 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评…
阅读更多...
链表OJ—环形链表的约瑟夫问题

链表OJ—环形链表的约瑟夫问题

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 前言 世上有两种耀眼的光芒&#xff0c;一种是正在升起的太阳&#xff0c;一种是正在努力学习编程的你!一个爱学编程的人。各位看官&#xff0c;我衷心的希望这篇博客能对你…
阅读更多...
11 双向链表

11 双向链表

单链表的局限&#xff1a; 单链表的缺点&#xff1a;逆序访问单链表中的元素耗时大。&#xff08;时间复杂度&#xff1a;O&#xff09; 双向链表的定义 第0个节点【a1】的pre指针为NULL&#xff0c;要注意 插入操作&#xff1a; 删除操作&#xff1a; 初步实现双链表 代码&…
阅读更多...
代码随想录算法训练营第三天| LeetCode203.移除链表元素、707.设计链表、206.反转链表

代码随想录算法训练营第三天| LeetCode203.移除链表元素、707.设计链表、206.反转链表

文章目录 一、203. 移除链表元素感受代码 二、707.设计链表感受代码 206.反转链表感受 总结 一、203. 移除链表元素 感受 我对这道题。从理论上来说太熟悉了。咸鱼讲数据结构常用的方法他都会讲。但是我没上机没写过。到后面上机还是写不出来。giao。 代码 第一次写&#xf…
阅读更多...
C语言实现单向链表

C语言实现单向链表

1.线性表 线性表可以分成两种 一种就是顺序表 也就是我们所熟知的数组 一种是今天的主角–链表 他们两者的区别在于 前者是顺序储存元素的 即数组元素的地址值是连续的 后者则是链式储存的 节点的地址值不一定连续 2.单向链表 链表中的节点是由两部分组成的 一部分是数据域 …
阅读更多...
华为OD机试真题-最长子字符串的长度(二)-2023年OD统一考试（C卷）

华为OD机试真题-最长子字符串的长度(二)-2023年OD统一考试（C卷）

题目描述： 给你一个字符串 s，字符串s首尾相连成一个环形 ，请你在环中找出l、o、x 字符都恰好出现了偶数次最长子字符串的长度。 输入描述： 输入是一串小写的字母组成的字符串。 输出描述： 输出是一个整数 补充说明： 1 <= s.length <= 5 x 10^5 s 只包含小写英文字母…
阅读更多...
LeetCode（57）合并两个有序链表【链表】【简单】

LeetCode（57）合并两个有序链表【链表】【简单】

目录 1.题目2.答案3.提交结果截图 链接&#xff1a; 合并两个有序链表 1.题目 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4…
阅读更多...
算法笔记—链表、队列和栈

算法笔记—链表、队列和栈

链表、队列和栈 1. 链表1.1 单链表反转1.2 双链表反转1.3 合并两个有序链表1.4 链表相加1.5 划分链表 2. 队列和栈2.1 循环队列2.2 栈实现队列2.3 队列实现栈2.4 最小栈2.2 双端队列 1. 链表 1.1 单链表反转 力扣 反转链表 // 反转单链表public ListNode reverseList(ListNod…
阅读更多...
Golang 链表的创建和读取 小记

Golang 链表的创建和读取 小记

文章目录 链表的相关知识链表的创建:模拟方式建立链表的**递归创建** 链表的读取遍历读取递归读取 完整代码 链表的相关知识 链表有时会具有头节点&#xff0c;头节点的指针指向第一个节点的地址&#xff0c;其本身的数据域可以根据自己的选择进行赋值   接下来我将以将int转…
阅读更多...
数据结构：第13关：查找两个单词链表共同后缀的起始结点

数据结构：第13关：查找两个单词链表共同后缀的起始结点

任务描述编程要求 输入输出测试说明来源 任务描述 本关任务&#xff1a;假定采用带头结点的单链表保存单词&#xff0c;当两个单词有相同的后缀时&#xff0c;则可共享相同的后缀空间。 例如&#xff0c;“loading”和“being”的存储映像如下图所示&#xff1a; 设str1和str2…
阅读更多...
LeetCode（66）二叉树的最大深度【二叉树】【简单】

LeetCode（66）二叉树的最大深度【二叉树】【简单】

目录 1.题目2.答案3.提交结果截图 链接&#xff1a; 二叉树的最大深度 1.题目 给定一个二叉树 root &#xff0c;返回其最大深度。 二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。 示例 1&#xff1a; 输入&#xff1a;root [3,9,20,null,null,15,7]…
阅读更多...
12.16_黑马数据结构与算法笔记Java

12.16_黑马数据结构与算法笔记Java

目录 167 B树 remove 168 B树 remove 搭架子 169 B树 remove case1-4 170 B树 remove case5-6分析 171 B树 remove case5 旋转 172 B树 remove case5 合并 173 B树 remove case6 174 B树 remove 演示1 175 B树 remove 演示2 176 哈希表 概述 177 哈希表 hash码映射索…
阅读更多...
Java-----链表练习题(上)

Java-----链表练习题(上)

本篇碎碎念&#xff1a;本篇无碎碎念 今日份励志文案: 很多人认为他们在思考&#xff0c;其实他们只是在整理自己的偏见 目录 一.203. 移除链表元素 - 力扣&#xff08;LeetCode&#xff09; 二.21. 合并两个有序链表 - 力扣&#xff08;LeetCode&#xff09…
阅读更多...
LeetCode——链表

LeetCode——链表

链表 链表类型&#xff1a;单链表&#xff08;只有next指针&#xff09;、双链表&#xff08;pre指针和next指针&#xff09;、循环链表&#xff08;尾节点指向头节点&#xff09; 增、删、改、遍历、翻转、交换 1.设计链表707中等 class LinkedNode {int val;LinkedNode n…
阅读更多...
leetcode链表小练（1.反转链表2.链表的中间节点3.合并两个有序链表4.环形链表①5.环形链表②）详解 (୨୧• ᴗ •͈)◞︎ᶫᵒᵛᵉ ♡

leetcode链表小练（1.反转链表2.链表的中间节点3.合并两个有序链表4.环形链表①5.环形链表②）详解 (୨୧• ᴗ •͈)◞︎ᶫᵒᵛᵉ ♡

目录 一.反转链表 思路一反转指针反向&#xff1a; 思路二头插法&#xff1a; 二.链表的中间节点&#xff1a; 三.合并两个有序数组: 思路一&#xff1a;从头开始&#xff0c;取两个链表中小的那个尾插到新链表。定义指针head,tail指向空&#xff0c;代表新链表的头结点。…
阅读更多...
Golang leetcode707 设计链表 （链表大成）

Golang leetcode707 设计链表 （链表大成）

文章目录 设计链表 Leetcode707不使用头节点使用头节点 推荐** 设计链表 Leetcode707 题目要求我们通过实现几个方法来完成对链表的各个操作 由于在go语言中都为值传递&#xff0c;&#xff08;注意这里与值类型、引用类型的而区别&#xff09;&#xff0c;所以即使我们直接在…
阅读更多...
LeetCode 2807. 在链表中插入最大公约数

LeetCode 2807. 在链表中插入最大公约数

给你一个链表的头 head &#xff0c;每个结点包含一个整数值。 在相邻结点之间&#xff0c;请你插入一个新的结点&#xff0c;结点值为这两个相邻结点值的 最大公约数 。 请你返回插入之后的链表。 两个数的 最大公约数 是可以被两个数字整除的最大正整数。 示例 1&#xf…
阅读更多...
【Leetcode】2487. 从链表中移除节点

【Leetcode】2487. 从链表中移除节点

文章目录 题目思路代码 题目 2487. 从链表中移除节点 思路 1、递归移除节点&#xff1a; 如果头节点为空&#xff0c;直接返回空。递归调用函数处理下一个节点 head->next。在递归返回后&#xff0c;判断当前节点的值是否小于之前记录的最大值 maxVal。如果小于 maxVal…
阅读更多...
leetcode-138-随机链表的复制（Java实现）

leetcode-138-随机链表的复制（Java实现）

题目&#xff1a; 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节点…
阅读更多...
Leetcod面试经典150题刷题记录 —— 链表篇

Leetcod面试经典150题刷题记录 —— 链表篇

Leetcod面试经典150题刷题记录-系列Leetcod面试经典150题刷题记录——数组 / 字符串篇Leetcod面试经典150题刷题记录 —— 双指针篇Leetcod面试经典150题刷题记录 —— 矩阵篇Leetcod面试经典150题刷题记录 —— 滑动窗口篇Leetcod面试经典150题刷题记录 —— 哈希表篇Leetcod面…
阅读更多...
数据结构入门到入土——链表（2）

数据结构入门到入土——链表（2）

目录 一&#xff0c;与链表相关的题目&#xff08;2&#xff09; 1.输入两个链表&#xff0c;找出它们的第一个公共节点 2.给定一个链表&#xff0c;判断链表中是否有环 3.给定一个链表&#xff0c;返回链表开始入环的第一个节点&#xff0c;若无则返回null 一&#xff0c;…
阅读更多...
Golang Leetcode19 删除链表的倒数第N个节点 递归 双指针法+迭代

Golang Leetcode19 删除链表的倒数第N个节点 递归 双指针法+迭代

删除链表的倒数第N个节点 leetcode19 递归 由于本体是倒数第几个节点&#xff0c;非常适合递归 从终到始 的运行方式 func removeNthFromEnd(head *ListNode, n int) *ListNode {// 创建一个虚拟头节点&#xff0c;简化边界条件处理dummy : &ListNode{Next: head}//检查…
阅读更多...
【leetcode】力扣算法之相交链表【中等难度】

【leetcode】力扣算法之相交链表【中等难度】

题目描述 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c;函数…
阅读更多...
GDB调试技巧实战--发现release版本程序中的循环链表

GDB调试技巧实战--发现release版本程序中的循环链表

目录 客户问题 GDB自定义命令发现循环链表 逐行解释 如何使用 客户问题 客户报告程序hang在那不干活了，通过查看现场发回来的diag信息，我们发现有一个进程几乎占用了100%CPU。 于是让客户发回来这个进程的core dump。 研究发现它陷入了一个循环链表。
阅读更多...
2024.1.3力扣每日一题——从链表中移除节点

2024.1.3力扣每日一题——从链表中移除节点

2024.1.3 题目来源我的题解方法一 递归方法二 栈方法三 反转链表方法四 单调栈头插法 题目来源 力扣每日一题&#xff1b;题序&#xff1a;2487 我的题解 方法一 递归 当前节点对其右侧节点是否删除无影响&#xff0c;因此可以对其右侧节点进行递归移除。 若当前节点为空&am…
阅读更多...
【leetcode】力扣热门之回文链表【简单难度】

【leetcode】力扣热门之回文链表【简单难度】

题目描述 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 用例 输入&#xff1a;head [1,2,2,1] 输出&#xff1a;true 输入&#xff1a;head [1,2] 输出&#xff1a;f…
阅读更多...
JavaScript版数据结构与算法（一）栈、队列、链表、集合、树

JavaScript版数据结构与算法（一）栈、队列、链表、集合、树

一、前言 为什么要学习数据结构与算法&#xff1f;最重要的就是面试要考算法&#xff0c;另外就是如果在实际工作当中&#xff0c;能够使用算法优化代码&#xff0c;会提升代码质量和运行效率&#xff0c;作为一名前端人员可能在实际中用的并不是特别多。数据结构与算法是分不…
阅读更多...
LeetCode203移除链表元素两种实现方法（Java实现）

LeetCode203移除链表元素两种实现方法（Java实现）

今天来分享的是移除链表元素的题目。 题目描述如下。 那么本道题目操作的是单链表&#xff0c;需要注意的是&#xff0c;单链表只能顺序通过next访问数组中的元素。 实现方法1&#xff1a;不使用虚拟节点进行求解 不使用虚拟节点我们在处理头结点需要进行判断&#xff0c;如果…
阅读更多...
【双指针算法应用举例】反转链表、二分查找、有序数组的平方等

【双指针算法应用举例】反转链表、二分查找、有序数组的平方等

总结 &#xff1a;双指针法的循环条件 while (left < right) {}1. 704. 二分查找 注意必须是升序或者降序的数组才可以 mid&#xff08;leftright)/2 2.977. 有序数组的平方 数组其实是有序的&#xff0c; 只不过负数平方之后可能成为最大数了。 那么数组平方的最大值就…
阅读更多...
1.倒排索引 2.逻辑斯提回归算法

1.倒排索引 2.逻辑斯提回归算法

1.倒排索引 https://help.aliyun.com/zh/open-search/retrieval-engine-edition/introduction-to-inverted-indexes 倒排索引&#xff08;Inverted Index&#xff09;是一种数据结构&#xff0c;用于快速查找包含某个特定词或词语的文档。它主要用于全文搜索引擎等应用&#…
阅读更多...
链接未来：深入理解链表数据结构（二.c语言实现带头双向循环链表）

链接未来：深入理解链表数据结构（二.c语言实现带头双向循环链表）

上篇文章简述讲解了链表的基本概念并且实现了无头单向不循环链表&#xff1a;链接未来&#xff1a;深入理解链表数据结构&#xff08;一.c语言实现无头单向非循环链表&#xff09;-CSDN博客 那今天接着给大家带来带头双向循环链表的实现&#xff1a; 文章目录 一.项目文件规划…
阅读更多...
数组和链表-内存存储分析

数组和链表-内存存储分析

1、pom.xml <?xml version"1.0" encoding"UTF-8"?> <project xmlns"http://maven.apache.org/POM/4.0.0"xmlns:xsi"http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation"http://maven.apache.org/POM/4.0.…
阅读更多...
LeetCode Hot100 138.随机链表的复制

LeetCode Hot100 138.随机链表的复制

题目&#xff1a; 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节…
阅读更多...
Leetcode—237.删除链表中的节点【中等】

Leetcode—237.删除链表中的节点【中等】

2023每日刷题&#xff08;六十&#xff09; Leetcode—237.删除链表中的节点 偷天换日实现代码 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode(int x) : val(x), next(NULL) {}* };*/ class Solution { pub…
阅读更多...
【LeetCode】链表精选12题

【LeetCode】链表精选12题

目录 快慢指针&#xff1a; 1. 相交链表&#xff08;简单&#xff09; 2. 环形链表&#xff08;简单&#xff09; 3. 快乐数&#xff08;简单&#xff09; 4. 环形链表 II&#xff08;中等&#xff09; 5. 删除链表的倒数第 N 个节点&#xff08;中等&#xff09; 递归迭…
阅读更多...
Golang 链表的基础知识

Golang 链表的基础知识

文章目录 链表链表基础知识部分链表的存储方式链表的定义链表的操作性能分析 链表 更多有关于go链表的内容可以见这篇文章链表的创建和读取 链表基础知识部分 什么是链表&#xff0c;链表是一种通过指针串联在一起的线性结构&#xff0c;每一个节点由两部分组成&#xff0c;…
阅读更多...
C语言，指针链表详解解说及代码示例

C语言，指针链表详解解说及代码示例

C语言&#xff0c;指针链表详解解说及代码示例 指针链表是一种常用的数据结构&#xff0c;用于存储和组织数据。它由一系列节点组成&#xff0c;每个节点包含数据和一个指向下一个节点的指针。通过这种方式&#xff0c;可以动态地添加、删除和访问节点&#xff0c;实现灵活的数…
阅读更多...
数据结构之树 --- 二叉树

数据结构之树 --- 二叉树

目录 定义二叉树的结构体 二叉树的遍历 递归遍历 非递归遍历 链式二叉树的实现 二叉树的功能接口 先序遍历创建二叉树 后序遍历销毁二叉树 先序遍历查找树中值为x的节点 层序遍历 上篇我们对二叉树的顺序存储堆进行了讲述&#xff0c;本文我们来看链式二叉树。 定…
阅读更多...
面试要点,算法,数据结构等练习大全

面试要点,算法,数据结构等练习大全

有趣的算法&#xff0c;面试常常碰到&#xff0c;多种语言实现~ 1 从数组中找出两个数字使得他们的和是给定的数字 tags: #hash 使用一个散列&#xff0c;存储数字和他对应的索引。然后遍历数组&#xff0c;如果另一半在散列当中&#xff0c;那么返回 这两个数的索引&#x…
阅读更多...
数据结构模拟实现LinkedList双向不循环链表

数据结构模拟实现LinkedList双向不循环链表

目录 一、双向不循环链表的概念 二、链表的接口 三、链表的方法实现 &#xff08;1&#xff09;display方法 &#xff08;2&#xff09;size方法 &#xff08;3&#xff09;contains方法 &#xff08;4&#xff09;addFirst方法 &#xff08;5&#xff09;addLast方法 …
阅读更多...
数据结构.链表（1）

数据结构.链表（1）

一.定义 分类&#xff1a; 二、单链表的定义和表示 三、单链表基本操作&#xff1a;
阅读更多...
「优选算法刷题」：长度最小的子数组

「优选算法刷题」：长度最小的子数组

一、题目 给定一个含有 n 个正整数的数组和一个正整数 target 。 找出该数组中满足其总和大于等于 target 的长度最小的 连续子数组 [numsl, numsl1, ..., numsr-1, numsr] &#xff0c;并返回其长度。如果不存在符合条件的子数组&#xff0c;返回 0 。 示例 1&#xff1a; 输…
阅读更多...
力扣第92题——反转链表 II（C语言题解）

力扣第92题——反转链表 II（C语言题解）

题目描述 给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], left 2, right 4 输出&#xff1…
阅读更多...
Leetcode—23.合并 K 个升序链表【困难】

Leetcode—23.合并 K 个升序链表【困难】

2023每日刷题&#xff08;八十三&#xff09; Leetcode—23.合并 K 个升序链表 算法思想 用容量为K的最小堆优先队列&#xff0c;把链表的头结点都放进去&#xff0c;然后出队当前优先队列中最小的&#xff0c;挂上链表&#xff0c;&#xff0c;然后让出队的那个节点的下一个…
阅读更多...
leetcode 19. 删除链表的倒数第 N 个结点 java解法

leetcode 19. 删除链表的倒数第 N 个结点 java解法

leetcode 19. 删除链表的倒数第 N 个结点 删除链表的倒数第 N 个结点 题目描述 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并返回链表的头结点。 解题思路 为了删除倒数第 n 个节点&#xff0c;我们可以使用双指针法。首先&#xff0c;我们将第一个指…
阅读更多...
【数据结构】链表(单链表与双链表实现+原理+源码)

【数据结构】链表(单链表与双链表实现+原理+源码)

博主介绍&#xff1a;✌全网粉丝喜爱、前后端领域优质创作者、本质互联网精神、坚持优质作品共享、掘金/腾讯云/阿里云等平台优质作者、擅长前后端项目开发和毕业项目实战✌有需要可以联系作者我哦&#xff01; &#x1f345;附上相关C语言版源码讲解&#x1f345; &#x1f44…
阅读更多...
[反转链表] [合并两个有序链表][分割链表]

[反转链表] [合并两个有序链表][分割链表]

这里写目录标题 反转链表合并两个有序链表分割链表 反转链表 1、题目&#xff1a; 2.思路  思路1&#xff1a;建立一个newHead,取一个节点进行头插。具体做法如下&#xff01; 建立一个newHead(新头)&#xff0c;由于一个节点里面存的是下一个节点的地址&#xff0c;如果取…
阅读更多...
Leetcode2807. 在链表中插入最大公约数

Leetcode2807. 在链表中插入最大公约数

Every day a Leetcode 题目来源&#xff1a;2807. 在链表中插入最大公约数 解法1&#xff1a;2807. 在链表中插入最大公约数 遍历链表&#xff0c;在当前节点 cur 后面插入 gcdNode 节点&#xff0c;同时 gcdNode 节点指向 cur 的下一个节点。 插入后&#xff0c;cur 更新…
阅读更多...
【数据结构与算法】4.自主实现单链表的增删查改

【数据结构与算法】4.自主实现单链表的增删查改

&#x1f4da;博客主页&#xff1a;爱敲代码的小杨. ✨专栏&#xff1a;《Java SE语法》 ❤️感谢大家点赞&#x1f44d;&#x1f3fb;收藏⭐评论✍&#x1f3fb;&#xff0c;您的三连就是我持续更新的动力❤️ &#x1f64f;小杨水平有限&#xff0c;欢迎各位大佬指点&…
阅读更多...
【C++修炼秘籍】List深度剖析

【C++修炼秘籍】List深度剖析

【C修炼秘籍】STL-List ☀️心有所向&#xff0c;日复一日&#xff0c;必有精进 ☀️专栏《C修炼秘籍》 ☀️作者&#xff1a;早凉 ☀️如果有错误&#xff0c;烦请指正&#xff0c;如有疑问可私信联系&#xff1b; 目录 【C修炼秘籍】STL-List 文章目录 前言 一、list介绍…
阅读更多...
数据结构——循环链表

数据结构——循环链表

1.循环单链表 最后一个结点的指针不是NULL,而是指向头结点 单链表和循环单链表的比较&#xff1a; 单链表&#xff1a;从一个结点出发只能找到该结点后续的各个结点&#xff1b;对链表的操作大多都在头部或者尾部&#xff1b;设立 头指针&#xff0c;从头结点找到尾部的时间…
阅读更多...
三、java线性表（顺序表、链表、栈、队列）

三、java线性表（顺序表、链表、栈、队列）

java线性表 三、线性表1.1 顺序表1.2 链表1.2.1 单向链表&#xff08;Singly Linked List&#xff09;1.2.2 双向链表&#xff08;Doubly Linked List&#xff09; 1.3 LinkedList VS ArrayList1.3.7 使用 LinkedList 的场景 1.4 栈1.5 队列 三、线性表 线性表是一种经典的数据…
阅读更多...
【leetcode】力扣热门算法之K个一组翻转链表【困难】

【leetcode】力扣热门算法之K个一组翻转链表【困难】

题目描述 给你链表的头节点 head &#xff0c;每 k 个节点一组进行翻转&#xff0c;请你返回修改后的链表。 k 是一个正整数&#xff0c;它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍&#xff0c;那么请将最后剩余的节点保持原有顺序。 你不能只是单纯的改变节…
阅读更多...
LeetCode-克服链表不能随机访问的问题

LeetCode-克服链表不能随机访问的问题

1.重排链表 题目描述&#xff1a; 给定一个单链表 L 的头节点 head &#xff0c;单链表 L 表示为&#xff1a; L0 → L1 → … → Ln - 1 → Ln 请将其重新排列后变为&#xff1a; L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → … 不能只是单纯的改变节点内部的值&#xff0…
阅读更多...
链表部分操作案例

链表部分操作案例

接上一篇 链表&#xff1a;带头节点和不带头结点&#xff0c;还有头指针-CSDN博客 这个可以做下参考&#xff0c;初步测试没问题了。其他的后面写 #include <stdio.h> #include <stdlib.h>typedef struct Node{int val;struct Node *next; }Nodes, *Linklist;…
阅读更多...
代码随想录算法训练营day3 | 链表 (1)

代码随想录算法训练营day3 | 链表 (1)

一、链表理论基础 链表是一种通过指针串联在一起的线性结构&#xff0c;每个节点由两部分组成&#xff1a;数据域和指针域&#xff08;指向下一个节点&#xff09;&#xff0c;最后一个节点的指针指向NULL&#xff08;空指针&#xff09;。 …
阅读更多...
王道计算机考研 数据结构C语言复现-第七章-表达式（波兰式）

王道计算机考研 数据结构C语言复现-第七章-表达式（波兰式）

这篇文章收录了王道考研课程中涉及的数据结构的所有代码。此外&#xff0c;本博客可能会添加一些额外的代码&#xff08;不仅限于王道考研&#xff09;&#xff0c;因为408考试中会频繁考察一些冷门的知识点&#xff0c;所以这篇博客会涵盖所有相关的代码。这也是我数据结构的第…
阅读更多...
Python | 四、链表

Python | 四、链表

为什么需要链表 在Python中&#xff0c;引入链表这一结构没有像C等语言那样有很多好处&#xff0c;因为Python里的列表和字符串结构已经十分灵活且大小可变&#xff0c;仍保留的好处如下&#xff1a; 列表、字符串等结构是连续存储的&#xff0c;因此如果有一块较小的内存区域…
阅读更多...
2024.1.14力扣每日一题——删除排序链表中的重复元素

2024.1.14力扣每日一题——删除排序链表中的重复元素

2024.1.14 题目来源我的题解方法一 双指针&#xff08;快慢指针&#xff09; 题目来源 力扣每日一题&#xff1b;题序&#xff1a;83 我的题解 方法一 双指针&#xff08;快慢指针&#xff09; 因为题目中的链表已经是升序排列&#xff0c;因此使用两个指针&#xff0c;分别…
阅读更多...
代码随想录算法训练营第4天 | 24. 两两交换链表中的节点 ， 19.删除链表的倒数第N个节点 ， 面试题 02.07. 链表相交 ， 142.环形链表II

代码随想录算法训练营第4天 | 24. 两两交换链表中的节点 ， 19.删除链表的倒数第N个节点 ， 面试题 02.07. 链表相交 ， 142.环形链表II

链表知识基础 文章链接&#xff1a;https://programmercarl.com/%E9%93%BE%E8%A1%A8%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html# 24. 两两交换链表中的节点 题目链接&#xff1a;https://leetcode.cn/problems/swap-nodes-in-pairs/ 使用虚拟头结点&#xff0c;这样会方便很…
阅读更多...
LeetCode 0083.删除排序链表中的重复元素：模拟

LeetCode 0083.删除排序链表中的重复元素：模拟

【LetMeFly】83.删除排序链表中的重复元素&#xff1a;模拟 力扣题目链接&#xff1a;https://leetcode.cn/problems/remove-duplicates-from-sorted-list/ 给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的…
阅读更多...
【Java 数据结构】LinkedList与链表

【Java 数据结构】LinkedList与链表

LinkedList与链表 1. ArrayList的缺陷2. 链表2.1 链表的概念及结构2.2 链表的实现 3. LinkedList的模拟实现4.LinkedList的使用4.1 什么是LinkedList4.2LinkedList的使用 5. ArrayList和LinkedList的区别 1. ArrayList的缺陷 上节课已经熟悉了ArrayList的使用&#xff0c;并且…
阅读更多...
删除倒数第N个结点---链表Oj

删除倒数第N个结点---链表Oj

https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/?envType=study-plan-v2&envId=top-100-liked 1、常规解法 删除倒数第N个结点，那就是删除整数第（len - N + 1）个结点，我们只需要找到第len-N个结点，让它的next指向倒数第N个结点…
阅读更多...
【数据结构与算法】之数组系列-20240116

【数据结构与算法】之数组系列-20240116

这里写目录标题 一、15. 三数之和二、16. 最接近的三数之和三、49. 字母异位词分组四、53. 最大子数组和五、189. 轮转数组六、179. 最大数 一、15. 三数之和 提示 中等 给你一个整数数组 nums &#xff0c;判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i ! j、i ! k…
阅读更多...
代码随想录算法训练营第三天 链表 cb2bbb29ee284b02af90933ba9e20fdb

代码随想录算法训练营第三天 链表 cb2bbb29ee284b02af90933ba9e20fdb

代码随想录算法训练营第三天| 链表 链表理论基础 203.溢出链表元素 707.设计链表 206.反转链表 1.了解链表理论基础 https://programmercarl.com/链表理论基础.html#链表的类型 2.LeetCode 203.移出链表元素 题目链接&#xff1a;https://leetcode.cn/problems/design-…
阅读更多...
LeetCode-23 合并 K 个升序链表

LeetCode-23 合并 K 个升序链表

LeetCode-23 合并 K 个升序链表 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 示例 1&#xff1a; 输入&#xff1a;lists [[1,4,5],[1,3,4],[2,6]] 输出&#xff1a;[1,1,2,3,4,4,5,6] 解…
阅读更多...
代码随想录算法训练61 | 总结篇

代码随想录算法训练61 | 总结篇

前面60天的刷题大概是按照如下类型来刷&#xff1a;数组-> 链表-> 哈希表->字符串->栈与队列->树->回溯->贪心->动态规划->单调栈。每道题目都是精心筛选&#xff0c;都是经典题目高频面试题。并且&#xff0c;每个专题开始都有理论基础篇&#xff…
阅读更多...
算法每日一题： 删除排序列表中的重复元素2 | 循环 | 链表的删除 | 虚拟节点

算法每日一题： 删除排序列表中的重复元素2 | 循环 | 链表的删除 | 虚拟节点

大家好&#xff0c;我是星恒 今天的题目是昨天题目的进化题&#xff0c;他对链表的删除加深了理解。最重要的是学会了对循环中的特殊部分的处理&#xff0c;还有设置虚拟节点的情况 好了&#xff0c;话不多说&#xff0c;我们直接开始 题目&#xff1a;leetcode 82给定一个已排…
阅读更多...
【C++】STL 容器 - list 双向链表容器 ① ( 容器特点 | 容器操作时间复杂度 | 构造函数 )

【C++】STL 容器 - list 双向链表容器 ① ( 容器特点 | 容器操作时间复杂度 | 构造函数 )

文章目录 一、 list 双向链表容器简介1、容器特点2、容器操作时间复杂度3、遍历访问5、头文件 二、 list 双向链表容器 构造函数1、默认无参构造函数2、创建包含 n 个相同元素的 list 双向链表3、使用初始化列表构造 list 双向链表4、使用另外一个 list 容器 构造 list 双向链表…
阅读更多...
探究Java中的链表

探究Java中的链表

引言&#xff1a; 在Java编程中&#xff0c;链表是一种常见的数据结构&#xff0c;具有灵活的内存管理和动态的元素插入与删除能力。本篇博客将深入探讨链表的结构和概念&#xff0c;比较链表与顺序表的区别&#xff0c;介绍Java中LinkedList的常用函数并通过示例说明LinkedLis…
阅读更多...
【数据结构】 循环单链表的基本操作 （C语言版）

【数据结构】 循环单链表的基本操作 （C语言版）

目录 一、循环单链表 1、循环单链表的定义&#xff1a; 2、循环单链表的优缺点&#xff1a; 二、循环单链表的基本操作算法&#xff08;C语言&#xff09; 1、宏定义 2、创建结构体 3、循环单链表的初始化 4、循环单链表的插入 5、求单链表长度 6、循环单链表的清空…
阅读更多...
LeetCode[141] [142] 环形链表I II

LeetCode[141] [142] 环形链表I II

141. 环形链表 - 力扣&#xff08;LeetCode&#xff09; 142. 环形链表 II - 力扣&#xff08;LeetCode&#xff09; 题解&#xff1a; 快慢指针题 从head开始&#xff0c;一个快指针&#xff0c;一次前进两步&#xff0c;一个慢指针&#xff0c;一次走一步 如果没有环&am…
阅读更多...
LeetCode [24] 两两交换链表中的节点

LeetCode [24] 两两交换链表中的节点

24. 两两交换链表中的节点 - 力扣&#xff08;LeetCode&#xff09; 1. 递归确实np ListNode* swapPairs(ListNode* head) {if(head nullptr || head->next nullptr)return head;ListNode* p1 head;ListNode* p2 head->next;p1->next swapPairs(p2->next);p…
阅读更多...
【Java 数据结构】栈和队列

【Java 数据结构】栈和队列

栈和队列 1. 栈(Stack)1.1 概念1.2 栈的使用1.3 栈的模拟实现1.4 栈的应用场景1.5 概念区分 2. 队列(Queue)2.1 概念2.2 队列的使用2.3 队列模拟实现2.4 循环队列 3. 双端队列 (Deque)4. 面试题 1. 栈(Stack) 1.1 概念 栈&#xff1a;一种特殊的线性表&#xff0c;其只允许在…
阅读更多...
python_ACM模式《剑指offer刷题》链表1

python_ACM模式《剑指offer刷题》链表1

题目&#xff1a; 面试tips&#xff1a; 询问面试官是否可以改变链表结构 思路&#xff1a; 1. 翻转链表&#xff0c;再遍历链表打印。 2. 想要实现先遍历后输出&#xff0c;即先进后出&#xff0c;因此可借助栈结构。 3. 可用隐式的栈结构&#xff0c;递归来实现。 代码…
阅读更多...
「优选算法刷题」：水果成篮

「优选算法刷题」：水果成篮

一、题目 你正在探访一家农场&#xff0c;农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示&#xff0c;其中 fruits[i] 是第 i 棵树上的水果 种类 。 你想要尽可能多地收集水果。然而&#xff0c;农场的主人设定了一些严格的规矩&#xff0c;你必须按照要求采摘…
阅读更多...
LeetCode：206反转链表

LeetCode：206反转链表

206. 反转链表 - 力扣&#xff08;LeetCode&#xff09; 不难&#xff0c;小细节是单写一个循环&#xff0c;把特殊情况包含进去&#xff0c; 单链表核心&#xff1a;上一个结点&#xff0c;当前结点&#xff0c;下一个结点&#xff0c; 代码&#xff1a;注释&#xff08;算是…
阅读更多...
链表与二叉树-数据结构

链表与二叉树-数据结构

链表与二叉树-数据结构 创建叶子node节点建立二叉树三元组&#xff1a;只考虑稀疏矩阵中非0的元素&#xff0c;并且存储到一个类&#xff08;三元组&#xff09;的数组中。 创建叶子node节点 class Node{int no;Node next;public Node(int no){this.nono;} } public class Lb…
阅读更多...
【数据结构】双向带头循环链表实现及总结

【数据结构】双向带头循环链表实现及总结

简单不先于复杂&#xff0c;而是在复杂之后。 文章目录 1. 双向带头循环链表的实现2. 顺序表和链表的区别 1. 双向带头循环链表的实现 List.h #pragma once #include <stdio.h> #include <assert.h> #include <stdlib.h> #include <stdbool.h>typede…
阅读更多...
【数据结构]排序算法之插入排序、希尔排序和选择排序

【数据结构]排序算法之插入排序、希尔排序和选择排序

简单不先于复杂&#xff0c;而是在复杂之后。 文章目录 1. 排序的概念及其运用1.1 排序的概念1.2 排序运用1.3 常见的排序算法 2. 常见排序算法的实现2.1 插入排序2.1.1 基本思想2.1.2 直接插入排序2.1.3 希尔排序&#xff08;缩小增量排序&#xff09; 2.2. 选择排序2.2.1 基本…
阅读更多...
Go语言每日一练——链表篇(五)

Go语言每日一练——链表篇(五)

传送门 牛客面试笔试必刷101题 ----------------合并k个已排序的链表 题目以及解析 题目 解题代码及解析 解析 这一道题与昨天的合并链表题目类似&#xff0c;但是由于有K个且时间复杂度要求控制在O(nlogn)&#xff0c;这里主要有两种解法&#xff1a;一种是依旧使用归并来…
阅读更多...
C语言静态链表的实现

C语言静态链表的实现

在静态链表中&#xff0c;元素之间按照顺序存储在数组中&#xff0c;数组中的每个元素都包含两个部分&#xff1a;数据部分和游标部分。数据部分用于存储元素的值&#xff0c;游标部分用于指示下一个元素的索引位置。这种结构使得在插入和删除操作时&#xff0c;只需要修改游标…
阅读更多...
Go语言每日一练 ——链表篇(三)

Go语言每日一练 ——链表篇(三)

传送门 牛客面试笔试必刷101题 ---------------- 链表中的节点每k个一组翻转 题目以及解析 题目 解题代码及解析 package main import _"fmt" import . "nc_tools" /** type ListNode struct{* Val int* Next *ListNode* }*//*** 代码中的类名、方…
阅读更多...
JAVASE进阶：Collection高级（2）——源码剖析ArrayList、LinkedList、迭代器

JAVASE进阶：Collection高级（2）——源码剖析ArrayList、LinkedList、迭代器

&#x1f468;‍&#x1f393;作者简介&#xff1a;一位大四、研0学生&#xff0c;正在努力准备大四暑假的实习 &#x1f30c;上期文章&#xff1a;JAVASE进阶&#xff1a;Collection高级&#xff08;1&#xff09;——源码分析contains方法、lambda遍历集合 &#x1f4da;订阅…
阅读更多...
C语言每日一题（48）回文链表

C语言每日一题（48）回文链表

力扣 234 回文链表 题目描述 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,2,1] 输出&#xff1a;true示例 2&#xff1…
阅读更多...
LeetCode-第876题-链表的中间结点

LeetCode-第876题-链表的中间结点

1.题目描述 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。如果有两个中间结点&#xff0c;则返回第二个中间结点。 2.样例描述 3.思路描述 创建两个快慢指针 slow , fast &#xff0c;起始共同指向头节点&#xff0c;slow 每次走一步&#xff0c;fas…
阅读更多...
[力扣 Hot100]Day25 环形链表

[力扣 Hot100]Day25 环形链表

题目描述 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&a…
阅读更多...
数据结构与算法-链表(力扣附链接)

数据结构与算法-链表(力扣附链接)

之前我们对C语言进行了一定的学习&#xff0c;有了一些基础之后&#xff0c;我们就可以学习一些比较基础的数据结构算法题了。这部分的知识对于我们编程的深入学习非常有用&#xff0c;对于一些基本的算法&#xff0c;我们学习之后&#xff0c;就可以参加一些编程比赛了&#x…
阅读更多...
leetcode-206-翻转链表

leetcode-206-翻转链表

对于链表来说&#xff0c;->next就是代表图上的那个箭头&#xff0c;指向后&#xff0c;就相当于已经建立完链接&#xff0c;就可以改变只想节点的指针的位置了 每一个指针&#xff0c;则是代表一个圈 一 解题 方法一&#xff1a;迭代 假设链表为 1→2→3→∅1 \rightar…
阅读更多...
Leetcode—61. 旋转链表【中等】

Leetcode—61. 旋转链表【中等】

2024每日刷题&#xff08;114&#xff09; Leetcode—61. 旋转链表 实现代码 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(int x) : val(x), next(nullptr) …
阅读更多...
Python算法题集_删除链表的倒数第 N 个结点

Python算法题集_删除链表的倒数第 N 个结点

Python算法题集_删除链表的倒数第 N 个结点 题19&#xff1a;删除链表的倒数第 N 个结点1. 示例说明2. 题目解析- 题意分解- 优化思路- 测量工具 3. 代码展开1) 标准求解【二次遍历】2) 改进版一【快慢指针】3) 改进版二【列表裁剪】 4. 最优算法 本文为Python算法题集之一的代…
阅读更多...
肯尼斯·里科《C和指针》第12章 使用结构和指针（1）链表

肯尼斯·里科《C和指针》第12章 使用结构和指针（1）链表

只恨当时学的时候没有读到这本书&#xff0c;&#xff0c;&#xff0c;&#xff0c;&#xff0c;&#xff0c; 12.1 链表 有些读者可能还不熟悉链表&#xff0c;这里对它作一简单介绍。链表(linked list)就一些包含数据的独立数据结构&#xff08;通常称为节点&#xff09;的集…
阅读更多...
LeetCode 21.合并两个有序链表(python版)

LeetCode 21.合并两个有序链表(python版)

需求 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4] 代码 class ListNode:def __init__(self,val0,nextNone):self.valva…
阅读更多...
「优选算法刷题」：比特位计数

「优选算法刷题」：比特位计数

一、题目 给你一个整数 n &#xff0c;对于 0 < i < n 中的每个 i &#xff0c;计算其二进制表示中 1 的个数 &#xff0c;返回一个长度为 n 1 的数组 ans 作为答案。 示例 1&#xff1a; 输入&#xff1a;n 2 输出&#xff1a;[0,1,1] 解释&#xff1a; 0 --> 0 1…
阅读更多...
力扣1290. 二进制链表转整数

力扣1290. 二进制链表转整数

Problem: 1290. 二进制链表转整数 文章目录 题目描述思路复杂度Code 题目描述 思路 1.记录一个变量res初始化为0&#xff0c;指针p指向链表头&#xff1b; 2.循环每次res res * 2 p -> val;p p -> next;&#xff08;充分利用二进制数的特性&#xff1b;其中利用指针先…
阅读更多...
Java链表（2）

Java链表（2）

&#x1f435;本篇文章将对双向链表进行讲解&#xff0c;模拟实现双向链表的常用方法 一、什么是双向链表 双向链表在指针域上相较于单链表&#xff0c;每一个节点多了一个指向前驱节点的引用prev以及多了指向最后一个节点的引用last&#xff1a; 二、双向链表的模拟实现 首先…
阅读更多...
树--二叉树(C语言纯手凹)

树--二叉树(C语言纯手凹)

目录 目录 1.什么是树&#xff1f;&#xff08;不深入&#xff0c;仅做了解&#xff09; 2.树的表示方式 2.1孩子兄弟表示法&#xff08;左孩子右兄弟&#xff09; 2.2孩子表示法 2.3双亲表示法 3.什么是二叉树 4.二叉树分类 4.1满二叉树 4.2完全二叉树 4.3二叉搜索树…
阅读更多...
数据结构----链表介绍、模拟实现链表、链表的使用

数据结构----链表介绍、模拟实现链表、链表的使用

文章目录 1. ArrayList存在的问题2. 链表定义2.1 链表的概念及结构2.2 链表的组合类型 3. 链表的实现3.1 单向、不带头、非循环链表的实现3.2 双向、不带头节点、非循环链表的实现 4.LinkedList的使用4.1 什么是LinkedList4.2 LinkedList的使用4.2.1. LinkedList的构造4.2.2. L…
阅读更多...
LeetCode-回文链表（234）

LeetCode-回文链表（234）

题目描述&#xff1a; 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 因为这一题是受到876题求链表中间节点的启发&#xff0c;所以在这里也加一下。 876.链表的中间结点…
阅读更多...
LeetCode206反转链表(java实现)

LeetCode206反转链表(java实现)

今天带来的题目解析是leetcode206&#xff0c;反转链表&#xff0c;我们来看下题目描述 如何实现链表的反转呢&#xff1f;我在这里提供的思路是双指针的思路。 具体的思路如下&#xff1a; 假设我们的原链表如下 首先定义一个指针pre&#xff0c;用于指向head之前的位置&am…
阅读更多...
【Leetcode 25】K 个一组翻转链表 —— 递归

【Leetcode 25】K 个一组翻转链表 —— 递归

25. K 个一组翻转链表 给你链表的头节点head&#xff0c;每k个节点一组进行翻转&#xff0c;请你返回修改后的链表。 k是一个正整数&#xff0c;它的值小于或等于链表的长度。如果节点总数不是k的整数倍&#xff0c;那么请将最后剩余的节点保持原有顺序。 你不能只是单纯的改…
阅读更多...
剑指offer面试题13 在O(1)时间删除链表结点

剑指offer面试题13 在O(1)时间删除链表结点

考察点 链表知识点 链表的删除正常情况下需要O(n)的时间&#xff0c;因为需要找到待删除结点的前置结点题目 分析 我们都知道链表删除往往需要O(n)遍历链表&#xff0c;找到待删除结点的前置结点&#xff0c;把前置结点的next指针指向待删除结点的后置结点。现在要求O(1)时间…
阅读更多...
力扣面试题02.07-链表相交

力扣面试题02.07-链表相交

链表相交 题目链接 解题思路&#xff1a; 题目可以确定如果相交&#xff0c;那么相交的部分一定是在链表的结尾部分第一步求得两条链表的长度第二步长度做差&#xff0c;将长的那条链表与短的那条链表后部分对其第三步遍历后面的部分&#xff0c;如果当前节点相等&#xff0c;…
阅读更多...
【数据结构】链表的一些面试题

【数据结构】链表的一些面试题

简单不先于复杂&#xff0c;而是在复杂之后。 链表面试题 删除链表中等于给定值 val 的所有结点。OJ链接 //1.常规方法struct ListNode* removeElements(struct ListNode* head, int val) {struct ListNode* cur head, *prev NULL;while(cur){if(cur->val val){//1.头删/…
阅读更多...
将链表反转

将链表反转

反转链表在解决需要从尾节点开始遍历到头节点的地方很实用&#xff0c;是一种常用的解题技巧。在反转时&#xff0c;我们可以考虑从前向后反转和从后向前反转两种方式。 法一&#xff1a;递归 每次将链表的头节点的下一个节点作为新的头节点&#xff0c;然后对剩余部分调用递归…
阅读更多...
环形链表找入环点----链表OJ---三指针

环形链表找入环点----链表OJ---三指针

https://leetcode.cn/problems/linked-list-cycle-ii/description/?envTypestudy-plan-v2&envIdtop-100-liked 首先&#xff0c;需要判断是否有环&#xff0c;而这里我们不单纯判断是否有环&#xff0c;还要为下一步做准备&#xff0c;需要让slow指针和fast都从头结点开始…
阅读更多...
【详解】斗地主随机发牌项目

【详解】斗地主随机发牌项目

目录 前言&#xff1a; 1.初始化牌 2.洗牌 3.揭牌 总代码&#xff1a; Card类&#xff1a; CardGame类&#xff1a; Main类&#xff1a; 结语&#xff1a; 前言&#xff1a; 斗地主是全国范围内的一种桌面游戏&#xff0c;本节我们来实现一下斗地主中的简单初始化牌、…
阅读更多...
前端面试题——JS实现反转链式表

前端面试题——JS实现反转链式表

前言 反转单向链表就是将整个单链表的数据进行倒序的过程。 例如&#xff0c;如果反转之前的单链表是0->1->2->3&#xff0c;那么反转之后的单链表应该是3->2->1->0。这个操作通常是通过改变链表中每个节点的指针方向来实现的&#xff0c;即让每个节点的指…
阅读更多...
Leecode之反转链表

Leecode之反转链表

一.题目及剖析 https://leetcode.cn/problems/reverse-linked-list/description/ 二.思路引入 设定三个指针,n1指向空, n2指向head,n3指向下一个元素,将n2->next指向n1,然后三个指针向后遍历重复即可 三.代码引入 /*** Definition for singly-linked list.* struct List…
阅读更多...
「优选算法刷题」：在排序数组中查找元素的第一个和最后一个位置

「优选算法刷题」：在排序数组中查找元素的第一个和最后一个位置

一、题目 给你一个按照非递减顺序排列的整数数组 nums&#xff0c;和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。 如果数组中不存在目标值 target&#xff0c;返回 [-1, -1]。 你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。 示例 1&…
阅读更多...
leetcode链表相关题目

leetcode链表相关题目

文章目录 1.移除链表元素方法1&#xff1a;方法2 2.合并两个有序链表3.链表的中间节点方法1方法2 4.反转单链表方法1方法2 5.分割链表6.链表中的倒数第k个节点方法1&#xff1a;方法2: 7.环形链表的约瑟夫问题8.链表的回文结构9.相交链表方法1方法2&#xff1a; 10.环形链表11.…
阅读更多...
数据结构（4） 链表（链式存储）

数据结构（4） 链表（链式存储）

链表&#xff08;链式存储&#xff09; 单链表定义基本操作的实现单链表的插入按位序插入指定节点的前插指定节点的后插 单链表的删除 小结 单链表 定义 顺序表优点:可随机存取&#xff0c;存储密度高&#xff0c;缺点:要求大片连续空间&#xff0c;改变容量不方便。 单链表优…
阅读更多...
合并K个有序链表----链表OJ

合并K个有序链表----链表OJ

https://leetcode.cn/problems/merge-k-sorted-lists/submissions/499384099/?envTypestudy-plan-v2&envIdtop-100-liked 1、两两合并 前面我们做过合并两个有序链表&#xff0c;那么这里合并K个有序链表&#xff0c;是否可以联想到合并两个呢&#xff1f;答案是可以的&am…
阅读更多...
链表 任意位置插入一个节点

链表 任意位置插入一个节点

那么&#xff0c;内存中发生了什么事情呢&#xff1f; 当程序开始执行时&#xff0c;最初将调用main函数&#xff0c;栈中的部分内存被分配用于执行函数。 所有局部变量以及该函数的执行状态都保存在这个特定的区域&#xff0c;我们也将其称为函数的栈帧。 在此main函数中&…
阅读更多...
【无标题】旋转链表与力扣报错：member access within null pointer of type ‘struct ListNode‘

【无标题】旋转链表与力扣报错：member access within null pointer of type ‘struct ListNode‘

项目场景&#xff1a; 做单链表反转题目&#xff0c;报错&#xff1a;member access within null pointer of type ‘struct ListNode’ 题目链接:LINK 问题描述 我明明在初始化指针时候&#xff0c;已经处理了n2->next情况却依然报错 这个报错提示含义是&#xff1a;大概就…
阅读更多...
单向循环链表的操作

单向循环链表的操作

main函数&#xff1a; #ifndef __loopLinkList_H__#define __loopLinkList_H__typedef int datatype;union msg{ //若数据的类型也为int&#xff0c;则不需要这个联合体datatype data;int len; //放头结点&#xff0c;记录链表长度};typedef struct node{union msg te…
阅读更多...
双向链表的操作（C语言）

双向链表的操作（C语言）

main函数部分&#xff1a; #include <stdio.h> #include "./23_doubleLinkList.h" int main(int argc, const char *argv[]) { doubleLinkList* head create_doubleLinkList();insertHead_doubleLinkList(head,12);insertHead_doubleLinkList(head,21);inse…
阅读更多...
【刷题记录】链表的回文结构

【刷题记录】链表的回文结构

本系列博客为个人刷题思路分享&#xff0c;有需要借鉴即可。 1.题目链接&#xff1a; LINK 2.详解思路&#xff1a; 思路&#xff1a;思路&#xff1a;先找到中间节点&#xff0c;然后逆置后半部分链表&#xff0c;一个指针指向链表的头节点&#xff0c;再一个指针指向逆置的头…
阅读更多...
python中的链表

python中的链表

单向链表 单向链表也叫单链表&#xff0c;是链表中最简单的一种形式&#xff0c;他的每个节点包含两个域&#xff0c;一个信息域&#xff08;元素域&#xff09;和一个链接域。这个链接指向链表中的下一个节点&#xff0c;而最后一个节点的连接域则指向一个空值。 &#xff08;…
阅读更多...
C语言链表（linked list）基础知识总结

C语言链表（linked list）基础知识总结

一、链表 1.概念&#xff1a;链表是一种物理存储单元上非连续、非顺序的存储结构。 2.组成&#xff1a;链表由一个个结点连接而成&#xff0c;每一个结点分为俩个主要部分。第一个部分是数据部分&#xff0c;用于存储该结点的数据。第二个部分为指针部分&#xff0c;每个结点…
阅读更多...
数据结构与算法 — 约瑟夫问题(Josephu)

数据结构与算法 — 约瑟夫问题(Josephu)

问题背景 著名犹太历史学家Josephus有过以下的故事&#xff1a;在罗马人占领乔塔帕特后&#xff0c;39 个犹太人与Josephus及他的朋友躲到一个洞中&#xff0c;39个犹太人决定宁愿死也不要被敌人抓到&#xff0c;于是决定了一个自杀方式&#xff0c;41个人排成一个圆圈&#x…
阅读更多...
JavaScript——读取链表元素，颠倒存储

JavaScript——读取链表元素，颠倒存储

题目背景&#xff1a; 对链表的考察。面试的时候&#xff0c;由于链表的创建、插入、删除等操作&#xff0c;代码量不是很多&#xff0c;相较哈希表、有向图等数据结构而言&#xff1b;但又考察应聘者的编程功底&#xff0c;为各个公司面试官所青睐。应当重视。 题目描述&…
阅读更多...
数据结构——C语言线性表（顺序表）的插入和删除

数据结构——C语言线性表（顺序表）的插入和删除

顺序表属于顺序存储结构&#xff0c;其逻辑次序与存储位置的物理次序一致&#xff0c;物理位置反映逻辑关系&#xff0c;按位置随机存取是其最大的特点。结构组成如下&#xff1a; #define MAXSIZE 100 typedef struct list{int array[MAXSIZE];int last; }SeqList;last记录当…
阅读更多...
《大话数据结构》——栈与队列

《大话数据结构》——栈与队列

栈 栈的定义 栈&#xff08;stack&#xff09;是限定仅在表尾进行插入和删除操作的线性表栈顶&#xff08;top&#xff09;允许插入和删除的一端&#xff0c;另一端叫栈底&#xff08;bottom&#xff09;栈&#xff1a;先入后出&#xff0c;类似弹夹 栈的顺序存储结构 即用…
阅读更多...
《大话数据结构》——线性表

《大话数据结构》——线性表

线性表的的定义 线性表元素个数有限&#xff1b;线性表元素的数据类型相同&#xff1b;第一个元素只有一个直接后继&#xff0c;最后一个元素只有一个直接前继&#xff0c;其他中间元素有且只有一个直接前继和直接后继&#xff1b; 线性表的抽象数据类型 基本操作&#xff1…
阅读更多...
剑指offer（16）——C++实现两个链表合并

剑指offer（16）——C++实现两个链表合并

题目 输入两个单调递增的链表&#xff0c;输出两个链表合成后的链表&#xff0c;当然我们需要合成后的链表满足单调不减规则。 考察点 链表 解题思路 递归实现&#xff0c;比较每个节点大小&#xff0c;将较小的放入新链表非递归&#xff0c;原理同上 完整代码 /*16-合并…
阅读更多...
剑指offer（3）——C++实现链表的反向输出

剑指offer（3）——C++实现链表的反向输出

题目描述 给定一个链表&#xff0c;反向输出。 考察知识 链表的创建以及常规操作栈的使用 解题思路 先进去的后输出&#xff0c;自然想到是栈的特点&#xff0c;故使用栈来实现。递归的本质也是栈。 完整代码 /*03_printlist*/ #include<iostream> #include<ve…
阅读更多...
数据结构-单链表的各种操作08

数据结构-单链表的各种操作08

单链表的创建、增加、删除、倒转 //链表 typedef struct Node {int data;struct Node *next; }TyLIST;//1.创建链表 TyLIST *CreateList() {TyLIST *m_pHead (TyLIST *)malloc(sizeof(TyLIST));m_pHead->data 0;m_pHead->next nullptr;int m_nvalue 0;printf("…
阅读更多...
数据结构之手写双向链表(Java)

数据结构之手写双向链表(Java)

public class DoublyLinkedList<E> {// 节点数量private int size;// 头节点private Node<E> head;// 尾节点private Node<E> tail;/*** 在链表尾部添加节点** param element*/public void add(E element) {add(size, element);}/*** 在指定索引处&#xff0…
阅读更多...
java集合部分：如何理解LinkedList？

java集合部分：如何理解LinkedList？

链表&#xff08;Linked list&#xff09;是一种常见的基础数据结构&#xff0c;是一种线性表&#xff0c;但是并不会按线性的顺序存储数据&#xff0c;而是在每一个节点里存到下一个节点的地址。 链表可分为单向链表和双向链表。 一个单向链表包含两个值: 当前节点的值和一个…
阅读更多...
第一次月考

第一次月考

以下哪个方法可以通过StringBuffer对象追加字符串&#xff1f; A.add() B.insert() C.append() D.into() 选C下面描述方法重写错误的是&#xff1f; A.要有子类继承或实现 B.子类方法的权限必须大于等于父类的权限 C.父类中被private权限修饰符的方法可以被子类重写 D.子类重写…
阅读更多...
链表基础知识和相关操作

链表基础知识和相关操作

一、链表的类型 1.单链表 入口点为链表的头结点(head)&#xff0c;链表中每个节点存储该结点的内容(数据)以及下一个节点的指针。 2.双链表 每个节点有两个指针域&#xff0c;一个指向该结点前一节点&#xff0c;另一个指向该结点后一节点&#xff0c;此种链表既可向前查询也…
阅读更多...
第三章--基于链表的符号表

第三章--基于链表的符号表

public class ST <Key,Value> {/*** 利用链表来存储符号表。这里的Node采用头插法创建&#xff0c;我在原有基础上创建了一个print方法。*/Node first;public class Node {Key key;Value val;Node next;public Node(Key key, Value val, Node next) {this.key key;this.…
阅读更多...
MySQL(InnoDB剖析):---哈希算法与自适应哈希索引

MySQL(InnoDB剖析):---哈希算法与自适应哈希索引

一、哈希算法 哈希算法是一种常见算法&#xff0c;时间复杂度为O(1)&#xff0c;且不只存在于索引中&#xff0c;每个数据库应用中都存在该数据库结构二、哈希表 哈希表也称散列表&#xff0c;由直接寻址表改进而来.先看直接寻址表 当关键字的全域U比较小时&#xff0c;直接寻…
阅读更多...
LeetCode算法解析之“重排链表”问题

LeetCode算法解析之“重排链表”问题

给定一个单链表 L&#xff1a;L0→L1→…→Ln-1→Ln &#xff0c; 将其重新排列后变为&#xff1a; L0→Ln→L1→Ln-1→L2→Ln-2→… 你不能只是单纯的改变节点内部的值&#xff0c;而是需要实际的进行节点交换。 示例 1: 示例 2: 解题思路如下&#xff1a; 因为链表不支持下标…
阅读更多...
LeetCode算法解析之“K个一组翻转链表问题”

LeetCode算法解析之“K个一组翻转链表问题”

给你一个链表&#xff0c;每 k 个节点一组进行翻转&#xff0c;请你返回翻转后的链表。 k 是一个正整数&#xff0c;它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍&#xff0c;那么请将最后剩余的节点保持原有顺序。 解题思路: 我们需要把链表结点按照 k 个一组分…
阅读更多...
LeetCode-21.合并两个有序链表

LeetCode-21.合并两个有序链表

21.合并两个有序单链表&#xff1a; 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 2&#xff1a; 输入&#xff1a;l1 [], l2 [] 输出&#xff1a;[] 示例 3&#xff1a; 输入&#xff1a;l1 [], l2 [0] 输出…
阅读更多...
LeetCode算法解析之单链表反转

LeetCode算法解析之单链表反转

单链表的反转 定义一个新的头结点 reverseHead &#xff0c;一点一点将链表反转后&#xff0c;再串起来 怎么个串法&#xff1f; 在原链表中每读取一个节点&#xff08;cur&#xff09;&#xff0c;先保存其下一个节点的地址&#xff08;next&#xff09;&#xff0c;然后将 c…
阅读更多...
算法-快慢指针

算法-快慢指针

一、“判断单链表是否有环” 我们就可以设置一个慢指针和一个快指针来遍历这个链表。慢指针一次移动一个节点&#xff0c;而快指针一次移动两个节点&#xff0c;如果该链表没有环&#xff0c;则快指针会先遍历完这个表&#xff0c;如果有环&#xff0c;则快指针会在第二次遍历…
阅读更多...
数据结构-2.单链表的插入

数据结构-2.单链表的插入

一.带头结点按位序插入 思路&#xff1a;找到它前面一个结点&#xff08;i-1&#xff09; bool InsertList(LinkList &L,int i,int e){if(i<1)return false;//i为插入位置&#xff0c;判断是否合法LNode *p;//p指针来扫描结点pL;//L指向头结点&#xff0c;也是p初始值…
阅读更多...
9月3号数据结构学习笔记

9月3号数据结构学习笔记

为何这样写可以&#xff0c;因为Q.front与Q.rear本身都是一个指针&#xff0c;指针指的地址变了&#xff0c;所以会有变化。 盲猜是把结构体 struct LinkNode命名为LinkNode struct命名为LinkQueue 对比一下单链表的操作我对初始化有点懵。 我明白了&#xff0c;因为LinkLi…
阅读更多...
链表重排序

链表重排序

问题描述&#xff1a; 给定一个单链表L: L0→L1→…→Ln-1→Ln,重新排列后为&#xff1a;L0→Ln→L1→Ln-1→L2→Ln-2→…必须在不改变节点值的情况下进行原地操作。题解1 - 链表长度(TLE) __ 直观角度来考虑&#xff0c;如果把链表视为数组来处理&#xff0c;那么我们要做的…
阅读更多...
合并k个升序链表-链表23-python

合并k个升序链表-链表23-python

归并思想&#xff0c;两两合并链表 python # Definition for singly-linked list. # class ListNode: # def __init__(self, val0, nextNone): # self.val val # self.next next class Solution:def merge(self, head1, head2):pre curr ListNode(10…
阅读更多...
严蔚敏数据结构P35——循环链表的建立和输出（书中无实例，本程序为帮助理解）

严蔚敏数据结构P35——循环链表的建立和输出（书中无实例，本程序为帮助理解）

严蔚敏数据结构P35——循环链表的建立和输出 &#xff08;书中无实例&#xff0c;本程序为帮助理解&#xff09; /* 严蔚敏数据结构P35——循环链表的建立和输出&#xff08;书中无实例&#xff0c;本程序为帮助理解&#xff09; *///头文件 #include<stdio.h> #include…
阅读更多...
使用哈夫曼树将字符重新编码(压缩数据)

使用哈夫曼树将字符重新编码(压缩数据)

huffmanTree.c #include "huffmanTree.h"HuffmanTree new_huffman_tree_node(data_size data) {//申请对内存给节点HuffmanTree tmp (HuffmanTree)malloc(sizeof(HuffmanTreeNode));if(tmp ! NULL) //申请成功{tmp->parentNode 0;tmp->leftSubtree 0;tmp…
阅读更多...
约瑟夫环 链表解法

约瑟夫环 链表解法

链接&#xff1a;登录—专业IT笔试面试备考平台_牛客网 来源&#xff1a;牛客网 输入描述: 输入一行包含三个整数n,k,m1<n<100,1<k<n-1,1<m<100 输出描述: 输出一个整数 示例1 输入 复制5 1 2 5 1 2 输出 复制3 3 链表解法 与数组标记法 #inc…
阅读更多...
数据结构知识点

数据结构知识点

1、线性结构与非线性结构线性结构&#xff1a;线性表&#xff0c;栈&#xff0c;队&#xff1b;一个根节点&#xff0c;最多一个前节点一个后节点&#xff1b;首节点无前节点&#xff0c;尾接点无后节点非线性结构&#xff1a;树形结构&#xff0c;图形结构线性表&#xff1a;由…
阅读更多...
队列实现的这些细节你都注意到了吗？

队列实现的这些细节你都注意到了吗？

&#x1f34c;队列实现的这些细节你都注意到了吗&#xff1f;&#x1f34c;队列的实现代码这些细节你都注意到了吗&#xff1f;队列的实现代码 Queue.h #define _CRT_SECURE_NO_WARNINGS 1#include<stdio.h> #include<stdlib.h> #include<assert.h> #inclu…
阅读更多...
[图文详解]C语言实现学生成绩管理系统，采用链表结构

[图文详解]C语言实现学生成绩管理系统，采用链表结构

目录 一、前言&#xff08;学习请从头开始看&#xff09; 二、要求和思路 2.1 要求 2.2 数据结构的定义 2.3 基本函数的申明 2.3.1 链表初始化 2.3.2 尾部增加节点 2.3.3 删除节点 2.3.4 修改节点 2.3.5 搜索节点 三、具体构建 3.1 函数申明 3.2 读取文件 3.3…
阅读更多...
学习笔记-单链表操作

学习笔记-单链表操作

求单链表中有效节点的个数 /** * * param head 链表的头节点 * return 返回的就是有效节点的个数 */ public static int getLength(HeroNode head) {if(head.next null) { //空链表return 0;}int length 0;//定义一个辅助的变量, 这里我们没有统计头节点HeroNode cur head.…
阅读更多...
学习笔记-单链表

学习笔记-单链表

单链表 单链表是由多个节点组成的。它是一种有序的链式存储&#xff0c;也就是在各节点的存储位置不一定相连。同时&#xff0c;单链表分为有头节点和没有头节点&#xff0c;具体通过工作的细节自己选择。而节点由数据和next指针组成。其中&#xff0c;next指针的作用是指向下一…
阅读更多...
操作系统|C语言模拟实现首次适应和最佳适应两种内存分配算法以及内存回收

操作系统|C语言模拟实现首次适应和最佳适应两种内存分配算法以及内存回收

两种算法 首次适应 首次适应算法从空闲分区表的第一个表目起查找该表&#xff0c;把最先能够满足要求的空闲区分配给作业&#xff0c;这种方法目的在于减少查找时间。为适应这种算法&#xff0c;空闲分区表(空闲区链)中的空闲分区要按地址由低到高进行排序。该算法优先使用低址…
阅读更多...
判断链表是否为回文结构

判断链表是否为回文结构

#判断链表是否为回文结构 class Solution:def isPail(self,head):curheadmylist[]while cur!None:mylist.append(cur.val)curcur.nextnlen(mylist)for i in range(0,n//2):if mylist[i]!mylist[n-i-1]:return Falsereturn True
阅读更多...
双向链表的创建与CRUD的实现

双向链表的创建与CRUD的实现

链表是由结点的方式来储存的&#xff0c;是链式存储。其的组成需要有data(数据域)&#xff0c;指向下一个结点的next&#xff0c;指向前一个结点的pre(双向链表)。链表可以分为有头结点和无头结点的链表。注意&#xff1a;链表是一种逻辑上的顺序存储结构&#xff0c;而物理上不…
阅读更多...
数据结构 图 邻接表表示法

数据结构 图 邻接表表示法

图 邻接表表示法 图的邻接矩阵表示法看这里 基本结构&#xff1a; template<typename InfoType> struct ArcNode {int adjvex;ArcNode* nextarc;InfoType* info; };template<typename VertexType, typename InfoType> struct VNode {VertexType data;ArcNode<…
阅读更多...
160 https://leetcode-cn.com/problems/intersection-of-two-linked-lists/ 相交链表

160 https://leetcode-cn.com/problems/intersection-of-two-linked-lists/ 相交链表

编写一个程序&#xff0c;找到两个单链表相交的起始节点。 https://leetcode-cn.com/problems/intersection-of-two-linked-lists/ 思路 两个指针同时从两个链表的head开始移动&#xff0c;由此计算出两个链表的长度差。然后让较长的链表减去这个差值&#xff0c;再设置两个指…
阅读更多...
数据结构-树的表示与存储

数据结构-树的表示与存储

一、双亲表示法 #define MAX_TREE_SIZE 100 using TElemType char; using PTNode struct PTNode1 //结点结构 {TElemType data; //结点数据int parent; //双亲位置 }; using PTree struct PTree1 //树结构 {PTNode nodes[MAX_TREE…
阅读更多...
数据结构--1. 链表

数据结构--1. 链表

文章目录一、单链表1. 基本运算1.1 单链表的建立1.1.1 头插法1.1.2 尾插法1.2 求表长1.3 查找1.3.1 按照序号查找1.3.2 按值x查找1.4 插入1.4.1 头插法和尾插法&#xff08;链表的建立&#xff09;1.4.2 任意位置插入1.5 删除二、单循环链表三、 双向链表1. 插入2. 删除一、单链…
阅读更多...
leetcode算法题之合并两个升序链表

leetcode算法题之合并两个升序链表

题目: 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 解决方法&#xff1a; /*** Example:* var li ListNode(5)* var v li.val* Definition for singly-linked list.* class ListNode(var val: Int) {* var next:…
阅读更多...
Java数据结构习题:编写一个EnNodeFirstNext（），接受首节点作为参数，将第二个结点插入链表并使之成为第一个结点的后续结点（如果参数为空则什么也不做)

Java数据结构习题:编写一个EnNodeFirstNext（），接受首节点作为参数，将第二个结点插入链表并使之成为第一个结点的后续结点（如果参数为空则什么也不做)

编写一个EnNodeFirstNext&#xff08;&#xff09;&#xff0c;接受首节点作为参数&#xff0c;将第二个结点插入链表并使之成为第一个结点的后续结点&#xff08;如果参数为空则什么也不做) 核心代码: // 编写一个EnNodeFirstNext&#xff08;&#xff09;&#xff0c;接受首…
阅读更多...
严蔚敏数据结构 P39——算法2.20（ 两张强制递增双向循环链表（List和List2）按值的大小，递增归并于一张归并表（List3）(利用前置指针和后置指针进行正序输出)）

严蔚敏数据结构 P39——算法2.20（ 两张强制递增双向循环链表（List和List2）按值的大小，递增归并于一张归并表（List3）(利用前置指针和后置指针进行正序输出)）

严蔚敏数据结构 P39——算法2.20 两张强制递增双向循环链表&#xff08;List和List2&#xff09;按值的大小&#xff0c;递增归并于一张归并表&#xff08;List3&#xff09;(利用前置指针和后置指针进行正序输出) /* 严蔚敏数据结构 P39——算法2.20 两张强制递增双向循环链表…
阅读更多...
单链表的整表删除__小工具——中职

单链表的整表删除__小工具——中职

本程序为提供可执行链表的必要环节&#xff0c;所以单独拎出来。 理解即可 单链表的整表删除 /* 本程序为提供可执行链表的必要环节&#xff0c;所以单独拎出来。 理解即可单链表的整表删除 *///头文件 #include<stdio.h> #include<malloc.h> #include<stdlib…
阅读更多...
深入理解redis底层数据结构之跳跃表

深入理解redis底层数据结构之跳跃表

跳跃表&#xff08;skipList&#xff09; ​ 跳跃表是redis中独有的数据结构&#xff0c;在了解它之前&#xff0c;我们先来回顾一下普通的有序链表。 ​ 在一串有序链表中&#xff0c;如果我们要查找某个值&#xff0c;我们只能从头节点依次向后遍历直到找到目标值为止。如果…
阅读更多...
Docker 批量删除中间镜像缓存

Docker 批量删除中间镜像缓存

Docker 批量删除中间镜像缓存 docker ps -a | grep "Exited" | awk {print $1 }|xargs docker stop docker ps -a | grep "Exited" | awk {print $1 }|xargs docker rm docker images|grep none|awk {print $3 }|xargs docker rmi
阅读更多...
LeetCode002之两数相加（相关话题：链表操作）

LeetCode002之两数相加（相关话题：链表操作）

题目描述 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照逆序的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0c;这两个数都不…
阅读更多...
LeetCode025之K 个一组翻转链表（关话题：递归，链表逆序）

LeetCode025之K 个一组翻转链表（关话题：递归，链表逆序）

题目描述&#xff1a; 给你一个链表&#xff0c;每 k 个节点一组进行翻转&#xff0c;请你返回翻转后的链表。 k 是一个正整数&#xff0c;它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍&#xff0c;那么请将最后剩余的节点保持原有顺序。 示例&#xff1a; …
阅读更多...
第5-6周练习题2020——2-3 链表拼接 (20分)

第5-6周练习题2020——2-3 链表拼接 (20分)

本题要求实现一个合并两个有序链表的简单函数。链表结点定义如下&#xff1a; struct ListNode { int data; struct ListNode *next; }; 函数接口定义&#xff1a; struct ListNode *mergelists(struct ListNode *list1, struct ListNode *list2); 其中list1和list2是用户传入…
阅读更多...
【数据结构入门】顺序表和链表的区别，以及啥是缓存利用率

【数据结构入门】顺序表和链表的区别，以及啥是缓存利用率

文章目录&#xff08;1&#xff09;顺序表和链表的区别&#xff08;2&#xff09;缓存利用率1&#xff09;存储器层次结构2&#xff09;CPU和寄存器、高速缓存&#xff0c;以及主存之间的关系3&#xff09;缓存利用率&#xff08;1&#xff09;顺序表和链表的区别 链表和顺序表…
阅读更多...
【数据结构入门】带头双向循环链表（List）详解（定义、增、删、查、改） | 配有大量图解，超详细哦~

【数据结构入门】带头双向循环链表（List）详解（定义、增、删、查、改） | 配有大量图解，超详细哦~

文章目录&#xff08;1&#xff09;前言&#xff08;2&#xff09;带头双向循环链表的实现1&#xff09;双向链表的定义2&#xff09;双向链表的初始化3&#xff09;双向链表的销毁4&#xff09;打印双向链表5&#xff09;双向链表的尾插6&#xff09;双向链表的尾删7&#xff…
阅读更多...
【LeetCode】反转链表（C语言）| 动图演示，超详细哦~

【LeetCode】反转链表（C语言）| 动图演示，超详细哦~

文章目录&#xff08;1&#xff09;题目描述&#xff08;2&#xff09;解题思路1&#xff09;解法1&#xff1a;调整节点指针的方向2&#xff09;解法2&#xff1a;头插法题目难度&#xff1a;《简单》&#xff08;1&#xff09;题目描述 给你单链表的头节点 head &#xff0c;…
阅读更多...
[javascript]二叉搜索树与双向链表

[javascript]二叉搜索树与双向链表

二叉搜索树与双向链表描述输入描述返回值描述示例1示例2代码描述 输入一棵二叉搜索树&#xff0c;将该二叉搜索树转换成一个排序的双向链表。如下图所示 数据范围&#xff1a;输入二叉树的节点数 0 \le n \le 10000≤n≤1000&#xff0c;二叉树中每个节点的值 0\le val \le 1…
阅读更多...
[剑指offer]JT25---复杂链表的复制(按部就班太难,map最懂我)

[剑指offer]JT25---复杂链表的复制(按部就班太难,map最懂我)

剑指offer第二十五题题目如下思路分析与代码题目如下 思路分析与代码 你别说&#xff0c;其实这题算难得 原始思路如下&#xff1a; 把复制的结点链接在原始链表的每一对应结点后面 把复制的结点的random指针指向被复制结点的random指针的下一个结点 拆分成两个链表&#…
阅读更多...
[剑指offer]JT14---链表中倒数第k个结点(震惊！！！双指针相对运动轻松解题)

[剑指offer]JT14---链表中倒数第k个结点(震惊！！！双指针相对运动轻松解题)

剑指offer第十四题题目如下思路与代码题目如下 思路与代码 第一种思路&#xff0c;把链表拿出来&#xff0c;然后倒着访问就行了&#xff0c;我开始是用vector存值&#xff0c;然后倒着访问&#xff0c;发现需要访问的是一个链表&#xff0c;那就不能直接用这种方法了啊。 这…
阅读更多...
【LeetCode】移除链表元素（C语言）| 图解算法，超详细哦~

【LeetCode】移除链表元素（C语言）| 图解算法，超详细哦~

文章目录&#xff08;1&#xff09;题目描述&#xff08;2&#xff09;解题思路1&#xff09;思路1&#xff1a;找到等于 val 的节点直接删除2&#xff09;思路2&#xff1a;将不等于 val 的节点尾插到一个新链表中《题目难度&#xff1a;简单》&#xff08;1&#xff09;题目描…
阅读更多...
【数据结构入门】无头单向非循环链表（SList）详解（定义、增、删、查、改） | 图解链表，超生动详细哦~

【数据结构入门】无头单向非循环链表（SList）详解（定义、增、删、查、改） | 图解链表，超生动详细哦~

文章目录&#xff08;1&#xff09;链表介绍1&#xff09;为什么引入链表2&#xff09;链表的概念及结构3&#xff09;链表的分类&#xff08;2&#xff09;无头单向非循环链表的实现1&#xff09;单链表的定义2&#xff09;动态申请一个节点3&#xff09;销毁&#xff08;释放…
阅读更多...
数据结构入门：队列

数据结构入门：队列

目录 文章目录 前言 1.队列 1.1 队列的概念及结构 1.2 队列的实现 1.2.1 队列的定义 1.2.2队列的初始化 1.2.3 入队 1.2.4 判空 1.2.5 出队 1.2.6 队头队尾数据 1.2.7 队列长度 1.2.8 队列销毁 总结 前言 队列&#xff0c;作为一种重要的数据结构&#xff0c;在计算机科学中扮演…
阅读更多...
【golang】链表（List）

【golang】链表（List）

List实现了一个双向链表&#xff0c;而Element则代表了链表中元素的结构。 可以把自己生成的Element类型值传给链表吗&#xff1f; 首先来看List的四种方法。 MoveBefore方法和MoveAfter方法&#xff0c;它们分别用于把给定的元素移动到另一个元素的前面和后面。 MoveToFro…
阅读更多...
【链表】经典链表题LeetCode

【链表】经典链表题LeetCode

文章目录 160. 相交链表 简单&#x1f525;206. 反转链表 简单&#x1f525;876. 链表的中间结点 简单234. 回文链表 简单&#x1f525;141. 环形链表 简单&#x1f525;142. 环形链表 II 中等&#x1f525;21. 合并两个有序链表 简单&#x1f525;2. 两数相加 中等&#x1f52…
阅读更多...
C语言 中序遍历二叉树--非递归算法

C语言 中序遍历二叉树--非递归算法

完整代码如下&#xff1a; #include <stdio.h> #include <stdlib.h> #include <string.h>typedef struct BiTNode//二叉树的结构体 {char ch;//二叉树的数据域 struct BiTNode *lchild,*rchild;//二叉树的指针域 }BiTNode ,*BiTree;typedef struct StackN…
阅读更多...
leetcode 206.反转链表

leetcode 206.反转链表

⭐️ 往期相关文章 ✨链接&#xff1a;数据结构-手撕单链表代码详解。 ⭐️ 题目描述 &#x1f31f; leetcode链接&#xff1a;反转链表 1️⃣ 代码&#xff1a; /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* }…
阅读更多...
链表基本操作（C语言/c++）

链表基本操作（C语言/c++）

链表基本操作 1建立链表 2头插 3尾插 4清空 5查找 6删除 7销毁 #include <stdio.h> #include <stdlib.h>#define OK 1 #define ERROR 0 #define FLASE -1typedef int ElemType; typedef int Status;typedef struct LNode {ElemType data;struct LNode *next; }LN…
阅读更多...
Third. LeetCode206:Reverse Linked List 反转链表

Third. LeetCode206:Reverse Linked List 反转链表

Reverse a singly linked list. Example: Input: 1->2->3->4->5->NULL Output: 5->4->3->2->1->NULL 第一种方式是用迭代的方式来做用temp来存一下节点&#xff0c;然后让curr.next prev&#xff0c;就实现了箭头的反转然后让prev往前走一个节…
阅读更多...
散列表（Hash Table）概念、散列冲突、开散列模拟实现散列表

散列表（Hash Table）概念、散列冲突、开散列模拟实现散列表

散列表提供了一种完全不同的存储和搜索方式&#xff0c;通过将关键码映射到表中某个位置上来存储元素&#xff0c;然后根据关键码用同样的方式直接访问。 理想的搜索方法是可以不经过任何比较&#xff0c;一次直接从表中拿到搜索的元素&#xff0c;如果在元素的存储位置与它的…
阅读更多...
删除链表的节点

删除链表的节点

题目描述&#xff1a; 给定单向链表的头指针和一个要删除的节点的值&#xff0c;定义一个函数删除该节点。 返回删除后的链表的头节点。 示例 1: 输入: head [4,5,1,9], val 5 输出: [4,1,9] 解释: 给定你链表中值为 5 的第二个节点&#xff0c;那么在调用了你的函数之后&a…
阅读更多...
扁平化多级双向链表

扁平化多级双向链表

题目描述&#xff1a; 多级双向链表中&#xff0c;除了指向下一个节点和前一个节点指针之外&#xff0c;它还有一个子链表指针&#xff0c;可能指向单独的双向链表。这些子列表也可能会有一个或多个自己的子项&#xff0c;依此类推&#xff0c;生成多级数据结构&#xff0c;如下…
阅读更多...
LeetCode 023、合并k个升序链表

LeetCode 023、合并k个升序链表

LeetCode 023、合并k个升序链表 题目 题解 class Solution { public:struct comp {bool operator()(ListNode* a, ListNode* b) {return a->val > b->val;}};ListNode* mergeKLists(vector<ListNode*>& lists) {if (lists.empty()) return nullptr;// 虚拟…
阅读更多...
【简单】234. 回文链表【java】

【简单】234. 回文链表【java】

234. 回文链表 文章目录234. 回文链表题目一、双指针二、栈的方式题目 请判断一个链表是否为回文链表。 一、双指针 static boolean isPalindrome(ListNode head) {Boolean flag true;List<Integer> head2 new ArrayList<Integer>();while(null ! head) {head2…
阅读更多...
每日一题（移除链表元素）

每日一题（移除链表元素）

每日一题&#xff08;移除链表元素&#xff09; 203. 移除链表元素 - 力扣&#xff08;LeetCode&#xff09; 思路一&#xff1a; 可以创建一个新的链表头节点newhead&#xff0c;只要是原链表中值不为val的节点、都通过尾插操作插到newhead所指向的链表中&#xff0c;原链表中…
阅读更多...
链式栈StackT

链式栈StackT

C关键词&#xff1a;内部类/模板类/头插 C自学精简教程 目录(必读) C数据结构与算法实现&#xff08;目录&#xff09; 栈的内存结构 空栈&#xff1a; 有一个元素的栈&#xff1a; 多个元素的栈&#xff1a; 成员函数说明 0 clear 清空栈 clear 函数负责将栈的对内存释放…
阅读更多...
队列的链表实现 题目（难度1/10）

队列的链表实现 题目（难度1/10）

C数据结构与算法 目录 队列介绍 队列这种容器&#xff0c;就像大家排队上公交车一样。 第一个来到的人排在最前面&#xff1b; 最后来的排在最后面&#xff1b; 第一个先上车&#xff08;离开队列&#xff09;&#xff1b; 队列的接口 队列是有如下接口的容器&#xff1…
阅读更多...
【Hello Algorithm】链表相关算法题

【Hello Algorithm】链表相关算法题

本篇博客介绍&#xff1a; 介绍下链表相关的算法题 链表相关算法题 快慢指针回文结构链表将单向链表按某值划分为左边小&#xff0c;中间相等&#xff0c;右边大的形式复制带随机指针的链表 链表相关的算法题其实都算不上难 我们真正要考虑的是一些边界问题 事实上链表题就是在…
阅读更多...
链表模拟栈

链表模拟栈

定义节点 class Node {var num: Int _var next: Node _def this(num: Int) {thisthis.num num}override def toString: String s"num[${this.num}]" }定义方法 class LinkStack {private var head new Node(0)def getHead: Node head//判断是否为空def isEmp…
阅读更多...
实现基于栈的表达式求值计算器(难度4/10)

实现基于栈的表达式求值计算器(难度4/10)

本作业主要考察&#xff1a;解释器模式的实现思想/栈结构在表达式求值方面的绝对优势 C数据结构与算法夯实基础作业列表 通过栈的应用&#xff0c;理解特定领域设计的关键作用&#xff0c;给大家眼前一亮的感觉。深刻理解计算机语言和人类语言完美结合的杰作。是作业中的上等…
阅读更多...
Lua用table实现各种数据结构-链表

Lua用table实现各种数据结构-链表

Lua 中用 tables 很容易实现链表&#xff0c;每一个节点是一个 table&#xff0c;指针是这个表的一个域&#xff08;field&#xff09;&#xff0c;并且指向另一个节点&#xff08;table&#xff09;。在lua中很少用到链表&#xff0c;但是使用table很容易实现链表。就如同C语言…
阅读更多...
剑指offer 036、两个链表的第一个公共结点

剑指offer 036、两个链表的第一个公共结点

剑指offer 036、两个链表的第一个公共结点 题目 题解 分两种情况&#xff1a; 长度相同时&#xff1a; 若两链表有公共结点&#xff0c;第一次就遍历到了若无公共结点&#xff0c;两链表同时走到尾部nullptr&#xff0c;返回nullptr 长度不同时&#xff1a; 若有公共结点&am…
阅读更多...
*剑指offer 025、复杂链表的复制

*剑指offer 025、复杂链表的复制

剑指offer 025、复杂链表的复制 题目 题解 参考牛客大佬chancy 分为三个步骤&#xff1a; /* struct RandomListNode {int label;struct RandomListNode *next, *random;RandomListNode(int x) :label(x), next(NULL), random(NULL) {} }; */ class Solution { public:Rando…
阅读更多...
链表反转-迭代和递归

链表反转-迭代和递归

要求很简单&#xff0c;输入一个链表&#xff0c;反转链表后&#xff0c;输出新链表的表头。反转链表是有2种方法(递归法&#xff0c;遍历法)实现的&#xff0c;面试官最爱考察的算法无非是 斐波那契数列和单链表反转&#xff0c;递归方法实现链表反转比较优雅&#xff0c; 但是…
阅读更多...
单链表Java数据结构篇

单链表Java数据结构篇

本章学习目录 页内目录 一&#xff0c;了解单链表 二&#xff0c;定义节点类 三&#xff0c;链表的增删改查 四&#xff0c;链表的进阶操作 一&#xff0c;单链表 概念&#xff1a;是一种链式存取的数据结构&#xff0c;用一组地址任意的存储单元存放线性表中的数据元素。链…
阅读更多...
【剑指offer】 18. 删除链表的节点

【剑指offer】 18. 删除链表的节点

题目 题目传送门&#xff1a;传送门&#xff08;点击此处&#xff09; 题解 思路 链表的删除操作&#xff0c;其实就是指针的变化&#xff0c;比较easy的题目 因为要删除一个元素&#xff0c;要修改删除元素的上一个元素的next指针&#xff0c;所以先创建一个新的node节点…
阅读更多...
【LeetCode】 206. 反转链表 2020年3月2日

【LeetCode】 206. 反转链表 2020年3月2日

题目 题目传送门&#xff1a;传送门&#xff08;点击此处&#xff09; 题解 反转链表&#xff0c;我们其实就是想让上边的链表变成下边的链表&#xff0c;就是下图这样&#xff1a; 其实只要每次改变两个节点的指针的方向就可以了 temp new ListNode(head.val); temp.next…
阅读更多...
CCF-CSP 201604-3 路径解析 C++实现

CCF-CSP 201604-3 路径解析 C++实现

题目信息 试题编号&#xff1a; 201604-3 试题名称&#xff1a; 路径解析 时间限制&#xff1a; 1.0s 内存限制&#xff1a; 256.0MB 问题描述&#xff1a; 　　在操作系统中&#xff0c;数据通常以文件的形式存储在文件系统中。文件系统一般采用层次化的组织形式&#xff0c…
阅读更多...
Java源码系列4——HashMap扩容时究竟对链表和红黑树做了什么?

Java源码系列4——HashMap扩容时究竟对链表和红黑树做了什么?

我们知道 HashMap 的底层是由数组&#xff0c;链表&#xff0c;红黑树组成的&#xff0c;在 HashMap 做扩容操作时&#xff0c;除了把数组容量扩大为原来的两倍外&#xff0c;还会对所有元素重新计算 hash 值&#xff0c;因为长度扩大以后&#xff0c;hash值也随之改变。 如果…
阅读更多...
LeetCode-86.分隔链表

LeetCode-86.分隔链表

给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你应当 保留 两个分区中每个节点的初始相对位置。 示例 1&#xff1a; 输入&#xff1a;head [1,4,3,2,5,2], x 3 输出…
阅读更多...
LeetCode-82.删除排序链表中重复元素二

LeetCode-82.删除排序链表中重复元素二

存在一个按升序排列的链表&#xff0c;给你这个链表的头节点 head &#xff0c;请你删除链表中所有存在数字重复情况的节点&#xff0c;只保留原始链表中 没有重复出现 的数字。 返回同样按升序排列的结果链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,3,4,4,5] 输…
阅读更多...
数据结构-8.静态链表 顺序表

数据结构-8.静态链表 顺序表

1. 静态链表 分配一整片连续内存空间&#xff0c;各个结点集中安置。用数组实现。 //定义一个静态链表 #define MaxSize 10 struct Node{ElemType data;int next; }; void testSLinkList(){struct Node a[MaxSize];//… } 由于静态链表已经被淘汰了&#xff0c;现在基本很少用…
阅读更多...
链表相关面试题第三篇

链表相关面试题第三篇

系列文章目录 文章目录系列文章目录前言一、环形链表1.题目描述2.解题思路二、环形链表进阶1.题目描述2.解题思路三、复杂带随机指针的链表1.题目描述2.解题思路四、对链表进行插入排序1.题目描述2.解题思路五、删除链表中重复节点&#xff0c;重复节点不保留1.题目描述2.解题思…
阅读更多...
数据结构-7.循环链表

数据结构-7.循环链表

一.循环单链表&#xff1a; 定义循环单链表 和普通单链表一样&#xff1a; typedef struct LNode{ElemType data;struct LNode *next; }LNode,*LinkList;初始化循环单链表&#xff1a; bool InitList(LinkList &L){L(LNode*)malloc(sizeof(LNode)); //分配一个单链表…
阅读更多...
数据结构-5.单链表的建立

数据结构-5.单链表的建立

一.带头结点的单链表的建立-尾插法 初始化一个单链表。 再复习一下初始化一个单链表&#xff1a; //初始化一个带头结点的单链表 typeset struct LNode{ElemType data;struct LNode *next; }LNode,*LinkList; bool InitList(LinkList &L){L(LNode*)malloc(sizeof(LNode))…
阅读更多...
数据结构-4.单链表的查找

数据结构-4.单链表的查找

一.带头结点的按位查找 之前在研究单链表的插入时是寻找第i-1个结点&#xff0c;所以我们这里还按照之前的思路进行循环查找。 //按位查找&#xff0c;结果返回第i个元素。 LNode* GetElem(LinkList L,int i){ //因为返回的是一个结点的地址if(i<0)return NULL; …
阅读更多...
LeetCode系列之「反转链表」

LeetCode系列之「反转链表」

剑指 Offer 24. 反转链表 ListNode // Definition for singly-linked list. public class ListNode {int val;ListNode next;ListNode(int x) { val x; } }一、迭代解法&#xff1a; class Solution {public ListNode reverseList(ListNode head) {if(head null) return n…
阅读更多...
合并两个有序链表--剑指Offer

合并两个有序链表--剑指Offer

1.题目描述 输入两个单调递增的链表&#xff0c;输出两个链表合成后的链表&#xff0c;当然我们需要合成后的链表满足单调不减规则。 2.题目分析 假设两个有序链表分别为list1和list2&#xff0c;则当list1的头结点小于list2的头结点时&#xff0c;list1一定为新链表的头结点&…
阅读更多...
Redis学习笔记（1）

Redis学习笔记（1）

我是跟着尚硅谷周阳老师的课程学习的&#xff0c;之前项目用过mongodb&#xff0c;但对redis和整个nosql都不是很熟悉&#xff0c;系统的学习下。 Redis和MongoDB的区别&#xff1a; https://www.cnblogs.com/java-spring/p/9488227.html 1.Redis简介 Redis:REmote DIctionary …
阅读更多...
数据结构课程作业——链表

数据结构课程作业——链表

函数名字功能&#xff1a; //创建长度为n,表头为head的单链表 尾插法 void init_1(link &head, int n); //删除递增顺序链表大于等于mink 小于等于maxk的数 void erase_1(link &head, int mink, int maxk); //输出单链表 void print_1(link &L); //创建长度为n,表…
阅读更多...
C的数据结构---带头结点的单链表

C的数据结构---带头结点的单链表

补充知识&#xff1a; 结构体中嵌套结构体&#xff1a; 1.结构体中可以嵌套另一个结构体类型的数据 ⒉结构体中可以嵌套指向自身的指针和指向另一个结构体的指针 3.结构体中不能嵌套自己类型的数据&#xff08;无穷递归&#xff0c;确定不了数据类型的内存大小&#xff0c;…
阅读更多...
Non-interger Area 思维

Non-interger Area 思维

problem nowcoder 思路 把点按照奇偶分为4类，一个三角形的面积是整数当且仅当构成它的三个点中至少2个是同一类的，用总共的三角形减去这类即可。 一开始并没有发现这个性质。 // Decline is inevitable, // Romance will last forever. #include <bits/stdc++.h> us…
阅读更多...
Map扩容

Map扩容

扩容&#xff1a; HashMap负载因子0.75&#xff0c;默认容量16 初始容量不能<0&#xff0c;也不能>最大容量 HashMap的最大容量值为2^30 负载因子越大&#xff0c;空间利用越充分&#xff0c;但hash碰撞概率上升&#xff1b;同等数据下&#xff0c;put/get效率低&#xf…
阅读更多...
~~顺序表~~

~~顺序表~~

1.线性结构的特点是&#xff1a; 在数据元素的非空有限集中&#xff1a; (1).存在唯一的一个被称为“第一个”的数据元素 (2).存在唯一的一个被称为“最后一个”的数据元素 (3).除第一个之外&#xff0c;集合中的每个数据元素都只有一个前驱 (4).除第一个之外&#xff0c;…
阅读更多...
【每天学习亿点点系列】——重温单链表

【每天学习亿点点系列】——重温单链表

&#x1f4a5;【每天学习亿点点系列】——重温单链表头文件以及测试部分的代码单链表各个接口的实现1.尾插2.尾删3.打印4.头插5.头删6.查找7.在任意位置之前插入8.在任意位置之后插入9.删除当前位置10.删除任意位置的前一个节点11.删除任意位置的后一个节点12.销毁13.判空注意点…
阅读更多...
数据结构与算法之线性表（二）：链式表的实现和应用

数据结构与算法之线性表（二）：链式表的实现和应用

系列文章传送门&#xff1a; 数据结构与算法之树和二叉树&#xff08;一&#xff09;&#xff1a;二叉树基本操作的实现及应用 数据结构与算法之线性表&#xff08;二&#xff09;&#xff1a;链式表的实现和应用 数据结构与算法之线性表&#xff08;三&#xff09;&#xff1…
阅读更多...
数据结构：链表，栈和队列，串，数组和广义表，树和二叉树

数据结构：链表，栈和队列，串，数组和广义表，树和二叉树

第一章&#xff1a;简单描述 时间复杂度的关系&#xff1a;O(1) < O(log2n) < O(n) < O(n * log2n) < O(n^3) < O(2^n) < O(n!)复杂度越大&#xff0c;执行越慢。空间复杂度&#xff1a;定义一个数组作为中转量为O(n),定义一个普通变量t,为O(1)。数据的逻辑结…
阅读更多...
《数据结构与算法》- 线性结构复习题 7-4 两个有序链表序列的交集 (10 分)

《数据结构与算法》- 线性结构复习题 7-4 两个有序链表序列的交集 (10 分)

用java做的&#xff0c;最后一组数据过不了&#xff0c;不知道为什么 public static void main (String[] args) {Scanner scannernew Scanner (System.in);int tmp0;LinkedList <Integer> list1new LinkedList<> ();LinkedList<Integer> list2new LinkedLis…
阅读更多...
【题解】二叉搜索树与双向链表

【题解】二叉搜索树与双向链表

二叉搜索树与双向链表 题目链接&#xff1a;二叉搜索树与双向链表 解题思路1&#xff1a;递归中序遍历 首先题目最后要求的是一个的递增的双向链表&#xff0c;而二叉搜索树也是一类非常有特色的树&#xff0c;它的根节点大于所有左侧的节点&#xff0c;同时又小于所有右侧的…
阅读更多...
Java：集合LinkedSet底层原理、TreeSet底层原理；开发中如何选择集合使用

Java：集合LinkedSet底层原理、TreeSet底层原理；开发中如何选择集合使用

LinkedSet底层原理 TreeSet底层原理 如果你想对自定义类型的对象进行排序&#xff0c;有两种方式 但是执行出来&#xff0c;如果两个比较的数据相等&#xff0c;就会造成一个数据丢失 第二种
阅读更多...
初阶数据结构（三）链表

初阶数据结构（三）链表

&#x1f493;博主csdn个人主页&#xff1a;小小unicorn&#x1f493; ⏩专栏分类&#xff1a;c &#x1f69a;代码仓库&#xff1a;小小unicorn的学习足迹&#x1f69a; &#x1f339;&#x1f339;&#x1f339;关注我带你学习编程知识 前面我们讲的线性表的顺序存储结构。它…
阅读更多...
ARTS打卡第二周之链表环的检测、gdb中disassemble的使用、底层学习建议、学习分享

ARTS打卡第二周之链表环的检测、gdb中disassemble的使用、底层学习建议、学习分享

Algorithm 题目&#xff1a;链表中环的检测 自己的分析见博客《检测链表中是否存在环》 Review disassemble command是我读的一篇英语文章&#xff0c;这篇文章主要是介绍gdb反汇编命令的使用和参数。自己为了能够演示这篇文章里边的内容&#xff0c;特意自己使用汇编语言编…
阅读更多...
顺序表链表OJ题(3)——【数据结构】

顺序表链表OJ题(3)——【数据结构】

W...Y的主页 &#x1f60a; 代码仓库分享 &#x1f495; 前言&#xff1a; 今天是链表顺序表OJ练习题最后一次分享&#xff0c;每一次的分享题目的难度也再有所提高&#xff0c;但是我相信大家都是非常机智的&#xff0c;希望看到博主文章能学到东西的可以一键三连关注一下博主…
阅读更多...
移除链表元素_每日一题

移除链表元素_每日一题

“路虽远&#xff0c;行则将至” ❤️主页&#xff1a;小赛毛 ☕今日份刷题&#xff1a;移除链表元素 题目描述&#xff1a; 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例1&…
阅读更多...
相交链表：k神题解的一点小感慨

相交链表：k神题解的一点小感慨

题目&#xff1a; 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 朴素解法 用…
阅读更多...
算法系列-力扣19-删除链表倒数第n个节点

算法系列-力扣19-删除链表倒数第n个节点

删除链表倒数第n个节点 链表定义 // lc codestart /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* ListNode(int val, ListNode next) { this.va…
阅读更多...
【数据结构篇】线性表1 --- 顺序表、链表 （万字详解！！）

【数据结构篇】线性表1 --- 顺序表、链表 （万字详解！！）

前言&#xff1a;这篇博客我们重点讲 线性表中的顺序表、链表 线性表&#xff08;linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构&#xff0c;常见的线性表&#xff1a;顺序表、链表、栈、队列... 线性表在逻辑上是…
阅读更多...
合并两个有序链表（每日一题）

合并两个有序链表（每日一题）

“路虽远&#xff0c;行则将至” ❤️主页&#xff1a;小赛毛 ☕今日份刷题&#xff1a;合并两个有序链表 题目描述&#xff1a; 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例1&#xff1a; 输入&#xff1a;l1 …
阅读更多...
【LeetCode】83. 删除排序链表中的重复元素

【LeetCode】83. 删除排序链表中的重复元素

83. 删除排序链表中的重复元素&#xff08;简单&#xff09; 方法&#xff1a;一次遍历 思路 由于给定的链表是排好序的&#xff0c;因此重复的元素在链表中出现的位置是连续的&#xff0c;因此我们只需要对链表进行一次遍历&#xff0c;就可以删除重复的元素。 从指针 cur 指…
阅读更多...
【链表OJ 11】复制带随机指针的链表

【链表OJ 11】复制带随机指针的链表

前言: &#x1f4a5;&#x1f388;个人主页:​​​​​​Dream_Chaser&#xff5e; &#x1f388;&#x1f4a5; ✨✨刷题专栏:http://t.csdn.cn/UlvTc ⛳⛳本篇内容:力扣上链表OJ题目 目录 leetcode138. 复制带随机指针的链表 1. 问题描述 2.代码思路: 2.1拷贝节点插入到…
阅读更多...
树（一）树和二叉树的基本概念

树（一）树和二叉树的基本概念

文章目录 一、树1、什么是树2、树的相关概念3、树的表示 二、二叉树1、二叉树的概念2、二叉树的几种情况3、特殊二叉树4、二叉树的性质5、二叉树的存储结构 一、树 1、什么是树 树是一种非线性的数据结构&#xff0c;它是由n&#xff08;n>0&#xff09;个有限结点组成一个…
阅读更多...
每日一题（两数相加）

每日一题（两数相加）

每日一题&#xff08;两数相加&#xff09; 2. 两数相加 - 力扣&#xff08;LeetCode&#xff09; 思路 思路&#xff1a; 由于链表从头开始向后存储的是低权值位的数据&#xff0c;所以只需要两个指针p1和p2&#xff0c;分别从链表的头节点开始遍历。同时创建一个新的指针new…
阅读更多...
王道数据结构编程题 链表

王道数据结构编程题 链表

链表定义 以下为本文解题代码的链表定义。 struct ListNode {int val;ListNode* next;ListNode(int val 0, ListNode* next nullptr) : val(val), next(next) {} };递归删除结点 题目描述 设计一个递归算法&#xff0c;删除不带头结点的单链表 L 中的所有值为 x 的结点&a…
阅读更多...
【剑指Offer】18.删除链表的节点

【剑指Offer】18.删除链表的节点

题目 给定单向链表的头指针和一个要删除的节点的值&#xff0c;定义一个函数删除该节点。 返回删除后的链表的头节点。 注意&#xff1a;此题对比原题有改动 示例 1: 输入: head [4,5,1,9], val 5 输出: [4,1,9] 解释: 给定你链表中值为 5 的第二个节点&#xff0c;那么…
阅读更多...
【面试必刷TOP101】反转链表 链表内指定区间反转

【面试必刷TOP101】反转链表 链表内指定区间反转

目录 题目&#xff1a;反转链表_牛客题霸_牛客网 (nowcoder.com) 题目的接口&#xff1a; 解题思路&#xff1a; 代码&#xff1a; 过啦&#xff01;&#xff01;&#xff01; 题目&#xff1a;链表内指定区间反转_牛客题霸_牛客网 (nowcoder.com) 题目的接口&#xff1…
阅读更多...
【算法】Java-使用数组模拟单向链表，双向链表

【算法】Java-使用数组模拟单向链表，双向链表

目录 试题1&#xff1a;实现一个单链表&#xff0c;并实现以下功能&#xff1a; 试题2&#xff1a;实现一个双链表&#xff0c;并实现以下功能 思路总结&#xff1a; 什么情况下可能涉及到用数组实现链表呢&#xff1f; 在学习时了解到了可以用数组模拟链表&#xff0c;使其…
阅读更多...
链表的基本操作(acm模式，中等）

链表的基本操作(acm模式，中等）

此题自己亲自动手实现难度确实不容易&#xff0c;为了更好的掌握 链表这一结构&#xff0c;还是得自己敲&#xff0c;自己debug,还得多次看&#xff0c;才能脑子清楚&#xff0c;手也熟。 // 本题的删除索引是从1开始&#xff0c;函数实现是从0开始&#xff0c;先说明这一点&a…
阅读更多...
再学C的数据结构---静态链表

再学C的数据结构---静态链表

StaticList.h #include <stdio.h> #include <stdlib.h> #include <assert.h>#define MAX_SIZE 20 typedef char Elemtype ;typedef struct ListNode {Elemtype data;int cur; //游标 }ListNode;typedef ListNode StaticList[MAX_SIZE]; void InitSList(Sta…
阅读更多...
48 # 单向链表

48 # 单向链表

上一节讲了可读流&#xff0c;在讲可写流之前得了解一下链表。 比如&#xff1a;并发往文件中写入数据 write("1"); write("2"); write("3");每次写都会开个线程&#xff0c;上面的写入可能出现 123&#xff0c;321&#xff0c;213… node 中…
阅读更多...
【C++】STL各容器对比

【C++】STL各容器对比

文章目录适用情况1优缺点适用情况2全—STL容器的适用情况和缺点https://blog.csdn.net/ArrowYL/article/details/79684113STL中vector list deque map 的优缺点以及区别适用情况1 Level 1 - 仅仅作为Map使用&#xff1a;采用静态数组 Level 2 - 保存定长数据&#xff0c;使用时…
阅读更多...
leetcode-Merge Two Sorted Lists

leetcode-Merge Two Sorted Lists

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists. 要把两个有序链表合成一个新的有序链表。 /*** Definition for singly-linked list.* struct ListNode {* int val;* …
阅读更多...
LeetCode C++7-两数相加

LeetCode C++7-两数相加

题目描述 给你两个非空的链表&#xff0c;表示两个非负的整数。它们每位数都是按照逆序的方式存储的&#xff0c;并且每个节点只能存储一位数字。请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。你可以假设除数字0之外&#xff0c;这两个数都不会以0开头。 举…
阅读更多...
【LeetCode21】合并两个有序链表（不带头结点）

【LeetCode21】合并两个有序链表（不带头结点）

题目描述 代码 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(int x) : val(x), next(nullptr) {}* ListNode(int x, ListNode *next) : val(x), next(next…
阅读更多...
如何才能拾起脚边的砖块？ Offer 22. 链表中倒数第k个节点

如何才能拾起脚边的砖块？ Offer 22. 链表中倒数第k个节点

剑指 Offer 22. 链表中倒数第k个节点题目如下解题思路vector存下链表&#xff0c;然后用小标输出快慢指针题目如下 解题思路 vector存下链表&#xff0c;然后用小标输出 /* Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* …
阅读更多...
Java合并有序链表--空间复杂度低

Java合并有序链表--空间复杂度低

一般说来&#xff0c;合并有序链表都会定义一个新的链表存放处理后的结果&#xff0c;笔者在想能不能利用原有两个链表的存储空间&#xff0c;不占用额外的存储空间&#xff0c;只在两个链表之间进行连接操作。以下为代码实现。 但是这样会破坏原有链表的值。 /*** author haoj…
阅读更多...
找到链表的第一个入环节点

找到链表的第一个入环节点

1.题目 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统…
阅读更多...
Java面试题：链表-反转链表

Java面试题：链表-反转链表

问题描述 给定一个单链表的头结点pHead(该头节点是有值的&#xff0c;比如在下图&#xff0c;它的val是1)&#xff0c;长度为n&#xff0c;反转该链表后&#xff0c;返回新链表的表头。 如当输入链表{1,2,3}时&#xff0c;经反转后&#xff0c;原链表变为{3,2,1}&#xff0c;…
阅读更多...
解剖—单链表相关OJ练习题

解剖—单链表相关OJ练习题

目录 一、移除链表元素 二、找出链表的中间节点 三、合并两个有序链表 四、反转链表 五、求链表中倒数第k个结点 六、链表分割 七、链表的回文结构 八、判断链表是否相交 九、判断链表中是否有环(一) 十、 判断链表中是否有环(二) 注&#xff1a;第六题和第七题牛…
阅读更多...
带头的循环双向链表的简单介绍

带头的循环双向链表的简单介绍

目录 带头的循环双向链表&#xff1a; 1、带头&#xff1a; 2、循环&#xff1a; 3、双向&#xff1a; 图例&#xff1a; 带头的双向循环链表的创建&#xff1a; 头文件部分&#xff1a; 主函数部分&#xff1a; 最终调试效果&#xff1a; 使用一级指针传参的原因&am…
阅读更多...
算法通关村第一关|黄金挑战|链表中的环问题双向链表

算法通关村第一关|黄金挑战|链表中的环问题双向链表

1.链表中环的问题 1.1 判断是否有环&#xff1a;使用集合处理&#xff0c;判断是否碰撞。 public ListNode detectCycle(ListNode head) {ListNode pos head;Set<ListNode> visited new HashSet<ListNode>();while (pos ! null) {if (visited.contains(pos)) {…
阅读更多...
数据结构与算法-树

数据结构与算法-树

树 &#x1f388;1.树和二叉树&#x1f388;2.树&#x1f52d;2.1树的定义&#x1f52d;2.2树的4种表示方法&#x1f52d;2.3树的基本术语&#x1f52d;2.4树的抽象数据类型定义 &#x1f388;3.二叉树&#x1f52d;3.1二叉树的定义&#x1f52d;3.2二叉树的抽象数据类型定义&a…
阅读更多...
【数据结构】模拟实现无头单向非循环链表

【数据结构】模拟实现无头单向非循环链表

链表的概念 学过ArrayList后我们知道它的底层是用数组来存储元素的&#xff0c;是连续的存储空间&#xff0c;当我们要从ArrayList任意位置删除或插入元素时&#xff0c;我们要把后续整体向前或后移动&#xff0c;时间复杂度为O(n)&#xff0c;效率比较低&#xff0c;因此Arra…
阅读更多...
初始C++入门（2）

初始C++入门（2）

缺省参数 缺省参数是 声明或定义函数时 为函数的 参数指定一个缺省值 。在调用该函数时&#xff0c;如果没有指定实 参则采用该形参的缺省值&#xff0c;否则使用指定的实参。 有句俗话叫&#xff0c;做人不能像缺省函数。 #include<iostream> using namespace std;void…
阅读更多...
c语言练习95：练习使用双向链表（实现增删改查）

c语言练习95：练习使用双向链表（实现增删改查）

练习使用双向链表&#xff08;实现增删改查&#xff09; 是指针指向了一块被释放的空间 解决方案&#xff1a; plistNULL List.h #pragma once #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> #include<assert.h> #include<…
阅读更多...
2023-10-19 指针与指针的指针，我就不信你脑壳不疼

2023-10-19 指针与指针的指针，我就不信你脑壳不疼

点击 <C 语言编程核心突破> 快速C语言入门 指针与指针的指针&#xff0c;我就不信你脑壳不疼 前言一、从一个链表实现说起二、指针, 指针的指针, 头疼的来源总结 前言 C实现一个链表&#xff0c;为什么有时候传入指针&#xff0c;有时候传入指针的指针&#xff0c;究竟…
阅读更多...
链表收尾（8.2）

链表收尾（8.2）

例题解析 138. 随机链表的复制 - 力扣&#xff08;LeetCode&#xff09; 1.拷贝节点插入原节点的后面&#xff08;核心&#xff09; 这样做的目的是方便找 random 节点&#xff0c;知道原节点可以找 random&#xff0c;知道上一个 random 可以找下一个 random 。 struct Node…
阅读更多...
【LeetCode75】第二十九题 删除链表的中间节点

【LeetCode75】第二十九题 删除链表的中间节点

目录 题目&#xff1a; 示例; 分析: 代码: 题目&#xff1a; 示例; 分析: 给我们一个链表&#xff0c;让我们把链表中间的节点删了。 那么最直观最基础的办法是遍历两边链表&#xff0c;第一遍拿到链表长度&#xff0c;第二次把链表中间节点删了。 这个暴力做法我没事过…
阅读更多...
代码随想录 （二）链表

代码随想录 （二）链表

链表 二 移除链表元素 1 没有头结点 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(int x) : val(x), next(nullptr) {}* ListNode(int x, ListNode *next)…
阅读更多...
环形链表笔记（自用）

环形链表笔记（自用）

环形链表 不管怎么样slow最多走半圈了&#xff0c; 快慢指针slow走一步&#xff0c;fast走两步最合适&#xff0c;因为假设fast和slow相差n每一次他们前进&#xff0c;就会相差n-1步&#xff0c;这样他们一定会相遇&#xff0c;如果是环形链表的话。 代码 /*** Definition for…
阅读更多...
【寻找链表的中间结点】python实现-附ChatGPT解析

【寻找链表的中间结点】python实现-附ChatGPT解析

1.题目 寻找链表的中间结点 知识点：链表数组 时间限制:1s空间限制:256MB 限定语言:不限 题目描述: 给定一个单链表L，请编写程序输出 L 中间结点保存的数据。 如果有两个中间结点，则输出第二个中间结点保存的数据。 例如：给定L为1-7-5，则输出应该为 7; 给定L为1-2-3-4，则输…
阅读更多...
数据结构与算法(C语言版)P6---队列

数据结构与算法(C语言版)P6---队列

1、队列的概念及结构 队列&#xff1a;只允许在一端进行插入数据操作&#xff0c;在另一端进行删除操作的特殊线性表&#xff0c;队列具有__先进先出__FIFO&#xff08;First In First Out&#xff09; 入队列&#xff1a;进行插入操作的一端称为__队尾__。 出队列&#xff1a;…
阅读更多...
算法-堆、队列、分治法-合并 K 个升序链表

算法-堆、队列、分治法-合并 K 个升序链表

算法-堆、队列、分治法-合并 K 个升序链表 1 题目概述 1.1 题目出处 https://leetcode.cn/problems/merge-k-sorted-lists 1.2 题目描述 2 题解 2.1 队列 2.1.1 解题思路 将各个有序子链表放入队列&#xff0c;两两合并&#xff0c;最后队列中剩的最后的子链表就是合并后…
阅读更多...
leetcodeTop100(21) 相交链表

leetcodeTop100(21) 相交链表

给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c;函数返回结果后&#xff0c;链表必须 保持其原始结构 。 双链表…
阅读更多...
【数据结构】链表的学习和介绍

【数据结构】链表的学习和介绍

前言 今天&#xff0c;我们来学习&#xff0c;数据结构中的链表 链表是什么 链表&#xff0c;就是多个结构体变量之间&#xff0c;通过结构体指针连接在一起的一种数据结构 提示&#xff1a; 本篇文章主要讲解动态链表&#xff0c;对于静态链表不做过多介绍 链表的分类 链…
阅读更多...
【LeetCode热题100】--160.相交链表

【LeetCode热题100】--160.相交链表

160.相交链表 使用双指针&#xff1a; /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode(int x) {* val x;* next null;* }* }*/ public class Solution {public ListNode getInter…
阅读更多...
数据结构-----二叉排序树

数据结构-----二叉排序树

目录 前言 1.什么是二叉排序树 2.如何构建二叉排序树 3.二叉排序树的操作 3.1定义节点储存方式 3.2插入节点操作 3.2创建二叉排序树 3.4遍历输出&#xff08;中序遍历&#xff09; 3.5数据查找操作 3.6获取最大值和最小值 3.7删除节点操作 3.8销毁二叉排序树 4.完…
阅读更多...
复习Day11：链表part04: 206. 反转链表、92. 反转链表II、25. K 个一组翻转链表、148. 排序链表

复习Day11：链表part04: 206. 反转链表、92. 反转链表II、25. K 个一组翻转链表、148. 排序链表

我用的方法是在leetcode再过一遍例题&#xff0c;明显会的就复制粘贴&#xff0c;之前没写出来就重写&#xff0c;然后从拓展题目中找题目来写。辅以Labuladong的文章看。然后刷题不用CLion了&#xff0c;使用leetcode自带的IDE模拟面试环境。 哈希表章节的题目思路很清晰&…
阅读更多...
6-10 单链表分段逆转 分数 15

6-10 单链表分段逆转 分数 15

void K_Reverse( List L, int K ) { //此题已经默认size > K 因为当size < K时 反转后将不再符合链表的定义//求出表中元素个数int size 0;for (List cur L->Next; cur ! NULL; cur cur->Next)size; List prv, cur, next, first, head L;//共需要反转 si…
阅读更多...
上机实验二 设计单循环链表 西安石油大学数据结构

上机实验二 设计单循环链表 西安石油大学数据结构

实验名称:设计单循环链表 (1&#xff09;实验目的:掌握线性表的链式存储结构;掌握单循环链表及其基本操作的实现。 (2&#xff09;主要内容:实现单循环链表的初始化、求数据元素个数、插入、删除、取数据元素等操作;用插入法建立带头结点的单循环链表;设计一个测试主函数验证…
阅读更多...
数据结构：链表（2），链表面试题

数据结构：链表（2），链表面试题

203. 移除链表元素 - 力扣&#xff08;LeetCode&#xff09; 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出…
阅读更多...
静态链表C/C++

静态链表C/C++

什么是静态链表 与常见的数据结构的链表不同,想想常见的链表,每次新增数据都要重新开辟内存,这对有时间限制的算法程序来说每次插入新的数据就malloc是绝对会TLE的(除非从一开始就新开辟连续的堆空间当然这种情况下就不是动态链表了). 所谓静态链表,指的是: 静态链表是一种使用…
阅读更多...
【链表】反转链表

【链表】反转链表

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kuan 的首页,持续学…
阅读更多...
链表实现稀疏多项式相加（C++）

链表实现稀疏多项式相加（C++）

#include<iostream> using namespace std; typedef struct node {float coef;//系数int expn;//指数struct node* next; }list,*linklist; void Createlist(linklist& l) {l new list;l->next NULL;linklist p,q;q l;cout << "输入多项式项数&#…
阅读更多...
链表的分割——哨兵位

链表的分割——哨兵位

现有一链表的头指针 ListNode* pHead&#xff0c;给一定值x&#xff0c;编写一段代码将所有小于x的结点排在其余结点之前&#xff0c;且不能改变原来的数据顺序&#xff0c;返回重新排列后的链表的头指针。 思路&#xff0c;把链表分成两个新链表&#xff0c;然后连接起来 代码…
阅读更多...
leetcode做题笔记143. 重排链表

leetcode做题笔记143. 重排链表

给定一个单链表 L 的头节点 head &#xff0c;单链表 L 表示为&#xff1a; L0 → L1 → … → Ln - 1 → Ln请将其重新排列后变为&#xff1a; L0 → Ln → L1 → Ln - 1 → L2 → Ln - 2 → … 不能只是单纯的改变节点内部的值&#xff0c;而是需要实际的进行节点交换。 …
阅读更多...
链表oj3（Leetcode）——相交链表；环形链表

链表oj3（Leetcode）——相交链表；环形链表

一&#xff0c;相交链表 相交链表&#xff08;Leetcode&#xff09; 1.1分析 看到这个我们首先想到的就是一个一个比较他们的值有相等的就是交点&#xff0c;但是如果a1和b2的值就相等呢&#xff1f;所以这个思路不行&#xff0c;第二种就是依次比较链表&#xff0c;但是这…
阅读更多...
算法通关村-----K个一组反转链表

算法通关村-----K个一组反转链表

K 个一组翻转链表 问题描述 给你链表的头节点 head &#xff0c;每 k 个节点一组进行翻转&#xff0c;请你返回修改后的链表。k 是一个正整数&#xff0c;它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍&#xff0c;那么请将最后剩余的节点保持原有顺序。你不能只…
阅读更多...
数据结构与算法（六）--链表的遍历，查询和修改，删除操作

数据结构与算法（六）--链表的遍历，查询和修改，删除操作

一、前言 上篇文章我们了解了链表的概念以及链表底层的搭建以及向链表中添加元素的操作。本次我们继续学习链表剩余的操作&#xff1a;遍历&#xff0c;查询和修改、删除操作。 二、链表查询以及遍历 ①获得链表的第index(0-based)个位置的元素&#xff08;不常用&#xff0…
阅读更多...
代码随想录Day03 | 链表基础1 LeetCode T203 移除链表元素 T707设计链表 T206 反转链表

代码随想录Day03 | 链表基础1 LeetCode T203 移除链表元素 T707设计链表 T206 反转链表

本题思路和解答主要来源于: 代码随想录 (programmercarl.com) LeetCode T203 移除链表元素 题目链接:203. 移除链表元素 - 力扣&#xff08;LeetCode&#xff09; 首先我们回顾一下单向链表,每个链表有一个指针域和一个数据域,在内存中是呈现不连续排列的,对比之前的数组,链…
阅读更多...
算法通关6-链表-1 实现单链表

算法通关6-链表-1 实现单链表

文章目录1 顺序的单链表2 逆序的单链表Github: https://github.com/345166018/Algorithm/blob/master/HxAlgo/src/linkedlist/SinglyLinkedList.java 1 顺序的单链表 定义结点 /*** 定义结点**/public static class Node {int val;Node next;public Node(int val, Node next)…
阅读更多...
链表的回文判断

链表的回文判断

思路: 找中间节点–>逆置->比较 代码&#xff1a; /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/struct ListNode* middleNode(struct ListNode* head) { struct ListNode*slowhead; struct ListNode*f…
阅读更多...
7-4 链表去重 (25 分)

7-4 链表去重 (25 分)

7-4 链表去重题目详情一、存储方式&#xff1a;二、去重&#xff1a;1.准备工作2.特判3.输出完整代码题目详情 给定一个带整数键值的链表 L&#xff0c;你需要把其中绝对值重复的键值结点删掉。即对每个键值 K&#xff0c;只有第一个绝对值等于 K 的结点被保留。同时&#xff…
阅读更多...
【Leetcode】148.排序链表

【Leetcode】148.排序链表

一、题目 1、题目描述 给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。 示例1： 输入：head = [4,2,1,3] 输出：[1,2,3,4]示例2： 输入：head = [-1,5,3,4,0] 输出：[-1,0,3,4,5]示例3： 输入：head = [] 输出：[]提示： 链表中节点的数目在范围 [0, 5 …
阅读更多...
leetcode-92：反转链表 II

leetcode-92：反转链表 II

92. 反转链表 II 给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], left 2, right 4 输出&a…
阅读更多...
【C++】LeetCode 160 相交链表

【C++】LeetCode 160 相交链表

今天再写一道算法题&#xff08;这两周都写算法题有点摆烂&#xff09; 题目 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1…
阅读更多...
文件存储空间管理（空闲表法，空闲链表法，位示图法，成组链表法）

文件存储空间管理（空闲表法，空闲链表法，位示图法，成组链表法）

1.存储空间的划分与初始化 1.文件卷&#xff08;逻辑卷)的概念 存储空间的划分:将物理磁盘划分为一个个文件卷&#xff08;逻辑卷、逻辑盘). 2.目录区与文件区 存储空间的初始化&#xff1a;将各个文件卷划分为目录区、文件区。 目录区包含文件目录、空闲表、位示图、超级…
阅读更多...
【Java集合类面试十】、HashMap中的循环链表是如何产生的？

【Java集合类面试十】、HashMap中的循环链表是如何产生的？

文章底部有个人公众号&#xff1a;热爱技术的小郑。主要分享开发知识、学习资料、毕业设计指导等。有兴趣的可以关注一下。为何分享&#xff1f; 踩过的坑没必要让别人在再踩&#xff0c;自己复盘也能加深记忆。利己利人、所谓双赢。 面试官&#xff1a;HashMap中的循环链表是如…
阅读更多...
华为OD 非严格递增连续数字序列（100分）【java】B卷

华为OD 非严格递增连续数字序列（100分）【java】B卷

华为OD统一考试A卷+B卷 新题库说明 你收到的链接上面会标注A卷还是B卷。目前大部分收到的都是B卷。 B卷对应20022部分考题以及新出的题目，A卷对应的是新出的题目。 我将持续更新最新题目 获取更多免费题目可前往夸克网盘下载，请点击以下链接进入： 我用夸克网盘分享了「华为O…
阅读更多...
力扣每日一题61：旋转链表

力扣每日一题61：旋转链表

题目描述&#xff1a; 给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], k 2 输出&#xff1a;[4,5,1,2,3]示例 2&#xff1a; 输入&#xff1a;head [0,1,2], k 4 输…
阅读更多...
【力扣刷题】删除链表的倒数第 N 个结点、两两交换链表中的节点、随机链表的复制

【力扣刷题】删除链表的倒数第 N 个结点、两两交换链表中的节点、随机链表的复制

&#x1f40c;个人主页&#xff1a; &#x1f40c; 叶落闲庭 &#x1f4a8;我的专栏&#xff1a;&#x1f4a8; c语言 数据结构 javaEE 操作系统 Redis 石可破也&#xff0c;而不可夺坚&#xff1b;丹可磨也&#xff0c;而不可夺赤。 刷题篇 一、删除链表的倒数第 N 个结点1.1 …
阅读更多...
相交链表-力扣

相交链表-力扣

一、题目描述 题目链接&#xff1a;力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 二、题解 注意题目所说的相交&#xff0c;相交节点不只是数值上的相等&#xff0c;而是相交以后两条链变成一条链。 解决改题目&#xff0c;我们可以&#xff1a;…
阅读更多...
【算法系列篇】与链表相关的算法

【算法系列篇】与链表相关的算法

文章目录 前言1. 两数相加1.1 题目要求1.2 做题思路1.3 Java代码实现 2. 两两交换链表中的节点2.1 题目要求2.2 做题思路2.3 Java代码实现 3. 重排链表3.1 题目要求3.2 做题思路3.3 Java代码实现 4. 合并 k 个升序链表4.1 题目要求4.2.1 做题思路一4.3.1 方法一Java代码实现4.2…
阅读更多...
BM2 链表内指定区间反转

BM2 链表内指定区间反转

思路&#xff1a;借助list先进后出特性&#xff0c;把m和n之间的数值直接入栈&#xff0c;通过出栈再修改原本链表纸 /*** struct ListNode {* int val;* struct ListNode *next;* ListNode(int x) : val(x), next(nullptr) {}* };*/ class Solution { public:/*** 代码中的类…
阅读更多...
【数据结构】链表的十三种操作

【数据结构】链表的十三种操作

菜单 //0、显示菜单 void menu() {cout << "菜单&#xff1a;" << endl;cout << "1.初始化或重置链表" << endl;cout << "2.销毁链表" << endl;cout << "3.清空链表" << endl;cout…
阅读更多...
环形链表[简单]

环形链表[简单]

优质博文&#xff1a;IT-BLOG-CN 一、题目 给你一个链表的头节点head&#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪next指针再次到达&#xff0c;则链表中存在环。为了表示给定链表中的环&#xff0c;评测系统内部使用整数pos来表示链…
阅读更多...
《算法通关村—如何基于数组（或者链表）实现栈》

《算法通关村—如何基于数组（或者链表）实现栈》

《算法通关村—如何基于数组&#xff08;或者链表&#xff09;实现栈》 理解什么是栈 栈和队列是比较特殊的线性表&#xff0c;又称之为访问受限的线性表。栈是很多表达式、符号等运算的基础&#xff0c;也是递归的底层实现。理论上递归能做的题目栈都可以&#xff0c;只是有…
阅读更多...
『力扣刷题本』：合并两个有序链表（递归解法）

『力扣刷题本』：合并两个有序链表（递归解法）

一、题目 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4]示例 2&#xff1a; 输入&#xff1a;l1 [], l2 [] 输出&#x…
阅读更多...
D (1092) : DS循环链表—约瑟夫环(Ver. I - A)

D (1092) : DS循环链表—约瑟夫环(Ver. I - A)

Description N个人坐成一个圆环&#xff08;编号为1 - N&#xff09;&#xff0c;从第S个人开始报数&#xff0c;数到K的人出列&#xff0c;后面的人重新从1开始报数。依次输出出列人的编号。 例如&#xff1a;N 3&#xff0c;K 2&#xff0c;S 1。 2号先出列&#xff0c;然…
阅读更多...
链表去重Java

链表去重Java

去除掉链表中重复的元素,两种方法: static class ListNode{private int val;private ListNode next;public ListNode(int val, ListNode next) {this.val val;this.next next;}Overridepublic String toString() {return "ListNode{" "val" val ",…
阅读更多...
代码随想录算法训练营第3天| 203.移除链表元素 、 707.设计链表 、 206.反转链表

代码随想录算法训练营第3天| 203.移除链表元素 、 707.设计链表 、 206.反转链表

JAVA代码编写 203. 移除链表元素 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5]示…
阅读更多...
王道p149 7.二叉树按二叉链表形式存储，写一个判别给定二叉树是否是完全二叉树的算法（c语言代码实现）

王道p149 7.二叉树按二叉链表形式存储，写一个判别给定二叉树是否是完全二叉树的算法（c语言代码实现）

采用层次遍历算法&#xff0c;将所有结点加入队列(包括空结点)。 如果没有左孩子&#xff0c;就看有没有右孩子&#xff0c;如果有右孩子&#xff0c;那么不为完全二叉树。 如果有左孩子&#xff0c;且之前不存在缺孩子的结点&#xff0c;左孩子进队&#xff0c;如果有右孩子…
阅读更多...
【数据结构初阶】顺序表和链表（1）

【数据结构初阶】顺序表和链表（1）

顺序表和链表&#xff08;1&#xff09; 1.线性表2.顺序表2.1概念以及结构2.1.1静态顺序表2.1.2动态顺序表3.顺序表的实现3.1初始化内容3.2初始化函数3.3销毁函数3.4打印函数3.5扩容函数3.6尾插3.6尾删函数3.7头插函数3.8头删函数3.9查找函数3.10插入函数3.11删除函数3.12修改函…
阅读更多...
面试算法24：反转链表

面试算法24：反转链表

题目 定义一个函数&#xff0c;输入一个链表的头节点&#xff0c;反转该链表并输出反转后链表的头节点。例如&#xff0c;把图4.8&#xff08;a&#xff09;中的链表反转之后得到的链表如图4.8&#xff08;b&#xff09;所示。 分析 由于节点j的next指针指向了它的前一个节…
阅读更多...
【牛客网刷题（数据结构）】：环形链表的约瑟夫问题

【牛客网刷题（数据结构）】：环形链表的约瑟夫问题

描述 编号为 1 到 n 的 n 个人围成一圈。从编号为 1 的人开始报数&#xff0c;报到 m 的人离开。 下一个人继续从 1 开始报数。 n-1 轮结束以后&#xff0c;只剩下一个人&#xff0c;问最后留下的这个人编号是多少&#xff1f; O(n) 示例1 好环形链表的约瑟夫问题是一个经典的问…
阅读更多...
链表-真正的动态数据结构

链表-真正的动态数据结构

创建节点 public class Node {T val;Node next;public Node(T val, Node next) {this.val val;this.next next;}public Node() {this(null, null);}public Node(T val) {this(val, null);}} 创建一个空链表 //创建链表public Node header;private int size;public MyLinkedLi…
阅读更多...
leetcode148 排序链表

leetcode148 排序链表

题目 给你链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 示例 输入&#xff1a;head [4,2,1,3] 输出&#xff1a;[1,2,3,4] 解析 在实际应用中&#xff0c;大概率会先转成数组排序后&#xff0c;再转成链表。对于本题而言&#xff0c;需要递归找…
阅读更多...
利用哈希表封装unordered_map和unordered_set

利用哈希表封装unordered_map和unordered_set

目录 一、迭代器1.1 普通迭代器1.1.1 operator 1.2 const迭代器1.3 代码实现 二、封装unordered_set三、封装unordered_map 一、迭代器 1.1 普通迭代器 1.1.1 operator 对于哈希桶结构&#xff0c;它的迭代器应该如何设计呢&#xff1f;我们仅封装一个Node的指针就行了吗&am…
阅读更多...
07 _ 链表（下）：如何轻松写出正确的链表代码？

07 _ 链表（下）：如何轻松写出正确的链表代码？

基础知识我都掌握了，但是写链表代码还是很费劲。哈哈，的确是这样的！ 想要写好链表代码并不是容易的事儿，尤其是那些复杂的链表操作，比如链表反转、有序链表合并等，写的时候非常容易出错。从我上百场面试的经验来看，能把“链表反转”这几行代码写对的人不足10%。 为什么…
阅读更多...
『力扣刷题本』：删除排序链表中的重复元素

『力扣刷题本』：删除排序链表中的重复元素

一、题目 给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,1,2] 输出&#xff1a;[1,2]示例 2&#xff1a; 输入&#xff1a;head [1,1,2,3,3] 输出&am…
阅读更多...
数组与链表算法-单向链表算法

数组与链表算法-单向链表算法

目录 数组与链表算法-单向链表算法 C代码 单向链表插入节点的算法 C代码 单向链表删除节点的算法 C代码 对单向链表进行反转的算法 C代码 单向链表串接的算法 C代码 数组与链表算法-单向链表算法 在C中&#xff0c;若以动态分配产生链表节点的方式&#xff0c;则可以…
阅读更多...
【LeetCode刷题（数据结构）】：给定一个链表 每个节点包含一个额外增加的随机指针 该指针可以指向链表中的任何节点或空节点 要求返回这个链表的深度拷贝

【LeetCode刷题（数据结构）】：给定一个链表 每个节点包含一个额外增加的随机指针 该指针可以指向链表中的任何节点或空节点 要求返回这个链表的深度拷贝

给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节点的值。新节点的 next…
阅读更多...
【LeetCode刷题（数据结构）】：给定一个链表 返回链表开始入环的第一个节点 如果链表无环 则返回 NULL

【LeetCode刷题（数据结构）】：给定一个链表 返回链表开始入环的第一个节点 如果链表无环 则返回 NULL

给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos…
阅读更多...
面试算法26：重排链表

面试算法26：重排链表

问题 给定一个链表&#xff0c;链表中节点的顺序是L0→L1→L2→…→Ln-1→Ln&#xff0c;请问如何重排链表使节点的顺序变成L0→Ln→L1→Ln-1→L2→Ln-2→…&#xff1f; 分析 首先把链表分成前后两半。在示例链表中&#xff0c;前半段链表包含1、2、3这3个节点&#xff0c…
阅读更多...
单链表经典OJ题：找出链表的中间节点

单链表经典OJ题：找出链表的中间节点

题目&#xff1a; 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。如果有两个中间结点&#xff0c;则返回第二个中间结点。 图例&#xff1a; 解法&#xff1a; 解法1: 先遍历链表确定链表节点的数量&#xff0c;然后再找到中间位置的节点 解法2: 快慢…
阅读更多...
算法通关村第二关|青铜|链表反转

算法通关村第二关|青铜|链表反转

1.建立虚拟头结点辅助反转 1.1 反转链表&#xff1a;使用虚拟头结点辅助反转。 public ListNode reverseList(ListNode head) {ListNode ans new ListNode(0);ListNode cur head;while (cur ! null) {ListNode next cur.next;cur.next ans.next;ans.next cur;cur next;…
阅读更多...
c语言练习93：环形链表的约瑟夫问题

c语言练习93：环形链表的约瑟夫问题

环形链表的约瑟夫问题 环形链表的约瑟夫问题_牛客题霸_牛客网 描述 编号为 1 到 n 的 n 个人围成一圈。从编号为 1 的人开始报数&#xff0c;报到 m 的人离开。 下一个人继续从 1 开始报数。 n-1 轮结束以后&#xff0c;只剩下一个人&#xff0c;问最后留下的这个人编号是…
阅读更多...
【Top101】002链表内指定区间反转

【Top101】002链表内指定区间反转

链表内指定区间反转_牛客题霸_牛客网 import java.util.*;/** public class ListNode {* int val;* ListNode next null;* public ListNode(int val) {* this.val val;* }* }*/public class Solution {/*** 代码中的类名、方法名、参数名已经指定&#xff0c;请勿…
阅读更多...
计算机考研自命题(3)

计算机考研自命题(3)

1、C语言–统计数字个数 1、编写程序&#xff0c;输入正整数n(1~10000),再输入n个正整数&#xff0c;找出这n个数中出现次数最多的数字&#xff0c;统计并输出其出现的次数 例如 1234 &#xff0c;2345&#xff0c; 3456 中出现次数最多的数字是 3和 4 &#xff0c;出现次数均为…
阅读更多...
计算机考研自命题(4)

计算机考研自命题(4)

1、C语言-通项求和 1、编写程序:求aaaaaaaaaaaaaaa…aaa的和&#xff0c;需要写一个函数fn(a,n)实现n个a的拼接&#xff0c;例如fn(3,2)返回的结果就是36。 # include<stdio.h>/* 解题思路&#xff1a;fun(a,n) a表示构成通项的数字 n表示有几个通项 先让一个 temp a,…
阅读更多...
【力扣刷题】只出现一次的数字、多数元素、环形链表 II、两数相加

【力扣刷题】只出现一次的数字、多数元素、环形链表 II、两数相加

&#x1f40c;个人主页&#xff1a; &#x1f40c; 叶落闲庭 &#x1f4a8;我的专栏&#xff1a;&#x1f4a8; c语言 数据结构 javaEE 操作系统 Redis 石可破也&#xff0c;而不可夺坚&#xff1b;丹可磨也&#xff0c;而不可夺赤。 刷题篇 一、只出现一次的数字1.1 题目描述1…
阅读更多...
合并两个有序链表OJ

合并两个有序链表OJ

合并两个有序链表OJ 文章目录 合并两个有序链表OJ一、题目及要求二、思路分析三、代码实现 一、题目及要求 二、思路分析 其次&#xff0c;题目里说了新链表是通过拼接原来的结点形成的&#xff0c;所以说我们不需要开辟新的空间。 三、代码实现 if (list1 NULL) {return li…
阅读更多...
链表OJ——环形链表初阶与进阶

链表OJ——环形链表初阶与进阶

呀哈喽&#xff0c;我是结衣。 环形链表1 描述 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数…
阅读更多...
leetcode一道比较难的链表题

leetcode一道比较难的链表题

今天还是继续来分享我们的链表题&#xff0c;这个题目有点难&#xff0c;主要是思路比较难想&#xff0c;但是如果沥青思路写起来就比较简单了&#xff08;我乱讲的&#xff09; 随机链表的复制 这个是题目的描述&#xff0c;大家也可以在链接里看&#xff0c;那我把这道题目…
阅读更多...
浅谈数据结构之链表

浅谈数据结构之链表

链表是一种灵活的数据结构&#xff0c;有单向链表、双向链表和循环链表等多种形式。在本文中&#xff0c;我们将深入探讨单向链表、双向链表、循环链表的定义、Java实现方式、使用场景&#xff0c;同时比较它们的不同之处。我们还会介绍链表与队列之间的区别。 单向链表 定义…
阅读更多...
《单链表》的实现（不含哨兵位的单向链表）

《单链表》的实现（不含哨兵位的单向链表）

目录 ​编辑 前言&#xff1a; 链表的概念及结构&#xff1a; 链表的实现&#xff1a; 1.typedef数据类型&#xff1a; 2.打印链表 &#xff1a; 3.创建新节点&#xff1a; 4.尾插 &#xff1a; 5.头插&#xff1a; 6.尾删 &#xff1a; 7.头删&#xff1a; 8.查找节…
阅读更多...
单链表相关经典算法OJ题：移除链表元素

单链表相关经典算法OJ题：移除链表元素

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 目录 前言 题目&#xff1a;移除链表元素 解法一&#xff1a; 解法一的代码实现&#xff1a; 解法二&#xff1a; 解法二代码的实现&#xff1a; 总结 前言 世上有两种耀眼的…
阅读更多...
【链表】数据查找和合并

【链表】数据查找和合并

获取链表中间位置的数据 #include <stdio.h> #include <stdlib.h>/* 定义链表的结构体 */ struct Node {int data;struct Node *next; };/* 获取链表中处于中间位置的元素并打印出来*/ void printMiddle(struct Node *head) {struct Node *slow_ptr head;struct …
阅读更多...
C语言编写链表的初始化、插入、删除、打印操作

C语言编写链表的初始化、插入、删除、打印操作

文章目录 1-11题例题12例题12答案答案一答案二 1-11题 C语言基础例题1-3题-指针篇 C语言基础例题4-5题-二维数组篇 C语言基础例题6-7题-结构体篇 C语言基础例题8-9题-大作业篇 C语言基础例题10-11题-字符串、指针篇 例题12 编写一个 C 语言程序&#xff0c;实现一个简单的链…
阅读更多...
「题解」环形链表的约瑟夫问题

「题解」环形链表的约瑟夫问题

文章目录 &#x1f349;题目&#x1f349;解析&#x1f34c;创建环形链表&#x1f34c;释放指定节点&#x1f34c;其他思路 &#x1f349;写在最后 &#x1f349;题目 &#x1f349;解析 题目的意思就是从环形链表的第一个节点开始数&#xff0c;数到第 m 的时候释放对应的节点…
阅读更多...
力扣138：随机链表的复制

力扣138：随机链表的复制

力扣138&#xff1a;随机链表的复制 题目描述&#xff1a; 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff…
阅读更多...
链表经典面试题之二

链表经典面试题之二

今天我们做一道环形链表的题目力扣141题https://leetcode.cn/problems/linked-list-cycle/ 这道题让我们分析链表中是否存环&#xff0c;存在的话返回true&#xff0c;不存在返回false。首先看到这道题我们要捋顺思路&#xff0c;怎么才能达到它要的效果&#xff1f;要找出是否…
阅读更多...
55. 右旋字符串（第八期模拟笔试）

55. 右旋字符串（第八期模拟笔试）

55. 右旋字符串&#xff08;第八期模拟笔试&#xff09; 原题链接&#xff1a;完成情况&#xff1a;解题思路&#xff1a;参考代码&#xff1a;错误经验吸取 原题链接&#xff1a; 55. 右旋字符串&#xff08;第八期模拟笔试&#xff09; https://kamacoder.com/problempage…
阅读更多...
【数据结构】树与二叉树（十一）：二叉树的层次遍历（算法LevelOrder）

【数据结构】树与二叉树（十一）：二叉树的层次遍历（算法LevelOrder）

文章目录 5.2.1 二叉树二叉树性质引理5.1&#xff1a;二叉树中层数为i的结点至多有 2 i 2^i 2i个&#xff0c;其中 i ≥ 0 i \geq 0 i≥0。引理5.2&#xff1a;高度为k的二叉树中至多有 2 k 1 − 1 2^{k1}-1 2k1−1个结点&#xff0c;其中 k ≥ 0 k \geq 0 k≥0。引理5.3&…
阅读更多...
C语言数据结构-----双向链表增删查改的代码实现

C语言数据结构-----双向链表增删查改的代码实现

文章目录 1.初始化双链表2.创建链表节点3.打印链表4.尾插5.尾删6.头插7.头删8.在pos之前插入8.1 在pos之前插入(改造头插)8.2 在pos之前插入(改造尾插) 9.删除pos位置9.1 删除pos位置(改造尾删)9.1 删除pos位置(改造头删) 10.查找11.毁灭 链接: 顺序表(动态顺序表增删查改的代码…
阅读更多...
链表的实现（文末附完整代码）

链表的实现（文末附完整代码）

链表的概念及结构 链表是一种物理存储结构上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接次序实现的 我们在上一篇文章所学习的顺序表是连续存储的 例如&#xff1a; 顺序表就好比火车上的一排座位&#xff0c;是连续的 而链表就好比是火车…
阅读更多...
Redis五种数据类型及命令操作（二）

Redis五种数据类型及命令操作（二）

&#x1f388;个人公众号:&#x1f388; :✨✨✨ 可为编程✨ &#x1f35f;&#x1f35f; &#x1f511;个人信条:&#x1f511; 知足知不足 有为有不为 为与不为皆为可为&#x1f335; &#x1f349;本篇简介:&#x1f349; 本篇记录Redis五种数据类型及命令操作&#xff0c;如…
阅读更多...
Leetcode—234.回文链表【简单】

Leetcode—234.回文链表【简单】

2023每日刷题&#xff08;二十七&#xff09; Leetcode—234.回文链表 直接法实现代码 /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/ bool isPalindrome(struct ListNode* head) {if(head NULL) {return t…
阅读更多...
数据结构-链表的简单操作代码实现3-LinkedList【Java版】

数据结构-链表的简单操作代码实现3-LinkedList【Java版】

写在前: 本篇博客主要介绍关于双向链表的一些简答操作实现&#xff0c;其中有有部分代码的实现和前两篇博客中的单向链表是相类似的。例如&#xff1a;查找链表中是否包含关键字key、求链表的长度等。 其余的涉及到prev指向的需要特别注意&#xff0c;区分和单向链表之间的差异…
阅读更多...
《LeetCode力扣练习》代码随想录——链表（两两交换链表中的节点---Java）

《LeetCode力扣练习》代码随想录——链表（两两交换链表中的节点---Java）

《LeetCode力扣练习》代码随想录——链表&#xff08;两两交换链表中的节点—Java&#xff09; 刷题思路来源于 代码随想录 24. 两两交换链表中的节点 虚拟头结点 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* L…
阅读更多...
《循环双向链表》（带哨兵位的头节点）

《循环双向链表》（带哨兵位的头节点）

目录 ​编辑 前言&#xff1a; 关于双向循环带头链表: 模拟实现双向循环带头链表&#xff1a; 1.typedef数据类型 2.打印链表 3.初始化链表&#xff1a; 4.创建节点 5.尾插 6.头插 7.尾删 8.头删 9.寻找节点 10.在节点前插入 11.删除指定节点 单链表和双链表的区别…
阅读更多...
LeetCode - 142. 环形链表 II （C语言，快慢指针，配图）

LeetCode - 142. 环形链表 II （C语言，快慢指针，配图）

如果你对快慢指针&#xff0c;环形链表有疑问&#xff0c;可以参考下面这篇文章&#xff0c;了解什么是环形链表后&#xff0c;再做这道题会非常简单&#xff0c;也更容易理解下面的图片公式等。 LeetCode - 141. 环形链表 &#xff08;C语言&#xff0c;快慢指针&#xff0c;…
阅读更多...
『力扣刷题本』:环形链表（判断链表是否有环）

『力扣刷题本』:环形链表（判断链表是否有环）

一、题目 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&am…
阅读更多...
C语言每日一题（34）链表的回文结构

C语言每日一题（34）链表的回文结构

牛客网 回文链表 题目描述 描述 对于一个链表&#xff0c;请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法&#xff0c;判断其是否为回文结构。 给定一个链表的头指针A&#xff0c;请返回一个bool值&#xff0c;代表其是否为回文结构。保证链表长度小于等于900。 …
阅读更多...
设计循环队列，解决假溢出问题

设计循环队列，解决假溢出问题

什么是假溢出&#xff1f; 当我们使用队列这种基本的数据结构时&#xff0c;很容易发现&#xff0c;随着入队和出队操作的不断进行&#xff0c;队列的数据区域不断地偏向队尾方向移动。当我们的队尾指针指向了队列之外的区域时&#xff0c;我们就不能再进行入队操作了&#xff…
阅读更多...
王道p150 20.将给定的表达式树转化为等价的中缀表达式（通过括号反应操作符的计算次序）

王道p150 20.将给定的表达式树转化为等价的中缀表达式（通过括号反应操作符的计算次序）

本题代码如下 void btreetoexp(tree t, char deep) {if (t NULL)return;else if (t->lchild NULL && t->rchild NULL)printf("%c", t->data);//输出操作数&#xff0c;不加括号else {if (deep > 1)printf("(");btreetoexp(t->l…
阅读更多...
leetcode做题笔记206. 反转链表

leetcode做题笔记206. 反转链表

给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&#xff1a;[2,1]示例 3&#xff1a; 输入&am…
阅读更多...
企业链表（未完成）

企业链表（未完成）

文章目录 1. 插入2. 代码实现 1. 插入 // 插入 void insert(LinkList* list, int pos, LinkNode* data) {if (!list || !data)return;if (pos < 0 || pos > list->size)return;LinkNode* curNode &(list->head);for (int i 0; i < pos; i) {curNode curN…
阅读更多...
Leetcode刷题详解——两两交换链表中的节点

Leetcode刷题详解——两两交换链表中的节点

1. 题目链接&#xff1a;24. 两两交换链表中的节点 2. 题目描述&#xff1a; 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 …
阅读更多...
[LeetCode]-链表中倒数第k个结点-CM11 链表分割-LCR 027. 回文链表

[LeetCode]-链表中倒数第k个结点-CM11 链表分割-LCR 027. 回文链表

目录 链表中倒数第k个结点 题目 思路 代码 CM11 链表分割 题目 思路 代码 LCR 027.回文链表 题目 思路 代码 链表中倒数第k个结点 链表中倒数第k个结点_牛客题霸_牛客网 (nowcoder.com)https://www.nowcoder.com/practice/529d3ae5a407492994ad2a246518148a?tpId…
阅读更多...
线性表之链式表

线性表之链式表

文章目录 主要内容一.单链表1.头插法建立单链表代码如下&#xff08;示例&#xff09;: 2.尾插法建立单链表代码如下&#xff08;示例&#xff09;: 3.按序号查找结点值代码如下&#xff08;示例&#xff09;: 4.按值查找表结点代码如下&#xff08;示例&#xff09;: 5.插入节…
阅读更多...
头插法创建单链表、遍历链表、删除链表 | C语言代码

头插法创建单链表、遍历链表、删除链表 | C语言代码

题目&#xff1a; 输入一系列自然数&#xff08;0和正整数&#xff09;&#xff0c;输入-1时表示输入结束。按照输入的顺序&#xff0c;用头插法建立单链表&#xff0c;并遍历所建立的单链表&#xff0c;输出这些数据。注意 -1 不加入链表。 输入格式: 第一行是一个正整数k&am…
阅读更多...
【左程云算法全讲2】链表、栈、队列、递归、哈希表和有序表

【左程云算法全讲2】链表、栈、队列、递归、哈希表和有序表

系列综述&#xff1a; &#x1f49e;目的&#xff1a;本系列是个人整理为了秋招面试的&#xff0c;整理期间苛求每个知识点&#xff0c;平衡理解简易度与深入程度。 &#x1f970;来源&#xff1a;材料主要源于左程云算法课程进行的&#xff0c;每个知识点的修正和深入主要参考…
阅读更多...
【牛客面试必刷TOP101】Day18.BM14 链表的奇偶重排和BM16 删除有序链表中重复的元素-II

【牛客面试必刷TOP101】Day18.BM14 链表的奇偶重排和BM16 删除有序链表中重复的元素-II

作者简介&#xff1a;大家好&#xff0c;我是未央&#xff1b; 博客首页&#xff1a;未央.303 系列专栏&#xff1a;牛客面试必刷TOP101 每日一句&#xff1a;人的一生&#xff0c;可以有所作为的时机只有一次&#xff0c;那就是现在&#xff01;&#xff01;&#xff01;&…
阅读更多...
创建一个链表

创建一个链表

1 问题 在数据结构的课堂上我们学习了关于单链表的许多知识&#xff0c;那么如何创建一个链表呢&#xff1f; 2 方法 链表&#xff1a;链表是由一系列节点组成的元素的集合。每个节点包含两部分&#xff0c;数据域item和指向下一个节点的指针next。通过节点之间的相互连接 &…
阅读更多...
Leetcode-876 链表的中间结点

Leetcode-876 链表的中间结点

本人解法有点硬凑答案… /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* ListNode(int val, ListNode next) { this.val val; this.next next; …
阅读更多...
【done】剑指offer18：删除链表指定节点

【done】剑指offer18：删除链表指定节点

力扣&#xff0c;https://leetcode.cn/problems/shan-chu-lian-biao-de-jie-dian-lcof/description/ // 自己写的答案 class Solution {public ListNode deleteNode(ListNode head, int val) {if (head null) {return null;}if (head.val val) {return head.next;}ListNode …
阅读更多...
LeetCode [简单] 160. 相交链表

LeetCode [简单] 160. 相交链表

给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c;函数返回结果后&#xff0c;链表必须 保持其原始结构 。 160.…
阅读更多...
求链表环的起始位置

求链表环的起始位置

leetcode中题目位置 https://leetcode.cn/problems/linked-list-cycle-ii/submissions/?envTypestudy-plan-v2&envIdtop-100-liked 代码&#xff1a; public class Solution {public ListNode detectCycle(ListNode head) {if (head null || head.next null) {return…
阅读更多...
【数据结构】树与二叉树（廿三）：树和森林的遍历——层次遍历（LevelOrder）

【数据结构】树与二叉树（廿三）：树和森林的遍历——层次遍历（LevelOrder）

文章目录 5.3.1 树的存储结构5. 左儿子右兄弟链接结构 5.3.2 获取结点的算法5.3.3 树和森林的遍历1. 先根遍历&#xff08;递归、非递归&#xff09;2. 后根遍历&#xff08;递归、非递归&#xff09;3. 森林的遍历4. 层次遍历a. 算法LevelOrderb. 算法解读c. 时间复杂度d.代码…
阅读更多...
python树的孩子链存储结构

python树的孩子链存储结构

树的孩子链存储结构是一种树的存储方式&#xff0c;它使用孩子兄弟表示法来表示树的结构。在这种存储结构中&#xff0c;树的每个节点都有一个指向其第一个孩子的指针和一个指向其下一个兄弟的指针。这样&#xff0c;可以通过这些指针来表示树的层次结构和节点之间的关系。 具…
阅读更多...
力扣21.合并两个有序链表

力扣21.合并两个有序链表

目录 1.解题思路2.代码实现 1.解题思路 遍历链表&#xff0c;通过判断两个链表的值从而链接到新的结点后面,遍历完毕后就得到了想要的链表. 2.代码实现 struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {struct ListNode* pNULL; struct…
阅读更多...
【Python数据结构与算法】线性结构小结

【Python数据结构与算法】线性结构小结

​​​​​​​ &#x1f308;个人主页: Aileen_0v0 &#x1f525;系列专栏:PYTHON学习系列专栏 &#x1f4ab;"没有罗马,那就自己创造罗马~" 目录 线性数据结构Linear DS 1.栈Stack 栈的两种实现 1.左为栈顶,时间复杂度为O(n) 2.右为栈顶,时间复杂度O(1) …
阅读更多...
【LeetCode刷题日志】206.反转链表

【LeetCode刷题日志】206.反转链表

&#x1f388;个人主页&#xff1a;库库的里昂 &#x1f390;C/C领域新星创作者 &#x1f389;欢迎 &#x1f44d;点赞✍评论⭐收藏✨收录专栏&#xff1a;LeetCode 刷题日志&#x1f91d;希望作者的文章能对你有所帮助&#xff0c;有不足的地方请在评论区留言指正&#xff0c;…
阅读更多...
链表中环的入口节点（环形链表），剑指offer,力扣

链表中环的入口节点（环形链表），剑指offer,力扣

目录 力扣题目地址&#xff1a; 题目&#xff1a; 我们直接看题解吧&#xff1a; 解题方法&#xff1a; 审题目事例提示&#xff1a; 解题分析&#xff1a; 解题思路&#xff1a; 主要思路&#xff1a;先判断是否有环&#xff0c;有则找出环入口节点 力扣题目地址&#xff1a; …
阅读更多...
Java LeetCode篇-深入了解关于单链表的经典解法

Java LeetCode篇-深入了解关于单链表的经典解法

&#x1f525;博客主页&#xff1a; 【小扳_-CSDN博客】 ❤感谢大家点赞&#x1f44d;收藏⭐评论✍ 文章目录 1.0 移除链表元素 1.1 使用双指针方法 2.0 反转链表 2.1 递归法 2.2 头插法 3.0 链表中倒数第 k 个节点 3.1 递归法 3.2 快慢指针 4.0 合并两个有序链表 4.1 递归法 …
阅读更多...
98. 验证二叉搜索树 探讨Stack实现栈，和Deque实现栈有什么区别

98. 验证二叉搜索树 探讨Stack实现栈，和Deque实现栈有什么区别

98. 验证二叉搜索树 原题链接&#xff1a;完成情况&#xff1a;解题思路&#xff1a;Stack实现方法&#xff1a; add方法() Deque实现方法&#xff1a;---add()方法 参考代码&#xff1a;错误经验吸取用push方法去实现&#xff0c;不要用add方法&#xff01;&#xff01;&…
阅读更多...
C语言每日一题（42）删除链表的倒数第N个结点

C语言每日一题（42）删除链表的倒数第N个结点

力扣网 19 删除链表的倒数第N个结点 题目描述 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5]示例 2&#xff1a; 输入&#xff1a;head …
阅读更多...
leetcode-142-环形链表（C语言实现）

leetcode-142-环形链表（C语言实现）

题目&#xff1a; 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评…
阅读更多...
LeetCode（56）两数相加【链表】【中等】

LeetCode（56）两数相加【链表】【中等】

目录 1.题目2.答案3.提交结果截图 链接&#xff1a; 两数相加 1.题目 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和…
阅读更多...
王道数据结构课后代码题p175 06.已知一棵树的层次序列及每个结点的度，编写算法构造此树的孩子-兄弟链表。（c语言代码实现）

王道数据结构课后代码题p175 06.已知一棵树的层次序列及每个结点的度，编写算法构造此树的孩子-兄弟链表。（c语言代码实现）

/* 此树为 A B C D E F G 孩子-兄弟链表为 A B E C F G D */ 本题代码如下 void createtree(tree* t, char a[], int degree[], int n) {// 为B数组分配内存tree* B (tree*)malloc(sizeof(tree) * n);int i 0;i…
阅读更多...
用C语言实现单链表

用C语言实现单链表

接下来&#xff0c;我们将使用C语言实现无头节点的单链表。 头文件&#xff1a; #pragma once #include <stdio.h> #include <assert.h> #include <stdlib.h>typedef int SLTDateType;typedef struct SListNode {SLTDateType data;struct SListNode* next;…
阅读更多...
【链表Linked List】力扣-83 删除排序链表中的重复元素

【链表Linked List】力扣-83 删除排序链表中的重复元素

目录 题目描述 解题过程 题目描述 给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,1,2] 输出&#xff1a;[1,2]示例 2&#xff1a; 输入&#xff1…
阅读更多...
【链表Linked List】力扣-24 两两交换链表中的节点

【链表Linked List】力扣-24 两两交换链表中的节点

目录 题目描述 解题过程 题目描述 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 示例 1&#xff1a; 输入&#xff1a;he…
阅读更多...
C++基础 -42- STL库之list链表

C++基础 -42- STL库之list链表

list链表的格式(需要定义头文件) list<int> data1(4, 100);list<int> data2(4, 500);list链表的合并接口 举例使用合并接口并且验证 data2.merge(data1);list<int>::iterator ccc;for (ccc data2.begin(); ccc ! data2.end(); ccc){cout << *ccc …
阅读更多...
数据结构：链表应用：第6关：链表的分解

数据结构：链表应用：第6关：链表的分解

任务描述 本关任务&#xff1a;利用单链表A表示一个非零整数序列&#xff0c;把A分解为两个具有相同结构的链表B和C&#xff0c;其中B表的结点为A表中值小于零的结点&#xff0c;而C表的结点为A表中值大于零的结点。要求空间复杂度为O(1)&#xff0c;链表B和C均利用链表A的结点…
阅读更多...
【链表Linked List】力扣-234回文链表

【链表Linked List】力扣-234回文链表

目录 问题描述 解题过程 labuladong题解 问题描述 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,2,1] 输出&#xff…
阅读更多...
环形链表解析（c语言）c语言版本！自我解析（看了必会）

环形链表解析（c语言）c语言版本！自我解析（看了必会）

目录 1.判断一个表是否是环形链表&#xff01; 代码如下 解析如下 2.快指针的步数和慢指针的步数有什么影响&#xff08;无图解析&#xff09; 3.怎么找到环形链表的入环点 代码如下 解析如下 1.判断一个表是否是环形链表&#xff01; 代码如下 bool hasCycle(struct L…
阅读更多...
剑指 Offer（第2版）面试题 18：删除链表的节点

剑指 Offer（第2版）面试题 18：删除链表的节点

剑指 Offer&#xff08;第2版&#xff09;面试题 18&#xff1a;删除链表的节点 剑指 Offer&#xff08;第2版&#xff09;面试题 18&#xff1a;删除链表的节点题目一&#xff1a;在 O(1) 时间删除链表结点题目二&#xff1a;删除链表中重复的节点 剑指 Offer&#xff08;第2版…
阅读更多...
【链表Linked List】力扣-109 有序链表转换二叉搜索树

【链表Linked List】力扣-109 有序链表转换二叉搜索树

目录 题目描述 解题过程 官方题解 题目描述 给定一个单链表的头节点 head &#xff0c;其中的元素 按升序排序 &#xff0c;将其转换为高度平衡的二叉搜索树。 本题中&#xff0c;一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差不超过 1。 示例 1: 输…
阅读更多...
java中AQS使用双向链表的原因是什么？

java中AQS使用双向链表的原因是什么？

AQS&#xff08;AbstractQueuedSynchronizer&#xff09;使用双向链表的主要原因是为了实现等待队列&#xff08;Wait Queue&#xff09;。这个等待队列是用于管理在同步器上等待的线程&#xff0c;例如在获取锁时发现锁被占用&#xff0c;线程就会加入到等待队列中等待。 使用…
阅读更多...
【链表Liked List】力扣-61 旋转链表

【链表Liked List】力扣-61 旋转链表

目录 题目描述 解题过程 题目描述 给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], k 2 输出&#xff1a;[4,5,1,2,3]示例 2&#xff1a; 输入&#xff1a;head […
阅读更多...
c语言数据结构---十字链表

c语言数据结构---十字链表

#include<stdio.h> #include<stdlib.h> typedef struct node{//十字链表 输入三元组返回矩阵 int row,col,val;struct node *down,*right; }JD,*J; typedef struct {J *rhead,*chead;int mu,nu,tu;//行列非0元 }CS; CS creat(CS M){int m,n,t;;int k,j,e;JD *p,*q…
阅读更多...
Java LeetCode篇-深入了解二叉树经典解法（三种方式实现：获取二叉树的最大深度）

Java LeetCode篇-深入了解二叉树经典解法（三种方式实现：获取二叉树的最大深度）

&#x1f525;博客主页&#xff1a; 【小扳_-CSDN博客】 ❤感谢大家点赞&#x1f44d;收藏⭐评论✍ 文章目录 1.0 对称二叉树 1.1 判断对称二叉树实现思路 1.2 代码实现&#xff1a;判断对称二叉树 2.0 二叉树的最大深度 2.1 使用递归实现获取二叉树的最大深度思路 2.2 代码实…
阅读更多...
leetcode 622. 设计循环链表

leetcode 622. 设计循环链表

这道题讲了两种方法&#xff0c;第一个代码是用数组实现的&#xff0c;第二个是用链表实现的&#xff0c;希望对你们有帮助 &#xff08;最好在VS自己测试一遍&#xff0c;再放到 leetcode上哦&#xff09; 下面的是主函数&#xff08;作参考&#xff09;&#xff0c;静下心来…
阅读更多...
【剑指offer|图解|链表】链表的中间结点 + 链表中倒数第k个结点

【剑指offer|图解|链表】链表的中间结点 + 链表中倒数第k个结点

&#x1f308;个人主页&#xff1a;聆风吟 &#x1f525;系列专栏&#xff1a;数据结构、算法模板 &#x1f516;少年有梦不应止于心动&#xff0c;更要付诸行动。 文章目录 &#x1f4cb;前言一. ⛳️链表的中间结点二. ⛳️链表中倒数第k个结点&#x1f4dd;结语 &#x1f4c…
阅读更多...
＜习题集＞＜LeetCode＞＜链表＞＜2/19/21/23/24＞

＜习题集＞＜LeetCode＞＜链表＞＜2/19/21/23/24＞

目录 2. 两数相加 19. 删除链表的倒数第 N 个结点 21. 合并两个有序链表 23. 合并 K 个升序链表 24. 两两交换链表中的节点 2. 两数相加 https://leetcode.cn/problems/add-two-numbers/ public ListNode addTwoNumbers(ListNode l1, ListNode l2) {//head是cur链表头节点…
阅读更多...
【LeetCode刷题（数据结构与算法）】：链表中的两数相加

【LeetCode刷题（数据结构与算法）】：链表中的两数相加

给你两个非空的链表&#xff0c;表示两个非负的整数 它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储一位数字 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表 你可以假设除了数字 0 之外&#xff0c;这两个数都不会以 0 开头 示例1&…
阅读更多...
基于C#实现块状链表

基于C#实现块状链表

在数据结构的世界里&#xff0c;我们会认识各种各样的数据结构&#xff0c;每一种数据结构都能解决相应领域的问题&#xff0c;当然每个数据结构&#xff0c;有他的优点&#xff0c;必然就有它的缺点&#xff0c;那么如何创造一种数据结构来将某两种数据结构进行扬长避短&#…
阅读更多...
链表K个节点的组内逆序调整问题

链表K个节点的组内逆序调整问题

链表K个节点的组内逆序调整问题 作者&#xff1a;Grey 原文地址&#xff1a; 博客园&#xff1a;链表K个节点的组内逆序调整问题 CSDN&#xff1a;链表K个节点的组内逆序调整问题 题目描述 LeetCode 25. Reverse Nodes in k-Group 本题的 follow up 是&#xff1a; Fol…
阅读更多...
【力扣100】234.回文链表

【力扣100】234.回文链表

添加链接描述 # Definition for singly-linked list. # class ListNode: # def __init__(self, val0, nextNone): # self.val val # self.next next class Solution:def isPalindrome(self, head: Optional[ListNode]) -> bool:# 思路是用一个数组接…
阅读更多...
LeetCode（65）LRU 缓存【链表】【中等】

LeetCode（65）LRU 缓存【链表】【中等】

目录 1.题目2.答案3.提交结果截图 链接&#xff1a; LRU 缓存 1.题目 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类&#xff1a; LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存int get(int key) 如果关键字 k…
阅读更多...
Leetcode的AC指南 —— 链表：24. 两两交换链表中的节点

Leetcode的AC指南 —— 链表：24. 两两交换链表中的节点

摘要&#xff1a; Leetcode的AC指南 —— 链表&#xff1a;24. 两两交换链表中的节点。题目介绍&#xff1a;给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能…
阅读更多...
【LeetCode】203. 移除链表元素（简单）——代码随想录算法训练营Day03

【LeetCode】203. 移除链表元素（简单）——代码随想录算法训练营Day03

题目链接&#xff1a;203. 移除链表元素 题目描述 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff…
阅读更多...
LeetCode刷题：141. 环形链表

LeetCode刷题：141. 环形链表

题目&#xff1a; 是否独立解答出&#xff1a;否&#xff0c;有思路&#xff0c;但是代码报错&#xff0c;参考解题代码后&#xff0c;修改通过 解题思路&#xff1a;利用循环与哈希表存储每一个节点&#xff0c;如果发现添加不进去说明&#xff0c;存在环&#xff0c;正常来说…
阅读更多...
java求链表中倒数第k个结点

java求链表中倒数第k个结点

下面我用两种方法求解&#xff1a; 第一种方法&#xff1a;通常我们做这种题就是求出链表的长度length&#xff0c;然后呢length-k的值就是我们要从链表头部走几步就可以了&#xff0c;代码解释&#xff1a; public class Solution {public class ListNode {int val;ListNode…
阅读更多...
题目2087蓝桥杯算法提高VIP_8皇后_改 _题目2087蓝桥杯算法提高VIP_8皇后_改

题目2087蓝桥杯算法提高VIP_8皇后_改 _题目2087蓝桥杯算法提高VIP_8皇后_改

51. N 皇后 原题链接&#xff1a;完成情况&#xff1a;解题思路&#xff1a;参考代码&#xff1a;_题目2087蓝桥杯算法提高VIP_8皇后_改_51N皇后_使用boolean数组表示已经占用的直or斜线 错误经验吸取 原题链接&#xff1a; 51. N 皇后 https://leetcode.cn/problems/n-quee…
阅读更多...
LeetCode（64）分隔链表【链表】【中等】

LeetCode（64）分隔链表【链表】【中等】

目录 1.题目2.答案3.提交结果截图 链接&#xff1a; 分隔链表 1.题目 给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你应当 保留 两个分区中每个节点的初始相对位置。 示…
阅读更多...
【力扣100】21.合并两个有序链表

【力扣100】21.合并两个有序链表

添加链接描述 # Definition for singly-linked list. # class ListNode: # def __init__(self, val0, nextNone): # self.val val # self.next next class Solution:def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -&…
阅读更多...
【力扣】148.排序链表

【力扣】148.排序链表

148.排序链表 怎么说&#xff0c;这道题看上去挺简单的&#xff0c;但是要搞清楚的知识点那还真不少&#xff0c;刷题好痛苦&#xff0c;但是要刷&#xff01;嘿嘿~ 首先&#xff0c;要搞懂归并排序&#xff0c;然后是递归。这道题我刚开始想的是递归&#xff0c;但是题友说时…
阅读更多...
C++ 删除链表中重复的节点 *

C++ 删除链表中重复的节点 *

在一个排序的链表中&#xff0c;存在重复的节点&#xff0c;请删除该链表中重复的节点&#xff0c;重复的节点不保留。 数据范围 链表中节点 val 值取值范围 [0,100] 。 链表长度 [0,100] 。 样例1 输入&#xff1a;1->2->3->3->4->4->5 输出&#xff1a;…
阅读更多...
【算法】算法题-20231221

【算法】算法题-20231221

这里写目录标题 一、830. 较大分组的位置二、657. 机器人能否返回原点三、771. 宝石与石头 一、830. 较大分组的位置 在一个由小写字母构成的字符串 s 中&#xff0c;包含由一些连续的相同字符所构成的分组。 例如&#xff0c;在字符串 s "abbxxxxzyy"中&#xff0…
阅读更多...
【数据结构和算法】找出两数组的不同

【数据结构和算法】找出两数组的不同

其他系列文章导航 Java基础合集数据结构与算法合集 设计模式合集 多线程合集 分布式合集 ES合集 文章目录 其他系列文章导航 文章目录 前言 一、题目描述 二、题解 2.1 哈希类算法题注意事项 2.2 方法一&#xff1a;哈希法 三、代码 3.1 方法一&#xff1a;哈希法 四…
阅读更多...
面试算法77：链表排序

面试算法77：链表排序

题目 输入一个链表的头节点&#xff0c;请将该链表排序。 分析 归并排序的主要思想是将链表分成两个子链表&#xff0c;在对两个子链表排序后再将它们合并成一个排序的链表。 这里可以用快慢双指针的思路将链表分成两半。如果慢指针一次走一步&#xff0c;快指针一次走两步…
阅读更多...
【leetcode100-024】【链表/快慢指针】回文链表

【leetcode100-024】【链表/快慢指针】回文链表

【题干】 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 进阶&#xff1a;你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题&#xff1f; 【思路】 判回文&#xff…
阅读更多...
利用 PEB_LDR_DATA 结构枚举进程模块信息

利用 PEB_LDR_DATA 结构枚举进程模块信息

1. 引言 我们常常通过很多方法来获取进程的模块信息&#xff0c;例如 EnumProcessModules 函数、CreateToolhelp32Snapshot 函数、WTSEnumerateProcesses 函数、ZwQuerySystemInformation 函数等。但是调用这些接口进行模块枚举的原理是什么我们并不知道。通过学习 PEB 中 PEB…
阅读更多...
【Leetcode】重排链表、旋转链表、反转链表||

【Leetcode】重排链表、旋转链表、反转链表||

目录 &#x1f4a1;重排链表 题目描述 方法一&#xff1a; 方法二&#xff1a; &#x1f4a1;旋转链表 题目描述 方法&#xff1a; &#x1f4a1;反转链表|| 题目描述 方法&#xff1a; &#x1f4a1;总结 &#x1f4a1;重排链表 题目描述 给定一个单链表 L 的头节…
阅读更多...
LeetCode 82：删除排序链表中的重复元素 II

LeetCode 82：删除排序链表中的重复元素 II

一、题目描述 给定一个已排序的链表的头 head &#xff0c; 删除原始链表中所有重复数字的节点&#xff0c;只留下不同的数字 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,3,4,4,5] 输出&#xff1a;[1,2,5]示例 2&#xff1a; 输入&#xff1a…
阅读更多...
LeetCode刷题：876. 链表的中间结点

LeetCode刷题：876. 链表的中间结点

题目&#xff1a; 是否参考题解&#xff1a;否 做题思路&#xff1a;看到题目关于奇偶数的题&#xff0c;首先想到了用计数器把链表遍历一遍&#xff0c;然后将计算出的数据个数count/2的下标作为头结点便可以遍历出来结果 题解思路&#xff1a;在评论区学习到还有两种解题思…
阅读更多...
12.7_黑马数据结构与算法Java

12.7_黑马数据结构与算法Java

030 单向链表 get 不会提前拿到所有的索引值&#xff0c;这样维护起来非常不方便。因此&#xff0c;我们是在遍历的时候得到他的索引值 %d&#xff1a;数字的占位符就是用百分号d表示 %n&#xff1a;换行符 thinking:String.format()? String.format()的详细用法_七月J的博客-…
阅读更多...
【链表Linked List】力扣-117 填充每个节点的下一个右侧节点指针II

【链表Linked List】力扣-117 填充每个节点的下一个右侧节点指针II

目录 问题描述 解题过程 官方题解 问题描述 给定一个二叉树&#xff1a; struct Node {int val;Node *left;Node *right;Node *next; } 填充它的每个 next 指针&#xff0c;让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点&#xff0c;则将 next 指针设置为 N…
阅读更多...
【数据结构】面试OJ题——链表

【数据结构】面试OJ题——链表

目录 1.移除链表元素 思路&#xff1a; 2.反转链表 思路&#xff1a; 3.链表的中间结点 思路&#xff1a; 4.链表中的倒数第K个结点 思路&#xff1a; 5.合并两个有序链表 思路&#xff1a; 6.链表分割 思路&#xff1a; 7.链表的回文结构 思路&#xff1a; 8.随机链表…
阅读更多...
秋招复习之数组与链表

秋招复习之数组与链表

目录 前言 1 数组 初始化数组&#xff1a; 访问元素 插入元素 删除元素 遍历数组&#xff1a; 查找元素 扩容数组&#xff1a; 数组的优点与局限性 2 链表 初始化链表 插入节点 删除节点 访问节点 查找节点 数组 vs. 链表 常见链表类型 3 列表 初始化列表 访问元素 插入与删…
阅读更多...
【力扣】234.回文链表2

【力扣】234.回文链表2

234.回文链表2 感觉自己还是有点时间&#xff0c;然后又学了两种解法。那就一起整理一下。 法一&#xff1a;反转链表后比较 题解看我的这一篇就行&#xff08;click) 法二&#xff1a;数组双指针 思路很简单&#xff0c;就是用while循环遍历一下整个链表将对应的值复制到…
阅读更多...
数据结构和算法-插入排序（算法效率 折半优化 顺序表与链表插入排序 代码实现）

数据结构和算法-插入排序（算法效率 折半优化 顺序表与链表插入排序 代码实现）

文章目录 插入排序算法实现算法效率分析优化-折半插入排序代码实现对链表进行插入排序小结 插入排序 首先49当作第一个已经排好序得元素&#xff0c;将第二个元素与前面得元素对比&#xff0c;发现小于49&#xff0c;于是49移动位置 此时将65与之前元素对比&#xff0c;发现其…
阅读更多...
数据结构——二叉树的链式结构

数据结构——二叉树的链式结构

个人主页&#xff1a;日刷百题 系列专栏&#xff1a;〖C语言小游戏〗〖Linux〗〖数据结构〗 〖C语言〗 &#x1f30e;欢迎各位→点赞&#x1f44d;收藏⭐️留言&#x1f4dd; ​ 一、二叉树的创建 这里我们使用先序遍历的思想来创建二叉树&#xff0c;这里的内容对于刚接触二…
阅读更多...
Java_LinkedList链表详解

Java_LinkedList链表详解

目录 前言 ArrayList的缺陷 链表 链表的概念及结构 链表的种类 1.单向或双向 2.带头或不带头 3.循环或不循环 LinkedList的使用 什么是LinkedList LinkedList的使用 LinkedList的构造 LinkedList的其他常用方法介绍 LinkedList的遍历 ArrayList和LinkedList的…
阅读更多...
探秘链表奇妙世界：从头到尾的数据之旅

探秘链表奇妙世界：从头到尾的数据之旅

目录 引言 链表介绍 单向链表的接口实现 结构 创建节点 头插 尾插 头删 尾删 打印 节点查找 节点前插入 节点删除 内存释放 总结 引言 在前面的学习中&#xff0c;我们深入了解了顺序表&#xff0c;通过其增删查改的操作&#xff0c;我们发现了顺序表在某些情况…
阅读更多...
LeetCode刷题笔记之链表

LeetCode刷题笔记之链表

一、移除链表元素 1. 203【移除链表元素】 题目&#xff1a; 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。代码&#xff1a; /*** Definition for singly-linked list.* public cla…
阅读更多...
【算法】链表-20240105

【算法】链表-20240105

这里写目录标题 一、LCR 023. 相交链表二、142. 环形链表 II 一、LCR 023. 相交链表 给定两个单链表的头节点 headA 和 headB &#xff0c;请找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 提示&#xff1a; listA 中节点数目为 m list…
阅读更多...
循序字符中插入数据（链表）

循序字符中插入数据（链表）

有一串已经从小到大排好序的数 2 3 5 8 9 10 18 26 32。现需要往这串数中插入 6 使其得 到的新序列仍符合从小到大排列。&#xff08;使用链表&#xff09;
阅读更多...
LeetCode142. Linked List Cycle II

LeetCode142. Linked List Cycle II

文章目录 一、题目二、题解 一、题目 Given the head of a linked list, return the node where the cycle begins. If there is no cycle, return null. There is a cycle in a linked list if there is some node in the list that can be reached again by continuously f…
阅读更多...
初级数据结构（三）——栈

初级数据结构（三）——栈

文中代码源文件已上传&#xff1a;数据结构源码 <-上一篇 初级数据结构&#xff08;二&#xff09;——链表 | 初级数据结构&#xff08;四&#xff09;——队列 下一篇-> 1、栈的特性 1.1、函数栈帧简述 即使是刚入门几天的小白&#xff0c;对栈这个字…
阅读更多...
Java带缓存的单向链表-线程安全

Java带缓存的单向链表-线程安全

开发原因 ArrayList太重&#xff0c;线程还不安全 在一些队列处理的时候&#xff0c;ArrayList有点麻烦&#xff0c;还比较占内存&#xff0c;还没缓存&#xff0c;又得再加个缓存队列 所以就开发了这个 轻量级&#xff0c;线程安全&#xff0c;带缓存&#xff01;nice!! 源码…
阅读更多...
LeetCode（61）删除链表的倒数第 N 个结点【链表】【中等】

LeetCode（61）删除链表的倒数第 N 个结点【链表】【中等】

目录 1.题目2.答案3.提交结果截图 链接&#xff1a; 删除链表的倒数第 N 个结点 1.题目 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5]示例…
阅读更多...
图灵日记之Leetcode删除有序数组中的重复项合并两个有序数组移除链表元素

图灵日记之Leetcode删除有序数组中的重复项合并两个有序数组移除链表元素

题目 删除有序数组中的重复项题目入口题目内容思路代码c版本c嘎嘎版本 合并两个有序数组题目链接题目内容思路代码c版本(c嘎嘎版本与c版本内容一样) 移除链表元素题目链接题目内容思路1代码1思路2代码2思路3代码3 删除有序数组中的重复项 题目入口 题目内容 给你一个 非严格…
阅读更多...
【数据结构和算法】字符串解码

【数据结构和算法】字符串解码

其他系列文章导航 Java基础合集数据结构与算法合集 设计模式合集 多线程合集 分布式合集 ES合集 文章目录 其他系列文章导航 文章目录 前言 一、题目描述 二、题解 2.1 什么情况会用到栈 2.2 方法一&#xff1a;辅助栈法 三、代码 3.1 方法一&#xff1a;辅助栈法 四…
阅读更多...
【leetcode】链表总结

【leetcode】链表总结

说明&#xff1a;本文内容来自于代码随想录 链表基本操作 https://leetcode.cn/problems/design-linked-list/ 删除节点 https://leetcode.cn/problems/remove-linked-list-elements/description/&#xff0c;删除节点&#xff0c;虚拟头节点。定义两个节点&#xff0c;分别…
阅读更多...
LeetCode（62）删除排序链表中的重复元素 II【链表】【中等】

LeetCode（62）删除排序链表中的重复元素 II【链表】【中等】

目录 1.题目2.答案3.提交结果截图 链接&#xff1a; 删除排序链表中的重复元素 II 1.题目 给定一个已排序的链表的头 head &#xff0c; 删除原始链表中所有重复数字的节点&#xff0c;只留下不同的数字 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1…
阅读更多...
【中等】24. 两两交换链表中的节点

【中等】24. 两两交换链表中的节点

题目 24. 两两交换链表中的节点 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 示例 1&#xff1a; 输入&#xff1a;head …
阅读更多...
王道计算机考研 数据结构C语言复现-第六章-队列

王道计算机考研 数据结构C语言复现-第六章-队列

这篇文章收录了王道考研课程中涉及的数据结构的所有代码。此外&#xff0c;本博客可能会添加一些额外的代码&#xff08;不仅限于王道考研&#xff09;&#xff0c;因为408考试中会频繁考察一些冷门的知识点&#xff0c;所以这篇博客会涵盖所有相关的代码。这也是我数据结构的第…
阅读更多...
大厂面试-美团高频考察算法之重排链表

大厂面试-美团高频考察算法之重排链表

本文学习目标或巩固的知识点 学习如何处理链表重排类题目 巩固反转链表巩固快慢指针巩固合并链表 提前说明&#xff1a;算法题目来自力扣、牛客等等途径 &#x1f7e2;表示简单 &#x1f7e1;表示中等 &#x1f534;表示困难 &#x1f92e;表示恶心 博主真实经历&#xff0c;…
阅读更多...
链表 迭代方式实现链表反转

链表 迭代方式实现链表反转

#include <stdio.h> #include <stdlib.h> 这两行是包含标准的输入输出库和动态内存分配库&#xff0c;以便你能够使用 printf、scanf 和 malloc 函数。 struct Node{//定义一个结构体类型 作为节点 int data;//存储整型数据 struct Node* next;//存储下一…
阅读更多...
【leetcode热题100】反转链表 II

【leetcode热题100】反转链表 II

给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], left 2, right 4 输出&#xff1a;[1,4,3,2…
阅读更多...
LeetCode：83和82.删除排序链表中的重复元素I,II

LeetCode：83和82.删除排序链表中的重复元素I,II

这两题算是链表的基础题&#xff0c;就遍历删除没啥特点&#xff0c; 83甚至不需要考虑第一个结点的特殊情况&#xff0c;属实是名副其实的easy了 LeetCode&#xff1a;21.合并两个有序链表之第一次的特殊情况-CSDN博客 83. 删除排序链表中的重复元素 - 力扣&#xff08;Lee…
阅读更多...
【算法与数据结构】链表、哈希表、栈和队列、二叉树

【算法与数据结构】链表、哈希表、栈和队列、二叉树

目录 一、算法与数据结构 二、链表 三、哈希表 四、栈和队列 五、二叉树 一、算法与数据结构 算法和数据结构是计算机科学中两个非常重要的概念。 数据结构是组织和存储数据的方式&#xff0c;它定义了数据元素之间的关系和操作。数据结构可以分为线性结构&#xff08;如…
阅读更多...
01.数据结构篇-链表

01.数据结构篇-链表

1.找出两个链表的交点 160. Intersection of Two Linked Lists (Easy) Leetcode / 力扣 例如以下示例中 A 和 B 两个链表相交于 c1&#xff1a; A: a1 → a2↘c1 → c2 → c3↗ B: b1 → b2 → b3 但是不会出现以下相交的情况&#xff0c;因为每个节点只有一个…
阅读更多...
每日OJ题_递归②_力扣21. 合并两个有序链表

每日OJ题_递归②_力扣21. 合并两个有序链表

目录 力扣21. 合并两个有序链表 解析代码 力扣21. 合并两个有序链表 21. 合并两个有序链表 难度 简单 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4]…
阅读更多...
「优选算法刷题」：连续数组

「优选算法刷题」：连续数组

一、题目 给定一个二进制数组 nums , 找到含有相同数量的 0 和 1 的最长连续子数组&#xff0c;并返回该子数组的长度。 示例 1: 输入: nums [0,1] 输出: 2 说明: [0, 1] 是具有相同数量 0 和 1 的最长连续子数组。 示例 2: 输入: nums [0,1,0] 输出: 2 说明: [0, 1] (或…
阅读更多...
【C语言】Leetcode 27.移除元素

【C语言】Leetcode 27.移除元素

一、代码实现 如果不考虑O(1)的空间复杂度的话我们可以再创建数组来进行遍历解决该问题&#xff0c;但是在要求之下该做法无法通过。于是我们可以用双指针来解决&#xff0c;最坏的情况时间复杂度为O(N)。 int removeElement(int* nums, int numsSize, int val) {int src 0;…
阅读更多...
list链表

list链表

1. list基本概念 功能&#xff1a;将数据进行链式存储 链表&#xff08;list&#xff09;是一种物理存储单元上非连续的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接实现的 链表的组成&#xff1a;链表由一系列结点组成 结点的组成&#xff1a;一个是存储数据…
阅读更多...
【LeetCode】递归精选8题——基础递归、链表递归

【LeetCode】递归精选8题——基础递归、链表递归

目录 基础递归问题&#xff1a; 1. 斐波那契数&#xff08;简单&#xff09; 1.1 递归求解 1.2 迭代求解 2. 爬楼梯&#xff08;简单&#xff09; 2.1 递归求解 2.2 迭代求解 3. 汉诺塔问题&#xff08;简单&#xff09; 3.1 递归求解 4. Pow(x, n)&#xff08;中等&…
阅读更多...
【优选算法专栏】专题九：链表--------两数之和

【优选算法专栏】专题九：链表--------两数之和

本专栏内容为&#xff1a;算法学习专栏&#xff0c;分为优选算法专栏&#xff0c;贪心算法专栏&#xff0c;动态规划专栏以及递归&#xff0c;搜索与回溯算法专栏四部分。 通过本专栏的深入学习&#xff0c;你可以了解并掌握算法。 &#x1f493;博主csdn个人主页&#xff1a;小…
阅读更多...
2024-02-21 算法: 测试链表是否有环

2024-02-21 算法: 测试链表是否有环

点击 <C 语言编程核心突破> 快速C语言入门 算法: 测试链表是否有环 前言一、双指针 ( 快慢指针 )二、代码总结 前言 要解决问题: 一道简单的算法题, 测试链表是否含有环. 想到的思路: 哈希表, 将链表指针强制转换为整型, 利用求余法建立哈希函数. 太复杂, 内存效率不高…
阅读更多...
Day17_集合与数据结构(链表,栈和队列,Map,Collections工具类,二叉树,哈希表)

Day17_集合与数据结构(链表,栈和队列,Map,Collections工具类,二叉树,哈希表)

文章目录 Day17 集合与数据结构学习目标1 数据结构2 动态数组2.1 动态数组的特点2.2 自定义动态数组2.3 ArrayList与Vector的区别&#xff1f;2.4 ArrayList部分源码分析1、JDK1.6构造器2、JDK1.7构造器3、JDK1.8构造器4、添加与扩容5、删除元素6、get/set元素7、查询元素8、迭…
阅读更多...
c语言：顺序表的按位置插入删除，去重操作。链表的尾插和输出

c语言：顺序表的按位置插入删除，去重操作。链表的尾插和输出

顺序表&#xff1a; datatype seek_index(seqlist*list,int index){//按位置查找if(list->len<index||list->len0||index>MAXSIZE){return -1;}printf("%d\n",list->date[index]);return 0;}int insert_index(seqlist*list,int index,datatype dat)…
阅读更多...
单向不带头链表

单向不带头链表

单向不带头链表 一、单项不带头链表结构完整代码 一、单项不带头链表结构 1.什么是链表&#xff1f;   我的理解是链表是一种逻辑上是线性结构&#xff0c;在真正的内存空间中是非线性&#xff0c;一般而言&#xff0c;不连续的结构&#xff0c;它是通过在堆区一块一块申请空…
阅读更多...
leetcode面试题 02.07. 链表相交

leetcode面试题 02.07. 链表相交

leetcode面试题 02.07. 链表相交 题目 思路 方案一&#xff1a;使用哈希表储存一个链表节点&#xff0c;在另一个链表进行查询是否有相同节点方案二&#xff1a;统计两个链表长度&#xff0c;然后末尾对齐&#xff0c;判断是否有相同节点 代码 使用哈希表set # Definition…
阅读更多...
LeetCode_Java_环形链表(题目+思路+代码)

LeetCode_Java_环形链表(题目+思路+代码)

141.环形链表 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位…
阅读更多...
【算法分析与设计】环形链表

【算法分析与设计】环形链表

&#x1f4dd;个人主页&#xff1a;五敷有你 &#x1f525;系列专栏&#xff1a;算法分析与设计 ⛺️稳中求进&#xff0c;晒太阳 题目 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次…
阅读更多...
Java中使用链表实现的数据结构

Java中使用链表实现的数据结构

在Java中&#xff0c;链表实现主要体现在以下几种数据结构中&#xff1a; 1. LinkedList LinkedList类实现了List接口和Deque接口&#xff0c;提供了双向链表的实现。它允许null元素&#xff0c;提供了列表的顺序访问以及在列表的头部和尾部进行高效的插入和移除操作。Linked…
阅读更多...
C#单向链表实现：Append,Move,Delete,InsertAscending, InsertUnAscending,Clear

C#单向链表实现：Append,Move,Delete,InsertAscending, InsertUnAscending,Clear

目录 一、链表定义 二、链表设计 1.先定义一个结点类&#xff08;Node&#xff09; 2.再定义链表类&#xff08;LinkedList&#xff09;并依次设计其方法 3.再实现删除方法 4.再实现Insert 的方法 5.再增加InsertAscending升序插入 6.再增加 InsertUnAscending 的方法…
阅读更多...
算法打卡day3|链表篇|Leetcode 203.移除链表元素、 707.设计链表 、 206.反转链表

算法打卡day3|链表篇|Leetcode 203.移除链表元素、 707.设计链表 、 206.反转链表

链表基本概念 定义 链表是一种通过指针串联在一起的线性结构&#xff0c;每一个节点由两部分组成&#xff0c;一个是数据域一个是指针域&#xff08;存放指向下一个节点的指针&#xff09;&#xff0c;最后一个节点的指针域指向null&#xff08;空指针的意思&#xff09;。其…
阅读更多...
Leecode之合并两个有序链表

Leecode之合并两个有序链表

一.题目及剖析 https://leetcode.cn/problems/merge-two-sorted-lists/description/ 二.思路引入 用指针遍历两个链表并实时比较,较小的元素进行尾插,然后较小元素的指针接着向后遍历 三.代码引入 /*** Definition for singly-linked list.* struct ListNode {* int va…
阅读更多...
从零开始学习数据结构—【链表】—【探索环形链的设计之美】

从零开始学习数据结构—【链表】—【探索环形链的设计之美】

环形链表 文章目录 环形链表1.结构图2.具体实现2.1.环形链表结构2.2.头部添加数据2.2.1.具体实现2.2.2.测试添加数据 2.3.尾部添加数据2.3.1.具体实现2.3.2.添加测试数据 2.4.删除头部数据2.4.1.具体实现2.4.2.测试删除数据 2.5.删除尾部数据2.5.1.具体实现2.5.2.测试删除数据 …
阅读更多...
数据结构知识点总结-线性表（3）-双向链表定义、循环单链表、、循环双向链表、静态链表、顺序表与链表的比较

数据结构知识点总结-线性表（3）-双向链表定义、循环单链表、、循环双向链表、静态链表、顺序表与链表的比较

双向链表定义 单链表结点中只有一个指向其后继的指针&#xff0c;这使得单链表只能从头结点依次顺序地向后遍历。若要访问某个结点的前驱结点&#xff08;插入、删除操作时&#xff09;&#xff0c;只能从头开始遍历&#xff0c;访问后继结点的时间复杂度为 O(1) &#xff0c; …
阅读更多...
【数据结构】OJ面试题《设计循环队列》(题库+代码)

【数据结构】OJ面试题《设计循环队列》(题库+代码)

1.前言 本题需要结构体和数组的知识&#xff0c;记录每天的刷题&#xff0c;继续坚持&#xff01; 2.OJ题目训练 设计循环队列 设计你的循环队列实现。 循环队列是一种线性数据结构&#xff0c;其操作表现基于 FIFO&#xff08;先进先出&#xff09;原则并且队尾被连接在队…
阅读更多...
数据结构与算法(数组,栈,队列,链表,哈希表,搜索算法,排序算法,查找算法,策略算法,递归算法,二叉搜索树BST,动态规划算法)

数据结构与算法(数组,栈,队列,链表,哈希表,搜索算法,排序算法,查找算法,策略算法,递归算法,二叉搜索树BST,动态规划算法)

文章目录 1 课程介绍1.1 前置知识1.2 为什么要学习算法1.3 大厂面试常见数据结构题目(基础)1.4 数据结构和算法的关系 2 数据结构2.1 数据结构概述2.1.1 数据结构是什么2.1.2 数据结构分类2.1.2.1 线性结构2.1.2.2 非线性结构2.1.2.3 小总结 2.1.3 数据结构范围 2.2 数组Array2…
阅读更多...
leetcode 3.反转链表；

leetcode 3.反转链表；

1.题目&#xff1a; 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 2.用例&#xff1a; 3.题目解析&#xff1a; &#xff08;1&#xff09;函数头&#xff1a; 要求返回结点&#xff0c;就 ListNode* reverseList(ListNode* head)&…
阅读更多...
LeetCode_Java_移除链表元素（题目+思路+代码）

LeetCode_Java_移除链表元素（题目+思路+代码）

203.移除链表元素 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5]思路&#xff1a;…
阅读更多...
【数据结构】循环链表的增删查改

【数据结构】循环链表的增删查改

文章目录前言一、什么是带头双向循环链表二、带头双向循环链表的实现2.1、动态开辟一个空间2.2、初始化与打印2.3、插入操作尾插头插在pos之前插入2.4、删除操作尾删头删删除pos处的位置2.4、查找与销毁操作前言 本文我们所要实现的是循环链表&#xff0c;即带头双向循环链表 一…
阅读更多...
【LeetCode热题100】23. 合并 K 个升序链表（链表）

【LeetCode热题100】23. 合并 K 个升序链表（链表）

一.题目要求 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 二.题目难度 困难 三.输入样例 示例 1&#xff1a; 输入&#xff1a;lists [[1,4,5],[1,3,4],[2,6]] 输出&#xff1a;[1,1,2,…
阅读更多...
LeetCode刷题---二叉树展开为链表

LeetCode刷题---二叉树展开为链表

官方题解&#xff1a;LeetCode官方题解 解题思想&#xff1a; 当根节点不为空时&#xff0c;从二叉树根节点开始遍历 判断当前节点是否有左节点&#xff0c;如果不存在左节点&#xff0c;则当前节点向右移一位 如果存在左节点&#xff0c;创建辅助节点指向左节点&#xff0c;判…
阅读更多...
【leetcode】链表分割

【leetcode】链表分割

大家好&#xff0c;我是苏貝&#xff0c;本篇博客带大家刷题&#xff0c;如果你觉得我写的还不错的话&#xff0c;可以给我一个赞&#x1f44d;吗&#xff0c;感谢❤️ 目录 方法1. 不用哨兵位方法2. 用哨兵位 点击查看题目 思路: 将链表分为2个链表list1和list2&#xff0c;…
阅读更多...
从零开始的LeetCode刷题日记：19.删除链表的倒数第N个节点

从零开始的LeetCode刷题日记：19.删除链表的倒数第N个节点

一.相关链接 题目链接&#xff1a;19.删除链表的倒数第N个节点 二.心得体会 这道题是道链表题&#xff0c;涉及到头结点的操作所以使用虚拟头结点。此外这也是道典型的双指针题目&#xff0c;只要快慢指针之间间隔n就可以做到让慢指针指向需要删除的节点的前节点&#xff0c;…
阅读更多...
⭐每天一道leetcode：83.删除排序链表中的重复元素（简单；链表遍历、删除经典题目）

⭐每天一道leetcode：83.删除排序链表中的重复元素（简单；链表遍历、删除经典题目）

⭐今日份题目 给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的链表 。 示例1 输入&#xff1a;head [1,1,2] 输出&#xff1a;[1,2] 示例2 输入&#xff1a;head [1,1,2,3,3] 输出&#xff1a;[1,2,3] …
阅读更多...
判断链表回文

判断链表回文

题目&#xff1a; //方法一&#xff0c;空间复杂度O(n) class Solution { public:bool isPalindrome(ListNode* head) {vector<int> nums; //放进数组后用双指针判断ListNode* cur head;while(cur){nums.emplace_back(cur->val);cur cur->next;}for(int i0…
阅读更多...
C#单向链表实现：用泛型类在当前位置插入新数据的方法Insert()

C#单向链表实现：用泛型类在当前位置插入新数据的方法Insert()

一、涉及到的知识点 1.ListNode<T>类 ListNode<T>是一个泛型类&#xff0c;用于表示链表中的一个节点。Value和Next属性是ListNode<T>最基本的属性&#xff0c;用于表示节点的值和指向下一个节点的引用。但是&#xff0c;完全可以根据实际需求添加其他属性&…
阅读更多...
leetcode 移除链表元素

leetcode 移除链表元素

本题中&#xff0c;我们是要移除链表的某一个节点&#xff0c;为了确保统一操作&#xff0c;我们需要使用虚拟头节点&#xff0c;这样我们删除节点的时候&#xff0c;就是把这个要删除的节点&#xff08;当前节点cur&#xff09;的前一个节点pre&#xff0c;使得pre.next指向要…
阅读更多...
leetcode热题100学习计划-链表-相交链表

leetcode热题100学习计划-链表-相交链表

思路 两条链表长短不一&#xff0c;找公共交点必须先对齐。记录两个链表各自长度&#xff0c;长的向短的看齐&#xff0c;长的先走多出来的那么一截&#xff0c;之后两者一起走&#xff0c;直到相遇或抵达末尾 代码 /*** Definition for singly-linked list.* public class …
阅读更多...
数据结构 - 链表 (三)

数据结构 - 链表 (三)

这篇博客完成单链表的最后部分&#xff0c;包括单链表的查找&#xff0c;任意位置插入删除数据&#xff0c;以及动态内存的释放。 1. 单链表的查找 单链表的结构如下图所示&#xff0c;我们查找数据只需将链表遍历一遍是否有需要查找的数据&#xff0c;同时也要考虑链表初始为…
阅读更多...
【数据结构和算法初阶(C语言)】带环链表问题详解（快慢指针的烧脑应用）

【数据结构和算法初阶(C语言)】带环链表问题详解（快慢指针的烧脑应用）

目录 1.铺垫-----带环链表基本了解 2. 题目&#xff1a;环形链表 3.环形链表|| ​编辑 3.1题解1 3.2 题解2 4.总结 1.铺垫-----带环链表基本了解 环形链表题目启迪&#xff1a; 环形链表特点&#xff1a;遍历链表会出现一模一样的地址 2. 题目&#xff1a;环形链表 给…
阅读更多...
力扣模板题：回文链表

力扣模板题：回文链表

请牢记检测回文串的模板 /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/ bool isPalindrome(struct ListNode* head) {int size0;struct ListNode* pointhead;while(point){size;pointpoint->next;}int arr…
阅读更多...
备战蓝桥杯————递归反转单链表

备战蓝桥杯————递归反转单链表

当要求只反转单链表中的一部分时&#xff0c;递归实现确实具有一定的挑战性&#xff0c;但也是可行的。下面我将介绍一种递归实现的方法来反转单链表中的一部分。 一、反转链表 题目描述 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示…
阅读更多...
c语言：将链表数据写入到文件，将数据读入链表

c语言：将链表数据写入到文件，将数据读入链表

#include "linklist.h" link_p createHead() { link_p H (link_p)malloc(sizeof(link)); if (H NULL) { printf("空间申请失败\n"); return NULL; } H->next NULL; H->len 0; return H; } link_p…
阅读更多...
【C项目】无头单向不循环链表

【C项目】无头单向不循环链表

简介&#xff1a;本系列博客为C项目系列内容&#xff0c;通过代码来具体实现某个经典简单项目 适宜人群&#xff1a;已大体了解C语法同学 作者留言&#xff1a;本博客相关内容如需转载请注明出处&#xff0c;本人学疏才浅&#xff0c;难免存在些许错误&#xff0c;望留言指正 作…
阅读更多...
java 实现删除单链表中所有指定的结点以及如何清空单链表

java 实现删除单链表中所有指定的结点以及如何清空单链表

文章目录1. 删除单链表中的所有的指定结点1.1 删除思路1.2 删除步骤1.2.1 删除结点不是头结点1.2.2 删除的结点是头结点的情况1.3 部分代码思路分析1.4 整体代码演示2. 清空单链表1. 删除单链表中的所有的指定结点 1.1 删除思路 定义一个 cur 来代替 head 遍历单链表。遇到指…
阅读更多...
【刷题记录】移除链表元素

【刷题记录】移除链表元素

本系列博客为个人刷题思路分享&#xff0c;有需要借鉴即可。 注&#xff1a;部分思路借鉴自程序员小熊 链接&#xff1a;https://leetcode.cn/problems/remove-linked-list-elements/solutions/341875/203-yi-chu-lian-biao-yuan-su-you-ya-di-gui-c-yu-ya/ 来源&#xff1a;力…
阅读更多...
LeetCode链表练习（上）

LeetCode链表练习（上）

文章目录前言1.反转链表1.题目分析2.代码示例2.力扣203. 移除链表元素1.题目分析2.代码示例3.力扣876. 链表的中间结点1.题目分析2.代码示例4.链表倒数第k个节点1.题目分析2.代码示例5.总结前言 之前介绍了链表的实现&#xff0c;为了更好巩固所学的知识&#xff0c;刷题是很有…
阅读更多...
21. Merge Two Sorted Lists(合并两个有序链表)

21. Merge Two Sorted Lists(合并两个有序链表)

问题描述 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 问题分析 我们只需要使用两个指针分别从两个链表的头部向后遍历整个链表&#xff0c;每一个次都让量个元素比较大小&#xff0c;小的元素并入的新的链表&#xf…
阅读更多...
链表总结 -- 《数据结构》-- c/c++

链表总结 -- 《数据结构》-- c/c++

链表的概念 链表是一种物理存储结构上非连续存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 链表是一种通过指针串联在一起的线性结构&#xff0c;每一个节点由两部分组成&#xff0c;一个是数据域一个是指针域&#xff08;存放指向下一个节点的…
阅读更多...
面试经典-31-随机链表的复制

面试经典-31-随机链表的复制

题目 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节点的值。新节…
阅读更多...
广义表的存储结构及其基本运算

广义表的存储结构及其基本运算

广义表存储结构构思: 通过上节广义表的定义 , 我相信大家对广义表有了大致的了解 , 广义表可以有多层嵌套 ,灵活多变 , 纵观四种表示方式 ,我们认为图解最直观 . 所以我们接下来的操作 ,就是在图的基础上来进行操作的. 广义表的相关操作分析,进而对图示进行改进: 数据操作: …
阅读更多...
详细解析单链表带头节点的结构体定义，普通单链表与有序单链表的创建等操作（含创建步骤与码源）

详细解析单链表带头节点的结构体定义，普通单链表与有序单链表的创建等操作（含创建步骤与码源）

14天阅读挑战赛努力是为了不平庸~ 算法学习有些时候是枯燥的&#xff0c;这一次&#xff0c;让我们先人一步&#xff0c;趣学算法&#xff01;欢迎记录下你的那些努力时刻&#xff08;算法学习知识点/算法题解/遇到的算法bug/等等&#xff09;&#xff0c;在分享的同时加深对于…
阅读更多...
2095. 删除链表的中间节点、19. 删除链表的倒数第 N 个结点、148. 排序链表

2095. 删除链表的中间节点、19. 删除链表的倒数第 N 个结点、148. 排序链表

LeetCode题解1、2095. 删除链表的中间节点2、 删除链表的倒数第 N 个结点3、排序链表1、2095. 删除链表的中间节点 题目描述&#xff1a; ➡️挑战链接⬅️ 分析&#xff1a; 首先题目要求我们删除中间节点&#xff0c;我们知道单链表是单向性的不能回头的&#xff0c;那么当…
阅读更多...
深度解析带头节点单链表的增删改查与销毁链表等操作（含算法编写步骤，有完整代码）

深度解析带头节点单链表的增删改查与销毁链表等操作（含算法编写步骤，有完整代码）

14天阅读挑战赛努力是为了不平庸~ 算法学习有些时候是枯燥的&#xff0c;这一次&#xff0c;让我们先人一步&#xff0c;趣学算法&#xff01;欢迎记录下你的那些努力时刻&#xff08;算法学习知识点/算法题解/遇到的算法bug/等等&#xff09;&#xff0c;在分享的同时加深对于…
阅读更多...
牛客网经典Java面试常见题

牛客网经典Java面试常见题

个人主页&#xff1a;熬夜磕代码丶 作品专栏: 数据结构与算法 我变秃了&#xff0c;也变强了 给大家介绍一款程序员必备刷题平台——牛客网 点击注册一起刷题收获大厂offer吧 文章目录一、二叉搜索树与双向链表二、从尾到头打印链表三、调整数组奇数位于偶数前面四、删除链表…
阅读更多...
数据结构与算法——链表（双向链表，顺序表与链表的比较)

数据结构与算法——链表（双向链表，顺序表与链表的比较)

&#x1f353;个人主页&#xff1a;bit.. &#x1f352;系列专栏&#xff1a;Linux(Ubuntu)入门必看 C语言刷题 数据结构与算法 目录 一.双向链表 二.双向链表的对称性&#xff1a;&#xff08;设指针p指向某一结点&#xff09; 1.双向链表的插入 2.双向链表的删除 …
阅读更多...
【(C语言)数据结构奋斗100天】顺序表和链表

【(C语言)数据结构奋斗100天】顺序表和链表

前言 &#x1f3e0;个人主页&#xff1a;泡泡牛奶 &#x1f335;系列专栏&#xff1a;[C语言] 数据结构奋斗100天 本期所介绍的线性表包括顺序表和链表&#xff0c;那么线性表优势什么一回事呢&#xff1f;就让我们带着以下问题&#xff0c;了解基本数据结构吧( •̀ ω •́ )…
阅读更多...
【数据结构】链表其实并不难 —— 手把手带你实现双向链表

【数据结构】链表其实并不难 —— 手把手带你实现双向链表

文章目录0. 前言1. 双向链表的概念2. 双向链表的实现2.1 结构设计2.2 接口总览2.3 初始化2.4 创建新节点2.5 尾插2.6 头插2.7 尾删2.8 头删2.9 查找2.10 在pos位置之前插入2.11 在pos位置删除2.12 打印2.13 销毁3. 完整代码List.hList.ctest.c4. 结语0. 前言 之前&#xff0c;…
阅读更多...
【Leetcode】拿捏链表（一）——206.反转链表、203.移除链表元素

【Leetcode】拿捏链表（一）——206.反转链表、203.移除链表元素

作者&#xff1a;一个喜欢猫咪的的程序员 专栏&#xff1a;《Leetcode》 喜欢的话&#xff1a;世间因为少年的挺身而出&#xff0c;而更加瑰丽。 ——《人民日报》 目录 206.反转链表 203.移除链表元素 206.反转链表 力扣https://leetcode…
阅读更多...
【数据结构】带头双向循环链表

【数据结构】带头双向循环链表

文章目录一、List.c1、创建新结点2、结点初始化3、打印数据4、任意位置的前面插入5、任意位置的删除&#xff08;当前位置&#xff09;6、尾插7.尾删8、头插9、头删10、查找数据11、判断链表里除了哨兵位是否有别的结点12、判断当前有几个数据13、销毁数据List.htest.c关于链表…
阅读更多...
【数据结构】二、线性表：6.顺序表和链表的对比不同（从数据结构三要素讨论：逻辑结构、物理结构（存储结构）、数据运算（基本操作））

【数据结构】二、线性表：6.顺序表和链表的对比不同（从数据结构三要素讨论：逻辑结构、物理结构（存储结构）、数据运算（基本操作））

文章目录 6.对比&#xff1a;顺序表&链表6.1逻辑结构6.2物理结构&#xff08;存储结构&#xff09;6.2.1顺序表6.2.2链表 6.3数据运算&#xff08;基本操作&#xff09;6.3.1初始化6.3.2销毁表6.3.3插入、删除6.3.4查找 6.对比&#xff1a;顺序表&链表 6.1逻辑结构 顺…
阅读更多...
双链表()

双链表()

双链表 实现一个双链表&#xff0c;双链表初始为空&#xff0c;支持 55 种操作&#xff1a; 在最左侧插入一个数&#xff1b;在最右侧插入一个数&#xff1b;将第 k 个插入的数删除&#xff1b;在第 k 个插入的数左侧插入一个数&#xff1b;在第 k 个插入的数右侧插入一个数 …
阅读更多...
LeetCode链表练习（下）

LeetCode链表练习（下）

文章目录前言1.链表分割1.题目分析2.代码示例2.环形链表1.题目分析2.代码示例3.142. 环形链表 II1.题目分析2.代码示例4.138. 复制带随机指针的链表1.题目分析2.代码示例5.237. 删除链表中的节点1.题目分析2.代码示例6.总结前言 本文还是继续介绍链表经典题&#xff0c;中间会…
阅读更多...
java数据结构与算法刷题-----LeetCode39. 组合总和

java数据结构与算法刷题-----LeetCode39. 组合总和

java数据结构与算法刷题目录&#xff08;剑指Offer、LeetCode、ACM&#xff09;-----主目录-----持续更新(进不去说明我没写完)&#xff1a;https://blog.csdn.net/grd_java/article/details/123063846 文章目录 解题思路 此题为216题的前置题&#xff0c;虽然题目整体难度更为…
阅读更多...
【C++】每日一题 82 删除排序链表中的重复元素

【C++】每日一题 82 删除排序链表中的重复元素

给定一个已排序的链表的头 head &#xff0c; 删除原始链表中所有重复数字的节点&#xff0c;只留下不同的数字 。返回 已排序的链表 。 class ListNode { public:int val;ListNode* next;ListNode(int _val) {val _val;next nullptr;} };ListNode* deleteDuplicates(ListNo…
阅读更多...
一文了解数据结构

一文了解数据结构

目录 数据结构 什么是数据结构 链表 数组 栈 队列 哈希表 堆 数据结构 什么是数据结构 「数据结构」决定了数据的顺序和位置关系.数据存储于内存时&#xff0c;决定了数据顺序和位置关系的便是「数据结构」 链表 「链表」中的数据呈线性排列。链表中添加删除数据比较…
阅读更多...
【数据结构】单链表（不带头结点）基本操作的实现（C语言）

【数据结构】单链表（不带头结点）基本操作的实现（C语言）

&#x1f680; 作者简介&#xff1a;一名在后端领域学习&#xff0c;并渴望能够学有所成的追梦人。 &#x1f40c; 个人主页&#xff1a;蜗牛牛啊 &#x1f525; 系列专栏&#xff1a;&#x1f6f9;初出茅庐C语言、&#x1f6f4;数据结构 &#x1f4d5; 学习格言&#xff1a;博…
阅读更多...
ArrayList源码简析

ArrayList源码简析

ArrayList源码简析ArrayList 简介Arraylist 和 Vector 的区别?Arraylist 与 LinkedList 区别?设计思路初始化插入元素扩容检查ensureCapacitySystem.arraycopy() 和 Arrays.copyOf()方法迭代器ArrayList 简介 ArrayList 的底层是数组队列&#xff0c;相当于动态数组。与 Jav…
阅读更多...
【OJ】K 个一组翻转链表

【OJ】K 个一组翻转链表

题目 基本思路&#xff1a;用计数栈实现分段&#xff0c;K个一组地翻转链表。 #include <bits/stdc.h> #include <stack> using namespace std;struct list_node {int val;struct list_node *next; };list_node *input_list() {int val, n;scanf("%d", …
阅读更多...
Leetcode 链表反转

Leetcode 链表反转

链表反转是指将一个单链表中的所有节点顺序逆转，即原先指向下一个节点的指针指向前一个节点，从而改变链表节点的指向关系。链表反转的基本原理可以通过迭代或递归两种方式来实现。 迭代方法： 迭代方法是最常用和直观的链表反转方式。其基本原理如下： 初始化三个指针：pre（…
阅读更多...
顺序表操作（动态+静态版本），思路清晰易懂

顺序表操作（动态+静态版本），思路清晰易懂

线性表SeqList的创建前言介绍动态顺序表的链接SeqList的创建和初始化SeqList尾插SeqList打印SeqList头插SeqList销毁SeqList尾删SeqList头删SeqList的查询SeqList指定位置的插入和删除两种顺序表的优缺点在上一篇文章我们了解到&#xff0c;数据结构就是对数据的高效处理方式的…
阅读更多...
【C++】每日一题 92 反转链表

【C++】每日一题 92 反转链表

给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 class ListNode { public:int val;ListNode* next;ListNode(int _val) {val _val;next nullptr;} };…
阅读更多...
代码随想录算法训练营第四天|24. 两两交换链表中的节点，19.删除链表的倒数第N个节点，面试题 02.07. 链表相交，142.环形链表II

代码随想录算法训练营第四天|24. 两两交换链表中的节点，19.删除链表的倒数第N个节点，面试题 02.07. 链表相交，142.环形链表II

代码随想录算法训练营第四天24.两两交换链表中的节点19.删除链表的倒数第N个节点02.07.链表相交142.环形链表II总结24.两两交换链表中的节点 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本…
阅读更多...
从尾到头打印链表 ，合并两个排序的链表、反转链表 ：迭代法

从尾到头打印链表 ，合并两个排序的链表、反转链表 ：迭代法

目录 合并两个排序的链表&#xff1a; 关于迭代法的理解&#xff1a; 每一层函数功能: 迭代的两个问题&#xff1a; 往里走时&#xff1a; 出来时&#xff1a; 从尾到头打印链表 返回数组&#xff1b; 每一层函数功能: 迭代的两个问题&#xff1a; 往里走时&#xff1…
阅读更多...
0083 环形链表

0083 环形链表

package LinkedList_; /* * 单向环形链表应用场景——约瑟夫问题 * 设编号为1&#xff0c;2....n的n个人围成一圈&#xff0c;约定编号为k&#xff08;1<k<n&#xff09;的人从1开始报数&#xff0c;数到m的人出列&#xff0c; * 它的下一位又从…
阅读更多...
【Leetcode每日一题】 递归 - 反转链表（难度⭐）（35）

【Leetcode每日一题】 递归 - 反转链表（难度⭐）（35）

1. 题目解析 题目链接&#xff1a;206. 反转链表 这个问题的理解其实相当简单&#xff0c;只需看一下示例&#xff0c;基本就能明白其含义了。 2.算法原理 一、递归函数的核心任务 递归函数的主要职责是接受一个链表的头指针&#xff0c;并返回该链表逆序后的新头结点。递归…
阅读更多...
【数据结构】单链表实现

【数据结构】单链表实现

文章目录一、链表概念结构及定义二、链表分类三、单链表实现逻辑&#xff08;1&#xff09;创建结构体&#xff08;2&#xff09;具体函数实现及解析&#xff08;*&#xff09;动态申请一个节点&#xff08;*&#xff09;单链表打印&#xff08;*&#xff09;单链表尾插&#x…
阅读更多...
【Java 数据结构】单链表与OJ题

【Java 数据结构】单链表与OJ题

篮球哥温馨提示&#xff1a;编程的同时不要忘记锻炼哦&#xff01;暮色降临&#x1f303;&#xff0c;冲一杯咖啡&#xff01; 目录 1、什么是链表&#xff1f; 2、实现一个单向非循环链表 2.1 实现前的约定 2.2 addFirst 方法 2.3 addList 方法 2.4 addIndex 方法 2.5 …
阅读更多...
数据结构（二）——单向有头链表的原理以及简单应用

数据结构（二）——单向有头链表的原理以及简单应用

本章主要叙述数据结构中单向有头链表的原理&#xff0c;在将原理说明白之后&#xff0c;后边会给出增删改查的实例代码和代码讲解。 文章目录一、单向有头链表的原理二、基本功能1、创建和摧毁链表2、按位置插入元素3、按元素大小插入元素4、删除元素5、一些小功能&#xff08;…
阅读更多...
数据结构——单链表专题

数据结构——单链表专题

目录 1. 链表的概念及结构2. 实现单链表初始化尾插头插尾删头删查找在指定位置之前插入数据在指定位置之后插入数据删除指定位之前的节点删除指定位置之后pos节点销毁链表 3. 完整代码test.cSList.h 4. 链表的分类 1. 链表的概念及结构 在顺序表中存在一定的问题&#xff1a; …
阅读更多...
【数据结构】链表OJ第二篇 —— 链表的中间节点 链表中倒数第k个节点 链表分割 链表的回文结构 相交链表

【数据结构】链表OJ第二篇 —— 链表的中间节点 链表中倒数第k个节点 链表分割 链表的回文结构 相交链表

文章目录0. 前言1. 链表的中间节点2. 链表中倒数第k个结点3. 链表分割4. 链表的回文结构5. 相交链表6. 结语0. 前言 书接上回&#xff0c;我们这次依然是为大家带来链表的OJ题。这一次的题量比之前多一些&#xff0c;内容为链表的中间节点、链表中倒数第k个节点、链表分割、链…
阅读更多...
138. 复制带随机指针的链表

138. 复制带随机指针的链表

LeetCode题解前言复制带随机指针的链表前言 在刷题的过程中&#xff0c;遇到了一个很棒的思路&#xff0c;与是便记录了下来&#xff01;&#xff01;&#xff01; &#x1f60a;&#x1f60a;&#x1f60a; 复制带随机指针的链表 题目描述&#xff1a; ➡️挑战链接⬅️ 分…
阅读更多...
【C++笔试强训】第二十天

【C++笔试强训】第二十天

&#x1f387;C笔试强训 博客主页&#xff1a;一起去看日落吗分享博主的C刷题日常&#xff0c;大家一起学习博主的能力有限&#xff0c;出现错误希望大家不吝赐教分享给大家一句我很喜欢的话&#xff1a;夜色难免微凉&#xff0c;前方必有曙光 &#x1f31e;。 &#x1f4a6;&a…
阅读更多...
Leetcode第21题：合并两个有序链表

Leetcode第21题：合并两个有序链表

生命无罪&#xff0c;健康万岁&#xff0c;我是laity。 我曾七次鄙视自己的灵魂&#xff1a; 第一次&#xff0c;当它本可进取时&#xff0c;却故作谦卑&#xff1b; 第二次&#xff0c;当它在空虚时&#xff0c;用爱欲来填充&#xff1b; 第三次&#xff0c;在困难和容易之…
阅读更多...
蓝桥杯必备算法分享——差分算法

蓝桥杯必备算法分享——差分算法

AcWing—差分算法 文章目录AcWing---差分算法一、什么是差分&#xff1f;二、差分的作用三、一维差分模板四、二维差分五、二维差分构造方法图示&#xff1a;六、二维差分矩阵模板总结差分算法是前缀和算法的逆运算。两者可以对比着学习&#xff1a; 一、什么是差分&#xff1…
阅读更多...
数据结构每日亿题(七)

数据结构每日亿题(七)

文章目录一题目二.思路2.1链表2.2数组三.代码一题目 原题传送门&#xff1a;力扣 题目&#xff1a; 题目的意思是让你写一个数据结构&#xff0c;这个结构的特点和队列一样先进先出&#xff0c;然后完成&#xff1a;判断是否为空&#xff0c;判断是否为满&#xff0c;添加一个…
阅读更多...
树的孩子兄弟链存储表示创建、遍历等算法

树的孩子兄弟链存储表示创建、遍历等算法

【实验目的】 1. 掌握树的孩子兄弟链存储表示。 2. 掌握树的创建、遍历等算法。 【问题描述】 树的创建及其操作。 【基本要求】 1. 创建树的孩子兄弟链式存储表示。假设以二元组(F,C)的形式输入一颗树的诸边&#xff0c;其中F表示双亲结点标识&#xff0c;C表示孩子结点…
阅读更多...
【数据结构】线性表 _顺序表 链表的增删查改 _[细节分析+代码实现]

【数据结构】线性表 _顺序表 链表的增删查改 _[细节分析+代码实现]

快速导航 1.线性表 2.顺序表 2.1 概念及结构 2.2 静态结构和动态结构的比较 2.3 接口实现(重点) 2.3.1 SeqList(初始化) &SeqListPrint(依次打印表中数据) 2.3.2 SeqListPushBack(尾插) 2.3.3 SeqListPushFront(头插) 2.3.4 SeqListPopBack(尾删) & SeqListPopFront(头…
阅读更多...
【LeetCode每日一题】——141.环形链表

【LeetCode每日一题】——141.环形链表

文章目录一【题目类别】二【题目难度】三【题目编号】四【题目描述】五【题目示例】六【解题思路】七【题目提示】八【题目进阶】九【时间频度】十【代码实现】十一【提交结果】一【题目类别】 链表 二【题目难度】 简单 三【题目编号】 141.环形链表 四【题目描述】 给…
阅读更多...
【C++】栈~~（很详细哦）

【C++】栈~~（很详细哦）

在前几天&#xff0c;我们刚一起学过顺序表&#xff0c;链表&#xff08;无头单向不循环&#xff0c;有头双向循环&#xff09;&#xff0c;这两种都属于线性表因为是一系列存储的。而以后的哈希表则是散列表 今天我们看一下栈 目录 1.栈的介绍 2.实现 3.题目 1.栈的介绍 …
阅读更多...
【C++】顺序表，链表，栈的练习（千万要会做）每日小细节007

【C++】顺序表，链表，栈的练习（千万要会做）每日小细节007

我们前几天已经学过了线性表&#xff1a;顺序表&#xff0c;链表和栈&#xff0c;但是只有理论知识是绝对不够的&#xff0c;我给大家找了一些很经典的题目&#xff0c;一定要做到立马有思路哦 &#xff08;如果还有小可爱没有看过我的顺序表&#xff0c;链表和栈的知识点说明&…
阅读更多...
LeetCode ——160. 相交链表，142. 环形链表 II

LeetCode ——160. 相交链表，142. 环形链表 II

✅<1>主页&#xff1a;C语言的前男友 &#x1f4c3;<2>知识讲解&#xff1a;LeetCode经典链表笔试题目 &#x1f525;<3>创作者&#xff1a;C语言的前男友 ☂️<4>开发环境&#xff1a;Visual Studio 2022 &#x1f3e1;<5>系统环境&#xff1a;…
阅读更多...
【数据结构】单链表定义的介绍及增删查改的实现

【数据结构】单链表定义的介绍及增删查改的实现

目录 前言 结点的初始化 增删 打印 查找 在指定位置后的插入 删除指定位置下一个结点的数据 销毁 与顺序表的对比 总结 源码 前言 相信很多人都像我一样&#xff0c;在正式学习链表之前就已经听过它的大名&#xff0c;但是就是不知道它究竟是干什么、怎么用的&#xf…
阅读更多...
力扣234.回文链表

力扣234.回文链表

给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,2,1] 输出&#xff1a;true示例 2&#xff1a; 输入&#xff1a;head [1,2…
阅读更多...
[数据结构]链表OJ题 (三) 链表的中间结点、链表中倒数第k个结点、合并两个有序链表、链表分割、链表的回文结构

[数据结构]链表OJ题 (三) 链表的中间结点、链表中倒数第k个结点、合并两个有序链表、链表分割、链表的回文结构

作者&#xff1a; 华丞臧. 专栏&#xff1a;【数据结构】 各位读者老爷如果觉得博主写的不错&#xff0c;请诸位多多支持(点赞收藏关注)。如果有错误的地方&#xff0c;欢迎在评论区指出。 推荐一款刷题网站 &#x1f449; LeetCode刷题网站 文章目录一、链表的中间结点题目描述…
阅读更多...
【数据结构与算法】单链表的增删查改（代码+图解）

【数据结构与算法】单链表的增删查改（代码+图解）

目录 顺序表和链表的特点&#xff1a; 时间复杂度&#xff1a; 分析&#xff1a; 单链表结构体和数据类型&#xff1a; 开辟一个节点和存储数据&#xff1a; 打印 尾插 尾删 头插 头删&#xff1a; 查找单链表中的元素 在pos后插入x 在pos前插入x 删除pos后的一个…
阅读更多...
【每日一题】LFU 缓存

【每日一题】LFU 缓存

一个缓存结构需要实现如下功能&#xff1a; void set(int key,int value)&#xff1a;加入或者修改 key 对应的 value int get(int key)&#xff1a;查询 key 对应的 value 值 但是缓存最多放 K 条记录&#xff0c;如果新的 K 1 条记录需要加入&#xff0c;就需要根据策略删掉…
阅读更多...
【JavaEE】PCB和进程调度的基本过程

【JavaEE】PCB和进程调度的基本过程

文章目录什么是进程PCB的组成PID内存指针文件描述符表并行和并发进程调度相关属性进程的状态优先级上下文进程的记账信息什么是进程 进程是正在运行的程序的实例&#xff08;an instance of a computer program that is being executed&#xff09; 进程&#xff08;process&am…
阅读更多...
数据结构之线性表中的顺序表【详解】

数据结构之线性表中的顺序表【详解】

前言 现在是北京时间11月24号0点2分&#xff0c;天气有一些冷&#xff0c;我现在很困&#xff0c;但是博客还没写&#xff0c;我很想睡觉&#xff0c;假如我现在放弃的码字&#xff0c;往床上一趟&#xff0c;其实也不怎么样&#xff0c;但是我们不能有拖延症&#xff0c;所以…
阅读更多...
反转链表问题的递归解法

反转链表问题的递归解法

目录 一、反转整个链表 二、反转部分链表 一、反转整个链表 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 首先在方法中我们需要判断递归终止的情况&#xff0c;如果headnull或者head.nextnull&#xff0c;那么我们就可以直接返回hea…
阅读更多...
内核中的RCU锁

内核中的RCU锁

RCU&#xff1a;Read-Copy-Update 已经有自旋锁&#xff0c;信号量&#xff0c;互斥锁等锁机制&#xff0c;为什么还需要RCU锁&#xff1f; 上述锁都使用了原子操作指令&#xff0c;即原子的访问内存&#xff0c;多CPU争用共享变量会让高速缓存一致性变得很糟&#xff0c;使得…
阅读更多...
LeetCode刷题---19. 删除链表的倒数第 N 个结点（双指针-快慢指针）

LeetCode刷题---19. 删除链表的倒数第 N 个结点（双指针-快慢指针）

文章目录一、编程题&#xff1a;142. 环形链表 II&#xff08;双指针-快慢指针&#xff09;1.题目描述2.示例1&#xff1a;3.示例2&#xff1a;4.示例3&#xff1a;5.提示&#xff1a;6.进阶&#xff1a;二、解题思路1.思路2.复杂度分析&#xff1a;3.算法图解三、代码实现总结…
阅读更多...
数据结构练级之路【链表带环问题】

数据结构练级之路【链表带环问题】

一、链表带环问题的代码和几个经典的面试题&#xff08;重点在于如何算入口点&#xff09; 代码非常的简单&#xff0c;但是有几个关于带环问题的讲解就比较不好理解 1.有关链表是否带环的题目和代码 &#xff08;较难且较经典&#xff09;&#xff08;有关链表带环的问题&a…
阅读更多...
【力扣】剑指offer第二天

【力扣】剑指offer第二天

剑指offer第二天[剑指 Offer 06. 从尾到头打印链表 - 力扣&#xff08;LeetCode&#xff09;]方法一代码方法二代码[剑指 Offer 24. 反转链表 - 力扣&#xff08;LeetCode&#xff09;]方法一代码方法二代码[剑指 Offer 35. 复杂链表的复制 - 力扣&#xff08;LeetCode&#xf…
阅读更多...
c语言数据结构---链表

c语言数据结构---链表

我喜欢我的懦弱&#xff0c;痛苦和难堪也喜欢。喜欢夏天的光照&#xff0c;风的气息&#xff0c;蝉的鸣叫&#xff0c;喜欢这些&#xff0c;喜欢得不得了。 ——村上春树《寻羊冒险记》 1.对链表的理解 2.链表每个节点的创建 3.输出链表 链表&#xff1a;顾名思义&#xff0c…
阅读更多...
实现一个后序遍历非递归算法

实现一个后序遍历非递归算法

实现一个后序遍历非递归算法。 解析&#xff1a; typedef enum{L,R} tagtype; typedef struct {Bitree ptr;tagtype tag; }stacknode; typedef struct {stacknode Elem[maxsize];int top; }SqStack; void PostOrderUnrec(Bitree t) {SqStack s;stacknode x;StackInit(s);pt;d…
阅读更多...
【数据结构初阶】反转链表

【数据结构初阶】反转链表

文章目录问题描述&#xff1a;思路分析&#xff1a;代码展示&#xff1a;问题描述&#xff1a; 给定一个单链表的头结点pHead(该头节点是有值的&#xff0c;比如在下图&#xff0c;它的val是1)&#xff0c;长度为n&#xff0c;反转该链表后&#xff0c;返回新链表的表头。 数据…
阅读更多...
【(C语言)数据结构奋斗100天】栈和队列

【(C语言)数据结构奋斗100天】栈和队列

前言 &#x1f3e0;个人主页&#xff1a;泡泡牛奶 &#x1f335;系列专栏&#xff1a;[C语言] 数据结构奋斗100天 本期所介绍的是栈和队列&#xff0c;那么什么是栈呢&#xff0c;什么是队列呢&#xff1f;在知道答案之前&#xff0c;请大家思考一下下列问题&#xff1a; 你如何…
阅读更多...
Contest2732 - 2022年计算机类数据结构作业3.20220929-1004

Contest2732 - 2022年计算机类数据结构作业3.20220929-1004

目录 问题 S: 算法2-25 有序单链表删除重复元素&#xff08;附加代码模式&#xff09; 问题 T: 案例3-1.1&#xff1a;线性表元素的区间删除 问题 U: 案例3-1.2&#xff1a;最长连续递增子序列 问题 V: 案例3-1.3&#xff1a;求链表的倒数第m个元素&#xff08;附加代码模式…
阅读更多...
【数据结构】LeetCode移除链表元素、反转链表、链表的中间结点

【数据结构】LeetCode移除链表元素、反转链表、链表的中间结点

目录 一、移除链表元素 1、题目说明 2、题目解析 二、反转链表 1、题目说明 2、题目解析 三、链表的中间结点 1、题目说明 2、题目解析 一、移除链表元素 1、题目说明 题目链接&#xff1a;移除链表的元素 给你一个链表的头节点 head &#xff0c;和一个整数 val&#xff0c;…
阅读更多...
【数据结构】(牛客)链表的回文结构，LeetCode相交链表，LeetCode环形链表

【数据结构】(牛客)链表的回文结构，LeetCode相交链表，LeetCode环形链表

目录 一、链表的回文结构 1、题目说明 2、题目解析 二、相交链表 1、题目说明 2、题目解析 三、环形链表 1、题目说明 2、题目解析 一、链表的回文结构 1、题目说明 题目链接&#xff1a;链表的回文结构 对于一个链表&#xff0c;请设计一个时间复杂度为O(n),额外空间复杂度…
阅读更多...
链表常见OJ题汇总（持续更新）

链表常见OJ题汇总（持续更新）

目录前言一、移除链表中的元素&#xff08;多指针法&#xff09;二、反转链表&#xff08;多指针法&头插法&#xff09;三、链表的中间结点&#xff08;算数法和双指针法&#xff09;四、链表中的第K个结点&#xff08;算数法&双指针法&#xff09;五、合并两个有序链表…
阅读更多...
LeetCode 138. 复制带随机指针的链表（C++）

LeetCode 138. 复制带随机指针的链表（C++）

思路&#xff1a; 用哈希表实现&#xff0c;创建一个哈希表来对应原链表中的每一个节点&#xff0c;这样也可以将原链表中的所有结点的next和random关系映射到哈希表复制链表中。 原题链接&#xff1a;https://leetcode.cn/problems/copy-list-with-random-pointer/description…
阅读更多...
Java-集合（3）

Java-集合（3）

Vector集合类 1.Vector底层保存数据的也是一个对象数组&#xff1a;protected Object[] elementDate; 2.Vector是线程同步的&#xff0c;也就是线程安全Vactor的操作方法都带有synchronized修饰。以此可以进行安全线程保障&#xff0c;所以在开发中如果确认只有一个线程操作集…
阅读更多...
【C++】list用法简单模拟实现

【C++】list用法简单模拟实现

文章目录1. list的介绍及使用1.1 list基本概念1.2 list的构造1.3 list的迭代器使用1.4 list 赋值和交换1.5 list 插入和删除1.6 list容量大小操作1.7 list 数据存取2. list的模拟实现这次要模拟实现的类及其成员函数接口总览2.1 结点类的实现2.2 迭代器的模拟实现2.3 反向迭代器…
阅读更多...
Java链表OJ题

Java链表OJ题

目录1. 删除链表中等于给定值val的所有结点2. 逆置单链表3. 链表的中间结点4. 链表中倒数第k个结点5. 将两个有序链表合并为一个新的有序链表6. 以给定值x为基准将链表分割成两部分7. 判断是否为回文链表8. 两个链表的第一个公共结点9. 判断链表中是否有环10. 链表开始入环的第…
阅读更多...
【数据结构和算法】使用数组的结构实现链表（单向或双向）

【数据结构和算法】使用数组的结构实现链表（单向或双向）

上文我们通过结构体的结构实现了队列、以及循环队列的实现&#xff0c;我们或许在其他老师的教学中&#xff0c;只学到了用结构体的形式来实现链表、队列、栈等数据结构&#xff0c;本文我想告诉你的是&#xff0c;我们可以使用数组的结构实现链表、单调栈、单调队列 目录 前言…
阅读更多...
Java中级之集合三

Java中级之集合三

Java中级之集合三 LinkedList实现类的基本使用 LinkedList底层是双向链表 常用方法 add、addFirst、addLast、offer、offerFirst、offerLast、poll、pollFirst、pollLast、remove、removeFirst、removeLast add();--------------------->添加元素到集合中addFirst();----…
阅读更多...
数据结构（二）：单向链表、双向链表

数据结构（二）：单向链表、双向链表

数据结构&#xff08;二&#xff09;一、什么是链表1.数组的缺点2.链表的优点3.链表的缺点4.链表和数组的区别二、封装单向链表1. append方法&#xff1a;向尾部插入节点2. toString方法&#xff1a;链表元素转字符串3. insert方法&#xff1a;在任意位置插入数据4.get获取某个…
阅读更多...
OJ刷题Day2 · 判断根结点是否等于子结点之和 · 删除有序数组中的重复项 · 合并两个有序链表 · 数组中的第K个最大元素（中等题）

OJ刷题Day2 · 判断根结点是否等于子结点之和 · 删除有序数组中的重复项 · 合并两个有序链表 · 数组中的第K个最大元素（中等题）

一、判断根结点是否等于子结点之和二、删除有序数组中的重复项三、合并两个有序链表四、数组中的第K个最大元素&#xff08;中等题&#xff09;一、判断根结点是否等于子结点之和 给你一个 二叉树 的根结点 root&#xff0c;该二叉树由恰好 3 个结点组成&#xff1a;根结点、左…
阅读更多...
贪心算法之装箱问题

贪心算法之装箱问题

问题描述&#xff1a; 有一些箱子&#xff0c;容量为V&#xff0c;同时有n个物品&#xff0c;每个物品有一个体积&#xff08;小于等于箱子容量&#xff09;&#xff0c;要求将物品全部装入箱子中&#xff0c;使占用的箱子数尽量少。 贪心算法中要求每一步的解都是当前步骤中的…
阅读更多...
剑指 Offer Day2——链表（简单）

剑指 Offer Day2——链表（简单）

目录剑指 Offer 06. 从尾到头打印链表剑指 Offer 24. 反转链表剑指 Offer 35. 复杂链表的复制剑指 Offer 06. 从尾到头打印链表 原题链接&#xff1a;06. 从尾到头打印链表 最容易想到的思路就是先从头到尾打印下来&#xff0c;然后 reverse 一下&#xff0c;但这里我们使用递归…
阅读更多...
LeetCode 19.删除链表的倒数第 N 个结点

LeetCode 19.删除链表的倒数第 N 个结点

原题链接 难度&#xff1a;middle\color{orange}{middle}middle 题目描述 给你一个链表&#xff0c;删除链表的倒数第 nnn 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5]示例 2&#x…
阅读更多...
链表(2)------数据结构

链表(2)------数据结构

1)进行反转单链表:节点的值不发生改变&#xff0c;只需要进行修改节点的指向 进行测试的时候要给方法传入一个头结点 输入:1&#xff0c;2&#xff0c;3&#xff0c;4&#xff0c;5&#xff1b; 输出:5&#xff0c;4&#xff0c;3&#xff0c;2&#xff0c;1&#xff1b; 1)我…
阅读更多...
代码随想录算法训练营第四天 java : 24. 两两交换链表中的节点 ，19.删除链表的倒数第N个节点 ，面试题 02.07. 链表相交，142环形链表II

代码随想录算法训练营第四天 java : 24. 两两交换链表中的节点 ，19.删除链表的倒数第N个节点 ，面试题 02.07. 链表相交，142环形链表II

文章目录Leetcode 24. 两两交换链表中的节点题目链接本题思路需要注意的点AC 代码Leetcode 19.删除链表的倒数第N个节点题目链接需要注意的点AC代码Leetcode面试题 02.07. 链表相交题目链接这个略了Leetcode 142环形链表II题目链接难点:AC代码今日收获**一朵玫瑰正马不停蹄地成…
阅读更多...
LINUX内核链表

LINUX内核链表

LINUX内核链表 一、传统链表的缺陷 传统的双向循环链表概念简单&#xff0c;操作方便&#xff0c;但存在有致命的缺陷&#xff0c;用一句话来概括就是&#xff1a; 每一条链表都是特殊的&#xff0c;不具有通用性。换句话说&#xff0c;对于每一种不同的数据&#xff0c;所构…
阅读更多...
LeetCode 23. 合并K个升序链表

LeetCode 23. 合并K个升序链表

原题链接 难度&#xff1a;hard\color{red}{hard}hard 题目描述 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 示例 1&#xff1a; 输入&#xff1a;lists [[1,4,5],[1,3,4],[2,6]] 输出…
阅读更多...
建单向链表-C语言实现

建单向链表-C语言实现

任务描述 本关需要你建立一个带头结点的单向链表。 相关知识 什么是链表？链表和二叉树是C语言数据结构的基础和核心。 链表有多种形式，它可以是单链接的或者双链接的，可以是已排序的或未排序的，可以是循环的或非循环的。 本关让我们来学习单链表。 单链表 单向链表（单…
阅读更多...
【数据结构与算法】LRU Cache

【数据结构与算法】LRU Cache

&#x1f320;作者&#xff1a;阿亮joy. &#x1f386;专栏&#xff1a;《数据结构与算法要啸着学》 &#x1f387;座右铭&#xff1a;每个优秀的人都有一段沉默的时光&#xff0c;那段时光是付出了很多努力却得不到结果的日子&#xff0c;我们把它叫做扎根 目录&#x1f449;…
阅读更多...
HashMap设计思想学习

HashMap设计思想学习

HashMap设计思想学习引言树化与退化红黑树的优势索引计算put流程扩容&#xff08;加载&#xff09;因子为何默认是 0.75fhashMap并发丢失数据问题jdk 1.7并发死链问题key 的设计引言 hashmap在jdk 1.7之前是数组链表结构&#xff0c;而jdk1.8之后变为是数组(链表|红黑树) 树化…
阅读更多...
剑指 Offer 52. 两个链表的第一个公共节点

剑指 Offer 52. 两个链表的第一个公共节点

摘要 剑指 Offer 52. 两个链表的第一个公共节点 一、两个链表的第一个公共节点解析 使用双指针的方法&#xff0c;可以将空间复杂度降至 O(1)。只有当链表 headA headB都不为空时&#xff0c;两个链表才可能相交。因此首先判断链表 headA和 headB是否为空&#xff0c;如果其…
阅读更多...
数据结构与算法基础（王卓）（10）：案例分析与实现（多项式；稀疏多项式；图书管理系统（略）；）

数据结构与算法基础（王卓）（10）：案例分析与实现（多项式；稀疏多项式；图书管理系统（略）；）

题干&#xff1a; 用线性表和链表的方式&#xff0c;分别实现&#xff08;稀疏&#xff09;多项式的 定义&#xff08;构造框架&#xff09;创建加减乘&#xff08;多项式&#xff09;线性表的创建&#xff1a; &#xff08;略&#xff0c;相较于其他操作难度不&#xff0c;以…
阅读更多...
【C语言】程序环境和预处理|预处理详解|定义宏（下）

【C语言】程序环境和预处理|预处理详解|定义宏（下）

主页&#xff1a;114514的代码大冒 qq:2188956112&#xff08;欢迎小伙伴呀hi✿(。◕ᴗ◕。)✿ &#xff09; Gitee&#xff1a;庄嘉豪 (zhuang-jiahaoxxx) - Gitee.com 文章目录 目录 文章目录 前言 2.5带副作用的宏参数 2.6宏和函数的对比 3#undef ​编辑 4 命令行定义…
阅读更多...
Python|每日一练|排序|递归|链表|字符串|数组|动态规划|哈希表|单选记录：K 个一组翻转链表|括号生成|无重复字符的最长子串

Python|每日一练|排序|递归|链表|字符串|数组|动态规划|哈希表|单选记录：K 个一组翻转链表|括号生成|无重复字符的最长子串

1、K 个一组翻转链表&#xff08;递归&#xff0c;链表&#xff09; 给你一个链表&#xff0c;每 k 个节点一组进行翻转&#xff0c;请你返回翻转后的链表。 k 是一个正整数&#xff0c;它的值小于或等于链表的长度。 如果节点总数不是 k 的整数倍&#xff0c;那么请将最后剩…
阅读更多...
数据结构与算法之《单链表》详解

数据结构与算法之《单链表》详解

标题&#xff1a;单链表的思路及代码实现 作者&#xff1a;Ggggggtm 寄语&#xff1a;与其忙着诉苦&#xff0c;不如低头赶路&#xff0c;奋路前行&#xff0c;终将遇到一番好风景 文章目录&#xff1a; 引入 一、链表的概念及结构 1.1 链表的概念 1.2 链表的结构 二、链表的思…
阅读更多...
【数据结构】二叉树链式结构的实现

【数据结构】二叉树链式结构的实现

&#x1f451;作者主页&#xff1a;进击的安度因 &#x1f3e0;学习社区&#xff1a;进击的安度因&#xff08;个人社区&#xff09; &#x1f4d6;专栏链接&#xff1a;数据结构 文章目录一、二叉树的链式存储二、二叉树链式结构的实现结构设计手动构建二叉树前序遍历中序遍历…
阅读更多...
【C语言】编程初学者入门训练（14）

【C语言】编程初学者入门训练（14）

文章目录131. kiki学结构体和指针132. kiki定义电子日历类133. 圣诞树134. 超级圣诞树131. kiki学结构体和指针 问题描述&#xff1a;KiKi学习了结构体和指针&#xff0c;他了解了结构体类型可以定义包含多个不同类型成员&#xff0c;而指针本质是内存地址&#xff0c;是引用数…
阅读更多...
HashMap

HashMap

文章目录HashMap实现原理HashMap 1.7 和 1.8为什么不直接使用红黑树&#xff1f;**红黑树的五大特点&#xff1a;**红黑树和平衡二叉树HashMap的 puthashmap扩容HahMap和HashTable的区别cncurrentHashMap的实现原理为什么要用ConcurrentHashMap&#xff1f;hashMap遍历HashMap实…
阅读更多...
链表OJ（六）链表相加(一) 链表相加(二)

链表OJ（六）链表相加(一) 链表相加(二)

目录 链表相加(一) 链表相加(二) 描述 二与一相比多了俩次反转而已 链表相加(一) 描述 给定两个非空链表逆序存储的的非负整数&#xff0c;每个节点只存储一位数组。 请你把两个链表相加以下相同方法返回链表&#xff0c;保证两个数都不会以 0 开头。 【我的解法】长到…
阅读更多...
剑指 Offer 36. 二叉搜索树与双向链表

剑指 Offer 36. 二叉搜索树与双向链表

摘要 剑指 Offer 36. 二叉搜索树与双向链表 一、二叉搜索树与双向链表 输入一棵二叉搜索树&#xff0c;将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点&#xff0c;只能调整树中节点指针的指向。 我们希望将这个二叉搜索树转化为双向循环链表。链表…
阅读更多...
【数据结构与算法】LinkedList与链表

【数据结构与算法】LinkedList与链表

✨个人主页&#xff1a;bit me ✨当前专栏&#xff1a;数据结构 ✨每日一语&#xff1a;假如困境有解&#xff0c;何须心烦意乱&#xff1b;倘若困境无解&#xff0c;又何须郁郁寡欢。每个人都有两次生命&#xff0c;当你意识到你只有一次生命的时候&#xff0c;你的第二次生命…
阅读更多...
【数据结构】————栈

【数据结构】————栈

文章目录前言栈是什么&#xff0c;栈的特点实现栈的基本操作栈的相关操作声明1.创建栈2.对栈进行初始化3.销毁栈4.判断栈是否为空5.压栈操作6.删除栈顶元素7.取出栈顶元素8.计算栈内存放多少个数据总结前言 本文主要讲述特殊的线性表——栈&#xff1a; 栈是什么&#xff0c;栈…
阅读更多...
算法练习 - 栈和队列(一)

算法练习 - 栈和队列(一)

算法练习 - 栈和队列(一) 文章目录算法练习 - 栈和队列(一)1 实现栈1.1 基于数组1.2 基于链表2. 实现队列2.1 基于数组&#xff08;循环队列&#xff09;2.2 基于链表3. 剑指 Offer 09. 用两个栈实现队列3.1 题目3.2 题解4. 用队列实现栈4.1 题目4.2 题解5. 栈排序5.1 题目5.2 …
阅读更多...
相交链表【2.23】

相交链表【2.23】

题目&#xff1a;给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c;…
阅读更多...
服务端开发之Java备战秋招面试3

服务端开发之Java备战秋招面试3

今天继续学习&#xff0c;先做两题算法题练练手&#xff0c;在继续整理八股文&#xff0c;深入理解&#xff0c;才能在面试的时候有更好地表现&#xff0c;一起加油吧&#xff0c;希望秋招多拿几个令人心动的offer&#xff0c;冲吧。 目录 1、算法题&#xff1a;判断链表中是…
阅读更多...
剑指Offer专项突击版题解三

剑指Offer专项突击版题解三

21.删除链表倒数第k个节点 思路&#xff1a;采用先遍历k个位置&#xff0c;在用双指针同时遍历。 22.找到链表环的入口 思路&#xff1a;map、判圈法&#xff08;先一步两步、找到哟圈之后在一步一步就会找到入口&#xff09; 23.两个链表的第一个重合点 思路&#xff1a;总会相…
阅读更多...
剑指Offer 第28天 复杂链表的赋值

剑指Offer 第28天 复杂链表的赋值

复杂链表的复制_牛客题霸_牛客网 描述 输入一个复杂链表&#xff08;每个节点中有节点值&#xff0c;以及两个指针&#xff0c;一个指向下一个节点&#xff0c;另一个特殊指针random指向一个随机节点&#xff09;&#xff0c;请对此链表进行深拷贝&#xff0c;并返回拷贝后的头…
阅读更多...
Java链表模拟实现+LinkedList介绍

Java链表模拟实现+LinkedList介绍

文章目录一、模拟实现单链表成员属性成员方法0&#xff0c;构造方法1&#xff0c;addFirst——头插2&#xff0c;addLast——尾插3&#xff0c;addIndex——在任意位置插入3.1&#xff0c;checkIndex——判断index合法性3.2&#xff0c;findPrevIndex——找到index-1位置的结点…
阅读更多...
LeetCode 1669. 合并两个链表（C++）

LeetCode 1669. 合并两个链表（C++）

思路&#xff1a; 该题思路很简单&#xff0c;对于单向链表&#xff0c;先遍历到指定的右边界的位置b1&#xff0c;做好标记供连接&#xff1b; 然后对于a-1位置的结点&#xff0c;连接list2&#xff0c;并最后连接后半段的list1 1.题目如下&#xff1a; 给你两个链表 list1 …
阅读更多...
【LeetCode】带环链表两道题

【LeetCode】带环链表两道题

第一题&#xff1a;环形链表 问题介绍 给你一个链表的头节点head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪next指针再次到达&#xff0c;则链表中存在环。为了表示给定链表中的环&#xff0c;评测系统内部使用整数pos 来表示链表…
阅读更多...
LeetCode 160. 相交链表

LeetCode 160. 相交链表

原题链接 难度&#xff1a;easy\color{Green}{easy}easy 题目描述 给你两个单链表的头节点 headAheadAheadA 和 headBheadBheadB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 nullnullnull 。 图示两个链表在节点 c1…
阅读更多...
js求解《初级算法》19.删除链表的倒数第N个结点

js求解《初级算法》19.删除链表的倒数第N个结点

一、题目描述 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] 二、思路 用虚拟头结点&#xff0b;双指针的方法解决该题&#xff0c;我们知道题目要求我们返回的是…
阅读更多...
剑指 Offer 64. 求1+2+…+n

剑指 Offer 64. 求1+2+…+n

剑指 Offer 64. 求12…n 难度&#xff1a;middle\color{orange}{middle}middle 题目描述 求 12...n12...n12...n &#xff0c;要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句&#xff08;A?B:C&#xff09;。 示例 1&#xff1a; 输入: n…
阅读更多...
Java查漏补缺（14）数据结构剖析、一维数组、链表、栈、队列、树与二叉树、List接口分析、Map接口分析、Set接口分析、HashMap的相关问题

Java查漏补缺（14）数据结构剖析、一维数组、链表、栈、队列、树与二叉树、List接口分析、Map接口分析、Set接口分析、HashMap的相关问题

Java查漏补缺&#xff08;14&#xff09;数据结构剖析、一维数组、链表、栈、队列、树与二叉树、List接口分析、Map接口分析、Set接口分析、HashMap的相关问题本章专题与脉络1. 数据结构剖析1.1 研究对象一&#xff1a;数据间逻辑关系1.2 研究对象二&#xff1a;数据的存储结构…
阅读更多...
21. 合并两个有序链表

21. 合并两个有序链表

题目链接&#xff1a;解题思路&#xff1a;遍历&#xff0c;双指针&#xff1a;因为两个链表有序&#xff0c;所以只需要依次比较两个元素的大小&#xff0c;然后添加到新的链表中即可first指针指向第一个链表l1&#xff0c;second指针指向第二个链表l2&#xff0c;answer保存合…
阅读更多...
剑指 Offer 22. 链表中倒数第k个节点

剑指 Offer 22. 链表中倒数第k个节点

⭐简单说两句⭐ CSDN个人主页&#xff1a;后端小知识 &#x1f50e;GZH&#xff1a;后端小知识 &#x1f389;欢迎关注&#x1f50e;点赞&#x1f44d;收藏⭐️留言&#x1f4dd; 题目&#xff1a; 剑指 Offer 22. 链表中倒数第k个节点 &#xff0c;我们今天来看一道easy的题目…
阅读更多...
【操作系统原理实验】调度算法模拟实现

【操作系统原理实验】调度算法模拟实现

选择一种高级语言如C/C等&#xff0c;模拟实现调度算法完成资源分配与回收的过程。2) 自定义PCB等核心数据结构&#xff1b;3) 利用列表、队列等容器类或者其他数据结构管理PCB,完成相应调度算法的模拟&#xff1b;4) 实现外围一些命令如创建进程、查看进程、关闭进程等&#x…
阅读更多...
数据结构——链表OJ题目讲解（1）

数据结构——链表OJ题目讲解（1）

作者&#xff1a;几冬雪来 时间&#xff1a;2023年3月7日 内容&#xff1a;数据结构链表OJ题目讲解 题目来源&#xff1a;力扣和牛客 目录 前言&#xff1a; 刷题&#xff1a; 1.移出链表元素&#xff1a; 2.链表的中间结点&#xff1a; 3. 链表中倒数第k个结点&#xff1…
阅读更多...
剑指 Offer 32 - II. 从上到下打印二叉树 II（java解题）

剑指 Offer 32 - II. 从上到下打印二叉树 II（java解题）

剑指 Offer 32 - II. 从上到下打印二叉树 II&#xff08;java解题&#xff09;1. 题目2. 解题思路3. 数据类型功能函数总结4. java代码5. 踩坑记录1. 题目 从上到下按层打印二叉树&#xff0c;同一层的节点按从左到右的顺序打印&#xff0c;每一层打印到一行。 例如: 给定二叉…
阅读更多...
LeetCode初级算法题（Java）：反转链表+统计N以内的素数+删除排序数组中的重复项

LeetCode初级算法题（Java）：反转链表+统计N以内的素数+删除排序数组中的重复项

文章目录1 反转链表1.1 题目1.2 解题思路解法1&#xff1a;迭代解法2&#xff1a;递归1.3 题解代码2 统计N以内的素数2.1 题目2.2 解题思路与题解代码解法1&#xff1a;暴力算法代码展示解法1&#xff1a;埃氏筛代码展示3 删除排序数组中的重复项3.1 题目3.2 解题思路3.3 题解代…
阅读更多...
单链表有环无环相交问题

单链表有环无环相交问题

题目描述&#xff1a; 给定两个有环也可能无环的单链表&#xff0c;头节点head1 和head2 请实现一个函数&#xff0c;如果两个链表相交&#xff0c;请返回相交的第一个节点&#xff0c; 如果不相交&#xff0c;返回null即可。 要求: 如果链表1的长度为N&#xff0c;链表2的长度…
阅读更多...
Python蓝桥杯训练：基本数据结构 [链表]

Python蓝桥杯训练：基本数据结构 [链表]

Python蓝桥杯训练&#xff1a;基本数据结构 [链表] 文章目录Python蓝桥杯训练&#xff1a;基本数据结构 [链表]一、链表理论基础知识二、有关链表的一些常见操作三、力扣上面一些有关链表的题目练习1、[移除链表元素](https://leetcode.cn/problems/remove-linked-list-element…
阅读更多...
力扣Top100题之两数相加（Java解法）

力扣Top100题之两数相加（Java解法）

0 题目描述 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0c;这两个数…
阅读更多...
【数据结构与算法】单链表的增删查改（附源码）

【数据结构与算法】单链表的增删查改（附源码）

这么可爱的猫猫不值得点个赞吗&#x1f63d;&#x1f63b; 目录 一.链表的概念和结构 二.单链表的逻辑结构和物理结构 1.逻辑结构 2.物理结构 三.结构体的定义 四.增加 1.尾插 SListpushback 2.头插 SListpushfront 五.删除 1.尾删 SListpopback 2.头删 SListpo…
阅读更多...
（五十二）大白话不断在表中插入数据时，物理存储是如何进行页分裂的？.md

（五十二）大白话不断在表中插入数据时，物理存储是如何进行页分裂的？.md

上回我们讲到了数据页的物理存储结构&#xff0c;数据页之间是组成双向链表的&#xff0c;数据页内部的数据行是组成单向链表的&#xff0c;每个数据页内根据主键做了一个页目录 然后一般来说&#xff0c;你没有索引的情况下&#xff0c;所有的数据查询&#xff0c;其实在物理…
阅读更多...
203. 移除链表元素 L2-027 名人堂与代金券

203. 移除链表元素 L2-027 名人堂与代金券

给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5] 示例 2&#xff1a; 输入&#…
阅读更多...
操作系统和初识进程

操作系统和初识进程

操作系统 操作系统是一组做计算机资源管理的软件的统称。 两大功能&#xff1a; 1、对下管理各种硬件设备 2、对上给软件提供稳定的运行环境 详细解释操作系统范畴的三大部分&#xff1a; 1、系统调用&#xff1a;操作系统提供的API &#xff08;应用程序需要调用这里的API才…
阅读更多...
数组还是队列？yocto-queue 源码告诉你

数组还是队列？yocto-queue 源码告诉你

前言 昨天刚学完 omit 的源码&#xff0c;今天趁着学习源码的热度还没结束&#xff0c;来学习一下另一个我之前未接触过的东西 yocto-queue。 yocto-queue 介绍 那么 yocto-queue 是什么呢&#xff1f;它有什么功能呢&#xff1f;查阅资料可得&#xff0c;对于数据比较多的数…
阅读更多...
队列-链表实现队列的初始化，入队，出队，清空，销毁操作

队列-链表实现队列的初始化，入队，出队，清空，销毁操作

#include "stdio.h" #include "stdlib.h"// 数据域 typedef struct LData {char c; // 常数 } LData;// 单链表 typedef struct Queue {LData data; //数据域struct Queue *next; } Queue;typedef struct Snode {Queue *front;Queue *rear; } Snode;// 初…
阅读更多...
leetcode: Swapping Nodes in a Linked List

leetcode: Swapping Nodes in a Linked List

leetcode: Swapping Nodes in a Linked List1. 题目描述2. 题目解答3. 总结1. 题目描述 You are given the head of a linked list, and an integer k.Return the head of the linked list after swapping the values of the kth node from the beginning and the kth node f…
阅读更多...
DPDK中的无锁共享数据结构

DPDK中的无锁共享数据结构

目录背景解决方法共享内存无锁操作新/老共享数据结构rte_ringrefcnt延迟释放方法1&#xff1a;读的线程来释放方法2&#xff1a;释放线程等到读线程轮询一轮参考背景 dpvs多线程&#xff0c;如何做到节约内存、高性能之间的均衡。 解决方法 共享内存 多线程共享内存&#x…
阅读更多...
【数据结构】单链表——增删查改【万字介绍】

【数据结构】单链表——增删查改【万字介绍】

目录 一&#xff0c;线性表 1&#xff0c;什么是线性表 2&#xff0c;线性表的结构 二&#xff0c;链表 1&#xff0c;什么是链表 2&#xff0c;链表的分类 3&#xff0c;单链表的特点 三&#xff0c;链表的实现 1&#xff0c;结构的定义 2&#xff0c;创建一个新结点 3&#…
阅读更多...
每日一题31——从尾到头打印链表

每日一题31——从尾到头打印链表

输入一个链表的头节点&#xff0c;从尾到头反过来返回每个节点的值&#xff08;用数组返回&#xff09;。 示例 1&#xff1a; 输入&#xff1a;head [1,3,2] 输出&#xff1a;[2,3,1] 限制&#xff1a; 0 < 链表长度 < 10000 解题思路&#xff1a; 将链表元素存储…
阅读更多...
LeetCode 2 - 两数相加

LeetCode 2 - 两数相加

给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0c;这两个数都不会以 0 开…
阅读更多...
【数据结构】双向链表的模拟实现（无头）

【数据结构】双向链表的模拟实现（无头）

目录 前言&#xff1a; 1、认识双向链表中的结点 2、认识并创建无头双向链表 3、实现双向链表当中的一些方法 3.1、遍历输出方法&#xff08;display&#xff09; 3.2、得到链表的长度&#xff08;size&#xff09; 3.3、查找关键字key是否包含在双链表中(contains) 3.…
阅读更多...
链表经典刷题--快慢指针与双指针

链表经典刷题--快慢指针与双指针

本篇总结链表解题思路----快慢指针&#xff0c;其实也就是双指针&#xff0c;这个快慢并不单纯指“快慢”&#xff0c;它更多的可以表示&#xff0c;速度快慢&#xff0c;距离长度&#xff0c;时间大小等等&#xff0c;用法很有趣也很独特&#xff0c;理解它的思想&#xff0c;…
阅读更多...
刷题28-有效的变位词

刷题28-有效的变位词

32-有效的变位词 解题思路&#xff1a; 注意变位词的条件&#xff0c;当两个字符串完全相等或者长度不等时&#xff0c;就不是变位词。 把字符串中的字符映射成整型数组&#xff0c;统计每个字符出现的次数 注意数组怎么初始化&#xff1a; int [] s1new int[26]代码如下&a…
阅读更多...
数据结构与算法之树结构基础

数据结构与算法之树结构基础

目录为什么要使用树结构树结构基本概念树的种类树的存储与表示常见的一些树的应用场景为什么要使用树结构 线性结构中不论是数组还是链表&#xff0c;他们都存在着诟病&#xff1b;比如查找某个数必须从头开始查&#xff0c;消耗较多的时间。使用树结构&#xff0c;在插入和查…
阅读更多...
LvglV7.0.2框架(一)

LvglV7.0.2框架(一)

Lvgl 任务调度 Tick Lvgl跟系统类似&#xff0c;外部只需调用其心跳计数函数&#xff0c;其内部控制相关任务的运行与控制。 lv_tick_inc(x) 控制Lvgl内部tick计数增加x lv_task_handler 循环执行注册的任务 数据结构 基础数据结构是双向链表lv_ll_t&#xff0c;根据优先级高…
阅读更多...
【数据结构】单链表中，如何实现 将链表中所有结点的链接方向“原地”逆转

【数据结构】单链表中，如何实现 将链表中所有结点的链接方向“原地”逆转

一.实现一个单链表&#xff08;无头单向不循环&#xff09; 我们首先实现一个无头单向不循环单链表。 写出基本的增删查改功能&#xff0c;以及其它的一些功能&#xff08;可忽略&#xff09;。 #include<stdio.h> #include<assert.h> #include<stdlib.h>…
阅读更多...
线性表的链式表示

线性表的链式表示

文章目录1.单链表1.1单链表的表示1.1.1构建 带头结点的单链表1.2基本操作1.2.1 头插法1.2.2 尾插法1.2.3 按序号查找结点1.2.4 按值查找表结点1.2.5 插入结点操作扩展&#xff1a;前插操作1.2.6 删除结点操作扩展&#xff1a;删除结点*p1.2.7 求表长操作2.双链表2.1 双链表的表…
阅读更多...
【算法竞赛-初级】基础数据结构-链表篇

【算法竞赛-初级】基础数据结构-链表篇

这个系列的文章主要是用来记录系统学习算法的心得思路&#xff0c;主要参考书籍是罗勇军老师的算法竞赛。现在目前目标是完成该书的初级部分&#xff0c;这篇文章是第一章基本数据结构中的链表部分。后续将持续更新该系列&#xff0c;欢迎大家一键三连&#xff01;&#x1f601…
阅读更多...
相交链表（力扣160）

相交链表（力扣160）

160.相交链表—力扣 题目描述&#xff1a; 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不…
阅读更多...
【算法之旅】基础数据结构之链表

【算法之旅】基础数据结构之链表

一名软件工程专业学生的算法之旅&#xff0c;记录自己从零开始学习数据结构与算法&#xff0c;从小白的视角学习数据结构&#xff1a;数组、对象/结构、字符串、队列、栈、树、图、堆、平衡树/线段树等&#xff0c;学习算法&#xff1a;枚举、排序、搜索、计数、分治策略、动态…
阅读更多...
【数据结构】实现二叉树的基本操作

【数据结构】实现二叉树的基本操作

目录 1. 二叉树的基本操作 2. 具体实现 2.1 创建BinaryTree类以及简单创建一棵树 2.2 前序遍历 2.3 中序遍历 2.4 后序遍历 2.5 层序遍历 2.6 获取树中节点的个数 2.7 获取叶子节点的个数 2.8 获取第K层节点的个数 2.9 获取二叉树的高度 2.10 检测值为val的元素是否…
阅读更多...
【STL】list剖析及模拟实现

【STL】list剖析及模拟实现

✍作者&#xff1a;阿润菜菜 &#x1f4d6;专栏&#xff1a;C 初识list 1. list基本概况 list是可以在常数范围内在任意位置进行插入和删除的序列式容器&#xff0c;并且该容器可以前后双向迭代。list的底层是双向链表结构&#xff0c;双向链表中每个元素存储在互不相关的独立…
阅读更多...
剑指 Offer 29. 顺时针打印矩阵

剑指 Offer 29. 顺时针打印矩阵

剑指 Offer 29. 顺时针打印矩阵 难度&#xff1a;middle\color{orange}{middle}middle 题目描述 输入一个矩阵&#xff0c;按照从外向里以顺时针的顺序依次打印出每一个数字。 示例 1&#xff1a; 输入&#xff1a;matrix [[1,2,3],[4,5,6],[7,8,9]] 输出&#xff1a;[1,2…
阅读更多...
刷题25-重排链表

刷题25-重排链表

重排链表 解题思路&#xff1a;通过观察链表可以发现&#xff0c;把链表一分为二&#xff0c;后半段链表反转&#xff0c;然后两个链表穿插连接&#xff0c;当链表的节点总数是奇数时&#xff0c;要保证链表的前半段比后半段多一个节点。 关于把链表一分为二&#xff0c;可以…
阅读更多...
Java每日一练(20230312)

Java每日一练(20230312)

目录 1. 两数之和 II ★ 2. 反转链表 ★★ 3. 二叉树的层序遍历 II ★★★ &#x1f31f; 每日一练刷题专栏 C/C 每日一练 ​专栏 Python 每日一练 专栏 Java 每日一练 专栏 1. 两数之和 II 给定一个已按照 非递减顺序排列 的整数数组 numbers &#xff0c;请你从数…
阅读更多...
链表算法题的四类问题：基础、双指针、快慢指针、递归

链表算法题的四类问题：基础、双指针、快慢指针、递归

一、基础 熟悉链表的数据结构 public class ListNode {public int val;public ListNode next;public ListNode(int val) { this.val val; } }1. 删除链表中指定值的节点 题目简述&#xff1a;给定一个不含重复值的单链表和一个要删除的值&#xff0c;定义一个函数删除该值节点…
阅读更多...
单向非循环链表

单向非循环链表

1、顺序表遗留问题 1. 中间/头部的插入删除&#xff0c;时间复杂度为O(N) 2. 增容需要申请新空间&#xff0c;使用malloc、realloc等函数拷贝数据&#xff0c;释放旧空间。会有不小的消耗。 3. 当我们以2倍速度增容时&#xff0c;势必会有一定的空间浪费。例如当前容量为100&a…
阅读更多...
手动实现 数组和链表

手动实现 数组和链表

数组和链表示意图 目的 不用java标准库 自己时间 一个 arraylist 和 linked list 区别 数组 数组 支持 随机访问 可以立即访问 根据 第一个元素的位置&#xff0c; 推算出 第三个地方的位置 如下图所示&#xff0c;假设我们知道 头的位置是X 数组是 int类型 每个位置就是 …
阅读更多...
详解带头双向循环链表（精美图示哦）

详解带头双向循环链表（精美图示哦）

全文目录引言带头双向循环链表接口实现链表的创建与销毁创建销毁链表的打印链表的头插与头删头插头删链表的尾插与尾删尾插尾删链表的查找链表在pos位置插入/删除插入删除总结引言 之前我们了解了顺序表与单链表的相关知识&#xff0c;实现了使用它们进行对数据的管理&#xf…
阅读更多...
【Leetcode——排序的循环链表】

【Leetcode——排序的循环链表】

&#x1f60a;&#x1f60a;&#x1f60a; 文章目录一、力扣题之排序循环链表二、解题思路1. 使用双指针法2、找出最大节点&#xff0c;最大节点的下一个节点是最小节点&#xff0c;由此展开讨论总结一、力扣题之排序循环链表 题目如下&#xff1a;航班直达&#xff01;&#…
阅读更多...
代码随想录--链表--设计链表题型

代码随想录--链表--设计链表题型

http://【帮你把链表操作学个通透&#xff01;LeetCode&#xff1a;707.设计链表-哔哩哔哩】 https://b23.tv/FB07jhU 链表中&#xff0c;为什么要用一个临时指针cur进行操作而不是直接用head&#xff0c;因为我们操作完链表后是需要返回头结点的&#xff0c;如果你用head的话…
阅读更多...
hashmap底层原理（自学）

hashmap底层原理（自学）

文章目录1、底层数据结构2、为什么不用二叉树/平衡树呢&#xff1f;3、hashmap的put方法4、神奇的地方1、扰动函数2、为什么 hash 值要与length-1相与3、HashMap数组的长度为什么是 2 的幂次方&#xff1f;1、底层数据结构 在JDK1.7 和JDK1.8 中有所差别&#xff1a; 在JDK1.7…
阅读更多...
2.两数相加

2.两数相加

给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0c;这两个数都不会以 0 …
阅读更多...
链表学习之复制含随机指针的链表

链表学习之复制含随机指针的链表

链表解题技巧 额外的数据结构&#xff08;哈希表&#xff09;&#xff1b;快慢指针&#xff1b;虚拟头节点&#xff1b; 复制含随机指针的链表 该链表节点的结构如下&#xff1a; class ListRandomNode { public:ListRandomNode() : val(0), next(nullptr), random(nullptr…
阅读更多...
【C++】面试101，链表相加，单链表排序，删除链表的重复元素，链表奇偶重排，判断链表是否回文

【C++】面试101，链表相加，单链表排序，删除链表的重复元素，链表奇偶重排，判断链表是否回文

1.链表相加&#xff08;二&#xff09; 最直观的思路就是直接走到末尾&#xff0c;然后按照进位规则写&#xff0c;但是走到最后怎么找到前一个&#xff1f;前一个的前一个&#xff1f; 所以先反转&#xff0c;然后按位相加(详见图&#xff09; #include <algorithm> …
阅读更多...
C++【list容器模拟实现函数解析】

C++【list容器模拟实现函数解析】

list容器&&模拟实现函数解析 文章目录list容器&&模拟实现函数解析一、list容器使用介绍二、list容器模拟实现及函数解析2.1 list结构体创建2.2 迭代器封装2.21 构造函数&#xff1a;2.22 前置和后置及- -2.23 解引用2.24 判断相等2.25 箭头重载2.26 第二个和第…
阅读更多...
【专项训练】数组、链表

【专项训练】数组、链表

数组array： list = []链表linked list # Definition for singly-linked list. class ListNode:def __init__(self, x):self.val = xself.next =
阅读更多...
HashMap底层实现原理及面试题

HashMap底层实现原理及面试题

文章目录1. 常见的数据结构有三种结构1.1 各自数据结构的特点2. HashMap2.1 概述2.2 底层结构2.2.1 HashMa实现原理&#xff1a;2.2.1.1 map.put(k,v)实现原理2.2.1.2 map.get(k)实现原理2.2.1.3 resize源码2.2.2 HashMap常用的变量2.2.3 HashMap构造函数2.3 JDK1.8之前存在的问…
阅读更多...
单链表归并排序 --自底向上 自顶向下

单链表归并排序 --自底向上 自顶向下

自顶向下 归并排序无序链表&#xff0c;自顶向下&#xff0c;故名思意就是将链表先切割成2部分&#xff0c;再切割成4部分&#xff0c;直到每个部分的元素为1个&#xff0c;此时是自然有序的&#xff0c;因为1个元素不用排序。 如何找到链表的最中间的节点&#xff1f; 那么不…
阅读更多...
链表相关oj题

链表相关oj题

1.Leetcode203 移除链表元素 解题思路&#xff1a;从头节点开始进行元素删除&#xff0c;每删除一个元素&#xff0c;需要重新链接节点 struct ListNode* removeElements(struct ListNode* head, int val){struct ListNode*dummyheadmalloc(sizeof(struct ListNode));dummyhea…
阅读更多...
一眼看破五花八门的链表结构

一眼看破五花八门的链表结构

文章目录&#x1f4d5;一&#xff1a;五花八门的链表结构&#x1f4d6;链表与数组的简单对比&#x1f4d6;单链表&#x1f4d6;循环链表&#x1f4d6;双向链表&#x1f4d5;二&#xff1a;链表VS数组性能大比拼&#x1f47f;最后说一句&#x1f431;‍&#x1f409;作者简介&am…
阅读更多...
【数据结构】链表

【数据结构】链表

目录 数据结构之链表&#xff1a;&#xff1a; SList.h 1.链表的概念及结构 2.链表的分类 SList.c 3.动态申请一个结点 4.单链表打印 5.单链表销毁 6.单链表头插 7.单链表头删 8.单链表尾插 9.单链表尾删 10.单链表查找 11.单链表在pos之前插入…
阅读更多...
【力扣-Python-21】合并两个有序链表（easy）

【力扣-Python-21】合并两个有序链表（easy）

https://leetcode.cn/problems/merge-two-sorted-lists/题目描述将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的# Definition for singly-linked list. # class ListNode: # def __init__(self, val0, nextNone): # …
阅读更多...
Leetcode—环形链表

Leetcode—环形链表

前言&#xff1a;给定一个链表&#xff0c;判断是否为循环链表并找环形链表的入口点 首先我们需要知道什么是双向循环链表&#xff0c;具体如下图所示。 对于链表&#xff0c;我们如何去判断链表是循环链表呢&#xff1f;又寻找入环点呢&#xff1f;我们可以利用快慢指针的方法…
阅读更多...
LRU算法

LRU算法

一、简介 LRU是Least Recently Used的缩写&#xff0c;即最近最少使用页面置换算法&#xff0c;是为虚拟页式存储管理服务的&#xff0c;是根据页面调入内存后的使用情况进行决策了。LRU算法就是将最近最久未使用的页面予以淘汰。 操作系统里&#xff0c;在内存不够的场景下&…
阅读更多...
数据结构——第二章 线性表（5）——双向循环链表

数据结构——第二章 线性表（5）——双向循环链表

双向循环链表1.双向循环链表的定义2.双向循环链表的基本操作实现2.1 双向循环链表的初始化操作2.2.双向循环链表的插入操作2.3. 双向循环链表的删除操作1.双向循环链表的定义 单向链表便于查询后继结点&#xff0c;不便于查询前驱结点。为了方便两个方向的查询&#xff0c;可以…
阅读更多...
LeetCode刷题笔记 - JavaScript（十三）

LeetCode刷题笔记 - JavaScript（十三）

文章目录1.剑指 Offer II 026. 重排链表2.剑指 Offer II 027. 回文链表3.剑指 Offer II 028. 展平多级双向链表4.剑指 Offer II 029. 排序的循环链表剑指 Offer II 026. 重排链表 剑指 Offer II 027. 回文链表 剑指 Offer II 028. 展平多级双向链表 剑指 Offer II 028. 展平多级…
阅读更多...
类和对象（一）

类和对象（一）

类和对象&#xff08;一&#xff09; C并不是纯面向对象语言 C是面向过程和面向对象语言的&#xff01; 面向过程和面向对象初步认识&#xff1a; C语言是面向过程的&#xff0c;关注的是过程&#xff0c;分析出求解问题的步骤&#xff0c;通过函数调用逐步解决问题。 C是基…
阅读更多...
剑指 Offer 25. 合并两个排序的链表

剑指 Offer 25. 合并两个排序的链表

剑指 Offer 25. 合并两个排序的链表 难度&#xff1a;easy\color{Green}{easy}easy 题目描述 输入两个递增排序的链表&#xff0c;合并这两个链表并使新链表中的节点仍然是递增排序的。 示例1&#xff1a; 输入&#xff1a;1->2->4, 1->3->4 输出&#xff1a;1…
阅读更多...
[数据结构]：13-插入排序（顺序表指针实现形式）（C语言实现）

[数据结构]：13-插入排序（顺序表指针实现形式）（C语言实现）

目录 前言 已完成内容 插入排序实现 01-开发环境 02-文件布局 03-代码 01-主函数 02-头文件 03-PSeqListFunction.cpp 04-SortCommon.cpp 05-SortFunction.cpp 结语 前言 此专栏包含408考研数据结构全部内容&#xff0c;除其中使用到C引用外&#xff0c;全为C语言代…
阅读更多...
队列实现及leetcode相关OJ题

队列实现及leetcode相关OJ题

上一篇写的是栈这一篇分享队列实现及其与队列相关OJ题 文章目录一、队列概念及实现二、队列源码三、leetcode相关OJ一、队列概念及实现 1、队列概念 队列同栈一样也是一种特殊的数据结构&#xff0c;遵循先进先出的原则&#xff0c;例如&#xff1a;想象在独木桥上走着的人&am…
阅读更多...
线性链表1

线性链表1

2.3.1线性链表单链表&#xff0c;用一个指针表示逻辑关系。特点&#xff1a;每个数据元素由节点(Node)构成。|data|next|线性结构head->a1|->a2|->a3|^节点可以连续也可以不连续。首节点&#xff1a;链表中第一个元素节点成为首节点尾节点&#xff1a;链表中最后一个元…
阅读更多...
二分查找——我欲修仙(功法篇)

二分查找——我欲修仙(功法篇)

个人主页&#xff1a;【&#x1f60a;个人主页】 系列专栏&#xff1a;【❤️我欲修仙】 学习名言&#xff1a;临渊羡鱼,不如退而结网——《汉书董仲舒传》 系列文章目录 第一章 ❤️ 二分查找 文章目录系列文章目录前言&#x1f697;&#x1f697;&#x1f697;二分查找&…
阅读更多...
148. 排序链表

148. 排序链表

148. 排序链表 给你链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [4,2,1,3] 输出&#xff1a;[1,2,3,4]解题思路 我们可以使用归并排序的思想来对链表进行排序。 具体步骤如下&#xff1a; 1、将链表…
阅读更多...
Ｎiuke:JZ36.二叉树与双向链表

Ｎiuke:JZ36.二叉树与双向链表

文章目录&#xff2e;iuke:JZ36.二叉树与双向链表题目描述示例思路分析代码实现&#xff2e;iuke:JZ36.二叉树与双向链表 题目描述 描述 输入一棵二叉搜索树&#xff0c;将该二叉搜索树转换成一个排序的双向链表。如下图所示 注意: 1.要求不能创建任何新的结点&#xff0c;只…
阅读更多...
【C++】STL—— list 模拟实现

【C++】STL—— list 模拟实现

文章目录&#x1f4d5; list 简介&#x1f4d5; list 模拟实现框架★ 迭代器实现 ★★反向迭代器的实现★构造函数、拷贝构造插入、删除其他成员函数&#x1f4d5; 源代码iterator.hlist.h&#x1f4d5; list 简介 vector 是一个和数组类似的容器&#xff0c;list 实际上就是和…
阅读更多...
面试题——求二叉树的下一个结点

面试题——求二叉树的下一个结点

题目&#xff1a; 给定一颗二叉树和其他的一个结点&#xff0c;如何找出中序遍历序列的下一个节点&#xff1f;树中的节点除了两个分别指向左右节点的指针&#xff0c;还有一个指向父亲节点的指针。 假如给定这棵二叉树的序列是{d,b,h,e,i,a,f,c,g},来分析如何找出二叉树的下一…
阅读更多...
线性表的链式存储——链表

线性表的链式存储——链表

目录 1.概念 2.链表 2.1 单链表概念及结构 2.2双链表的概念及结构 2.3 循环链表 3.链表的具体使用 4.自己实现链表及方法&#xff1a; 双链表&#xff1a; 单链表&#xff1a; 1.概念 链式存储是常用的动态存储方式&#xff0c;相对于顺序表&#xff0c;可以更好的任…
阅读更多...
ArrayList与顺序表

ArrayList与顺序表

目录 ​编辑 一、线性表 二、顺序表 1、接口的实现 &#xff08;1&#xff09;打印顺序表 &#xff08;2&#xff09;新增元素 &#xff08;3&#xff09;判定是否包含某个元素 &#xff08;4&#xff09;查找某个元素对应的位置下标 &#xff08;5&#xff09;获取 …
阅读更多...
队列实现图书信息管理（C语言）

队列实现图书信息管理（C语言）

文章目录Queue.hmain.cQueue.c用队列实现一个图书信息管理&#xff0c;这里放一下有哪些文件。&#xff08;ps&#xff1a;我之前写的是学生信息管理&#xff0c;但是有人说我们的作业是写图书&#xff0c;就该了下内容&#xff0c;没有改文件名&#xff09;队列是用链表实现的…
阅读更多...
Java——反转链表

Java——反转链表

题目链接 牛客在线oj题——反转链表 题目描述 给定一个单链表的头结点pHead(该头节点是有值的&#xff0c;比如在下图&#xff0c;它的val是1)&#xff0c;长度为n&#xff0c;反转该链表后&#xff0c;返回新链表的表头。 数据范围&#xff1a; 0≤n≤1000 要求&#xff1…
阅读更多...
数据结构Python版---设计链表(Day8)

数据结构Python版---设计链表(Day8)

文章目录1.1 ⭐算法原理&#xff1a;1.2 &#x1f43a;设计链表2.1 定义链表2.2 初始化空链表2.3 遍历链表2.4 在头节点添加新节点2.5 在尾节点添加新节点2.6 指定位置添加新节点2.7 指定位置删除新节点1.1 ⭐算法原理&#xff1a; 设计链表原理&#xff1a; 1&#xff09;链表…
阅读更多...
【Linux】文件描述符

【Linux】文件描述符

文章目录&#x1f4d5; 预备知识&#x1f4d5; 文件操作的接口open() 接口write() 接口read() 接口close() 接口&#x1f4d5; 文件描述符三个标准流★ 理解文件描述符 ★★ Linux下一切皆文件 ★文件描述符分配规则&#x1f4d5; 重定向的本质&#x1f4d5; dup2() 函数&#…
阅读更多...
菜鸟刷题Day6

菜鸟刷题Day6

⭐作者&#xff1a;别动我的饭 ⭐专栏&#xff1a;菜鸟刷题 ⭐标语&#xff1a;悟已往之不谏&#xff0c;知来者之可追 一.链表内指定区间反转&#xff1a;链表内指定区间反转_牛客题霸_牛客网 (nowcoder.com) 描述 将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转…
阅读更多...
数据结构与算法四 线性表

数据结构与算法四 线性表

一 线性表 线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。 前驱元素&#xff1a; 若A元素在B元素的前面&#xff0c;则称A为B的前驱元素 后继元素&#xff1a; 若B元素在A元素的后面&#xff0c;则称B为A的后继元素 …
阅读更多...
数据结构之Go实现栈

数据结构之Go实现栈

文章目录栈的基础知识栈的基本概念栈的结构体定义栈的实现数组栈切片栈链表栈栈的基础知识 栈的基本概念 &#xff08;1&#xff09;栈的定义 栈是一种只能在一端进行插入或删除操作的线性表&#xff0c;其中允许进行插入或删除操作的一端称为栈顶&#xff08;Top&#xff09…
阅读更多...
LRU缓存替换策略及C#实现

LRU缓存替换策略及C#实现

LRU缓存替换策略 缓存是一种非常常见的设计&#xff0c;通过将数据缓存到访问速度更快的存储设备中&#xff0c;来提高数据的访问速度&#xff0c;如内存、CPU缓存、硬盘缓存等。 但与缓存的高速相对的是&#xff0c;缓存的成本较高&#xff0c;因此容量往往是有限的&#xf…
阅读更多...
【剑指offer|4.从尾到头打印单链表】

【剑指offer|4.从尾到头打印单链表】

0.从尾到头打印单链表 单链表&#xff1a;一般给的都是无头节点的 另外&#xff1a;在面试中&#xff0c;如果我们打算修改输入的数据&#xff0c;则最好问一下面试官是不是允许修改 下面这种先把链表节点的值按链表序放到数组中&#xff0c;然后来一个算法库中的reverse属实有…
阅读更多...
C语言数据结构二：单向链表

C语言数据结构二：单向链表

单项链表由两个结构体组成。 一、链表结点的结构体 首先是链表的结构体。链表的结构体有两部分构成&#xff1a;数据域和指针域。 数据域&#xff1a;之前我们会写具体类型&#xff0c;但是在数据结构中为了让类型泛指&#xff0c;所以我们也是void*类型。节点上只存地址。类…
阅读更多...
文章一:Python高级数据结构与算法实

文章一:Python高级数据结构与算法实

一、简介 在这篇文章中&#xff0c;我们将学习Python中的高级数据结构&#xff0c;如堆、栈、队列、链表等&#xff0c;并使用Python实现常见的算法&#xff0c;如排序、查找等。我们将从以下几个方面来展开本文的内容&#xff1a; 栈&#xff08;Stack&#xff09;队列&…
阅读更多...
C/C++每日一练(20230406)

C/C++每日一练(20230406)

目录 1. 按要求求质数 ※ 2. 两数之和 &#x1f31f; 3. 颜色分类 &#x1f31f;&#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Golang每日一练 专栏 Python每日一练 专栏 C/C每日一练 专栏 Java每日一练 专栏 1. 按要求求质数 求10-100之间个位数为…
阅读更多...
HashMap的底层原理

HashMap的底层原理

hashmap是一个以key,value形式存储的集合,在JDK1.7中是以数组链表的数据结构,在JDK1.8中是数组链表红黑树的数据结构,他在对数据操作时继承了数组的线性查找和链表的寻址修改 红黑树 : 除了插入操作慢,其他操作都是比链表要快的,当hash表中链表的长度超过8,数组长度大于64,就…
阅读更多...
【数据结构】二叉树顺序结构及实现

【数据结构】二叉树顺序结构及实现

&#x1f680;write in front&#x1f680; &#x1f4dc;所属专栏&#xff1a;初阶数据结构 &#x1f6f0;️博客主页&#xff1a;睿睿的博客主页 &#x1f6f0;️代码仓库&#xff1a;&#x1f389;VS2022_C语言仓库 &#x1f3a1;您的点赞、关注、收藏、评论&#xff0c;是对…
阅读更多...
【可信平台】--批号产生耗用，重新推送入库、领料和出库

【可信平台】--批号产生耗用，重新推送入库、领料和出库

W200251132023010600002、W200274762023010600196已经产生耗用，所以入库、领料、出库数据需要重新推送一次 早上申工说，红色的4个批次平台没有同步记录，就不要同步了。 黄色的两个批次W200251132023010600002、W200274762023010600196已经产生耗用，所以入库、领料、出库数…
阅读更多...
栈的定义及基本操作实现（顺序栈）

栈的定义及基本操作实现（顺序栈）

个人主页&#xff1a;【&#x1f60a;个人主页】 系列专栏&#xff1a;【❤️数据结构与算法】 学习名言&#xff1a;天子重英豪&#xff0c;文章教儿曹。万般皆下品&#xff0c;惟有读书高 系列文章目录 第一章 ❤️ 学前知识 第二章 ❤️ 单向链表 第三章 ❤️ 递归 文章目录…
阅读更多...
面试问题之高并发内存池项目

面试问题之高并发内存池项目

项目部分 1.这个项目是什么? 高并发内存池的原型是谷歌一个开源项目&#xff0c;tcmalloc&#xff0c;而这个项目&#xff0c;就是tcmalloc中最核心的框架和部分拿出来进行模拟。他的作用就是在去代替原型的内存分配函数malloc和free。这个项目涉及的技术有&#xff0c;c&…
阅读更多...
探索LeetCode【0002】

探索LeetCode【0002】

题目在此【0002】两数相加 1、官方答案&#xff08;没搞懂&#xff09; https://leetcode.cn/problems/add-two-numbers/solution/liang-shu-xiang-jia-by-leetcode-solution/ /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *ne…
阅读更多...
数据结构——链表经典OJ题题解

数据结构——链表经典OJ题题解

前言 在学习了单链表这种数据结构后&#xff0c;便可以尝试去练习一些题目来巩固对这块知识点。练习这些题目还可以让我们提升代码能力和对指针有新的理解。 1. 移除链表元素 方法一 思路 通过两个指针变量来遍历整个链表。cur指针一开始指向链表的头结点&#xff0c;prev指…
阅读更多...
【链表】Leetcode 138. 复制带随机指针的链表

【链表】Leetcode 138. 复制带随机指针的链表

Halo&#xff0c;这里是Ppeua。平时主要更新C语言&#xff0c;C&#xff0c;数据结构算法......感兴趣就关注我吧&#xff01;你定不会失望。 &#x1f308;个人主页&#xff1a;主页链接 &#x1f308;算法专栏&#xff1a;专栏链接 我会一直往里填充内容哒&#xff01; &…
阅读更多...
[牛客算法总结]：链表相加(二)

[牛客算法总结]：链表相加(二)

标签&#xff1a; 链表、栈 题目&#xff1a; 假设链表中每一个节点的值都在 0 - 9 之间&#xff0c;那么链表整体就可以代表一个整数。 给定两个这种链表&#xff0c;请生成代表两个整数相加值的结果链表。 数据范围&#xff1a;0 \le n,m \le 10000000≤n,m≤1000000&#…
阅读更多...
【数据结构】第四站：单链表力扣题(一)

【数据结构】第四站：单链表力扣题(一)

目录 一、移除链表元素 二、链表的中间结点 三、链表中倒数第k个结点 四、反转链表 五、合并两个有序链表 六、分割链表 一、移除链表元素 题目描述&#xff1a;力扣 法一&#xff1a;直接循环依次判断 对于这个题目&#xff0c;我们最容易想到的一种思路就是&#xff0c…
阅读更多...
138. 复制带随机指针的链表-C语言

138. 复制带随机指针的链表-C语言

题目来源&#xff1a;力扣 题目描述&#xff1a; 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每…
阅读更多...
leetcode -- 876.链表的中间节点

leetcode -- 876.链表的中间节点

文章目录&#x1f428;1.题目&#x1f407;2. 解法1-两次遍历&#x1f340;2.1 思路&#x1f340;2.2 代码实现&#x1f401;3. 解法2-快慢指针&#x1f33e;3.1 思路&#x1f33e;3.2 **代码实现**&#x1f42e;4. 题目链接&#x1f428;1.题目 给你单链表的头结点head&#…
阅读更多...
【链表OJ题(九)】环形链表延伸问题以及相关OJ题

【链表OJ题(九)】环形链表延伸问题以及相关OJ题

环形链表OJ题 1. 环形链表 链接&#xff1a;141. 环形链表 描述&#xff1a; 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&…
阅读更多...
【数据结构】Java实现双向链表

【数据结构】Java实现双向链表

目录 1. 接口的实现 2. 动手实现双链表 2.1 重写SeqList接口方法 2.2 在当前链表尾部添加节点&#xff08;尾插&#xff09; 2.3 在当前链表头部添加节点&#xff08;头插&#xff09; 2.4 检验index是否合法 2.5 在 第index位置添加节点&#xff08;任意位置&#xff09; 2.6 …
阅读更多...
Java每日一练(20230320)

Java每日一练(20230320)

目录 1. 两数之和 &#x1f31f;&#x1f31f; 2. 盛最多水的容器 &#x1f31f;&#x1f31f; 3. 反转链表 II &#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Golang每日一练 专栏 Python每日一练 专栏 C/C每日一练 专栏 Java每日一练 专栏 1. 两数…
阅读更多...
Leetcode707. 设计链表

Leetcode707. 设计链表

题目 Leetcode707. 设计链表 你可以选择使用单链表或者双链表&#xff0c;设计并实现自己的链表。 单链表中的节点应该具备两个属性&#xff1a;val 和 next 。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。 如果是双向链表&#xff0c;则还需要属性 pr…
阅读更多...
【数据结构】千字深入浅出讲解队列（附原码 | 超详解）

【数据结构】千字深入浅出讲解队列（附原码 | 超详解）

&#x1f680;write in front&#x1f680; &#x1f4dd;个人主页&#xff1a;认真写博客的夏目浅石. &#x1f381;欢迎各位→点赞&#x1f44d; 收藏⭐️ 留言&#x1f4dd; &#x1f4e3;系列专栏&#xff1a;C语言实现数据结构 &#x1f4ac;总结&#xff1a;希望你看完…
阅读更多...
【1019. 链表中的下一个更大节点】

【1019. 链表中的下一个更大节点】

来源&#xff1a;力扣&#xff08;LeetCode&#xff09; 描述&#xff1a; 给定一个长度为 n 的链表 head 对于列表中的每个节点&#xff0c;查找下一个 更大节点 的值。也就是说&#xff0c;对于每个节点&#xff0c;找到它旁边的第一个节点的值&#xff0c;这个节点的值 严…
阅读更多...
实验一：第五题循环链表的应用（约瑟夫回环问题）

实验一：第五题循环链表的应用（约瑟夫回环问题）

n个数据元素构成一个环&#xff0c;从环中任意位置开始计数&#xff0c;计到m将该元素从表中取出&#xff0c;重复上述过程&#xff0c;直至表中只剩下一个元素。 提示&#xff1a;用一个无头结点的循环单链表来实现n个元素的存储。 参考代码&#xff1a; #include<stdio…
阅读更多...
链表篇总结

链表篇总结

移除链表元素&#xff1a; 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 思路&#xff1a; 这里以链表 1 4 2 4 来举例&#xff0c;移除元素4。 那么因为单链表的特殊性&#xff0c;只…
阅读更多...
算数大法之神算宝典

算数大法之神算宝典

公式 常数 整型最大值 Integer.MAX_VALUE 整型最小值 Integer.MIN_VALUE 构造栈 Stack<TreeNode> stack new Stack<>() 构造队列 Queue<TreeNode> queue new LinkedList<TreeNode>() 循环链表的入口&#xff0c;如图所示&#xff1a; 假设从头…
阅读更多...
链表实现学生信息管理（C语言）

链表实现学生信息管理（C语言）

文章目录SList.h文件main.c文件SList.c文件用链表实现学生信息管理。这里放一下有哪些文件。 下面是具体代码实现。 SList.h文件 #pragma once防止库函数的重复引用&#xff0c;因为库函数会在预编译的时候在程序中展开&#xff0c;会增大程序的体积。   通过typedef对数据…
阅读更多...
c语言数据结构——链表的实现及其基本操作

c语言数据结构——链表的实现及其基本操作

前言 顺序表的问题及思考 问题&#xff1a; 中间/头部的插入删除&#xff0c;时间复杂度为O(N)增容需要申请新空间&#xff0c;拷贝数据&#xff0c;释放旧空间。会有不小的消耗。增容一般是呈2倍的增长&#xff0c;势必会有一定的空间浪费。例如当前容量为100&#xff0c;满…
阅读更多...
回文链表问题

回文链表问题

234. 回文链表 - 力扣&#xff08;LeetCode&#xff09; 递归方案 void traverse(ListNode* head) {// 前序遍历代码traverse(head->next);// 后序遍历代码 }链表兼具递归结构&#xff0c;树结构不过是链表的衍生。链表其实也可以有前序遍历和后序遍历 如果我想正序打印链…
阅读更多...
STL序列式容器array、vector、deque、list 和 forward list

STL序列式容器array、vector、deque、list 和 forward list

目录 array begin()/end() 和 cbegin()/cend() rbegin()/rend() 和 crbegin()/crend() vector 创建vector容器的几种方式 emplace_back()和push_back()的区别 insert() emplace() deque 创建deque容器的几种方式 list list容器的创建 list容器可用的成员函数 list…
阅读更多...
114. 二叉树展开为链表 Python

114. 二叉树展开为链表 Python

文章目录一、题目描述示例 1示例 2示例 3二、代码三、解题思路一、题目描述 给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左子指针始终…
阅读更多...
线性表和链表的优缺点

线性表和链表的优缺点

线性表和链表的优缺点 1. 顺序存储结构的优缺点 优点&#xff1a; 线性表逻辑上相邻&#xff0c;物理上也相邻&#xff0c;可随机存取任意元素。 缺点&#xff1a; 线性表插入、删除操作需要移动大量元素 存储空间是预分配的&#xff0c;不灵活&#xff0c;空间浪费&#xff0…
阅读更多...
约瑟夫问题

约瑟夫问题

约瑟夫问题是一个经典的数学问题&#xff0c;也是计算机科学中常见的数据结构和算法题目之一。它的形式是&#xff1a;有n个人站成一排&#xff0c;从第一个人开始报数&#xff0c;每次报到m的人出列&#xff0c;直到所有人都出列为止。请问&#xff0c;最后留下的人原来在什么…
阅读更多...
07.LinkedList与链表

07.LinkedList与链表

1. ArrayList的缺陷 通过源码知道&#xff0c;ArrayList底层使用数组来存储元素&#xff1a; public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable {// ... // 默认容量是10private sta…
阅读更多...
Java基础——Set集合实现类

Java基础——Set集合实现类

&#xff08;1&#xff09;Set集合实现类特点&#xff1a; HashSet&#xff1a;无序&#xff0c;不重复&#xff0c;无索引。LinkedHashSet&#xff1a;有序&#xff0c;不重复&#xff0c;无索引。TreeSet&#xff1a;排序&#xff0c;不重复&#xff0c;无索引。&#xff08…
阅读更多...
【数据结构】栈和队列（笔记总结）

【数据结构】栈和队列（笔记总结）

&#x1f466;个人主页&#xff1a;Weraphael ✍&#x1f3fb;作者简介&#xff1a;目前学习C和算法 ✈️专栏&#xff1a;数据结构 &#x1f40b; 希望大家多多支持&#xff0c;咱一起进步&#xff01;&#x1f601; 如果文章对你有帮助的话 欢迎 评论&#x1f4ac; 点赞&…
阅读更多...
代码随想录算法训练营第四天| 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 142.环形链表II

代码随想录算法训练营第四天| 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 142.环形链表II

接了个活&#xff0c;搞得我今天没赶上打卡&#xff0c;根本没时间写 24. 两两交换链表中的节点题目加卡哥讲解链接卡哥画的图一开始我没反应过来&#xff0c;后来才发现真香所以这个题的关键就是画图&#xff0c;把步骤一步一步的标出来&#xff0c;完成每步的时候&#xff0c…
阅读更多...
21. 合并两个有序链表(Java)

21. 合并两个有序链表(Java)

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4] 示例 2&#xff1a; 输入&#xff1a;l1 [], l2 [] 输出&#xff1a;[] …
阅读更多...
什么是链表

什么是链表

1.数组的存储方式和缺点 1、数组的存储特点&#xff1a;在一个连续的内存空间里面&#xff0c;存放着某些特点的数据&#xff0c;把这些数据集合在某个内存空间中。 数组非常明确的特点是&#xff1a;数组是一个整体&#xff0c;每一个元素的地址是连续的。结构体其实也类似&…
阅读更多...
【LeetCode每日一题: 1019. 链表中的下一个更大节点 | 单调栈 】

【LeetCode每日一题: 1019. 链表中的下一个更大节点 | 单调栈 】

&#x1f34e;作者简介&#xff1a;硕风和炜&#xff0c;CSDN-Java领域新星创作者&#x1f3c6;&#xff0c;保研|国家奖学金|高中学习JAVA|大学完善JAVA开发技术栈|面试刷题|面经八股文|经验分享|好用的网站工具分享&#x1f48e;&#x1f48e;&#x1f48e; &#x1f34e;座右…
阅读更多...
【纺丝和DTY的AA率说明】

【纺丝和DTY的AA率说明】

1、POY AA率计算方法 POY AA率＝POY外观等级AA等级重量/POY总重量 POY外观等级AA等级重量；丝锭记录表中每日外观等级为AA的POY总重量 POY总重量；丝锭记录表中当天POY的总重量 数据来源：丝锭记录表 路径：朗通MES→基础数据→丝锭记录表 需根据物料描述前三位字段区分P…
阅读更多...
剑指 Offer II 024. 反转链表（经典题型）

剑指 Offer II 024. 反转链表（经典题型）

时间是伟大的作者&#xff0c;她能写出未来的结局。 ——卓别林 目录 题目描述&#xff1a; 方法1&#xff1a;迭代法&#xff08;翻指针&#xff09; 方法2&#xff1a;头插法 方法3&#xff1a;递归法 题目描述&#xff1a; 给定单链…
阅读更多...
代码随想录【链表】---＞删除倒数第N个节点、链表相交、环形链表

代码随想录【链表】---＞删除倒数第N个节点、链表相交、环形链表

⭐️代码随想录⭐️ 数组篇: 二分查找 移除数组 有序数组的平方 长度最小的数组 螺旋矩阵 链表篇&#xff1a; 链表移除 设计链表 反转链表 交换链表中的节点 文章目录19. 删除链表的倒数第 N 个结点思路代码面试题 02.07. 链表相交思路代码142. 环形链表 II思路判断链表有环确…
阅读更多...
PTA团体天梯赛训练集题解L2（完整注释思路解法）

PTA团体天梯赛训练集题解L2（完整注释思路解法）

PTA团体天梯赛训练集题解L2（完整注释思路解法） L2-002 链表去重 (25 分) 给定一个带整数键值的链表 L，你需要把其中绝对值重复的键值结点删掉。即对每个键值 K，只有第一个绝对值等于 K 的结点被保留。同时，所有被删除的结点须被保存在另一个链表上。例如给定 L 为 21→-…
阅读更多...
【牛客刷题专栏】0x19:JZ18 删除链表的节点(C语言编程题)

【牛客刷题专栏】0x19:JZ18 删除链表的节点(C语言编程题)

前言 个人推荐在牛客网刷题(点击可以跳转)&#xff0c;它登陆后会保存刷题记录进度&#xff0c;重新登录时写过的题目代码不会丢失。个人刷题练习系列专栏&#xff1a;个人CSDN牛客刷题专栏。 题目来自&#xff1a;牛客/题库 / 在线编程 / 剑指offer&#xff1a; 目录前言问题…
阅读更多...
【数据结构】哈希表详解以及代码实现

【数据结构】哈希表详解以及代码实现

目录 1.来源&#xff1a; 2.哈希函数 1.哈希函数的设计规则 2.哈希函数的设计思路 3.哈希碰撞 4.解决哈希碰撞的方案 5.负载因子 3.基于开散列方案的HashMap实现 1.HashMap类中的属性 2.哈希函数 3.判断当前哈希表中是否含有指定的key值 4.判断当前哈希表中是否包含…
阅读更多...
容器-LinkedList

容器-LinkedList

LinkedList LinkedList的概述 LinkedList的底层使用双向链表实现。 链表是一种线性数据结构&#xff0c;其中每个元素都是一个单独的对象&#xff0c;包含一个指向列表中下一个节点的引用。 它可以用于实现各种抽象数据类型&#xff0c;例如列表、堆栈、队列等。 LinkedLis…
阅读更多...
C语言-数据结构与算法-详细全面的链表知识总结归纳

C语言-数据结构与算法-详细全面的链表知识总结归纳

C语言链式存储结构的详细讲解一.前言(为什么要使用链式存储)一.单链表1.单链表的结点描述2.单链表基本操作(1)初始化单链表(2)采用头插法建立单链表(带头结点)(3).采用尾插法建立单链表(4)按照位序查找结点(4)在链表中间插入结点(5)删除第i个结点二.双链表1.双链表的结点类型描…
阅读更多...
LeetCode热题HOT100：单词拆分、环形链表 II、LRU 缓存

LeetCode热题HOT100：单词拆分、环形链表 II、LRU 缓存

LeetCode热题HOT100 139. 单词拆分 题目&#xff1a;给你一个字符串 s 和一个字符串列表 wordDict 作为字典。请你判断是否可以利用字典中出现的单词拼接出 s 。 注意&#xff1a;不要求字典中出现的单词全部都使用&#xff0c;并且字典中的单词可以重复使用。 示例 1&#xf…
阅读更多...
【链表】力扣203题：移除链表元素

【链表】力扣203题：移除链表元素

【链表】力扣203题&#xff1a;移除链表元素 力扣203题&#xff1a;移除链表元素 建议在看题目之前先了解数组的具体知识点&#xff0c;可以看这里&#xff1a; 算法基础&#xff08;三&#xff09;&#xff1a;链表知识点及题型讲解。 力扣203题&#xff1a;移除链表元素 给…
阅读更多...
4. 线性表

4. 线性表

4. 线性表 线性表是最基本、最简单、也是最常用的一种数据结构(逻辑结构)。一个线性表是n个具有相同特性的数据元素的有限序列。 前驱元素&#xff1a; 若A元素在B元素的前面&#xff0c;则称A为B的前驱元素 后继元素&#xff1a; 若B元素在A元素的后面&#xff0c;则称B为…
阅读更多...
集合-LinkedList

集合-LinkedList

LinkedList LinkedList的概述 LinkedList的底层使用双向链表实现。 链表是一种线性数据结构&#xff0c;其中每个元素都是一个单独的对象&#xff0c;包含一个指向列表中下一个节点的引用。 它可以用于实现各种抽象数据类型&#xff0c;例如列表、堆栈、队列等。 LinkedLis…
阅读更多...
数据结构刷题笔记 | 数组、字符串、链表、栈、队列、数、图

数据结构刷题笔记 | 数组、字符串、链表、栈、队列、数、图

本篇为笔者学习数据结构时&#xff0c;在牛客网站的刷题笔记。 数据结构分为&#xff1a; 逻辑结构【面向问题的】 集合结构线性结构&#xff08;一对一&#xff09;树形结构&#xff08;一对多的层次关系&#xff09;图形结构&#xff08;多对多&#xff09; 物理结构&#x…
阅读更多...
＜数据结构＞ 链表 - 单链表（c语言实现）

＜数据结构＞ 链表 - 单链表（c语言实现）

B.最简单结构的链表——不带哨兵位单链表的实现&#xff08;关于哨兵位结点&#xff09; 一、不带哨兵位单链表结点的创建1.1 typedef 链表的数据类型 1.2 结点的结构体创建 二、单链表要实现的功能 三、需要包含的头文件四、函数接口一览为什么有些函数参数传递的是二级指针&a…
阅读更多...
【快乐手撕LeetCode题解系列】——移除链表元素

【快乐手撕LeetCode题解系列】——移除链表元素

【【快乐手撕LeetCode题解系列】——移除链表元素&#x1f60e;前言&#x1f64c;删除有序数组中的重复项&#x1f64c;解法一&#xff1a;画图分析&#xff1a;&#x1f60d;思路分析&#xff1a;&#x1f60d;源代码分享&#xff1a;&#x1f60d;解法二&#xff1a;画图分析…
阅读更多...
数据结构入门（C语言版）栈和队列之栈的介绍及实现

数据结构入门（C语言版）栈和队列之栈的介绍及实现

栈栈的概念栈的实现过程栈的结构体与接口的定义1、静态栈结构2、动态栈结构3、栈的接口定义栈的接口实现①初始化栈(StackInit)②入栈(StackPush)③出栈(StackPop)④栈顶(StackTop)⑤栈元素个数(StackSize)⑥检测栈是否为空(StackEmpty)⑦销毁栈(StackDestroy)结语栈的概念 栈…
阅读更多...
如何合并多个升序链表？

如何合并多个升序链表？

前言 本文主要介绍如何将多个小的升序链表合并一个大的升序链表。 需求描述 给出K个升序链接&#xff0c;要求把这K个升序链表合并成一个&#xff0c;并且这个链表也是升序的。 例如&#xff1a;A [1,5,6]&#xff0c; B [2,3,8], C [4,4,9] 将这3个链表合并成一个链表D…
阅读更多...
判断环形链表是否有环？？返回环形链表的入口点

判断环形链表是否有环？？返回环形链表的入口点

给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;…
阅读更多...
Java——合并两个排序的链表

Java——合并两个排序的链表

题目链接 牛客在线oj题——合并两个排序的链表 题目描述 输入两个递增的链表&#xff0c;单个链表的长度为n&#xff0c;合并这两个链表并使新链表中的节点仍然是递增排序的。 数据范围&#xff1a; 0≤n≤1000&#xff0c;−1000≤节点值≤1000 要求&#xff1a;空间复杂…
阅读更多...
【单链表】的增删查改

【单链表】的增删查改

&#x1f58a;作者 : Djx_hmbb &#x1f4d8;专栏 : 数据结构 &#x1f606;今日分享 : “Onc in a blu moon” : “罕见的,千载难逢的” (出现在19世纪,指的是"在一个月内出现的第二次圆月”&#xff0c;这种现象每隔32个月发生一次。) 文章目录✔单链表的功能实现:&…
阅读更多...
刷完这篇文章，再也不怕链表啦！

刷完这篇文章，再也不怕链表啦！

刷完这篇文章&#xff0c;再也不怕链表啦&#xff01;寻找单链表的倒数第 k 个节点删除链表的倒数第 N 个结点旋转链表寻找单链表的中点删除链表中的节点删除链表的中间节点判断单链表是否包含环回文链表合并两个有序链表合并 k 个有序链表链表的分解反转链表反转链表 IIK 个一…
阅读更多...
十五周算法训练营——链表专题

十五周算法训练营——链表专题

今天是十五周算法训练营的第三周&#xff0c;主要讲链表专题&#xff0c;包含&#xff1a;反转链表、移除链表、交换链表、链表相交、删除链表中的倒数第N个节点、环形链表II。&#xff08;欢迎加入十五周算法训练营&#xff0c;与小伙伴一起卷算法——文章末尾进群&#xff09…
阅读更多...
数据结构三叉链表与线索二叉树的思路与实现详解

数据结构三叉链表与线索二叉树的思路与实现详解

❤️作者主页&#xff1a;微凉秋意 ✅作者简介&#xff1a;后端领域优质创作者&#x1f3c6;&#xff0c;CSDN内容合伙人&#x1f3c6;&#xff0c;阿里云专家博主&#x1f3c6; 文章目录前言1、三叉链表思路与具体实现1.1、思路1.2、代码实现2、三种线索二叉树的实现2.1、中序…
阅读更多...
算法刷题总结 (七) 双指针

算法刷题总结 (七) 双指针

算法总结7 双指针一、双指针的概念1.1、什么是双指针&#xff1f;1.2、常见类型1.2.1、快慢指针1.2.2、左右端点指针1.2.3、区间指针 - 滑动窗口汇总二、经典例题2.1、快慢指针&#xff08;1&#xff09;、链表判环141. 环形链表142. 环形链表 II287. 寻找重复数876. 链表的中间…
阅读更多...
二叉排序树的插入和删除操作（python实现）

二叉排序树的插入和删除操作（python实现）

二叉排序树的插入和删除操作都是在保持二叉排序树特性的前提下进行的。 插入操作&#xff1a; 在二叉排序树中插入一个新节点时&#xff0c;先比较新节点的值和当前节点的值的大小关系&#xff0c;若小于当前节点&#xff0c;则继续在当前节点的左子树中查找&#xff1b;若大…
阅读更多...
双向带头循环链表的实现

双向带头循环链表的实现

双向带头循环链表 双向带头循环链表结构讲解期望实现功能创建链表和头节点作用头插和头删头插头删 尾插与尾删尾插尾删 pos 删除和插入插入删除 打印和查找 整体代码 这个数据结构可以算是YYDS的存在了。 我们前面讲过的单链表&#xff0c;尾删和尾插需要遍历数组&#xff0c;极…
阅读更多...
STL : 栈 stack 与 队列 queue

STL : 栈 stack 与 队列 queue

Stack #include<stack> using namespace std; 栈&#xff1a;LIFO&#xff0c;先进后出&#xff1b; 不允许遍历&#xff0c;仅仅一个出口&#xff0c;只有栈顶元素可被访问到。 Member functions NameRoleNotice&#xff08;constructor&#xff09;基本构造函数指…
阅读更多...
C语言实现链表--数据结构

C语言实现链表--数据结构

魔王的介绍&#xff1a;&#x1f636;‍&#x1f32b;️一名双非本科大一小白。魔王的目标&#xff1a;&#x1f92f;努力赶上周围卷王的脚步。魔王的主页&#xff1a;&#x1f525;&#x1f525;&#x1f525;大魔王.&#x1f525;&#x1f525;&#x1f525; ❤️‍&#x1…
阅读更多...
图形化之家谱遗传系统

图形化之家谱遗传系统

1&#xff1a;废话不多说先看成果。 QQ录屏20230418163603 QQ录屏20230418163732 2&#xff1a;解析&#xff1a; 1&#xff1a;不知道会有多少个孩子&#xff0c;所以我们用二叉树的孩子兄弟结构 typedef struct treeNode {char name[100];//名字int generation;//辈分char g…
阅读更多...
Redis数据结构与对象-链表和字典

Redis数据结构与对象-链表和字典

1、链表 其实个人感觉redis的链表内容和其他的差不多。就是一个listNode结构&#xff0c;里面又指向前置节点和后置节点的指针。 然后redis链表可以保存各种不同类型的值。 链表被广泛用于实现redis的各种功能&#xff0c;比如列表键、发布与订阅、慢查询、监视器等。 2、字典…
阅读更多...
【力扣-JZ22】链表中倒数第k个结点

【力扣-JZ22】链表中倒数第k个结点

&#x1f58a;作者 : Djx_hmbb &#x1f4d8;专栏 : 数据结构 &#x1f606;今日分享 : "把手插进米堆的原因 " : 因为米堆类似于高密度的流体&#xff0c;会给人的手带来较大的压强&#xff0c;这种压强促进静脉血回流&#xff0c;会让人感到生理上的舒服。 文章目…
阅读更多...
详解c++---list模拟实现

详解c++---list模拟实现

目录标题 list的准备工作构造函数push_backlist迭代器beginendinserteraseclearconst迭代器list迭代器区间构造swap现代拷贝构造函数现代赋值重载sizeempty->重载 list的准备工作 首先我们知道list是一个带头双向链表&#xff0c;他的数据就会存储在一个一个的节点里面&…
阅读更多...
【数据结构】超详细之单向链表（C语言实现）

【数据结构】超详细之单向链表（C语言实现）

文章目录 前言一、单向链表是什么&#xff1f;二、单向链表实现步骤 1.打印链表数据以及实现链表头插2.实现链表尾插3.实现链表头删尾删4.实现链表查找5.实现链表在pos之前/之后插入6.实现链表删除pos位置的值7.实现链表删除pos之后位置的值总结 前言 今天我要介绍单向链表&am…
阅读更多...
leetcode146. LRU Cache

leetcode146. LRU Cache

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类&#xff1a; LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中&#xff0c;则返回关键字的值&#xff0c;否则返回 -1 …
阅读更多...
如何用链表实现LRU缓存淘汰算法

如何用链表实现LRU缓存淘汰算法

链表学习 一、 缓存1.1缓存介绍1.2 缓存策略 二、链表结构2.1 单链表2.2 循环链表2.3 双向链表2.4 双向循环链表2.5 链表与数组性能对比 三、如何基于链表实现LRU缓存淘汰算法 一、 缓存 1.1缓存介绍 缓存是一种提高数据读取性能的技术&#xff0c;在硬件设计、软件开发中都有…
阅读更多...
看完这篇文章你就彻底懂啦｛保姆级讲解｝-----（LeetCode刷题142环形链表II） 2023.4.24

看完这篇文章你就彻底懂啦｛保姆级讲解｝-----（LeetCode刷题142环形链表II） 2023.4.24

目录 前言算法题&#xff08;LeetCode刷题142环形链表II&#xff09;—&#xff08;保姆级别讲解&#xff09;分析题目&#xff1a;算法思想环形链表II代码&#xff1a;补充 结束语 前言 本文章一部分内容参考于《代码随想录》----如有侵权请联系作者删除即可&#xff0c;撰写…
阅读更多...
数据结构（顺序结构、链式结构、索引结构、散列结构）

数据结构（顺序结构、链式结构、索引结构、散列结构）

文章目录 1.概述2.数据间逻辑关系3.数据的存储结构&#xff08;或物理结构&#xff09;3.1顺序结构3.2链式结构3.3索引结构3.4散列结构 4.运算结构 1.概述 数据结构&#xff0c;就是一种程序设计优化的方法论&#xff0c;研究数据的逻辑结构和物理结构以及它们之间相互关系&am…
阅读更多...
【软考备战·希赛网每日一练】2023年5月4日

【软考备战·希赛网每日一练】2023年5月4日

文章目录 一、今日成绩二、错题总结第一题第二题第三题第四题三、知识查缺 题目及解析来源&#xff1a;2023年05月04日软件设计师每日一练 一、今日成绩 二、错题总结 第一题 解析&#xff1a; 修改Linux文件权限命令&#xff1a;chmod。 第二题 解析&#xff1a; 第三题 解析…
阅读更多...
【算法Hot100系列】合并两个有序链表

【算法Hot100系列】合并两个有序链表

💝💝💝欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学习,不断总结,共同进步,活到老学到老导航 檀越剑指大厂系列:全面总结 jav…
阅读更多...
【力扣每日一题】力扣83删除排序链表中的重复元素

【力扣每日一题】力扣83删除排序链表中的重复元素

题目来源 力扣83删除排序链表中的重复元素 题目描述 给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的链表 。 思路分析 思路一&#xff1a;使用两个指针&#xff0c;last指针指向上一个元素&#xff0c;…
阅读更多...
代码随想录 Leetcode142. 环形链表 II

代码随想录 Leetcode142. 环形链表 II

题目&#xff1a; 代码(首刷看解析 2024年1月13日&#xff09;&#xff1a; class Solution { public:ListNode *detectCycle(ListNode *head) {if (head nullptr) return nullptr;ListNode* fast head;ListNode* slow head;while (true) {if(fast->next nullptr || fa…
阅读更多...
基于面向对象，C++实现双链表

基于面向对象，C++实现双链表

双链表同单链表类似&#xff0c;由一个值和两个指针组成 Node.h节点头文件 #pragma once class Node { public:int value;Node* prev;Node* next;Node(int value);~Node(); };Node.cpp节点源文件 #include "Node.h"Node::Node(int value) {this->value value…
阅读更多...
数据结构学习之单向循环链表应用的案例（旋转链表）

数据结构学习之单向循环链表应用的案例（旋转链表）

实例要求&#xff1a; 1、给定一个链表的头节点 head &#xff0c;请你旋转链表&#xff0c;将链表每个节点向右移动 k 个位置&#xff1b; 2、链表中节点的数目的范围为[0, 500] &#xff1b; 实例分析&#xff1a; 1、入参合理性检查&#xff0c;即head ! NULL || head-&…
阅读更多...
链接未来：深入理解链表数据结构（一.c语言实现无头单向非循环链表）

链接未来：深入理解链表数据结构（一.c语言实现无头单向非循环链表）

在上一篇文章中&#xff0c;我们探索了顺序表这一基础的数据结构&#xff0c;它提供了一种有序存储数据的方法&#xff0c;使得数据的访 问和操作变得更加高效。想要进一步了解&#xff0c;大家可以移步于上一篇文章&#xff1a;探索顺序表&#xff1a;数据结构中的秩序之美 今…
阅读更多...
C/C++ BM1反转链表

C/C++ BM1反转链表

文章目录 前言题目1.解决方案一1.1 思路阐述1.2 源码 2. 解决方案二2.1 思路阐述2.2 源码 总结 前言 这题是牛客网的BM1&#xff0c;主要涉及到链表的操作以及栈数据结构的使用。 题目 给定一个单链表的头结点pHead(该头节点是有值的&#xff0c;比如在下图&#xff0c;它的…
阅读更多...
leetcode 142 环形链表II

leetcode 142 环形链表II

题目 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使…
阅读更多...
单链表与循环链表创建

单链表与循环链表创建

链表 struct List {int data;struct List* next; }创建链表 单链表 实现 struct List* listCreate() {int data;struct List* head NULL;struct List* pre NULL;struct List* current NULL;while(scanf("%d",&data) && data ! -1){current (stru…
阅读更多...
链表存数相加算法(leetcode第2题)

链表存数相加算法(leetcode第2题)

题目描述&#xff1a; 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外&#xff0c;这…
阅读更多...
【每日一题】LeetCode141.环形链表

【每日一题】LeetCode141.环形链表

个人主页&#xff1a;白日依山璟 专栏&#xff1a;Java|数据结构与算法|每日一题 文章目录 1. 题目描述示例1&#xff1a;示例2&#xff1a;示例3&#xff1a;提示: 2. 思路3. 代码 1. 题目描述 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某…
阅读更多...
算法竞赛基础：C++双向链表的结构和实现（普通链表、List、静态链表）

算法竞赛基础：C++双向链表的结构和实现（普通链表、List、静态链表）

算法竞赛基础&#xff1a;双向链表 本文将会介绍在算法竞赛中双向链表的几种使用方式&#xff0c;适合有一定基础的人阅读。 双向链表的结构 一般来说&#xff0c;普通的链表结构是这样的&#xff1a; struct node {int num;node *next; }next指针指向下一个链表&#xff…
阅读更多...
linkindList源码分析

linkindList源码分析

前言 LinkedList &#xff0c;基于节点实现的双向链表的 List &#xff0c;每个节点都指向前一个和后一个节点从而形成链表。 LinkedList集合同时具有List集合和Queue集合的基本特征 类图 如下 1 个接口是少于 ArrayList 的&#xff1a; java.util.RandomAccess 接口&#xff…
阅读更多...
ArrayList的扩容机制

ArrayList的扩容机制

前置知识 ArrayList的底层实现是一个Object[]&#xff0c;而LinkedList的底层实现是一个链表 ArrayList与LinkedList相对比&#xff1a; ArrayList在随机访问时可以做到O(1)&#xff0c;但是LinkedList的随机访问就是遍历链表&#xff0c;所以时间复杂度是O(N)ArrayList在插入…
阅读更多...
块状链表实现BigString大字符串操作（golang）

块状链表实现BigString大字符串操作（golang）

前言 块状链表是介于链表和数组之间的数据结构&#xff0c;能够在 O ( n ) O(\sqrt{n}) O(n ​)时间内完成插入、删除、访问操作。 数据结构如图所示。假设最大容量为 n n n, 则它有一个长度为 s n s\sqrt{n} sn ​的链表。链表中每个结点是一个长度为 2 n 2 \times \sqrt{…
阅读更多...
[蓝桥杯2023初赛] 整数删除

[蓝桥杯2023初赛] 整数删除

给定一个长度为 N 的整数数列&#xff1a;A1, A2, ... , AN。你要重复以下操作 K 次&#xff1a; 每次选择数列中最小的整数&#xff08;如果最小值不止一个&#xff0c;选择最靠前的&#xff09;&#xff0c;将其删除。 并把与它相邻的整数加上被删除的数值。 输出 K 次操作后…
阅读更多...
【每日一题】leetcode21 - - 合并两个有序链表

【每日一题】leetcode21 - - 合并两个有序链表

文章目录 1.题目描述2.解题思路方法1&#xff1a;方法2&#xff1a; 1.题目描述 题目链接&#xff1a;力扣21&#xff0c;合并两个有序链表 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 2.解题思路 方法1&#xff1a;…
阅读更多...
初阶数据结构之带头+双向+循环链表增删查实现（三）

初阶数据结构之带头+双向+循环链表增删查实现（三）

文章目录 [TOC](文章目录) 前言一、带头双向循环链表的初始化1.1带头双向循环链表的结构体定义1.2初始化代码的实现 二、带头双向循环链表的增功能实现2.1头插代码的实现2.2尾插代码的实现 三、带头双向循环链表的打印功能实现3.1打印代码的实现 四、带头双向循环链表删功能实现…
阅读更多...
四、c++学习（类的简介）

四、c++学习（类的简介）

上一篇我们做了一个简单的界面优化&#xff0c;并且我们可以选择进入游戏界面&#xff0c;所以这一篇我们来实现贪吃蛇和食物。 C学习&#xff0c;b站直播视频 文章目录 4.0 课程目标4.1 结构体4.1.1 c语言面向对象4.1.2 c的结构体4.1.3 内存对齐 4.2 union4.2.1 union应用&am…
阅读更多...
代码随想录 LeetCode链表篇 Java

代码随想录 LeetCode链表篇 Java

文章目录 &#xff08;简单&#xff09;203. 移除链表元素&#xff08;中等&#xff09;707. 设计链表&#xff08;简单&#xff09;206. 反转链表&#xff08;中等&#xff09;24. 两两交换链表中的节点&#xff08;中等&#xff09;19. 删除链表的倒数第 N 个结点&#xff08…
阅读更多...
C++ 基础STL-list容器

C++ 基础STL-list容器

STL-list 容器&#xff0c;又称双向链表容器&#xff0c;即该容器的底层是以双向链表的形式实现的。这意味着&#xff0c;list 容器中的元素可以分散存储在内存空间里&#xff0c;而不是必须存储在一整块连续的内存空间中。 链表的优点&#xff1a;可以对任意位置进行快速插入和…
阅读更多...
【数据结构】栈及其实现

【数据结构】栈及其实现

目录 &#x1f920;前言 什么是栈&#xff1f; 栈的定义及初始化 栈的定义 栈的初始化 栈的判空 栈顶压栈 栈顶出栈 栈的数据个数 栈的销毁 完整代码 总结 &#x1f920;前言 学了相当长一段时间的链表&#xff0c;总算是跨过了一个阶段。从今天开始我们将进入栈和…
阅读更多...
二叉搜索树、AVL树、红黑树底层源码以及迭代器模拟实现，map/set的封装

二叉搜索树、AVL树、红黑树底层源码以及迭代器模拟实现，map/set的封装

这次给大家分享的还是关于二叉树部分的内容&#xff0c;之前的文章已经分享过一些二叉树的基础知识&#xff0c;如果不了解的朋友可以看看&#xff1a;二叉树以及堆和堆排序。普通的二叉树其实是没有什么实际的应用价值的&#xff0c;而map和set大家用过或者听过吗&#xff1f;…
阅读更多...
LeetCode_Day3 | 反转链表/移除链表的元素/设计个链表

LeetCode_Day3 | 反转链表/移除链表的元素/设计个链表

LeetCode_链表 203.移除链表元素1. 题目描述2. 直接使用原表删除1. 思路2. 代码实现 3. 使用虚拟头节点删除1. 思路2. 代码实现 707.设计链表1.题目描述2.单链表&#xff1a;虚拟头节点设计1. 思路2. 代码实现及部分逻辑解释3. 需要注意的点 206.反转链表1.题目描述2. 双指针法…
阅读更多...
单链表（增、删、查、改）的详细介绍 必看！！！

单链表（增、删、查、改）的详细介绍 必看！！！

文章目录 链表介绍单链表初始化单链表打印增加节点单链表的头插单链表的尾插在给定位置之后插入在给定位置之前插入 删除节点单链表的头删单链表的尾删删除给定位置之后的节点删除给定位置处的节点 查找节点修改节点单链表销毁 链表介绍 链表是一种物理存储单元上非连续、非顺序…
阅读更多...
【数据结构】--- 几分钟走进栈和队列(详解-下)

【数据结构】--- 几分钟走进栈和队列(详解-下)

文章目录 前言&#x1f31f;一、队列的概念及结构&#xff1a;&#x1f31f;二、队列实现的两种方式&#xff1a;&#x1f31f;三、队列的实现&#xff1a;&#x1f30f;3.1队列结构&#xff1a;&#x1f30f;3.2初始化&#xff1a;&#x1f30f;3.3释放(类似单链表)&#xff1…
阅读更多...
【牛客网面试必刷TOP101】链表篇（一）

【牛客网面试必刷TOP101】链表篇（一）

【牛客网面试必刷TOP101】链表篇&#xff08;一&#xff09; 前言刷题网站刷题&#xff01;BM1 反转链表思路一&#xff1a;用栈解决思路二&#xff1a;双链表求解思路三&#xff1a;递归解决 总结 BM2 链表内指定区间反转思路一&#xff1a;头插法迭代思路二&#xff1a;递归 …
阅读更多...
【33.有效的数独】

【33.有效的数独】

请你判断一个 9 x 9 的数独是否有效。只需要 根据以下规则 &#xff0c;验证已经填入的数字是否有效即可。 数字 1-9 在每一行只能出现一次。 数字 1-9 在每一列只能出现一次。 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。&#xff08;请参考示例图&#xff09; …
阅读更多...
【数据结构】队列及其实现

【数据结构】队列及其实现

目录 &#x1f60e;前言 认识队列 队列的初始化 队列判空 数据队尾入队 数据队头出队 取队头数据 取队尾数据 队列数据的个数 队列销毁 总结 &#x1f60e;前言 上次我们学习了栈及其实现&#xff0c;当然也少不它的好兄弟队列啦&#xff0c;今天我们开始队列的学习队…
阅读更多...
irq_domain 负责的事情以及小组成员分担的任务

irq_domain 负责的事情以及小组成员分担的任务

文章目录 简介irq_domain 要做哪些事irq_desc 结构图irq_domain 小组的重要成员有哪些irq_domain 小组的重要成员解析irq_domain 的左膀右臂 irq_chip & irq_domain_opsirq_chip 分担了哪些工作irq_domain_ops 分担了哪些工作 其他成员分担了哪些工作 irq_desc 怎么与 irq …
阅读更多...
编织数据结构的艺术：双向带头循环链表的华丽实现

编织数据结构的艺术：双向带头循环链表的华丽实现

上一篇博客&#xff0c;我们了解并实现了单向不带头不循环链表&#xff0c;而本篇博客会讲解链表中的王者&#xff1a;双向带头循环链表。 概述 双向带头循环链表的特点是&#xff1a; 每个结点内部&#xff0c;既有指向上一个结点的前驱指针prev&#xff0c;也有指向下一个…
阅读更多...
【数据结构】数据结构概念 ( 数据结构中常见的存储结构 | 数据结构中常见的逻辑结构 )

【数据结构】数据结构概念 ( 数据结构中常见的存储结构 | 数据结构中常见的逻辑结构 )

文章目录 一、数据结构概念二、数据结构中常见的存储结构二、数据结构中常见的逻辑结构 一、数据结构概念 数据结构 是 计算机内存 中 组织 和 存储 数据 的方式 , 有以下两部分组成 : 逻辑结构 : 数据的存放形式 ;操作 : 数据如何操作 , 如 : 排序 , 查询 , 删除 , 增加 , 修…
阅读更多...
HashMap 的实现原理是什么，如何避免死锁

HashMap 的实现原理是什么，如何避免死锁

HashMap是一种常用的数据结构&#xff0c;其实现原理是使用了哈希表&#xff08;Hash Table&#xff09;来存储键值对。具体来说&#xff0c;它通过将键映射到一个数组索引来快速定位一个值。 在HashMap中&#xff0c;每个键值对都被称为Entry。每个Entry包含一个Key和一个Val…
阅读更多...
【数据结构】栈的详解

【数据结构】栈的详解

☃️个人主页&#xff1a;fighting小泽 &#x1f338;作者简介&#xff1a;目前正在学习C语言和数据结构 &#x1f33c;博客专栏&#xff1a;数据结构 &#x1f3f5;️欢迎关注&#xff1a;评论&#x1f44a;&#x1f3fb;点赞&#x1f44d;&#x1f3fb;留言&#x1f4aa;&…
阅读更多...
leetcode 2130. Maximum Twin Sum of a Linked List（链表的最大孪生和）

leetcode 2130. Maximum Twin Sum of a Linked List（链表的最大孪生和）

给出一个单向链表&#xff0c;第i 个node 和 第(n-1-i)个node称为twin. 0 < i < n/2 - 1 求所有twin的最大和。 链表长度为偶数。 思路&#xff1a; 链表长度为偶数&#xff0c;就省了不少步骤&#xff0c;不用再考虑奇数时中间那个node单独计算了。 直觉上来看&#x…
阅读更多...
Java中的基本容器知识你真的了解过吗？

Java中的基本容器知识你真的了解过吗？

前言&#xff1a;尽量使用简单易懂的通俗语言让大家初步了解各个重要的知识点。博学之&#xff0c;审问之&#xff0c;慎思之&#xff0c;明辨之&#xff0c;笃行之。 一、容器&#xff08;Collection&#xff09; Collection容器其实是用来存储独立元素的各种数据结构&#xf…
阅读更多...
leetcode：环形链表（详解）

leetcode：环形链表（详解）

前言&#xff1a;内容包括-题目&#xff0c;代码实现&#xff0c;大致思路&#xff0c;代码解读&#xff0c;拓展问题 题目&#xff1a; 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&…
阅读更多...
【Leetcode -19.删除链表的倒数第N个结点 -24.两两交换链表中的节点】

【Leetcode -19.删除链表的倒数第N个结点 -24.两两交换链表中的节点】

Leetcode Leetcode -19.删除链表的倒数第N个结点Leetcode - 24.两两交换链表中的节点 Leetcode -19.删除链表的倒数第N个结点 题目&#xff1a;给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;he…
阅读更多...
线性结构的存储类型

线性结构的存储类型

线性结构的存储类型 顺序标&#xff1a;顺序标就是数组&#xff0c;也成为向量vector、高维向量及称为张量即tensor 链表&#xff1a;单链表、双链表、循环链表 线性表概念 表目、文件、索引、表的长度、空表 线性表由节点表和关系表组成二元组&#xff1b; 节点集由有限的…
阅读更多...
leetcode：相交链表（详解）

leetcode：相交链表（详解）

前言&#xff1a;内容包括-题目&#xff0c;代码实现&#xff0c;大致思路&#xff0c;代码解读 题目&#xff1a; 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两…
阅读更多...
【C++初阶9-list实现】封装——我主沉浮，何不能至？

【C++初阶9-list实现】封装——我主沉浮，何不能至？

使用 翻阅文档即可。 是什么 带头双向循环链表。 实现 1. 类成员设计 template <class T> struct list_node {T _val;list_node* _next;list_node* _prev; };template <class T> class list { private:list_node<T> _head; };2. 类方法设计 namespace…
阅读更多...
【两个月算法速成】day04

【两个月算法速成】day04

本文以收录专题刷题记录 目录 24. 两两交换链表中的节点 题目链接 思路 代码 19. 删除链表的倒数第 N 个结点 题目链接 思路-双指针 代码 面试题 02.07. 链表相交 题目链接 思路 代码 24. 两两交换链表中的节点 题目链接 力扣 思路 建议使用虚拟节点&#xff0…
阅读更多...
【Leetcode -61.旋转链表 -82.删除排序链表中的重复元素Ⅱ】

【Leetcode -61.旋转链表 -82.删除排序链表中的重复元素Ⅱ】

Leetcode Leetcode -61.旋转链表Leetcode -82.删除排序链表中的重复元素Ⅱ Leetcode -61.旋转链表 题目&#xff1a;给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 示例 1&#xff1a; 输入&#xff1a;head [1, 2, 3, 4, …
阅读更多...
Leetcode202. 快乐数

Leetcode202. 快乐数

Every day a leetcode 题目来源&#xff1a;202. 快乐数 解法1&#xff1a;hash 根据几个例子&#xff0c;我们发现只有2种结果&#xff1a; 最终会得到1最终进入一个循环 其实得到1后&#xff0c;继续计算&#xff08;将该数替换为它每个位置上的数字的平方和&#xff09…
阅读更多...
Java每日一练(20230429)

Java每日一练(20230429)

目录 1. 二叉树的后序遍历 &#x1f31f;&#x1f31f; 2. 删除无效的括号 &#x1f31f;&#x1f31f;&#x1f31f; 3. 合并两个有序链表 &#x1f31f;&#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Golang每日一练 专栏 Python每日一练 专栏 C/C每…
阅读更多...
数据结构 | 常见的数据结构是怎样的？

数据结构 | 常见的数据结构是怎样的？

本文简单总结数据结构的概念及常见的数据结构种类 1’ 2。 更新&#xff1a;2023 / 04 / 05 数据结构 | 常见的数据结构是怎样的&#xff1f; 总览概念分类 常用的数据结构数组链表跳表栈队列树二叉树完全二叉树、满二叉树 平衡二叉树单旋转左旋右旋 红黑树红黑树 V.S 平衡二叉…
阅读更多...
[Data structure]单链表 | 一文介绍线性数据结构之一的单链表(Java实现)

[Data structure]单链表 | 一文介绍线性数据结构之一的单链表(Java实现)

⭐作者介绍&#xff1a;大二本科网络工程专业在读&#xff0c;持续学习Java&#xff0c;努力输出优质文章 ⭐作者主页&#xff1a;逐梦苍穹 ⭐所属专栏&#xff1a;数据结构。数据结构专栏主要是在讲解原理的基础上拿Java实现 ⭐如果觉得文章写的不错&#xff0c;欢迎点个关注一…
阅读更多...
趣说数据结构（练习1） —— 顺序表/链表力扣刷题

趣说数据结构（练习1） —— 顺序表/链表力扣刷题

练习 1 —— 顺序表/链表力扣刷题 1. 合并两个有序链表 力扣题目地址&#xff1a;https://leetcode.cn/problems/merge-two-sorted-lists/ 问题描述&#xff1a;将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例&#x…
阅读更多...
【C++STL精讲】list的使用教程及其模拟实现

【C++STL精讲】list的使用教程及其模拟实现

文章目录 &#x1f490;专栏导读&#x1f490;文章导读&#x1f337;list是什么&#xff1f;&#x1f337;list如何使用&#xff1f;&#x1f337;list的模拟实现&#x1f33a;定义list类&#x1f33a;构造函数&#x1f33a;push_back&#x1f33a;pop_back &#x1f337;list迭…
阅读更多...
线性表总结

线性表总结

线性表 目录&#xff1a; 文章目录 线性表概念一、线性表的定义二、线性表的基本操作三、线性表的实现方式四、线性表的应用总结 概念 线性表是一种基本的数据结构&#xff0c;由一系列具有相同类型的数据元素构成&#xff0c;这些元素之间具有线性的顺序关系&#xff0c;每个…
阅读更多...
C++中的list容器

C++中的list容器

文章目录 list的介绍list的使用list的构造list iterator的使用list capacitylist元素访问list modifierslist的迭代器失效 list与vector的对比 list的介绍 list是可以在常数范围内的任意位置进行插入和删除的序列式容器&#xff0c;并且该容器可以前后双向迭代&#xff1b;   …
阅读更多...
【刷题】203. 移除链表元素

【刷题】203. 移除链表元素

203. 移除链表元素 一、题目描述二、示例三、实现方法1-找到前一个节点修改next指向方法2-不是val的尾插重构 总结 203. 移除链表元素 一、题目描述 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新…
阅读更多...
【数据结构】线性表 ⑥ ( 双循环链表 | 双循环链表插入操作 | 双循环链表删除操作 | LinkedList 双循环链表源码分析 )

【数据结构】线性表 ⑥ ( 双循环链表 | 双循环链表插入操作 | 双循环链表删除操作 | LinkedList 双循环链表源码分析 )

文章目录 一、双循环链表插入操作处理二、双循环链表删除操作处理三、LinkedList 双循环链表源码分析1、链表节点2、LinkedList 链表中收尾元素指针3、链表插入操作4、链表向指定位置插入操作5、获取指定索引的元素6、删除指定索引的元素 一、双循环链表插入操作处理 双循环链表…
阅读更多...
通讯录实现的需求分析和架构设计

通讯录实现的需求分析和架构设计

本文实现的是通讯录产品的需求分析和架构设计&#xff0c;重点在于结构层次的设计&#xff0c;方便代码阅读和维护。 一、通讯录实现的需求分析 1、通讯录的功能清单 添加一个人员打印显示所有人员删除一个人员查找一个人员保存文件加载文件 2&#xff0c;数据存储信息 人员…
阅读更多...
Leetcode 剑指 Offer II 027. 回文链表

Leetcode 剑指 Offer II 027. 回文链表

题目难度: 简单 原题链接 今天继续更新 Leetcode 的剑指 Offer&#xff08;专项突击版&#xff09;系列, 大家在公众号 算法精选 里回复 剑指offer2 就能看到该系列当前连载的所有文章了, 记得关注哦~ 题目描述 给定一个链表的 头节点 head &#xff0c;请判断其是否为回文链表…
阅读更多...
143. 重排链表

143. 重排链表

题目描述&#xff1a; 主要思路&#xff1a; 没有找到什么特殊的捷径&#xff0c;主要就是链表的一些基础操作。 实现了三个函数&#xff0c;一个是找到链表的中心结点&#xff0c;一个是将中心结点之后的链表进行翻转&#xff0c;另一个就是两段链表进行拼接。 class Soluti…
阅读更多...
数据结构初阶（3）（链表：链表的基本概念、链表的类型、单向不带头非循环链表的实现、链表的相关OJ练习、链表的优缺点 ）

数据结构初阶（3）（链表：链表的基本概念、链表的类型、单向不带头非循环链表的实现、链表的相关OJ练习、链表的优缺点 ）

接上次博客&#xff1a;和数组处理有关的一些OJ题&#xff1b;ArrayList 实现简单的洗牌算法&#xff08;JAVA)(ArrayList&#xff09;_di-Dora的博客-CSDN博客 目录 链表的基本概念 链表的类型 单向、不带头、非循环链表的实现 遍历链表并打印节点值&#xff1a; 在链…
阅读更多...
反转链表(链表篇)

反转链表(链表篇)

给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 思路&#xff1a; ①双指针法 ②递归法 如果再定义一个新的链表&#xff0c;实现链表元素的反转&#xff0c;其实这是对内存空间的浪费。 其实只需要改变链表的next指针的指向&#xff0c;…
阅读更多...
测试开发备战秋招面试5-牛客刷题之链表篇

测试开发备战秋招面试5-牛客刷题之链表篇

趁着5.1假期把牛客网的必刷的TOP101过一遍&#xff0c;额&#xff0c;题目量有点大&#xff0c;争取5天给刷完吧&#xff0c;哈哈&#xff0c;加油啦。再用雷布斯的那句话来激励自己吧&#xff1a;努力了那么多年,回头一望,几乎全是漫长的挫折和煎熬。对于大多数人的一生来说,顺…
阅读更多...
链表：常见面试题-拷贝特殊链表

链表：常见面试题-拷贝特殊链表

题目&#xff1a; 一种特殊的单链表节点类描述如下: class Node { int value; Node next; Node rand; Node(int val) {value val} } rand指针是单链表节点结构中新增的指针&#xff0c;rand可能指向链表中的任意一个节点&#xff08;包括自己&#xff09;&#xff0c;也可…
阅读更多...
线索二叉树(前中后序线索化/遍历/画线索)

线索二叉树(前中后序线索化/遍历/画线索)

线索二叉树 文章目录 线索二叉树1 线索二叉树的基本概念2 线索二叉树的构造2.1 线索二叉树的存储结构2.2 给线索二叉树画线索2.2.1 中序2.2.2 先序2.2.3 后序 2.3 二叉树线索化代码实现2.3.1 通过中序遍历线索化2.3.2 通过先序遍历线索化2.3.3 通过后序遍历线索化 3 线索二叉树…
阅读更多...
链表中倒数第k个结点（附带源码）

链表中倒数第k个结点（附带源码）

目录 代码部分&#xff1a; 核心&#xff1a;看图 代码部分&#xff1a; struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {// write code here// write code hereif (k 0){return NULL;}else{struct ListNode* slow pListHead, * fast pListHead;//…
阅读更多...
移除链表元素和链表的中间结点

移除链表元素和链表的中间结点

移除链表元素 一、移除链表元素二、链表的中间结点 一、移除链表元素 1.题目. 2.思路.   思路1:很简单&#xff0c;最常规的方法&#xff0c;建立一个新的链表&#xff0c;头为newHead&#xff0c;遍历链表&#xff0c;不是val值的拿下来尾插&#xff0c;注意一些细节&…
阅读更多...
数据结构之线性表(一般的线性表)

数据结构之线性表(一般的线性表)

前言 接下来就开始正式进入数据结构环节了&#xff0c;我们先从线性表开始。 线性表 线性表&#xff08;linear list&#xff09;也叫线性存储结构&#xff0c;即数据元素的逻辑结构为线性的数据表&#xff0c;它是数据结构中最简单和最常用的一种存储结构&#xff0c;专门存…
阅读更多...
数据结构——顺序表和链表的比较

数据结构——顺序表和链表的比较

1.逻辑结构 顺序表和链表都属于线性表&#xff0c;都是线性结构 2.存储结构 顺序表&#xff1a;顺序存储 优点&#xff1a;支持随机存取&#xff0c;存储密度高 缺点&#xff1a;大片连续空间分配不方便&#xff0c;改变容量不方便 链表&#xff1a;链式存储 优点&#…
阅读更多...
数据结构——静态链表

数据结构——静态链表

1.定义&#xff1a; &#xff08;1&#xff09;单链表&#xff1a;各个结点散落在内存中的各个角落&#xff0c;每个结点有指向下一个节点的指针(下一个结点在内存 中的地址); &#xff08;2&#xff09;静态链表&#xff1a;用数组的方式来描述线性表的链式存储结构: 分配一…
阅读更多...
96 双指针解旋转链表

96 双指针解旋转链表

给定一个链表&#xff0c;旋转链表&#xff0c;将链表每个节点向右移动k个位置&#xff0c;其中k是复数。 示例1&#xff1a;输入1->2->3->4->5->6->null;k2 输出&#xff1a; 5->6->1->2->3->4 双指针求解&#xff1a;定义快慢两个…
阅读更多...
java数据结构与算法刷题-----LeetCode19. 删除链表的倒数第 N 个结点

java数据结构与算法刷题-----LeetCode19. 删除链表的倒数第 N 个结点

java数据结构与算法刷题目录&#xff08;剑指Offer、LeetCode、ACM&#xff09;-----主目录-----持续更新(进不去说明我没写完)&#xff1a;https://blog.csdn.net/grd_java/article/details/123063846 文章目录 法一&#xff1a;翻转链表法二&#xff1a;双指针 法一&#xff…
阅读更多...
【C++中STL】list链表

【C++中STL】list链表

List链表 基本概念构造函数赋值和交换大小操作插入和删除数据存取反转和排序 基本概念 将数据进行链式存储 链表list是一种物理存储单元上非连续的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接实现的&#xff0c;链表是由一系列结点组成&#xff0c;结点的组…
阅读更多...
力扣经典题目：反转链表

力扣经典题目：反转链表

1.题目分析&#xff1a;正常顺序为从一到五&#xff0c;但题目要求为从五到一&#xff0c;自然而然与头插法相联系。 2.此题得出解题方法&#xff1a;重现纠错法 3.观察下面的代码&#xff0c;找出问题&#xff1a; 反转链表的经典错误 王赫辰/c语言 - Gitee.com 看起来也…
阅读更多...
leetcode:排序链表(递归)

leetcode:排序链表(递归)

题目&#xff1a; 给定链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [4,2,1,3] 输出&#xff1a;[1,2,3,4]示例 2&#xff1a; 输入&#xff1a;head [-1,5,3,4,0] 输出&#xff1a;[-1,0,3,4,5]示例…
阅读更多...
面试题----集合

面试题----集合

概述 从上图可以看出&#xff0c;在Java 中除了以 Map 结尾的类之外&#xff0c; 其他类都实现了 Collection 接⼝。 并且&#xff0c;以 Map 结尾的类都实现了 Map 接⼝List,Set,Map List (对付顺序的好帮⼿)&#xff1a; 存储的元素是有序的、可重复的。 Set (注重独⼀⽆⼆…
阅读更多...
leetcode系列：反转链表

leetcode系列：反转链表

反转链表是一道比较简单的题&#xff0c;主要考察的是对链表数据结构的理解和双指针应用&#xff0c;比较容易出错的地方是指针的移动顺序。在练习的过程中想到了一个比较形象的表示方法&#xff0c;于是记录下来。 # Definition for singly-linked list. # class ListNode: #…
阅读更多...
（浙大陈越版）数据结构 第二章 线性结构 2.4 多项式的加法和乘法运算实现

（浙大陈越版）数据结构 第二章 线性结构 2.4 多项式的加法和乘法运算实现

目录 2.4.1多项式的加法运算实现 如何设计一个函数分别求两个一元多项式的和&#xff1f; 算法思路&#xff1a;两个指针p1&#xff0c;p2分别指向两个多项式的第一个结点&#xff08;最高项&#xff09;并循环 循环&#xff1a; 2.4.2 多项式的乘积 1.多项式的表示 2.程…
阅读更多...
Go数据机构----栈与队列

Go数据机构----栈与队列

一、栈Stack和队列Queue 我们日常生活中&#xff0c;都需要将物品排列&#xff0c;或者安排事情的先后顺序。更通俗地讲&#xff0c;我们买东西时&#xff0c;人太多的情况下&#xff0c;我们要排队&#xff0c;排队也有先后顺序&#xff0c;有些人早了点来&#xff0c;排完队…
阅读更多...
＜数据结构＞NO4.带头双向循环链表

＜数据结构＞NO4.带头双向循环链表

文章目录 前言1. 头文件2. 函数实现1&#xff09;创建哨兵位节点2&#xff09;新增一个节点3&#xff09;打印链表4&#xff09;头插5&#xff09;尾插6&#xff09;头删7&#xff09;尾删8&#xff09;查找9&#xff09;pos前插入10&#xff09;删除pos处节点11&#xff09;销…
阅读更多...
数据结构-链表（详解）

数据结构-链表（详解）

前言&#xff1a;内容包括&#xff1a;链表的分类&#xff0c;无头单向非循环链表的增删查改的实现&#xff0c;带头双向循环链表的增删查改的实现 目录 链表的分类 1. 单向或者双向 ​编辑 2. 带头或者不带头 3. 循环或者非循环 无头单向非循环链表&#xff1a; ​编辑…
阅读更多...
双链表——“数据结构与算法”

双链表——“数据结构与算法”

各位CSDN的uu们你们好呀&#xff0c;今天&#xff0c;小雅兰又回来了&#xff0c;到了好久没有更新的数据结构与算法专栏&#xff0c;最近确实发现自己有很多不足&#xff0c;需要学习的内容也有很多&#xff0c;所以之后更新文章可能不会像之前那种一天一篇或者一天两篇啦&…
阅读更多...
LeetCode-206. 反转链表

LeetCode-206. 反转链表

目录 双指针递归 题目来源 206. 反转链表 双指针 定义两个指针&#xff1a; pre 和 cur&#xff1b;pre 在前 cur 在后。 每次让 cur 的 next 指向 pre&#xff0c;实现一次局部反转 局部反转完成之后&#xff0c;pre 和 cur 同时往前移动一个位置 循环上述过程&#xff0c;直…
阅读更多...
【Hello Algorithm】基础数据结构

【Hello Algorithm】基础数据结构

作者&#xff1a;小萌新 专栏&#xff1a;算法 作者简介&#xff1a;大二学生 希望能和大家一起进步 本篇博客简介&#xff1a;介绍几种基础数据结构 基础数据结构 单链表结构翻转单链表删除节点 双链表栈和队列用栈实现队列用队列实现栈 哈希表 单链表结构 在阅读这篇文章之前…
阅读更多...
【力扣-141】 环形链表 + 【力扣-142】 环形链表 II

【力扣-141】 环形链表 + 【力扣-142】 环形链表 II

&#x1f58a;作者 : Djx_hmbb &#x1f4d8;专栏 : 数据结构 &#x1f606;今日分享 : 霍桑效应(霍索恩效应) : 是指那些意识到自己正在被别人观察的个人具有改变自己行为的倾向。 霍桑效应告诉我们&#xff1a;从旁人的角度&#xff0c;善意的谎言和夸奖真的可以造就一个人&a…
阅读更多...
Leetcode 剑指 Offer II 026. 重排链表

Leetcode 剑指 Offer II 026. 重排链表

题目难度: 中等 原题链接 今天继续更新 Leetcode 的剑指 Offer&#xff08;专项突击版&#xff09;系列, 大家在公众号 算法精选 里回复 剑指offer2 就能看到该系列当前连载的所有文章了, 记得关注哦~ 题目描述 给定一个单链表 L 的头节点 head &#xff0c;单链表 L 表示为&a…
阅读更多...
c++《list容器的使用》

c++《list容器的使用》

本文主要介绍list的一些常见接口的使用 文章目录 一、list的介绍二、list的使用2.1 list的构造函数2.2 list迭代器的使用2.3 list相关的容量大小相关的函数2.4 list数据的访问相关的函数2.5 list的数据调整相关的函数2.6 list中其他函数操作 一、list的介绍 list是可以以O(1)的…
阅读更多...
约瑟夫问题及求解方法

约瑟夫问题及求解方法

文章目录 什么是约瑟夫问题&#xff1f;求解方法代码实现 什么是约瑟夫问题&#xff1f; 约瑟夫问题是一个经典的数学难题&#xff0c;其一般形式可以描述为&#xff1a; n个人&#xff08;编号从1到n&#xff09;&#xff0c;围坐在一张圆桌周围。从第一个人开始报数&#x…
阅读更多...
HashMap原理汇总

HashMap原理汇总

HashMap在JDK1.7和1.8的实现是有些不同的。 在JDK1.7中&#xff0c;HashMap 的实现是 数组 链表 在JDK1.8中&#xff0c;HashMap的底层实现是数字 链表/ 红黑树 key的要求 HashMap的key可以为null&#xff0c;而且只能有一个key为null 重写hashCode()和equals()方法key的内…
阅读更多...
代码随想录复习 203 移除链表元素

代码随想录复习 203 移除链表元素

代码如下 /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func removeElements(head *ListNode, val int) *ListNode { prehead : &ListNode{} //设置一个虚拟头结点 prehead.Next head //虚拟…
阅读更多...
【leetcode】138.复制带随机指针的链表

【leetcode】138.复制带随机指针的链表

《力扣》138.复制带随机指针的链表 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设…
阅读更多...
ConcurrentHashMap实现原理

ConcurrentHashMap实现原理

1. 哈希表 1.1 介绍 哈希表是一种key-value存储数据的结构&#xff0c;根据key即可查到对应的value。 如果所有的键是整数&#xff0c;我们可用简单的无序数组来表示&#xff0c;键作为数组索引&#xff0c;值即为对应的值 1.2 链式哈希表 链式哈希表本质由一组链表构成。每…
阅读更多...
【JAVA面试】HashMap的扩容机制

【JAVA面试】HashMap的扩容机制

提示&#xff1a;文章先作为初版&#xff0c;等后续时间充足后&#xff0c;补充更深的内容 文章目录 HashMap的扩容机制一、1.7版本二、1.8版本三、插入方式三、底层变化 HashMap的扩容机制 一、1.7版本 1.先生成新数组 2&#xff0e;遍历老数组中的每个位置上的链表上的每个…
阅读更多...
从单向链表中删除指定值的节点

从单向链表中删除指定值的节点

描述 输入一个单向链表和一个节点的值&#xff0c;从单向链表中删除等于该值的节点&#xff0c;删除后如果链表中无节点则返回空指针。 链表的值不能重复。 构造过程&#xff0c;例如输入一行数据为: 6 2 1 2 3 2 5 1 4 5 7 2 2 则第一个参数6表示输入总共6个节点&#xff0c;第…
阅读更多...
LeetCode刷题系列之-----＞（指针玩转链表篇）（三）

LeetCode刷题系列之-----＞（指针玩转链表篇）（三）

&#x1f349;博客主页&#xff1a;阿博历练记 &#x1f4d6;文章专栏&#xff1a;数据结构与算法 &#x1f50d;代码仓库&#xff1a;阿博编程日记 &#x1f339;欢迎关注&#xff1a;欢迎友友们点赞收藏关注哦 文章目录 &#x1f58b;1.题目描述&#x1f4a1; 逻辑分析&#…
阅读更多...
代码随想录复习 707设计链表

代码随想录复习 707设计链表

代码如下 type Node struct { //定义一个节点 &#xff0c;包含一个数据变量一个指针 Val int Next *Node } type MyLinkedList struct { //定义一个链表 &#xff0c;链表里面有一个虚拟头节点&#xff0c;和大小 Dummayhead *Node Size int } func Constructor(…
阅读更多...
[一篇读懂]C语言十二讲：栈与队列和真题实战

[一篇读懂]C语言十二讲：栈与队列和真题实战

[一篇读懂]C语言十二讲&#xff1a;栈与队列和真题实战 1. 与408关联解析及本节内容介绍1 与408关联解析2 本节内容介绍 2. 栈(stack)的原理解析2.1 **栈&#xff1a;只允许在一端进行插入或删除操作的线性表**2.2 栈的基本操作2.3 栈的顺序存储2.4 栈的链表存储 3. 初始化栈 -…
阅读更多...
（数据结构）栈的实现——再一次保姆级教学

（数据结构）栈的实现——再一次保姆级教学

目录 1. 栈 ​编辑 1.2 栈的实现 2. 代码的实现 2.1 初始化栈和销毁栈 2.2栈顶元素的插入 2.3栈顶元素的删除 栈元素删除 2.4栈顶元素的获取和栈元素的个数 1. 栈 1.1 栈的概念和结构 栈(Stack)是一种线性存储结构&#xff0c;它具有如下特点&#xff1a; &#xff0…
阅读更多...
【LeeCode】每日一题：复制带随机指针的链表

【LeeCode】每日一题：复制带随机指针的链表

​&#x1f47b;内容专栏&#xff1a;《LeetCode刷题专栏》 &#x1f428;本文概括&#xff1a; 138.复制带随机指针的链表 &#x1f43c;本文作者&#xff1a;花 碟 &#x1f438;发布时间&#xff1a;2023.5.18 ​复制带随机指针的链表 力扣链接-> 138.复制带随机指针的链…
阅读更多...
＜数据结构＞NO5.栈和队列

＜数据结构＞NO5.栈和队列

目录 栈 Ⅰ.栈的概念 Ⅱ.栈的实现 Ⅲ.测试代码 队列 Ⅰ.队列的概念 Ⅱ.队列的实现 &#x1f4ad;前言 栈和队列也是一种常见的线性存储的数据结构&#xff0c;只不过它们的某些操作受到了限制&#xff0c;比如栈只允许从栈顶插入删除元素、队列只允许从队尾插入元素&…
阅读更多...
数据结构与算法05：跳表和散列表

数据结构与算法05：跳表和散列表

目录 【跳表】 跳表的实现原理 如何确定跳表的层高&#xff1f; 【散列表】 散列函数的设计 散列冲突 &#xff08;1&#xff09;开放寻址法&#xff08;Open Addressing&#xff09; &#xff08;2&#xff09;链表法&#xff08;chaining&#xff09; 装载因子 如何…
阅读更多...
24届秋招专场·双指针巧解链表套路题

24届秋招专场·双指针巧解链表套路题

你好&#xff0c;我是安然无虞。 文章目录 合并两个有序链表分隔链表合并K个有序链表链表中倒数最后K个节点变形题: 删除链表的倒数第N个节点链表的中点判断链表是否有环环形链表II相交链表 大家好, 好久不见了, 从今天开始, 后面会经常更新笔试面试真题, 准备今年24届秋招的小…
阅读更多...
Python版Day4

Python版Day4

24. 两两交换链表中的节点 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 # Definition for singly-linked list. # class Lis…
阅读更多...
【LeetCode】203，移除链表元素。 难度等级：简单。链表入门题目，值得深入研究。

【LeetCode】203，移除链表元素。 难度等级：简单。链表入门题目，值得深入研究。

文章目录 一、题目二、解答&#xff1a;迭代法&#xff0c;引入一个新的头结点三、难点解释 【LeetCode】203&#xff0c;移除链表元素。 难度等级&#xff1a;简单。 本题是链表入门题目&#xff0c;值得深入研究。 一、题目 二、解答&#xff1a;迭代法&#xff0c;引入一个…
阅读更多...
数据结构之初识树与堆

数据结构之初识树与堆

前言&#xff1a;前面学习了顺序表&#xff0c;队列&#xff0c;栈&#xff0c;链表&#xff0c;我们知道他们都是一种线性表&#xff0c;是一种线性结构&#xff0c;而除此之外&#xff0c;仍有许多我们还没认识的结构&#xff0c;比如树形结构&#xff0c;不同于线性结构&…
阅读更多...
一看就懂之与栈结构（FILO）相对的——队列结构（FLFO）

一看就懂之与栈结构（FILO）相对的——队列结构（FLFO）

文章目录 一、什么是队列&#xff0c;什么是FIFO二、使用C模拟实现以及解析队列1.结构体的定义2.队列的创建及销毁3.实现插入操作4.队列删除操作5.获取栈中有效元素个数以及头元素尾元素 源代码分享 一、什么是队列&#xff0c;什么是FIFO ​ 队列允许在一端进行插入操作&…
阅读更多...
初阶数据结构之单链表的实现（四）

初阶数据结构之单链表的实现（四）

文章目录 链表的概念及结构一、链表的逻辑结构是什么样的&#xff1f;二、链表的初始化2.1链表初始化的示意2.2链表初始化代码实现 三、链表的各类接口函数定义四、链表的各类接口函数的代码实现4.1链表的打印代码实现4.1.1打印代码的实现 4.2链表的尾插代码实现4.2.1尾插代码实…
阅读更多...
数据结构初阶（3）（链表：链表的基本概念、链表的类型、单向不带头非循环链表的实现、链表的优缺点 ）

数据结构初阶（3）（链表：链表的基本概念、链表的类型、单向不带头非循环链表的实现、链表的优缺点 ）

接上次博客&#xff1a;和数组处理有关的一些OJ题&#xff1b;ArrayList 实现简单的洗牌算法&#xff08;JAVA)(ArrayList&#xff09;_di-Dora的博客-CSDN博客 目录 链表的基本概念 链表的类型 单向、不带头、非循环链表的实现 遍历链表并打印节点值&#xff1a; 在链…
阅读更多...
leetcode 138.复制带随机指针的链表

leetcode 138.复制带随机指针的链表

题目链接&#xff1a;leetcode 138 1.题目 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节…
阅读更多...
线程池底层实现学习

线程池底层实现学习

什么是线程池❔ 线程池是一个维持固定数量线程的池式结构 问&#xff1a;为什么要是固定数量 **答&#xff1a;**线程是一个紧缺的系统资源&#xff0c;随着线程不断的创建&#xff0c;达到一定数量后&#xff0c;操作系统的压力会越来越大 问&#xff1a; 如何来决定线程池中…
阅读更多...
《双向队列》

《双向队列》

介绍 双向队列&#xff08;deque&#xff0c;全名double-ended queue&#xff09;是一种具有队列和栈性质的数据结构。 对于队列&#xff0c;我们只能在头部删除或在尾部添加元素&#xff0c; 而「双向队列 Deque」更加灵活&#xff0c;在其两端都能执行元素添加或删除操作。…
阅读更多...
线性结构-链表

线性结构-链表

链表也是一种常用的线性数据结构&#xff0c;与数组不同的是&#xff0c;链表的存储空间并不连续&#xff0c;它是用一组地址任意的存储单元来存放数据的&#xff0c;也就是将存储单元分散在内存的各个地址上。 这些地址分散的存储单元叫做链表的节点&#xff0c;链表就是由一个…
阅读更多...
《程序员面试金典（第6版）》面试题 02.06. 回文链表（双指针(快慢指针），查找链表中间节点，反转链表）

《程序员面试金典（第6版）》面试题 02.06. 回文链表（双指针(快慢指针），查找链表中间节点，反转链表）

题目描述 编写一个函数&#xff0c;检查输入的链表是否是回文的。 题目传送门~&#xff1a;面试题 02.06. 回文链表 示例 1&#xff1a; 输入&#xff1a; 1->2 输出&#xff1a; false 示例 2&#xff1a; 输入&#xff1a; 1->2->2->1 输出&#xff1a; true 进…
阅读更多...
Leetcode每日一题——“用栈实现队列”

Leetcode每日一题——“用栈实现队列”

各位CSDN的uu们你们好呀&#xff0c;今天&#xff0c;小雅兰的内容是用栈实现队列&#xff0c;这和小雅兰的上一篇博客“用队列实现栈”好像有点点关系噢&#xff0c;事实上&#xff0c;也确实是这样的&#xff0c;下面&#xff0c;让我们进入Leetcode的世界吧&#xff01;&…
阅读更多...
合并有序链表---链表OJ---归并思想

合并有序链表---链表OJ---归并思想

https://leetcode.cn/problems/merge-two-sorted-lists/?envTypestudy-plan-v2&envIdtop-100-liked 将两个有序的链表合并为一个新的有序链表&#xff0c;那不就是和归并排序中最后合并的思想一样吗&#xff1f;只不过那里合并的是数组&#xff0c;这里合并的是链表。 首先…
阅读更多...
链表——超详细

链表——超详细

一、无头单向非循环链表 1.结构&#xff08;两个部分&#xff09;&#xff1a; typedef int SLTDataType; typedef struct SListNode {SLTDataType data;//数据域struct SListNode* next;//指针域 }SLNode; 它只有一个数字域和一个指针域&#xff0c;里面数据域就是所存放的…
阅读更多...
【数据结构】链表算法总结

【数据结构】链表算法总结

知识概览 链表包括单链表和双链表&#xff0c;这里讨论算法题中的链表。为了考虑算法题中对于时间效率的要求&#xff0c;链表通常是用数组模拟成静态链表的形式&#xff0c;速度快。单链表可以用来写邻接表&#xff08;包括n个链表&#xff09;&#xff0c;邻接表可以存储树和…
阅读更多...
【代码随想录-链表】两两交换链表中的节点

【代码随想录-链表】两两交换链表中的节点

💝💝💝欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学习,不断总结,共同进步,活到老学到老导航 檀越剑指大厂系列:全面总结 jav…
阅读更多...
【Leedcode】数据结构中链表必备的面试题（第四期）

【Leedcode】数据结构中链表必备的面试题（第四期）

【Leedcode】数据结构中链表必备的面试题&#xff08;第四期&#xff09; 文章目录【Leedcode】数据结构中链表必备的面试题&#xff08;第四期&#xff09;1.题目2.思路图解(1)思路一(2)思路二3.源代码总结1.题目 相交链表&#xff1a; 如下&#xff08;示例&#xff09;&…
阅读更多...
力扣0086——分隔链表

力扣0086——分隔链表

分隔链表 难度&#xff1a;中等 题目描述 给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你应当 保留 两个分区中每个节点的初始相对位置。 示例1 origin_url%2Fimages…
阅读更多...
freertos 源码分析一 list链表数据结构

freertos 源码分析一 list链表数据结构

链表和任务管理是freertos 的核心&#xff0c;先分析链表源码&#xff0c;freertos的链表是双向环形链表&#xff0c;定义与数据结构在list.h中&#xff0c;表项的初始化&#xff0c;插入与删除在list.c中。 数据结构 一、表项数据结构 struct xLIST_ITEM {listFIRST_LIST_IT…
阅读更多...
C语言实现跳表（附源码）

C语言实现跳表（附源码）

最近在刷一些链表的题目&#xff0c;在leetcode上有一道设计跳表的题目&#xff0c;也是通过查阅各种资料&#xff0c;自己实现出来&#xff0c;感觉这是种很神奇的数据结构。 一.简介 跳表与红黑树&#xff0c;AVL树等&#xff0c;都是一种有序集合&#xff0c;那既然是有序…
阅读更多...
【代码随想录算法训练营-第四天】【链表】24，19， 面试题 02.07，142

【代码随想录算法训练营-第四天】【链表】24，19， 面试题 02.07，142

24. 两两交换链表中的节点 第一遍-递归-小看了一下题解 思路&#xff1a; 读了两遍题目才理解…相邻节点的交换&#xff0c;这个操作很容易实现&#xff0c;但需要一个tmpNode因为是链表的题目&#xff0c;没开始思考之前先加了dummyNode&#xff0c;还真管用把dummyNode作为…
阅读更多...
Leetcode21. 合并两个有序链表

Leetcode21. 合并两个有序链表

一、题目描述&#xff1a; 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4]输出&#xff1a;[1,1,2,3,4,4] 示例 2&#xff1a; 输入&#xff1a;l1 [], l2…
阅读更多...
C语言-链表_基础

C语言-链表_基础

链表-基础 1. 数组 1.1 静态数组 例子:int nums[5] {0};struct person ps[5]; 缺点:1,无法修改地址2,无法动态定义长度3,占用内存过大或过小4,增删速度慢 优点数组的内存是连续开辟的,所以读取速度快1.2 动态数组 例子:int *nums (int *) calloc(5,sizeof(int));struct p…
阅读更多...
LeetCode-删除排序链表中的重复元素问题

LeetCode-删除排序链表中的重复元素问题

1.删除排序链表中的重复元素 题目描述&#xff1a; 给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回已排序的链表 。 思路&#xff1a; 因为要删除相同元素&#xff0c;很容易想到定义两个指针pre&#xff0c;cur。…
阅读更多...
LeetCode 92.反转链表II

LeetCode 92.反转链表II

题目&#xff1a; 给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 方法&#xff1a;灵神 反转链表 代码&#xff1a; class Solution {public ListN…
阅读更多...
【STL模版库】list介绍及使用 {inserterase的迭代器失效问题，vector_sort VS list_sort，list的其他接口函数}

【STL模版库】list介绍及使用 {inserterase的迭代器失效问题，vector_sort VS list_sort，list的其他接口函数}

一、list的介绍 list是可以在常数时间内在任意位置进行插入和删除的序列式容器&#xff0c;并且该容器可以前后双向迭代。list的底层是双向带头循环链表结构&#xff0c;双向链表中每个元素存储在互不相关的独立节点中&#xff0c;在节点中通过指针指向其前一个元素和后一个元…
阅读更多...
BetaFlight Mark4 H7 Dual270 + BN880 + CRSF 配置存档

BetaFlight Mark4 H7 Dual270 + BN880 + CRSF 配置存档

BetaFlight Mark4 H7 Dual270 BN880 CRSF 配置存档 1. 源由2. 配置2.1 端口2.2 系统2.3 对齐2.4 GPS2.5 救援2.6 PID2.7 Rate2.8 滤波2.9 接收器2.10 模式2.11 电机 3.差异4. 整机效果5. 飞行效果6. 参考资料 1. 源由 手头这台航模四轴&#xff0c;基本调试的差不多&#xf…
阅读更多...
【数据结构与算法篇】栈与队列（详解）附加Leetcode经典笔试题

【数据结构与算法篇】栈与队列（详解）附加Leetcode经典笔试题

​&#x1f47b;内容专栏&#xff1a;《数据结构与算法专栏》 &#x1f428;本文概括&#xff1a; 讲述数据结构栈与队列基本知识。 &#x1f43c;本文作者&#xff1a;花 碟 &#x1f438;发布时间&#xff1a;2023.5.23 文章目录 一、栈1.栈的概念及结构2.栈的实现 二、有效的…
阅读更多...
【LeetCode】 复制带随机指针的链表

【LeetCode】 复制带随机指针的链表

Leetcode 138.复制带随机指针的链表 文章目录 题目描述解题思路运行代码 题目描述 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全…
阅读更多...
《LKD3粗读笔记》(15)进程地址空间

《LKD3粗读笔记》(15)进程地址空间

进程地址空间&#xff1a;内核除了管理本身的内存外&#xff0c;还必须管理用户空间中进程的内存&#xff0c;这个内存就是进程地址空间&#xff0c;即系统中每个用户空间进程所看到的内存。Linux操作系统采用虚拟内存技术&#xff0c;系统中的所有进程之间以虚拟方式共享内存。…
阅读更多...
day4--链表内指定区间反转

day4--链表内指定区间反转

迭代方法 1. 第m个节点的前一个节点pre和第n个节点&#xff1b; 2. 将第m个节点到第n个节点的链表部分反转&#xff1b; 3. 将pre节点的next指向反转后链表的头节点&#xff0c;将反转后链表的尾节点的next指向n1节点。 /*** struct ListNode {* int val;* struct ListNode…
阅读更多...
《程序员面试金典（第6版）》面试题 02.05. 链表求和（构建一个新链表）

《程序员面试金典（第6版）》面试题 02.05. 链表求和（构建一个新链表）

题目解析 给定两个用链表表示的整数&#xff0c;每个节点包含一个数位。这些数位是反向存放的&#xff0c;也就是个位排在链表首部。编写函数对这两个整数求和&#xff0c;并用链表形式返回结果。 题目传送门&#xff1a;面试题 02.05. 链表求和 示例&#xff1a; 输入&#x…
阅读更多...
双指针题目学习

双指针题目学习

主题 在算法比赛中&#xff0c;双指针的题目涉及的特别多&#xff0c;无论是大学时候的acm比赛还是蓝桥杯比赛中&#xff0c;都有许多涉及双指针的做题思路&#xff0c;在之后的工作面试中&#xff0c;手写代码环节中&#xff0c;双指针的思想也是经常能使用到的。 算法思路 …
阅读更多...
Java集合回顾

Java集合回顾

能不能和你竭尽全力奔跑 / 向着海平线 / 余晖消逝之前都不算终点 文章目录 集合概述Java 集合概览List, Set, Queue, Map 四者的区别&#xff1f;集合框架底层数据结构总结如何选用集合?为什么要使用集合&#xff1f; ListArrayList 和 Array&#xff08;数组&#xff09;的区…
阅读更多...
【C++】详解STL中的list及其与vector的比较

【C++】详解STL中的list及其与vector的比较

目录 一、list的介绍及其使用1、list的介绍2、list的使用2.1 list的构造2.2 list iterator的使用3、list的元素访问接口4、list的调节器6、list的迭代器失效 二、list的模拟实现及反向迭代器1、模拟实现list2、list的反向迭代器 三、list和vector的比较 一、list的介绍及其使用…
阅读更多...
图解LeetCode链表题

图解LeetCode链表题

&#x1f490;文章导读 本篇文章主要详细的用图解的方式为大家讲解了简单程度的链表题&#xff0c;如果题中有错误的地方&#xff0c;还麻烦您在评论区指出&#xff0c;你的意见就是我最大的进步&#xff01;&#xff01;&#xff01; &#x1f490;专栏导读 &#x1f934;作者…
阅读更多...
如何在华为OD机试中获得满分？Java实现【合并 K 个升序链表】一文详解！

如何在华为OD机试中获得满分？Java实现【合并 K 个升序链表】一文详解！

✅创作者&#xff1a;陈书予 &#x1f389;个人主页&#xff1a;陈书予的个人主页 &#x1f341;陈书予的个人社区&#xff0c;欢迎你的加入: 陈书予的社区 &#x1f31f;专栏地址: Java华为OD机试真题&#xff08;2022&2023) 文章目录 1. 题目描述2. 输入描述3. 输出描述…
阅读更多...
HashMap 简述

HashMap 简述

文章目录 前言一、HashMap的数据结构二、HashMap存储数据的大致过程1 哈希值2 什么是哈希冲突?3 为何有两种数据结构? 三、HashMap常用知识总结 前言 HashMap 是开发中常用的一种数据结构,通常用做返回值,计算比对等,会经常用到; 一、HashMap的数据结构 jdk8之后,数据结构是…
阅读更多...
【刷题】138. 复制带随机指针的链表

【刷题】138. 复制带随机指针的链表

138. 复制带随机指针的链表 一、题目描述二、示例三、实现 138. 复制带随机指针的链表 一、题目描述 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝…
阅读更多...
【LeetCode】环形链表+结论证明

【LeetCode】环形链表+结论证明

题目链接&#xff1a;环形链表 题目&#xff1a;给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 p…
阅读更多...
leetcode--环形链表.找到入环节点（java）

leetcode--环形链表.找到入环节点（java）

环形链表II 环形链表.找到入环节点题目描述解题思路 环形链表.找到入环节点 LeetCode 142&#xff1a;环形链表II 可以在这里测试 题目描述 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节…
阅读更多...
数据结构与算法（四）

数据结构与算法（四）

一、链表 线性表&#xff1a;0个或者是多个数据元素有限序列 物理的存储结构&#xff1a; 顺序存储&#xff1a;用一段连续的存储单元依次存储线性表的数据元素。链式存储&#xff1a;内存地址可以是连续的&#xff0c;也可以是不连续的。把数据元素存放在任意的存储单元里&…
阅读更多...
【Leetcode刷题】算法：合并两个有序链表

【Leetcode刷题】算法：合并两个有序链表

文章目录 一、题目介绍二、解决办法三、提交结果 一、题目介绍 二、解决办法 首先定义一个名为ListNode的类&#xff1a; class ListNode:def __init__(self, val0, nextNone):self.val valself.next nextListNode代表一个链表节点&#xff0c;每个节点包含一个值&#xff…
阅读更多...
C++ list

C++ list

C list &#x1f4df;作者主页&#xff1a;慢热的陕西人 &#x1f334;专栏链接&#xff1a;C &#x1f4e3;欢迎各位大佬&#x1f44d;点赞&#x1f525;关注&#x1f693;收藏&#xff0c;&#x1f349;留言 本博客主要内容介绍了C中list和相关接口的使用 Clist C listⅠ. li…
阅读更多...
【算法】算法学习二：链表 数组 选择排序

【算法】算法学习二：链表 数组 选择排序

文章目录 一、链表和数组二、选择排序&#xff08;含示例代码&#xff09; 一、链表和数组 链表和数组是常见的数据结构&#xff0c;用于组织和存储数据。它们在内部实现和使用方式上有一些显著的区别。 数组是一个连续的内存块&#xff0c;用于存储相同类型的元素。数组的每…
阅读更多...
03. 数据结构之链表

03. 数据结构之链表

前言 链表是相区别于数组的&#xff0c;另一种典型的线性表数据结构。也是学习后面复杂的数据结构的基础&#xff0c;我们后面很多结构比如树&#xff0c;有向图等都可以用链表很方便的存储管理。 1. 概念 链表&#xff08;linked list&#xff09;是一种在物理上非连续、非…
阅读更多...
【数据结构】顺序表---C语言版（数据结构开篇小菜，全网最详细！小白看一遍就学会！！！）

【数据结构】顺序表---C语言版（数据结构开篇小菜，全网最详细！小白看一遍就学会！！！）

文章目录 &#x1f354;一、前言&#x1f35f;1. 什么是数据结构 &#x1f354;二、顺序表的概念----线性表&#x1f35f;1. 什么是线性表&#x1f35f;2. 顺序表与数组的区别 &#x1f354;三、顺序表详解&#x1f4a7; 静态顺序表&#x1f4a7; 动态顺序表&#x1f34e;创建动…
阅读更多...
牛客网剑指offer|中等题day2|JZ22链表中倒数最后k个结点(简单)、JZ35复杂链表的复制（复杂）、JZ77按之字形顺序打印二叉树（中等）

牛客网剑指offer|中等题day2|JZ22链表中倒数最后k个结点(简单)、JZ35复杂链表的复制（复杂）、JZ77按之字形顺序打印二叉树（中等）

JZ22链表中倒数最后k个结点(简单) 链接&#xff1a;链表中倒数最后k个结点_牛客题霸_牛客网 /*** struct ListNode {* int val;* struct ListNode *next;* ListNode(int x) : val(x), next(nullptr) {}* };*/ class Solution { public:/*** 代码中的类名、方法名、参数名已经指…
阅读更多...
代码随想录复习 29删除倒数第N个节点

代码随想录复习 29删除倒数第N个节点

代码如下 /** * Definition for singly-linked list. * type ListNode struct { * Val int * Next *ListNode * } */ func removeNthFromEnd(head *ListNode, n int) *ListNode { dummyhead : &ListNode { // 设置一个虚拟头结点 Next : head, } fast : dummy…
阅读更多...
链表操作：尾插法

链表操作：尾插法

自定义链表操作&#xff1a; static PT_DispOpr g_ptInputOprHead; /*定义链表头*//*尾插链表*/ int RegisterOpr(PT_DispOpr ptDispOpr) {PT_DispOpr ptTmp;if (!g_ptDispOprHead){g_ptDispOprHead ptDispOpr;ptDispOpr->ptNext NULL;}else{ptTmp g_ptDispOprHead;w…
阅读更多...
ConcurrentHashMap内部结构分析(属性，内部类，构造器)

ConcurrentHashMap内部结构分析(属性，内部类，构造器)

ConcurrentHashMap内部结构分析(属性&#xff0c;内部类&#xff0c;构造器) 文章目录ConcurrentHashMap内部结构分析(属性&#xff0c;内部类&#xff0c;构造器)1. ConcurrentHashMap介绍2. ConcurrentHashMap的继承体系3. ConcurrentHashMap整体流程与结构4. 内部结构分析4.…
阅读更多...
Leetcode23. 合并K个升序链表 -两种方法

Leetcode23. 合并K个升序链表 -两种方法

23. 合并K个升序链表食用指南&#xff1a;题目描述&#xff1a;题目分析&#xff1a;算法模板:代码实现&#xff1a;法一&#xff1a;漏斗堆法1.5&#xff1a;迭代器 / 范围for不需要判断输入为空法二&#xff1a;两两合并链表注意点&#xff1a;1. 自定义STL中的堆&#xff1a…
阅读更多...
【数据结构初阶】二、顺序表的实现

【数据结构初阶】二、顺序表的实现

目录 一、线性表 二、顺序表 2.1 顺序表概念及结构 2.2 顺序表接口实现 2.2.1 顺序表初始化 2.2.2 顺序表的销毁 2.2.3 顺序表的打印 2.2.4 顺序表增加数据&#xff08;插入&#xff0c;头插、尾插&#xff09; 2.2.5 顺序表删除数据&#xff08;删除&#xff0c;头删…
阅读更多...
访问链表中的某个元素（快慢指针）

访问链表中的某个元素（快慢指针）

访问链表的中间元素题目一&#xff1a;访问中间元素题目信息&#xff1a;&#xff08;1&#xff09;题目连接&#xff1a;&#xff08;2&#xff09;题目信息&#xff1a;题目解答&#xff1a;&#xff08;1&#xff09;方法一&#xff1a;遍历&#xff08;1&#xff09;方法二…
阅读更多...
6、链表和数组，哪个实现队列更快？

6、链表和数组，哪个实现队列更快？

链表和数组&#xff0c;哪个实现队列更快&#xff1f; 数组是连续存储&#xff0c;push很快&#xff0c;shift很慢链表是非连续存储&#xff0c;add和delete都很快&#xff08;但查找很慢&#xff09;结论&#xff1a;链表实现队列更快 链表实现队列 单向链表&#xff0c;但…
阅读更多...
数据结构的讲解章节之一（线性表中的顺序表）

数据结构的讲解章节之一（线性表中的顺序表）

今天&#xff0c;我将带来数据结构中的线性表之顺序表。 目录线性表顺序表动态顺序表的三个文档初始化函数检查空间是否满的函数打印函数销毁顺序表的函数尾插和尾删函数头插和头删函数中间插入数据和中间删除数据的函数查找函数菜单和主函数函数的声明和结构体的定义SeqList.c…
阅读更多...
【数据结构】——单链表

【数据结构】——单链表

目录 1.链表 1.1 链表的概念及结构 1.2 链表的分类 1. 单向或者双向 2. 带头或者不带头 3. 循环或者非循环 1.3实现一个单链表&#xff08;无头单项非循环链表增删查改的实现&#xff09; 1.链表结构的创建 2.创建一个节点 3.创建一个链表 4.打印链表 5…
阅读更多...
C++初阶 List的模拟实现

C++初阶 List的模拟实现

作者&#xff1a;小萌新 专栏&#xff1a;C初阶 作者介绍&#xff1a;大二学生 希望能和大家一起进步 本篇博客简介&#xff1a;模拟STL中List的实现 List的模拟实现本篇博客目标节点类的实现构造函数迭代器类的实现迭代器类模拟实现的意义迭代器类的三个参数说明构造函数运算…
阅读更多...
数据结构：单链表

数据结构：单链表

用&#xff08;带头节点&#xff09;单链表完成图书统计。节点结构包括书籍编号&#xff0c;书籍名以及对应作者。功能包括增加&#xff08;尾插法和指定位置插入法&#xff09;、删除、修改、查看。 一、定义节点结构 每一个节点都包括这些变量&#xff0c;构造器复杂将传入的…
阅读更多...
LeetCode刷题2：链表篇

LeetCode刷题2：链表篇

提示&#xff1a;本篇共7道力扣题目供大家食用&#xff0c;时间自行把控~ 算法刷题系列笔记 LeetCode刷题1&#xff1a;数组篇 文章目录算法刷题系列笔记作者有话说一、链表知识1.1 什么是链表?1.2 链表的类型1.3 链表操作二、经典题目2.1 Leetcode203.移除链表元素2.2 Leet…
阅读更多...
【再临数据结构】链表

【再临数据结构】链表

目录 链表的结构、特点 实际结构 逻辑结构 特点&#xff1a; 自建链表 链表节点类 单向链表类 单向链表添加节点示意图 双向链表 链表的操作 删除节点 添加节点 性能分析 补充&#xff1a;环形链表 链表的结构、特点 链表是有序的结构&#xff0c;但在物理设备&…
阅读更多...
【Leetcode -138.复制带随机指针的链表 -2130.链表最大孪生和】

【Leetcode -138.复制带随机指针的链表 -2130.链表最大孪生和】

Leetcode Leetcode -138.复制带随机指针的链表Leetcode -2130.链表最大孪生和 Leetcode -138.复制带随机指针的链表 题目&#xff1a;给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构…
阅读更多...
【地铁上的面试题】--基础部分--数据结构与算法--数组和链表

【地铁上的面试题】--基础部分--数据结构与算法--数组和链表

零、章节简介 《数据结构与算法》是《地铁上的面试题》专栏的第一章&#xff0c;重点介绍了技术面试中不可或缺的数据结构和算法知识。数据结构是组织和存储数据的方式&#xff0c;而算法是解决问题的步骤和规则。 这一章的内容涵盖了常见的数据结构和算法&#xff0c;包括数组…
阅读更多...
解密高并发场景下的集合类问题，让程序更高效稳定！

解密高并发场景下的集合类问题，让程序更高效稳定！

大家好&#xff0c;我是小米&#xff0c;一个热爱技术分享的小伙伴。在日常开发中&#xff0c;我们经常会使用集合类来处理数据&#xff0c;但在高并发场景下&#xff0c;集合类可能会遇到一些线程安全的问题。今天&#xff0c;我们就来探讨一下集合类在高并发中是如何解决问题…
阅读更多...
代码随想录-链表

代码随想录-链表

基础知识 链表是一种通过指针串联在一起的线性结构。在内存中不是连续分布的&#xff0c;分配机制取决于操作系统内存管理。 类型 三种类型&#xff1a;单链表、双链表、循环链表 单链表&#xff1a;每个节点由两部分组成&#xff0c;数据域和指针域&#xff08;存放指向下…
阅读更多...
数据结构练习题1：基本概念

数据结构练习题1：基本概念

练习题1&#xff1a;基本概念 1 抽象数据类型概念分析2. 逻辑结构与存储结构概念分析3.综合选择题4.综合判断题5.时间复杂度相关习题 1 抽象数据类型概念分析 1.可以用&#xff08;抽象数据类型&#xff09;定义一个完整的数据结构。 分析&#xff1a; 1&#xff09;抽象数据…
阅读更多...
HJ48 从单向链表中删除指定值的节点

HJ48 从单向链表中删除指定值的节点

描述 输入一个单向链表和一个节点的值&#xff0c;从单向链表中删除等于该值的节点&#xff0c;删除后如果链表中无节点则返回空指针。 链表的值不能重复。 构造过程&#xff0c;例如输入一行数据为: 6 2 1 2 3 2 5 1 4 5 7 2 2 则第一个参数6表示输入总共6个节点&am…
阅读更多...
Flutter中 MediaQuery 和 build 优化你不知道的秘密

Flutter中 MediaQuery 和 build 优化你不知道的秘密

Flutter中 MediaQuery 和 build 优化你不知道的秘密 Flutter是一个快速发展的跨平台移动应用开发框架&#xff0c;它提供了许多强大的工具来创建高性能的应用程序。其中两个最重要的工具是MediaQuery和build方法。本文将介绍如何使用这些工具优化应用程序性能&#xff0c;并分…
阅读更多...
LeetCode - #86 分隔链表

LeetCode - #86 分隔链表

文章目录 前言1. 描述2. 示例3. 答案关于我们 前言 我们社区陆续会将顾毅&#xff08;Netflix 增长黑客&#xff0c;《iOS 面试之道》作者&#xff0c;ACE 职业健身教练。&#xff09;的 Swift 算法题题解整理为文字版以方便大家学习与阅读。 LeetCode 算法到目前我们已经更新…
阅读更多...
什么是链表？

什么是链表？

链表 什么是链表&#xff1f; 链表是有序的数据结构&#xff0c;链表中的每个部分称为节点。可以首、尾、中间进行数据存取&#xff0c;链表的元素在内存中不必是连续的空间&#xff0c;每个节点通过 next 指针指向下一个节点。 优点 链表的添加和删除不会导致其余元素位移。…
阅读更多...
数据结构链表（C语言实现）

数据结构链表（C语言实现）

绪论 机遇对于有准备的头脑有特别的亲和力。本章将讲写到链表其中主要将写到单链表和带头双向循环链表的如何实现。 话不多说安全带系好&#xff0c;发车啦&#xff08;建议电脑观看&#xff09;。 附&#xff1a;红色&#xff0c;部分为重点部分&#xff1b;蓝颜色为需要记忆的…
阅读更多...
LeetCode - #83 删除排序链表中的重复元素

LeetCode - #83 删除排序链表中的重复元素

文章目录 前言1. 描述2. 示例3. 答案关于我们 前言 我们社区陆续会将顾毅&#xff08;Netflix 增长黑客&#xff0c;《iOS 面试之道》作者&#xff0c;ACE 职业健身教练。&#xff09;的 Swift 算法题题解整理为文字版以方便大家学习与阅读。 LeetCode 算法到目前我们已经更新…
阅读更多...
leetcode刷题整理！

leetcode刷题整理！

链表&#xff1a; 21. Merge Two Sorted Lists(合并两个有序链表) 递归&#xff1b; 206. Reverse Linked List&#xff08;反转链表&#xff09; 234. Palindrome Linked List&#xff08;是否回文链表&#xff09; JZ22 链表中倒数最后k个结点 19. Remove Nth Node From End…
阅读更多...
C专家编程 —— 链接的思考

C专家编程 —— 链接的思考

文章目录 编译器的作用动态链接和静态链接动态链接动态链接的优点 函数库链接的几个小秘密 编译器的作用 通常编译器被氛围六七个小的程序&#xff1a; C预处理器&#xff0c;得到main.i文件前端做语法语义分析&#xff0c;然后后端生成汇编的指令代码main.s文件优化器可以放…
阅读更多...
【数据结构】单链表 创建 插入 删除 查找 完整代码

【数据结构】单链表 创建 插入 删除 查找 完整代码

3.1 单链表 3.1.1 定义 注&#xff1a; 元素离散的分布在存储空间中&#xff0c;所以单链表是非随机存取的存储结构。 即不能直接找到表中某个特定的结点&#xff0c;需要从表头开始遍历&#xff0c;依次查找。 定义的代码 typedef struct LNode {ElemType data;//每个节点存放…
阅读更多...
Racket链表与二叉树

Racket链表与二叉树

不管是链表还是二叉树都是链式存储结构&#xff0c;用习惯的话说就是需要数据域指针域&#xff08;如果对cpp等传统语言实现链表有所了解的话&#xff09; 在lisp中也需要使用结构体来实现它 结构体 struct在官方文档的页面&#xff1a;Racket - 5 Structures 可以通过以下…
阅读更多...
＜数据结构＞顺序表和链表的比较|缓存命中率

＜数据结构＞顺序表和链表的比较|缓存命中率

&#x1f4ad;前言&#xff1a;通过之前对顺序表和链表的实现&#xff0c;我们可以发现在增删查改某些操作上两者的效率前言有所差异&#xff0c;本篇文章将总结二者的异同。 顺序表的实现http://t.csdn.cn/Lxyg2单链表的实现http://t.csdn.cn/rHgjG双链表的实现http://t.csdn.…
阅读更多...
图解LeetCode——141. 环形链表

图解LeetCode——141. 环形链表

一、题目 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&a…
阅读更多...
STL --- 2、容器 （2）List

STL --- 2、容器 （2）List

目录 1、std::list 的特点 2、std::list 常用的 API 3、std::list 使用的例子 4、std::list 一些坑 1、std::list 的特点 &#xff08;1&#xff09;list 是 STL 中的一个容器&#xff0c;实现了双向链表结构。 &#xff08;2&#xff09;list 中的元素可以在任何位置进行…
阅读更多...
LeetCode：23. 合并 K 个升序链表

LeetCode：23. 合并 K 个升序链表

23. 合并 K 个升序链表 1&#xff09;题目2&#xff09;过程3&#xff09;代码1. 最开始2.初步优化 4&#xff09;结果1. 最开始2. 初步优化 1&#xff09;题目 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合…
阅读更多...
浅谈java中集合框架-双端队列 deque

浅谈java中集合框架-双端队列 deque

deque&#xff08;double-ended queue&#xff0c;双端队列&#xff09;是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出 实现&#xff1a; Deque表示双端队列。双端队列是在两端都可以进行插入和删除的队列。 1. LinkedList 新建一个双端队列&#xff…
阅读更多...
《C++ list的模拟实现》

《C++ list的模拟实现》

本文主要介绍list容器的模拟实现 文章目录 1、迭代器正向迭代器类反向迭代器类 2、push_back尾插函数3、 push_front头插函数4、 insert插入函数5、erase删除函数6、pop_front函数7、pop_back函数8、 构造函数9、 拷贝构造函数10、 list赋值重载函数11、clear12、 析构函数程序…
阅读更多...
骚戴独家笔试---算法篇

骚戴独家笔试---算法篇

链表 反转链表 /* public class ListNode { int val; ListNode next null;ListNode(int val) { this.val val; } }*/ import java.util.Stack; public class Solution {public ListNode ReverseList(ListNode head) {Stack<ListNode> stack new Stack<>();//把…
阅读更多...
聊聊glibc中malloc函数的unlink

聊聊glibc中malloc函数的unlink

unlink的意思其实就是删除。在介绍这个函数之前&#xff0c;我们得介绍一点概念。在程序中&#xff0c;如果我们使用malloc申请的内存在不用或者不需要的时候&#xff0c;是需要程序员手动去释放&#xff0c;也就是free操作。我们知道malloc操作free操作都是涉及到内存管理的。…
阅读更多...
两个链表的入环节点(java)

两个链表的入环节点(java)

两个链表的入环节点 两个链表的入环节点解题思路代码演示 链表相关的题 两个链表的入环节点 给定两个可能有环也可能无环的单链表&#xff0c;头节点head1和head2 请实现一个函数&#xff0c;如果两个链表相交&#xff0c;请返回相交的第一个节点。如果不相交返回null 要求如果…
阅读更多...
【数据结构】链表 linked list

【数据结构】链表 linked list

一、什么是链表 零散的内存空间存储&#xff0c;由元素和指针组成 二、常用操作 1.原理 access&#xff1a;通过next指针遍历 时间复杂度&#xff1a;O(N) search&#xff1a;通过next指针遍历 时间复杂度&#xff1a;O(N) insert&#xff1a;找个新的内存空间存储新元素…
阅读更多...
《程序员面试金典（第6版）》面试题 02.07. 链表相交（查找节点操作，哈希表，双指针（先走n步法，交替遍历法））

《程序员面试金典（第6版）》面试题 02.07. 链表相交（查找节点操作，哈希表，双指针（先走n步法，交替遍历法））

题目描述 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 题目传输门&#xff1a;面试题 02.07. 链表相交 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结…
阅读更多...
【map和set的封装】

【map和set的封装】

文章目录 前言1 大致框架2 迭代器3 map和set的封装 前言 上篇博客已经讲解了红黑树插入的模拟实现&#xff0c;这篇文章的目的是利用上节课讲解的底层实现来封装map和set.参考代码借鉴的是STL SGI版本3.0 1 大致框架 首先我们来看看源码里面怎么定义的: 从源码中我们不难发现m…
阅读更多...
有序单链表去重

有序单链表去重

根据程序提供的LNode结构&#xff0c;删除以h为头结点的有序单链表中的重复元素&#xff0c;并返回删除的元素构成的新单链表&#xff08;保持原来表中的相对顺序&#xff09;。 函数接口定义&#xff1a; LNode* DelR(LNode *h); 其中h为无附加表头的单链表的首结点地址。要求…
阅读更多...
＜顺序表—链表＞题目练习《数据结构(C语言版)》

＜顺序表—链表＞题目练习《数据结构(C语言版)》

目录 题目&#xff1a; 1. 下列数据结构中&#xff0c;不属于线性表的是&#xff08; &#xff09; 2. 在长度为 n 的顺序表下标为 i 的位置前插入一个元素&#xff08;1 ≤ i ≤ n1&#xff09;&#xff0c;元素的移动次数为&#xff08; &#xff09; 3.动态顺序表中…
阅读更多...
LeetCode：138. 复制带随机指针的链表（含原码实现）

LeetCode：138. 复制带随机指针的链表（含原码实现）

目录 前言 一&#xff0c;题目分析 二&#xff0c;思路分析 步骤一&#xff1a; 步骤二&#xff1a; 步骤三&#xff1a; 三&#xff0c;原码实现 前言 小伙伴们大家好啊&#xff01;今天为大家带来一篇力扣上不常见的链表题目&#xff1a;复制带随机指针的链表。 一&a…
阅读更多...
手把手教你学会简单的链表相交问题（LeetCode 160 .相交链表）

手把手教你学会简单的链表相交问题（LeetCode 160 .相交链表）

目录 前言 一&#xff0c;题目分析 1.1题目分析 1.2多种思路 二&#xff0c;思路分析 2.1判断链表是否相交 2.2找出第一个相交的节点 第一步&#xff1a;是否相交 第二步&#xff1a;比较前的准备 第三步&#xff1a;比较 三&#xff0c;原码实现 前言 Hello&#…
阅读更多...
一文介绍Js的数据结构

一文介绍Js的数据结构

目录 1、什么是数据结构&#xff1f; 2、对象 3、数组 4、栈 5、队列 6、链表 7、树 8.总结 很高兴您对JavaScript数据结构感兴趣&#xff01;JavaScript是一种强大的编程语言&#xff0c;它提供了许多内置数据结构和算法&#xff0c;可以帮助开发人员处理和操作各种数…
阅读更多...
数据结构和算法，在Python中的实现方式

数据结构和算法，在Python中的实现方式

部分数据来源&#xff1a;ChatGPT 数据结构 在计算机科学中&#xff0c;数据结构指的是计算机中用来存储和组织数据的方式。数据结构是为算法服务的&#xff0c;同一个算法在不同的数据结构上运行效率可能会有很大的不同。这就要求我们在解决问题时要根据具体情况选择合适的数…
阅读更多...
剑指 Offer 18. 删除链表的节点解题思路

剑指 Offer 18. 删除链表的节点解题思路

文章目录 题目解题思路 题目 给定单向链表的头指针和一个要删除的节点的值&#xff0c;定义一个函数删除该节点。 返回删除后的链表的头节点。 注意&#xff1a;此题对比原题有改动 示例 1: 输入: head [4,5,1,9], val 5 输出: [4,1,9] 解释: 给定你链表中值为 5 的第二…
阅读更多...
二级指针骚操作实现链表虚拟头节点

二级指针骚操作实现链表虚拟头节点

重点是不用像其他文章里那样&#xff0c;用一个普通节点成员变量当头节点&#xff0c;节省一点空间占用&#xff0c;反正我觉得有点骚。就不详细交代技术背景了&#xff0c;简而言之&#xff0c;就是链表中第一个节点前没有节点了&#xff0c;只有一个指向它的指针&#xff0c;…
阅读更多...
LeetCode_双指针_中等_82.删除排序链表中的重复元素 II

LeetCode_双指针_中等_82.删除排序链表中的重复元素 II

目录 1.题目2.思路3.代码实现&#xff08;Java&#xff09; 1.题目 给定一个已排序的链表的头 head &#xff0c; 删除原始链表中所有重复数字的节点&#xff0c;只留下不同的数字 。返回已排序的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,3,4,4,5] 输出&…
阅读更多...
数据结构与算法03：栈

数据结构与算法03：栈

目录 什么是栈&#xff1f; 栈在函数调用中的应用 栈的应用&#xff1a;如何实现浏览器的前进和后退功能&#xff1f; 每日一练&#xff1a;左右括号匹配 什么是栈&#xff1f; 简单地说&#xff0c;先进后出&#xff0c;后进先出的数据结构就是栈&#xff0c;可以理解为一…
阅读更多...
全面理解链表数据结构：各种节点操作、做题技巧，易错点分析与题目清单（C++代码示例，不断更新）

全面理解链表数据结构：各种节点操作、做题技巧，易错点分析与题目清单（C++代码示例，不断更新）

什么是链表 链表是一种线性数据结构&#xff0c;它包含的元素并不是物理上连续的&#xff0c;而是通过指针进行连接。链表中的每个元素通常由一个节点表示&#xff0c;每个节点包含一个数据元素和一个或多个链接&#xff08;指针&#xff09;。 链表的主要类型包括&#xff1a;…
阅读更多...
第二期：链表经典例题（两数相加，删除链表倒数第N个节点，合并两个有序列表）

第二期：链表经典例题（两数相加，删除链表倒数第N个节点，合并两个有序列表）

每道题后都有解析帮助你分析做题&#xff0c;答案在最下面&#xff0c;关注博主每天持续更新。 PS&#xff1a;每道题解题方法不唯一&#xff0c;欢迎讨论&#xff01; 1.两数相加 题目描述 给你两个非空的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照逆序的方式…
阅读更多...
CSDN 每日一练用例数据缺失了怎么办？

CSDN 每日一练用例数据缺失了怎么办？

CSDN 每日一练用例数据缺失了怎么办&#xff1f; 引子1、用例与结果不匹配2、阅读理解困难3、用例数据缺失 用例数据缺失&#xff0c;却有人 AC &#xff1f;神奇的 c28761 津津的储蓄计划70093 近视的小张 小结最后的吐槽 引子 老顾最近几个月经常在 CSDN 举办的周赛上浑水摸…
阅读更多...
【数据结构每日一题】栈——中心对称链

【数据结构每日一题】栈——中心对称链

[数据结构习题]栈——中心对称链 &#x1f449;知识点导航&#x1f48e;&#xff1a;【数据结构】栈和队列 &#x1f449;[王道数据结构]习题导航&#x1f48e;&#xff1a; p a g e 70.4 page70.4 page70.4 本节为栈和链表综合练习题 题目描述&#xff1a; &#x1f387;思路…
阅读更多...
单链表OJ题：LeetCode--142.环形链表Ⅱ（判断第一次入环的节点）

单链表OJ题：LeetCode--142.环形链表Ⅱ（判断第一次入环的节点）

朋友们、伙计们&#xff0c;我们又见面了&#xff0c;本期来给大家解读一下LeetCode中第142道单链表OJ题&#xff0c;如果看完之后对你有一定的启发&#xff0c;那么请留下你的三连&#xff0c;祝大家心想事成&#xff01; 数据结构与算法专栏&#xff1a;数据结构与算法 个 人…
阅读更多...
【数据结构】LinkedList与链表

【数据结构】LinkedList与链表

目录 1.链表 1.1链表的定义和分类 1.2常见方法的实现 1.3链表面试题 2.LinkedList 2.1双向链表 2.2双向链表的模拟实现 1.链表 1.1链表的定义和分类 定义&#xff1a;链表在物理存储上非连续&#xff0c;逻辑上连续。数据元素的逻辑顺序是通过链表中的引用链接次序实…
阅读更多...
静态链表(C)

静态链表(C)

静态链表同时具备链式存储和顺序存储的优点。可以直接通过下标查找&#xff1b;添加删除元素时不需要移动元素。 其本身还是顺序存储&#xff0c;只是数组中用了个游标指出下一个元素的相对位置。 datacur 初始化&#xff0c;[0]是数据链表表头&#xff1b;[1]是备用链表表头。…
阅读更多...
单链表【数据结构、数组模拟】

单链表【数据结构、数组模拟】

不采用动态链表 一般情况下&#xff0c;都是直接使用下面的代码进行模拟的 struct Node{int val;Node *next; }然后当我们需要进行创建一个新的节点时&#xff0c;都需要使用new Node()&#xff0c;非常慢&#xff01;&#xff01;&#xff01; 数据规模一般都是10w~100w的数…
阅读更多...
C++算法：有向无环图拓扑排序（领接链表）

C++算法：有向无环图拓扑排序（领接链表）

文章目录 前言一、邻接表二、代码1、生成图2、出度、入度计算3、拓扑排序 总结 前言 前文有向无环图实现游戏技能树中我们使用了矩阵存储图的关系&#xff0c;可以称之为邻接矩阵。显然&#xff0c;链表也是可以实现的。在图结构入门一文中&#xff0c;我们也提到了链表存储的…
阅读更多...
【链表Part01】| 203.移除链表元素、707.设计链表、206.反转链表

【链表Part01】| 203.移除链表元素、707.设计链表、206.反转链表

目录 ✿LeetCode203.移除链表元素❀ ✿LeetCode707.设计链表❀ ✿LeetCode206.反转链表❀ ✿LeetCode203.移除链表元素❀ 链接&#xff1a;203.移除链表元素 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff…
阅读更多...
链表内指定区间反转

链表内指定区间反转

题目&#xff1a; 将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转&#xff0c;要求时间复杂度 O(n)&#xff0c;空间复杂度 O(1)。 例如&#xff1a; 给出的链表为 1→2→3→4→5→NULL&#xff0c;m2&#xff0c;n4 返回 1→4→3→2→5→NULL 数据范围&#xff…
阅读更多...
初识单链表/单链表头指针的创建

初识单链表/单链表头指针的创建

链表的概念及结构 概念&#xff1a;链表是一种物理存储结构上非连续、非顺序的存储结构。链表不像数组中的元素那样&#xff0c;每个数据的的地址是连续的。数组的物理存储结构&#xff1a;数组中上一个数据的地址和下一个数据的地址是连续的&#xff0c;正好差一个整型大小 链…
阅读更多...
【数据结构】详解队列和循环队列

【数据结构】详解队列和循环队列

目录一.队列1.队列的概念及结构2.队列的实现Queue.hQueue.c二.循环队列1.循环队列的实现2.设计循环队列解题思路代码一.队列 1.队列的概念及结构 队列&#xff1a;只允许在一端进行插入数据操作&#xff0c;在另一端进行删除数据操作的特殊线性表&#xff0c;队列具有先进先出…
阅读更多...
学习性能所必须的知识之算法

学习性能所必须的知识之算法

什么是算法？ 通过有效地缩小查找范围，只需要很少的次数就能很快速的找到需要的数字，这样的策略或方法就称为“算法”。 算法的好坏对性能有很大的影响。 学习算法的窍门 掌握算法优点与缺陷，“折中”是一个很重要的思维通过在图上推演来思考评价算法的指标 通过复杂度（…
阅读更多...
【数据结构】C语言实现双链表

【数据结构】C语言实现双链表

目录 前言 双链表节点定义 接口函数实现 初始化函数 创建节点 打印双链表 尾插节点 尾删节点 头插节点 头删节点 指定位置前插入 删除指定位置节点 改写插入删除 判断链表是否为空 计算链表长度 销毁链表 双链表完整代码 浅谈链表及顺序表 前言 前面我们已经实…
阅读更多...
力扣刷题第一天：剑指 Offer 18. 删除链表的节点、LC206.反转链表

力扣刷题第一天：剑指 Offer 18. 删除链表的节点、LC206.反转链表

目录 零、前言 剑指 Offer 18. 删除链表的节点 一、题目描述 二、解题思路 三、完整代码 LC206.反转链表 一、题目描述 二、解题思路 三、完整代码 零、前言 这篇文章主要讲解两道链表相关的题目&#xff0c;分别是剑指 Offer 18和LC206。链表作为数据结构中重要的一…
阅读更多...
【代码题】五道链表面试题

【代码题】五道链表面试题

目录 1.移除链表元素 2.反转链表 3.链表的中间结点 4.链表中倒数第k个结点 5.合并两个有序链表 1.移除链表元素 点击进入该题 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回新的头节点 。 思路&am…
阅读更多...
08_FreeRTOS列表和列表项讲解

08_FreeRTOS列表和列表项讲解

目录 列表和列表项的简介 列表 列表项 迷你列表项 列表和列表项的关系 列表相关API函数介绍 初始化列表vListInitialise函数详解 列表项的初始化函数vListInitialiseItem函数 列表项的插入vListInsert函数 列表项末尾插入vListInsertEnd函数 列表项的删除函数uxLis…
阅读更多...
链表题目总结 -- 递归

链表题目总结 -- 递归

目录一. 递归反转整个链表1. 思路简述2. 代码3. 总结二. 反转链表前 N 个节点1. 思路简述2. 代码3. 总结三、反转链表的一部分1. 思路简述2. 代码3.总结四、反转链表后N个节点1. 思路简述2. 代码3.总结一. 递归反转整个链表 题目链接&#xff1a;https://leetcode.cn/problems…
阅读更多...
数据结构之单链表

数据结构之单链表

一、链表的组成 链表是由一个一个的节点组成的&#xff0c;节点又是一个一个的对象&#xff0c; 相邻的节点之间产生联系&#xff0c;形成一条链表。 例子&#xff1a;假如现在有两个人&#xff0c;A和B&#xff0c;A保存了B的联系方式&#xff0c;这俩人之间就有了联系。 A和…
阅读更多...
LeetCode 234. 回文链表 | C语言版

LeetCode 234. 回文链表 | C语言版

LeetCode 234. 回文链表 | C语言版LeetCode 234. 回文链表题目描述解题思路思路一&#xff1a;使用快慢双指针代码实现运行结果参考文章&#xff1a;[https://leetcode.cn/problems/palindrome-linked-list/solutions/1011052/dai-ma-sui-xiang-lu-234-hui-wen-lian-bia-qs0k/?…
阅读更多...
解决console.log打印不出深度链表问题

解决console.log打印不出深度链表问题

解决console.log打印不出深度链表问题相信大家在写算法题的时候会遇到这样一个问题&#xff0c;写了一个链表的数据结构&#xff0c;在append几个数据之后&#xff0c;想console.log打印以下看看append正不正确&#xff0c;但是&#xff0c;consolo.log出来成这个样子&#xff…
阅读更多...
数据结构:链表基础OJ练习+带头双向循环链表的实现

数据结构:链表基础OJ练习+带头双向循环链表的实现

目录 一.leetcode剑指 Offer II 027. 回文链表 1.问题描述 2.问题分析与求解 (1) 快慢指针法定位链表的中间节点 (2) 将链表后半部分进行反转 附:递归法反转链表 (3) 双指针法判断链表是否回文 二.带头双向循环链表的实现 1.头文件 2.节点内存申请接口和链表初始化接口…
阅读更多...
【排序8：对链表进行插入排序】

【排序8：对链表进行插入排序】

给定单个链表的头 head &#xff0c;使用 插入排序 对链表进行排序&#xff0c;并返回 排序后链表的头 。 插入排序 算法的步骤: 插入排序是迭代的&#xff0c;每次只移动一个元素&#xff0c;直到所有元素可以形成一个有序的输出列表。 每次迭代中&#xff0c;插入排序只从输…
阅读更多...
数据结构——顺序表(万字讲解）

数据结构——顺序表(万字讲解）

单向链表&#xff08;又名单链表、线性链表&#xff09;是链表的一种&#xff0c;其特点是链表的链接方向是单向的&#xff0c;对链表的访问要通过从头部开始&#xff0c;依序往下读取。 //单链表的打印 void SLTPrint(SLTNode* phead) {SLTNode* cur phead;while (cur){pri…
阅读更多...
【leetcode刷题之路】剑指Offer（1）——字符串+链表+双指针

【leetcode刷题之路】剑指Offer（1）——字符串+链表+双指针

文章目录 1 字符串1.1【字符串】【双指针】剑指 Offer 05 - 替换空格1.2【字符串】剑指 Offer 58 - II. 左旋转字符串1.3 【双指针】【字符串】剑指 Offer 20 - 表示数值的字符串1.4 【双指针】【字符串】剑指 Offer 67 - 把字符串转换成整数 2 链表2.1 【回溯】【链表】剑指 O…
阅读更多...
算法刷题-链表-两两交换链表中的节点

算法刷题-链表-两两交换链表中的节点

两两交换链表中的节点 24. 两两交换链表中的节点思路其他语言版本 24. 两两交换链表中的节点 力扣题目链接 给定一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后的链表。 你不能只是单纯的改变节点内部的值&#xff0c;而是需要实际的进行节点交换。 思…
阅读更多...
【数据结构与算法】深入浅出：单链表的实现和应用

【数据结构与算法】深入浅出：单链表的实现和应用

&#x1f331;博客主页&#xff1a;青竹雾色间. &#x1f618;博客制作不易欢迎各位&#x1f44d;点赞⭐收藏➕关注 ✨人生如寄&#xff0c;多忧何为 ✨ 目录 前言 单链表的基本概念 节点 头节点 尾节点 单链表的基本操作 创建单链表 头插法&#xff1a; 尾插法&#…
阅读更多...
【哈希的模拟实现】

【哈希的模拟实现】

文章目录 1 哈希概念2 哈希冲突2.1 直接定址法 (常用)2.2 除留余数法 (常用)2.3 平方取中法2.4 折叠法2.5 随机数法2.6 数学分析法 3 闭散列3.1 线性探测3.2 二次探测 4 开散列4.1 开散列概念4.2哈希桶的模拟实现4.3 开散列与闭散列的比较 1 哈希概念 顺序结构以及平衡树中&…
阅读更多...
【每日算法 数据结构(C++)】—— 06 | 合并多个有序链表（解题思路、流程图、代码片段）

【每日算法 数据结构(C++)】—— 06 | 合并多个有序链表（解题思路、流程图、代码片段）

文章目录 01 | &#x1f451; 题目描述02 | &#x1f50b; 解题思路03 | &#x1f9e2; 代码片段 Time waits for no one, cherish every moment. 岁月不居&#xff0c;时光荏苒&#xff0c;珍惜每分每秒 01 | &#x1f451; 题目描述 给你若干个有序链表&#xff0c;请将他们合…
阅读更多...
算法刷题-链表-链表相交

算法刷题-链表-链表相交

链表相交 面试题 02.07. 链表相交思路其他语言版本JavaPythonGojavaScript 面试题 02.07. 链表相交 同&#xff1a;160.链表相交 力扣题目链接 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0…
阅读更多...
3.12生产者消费者模型 3.13条件变量 3.14信号量 C++实现生产者消费者模型

3.12生产者消费者模型 3.13条件变量 3.14信号量 C++实现生产者消费者模型

3.12生产者消费者模型 生产者消费者模型中的对象&#xff1a; 1、生产者 2、消费者 3、容器 若容器已满&#xff0c;生产者阻塞在这&#xff0c;通知消费者去消费&#xff1b;若容器已空&#xff0c;则消费者阻塞&#xff0c;通知生产者去生产。生产者可以有多个&#xff0c;消…
阅读更多...
【LeetCode】-链表

【LeetCode】-链表

文章目录前言一、移除链表元素二、设计链表三、反转链表四、两两交换链表中的节点五、删除链表的倒数第N个节点六、链表相交七、环形链表 II前言 初识LeetCode与算法&#xff0c;将在此系列文章里面&#xff0c;记录自己的算法学习经历&#xff0c;前期主要是监督自己学习打卡…
阅读更多...
在JavaScript中的数据结构（队列）

在JavaScript中的数据结构（队列）

文章目录 什么是队列&#xff1f;创建队列新建队列队列可用的方法队列添加元素队列移除元素队列查看元素查看队列头元素检查队列是否为空检查队列的长度打印队列元素 完整队列代码 循环队列优先队列是什么&#xff1f;总结 什么是队列&#xff1f; 当我们在浏览器中打开新标签…
阅读更多...
接口列表-linux链表-6

接口列表-linux链表-6

linux内核里的字符串转换 ,链表操作常用函数(转)
阅读更多...
一学就会-----链表的回文结构

一学就会-----链表的回文结构

文章目录 题目描述思路代码示例 题目描述 对于一个链表&#xff0c;请设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法&#xff0c;判断其是否为回文结构。 给定一个链表的头指针A&#xff0c;请返回一个bool值&#xff0c;代表其是否为回文结构。保证链表长度小于等于90…
阅读更多...
【1171. 从链表中删去总和值为零的连续节点】

【1171. 从链表中删去总和值为零的连续节点】

来源&#xff1a;力扣&#xff08;LeetCode&#xff09; 描述&#xff1a; 给你一个链表的头节点 head&#xff0c;请你编写代码&#xff0c;反复删去链表中由 总和 值为 0 的连续节点组成的序列&#xff0c;直到不存在这样的序列为止。 删除完毕后&#xff0c;请你返回最终…
阅读更多...
两个链表的第一个公共结点

两个链表的第一个公共结点

描述 输入两个无环的单向链表&#xff0c;找出它们的第一个公共结点&#xff0c;如果没有公共节点则返回空。&#xff08;注意因为传入数据是链表&#xff0c;所以错误测试数据的提示是用其他方式显示的&#xff0c;保证传入数据是正确的&#xff09; 数据范围&#xff1a; 0n…
阅读更多...
Java并发容器 并发队列

Java并发容器 并发队列

并发容器概览 ConcurrentHashMap : 线程安全的HashMap CopyOnWriteArrayList: 线程安全的List BlockingQueue:这是一个接口&#xff0c;表示阻塞队列&#xff0c;非常适合用于作为数据共享的通道 ConcurrentLinkedQueue : 高效的非阻塞并发队列&#xff0c;使用链表实现。可…
阅读更多...
【数据结构与算法篇】深入浅出——二叉树（详解）

【数据结构与算法篇】深入浅出——二叉树（详解）

​&#x1f47b;内容专栏&#xff1a;《数据结构与算法专栏》 &#x1f428;本文概括&#xff1a; 二叉树是一种常见的数据结构&#xff0c;它在计算机科学中广泛应用。本博客将介绍什么是二叉树、二叉树的顺序与链式结构以及它的基本操作&#xff0c;帮助读者理解和运用这一重…
阅读更多...
SkipList（跳表）

SkipList（跳表）

基本概述 SkipList&#xff08;跳表&#xff09;首先是链表&#xff0c;但与传统链表相比有几点差异&#xff1a; 元素按照升序排列存储节点可能包含多个指针&#xff0c;指针跨度不同【根据元素个数不同&#xff0c;可以建立多级指针&#xff08;最多可以建立32级指针&#…
阅读更多...
Redis从入门到精通【高阶篇】之底层数据结构链表包(listpacks)详解

Redis从入门到精通【高阶篇】之底层数据结构链表包(listpacks)详解

文章目录 0.前言2. listpacks&#xff08;紧凑列表&#xff09;2. 源码解析3. 总结 0.前言 上个篇章回顾&#xff0c;我们上个章节我们学习了《Redis从入门到精通【高阶篇】之底层数据结构字典(Dictionary)详解》 本文将Redis底层数据结构 listpacks&#xff08;链表包&#…
阅读更多...
Leetcode24 两两交换节点

Leetcode24 两两交换节点

1. 思路 交换两个指针的操作&#xff0c;比较基础。只不是是在处理指针的操作上加入了递归节点&#xff0c;因为prev的下一个节点还没有完全确定&#xff0c;所以需要用递归的方式来代替 2. Python3实现 class Solution:def swapPairs(self, head: Optional[ListNode]) ->…
阅读更多...
Floyd 判圈算法(Floyd Cycle Detection Algorithm)

Floyd 判圈算法(Floyd Cycle Detection Algorithm)

Floyd 判圈算法(Floyd Cycle Detection Algorithm) 前言 Floyd判圈算法属于对指针操作的算法&#xff0c;它一般需要且仅需要两个指针&#xff0c;通过设定不同的指针移动速度&#xff0c;来判定链表或有限状态机中是否存在环。人为规定移动较快的指针称为快速指针(fast poin…
阅读更多...
Flutter 自定义实现时间轴、侧边进度条

Flutter 自定义实现时间轴、侧边进度条

时间轴和侧边进度条是非常常见的 UI 控件&#xff0c;它们可以增强应用的视觉效果和交互体验。在这篇文章中&#xff0c;我们将详细介绍如何使用 Flutter 自定义实现这两个控件。 时间轴 时间轴是一个用于显示时间或进度的控件&#xff0c;通常在一些时间线上用于展示事件的发…
阅读更多...
数据结构栈的代码实现(C语言)

数据结构栈的代码实现(C语言)

一 、栈的顺序代码实现 初始化一个空栈 bool InitStack(SqStack *s) {s->base (ElemType *) malloc(STACK_INIT_SIZE * sizeof(ElemType));if(s->base NULL) {return false;}s->top s->base;s->stack_size STACK_INIT_SIZE;return true; }判断栈是否为空 …
阅读更多...
线性表的代码实现(C语言)

线性表的代码实现(C语言)

一 、线性表顺序结构实现 初始化一个空的线性表 int InitList(SqList *L){L->elem (ElemType *) malloc(list_init_size * sizeof(ElemType));if (!L->elem) {exit(OVERFLOW);}L->length 0;L->listsize list_init_size;return OK; }向线性表中添加元素 int I…
阅读更多...
LeetCode刷题----链表【2020第一版】

LeetCode刷题----链表【2020第一版】

0.摘要 链表应该是面试中被问得最频繁的数据结构。 原因&#xff1a; ①链表通过指针将若干个节点连接成链状结构&#xff0c;其"增删改查"操作易于实现。 ②链表需要对指针的操作&#xff0c;需要较好的编程功底。 1. 8道经典链表题目 1.1 链表逆序(eazy) Q: 已知…
阅读更多...
深入学习ArrayList 和 LinkedList类

深入学习ArrayList 和 LinkedList类

先来看一小段程序&#xff0c;实现了一个简易记事本的功能&#xff1b; import java.awt.event.*; import java.util.*; import javax.swing.*; public class JAVA链表系统库 {static JFrame f new JFrame();static MPanel mp new MPanel();public static void main(String a…
阅读更多...
【剑指 Offer 06. 从尾到头打印链表】（List＜Integer＞转int[]）

【剑指 Offer 06. 从尾到头打印链表】（List＜Integer＞转int[]）

【解题思路】 将链表的值放入list数组中&#xff0c;再将数组逆置。 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode(int x) { val x; }* }*/ class Solution {public int[] reversePrint(ListNode hea…
阅读更多...
LWN：实现maple tree！

LWN：实现maple tree！

关注了就能看到更多这么棒的文章哦&#xff5e; Introducing maple trees February 12, 2021 This article was contributed by Marta Rybczyńska DeepL assisted translation https://lwn.net/Articles/845507/ 在外界看来&#xff0c;Linux 内核的内部似乎变化很少&#xff…
阅读更多...
leetcode61. 旋转链表(java)

leetcode61. 旋转链表(java)

旋转链表 leetcode61. 旋转链表题目描述 解题思路代码演示链表专题 leetcode61. 旋转链表 Leetcode链接&#xff1a; https://leetcode.cn/problems/rotate-list/ 题目描述 给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 示例…
阅读更多...
单链表OJ题：LeetCode--160.相交链表

单链表OJ题：LeetCode--160.相交链表

朋友们、伙计们&#xff0c;我们又见面了&#xff0c;本期来给大家解读一下LeetCode中第160道单链表OJ题&#xff0c;如果看完之后对你有一定的启发&#xff0c;那么请留下你的三连&#xff0c;祝大家心想事成&#xff01; 数据结构与算法专栏&#xff1a;数据结构与算法 个 人…
阅读更多...
堆-链表实现

堆-链表实现

小顶堆大顶堆的概念大家应该都很熟悉了&#xff0c;如果不了解&#xff0c;可以搜索一下&#xff0c;网上很多介绍&#xff0c;而且很多源码实现&#xff0c;都很简单。 不过从网上看了一些堆的实现&#xff0c;都是用数组的。但是数组有一个缺陷&#xff0c;需要扩展时&#…
阅读更多...
二叉树的相关操作

二叉树的相关操作

一.二叉树 本文的数据结构基于C语言练习。 C语言中的二叉树是一种数据结构&#xff0c;用于表示具有层次关系的数据集合。它由一个根节点开始&#xff0c;每个节点最多有两个子节点&#xff0c;分别称为左子节点和右子节点。 二叉树有许多相关性质&#xff0c;其中一些重要的包…
阅读更多...
力扣----环形链表

力扣----环形链表

&#x1f388;个人主页:&#x1f388; :✨✨✨初阶牛✨✨✨ &#x1f43b;推荐专栏1: &#x1f354;&#x1f35f;&#x1f32f;C语言初阶 &#x1f43b;推荐专栏2: &#x1f354;&#x1f35f;&#x1f32f;C语言进阶 &#x1f511;个人信条: &#x1f335;知行合一 金句分享:…
阅读更多...
【算法题】链表系列之从尾到头打印链表、重建二叉树、用两个栈实现队列

【算法题】链表系列之从尾到头打印链表、重建二叉树、用两个栈实现队列

【算法题】链表系列 一、从尾到头打印链表1.1、题目描述1.2、递归法1.3、栈&#xff08;stack&#xff09; 二、重建二叉树2.1、题目描述2.2、前置知识&#xff1a;2.3、分治算法2.4、小结 三、用两个栈实现队列3.1、题目描述3.2、双栈法3.3、小结 总结 一、从尾到头打印链表 …
阅读更多...
【数据结构】——单链表的各功能实现

【数据结构】——单链表的各功能实现

【数据结构】——单链表的各功能实现 花了一些时间将单链表实现了一遍&#xff0c;基本涵盖了单链表的所有功能与算法&#xff0c;先上代码&#xff0c;写实验报告的同学可以直接白嫖。 具体功能如下&#xff1a; 这个是带头结点的单链表 #include <cstdio> #include…
阅读更多...
C语言堆栈详解

C语言堆栈详解

C语言堆栈详解 #include <stdio.h> #include <malloc.h> #include <stdlib.h>typedef struct Node {int data;struct Node* pNext; }NODE, * PNODE;typedef struct Stack {PNODE pTop;PNODE pBottom; }STACK, * PSTACK;void init(PSTACK); //初始化函数 void…
阅读更多...
LeetCode 148. 排序链表（归并和快速排序）

LeetCode 148. 排序链表（归并和快速排序）

2021年04月18日 周日 天气晴 【不悲叹过去&#xff0c;不荒废现在&#xff0c;不惧怕未来】 本文目录1. 题目简介2. 题解2.1 快速排序2.1.1 值交换&#xff08;1&#xff09;递归&#xff08;2&#xff09;迭代2.1.2 指针交换2.2 归并排序&#xff08;1&#xff09;递归&#x…
阅读更多...
[LeetCode]445. 两数相加 II（使用链表翻转或两个辅助栈）

[LeetCode]445. 两数相加 II（使用链表翻转或两个辅助栈）

两数相加 II 给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。 你可以假设除了数字 0 之外&#xff0c;这两个数字都不会以零开头。 示例&#xff1a; 输入&#xff1a;(7 -> 2 -&g…
阅读更多...
python3 链表中删除指定值的节点

python3 链表中删除指定值的节点

class LNode:def __init__(self, elem, next_None):self.elem elemself.next next_def AddToTail(head, elem):if type(head) is not LNode and head is not None:#如果head的类型不是LNode且head不是None&#xff0c;则直接返回&#xff0c;不做处理print("")retu…
阅读更多...
LinkedList容器类

LinkedList容器类

ArrayList、Vector和LinkedList在底层存储元素时所使用的结构不同&#xff0c;ArrayList、Vector在底层用的是数组存储元素&#xff0c;LinkedList底层用双向链表实现的存储。特点&#xff1a;查询效率低&#xff0c;增删效率高&#xff0c;线程不安全。 双向链表也叫双链表&a…
阅读更多...
【linux kernel】linux内核数据结构分析之链表

【linux kernel】linux内核数据结构分析之链表

&#x1f440;Linux内核中实现了一套经典的链表操作&#xff0c;定义在/include/linux/list.h文件中&#xff0c;本文基于linux内核源码6.2.7&#xff0c;记录了其常用操作链表的API函数&#xff0c;便于在阅读linux内核源码时更好的理解程序执行的过程和细节。 文章目录 &…
阅读更多...
（十八）剑指offer之复杂链表的复制

（十八）剑指offer之复杂链表的复制

题目描述&#xff1a; 输入一个复杂链表&#xff08;每个节点中有节点值&#xff0c;以及两个指针&#xff0c;一个指向下一个节点&#xff0c;另一个特殊指针指向任意一个节点&#xff09;&#xff0c;返回结果为复制后复杂链表的head。 注意&#xff1a;输出结果中请不要返…
阅读更多...
【力扣面试】面试题 02.07. 链表相交

【力扣面试】面试题 02.07. 链表相交

【力扣面试】面试题 02.07. 链表相交 文章目录题目解题思路代码题目 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证…
阅读更多...
C语言中的二级指针 -- 链表操作

C语言中的二级指针 -- 链表操作

https://blog.csdn.net/jasonchen_gbd/article/details/45276629 总结&#xff1a;其实链表使用二级指针的好处就是&#xff0c;不管是头插尾插等操作后&#xff0c;链表的根节点地址不需要改变。如果链表是全局变量&#xff0c;那么就不用操作链表后返回该链表的根节点地址。…
阅读更多...
数据结构课设——散列文件的插入、删除和查找

数据结构课设——散列文件的插入、删除和查找

题目 功能要求&#xff1a; &#xff08;1&#xff09;初始化散列文件&#xff1b; &#xff08;2&#xff09;向散列文件中插入一个元素&#xff1b; &#xff08;3&#xff09;从散列文件中删除一个元素&#xff1b; &#xff08;4&#xff09;从散列文件中查找一个元素。 散…
阅读更多...
刷穿LeetCode——Task13

刷穿LeetCode——Task13

这篇博客记录刷题13天的学习心得。 160.相交链表 编写一个程序&#xff0c;找到两个单链表相交的起始节点。 如下面的两个链表&#xff1a; 在节点 c1 开始相交。 示例 1&#xff1a; 输入&#xff1a;intersectVal 8, listA [4,1,8,4,5], listB [5,0,1,8,4,5], skipA …
阅读更多...
数据结构——线性表练习1

数据结构——线性表练习1

题目描述 将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中不允许有重复的数据。 程序 #include <bits/stdc.h> using namespace std; typedef int Elemtype; typedef struct LNode {Elemty…
阅读更多...
链表（上）：如何实现LRU缓存淘汰算法?

链表（上）：如何实现LRU缓存淘汰算法?

链表是一种最基础的数据结构&#xff0c;学习链表有什么用&#xff1f;为了回答这个问题&#xff0c;先来讨论一个经典的链表应用场景&#xff0c;那就是 LRU 缓存淘汰算法。 缓存是一种提高数据读取性能的技术&#xff0c;在硬件设计、软件开发中都有着非常广泛的应用&#xf…
阅读更多...
喔嚯霍，二叉树的遍历，先序，中序，后序原来这么简单（附代码）！！！

喔嚯霍，二叉树的遍历，先序，中序，后序原来这么简单（附代码）！！！

二叉树的遍历 既然想要明白二叉树的遍历&#xff0c;那我们是不是要首先明白什么是二叉树呀&#xff1f;【手动狗头】 1.认识我们的二叉树兄弟 至于中间这多了一条腿的家伙&#xff0c;我打保票他肯定不是二叉树&#xff01;&#xff01;&#xff01;【手动狗头】 听到二叉…
阅读更多...
java单向链表按某值划分成左边小，中间相等，右边大的形式

java单向链表按某值划分成左边小，中间相等，右边大的形式

【题目】 给定一个单链表的头节点head&#xff0c;节点值类型是整型&#xff0c;在给定一个整数pivot&#xff0c;实现一个调整链表的函数&#xff0c;将链表调整为&#xff0c;左边部分是小于pivot的节点&#xff0c;中间是等于的&#xff0c;右侧是大于的 【要求】 调整后节点…
阅读更多...
java打印有序链表的公共部分

java打印有序链表的公共部分

【题目】 给定2个有序链表的头指针head1和head2&#xff0c;打印两个链表的公共部分 【要求】 两个量表总长度为N&#xff0c;时间复杂度为O(N),二娃空间复杂度O(1) public class Node{public int value;public Node next;public Node(int value) {this.value value;} }pri…
阅读更多...
【C/C++数据结构】链表与快慢指针

【C/C++数据结构】链表与快慢指针

目录 一、单链表 二、双向循环链表 三、判断链表是否带环 四、链表的回文结构判断 五、复制带随机指针的链表 一、单链表 优点&#xff1a;头部增删效率高&#xff0c;动态存储无空间浪费 缺点&#xff1a;尾部增删、遍历效率低&#xff0c;不支持随机访问节点 头结点&…
阅读更多...
快慢指针在链表中的应用

快慢指针在链表中的应用

判断链表中是否存在环 让快慢指针从链表头开始遍历&#xff0c;快指针向前移动两个位置&#xff0c;慢指针向前移动一个位置;如果快指针到达NULL&#xff0c;说明链表以NULL为结尾&#xff0c;不是循环链表。如果 快指针追上慢指针&#xff0c;则表示出现了循环。 bool hasCycl…
阅读更多...
【算法题】剪绳子、计算二进制中1的个数、数值的整数次方

【算法题】剪绳子、计算二进制中1的个数、数值的整数次方

剪绳子、计算二进制中1的个数、数值的整数次方 一、剪绳子1.1、题目描述1.2、思路1.3、代码实现&#xff1a;1.4、华丽的快速幂取余1.5、小结 二、数值的整数次方2.1、题目描述2.2、思路2.3、代码实现2.4、小结 三、计算二进制中1的个数3.1、题目描述3.2、思路3.3、代码实现3.4…
阅读更多...
大厂可能会问的那些思维题和技术点

大厂可能会问的那些思维题和技术点

精选大厂可能会问的那些思维题和技术点 一、题目一1.1、思路&#xff1a;1.2、代码实现 二、题目二三、const 的含义及实现机制, ,比如 : const int i, 是怎么做到 i 只可读的? ?四、到商店里买 200 的商品返还 100 优惠券( ( 可以在本商店代替现金) ) 。请问实际上折扣是多少…
阅读更多...
278. 第一个错误的版本——二分查找

278. 第一个错误的版本——二分查找

class Solution { public:int firstBadVersion(int n) {int left 1, right n, ans n;while(left < right){//以后尽量还是写下面这个格式的&#xff0c;防止INT型溢出int mid left (right - left) / 2;//如果false向左找&#xff0c;true向右找if(!isBadVersion(mid))l…
阅读更多...
链表的增删改查

链表的增删改查

#include<stdio.h> #include<math.h>//定义一个结点数据结构 typedef struct Node{int data; //数据域struct Node* pNext; //指针域 }NODE, *PNODE;//NODE > struct Node //PNODE > struct Node *//函数声明 PNODE create_list(); void traverse_list(PNODE…
阅读更多...
嵌入式大杂烩周记 | 第 3 期：sys/queue.h

嵌入式大杂烩周记 | 第 3 期：sys/queue.h

大家好&#xff0c;我是杂烩君。 嵌入式大杂烩周记主要是一些实用项目学习分享&#xff0c;每周一篇&#xff0c;每篇一个主题。 内容主要来源于我们之前收集的资料&#xff1a; https://gitee.com/zhengnianli/EmbedSummary 本期主角&#xff1a;sys/queue.h queue.h是Linux、…
阅读更多...
leetcode每日一道（9）：判断给定的链表中是否有环

leetcode每日一道（9）：判断给定的链表中是否有环

题目描述 判断给定的链表中是否有环 扩展&#xff1a; 你能给出不利用额外空间的解法么&#xff1f; 思路 快慢指针 代码 class Solution { public:bool hasCycle(ListNode *head) {if (!head)return 0;auto fast head, slow head;while(fast&&fast->next){fas…
阅读更多...
数据结构之顺序表和链表的区别

数据结构之顺序表和链表的区别

顺序表和链表的区别 存储空间上 顺序存储结构用一段连续的存储单元依次存储线性表的数据元素&#xff0c;物理上连续 链式存储结构用一组任意的存储单元存放线性表的元素&#xff0c;逻辑上连续&#xff0c;但物理上不一定连续(逻辑上就是我们想象出来的&#xff0c;看着它是链…
阅读更多...
19. 删除链表的倒数第 N 个结点——双指针

19. 删除链表的倒数第 N 个结点——双指针

原版 class Solution { public:ListNode* removeNthFromEnd(ListNode* head, int n) {if(!head->next) return nullptr;ListNode *l_ptr head, *r_ptr head;for(int i 0; i < n; i){r_ptr r_ptr->next;}while(r_ptr && r_ptr->next){l_ptr l_ptr->…
阅读更多...
排序算法分析及代码实现——五类九种排序（面试考研必备）

排序算法分析及代码实现——五类九种排序（面试考研必备）

目录一、前言二、插入排序2.1 直接插入排序2.2 折半插入排序2.3 希尔插入排序三、交换排序3.1 冒泡排序3.2 快速排序四、选择排序4.1 简单选择排序4.2 堆排序堆定义堆排序思想分析五、归并排序递归算法非递归算法六、基数排序七、对比一、前言 排序算法是一类很经典的算法&…
阅读更多...
初识链表-linux链表-1

初识链表-linux链表-1

目的&#xff1a; 初识链表操作 参考&#xff1a; linux 应用层编程之内核链表list的使用 linux中链表的使用 Linux内核中经典链表 list_head 常见使用方法解析
阅读更多...
(Java算法)剑指offer-面试题59 - I. 滑动窗口的最大值

(Java算法)剑指offer-面试题59 - I. 滑动窗口的最大值

给定一个数组 nums 和滑动窗口的大小 k&#xff0c;请找出所有滑动窗口里的最大值。 示例: 输入: nums [1,3,-1,-3,5,3,6,7], 和 k 3 输出: [3,3,5,5,6,7] 解释: 滑动窗口的位置 最大值 [1 3 -1] -3 5 3 6 7 3 1 [3 -1 -3] 5 3 6 7 3 1 3 [-1 -3 5] 3 6 7 …
阅读更多...
链表从指定节点后方插入新节点

链表从指定节点后方插入新节点

插入新节点的方法 1.节点后 2.节点前 如果要在3的后面插入&#xff1b; 第一步&#xff0c;找到3 第二步&#xff0c;new->next 3->next(新节点的下一个等于3的下一个) 第三步&#xff0c;3->next new&#xff08;让3的下一个等于new&#xff09; 建立函数&#x…
阅读更多...
C++ 链表、栈、队列

C++ 链表、栈、队列

一、C 链表 链表实际上是线性表的链式存储结构&#xff0c;与数组不同的是&#xff0c;它是用一组任意的存储单元来存储线性表中的数据&#xff0c;存储单元不一定是连续的&#xff0c; 且链表的长度不是固定的&#xff0c;链表数据的这一特点使其可以非常的方便地实现节点的…
阅读更多...
java基础 Map补充LinkedHashMap，TreeMap，以及Properties类,Set。

java基础 Map补充LinkedHashMap，TreeMap，以及Properties类,Set。

因为前面讲hashMap的源码&#xff0c;发现太长了&#xff0c;所以本章作为补充&#xff0c;毕竟Map的接口下还有其他常用的实现类&#xff0c;所以本篇是讲LinkedHashMap还有TreeMap&#xff0c;以及Properties类。 LinkedHashMap 看名知其意&#xff0c;也是一个链表结构&am…
阅读更多...
java基础 哈希表入门理解

java基础 哈希表入门理解

在集合类会看见很多这个单词hash。hash其实就是一种存储的算法叫做哈希表。 而理解哈希表&#xff0c;其实需要有几个前提&#xff1a;数组&#xff0c;模运算&#xff0c;链表。 先声明本章不会讲的多深&#xff0c;如果需要进阶的朋友就不要看了&#xff0c;因为看了也不会…
阅读更多...
链表节点个数及查找

链表节点个数及查找

链表节点个数 先定义一个整形函数&#xff0c;因为节点个数肯定是整型变量。 int huoqujiediannum(struct Test *head) {int cnt 0;while(head ! NULL){cnt;head head->next;}printf("cnt %d\n",cnt);return cnt; }然后在main函数里面调用定义的函数。 int …
阅读更多...
数据结构List示例（一）:链表反转

数据结构List示例（一）:链表反转

链式存储结构就是两个相邻的元素在内存中可能不是相邻的&#xff0c;每一个元素都有一个指针域&#xff0c;指针域一般是存储着到下一个元素的指针。这种存储方式的优点是插入和删除的时间复杂度为O(1)&#xff0c;不会浪费太多内存&#xff0c;添加元素的时候才会申请内存&…
阅读更多...
链表静态添加和动态遍历

链表静态添加和动态遍历

如果链表中得变量多了怎么办&#xff1f; struct Test t1 {1,NULL};struct Test t2 {2,NULL};struct Test t3 {3,NULL};struct Test t4 {4,NULL};t1.next &t2;t2.next &t3;t3.next &t4;那就不能用这种办法了。 printf("%d %d %d %d\n",t1.data,t…
阅读更多...
链表是个好东西

链表是个好东西

1.什么是链表 我的理解-是数据结构&#xff0c;是一种数据存放的思想。 官方的&#xff1b;链表是一种物理存储单元上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 2. 链表的优点 连表的每一项都是一个结构体&#xff0c;链表…
阅读更多...
(java)leetcode 147.对链表进行插入排序

(java)leetcode 147.对链表进行插入排序

题目解读&#xff1a; 题目给了我们基本的链表的结构&#xff1a; /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode(int x) { val x; }* }*/然后我们依据人家传过来的链表头&#xff0c;通过next&#…
阅读更多...
LeetCode 237. 删除链表中的节点

LeetCode 237. 删除链表中的节点

原题链接 难度&#xff1a;middle\color{orange}{middle}middle 题目描述 有一个单链表的 headheadhead&#xff0c;我们想删除它其中的一个节点 nodenodenode。 给你一个需要删除的节点 nodenodenode 。你将 无法访问 第一个节点 headheadhead。 链表的所有值都是 唯一的&…
阅读更多...
链表学习基础

链表学习基础

链表 通过指针串联在一起的线性结构&#xff0c;每个节点由数据域和指针域两部分组成。链表节点在内存中的存储通常不是连续的&#xff0c;各节点通过指针连接在一起&#xff0c;其内存分布大致如下图所示。 定义 单链表 struct ListNode {// DATATYPE 可以是任意存放数据的…
阅读更多...
链表学习之链表划分

链表学习之链表划分

链表解题技巧 额外的数据结构&#xff08;哈希表&#xff09;&#xff1b;快慢指针&#xff1b;虚拟头节点&#xff1b; 链表划分 将单向链表值划分为左边小、中间相等、右边大的形式。中间值为pivot划分值。 要求&#xff1a;调整之后节点的相对次序不变&#xff0c;时间复…
阅读更多...
链表OJ（三） 反转链表合集

链表OJ（三） 反转链表合集

目录 反转链表 反转链表 II 链表中的节点每k个一组翻转 描述 给定一个单链表的头结点pHead(该头节点是有值的&#xff0c;比如在下图&#xff0c;它的val是1)&#xff0c;长度为n&#xff0c;反转该链表后&#xff0c;返回新链表的表头。 数据范围&#xff1a; 0≤n≤10000≤…
阅读更多...
数据结构之顺序表篇

数据结构之顺序表篇

一、顺序表概念 二、顺序表各类接口实现 *顺序表初始化 **顺序表销毁 ***顺序表插入操作 ****顺序表删除操作 *****顺序表查找操作 ******顺序表实现打印操作 三、顺序表整体实现源码 *SeqList.h **SeqList.c ***test.c 一、顺序表概念 讲顺序表之前先引入线性表概念&#xff…
阅读更多...
数据结构与算法—链表list

数据结构与算法—链表list

目录 链表 链表类型 链表插入 链表删除 写程序注意点 与数组区别 链表应用 LRU 实现思想 链表 链表&#xff0c;一种提高数据读取性能的技术&#xff0c;在硬件设计、软件开发中有广泛应用。常见CPU缓存&#xff0c;数据库缓存&#xff0c;浏览器缓存等。缓存满时&#…
阅读更多...
LeetCode 热题 100 | 链表（中上）

LeetCode 热题 100 | 链表（中上）

目录 1 141. 环形链表 1.1 哈希表 1.2 快慢指针 2 142. 环形链表 II 2.1 哈希表 2.2 快慢指针 3 21. 合并两个有序链表 4 2. 两数相加 菜鸟做题第三周&#xff0c;语言是 C 1 141. 环形链表 1.1 哈希表 解题思路&#xff1a;遍历链表&#xff0c;在哈希表中…
阅读更多...
【蓝桥杯】环形链表的约瑟夫问题

【蓝桥杯】环形链表的约瑟夫问题

目录 题目描述&#xff1a; 输入描述&#xff1a; 输出描述&#xff1a; 示例1 解法一&#xff08;C&#xff09;&#xff1a; 解法二&#xff08;Cpp&#xff09;&#xff1a; 正文开始&#xff1a; 题目描述&#xff1a; 据说著名犹太历史学家 Josephus 有过以下故事&a…
阅读更多...
java数据结构与算法刷题-----LeetCode15. 三数之和

java数据结构与算法刷题-----LeetCode15. 三数之和

java数据结构与算法刷题目录&#xff08;剑指Offer、LeetCode、ACM&#xff09;-----主目录-----持续更新(进不去说明我没写完)&#xff1a;https://blog.csdn.net/grd_java/article/details/123063846 解题思路 和LeetCode1.两数之和一样&#xff0c;但是这道题边界条件更多。…
阅读更多...
一篇文章了解区分指针数组，数组指针，函数指针，链表。

一篇文章了解区分指针数组，数组指针，函数指针，链表。

最近在学习指针&#xff0c;发现指针有这许多的知识&#xff0c;其中的奥妙还很多&#xff0c;需要学习的也很多&#xff0c;今天那我就将标题中的有关指针知识&#xff0c;即指针数组&#xff0c;数组指针&#xff0c;函数指针&#xff0c;给捋清楚这些知识点&#xff0c;区分…
阅读更多...
算法学习——LeetCode力扣链表篇2

算法学习——LeetCode力扣链表篇2

算法学习——LeetCode力扣链表篇2 24. 两两交换链表中的节点 24. 两两交换链表中的节点 - 力扣&#xff08;LeetCode&#xff09; 描述 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&…
阅读更多...
【数据结构与算法】(7)基础数据结构之双端队列的链表实现、环形数组实现示例讲解

【数据结构与算法】(7)基础数据结构之双端队列的链表实现、环形数组实现示例讲解

目录 2.6 双端队列1) 概述2) 链表实现3) 数组实现习题E01. 二叉树 Z 字层序遍历-Leetcode 103 2.6 双端队列 1) 概述 双端队列、队列、栈对比 定义特点队列一端删除&#xff08;头&#xff09;另一端添加&#xff08;尾&#xff09;First In First Out栈一端删除和添加&…
阅读更多...
C语言数据结构之顺序表的增删改查

C语言数据结构之顺序表的增删改查

C语言数据结构之顺序表的增删改查 tips&#xff1a;前些天学习了链表的操作以及相关的数据结构&#xff0c;今天我们来学习一下c语言数据结构之顺序表的增删改查。 顺序表采用顺序存储&#xff0c;即把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中&#xff0c;元素之间…
阅读更多...
反转列表中head.next.next = head； head.next = null；

反转列表中head.next.next = head； head.next = null；

head.next.next head; head.next null; 这段代码意思 如下 4->5 代码走到54行的时候,直接变成套娃了 4->5>4>5>4>5 走到55行变成5->4 力扣的递归
阅读更多...
牛客网《剑指Offer》（3）从尾到头打印链表

牛客网《剑指Offer》（3）从尾到头打印链表

题目描述 输入一个链表&#xff0c;按链表从尾到头的顺序返回一个ArrayList。 题目分析 链表反转一般有三种方法&#xff1a;1、递归&#xff1b;2、栈&#xff1b;3、节点替换。 下面介绍前两种方法&#xff0c;第三种方法后面还有一道链表反转的题&#xff0c;在那详细介…
阅读更多...
C语言数据结构之栈(链表实现)

C语言数据结构之栈(链表实现)

C语言数据结构之栈(链表实现) tips:前些天学习了单链表的增删改查&#xff0c;对于双向链表和循环链表而言&#xff0c;无非就是对单链表的指针进行稍微的变换。今天来看看c语言数据结构之栈的实现以及栈的各种操作。 栈的特点是先进后出&#xff0c;后进先出&#xff0c;因此…
阅读更多...
C语言数据结构之链表的增删改查

C语言数据结构之链表的增删改查

C语言数据结构之链表的增删改查 tips:昨天学习了c语言结构体&#xff0c;今天来看看c语言数据结构之链表(单链表)的增删改查操作 首先我们创建一个简单的学生信息结构体&#xff0c;作为后面增删改查的主体 student结构体包含 数据域&#xff1a;学号&#xff0c;分数&#xf…
阅读更多...
LeetCode237：删除链表中的节点

LeetCode237：删除链表中的节点

/*请编写一个函数&#xff0c;使其可以删除某个链表中给定的&#xff08;非末尾&#xff09;节点&#xff0c;你将只被给定要求被删除的节点。 现有一个链表 -- head [4,5,1,9],请删除这个链表的node节点 */ /* 由于我们无法得到这个链表&#xff0c;所以我们将要删除的node节…
阅读更多...
【Java】带你从零到一系列8 画图带你从顺序表到链表1

【Java】带你从零到一系列8 画图带你从顺序表到链表1

前言&#xff1a;顺序表与链表是非常基本的数据结构&#xff0c;它们可以被统称为线性表。他们是学好数据结构的基础。而对于学习Java编程语言来说&#xff0c;也有着提高代码量和思维方式的好处&#xff0c;所以本篇我们来介绍顺序表和链表。 每文一图&#xff1a; 画图带你从…
阅读更多...
单链表课后算法设计题——数据结构C语言版严蔚敏

单链表课后算法设计题——数据结构C语言版严蔚敏

文章目录算法设计题2、(3)算法设计题2、&#xff08;4&#xff09;求并集算法设计题2、(3) 【题目】 已知两个链表A和链表B分别表示两个集合,其元素递增排列。请设计一个算法用于求出A和B的交集,并存放到A链表中。 【思路分析】 1、定义两个指针a、b分别指向链表A和链表B的…
阅读更多...
【力扣面试】面试题 02.05. 链表求和

【力扣面试】面试题 02.05. 链表求和

【力扣面试】面试题 02.05. 链表求和 文章目录题目解题思路&#xff1a;代码题目 给定两个用链表表示的整数&#xff0c;每个节点包含一个数位。 这些数位是反向存放的&#xff0c;也就是个位排在链表首部。 编写函数对这两个整数求和&#xff0c;并用链表形式返回结果。 示例&…
阅读更多...
（十一）剑指offer之反转链表和合并链表

（十一）剑指offer之反转链表和合并链表

1、题目描述&#xff1a; 输入一个链表&#xff0c;反转链表后&#xff0c;输出链表的所有元素。 /* struct ListNode {int val;struct ListNode *next;ListNode(int x):val(x), next(NULL) {} };*/ class Solution { public:ListNode* ReverseList(ListNode* pHead) {if(pHe…
阅读更多...
【力扣面试】面试题 02.04. 分割链表

【力扣面试】面试题 02.04. 分割链表

【力扣面试】面试题 02.04. 分割链表 文章目录题目解题思路代码题目 给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你不需要 保留 每个分区中各节点的初始相对位置。 示例 …
阅读更多...
牛客 剑指Offer 输出链表的倒数第k个节点

牛客 剑指Offer 输出链表的倒数第k个节点

题目 输入一个链表&#xff0c;输出该链表中倒数第k个结点。 代码和解释 \qquad这道题目是一道很经典的题目&#xff0c;并且是某一年的408考题。题目求的是倒数第k个节点&#xff0c;如果直接遍历&#xff0c;求出链表的长度的话&#xff0c;会需要多次遍历&#xff0c;有种…
阅读更多...
【力扣面试】面试题 02.03. 删除中间节点

【力扣面试】面试题 02.03. 删除中间节点

【力扣面试】面试题 02.03. 删除中间节点 文章目录题目解题思路代码题目 若链表中的某个节点&#xff0c;既不是链表头节点&#xff0c;也不是链表尾节点&#xff0c;则称其为该链表的「中间节点」。 假定已知链表的某一个中间节点&#xff0c;请实现一种算法&#xff0…
阅读更多...
【力扣面试】面试题 02.02. 返回倒数第 k 个节点

【力扣面试】面试题 02.02. 返回倒数第 k 个节点

【力扣面试】面试题 02.02. 返回倒数第 k 个节点 文章目录题目解题思路题目 实现一种算法&#xff0c;找出单向链表中倒数第 k 个节点。返回该节点的值。 注意&#xff1a;本题相对原题稍作改动 示例&#xff1a; 输入&#xff1a; 1->2->3->4->5 和 k 2 输出&…
阅读更多...
Redis访问速度很快只是因为它是内存数据库吗？

Redis访问速度很快只是因为它是内存数据库吗？

对于Redis这种内存数据库来说&#xff0c;除了访问的是内存之外&#xff0c;Redis访问速度飞快还取决于其他的一些因素&#xff0c;而这些都跟Redis的高可用性有很大关系。下面是衡量Redis的三个纬度&#xff1a; 1.高性能&#xff1a;线程模型、网络I/O模型、数据结构&#xf…
阅读更多...
散列（Hash）之习题分析

散列（Hash）之习题分析

散列&#xff08;Hash&#xff09;之习题分析一、什么是散列&#xff08;Hash&#xff09;&#xff08;一&#xff09;、Hash的概念&#xff08;二&#xff09;、处理冲突的方法二、HashMap解析&#xff08;一&#xff09;、HashMap的概念&#xff08;二&#xff09;、HashMap的…
阅读更多...
5-4树与二叉树-树的存储结构

5-4树与二叉树-树的存储结构

1.双亲表示法&#xff08;顺序存储&#xff09; 这种存储方式采用一组连续空间来存储每个结点&#xff0c;同时在每个结点中增设一个伪指针&#xff0c;指示其双亲结点在数组中的位置 优点&#xff1a;可以很快得到每个结点的双亲结点 缺点&#xff1a;求结点的孩子时需要遍…
阅读更多...
数组实现单双链表的快速操作[时间复杂度为O(1)]

数组实现单双链表的快速操作[时间复杂度为O(1)]

826. 单链表 - AcWing题库高质量的算法题库https://www.acwing.com/problem/content/828/ #include <iostream> using namespace std;const int N 1e510; int e[N],ne[N],head,idx;int main() {int n,k,x;char op;head -1, idx 0;cin >> n;while (n -- ){cin &…
阅读更多...
数据结构和算法（五）双向链表

数据结构和算法（五）双向链表

双向链表增删改查 单向链表查找的方向只能是一个方向&#xff0c;双向链表可以向前或者向后查找单向链表不可以自我删除&#xff0c;需要靠辅助节点&#xff0c;双向链表可以自我删除 双向链表增删改查思路 遍历&#xff1a;方式与单链表一样&#xff0c;可以向前也可以向后…
阅读更多...
数据结构和算法（四）链表--单链表

数据结构和算法（四）链表--单链表

1、链表&#xff08;Linked List&#xff09;介绍 链表是种常见数据结构&#xff0c;可以动态进行存储分配&#xff0c;是个功能强大的数组&#xff0c;可以在节点中定义多种数据类型链表以节点的方式存储数据&#xff0c;链式存储链表中每个节点包含 data 域&#xff0c;next…
阅读更多...
算法篇：链表之合并有序链表

算法篇：链表之合并有序链表

算法&#xff1a;算法的核心在于两个有序链表的合并操作&#xff0c;K个有序链表的合并只是一个变形题目&#xff0c;先拆分成k/2个有序链表&#xff0c;然后等比数列减少到1个数列。题目1:合并两个有序链表https://leetcode-cn.com/problems/merge-two-sorted-lists/代码实现&…
阅读更多...
Leetcode解题目录（Python版）

Leetcode解题目录（Python版）

Leetcode解题目录&#xff08;Python版&#xff09;题目目录1.排序算法2.哈希表3.动态规划题目来源于LeetCode官网题库&#xff0c;解题思路参考官网各大佬&#xff0c;这里做一个目录方便大家查找&#xff0c;另外方便自己回顾知识点。 持续更新… &#x1f610; &#x1f610…
阅读更多...
奇数节点升序、偶数节点降序，得到整体升序的链表

奇数节点升序、偶数节点降序，得到整体升序的链表

import java.util.ArrayList; import java.util.List;/*** 奇数节点升序、偶数节点降序&#xff0c;得到整体升序的链表*/ public class OddEvenLink {private static class Node {int value -1;Node next null;public Node(){}public Node(int value){this.value value;}}p…
阅读更多...
Leetcode-每日一题【876.链表的中间结点】

Leetcode-每日一题【876.链表的中间结点】

题目 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5]输出&#xff1a;[3,4,5]解释&#xff1a;链表只有一个中间结点&#xff0c;值为 3…
阅读更多...
数据结构基础知识梳理

数据结构基础知识梳理

前言 本篇旨在介绍关于数据结构的一些入门的知识点&#xff0c;让大家能够更好的入门数据结构与算法&#xff0c;故此都是对一些简单数据结构与基本算法的梳理 一、复杂度 虽然说数据结构和算法是两个不同的大小&#xff0c;那为什么先介绍复杂度呢&#xff1f; Pascal之父——…
阅读更多...
【链表OJ题】将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

【链表OJ题】将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

【链表OJ题】&#xff1a; 本题来自力扣算法题&#xff0c;链接&#xff1a;合并两个有序链表 题目&#xff1a;将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 这道题目应该怎么做呢&#xff0c;我们用下面这个例子给大家…
阅读更多...
【链表OJ题】给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

【链表OJ题】给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

【链表OJ题】&#xff1a; 本题来自于力扣算法题&#xff0c;链接&#xff1a;206. 反转链表 题目&#xff1a;给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 对于这一题的反转链表&#xff0c;其实也是next域中地址的问题&#xff0c;…
阅读更多...
【Java】带你从零到一系列9 画图带你从顺序表到链表2

【Java】带你从零到一系列9 画图带你从顺序表到链表2

前言&#xff1a;上一篇我们学习了顺序表&#xff0c;已经找到对于顺序表的概念有了一定的掌握&#xff0c;但我们学习了顺序表之后发现&#xff0c;它有一些地方做不到更好或者难做到&#xff0c;所以我们有了链表&#xff0c;这一篇将带你走进链表的学习&#xff01; 每文一图…
阅读更多...
leetcode_123 Flatten Binary Tree to Linked List

leetcode_123 Flatten Binary Tree to Linked List

题目&#xff1a; 把二叉树转换为链表 Given a binary tree, flatten it to a linked list in-place. For example, given the following tree: 1/ \2 5/ \ \ 3 4 6The flattened tree should look like: 1\2\3\4\5\6 解法一&#xff1a;递归 preorder的逆序 链表…
阅读更多...
【NOI2017模拟3.25】历史行程

【NOI2017模拟3.25】历史行程

Description 给出一个长度为n的字符串&#xff0c;m次询问前缀l~r中两两的最长后缀最长是多少。 n,m<1e5 Solution 显然先倒过来&#xff0c;询问变成求后缀的lcp SA处理一下就好了。 但是rank不是有序的&#xff0c;无法处理&#xff0c;怎么办呢&#xff1f; 可以离…
阅读更多...
Java集合-LinkedList

Java集合-LinkedList

LinkedList概述set和get函数概述 以双向链表实现。链表无容量限制&#xff0c;但双向链表本身使用了更多空间&#xff0c;也需要额外的链表指针操作。 按下标访问元素&#xff0c;需要遍历链表(但不一定从头开始遍历链表)。 set和get函数 两个函数都调用了 node 函数&#x…
阅读更多...
leetcode----在O(n log n)的时间内使用常数级空间复杂度对链表进行排序。

leetcode----在O(n log n)的时间内使用常数级空间复杂度对链表进行排序。

import java.util.*;/** public class ListNode {* int val;* ListNode next null;* }*/public class Solution {/*** * param head ListNode类 * return ListNode类不带头节点思路&#xff1a;采用归并排序的方法。其时间复杂度为O&#xff08;nlog2n&#xff09;1.先找到…
阅读更多...
数据结构——c++链表

数据结构——c++链表

数据结构——c链表链表菜单链表菜单 #include<iostream> #include<stdlib.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 //不可实行的 #define OVERFLOW -2 //溢出 using namespace std;typedef int Status;typed…
阅读更多...
学习C/C++语言系列（2）栈

学习C/C++语言系列（2）栈

栈是什么 栈是一种特殊的线性表&#xff0c;特殊在哪呢&#xff1f;特殊在于栈上的空间只能后进先出&#xff0c;即最后进来的只能最先出去。这就好比硬币管里的硬币&#xff0c;只能先拿出最后放出去的。 这种后进先出的原则就叫做Last In First Out(LIFO)。 栈的C语言实现 …
阅读更多...
C语言双向链表的创建与遍历

C语言双向链表的创建与遍历

双向链表 ●◡● 创建遍历完整代码创建 双向链表可以使每一个节点可以与上一个和下一个节点相连&#xff0c;就需要在单向链表的结构体中加一个指向上一个节点的指针 struct List{char Nam[30];float Num;struct List *pNext,*pLast; };如何创建&#xff1a; 先开辟一个pNew的…
阅读更多...
面试题35：复杂链表的复制

面试题35：复杂链表的复制

面试题35&#xff1a;复杂链表的复制 实现 copyRandomList 函数&#xff0c;复制一个复杂链表。在复杂链表中&#xff0c;每个节点除了有一个 next 指针指向下一个节点&#xff0c;还有一个 random 指针指向链表中的任意节点或者 null。 class Solution { public:Node* copyR…
阅读更多...
java单链表的定义、初始化和打印

java单链表的定义、初始化和打印

1、单链表的定义 class ListNode {// -参考力扣节点定义int val;ListNode next;ListNode() {}ListNode(int val) { this.val val; }ListNode(int val, ListNode next) { this.val val; this.next next; } } 2、单链表(没有头节点)的初始化和打印 public class mergeTwoLis…
阅读更多...
链表___

链表___

链表 在单向链表末尾增加一个新的节点 struct ListNode {int m_nValue;ListNode* m_pNext; };void AddToTail(ListNode** pHead,int value) // pHead是指向指针的指针&#xff1b; {// new:new开辟的空间在堆上&#xff0c;而一般声明的变量在栈上。该段空间在局部函数调用结…
阅读更多...
基于链表操作的飞机大战游戏

基于链表操作的飞机大战游戏

目录 飞机大战结构体游戏三部曲初始化Game_Init()绘制Game_Paint()数据更新Game_Updata()主函数按键的处理说明链表的增删操作添加敌方飞机敌方飞机移动添加子弹子弹移动 飞机大战 基于链表操作的飞机大战游戏 结构体 定义飞机大战所需结构体并全局定义结构体成员 //子弹的结…
阅读更多...
你对工作队列了解多少？Linux中断处理中的workqueue介绍

你对工作队列了解多少？Linux中断处理中的workqueue介绍

Linux中断处理中的workqueue介绍 一、workqueue的作用及在Linux中断处理中的应用1.1、workqueue的概述1.2、workqueue在Linux中断处理中的作用 二、workqueue的实现原理2.1、工作队列和工作者线程的关系2.2、工作队列的创建和销毁2.3、工作者线程的创建和销毁2.4、扩展知识&…
阅读更多...
java判断单链表是否是回文链表

java判断单链表是否是回文链表

判断一个链表是不是回文链表&#xff0c;可以借助栈或者是快慢指针的方法 这些都是根据左程云的算法课程整理出来的代码 1.借助栈结构&#xff0c;先进后出的特性 将链表遍历并且一次入栈&#xff0c;再将链表重新遍历&#xff0c;并将栈弹出&#xff0c;依次作对比&#xff…
阅读更多...
剑指Offer 面试题5 从尾到头打印链表

剑指Offer 面试题5 从尾到头打印链表

剑指Offer 面试题5 从尾到头打印链表 本文题目来自《剑指offer 名企面试官精讲典型编程题》面试题5。 题目5&#xff1a;输入一个链表的头结点&#xff0c;从尾到头反过来打印每个结点的值。 思路:从头到尾遍历一遍链表&#xff0c;将每个结点顺次压入栈中。遍历完链表后&#…
阅读更多...
java反转单链表和双链表

java反转单链表和双链表

反转单链表和双链表 public static class Node{private int value;private Node next;public Node(int value) {this.value value;}}//打印单链表private static void printNodeList(Node head){System.out.println("nodeList print:");while (null ! head){System.…
阅读更多...
基础数据结构：队列

基础数据结构：队列

队列相对于栈来说是一个功能特性相反的结构&#xff0c;实现难度上与栈相当&#xff0c;栈与队列的学习重点都在于在实际中如何利用这两种数据结构的特点去解决问题。 队列&#xff1a;即只允许在队尾入数据&#xff0c;队头出数据&#xff08;特点&#xff1a;先进先出FIFO&a…
阅读更多...
基础数据结构：双向带头循环链表

基础数据结构：双向带头循环链表

本篇系上篇链表的补充&#xff0c;对双向带头循环链表进行模拟实现 tips&#xff1a;虽然听着比无头单向不循环链表复杂&#xff0c;但由于结构特点&#xff0c;模拟实现时是比极简形式的单链表容易许多的 首先我们还是先来看看双向链表的结点构成&#xff1a; typedef int LTD…
阅读更多...
Go语言每日一题——链表篇(七)

Go语言每日一题——链表篇(七)

传送门 牛客面试笔试必刷101题 ----------------删除链表的倒数第n个节点 题目以及解析 题目 解题代码及解析 解析 这一道题与昨天的题目在解题思路上有一定的相似之处&#xff0c;都是基于双指针定义快慢指针&#xff0c;这里我们让快指针先走n步&#xff0c;又因为n一定…
阅读更多...
【C语言 - 力扣 - 反转链表】

【C语言 - 力扣 - 反转链表】

反转链表题目描述 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 题解1-迭代 假设链表为 1→2→3→∅&#xff0c;我们想要把它改成 ∅←1←2←3。 在遍历链表时&#xff0c;将当前节点的 next 指针改为指向前一个节点。由于节点没…
阅读更多...
【每日一题】LeetCode——链表的中间结点

【每日一题】LeetCode——链表的中间结点

&#x1f4da;博客主页&#xff1a;爱敲代码的小杨. ✨专栏&#xff1a;《Java SE语法》 | 《数据结构与算法》 | 《C生万物》 ❤️感谢大家点赞&#x1f44d;&#x1f3fb;收藏⭐评论✍&#x1f3fb;&#xff0c;您的三连就是我持续更新的动力❤️ &#x1f64f;小杨水平有…
阅读更多...
Leecode之分割链表

Leecode之分割链表

一.题目及剖析 https://leetcode.cn/problems/partition-list-lcci/description/ 二.思路引入 就是将其分成大小两个链表,以x为分界线进行分堆,最后再将两链表合并 三.代码引入 /*** Definition for singly-linked list.* struct ListNode {* int val;* struct Lis…
阅读更多...
【数据结构】链表（C语言实现）

【数据结构】链表（C语言实现）

创作不易&#xff0c;本篇文章如果帮助到了你&#xff0c;还请点赞 关注支持一下♡>&#x16966;<)!! 主页专栏有更多知识&#xff0c;如有疑问欢迎大家指正讨论&#xff0c;共同进步&#xff01; &#x1f525;c语言系列专栏&#xff1a;c语言之路重点知识整合 &#x…
阅读更多...
【LeetCode】138. 复制带随机指针的链表

【LeetCode】138. 复制带随机指针的链表

题目链接&#xff1a;https://leetcode.cn/problems/copy-list-with-random-pointer/description/ &#x1f4d5;题目要求&#xff1a; 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。…
阅读更多...
c语言实现栈(顺序栈,链栈)

c语言实现栈(顺序栈,链栈)

&#x1f388;个人主页:&#x1f388; :✨✨✨初阶牛✨✨✨ &#x1f43b;推荐专栏: &#x1f354;&#x1f35f;&#x1f32f;C语言进阶 &#x1f511;个人信条: &#x1f335;知行合一 &#x1f349;本篇简介:>:讲解用c语言实现:“数据结构之"栈”,分别从"顺序栈…
阅读更多...
指针穿梭，数据流转：探秘C语言实现单向不带头不循环链表

指针穿梭，数据流转：探秘C语言实现单向不带头不循环链表

本篇博客会讲解链表的最简单的一种结构&#xff1a;单向不带头不循环链表&#xff0c;并使用C语言实现。 概述 链表是一种线性的数据结构&#xff0c;而本篇博客讲解的是链表中最简单的一种结构&#xff0c;它的一个结点的声明如下&#xff1a; // 单链表存储的数据类型 typ…
阅读更多...
【数据结构】双向链表(链表实现+测试+原码)

【数据结构】双向链表(链表实现+测试+原码)

前言 在双向链表之前&#xff0c;如果需要查看单链表来复习一下&#xff0c;链接在这里&#xff1a; http://t.csdnimg.cn/Ib5qS 1.双向链表 1.1 链表的分类 实际中链表的结构非常多样&#xff0c;以下情况组合起来就有8种链表结构&#xff1a; 1.1.1 单向或者双向 1.1.2 …
阅读更多...
每日OJ题_算法_递归③力扣206. 反转链表

每日OJ题_算法_递归③力扣206. 反转链表

目录 力扣206. 反转链表 解析代码 力扣206. 反转链表 206. 反转链表 LCR 024. 反转链表 难度 简单 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,…
阅读更多...
数据结构5——线性表4：多项式实现例题

数据结构5——线性表4：多项式实现例题

1、一元多项式的运算 用顺序表存储多项式每次幂的系数&#xff0c;然后将将两个多项式对应位置的数组相加 代码实现&#xff1a; 输出结果&#xff1a; 2、稀疏多项式的运算 许许多多系数和指数&#xff08;p,e&#xff09;构成线性表A、B 算法步骤1&#xff1a;使用顺序表…
阅读更多...
第五章：C语言数据结构与算法之双向带头循环链表

第五章：C语言数据结构与算法之双向带头循环链表

系列文章目录 文章目录系列文章目录前言一、哨兵位的头节点二、双向链表的结点三、接口函数的实现1、创建结点2、初始化3、尾插与尾删4、头插与头删5、打印6、查找7、随机插入与随机删除8、判空、长度与销毁四、顺序表和链表的对比1. 不同点2. 优缺点五、缓存命中1、缓存2、缓存…
阅读更多...
基础数据结构：链表

基础数据结构：链表

链表是相对顺序表来说复杂一些些的数据结构&#xff0c;但其与顺序表在性质上是存在一定的互补的&#xff0c;我们一起来随着这篇文章来看看。 首先来了解基本的链表概念 链表在逻辑结构上是连续的&#xff0c;物理结构上则为非连续的 链表也分为静态与动态链表 &#xff08;…
阅读更多...
每日算法题：Day1（链表相关）

每日算法题：Day1（链表相关）

先附上算法题链接&#xff1a; 剑指offer II 027.回文链表 剑指 Offer II 022. 链表中环的入口节点 面试题 02.07. 链表相交 回文链表&#xff1a; 题目意思容易理解&#xff0c;就不过多赘述。在此主要谈一下相关的思路。 思路一 将该链表的每个结点的val都放到一个容器中去…
阅读更多...
《程序设计基础》 第十一章 指针进阶 6-15 删除单链表偶数节点 (20 分)

《程序设计基础》 第十一章 指针进阶 6-15 删除单链表偶数节点 (20 分)

本题要求实现两个函数&#xff0c;分别将读入的数据存储为单链表、将链表中偶数值的结点删除。链表结点定义如下&#xff1a; struct ListNode {int data;struct ListNode *next; };函数接口定义&#xff1a; struct ListNode *createlist(); struct ListNode *deleteeven( s…
阅读更多...
《程序设计基础》 第十一章 指针进阶 6-12 单链表结点删除 (20 分)

《程序设计基础》 第十一章 指针进阶 6-12 单链表结点删除 (20 分)

本题要求实现两个函数&#xff0c;分别将读入的数据存储为单链表、将链表中所有存储了某给定值的结点删除。链表结点定义如下&#xff1a; struct ListNode {int data;ListNode *next; };函数接口定义&#xff1a; struct ListNode *readlist(); struct ListNode *deletem( s…
阅读更多...
《程序设计基础》 第十一章 指针进阶 6-10 链表拼接 (20 分)

《程序设计基础》 第十一章 指针进阶 6-10 链表拼接 (20 分)

本题要求实现一个合并两个有序链表的简单函数。链表结点定义如下&#xff1a; struct ListNode {int data;struct ListNode *next; }; 函数接口定义&#xff1a; struct ListNode *mergelists(struct ListNode *list1, struct ListNode *list2); 其中list1和list2是用户传入…
阅读更多...
《程序设计基础》 第十一章 指针进阶 6-9 逆序数据建立链表 (20 分)

《程序设计基础》 第十一章 指针进阶 6-9 逆序数据建立链表 (20 分)

本题要求实现一个函数&#xff0c;按输入数据的逆序建立一个链表。 函数接口定义&#xff1a; struct ListNode *createlist(); 函数createlist利用scanf从输入中获取一系列正整数&#xff0c;当读到−1时表示输入结束。按输入数据的逆序建立一个链表&#xff0c;并返回链表…
阅读更多...
1160 队列安排

1160 队列安排

1160 队列安排 这不就是链表吗 链表的基本操作 这个题不是我想的这么简单 首先对于前后其实就是左右的关系 所谓的插入左右实质上什么&#xff0c;其实没有什么含义&#xff0c;比如i要插到k左面&#xff0c;其实i就是在k的前面 同样的i在k的右面就当成后面 #include<ios…
阅读更多...
链表，循环链表

链表，循环链表

酝酿中。。。。
阅读更多...
C语言学习——链表

C语言学习——链表

链表的实质名词解释 链表的作用如何使用链表创建结构体创建结构体变量创建链表遍历链表 具体案例按照id找某个学生 链表的实质 串联起来的对象 名词解释 链表头&#xff1a;第一个对象 链表尾&#xff1b;最后一个对象 链表的作用 一次性访问多个对象 如何使用链表 ①创…
阅读更多...
java 面试篇-单链表基础

java 面试篇-单链表基础

java 实现单链表 一、数据结构的定义 链表节点的定义public class Node {public int val;public Node next;public Node(int val, Node next) {this.val val;this.next next;}public Node(int val) {this(val, null); } } 单链表的定义public class LinkList {public Node …
阅读更多...
LeetCode 面试题 02.01. 移除重复节点

LeetCode 面试题 02.01. 移除重复节点

原题目&#xff1a;https://leetcode-cn.com/problems/remove-duplicate-node-lcci/ 思路&#xff1a; 改变链表的链接方式&#xff0c;使用set保留存储过的值&#xff0c;pre记录前一个节点&#xff0c;q代表当前节点。 如果q->val不存在与set&#xff1a;preq,qq->ne…
阅读更多...
LeetCode 2. 两数相加

LeetCode 2. 两数相加

原题目&#xff1a;https://leetcode-cn.com/problems/add-two-numbers/ 思路&#xff1a; 使用pre来记录父节点&#xff0c;用s来保持进位 代码&#xff1a; class Solution { public:ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {ListNode* hair new ListNode(…
阅读更多...
数据结构与算法_单向链表实现栈和队列并实现单向循环链表

数据结构与算法_单向链表实现栈和队列并实现单向循环链表

栈的实现 什么是栈&#xff1f; 栈又名堆栈&#xff0c;它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。插入元素的一端称为栈顶&#xff0c;相对应的另一端称为栈底。 根据上一文所写LinkedList的类实现栈 public class LinkedStack<E> implement…
阅读更多...
Design Circular Deque 设计循环双端队列

Design Circular Deque 设计循环双端队列

文章目录Design Circular Deque 设计循环双端队列Description思路:Design Circular Deque 设计循环双端队列 Description MyCircularDeque circularDeque new MycircularDeque(3); // set the size to be 3 circularDeque.insertLast(1); // return true circularDeque.in…
阅读更多...
Remove Duplicates from Sorted List删除排序链表中的重复元素

Remove Duplicates from Sorted List删除排序链表中的重复元素

文章目录Remove Duplicates from Sorted List删除排序链表中的重复元素Remove Duplicates from Sorted List删除排序链表中的重复元素 Given the head of a sorted linked list, delete all duplicates such that each element appears only once. Return the linked list sor…
阅读更多...
Remove Nth Node From End of List删除链表的倒数第 N 个结点

Remove Nth Node From End of List删除链表的倒数第 N 个结点

文章目录Remove Nth Node From End of List 删除链表的倒数第 N 个结点双指针虚头Remove Nth Node From End of List 删除链表的倒数第 N 个结点 Given the head of a linked list, remove the nth node from the end of the list and return its head. 输入&#xff1a;head …
阅读更多...
Reverse Linked List 2 反转链表的一部分

Reverse Linked List 2 反转链表的一部分

文章目录Reverse Linked List 反转链表迭代法递归法Reverse Linked List 反转链表 迭代法 反转链表&#xff0c;该链表为单链表。 head 节点指向的是头节点。 最简单的方法&#xff0c;就是建一个新链表&#xff0c;将原来链表的节点一个个找到&#xff0c;并且使用头插法插…
阅读更多...
数据结构与算法_单向链表

数据结构与算法_单向链表

链表 什么是链表&#xff1f; 链表是一种物理存储上非连续、非顺序的存储结构&#xff0c;数据元素之间是通过指针链接起来的。 链表是由节点组成的&#xff0c;节点可在链表存储时动态生成。一个节点由它的数据域和指向下一个节点的指针域组成。 由于线性表在插入元素和删除…
阅读更多...
PAT甲级真题 1097 Deduplication on a Linked List (25分) C++实现（模拟链表判断重复值，两个map）

PAT甲级真题 1097 Deduplication on a Linked List (25分) C++实现（模拟链表判断重复值，两个map）

题目 Given a singly linked list L with integer keys, you are supposed to remove the nodes with duplicated absolute values of the keys. That is, for each value K, only the first node of which the value or absolute value of its key equals K will be kept. At …
阅读更多...
PAT甲级真题 1052 Linked List Sorting (25分) C++实现（模拟链表）

PAT甲级真题 1052 Linked List Sorting (25分) C++实现（模拟链表）

题目 A linked list consists of a series of structures, which are not necessarily adjacent in memory. We assume that each structure contains an integer key and a Next pointer to the next structure. Now given a linked list, you are supposed to sort the stru…
阅读更多...
PAT甲级真题 1032 Sharing (25分) C++实现（模拟链表找公共元素，计数法两次遍历）

PAT甲级真题 1032 Sharing (25分) C++实现（模拟链表找公共元素，计数法两次遍历）

题目 To store English words, one method is to use linked lists and store a word letter by letter. To save some space, we may let the words share the same sublist if they share the same suffix. For example, “loading” and “being” are stored as showed in …
阅读更多...
如何判断二叉树是循环链表

如何判断二叉树是循环链表

listnode *p head while(p!null) { pp->next; if(phead) { print("是循环链表"); break; } } if(pnull) {print("是普通链表");}
阅读更多...
jdk1.8后为什么hashmap中链表长度大于8会转变成红黑树

jdk1.8后为什么hashmap中链表长度大于8会转变成红黑树

hashmap源码中有以下注释 /* * Implementation notes. * * This map usually acts as a binned (bucketed) hash table, but * when bins get too large, they are transformed into bins of * TreeNodes, each structured similarly to those in * java.util.TreeMap. Most me…
阅读更多...
C# 数据结构 是否有序

C# 数据结构 是否有序

c#中list<String > listnew list<String>(); 请问list中的元素是有序还是无序的&#xff1f; List 集合是有序的&#xff0c;并且是自动排序&#xff0c;一般情况下按照加进去的元素时间来排序&#xff0c;先加的序号就更小&#xff0c;从下标为 0 开始&#xff0c…
阅读更多...
87、美团算法题---重排链表

87、美团算法题---重排链表

一、题目 二、实现 方法一&#xff1a;使用数组 /** function ListNode(x){* this.val x;* this.next null;* }*//*** * param head ListNode类 * return void*/ function reorderList( head ) {// if(!head || !head.next){return;}let arr [];let p head;while(p){…
阅读更多...
学习C/C++系列（3）列

学习C/C++系列（3）列

列是什么 列可以想象成一种特殊的栈&#xff0c;我们在前面提到&#xff0c;栈遵循的原则是后进先出&#xff0c;列遵循的原则则是先进先出。列只允许在一端进行插入数据操作&#xff0c;在另一端进行删除数据操作的特殊线性表&#xff0c;队列具有先进先出FIFO(First In Firs…
阅读更多...
链表、堆栈、队列的区别

链表、堆栈、队列的区别

链表&#xff0c;队列和栈都是数据结构的一种。Sartaj Sahni 在他的《数据结构、算法与应用》一书中称&#xff1a;“数据结构是数据对象&#xff0c;以及存在于该对象的实例和组成实例的数据元素之间的各种联系。这些联系可以通过定义相关的函数来给出。”他将数据对象&#x…
阅读更多...
数据结构实验一

数据结构实验一

****学生实验报告 开课学院及实验室&#xff1a;计算机科学与工程实验 20**年 ** 月 ** 日 学院 ************ 年级、专业、班 **** 姓名 *** 学号 ********** 实验课程名称 数据结构 成绩 ** 实验项目名称 实验一.线性表、堆栈和队列的操作与实现 指导老师 *** 评语: 一、实验…
阅读更多...
链表相关题目

链表相关题目

文章目录1: o(1)时间删除链表节点2&#xff1a;判断一个链表A是否是回文&#xff0c;o(n)时间复杂度&#xff0c;o(1)空间复杂度3&#xff1a;判断链表是否有环4&#xff1a;找到相交链表的相交节点5: 删除排序链表的重复元素6&#xff1a;循环移动链表1: o(1)时间删除链表节点…
阅读更多...
C语言单链表，双向链表，循环单链表，循环双链表的基本操作

C语言单链表，双向链表，循环单链表，循环双链表的基本操作

1.单链表的基本操作&#xff08;C语言&#xff09; 创建头节点 Linklist *Creat(Linklist *L) {L (Linklist *)malloc(sizeof(Linklist));if (L NULL) return NULL; /*内存分配不成功,返回空指针*/L -> next NULL;return L; }插入一个新的节点 先用malloc函数给新的…
阅读更多...
创建python软连接_创建链接列表– Python实现

创建python软连接_创建链接列表– Python实现

创建python软连接Linked list is one of the famous data structure that people come across. It is a linear data structure that is stored in memory in non-contagious fashion. One can access elements of a linked list from the start only, unless reference to oth…
阅读更多...
word如何插入无序列表_无序链接列表–前缀，附加，插入位置，反向，删除，搜索

word如何插入无序列表_无序链接列表–前缀，附加，插入位置，反向，删除，搜索

word如何插入无序列表In order to implement an unordered linked list we need to construct linked list which contains Node class, a building block for constructing linked list 为了实现无序链表&#xff0c;我们需要构建包含Node类的链表&#xff0c;Node类是构建链表…
阅读更多...
剑指offer--06. 从尾到头打印链表

剑指offer--06. 从尾到头打印链表

解法1&#xff1a;先知道链表的长度是多少&#xff0c;然后创建数组&#xff0c;最后倒叙给数组赋值。 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode(int x) { val x; }* }*/ class Solution {public…
阅读更多...
【数据结构】队列——顺序实现+链式实现（带头结点+不带头结点）入队 出队 初始化 判空 双端队列 完整代码

【数据结构】队列——顺序实现+链式实现（带头结点+不带头结点）入队 出队 初始化 判空 双端队列 完整代码

文章目录 四 队列1.基本概念2.队列的顺序存储3.队列的链式实现3.1 定义3.2 带头结点3.2.1 初始化3.2.2 判空3.2.3 入队3.2.4 出队3.2.5 完整代码 3.3 不带头结点3.3.1 初始化3.3.2 入队3.3.3 出队3.3.4 完整代码 4.双端队列 四 队列 1.基本概念 定义 只允许在一端进行插入&…
阅读更多...
postgres源码解析52 磁盘管理器--1

postgres源码解析52 磁盘管理器--1

简介 postgres中的磁盘管理器SMGR对外提供了管理磁盘介质的接口&#xff0c;其主要实现在md.c文件中。磁盘管理器并非对磁盘上的文件直接进行操作&#xff0c;而是通过VFD机制进行文件操作。凡是对存储在磁盘中的表进行访问操作均会与磁盘管理器打交道&#xff0c;由它进行统一…
阅读更多...
lc23. 合并K个升序链表

lc23. 合并K个升序链表

题目描述给你一个链表数组&#xff0c;每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。示例 1&#xff1a;输入&#xff1a;lists [[1,4,5],[1,3,4],[2,6]]输出&#xff1a;[1,1,2,3,4,4,5,6]解释&#xff1a;链表数组如下&…
阅读更多...
第七章：C语言数据结构与算法初阶之队列

第七章：C语言数据结构与算法初阶之队列

系列文章目录 文章目录系列文章目录前言一、队列二、队列的实现三、接口函数的实现1、初始化2、销毁3、入队/出队4、队头/队尾5、判空/元素个数四、队列中元素的访问总结前言 队列&#xff1a;只允许在一端进行插入数据&#xff0c;在另一端进行删除数据操作的特殊线性表。 一…
阅读更多...
【Leetcode 876】【Leetcode 19】【GO】链表专题

【Leetcode 876】【Leetcode 19】【GO】链表专题

【Leetcode 876】链表的中间节点 题目 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结点。 解题思路 此类题目的解法为 快慢指针 核心逻辑就是设定两个指针&#xff0c;一个快后面那个指针指定的…
阅读更多...
Leetcode24.两两交换链表中的节点

Leetcode24.两两交换链表中的节点

目录一、题目描述&#xff1a;二、解决思路和代码1. 解决思路2. 代码一、题目描述&#xff1a; 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交…
阅读更多...
单链表-----重置版

单链表-----重置版

本期我们对之前讲过的单链表进行重置&#xff0c;增加了亿些细节&#xff0c;不过整体变化不大 (13条消息) 链表与其多种接口实现1-CSDN博客 目录 链表的结构 打印 尾插 创建新节点 头插 尾删 头删 查找 任意位置前插入 任意位置删除 pos后插入 pos后删除 全部代码…
阅读更多...
[数据结构]栈和队列

[数据结构]栈和队列

&#x1f387;[数据结构]栈和队列&#x1f387; &#x1f31f; 正式开始学习数据结构啦~此专栏作为学习过程中的记录&#x1f31f; 文章目录 &#x1f387;[数据结构]栈和队列&#x1f387;&#x1f370;一. 栈&#x1f680;1.了解栈&#x1f680;2.顺序栈&#x1f506;1.顺序栈…
阅读更多...
数据结构与算法09：二叉树

数据结构与算法09：二叉树

目录 【树】 【二叉树】 二叉树的遍历 Go代码实现 二叉树的复杂度分析 【二叉搜索树】 Go代码实现 【每日一练&#xff1a;移除元素】 【树】 什么是树&#xff1f;这个不用解释了吧&#xff0c;马路两边种的都是树。数据结构里面的“树”和现实生活中的树类似&#…
阅读更多...
双指针 -876. 链表的中间结点-leetcode

双指针 -876. 链表的中间结点-leetcode

开始一个专栏&#xff0c;写自己的博客 双指针&#xff0c;也算是作为自己的笔记吧&#xff01; 双指针从广义上来说&#xff0c;是指用两个变量在线性结构上遍历而解决的问题。狭义上说&#xff0c; 对于数组&#xff0c;指两个变量在数组上相向移动解决的问题&#xff1b;对…
阅读更多...
[链表] 反转链表

[链表] 反转链表

206. 反转链表 - 力扣&#xff08;LeetCode&#xff09; 优质题解&#xff1a;【反转链表】&#xff1a;双指针&#xff0c;递归&#xff0c;妖魔化的双指针 - 反转链表 - 力扣&#xff08;LeetCode&#xff09; 题目 定义一个函数&#xff0c;输入一个链表的头节点&#xff0…
阅读更多...
算法套路五——快慢指针

算法套路五——快慢指针

算法套路五——快慢指针 算法示例LeetCode876. 链表的中间结点 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。如果有两个中间结点&#xff0c;则返回第二个中间结点。 可以设置快慢指针&#xff0c;快指针每次移动两步&#xff0c;慢指针每次移动一步…
阅读更多...
PAT链表题(模拟)

PAT链表题(模拟)

L2-002 链表去重 给定一个带整数键值的链表 L&#xff0c;你需要把其中绝对值重复的键值结点删掉。即对每个键值 K&#xff0c;只有第一个绝对值等于 K 的结点被保留。同时&#xff0c;所有被删除的结点须被保存在另一个链表上。例如给定 L 为 21→-15→-15→-7→15&#xff0…
阅读更多...
【数据结构与算法】栈和队列(StackQueue)

【数据结构与算法】栈和队列(StackQueue)

TOC 数据结构—栈 栈的概念 要想学习一个东西&#xff0c;概念是一定要看并且理解的&#xff0c;那么栈是个什么玩意呢&#xff1f; 栈&#xff1a;一种特殊的线性表&#xff0c;其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶&#x…
阅读更多...
为什么链表的插入删除要用二级指针？

为什么链表的插入删除要用二级指针？

#include <iostream> using namespace std; typedef struct listnode { int date; struct listnode *next; }listnode; void Init(listnode **head) //链表初始化 { listnode *pnew listnode; p->date0; p->nextNULL; *headp; print…
阅读更多...
【数据结构OJ题】链表带环问题

【数据结构OJ题】链表带环问题

目录 1.判断链表是否带环 证明 2.寻找环的入口点 1.判断链表是否带环 原题链接&#xff1a;力扣 思路一&#xff1a;先遍历一遍链表&#xff0c;计算出链表的长度&#xff0c;然后将长度除二&#xff0c;在遍历半个链表即可。但是这种方法效率比较低。 思路二&#xff1a;…
阅读更多...
代码随想录算法训练营第4天| LeetCode 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交

代码随想录算法训练营第4天| LeetCode 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交

24. 两两交换链表中的节点 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* ListNode(int val, ListNode next) { this.val val; this.next next…
阅读更多...
代码随想录算法训练营第4天| 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 142.环形链表II

代码随想录算法训练营第4天| 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 142.环形链表II

今日学习的文章链接&#xff0c;或者视频链接 第二章 链表part02 自己看到题目的第一想法 看完代码随想录之后的想法 24: 注意链表的操作&#xff1a; class Solution { public:ListNode* swapPairs(ListNode* head) {auto dummyhead new ListNode(0,head);auto prev …
阅读更多...
4.6 环形链表 II

4.6 环形链表 II

142 环形链表 II题目给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用…
阅读更多...
剑指 Offer 09. 用两个栈实现队列（python3编写）

剑指 Offer 09. 用两个栈实现队列（python3编写）

目录1、题目描述&#xff1a;2、方法&#xff1a;思路&#xff1a;代码&#xff1a;1、题目描述&#xff1a; 2、方法&#xff1a; 思路&#xff1a; 维护两个栈&#xff0c;第一个栈支持插入操作&#xff0c;第二个栈支持删除操作。 根据栈先进后出的特性&#xff0c;我们每次…
阅读更多...
算法与数据结构-链表

算法与数据结构-链表

文章目录 链表和数组的区别常见的链表类型单链表循环链表双向链表 总结 链表和数组的区别 相比数组&#xff0c;链表是一种稍微复杂一点的数据结构。对于初学者来说&#xff0c;掌握起来也要比数组稍难一些。这两个非常基础、非常常用的数据结构&#xff0c;我们常常会放到一块…
阅读更多...
剑指 Offer 35. 复杂链表的复制（python3编写）

剑指 Offer 35. 复杂链表的复制（python3编写）

目录1、题目描述&#xff1a;2、方法一&#xff1a;迭代哈希表思路&#xff1a;代码&#xff1a;3、方法二&#xff1a;后继节点思路&#xff1a;代码&#xff1a;4、总结1、题目描述&#xff1a; 2、方法一&#xff1a;迭代哈希表 思路&#xff1a; 我们先看看暴力法怎么做的…
阅读更多...
单链表【数据结构】

单链表【数据结构】

1、顺序表存在的问题 顺序表存在一些问题&#xff1a; &#xff08;1&#xff09;中间、头部的插入删除&#xff0c;时间复杂度为O(N)&#xff08;2&#xff09;增容需要申请新空间&#xff0c;拷贝数据&#xff0c;释放旧空间。会有不小的消耗。&#xff08;3&#xff09;增容…
阅读更多...
代码随想录第四天|交换节点、链表相交、环形链表

代码随想录第四天|交换节点、链表相交、环形链表

代码随想录第四天 Leetcode 24 两两交换链表中的节点Leetcode 19 删除链表的倒数第 N 个结点Leetcode 面试题 02.07 链表相交Leetcode 142 环形链表 II Leetcode 24 两两交换链表中的节点 题目链接: 两两交换链表中的节点 自己的思路:迭代和递归。迭代&#xff1a;以链表1–&g…
阅读更多...
剑指 Offer 06. 从尾到头打印链表（python3编写）

剑指 Offer 06. 从尾到头打印链表（python3编写）

目录1、题目描述&#xff1a;2、方法一&#xff1a;使用栈保存结果思路&#xff1a;代码&#xff08;迭代法&#xff09;&#xff1a;代码&#xff08;递归法&#xff09;&#xff1a;3、方法二&#xff1a;反转链表思路&#xff1a;代码&#xff1a;4、方法三&#xff1a;保存…
阅读更多...
leetcode笔记总结——（16）环形链表（python编写）

leetcode笔记总结——（16）环形链表（python编写）

来源&#xff1a;代码随想录. 力扣题目链接. 目录1、题目描述&#xff1a;2、实现思路&#xff1a;2.1 方法一思路&#xff1a;2.1 方法二思路&#xff1a;3、代码描述&#xff08;python&#xff09;&#xff1a;3.1 方法一的代码&#xff1a;3.1 方法二的代码&#xff1a;1、…
阅读更多...
《数据结构和算法》—链表

《数据结构和算法》—链表

1 链表&#xff1a;一组数在内存中并不是存储在连续的内存空间的形式&#xff0c;称之为链表&#xff0c;和数组类似 链表每个链表的节点&#xff0c;不仅仅存储的元素还有一个指针&#xff0c;指向它的下一个元素&#xff0c;直到最后指到Null的时候就代表链表的结束 单端链…
阅读更多...
LeetCode 141 环形链表

LeetCode 141 环形链表

题目描述&#xff1a; 给定一个链表&#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;我们使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;…
阅读更多...
题解 | #删除链表中重复的结点#(哈希表）

题解 | #删除链表中重复的结点#(哈希表）

发现《剑指offer》里很多的链表题都是需要用到各种模板类&#xff0c;哈希模板类是高频出现的内容&#xff0c;学校里教到STL基本的类就结束了&#xff0c;甚至连vector这类神器都是一笔带过。。 话不多说&#xff0c;上代码 /* struct ListNode {int val;struct ListNode *ne…
阅读更多...
LeetCode 92 反转链表 II

LeetCode 92 反转链表 II

题目描述&#xff1a; 给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表。 示例&#xff1a; 输入&#xff1a;head [1, 2, 3, 4, 5]&#xff0c;left 2&a…
阅读更多...
python中变量标识的本质以及由这个本质而来的python版的链表

python中变量标识的本质以及由这个本质而来的python版的链表

1.在python为什么以下代码可以实现a,b值互换&#xff1f; a 10 b 20 a,b b,a 在python当中&#xff0c;变量保存的其实是一块地址&#xff0c;a 10也就是内存中开辟了一块地址&#xff0c;a是这块地址的别名a实际是地址0x23(假设开辟的地址为0x23)&#xff0c;而地址才真…
阅读更多...
LeetCode 61 旋转链表

LeetCode 61 旋转链表

题目描述&#xff1a; 给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 示例&#xff1a; 输入&#xff1a;head [1, 2, 3, 4, 5]&#xff0c;k 2 输出&#xff1a;[4, 5, 1, 2, 3] 输入&#xff1a;head [0, 1, 2]&#xf…
阅读更多...
LeetCode 19 删除链表的倒数第N个节点

LeetCode 19 删除链表的倒数第N个节点

题目描述&#xff1a; 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例&#xff1a; 输入&#xff1a;head [1, 2, 3, 4, 5]&#xff0c;n 2 输出&#xff1a;[1, 2, 3, 5] 输入&#xff1a;head [1]&#xff0c;n 1 输出&…
阅读更多...
4-链表倒数第k个结点

4-链表倒数第k个结点

题目描述 输入一个链表&#xff0c;输出该链表中倒数第k个结点。如果该链表长度小于k&#xff0c;请返回空。 Me 我的实现思路为&#xff1a;通过一次完全遍历获取链表长度&#xff0c;根据长度于k的差值定位倒数第k个节点。这个思路很好想&#xff0c;也很难优化。 public…
阅读更多...
青岛大学_王卓老师【数据结构与算法】Week04_01_循环链表_学习笔记

青岛大学_王卓老师【数据结构与算法】Week04_01_循环链表_学习笔记

本文是个人学习笔记&#xff0c;素材来自青岛大学王卓老师的教学视频。 一方面用于学习记录与分享&#xff0c;另一方面是想让更多的人看到这么好的《数据结构与算法》的学习视频。 如有侵权&#xff0c;请留言作删文处理。 课程视频链接&#xff1a; 数据结构与算法基础–…
阅读更多...
数据结构--栈的链式存储

数据结构--栈的链式存储

数据结构–栈的链式存储 推荐使用不带头结点的单链表 \color{green}推荐使用不带头结点的单链表 推荐使用不带头结点的单链表 typedef struct LNode {ElemType data;struct LNode* next; } LNode, *LinkList;bool InitList(LinkList &L) {L->next NULL; }后插操作&…
阅读更多...
408复习笔记（一）：经典数据结构和算法PART1（线性表、栈和队列、数组和特殊矩阵、串、树）

408复习笔记（一）：经典数据结构和算法PART1（线性表、栈和队列、数组和特殊矩阵、串、树）

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录前言一、线性表1.单链表2.双链表3.循环链表4.静态链表二、操作受限的线性表——栈和队列1.顺序栈2.链栈3.共享栈4.队列的顺序存储5.循环队列6.链式队列7.双端队列、输…
阅读更多...
LeetCode50天刷题计划（Day 1—— 两数相加 11.00-12.30）

LeetCode50天刷题计划（Day 1—— 两数相加 11.00-12.30）

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录前言一、题目描述题目示例提示二、思路三、代码1.python2.c前言 机试太菜了每次都被秒杀 所以趁暑假好好练习一下吧~ 一、题目描述 题目 两数相加 给你两个 非空…
阅读更多...
给植物浇水

给植物浇水

5201. 给植物浇水 难度中等0 你打算用一个水罐给花园里的 n 株植物浇水。植物排成一行&#xff0c;从左到右进行标记&#xff0c;编号从 0 到 n - 1 。其中&#xff0c;第 i 株植物的位置是 x i 。x -1 处有一条河&#xff0c;你可以在那里重新灌满你的水罐。 每一株植物都…
阅读更多...
5915. 找出临界点之间的最小和最大距离

5915. 找出临界点之间的最小和最大距离

5915. 找出临界点之间的最小和最大距离 链表中的 临界点 定义为一个 局部极大值点 或 局部极小值点 。 如果当前节点的值 严格大于 前一个节点和后一个节点&#xff0c;那么这个节点就是一个 局部极大值点 。 如果当前节点的值 严格小于 前一个节点和后一个节点&#xff0c…
阅读更多...
间隔删除链表结点

间隔删除链表结点

给你一个链表的头结点 head&#xff0c;每隔一个结点删除另一个结点&#xff08;要求保留头结点&#xff09;。 请返回最终链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4] 输出: [1,3] 解释&#xff1a; 蓝色结点为删除的结点 示例 2&#xff1a; 输入&a…
阅读更多...
02.07. 链表相交

02.07. 链表相交

问题&#xff1a;给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c;函数返…
阅读更多...
移除链表元数

移除链表元数

思路 这里以链表 1 4 2 4 来举例&#xff0c;移除元素4。 如果使用C&#xff0c;C编程语言的话&#xff0c;不要忘了还要从内存中删除这两个移除的节点&#xff0c; 清理节点内存之后如图&#xff1a; 当然如果使用java &#xff0c;python的话就不用手动管理内存了。 还要说…
阅读更多...
删除单向链表的最后一个节点

删除单向链表的最后一个节点

具体操作&#xff1a; 1、封装一个生成链表的函数&#xff08;createlist&#xff09;&#xff0c;一个遍历并打印链表的函数&#xff08;printlist&#xff09;&#xff0c;一个删除链表最后节点的函数&#xff08;deletelist需要判断是否只剩1个节点&#xff09;&#xff1b…
阅读更多...
链表定义 头插法 尾插法 按位序查找 按值查找 插入 删除 双链表 循环链表 静态链表 链表逆置 C语言实现

链表定义 头插法 尾插法 按位序查找 按值查找 插入 删除 双链表 循环链表 静态链表 链表逆置 C语言实现

单链表的定义 typedef struct LNode{ElemType data;//数据域struct LNode *next;//指针域 }LNode,*LinkList;说明(上面两种重命名方式) 作用是相同的&#xff0c;理解上不同 LNode&#xff1a;强调这是一个结点&#xff0c;指向一个结点的指针就代表这个结点&#xff08;在创建…
阅读更多...
leetcode 21.合并两个有序链表|数据结构-链表

leetcode 21.合并两个有序链表|数据结构-链表

leetcode 21. 合并两个有序链表 难度&#xff1a;简单 题目&#xff1a;将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 代码如下&#xff1a; struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2)…
阅读更多...
leetcode 19.删除链表倒数第N个节点|数据结构-链表

leetcode 19.删除链表倒数第N个节点|数据结构-链表

19. 删除链表的倒数第N个节点 难度&#xff1a;中等 题目&#xff1a;给定一个链表&#xff0c;删除链表的倒数第 n 个节点&#xff0c;并且返回链表的头结点。 说明&#xff1a;给定一个链表: 1->2->3->4->5, 和 n 2. 当删除了倒数第二个节点后&#xff0c;链表变…
阅读更多...
leetcode 206.反转链表|数据结构-链表

leetcode 206.反转链表|数据结构-链表

206. 反转链表 难度&#xff1a;简单 题目&#xff1a;反转一个单链表。 代码如下&#xff1a; struct ListNode* reverseList(struct ListNode* head) {struct ListNode *pre NULL;struct ListNode *cur head;struct ListNode *next NULL;while (cur ! NULL) {next cur-&…
阅读更多...
第二章--线性表之单链表

第二章--线性表之单链表

目录一、单链表的定义1.什么是单链表2.用代码定义一个单链表代码实现&#xff1a;3.不带头结点的单链表代码实现&#xff1a;4.带头结点的单链表二、插入和删除1.按位序插入(1)、带头结点(2).不带头结点(3).指定结点的后插操作(4).指定结点的前插操作2.按位删除(1).带头结点(2)…
阅读更多...
剑指offer 刷题 二 链表（06 24 35）

剑指offer 刷题 二 链表（06 24 35）

剑指 Offer 06. 从尾到头打印链表 输入一个链表的头节点&#xff0c;从尾到头反过来返回每个节点的值&#xff08;用数组返回&#xff09;。 迭代 def reversePrint(self, head: ListNode):cur headli []while cur:li.append(cur.val)cur cur.nextli.reverse()return li递…
阅读更多...
Leetcode 刷题笔记 双向链表

Leetcode 刷题笔记 双向链表

一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接&#xff1a;一个指向前一个节点&#xff0c;当此节点为第一个节点时&#xff0c;指向空值&#xff1b;而另一个指向下一个节点&#xff0c;当此节点为最后一个节点时&#xff0c;指向空值。 class Node(obje…
阅读更多...
Leetcode 刷题笔记 链表

Leetcode 刷题笔记 链表

链表&#xff1a;通过链将结点们连接起来。 链表&#xff08;Linked list&#xff09;是一种常见的基础数据结构&#xff0c;是一种线性表&#xff0c;但是不像顺序表一样连续存储数据&#xff0c;而是在每一个节点&#xff08;数据存储单元&#xff09;里存放下一个节点的位置…
阅读更多...
剑指 Offer 24. 反转链表（python3编写）

剑指 Offer 24. 反转链表（python3编写）

目录1、题目描述&#xff1a;2、方法一&#xff1a;一次遍历&#xff0c;反转指针指向思路&#xff1a;代码&#xff1a;3、方法二&#xff1a;保存栈&#xff0c;再取栈顶&#xff0c;串起来思路&#xff1a;代码&#xff1a;1、题目描述&#xff1a; 要是之前没做过这道题&am…
阅读更多...
题143.pat甲级练习-1032 Sharing (25 分)

题143.pat甲级练习-1032 Sharing (25 分)

文章目录题143.pat甲级练习-1032 Sharing (25 分)一、题目二、题解题143.pat甲级练习-1032 Sharing (25 分) 一、题目 二、题解 题目要求找到共用链表的表头的地址输出&#xff0c;我采用的路子是分开遍历两个单词&#xff0c;把遍历到的节点地址对应flag&#xff0c;然后看谁最…
阅读更多...
打造先进的内存KV数据库-4 伙伴内存管理系统

打造先进的内存KV数据库-4 伙伴内存管理系统

伙伴算法 大概是这样的&#xff0c;monkey储存引擎&#xff08;今年猴年了嘛&#xff5e;取个名字&#xff0c;重了再换&#xff09;的内存管理使用伙伴算法&#xff0c;大概原理是这样的&#xff1a; 1.多个空闲内存块的链表&#xff0c;分别是不同大小的内存块&#xff0c;…
阅读更多...
【JUC系列】并发容器之ConcurrentHashMap(JDK1.8版)扩容图解说明

【JUC系列】并发容器之ConcurrentHashMap(JDK1.8版)扩容图解说明

ConcurrentHashMap&#xff08;JDK1.8&#xff09;扩容说明 文章目录ConcurrentHashMap&#xff08;JDK1.8&#xff09;扩容说明扩容过程触发条件基本原理步骤case1&#xff1a;当前的任务是整个数组扩容的最后一个任务或者扩容冲突。case2&#xff1a;该桶为空即Node数组i下标…
阅读更多...
C的几个小程序和概念(also,Pointers on C)

C的几个小程序和概念(also,Pointers on C)

C的几个小程序和概念(also,Pointers on C) 1、char *strncpy(char *dest, const char *src&#xff0c;int count) string.h 将字符串src中的count个字符拷贝到字符串dest中去 dest 等于src的前count个字符内容 返回指向dest的指针 int main() { char *s2"hello&q…
阅读更多...
c语言成绩管理系统（链表）

c语言成绩管理系统（链表）

C语言实现了学生成绩管理系统&#xff0c;可以进行学生成绩的增加&#xff0c;删除&#xff0c;修改&#xff0c;查询&#xff0c;计算平均成绩和展示。 开发语言&#xff1a;C语言 开发工具&#xff1a;Dev c 开发者&#xff1a;呵呵up 创建学生成绩信息 2. 插入学生信息 3.…
阅读更多...
数据结构算法学习笔记(一) 链表

数据结构算法学习笔记(一) 链表

个人学习数据结构算法笔记系列 链表 目录 个人学习数据结构算法笔记系列 链表 &#xff08;一&#xff09;知道什么是链表&#xff1f; &#xff08;二&#xff09;链表的几种类型 1.单链表 2.双向链 &#xff08;三&#xff09;构造链表 &#xff08;四&#xff09;链…
阅读更多...
二叉树中的列表 Linked List in Binary Tree

二叉树中的列表 Linked List in Binary Tree

文章目录二叉树中的列表 Linked List in Binary Tree思路Tag二叉树中的列表 Linked List in Binary Tree 一颗以root为根的二叉树&#xff0c;和一个head 为首节点的链表。如果在二叉树中存在一个一直向下的路径&#xff0c;并且每一个节点的值都对应head为首节点的链表的值&a…
阅读更多...
Partition List 分隔链表

Partition List 分隔链表

文章目录Partition List 分隔链表Description思路: 虚头Partition List 分隔链表 Description 将一个链表&#xff0c;按照给定的x值&#xff0c;分成2部分&#xff0c;链表前部小于x&#xff0c;后部大于等于x 输入&#xff1a;head [1,4,3,2,5,2], x 3 输出&#xff1a;[…
阅读更多...
【PAT刷题甲级】1074.Reversing Linked List

【PAT刷题甲级】1074.Reversing Linked List

1074 Reversing Linked List (25 分) 测试点1,5错误已解决。 Given a constant K and a singly linked list L, you are supposed to reverse the links of every K elements on L. For example, given L being 1→2→3→4→5→6, if K3, then you must output 3→2→1→6→5→…
阅读更多...
1052 Linked List Sorting (25分)

1052 Linked List Sorting (25分)

5 00001 11111 100 -1 00001 0 22222 33333 100000 11111 12345 -1 33333 22222 1000 12345输出&#xff1a; 5 12345 12345 -1 00001 00001 0 11111 11111 100 22222 22222 1000 33333 33333 100000 -1注意点&#xff1a; 1、可能会有无效节点所以排序中要包括筛选 2、有效节…
阅读更多...
带头结点的单链表

带头结点的单链表

#include <stdio.h> #include <stdlib.h> #include <time.h>#define MALLOC_OK 1 #define MALLOC_NO 0 #define CREATE_OK 1 #define CREATE_NO 0/**带头结点的单链表* * */struct node {int num;char name;int age;struct node *next; };typedef struct nod…
阅读更多...
1032 Sharing (25分)

1032 Sharing (25分)

11111 22222 9 67890 i 00002 00010 a 12345 00003 g -1 12345 D 67890 00002 n 00003 22222 B 23456 11111 L 00001 23456 e 67890 00001 o 00010输出&#xff1a; 67890注意输出格式%05d 不然测试点4是过不了的 结构体中设置flag/order便于链表的处理 order用于顺序链接 fla…
阅读更多...
1074 Reversing Linked List (25分)

1074 Reversing Linked List (25分)

00100 6 4 00000 4 99999 00100 1 12309 68237 6 -1 33218 3 00000 99999 5 68237 12309 2 33218输出&#xff1a; 00000 4 33218 33218 3 12309 12309 2 00100 00100 1 99999 99999 5 68237 68237 6 -1分为两块 链表处理 和 结果处理 链表处理通过order顺序链接起来 通过对or…
阅读更多...
1097 Deduplication on a Linked List

1097 Deduplication on a Linked List

题目来源&#xff1a;PAT (Advanced Level) Practice Given a singly linked list L with integer keys, you are supposed to remove the nodes with duplicated absolute values of the keys. That is, for each value K, only the first node of which the value or absolu…
阅读更多...
1032 Sharing

1032 Sharing

题目来源&#xff1a;PAT (Advanced Level) Practice To store English words, one method is to use linked lists and store a word letter by letter. To save some space, we may let the words share the same sublist if they share the same suffix. For example, load…
阅读更多...
习题2.5 两个有序链表序列的合并 (15point(s))

习题2.5 两个有序链表序列的合并 (15point(s))

习题2.5 两个有序链表序列的合并 (15point(s)) 本题要求实现一个函数&#xff0c;将两个链表表示的递增整数序列合并为一个非递减的整数序列。 函数接口定义&#xff1a; List Merge( List L1, List L2 ); 其中List结构定义如下&#xff1a; typedef struct Node PtrToNode;…
阅读更多...
LeetCode160相交链表

LeetCode160相交链表

分析 如果不相交则直接返回null如果两个链表相交&#xff0c;则相交后面的部分一样我们不用考虑&#xff0c;所以我们只需要考虑前面即可。 解法 如果两个链表等长的话分别遍历两个链表&#xff0c;判断所向的节点是否相等。如果不等长的话&#xff0c;可以先让长的链表走两…
阅读更多...
LeetCode 面试题02.03 删除中间的节点

LeetCode 面试题02.03 删除中间的节点

怎么说呢&#xff0c;这道题不难&#xff0c;但重点在于理解。不然就像我一样gg&#xff08;想了好久才想通&#xff0c;已哭晕在厕所&#xff09;觉得需要记录一下这道题。 分析&#xff1a; 删除单向链表中间的某个节点&#xff0c;既不是头也不是尾&#xff08;这个非常关…
阅读更多...
Leetcode 203.移除链表中的元素

Leetcode 203.移除链表中的元素

链表的题我们如果没思路的话画图就完事了。链表中我们需要关注三个主要的位置&#xff0c;头&#xff0c;尾&#xff0c;和中任意位置 下面我们来画图解释一下。 我们可以使用双指针来解决这个问题&#xff0c;cur代表当前节点&#xff08;从head.next开始&#xff09;&…
阅读更多...
习题2.4 递增的整数序列链表的插入 (15point(s))

习题2.4 递增的整数序列链表的插入 (15point(s))

习题2.4 递增的整数序列链表的插入 (15point(s)) 本题要求实现一个函数&#xff0c;在递增的整数序列链表&#xff08;带头结点&#xff09;中插入一个新整数&#xff0c;并保持该序列的有序性。 函数接口定义&#xff1a; List Insert( List L, ElementType X ); 其中List结…
阅读更多...
链表OJ题（1）

链表OJ题（1）

目录 一 、删除链表中等于给定值 val 的所有节点。 二、 反转一个单链表。 三、 给定一个带有头结点 head 的非空单链表&#xff0c;返回链表的中间结点。如果有两个中间结点&#xff0c;则返回第二个中间结点。 四、输入一个链表&#xff0c;输出该链表中倒数第k个结点 Y…
阅读更多...
链表的头结点和头指针_从没有头指针的链表中删除节点

链表的头结点和头指针_从没有头指针的链表中删除节点

链表的头结点和头指针Problem statement: 问题陈述&#xff1a; Write a program to delete a node in a linked list where the head pointer to the node is not given, only the address of the node to be deleted is provided. 编写程序以删除链表中的节点&#xff0c;该…
阅读更多...
对单个字符串排序_对单个链接列表进行绝对排序

对单个字符串排序_对单个链接列表进行绝对排序

对单个字符串排序Problem statement: 问题陈述&#xff1a; Given a singly linked list which is ordered in terms of absolute value. Return the sorted linked list in ascending order (based on their original values). No additional storage should be used. 给定一…
阅读更多...
【数据结构与算法】单词查找题解（直接查找 折半查找 有索引表的折半查找 Hash查找）

【数据结构与算法】单词查找题解（直接查找 折半查找 有索引表的折半查找 Hash查找）

题目大意 给定一个单词表“dictionary3000.txt”，单词表已经排好序，通过指定的方式，从下面四种方法查找出单词，输出找到与否并给出查找次数。 在单词表中以顺序查找方式查找，因为单词表已排好序，遇到相同的或第一个比待查找的单词大的单词，就要终止查找；在单词表中以折…
阅读更多...
Java 1025 反转链表

Java 1025 反转链表

题目内容&#xff1a; 给定一个常数 K 以及一个单链表 L&#xff0c;请编写程序将 L 中每 K 个结点反转。例如&#xff1a;给定 L 为 1→2→3→4→5→6&#xff0c;K 为 3&#xff0c;则输出应该为 3→2→1→6→5→4&#xff1b;如果 K 为 4&#xff0c;则输出应该为 4→3→2→…
阅读更多...
数据结构与算法之符号表

数据结构与算法之符号表

1. 符号表 符号表最主要的目的就是将一个键和一个值联系起来&#xff0c;符号表存储的元素是一个键和一个值共同组成的键值对数据&#xff0c;我们可以根据键来查找对应的值。 符号表中&#xff0c;键具有唯一性符号表的API设计&#xff1a; 代码实现 package com.tiger.stu…
阅读更多...
总结：删除单链表/单循环链表中的最小值节点的两种解法（并延伸至：依次找出链表的最小值，打印并删除，释放空间）

总结：删除单链表/单循环链表中的最小值节点的两种解法（并延伸至：依次找出链表的最小值，打印并删除，释放空间）

前言 最近在写数据结构的王道考研书&#xff0c;复习到了链表&#xff0c;写了一些练习题&#xff0c;发现了关于找出链表中的最小值节点有两种方法&#xff0c;而至于是单链表还是循环单链表&#xff0c;只不过是更改了循环的条件。 类似的&#xff0c;也可以得出“依次找出…
阅读更多...
数据结构王道考研书链表练习题---删除一个最小值节点的高效算法

数据结构王道考研书链表练习题---删除一个最小值节点的高效算法

题目描述&#xff1a; 试编写在带头结点的单链表L中删除一个最小值节点的高效算法&#xff08;假设最小值结点是唯一的&#xff09; 答案的思路很清晰&#xff0c;但我一开始没想到&#xff0c;我想到的思路如下&#xff08;较为平直&#xff0c;没有答案那么高级的思路&#x…
阅读更多...
操作系统——空闲内存管理

操作系统——空闲内存管理

空闲内存管理目录 文章目录空闲内存管理目录前言一、使用位图的存储管理二、使用链表的存储管理1.首次适配算法2.下次适配算法3.最佳适配算法4.最差适配算法5.快速适配算法前言 在动态分配内存时&#xff0c;操作系统有两种方法跟踪内存使用情况:位图和空闲区链表。 一、使用…
阅读更多...
【 基础知识】轻松实现基本数据结构、时间复杂度、加权有向图，加权无向图的最短路径算法、排序算法等

【 基础知识】轻松实现基本数据结构、时间复杂度、加权有向图，加权无向图的最短路径算法、排序算法等

程序的空间复杂度与时间复杂度 程序的空间复杂度与存储有关 时间复杂度与算法次数有关&#xff0c; 是最差情况下大致的程序运行次数。程序运行时间 时间复杂度 * 一次运算所需要的时间 。 时间复杂度写法O(n) n次运算的复杂度是O(n) 二分查找的时间复杂度是 O(log n) 就是求以…
阅读更多...
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 栈

《数据结构、算法与应用 —— C++语言描述》学习笔记 — 栈

《数据结构、算法与应用 —— C语言描述》学习笔记 — 栈一、抽象数据类型二、数组描述1、作为派生类实现&#xff08;1&#xff09;复杂度分析&#xff08;2&#xff09;评价2、直接实现3、性能测量三、链表描述1、作为派生类实现2、直接实现3、性能比较栈是一种特殊的线性表&…
阅读更多...
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 稀疏矩阵 — 多线性表

《数据结构、算法与应用 —— C++语言描述》学习笔记 — 稀疏矩阵 — 多线性表

《数据结构、算法与应用 —— C语言描述》学习笔记 — 稀疏矩阵 — 多线性表一、描述方式二、链表结构改进1、节点修改2、链表扩展3、扩展链表修改&#xff08;1&#xff09;内置元素插入&#xff08;2&#xff09;对外插入接口&#xff08;3&#xff09;拷贝、赋值三、稀疏矩阵…
阅读更多...
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 线性表 —— 链式描述

《数据结构、算法与应用 —— C++语言描述》学习笔记 — 线性表 —— 链式描述

《数据结构、算法与应用 —— C语言描述》学习笔记 — 线性表 —— 链式描述一、链表的节点二、线性表链表描述1、构造和拷贝2、析构3、容量4、查找5、删除6、插入7、输出三、迭代器1、接口2、实现3、begin 和 end四、线性表扩展1、接口2、链表接口3、链表实现&#xff08;1&am…
阅读更多...
160. 相交链表 python

160. 相交链表 python

160. 相交链表 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c;函数返…
阅读更多...
算法笔记二（这些数据结构你知道吗？）

算法笔记二（这些数据结构你知道吗？）

目录 一、数组模拟单链表 二、数组模拟双链表 三、数组模拟栈 1、表达式求值 四、数组模拟队列 五、单调栈 六、单调队列 七、KMP 八、Trie? 1.最大异或对 九、并查集
阅读更多...
【LeetCode】—— 回文链表LeetCode234题

【LeetCode】—— 回文链表LeetCode234题

LeetCode234题回文链表 题目描述 请判断一个链表是否为回文链表。 示例 1: 输入: 1->2 输出: false示例 2: 输入: 1->2->2->1 输出: true解题思路 首先利用快慢指针找到链表的中间节点&#xff0c;再将链表的后半部分逆置之后对比两部分链表是否相同&#xf…
阅读更多...
一文就够！HashMap扩容死循环问题

一文就够！HashMap扩容死循环问题

JDK 1.7 HashMap 扩容核心算法 下面这是JDK 1.7中HashMap扩容时调用的核心代码&#xff0c;作用是将原hash桶中的节点转移到新的hash桶中&#xff1a; void transfer(Entry[] newTable) { Entry[] src table; int newCapacity newTable.length; for (int j 0; j < src.l…
阅读更多...
containers-容器

containers-容器

维基百科定义&#xff1a;In computer science, a container is a class, a data structure,[1][2] or an abstractdata type (ADT) whose instances are collections of other objects. In other words;they are used for storing objects in an organized way following spec…
阅读更多...
数据结构教程（详细又简单——C语言实现）

数据结构教程（详细又简单——C语言实现）

本博文使用简单易懂的方式讲解数据结构&#xff0c;并用C语言进行了实现&#xff0c;即使你是零基础&#xff0c;本博文也会为你铺平学习之路&#xff0c;相信读完本博客你会对数据结构有更深一步的了解和认识。 本博文中提到的所有数据结构都使用C语言进行了实现&#xff0c;…
阅读更多...
复杂链表的复制的几种解法 — C+++实现

复杂链表的复制的几种解法 — C+++实现

题目描述 输入一个复杂链表&#xff08;每个节点中有节点值&#xff0c;以及两个指针&#xff0c;一个指向下一个节点&#xff0c;另一个特殊指针random指向一个随机节点&#xff09;&#xff0c;请对此链表进行深拷贝&#xff0c;并返回拷贝后的头结点。&#xff08;注意&…
阅读更多...
PAT (Basic Level) Practice （中文）- 1025 反转链表 (25 分)

PAT (Basic Level) Practice （中文）- 1025 反转链表 (25 分)

题目 给定一个常数 K 以及一个单链表 L&#xff0c;请编写程序将 L 中每 K 个结点反转。例如&#xff1a;给定 L 为 1→2→3→4→5→6&#xff0c;K 为 3&#xff0c;则输出应该为 3→2→1→6→5→4&#xff1b;如果 K 为 4&#xff0c;则输出应该为 4→3→2→1→5→6&#xff…
阅读更多...
刷题：线性结构—链表

刷题：线性结构—链表

目录 单链表 插入元素 删除元素 创建单列表 双链表 循环链表 例题 移除链表元素 旋转链表 单链表 class ListNode:def __init__(self,val0,nextNone):self.val valself.next next val 这一个节点对应的值 next 这个节点指向的下一个节点 带头结点的单链表&…
阅读更多...
数据结构笔记-实现链表反转 python

数据结构笔记-实现链表反转 python

概述 这里主要针对单向链接表&#xff0c;单向连接表的结点是一个二元组&#xff0c;其中元素域elem保存着作为表元素的数据项&#xff0c;连接域next包含着同一个表里下一个节点的标识。在最常见的单链表里&#xff0c;与表里n个元素对应的n个结点通过连接形成一条结点链&…
阅读更多...
剑指offer（14）——C++实现输出链表倒数第K个节点

剑指offer（14）——C++实现输出链表倒数第K个节点

题目 输入一个链表&#xff0c;输出该链表中倒数第k个结点。 考察点 链表代码的鲁棒性 解题思路 一开始想法&#xff1a;遍历下链表&#xff0c;然后从后往前回溯K个节点&#xff0c;输出即可。但因给定链表为单链表&#xff0c;其节点只有从前往后的指针&#xff0c;故该…
阅读更多...
数据结构笔记-栈与队列 python

数据结构笔记-栈与队列 python

概述 栈与队列是程序设计中被广泛应用的两种重要的数据结构&#xff0c;都是在特定范围的存储单元内存储数据&#xff0c;这些数据都可以被重新取出使用&#xff0c;与线性表相比&#xff0c;他们的插入和删除受到更多的约束&#xff0c;固又称限定性的线性表结构。他们是最简…
阅读更多...
从尾到头打印链表

从尾到头打印链表

输入一个链表的头节点&#xff0c;按链表从尾到头的顺序返回每个节点的值&#xff08;用数组返回&#xff09;。 如输入{1,2,3}的链表如下图: ​ 返回一个数组为[3,2,1] 0 < 链表长度 < 10000 示例1 输入&#xff1a; {1,2,3} 返回值&#xff1a; [3,2,1]示例2 输入…
阅读更多...
FreeRTOS实时操作系统（六）列表与列表项

FreeRTOS实时操作系统（六）列表与列表项

系列文章目录 文章目录 系列文章目录简要概念列表列表项迷你列表项 相关API函数初始化列表列表项初始化列表项插入&#xff08;升序&#xff09;末尾列表项插入列表项删除 实战实验 简要概念 列表是 FreeRTOS 中的一个数据结构&#xff0c;概念上和链表有点类似&#xff0c;列…
阅读更多...
[数据结构初阶]双链表

[数据结构初阶]双链表

目录 双链表定义 初始化 创建节点 尾插 ​编辑 尾删 头插 头删 打印 查找 pos插入 头插复用 尾插复用 pos删除 头删复用 尾删复用 判空 size 销毁 完整代码 前面我们学习了单链表&#xff0c;但按照带头不带头(哨兵)和循环不循环我们可以有四种单链表&#…
阅读更多...
JAVA数据结构之顺序表、单向链表及双向链表的设计和API实现

JAVA数据结构之顺序表、单向链表及双向链表的设计和API实现

一、顺序表 顺序表在内存中是数组的形式存储 类名SequenceList构造方法SequenceList(int capacity)&#xff1a;创建容量为capacity的SequenceList对象成员方法1. public void clear()&#xff1a;空置线性表 2. public boolean isEmpty()&#xff1a;判断线性表是否为空&…
阅读更多...
92%的同学都在搜索的hashmap面试题

92%的同学都在搜索的hashmap面试题

现在网上有关hashmap面试题的资料可以说是五花八门的&#xff0c;有的只有问题没有回答&#xff0c;有的有回答没有解答思路&#xff0c;这就让我们很难参考了。在我们的面试中除了要征服面试官&#xff0c;让面试官看到我们的技术功底&#xff0c;也是面试者之间的pk&#xff…
阅读更多...
面经-01

面经-01

面试java开发工程师 常用数据结构&#xff0c;区别及使用场景 以下是一些常用的数据结构&#xff0c;它们的区别以及适用场景&#xff1a; 数组 (Array)&#xff1a; 区别&#xff1a;数组是一种连续内存空间的数据结构&#xff0c;具有固定的大小&#xff0c;用于存储相同类型…
阅读更多...
leetcode876.链表的中间节点

leetcode876.链表的中间节点

个人主页&#xff1a;平行线也会相交 欢迎 点赞&#x1f44d; 收藏✨ 留言✉ 加关注&#x1f493;本文由 平行线也会相交 原创 收录于专栏【LeetCode】 目录题目链接解法1&#xff1a;快慢指针解题代码题目链接 题目链接 解法1&#xff1a;快慢指针 解法一&#xff1a;快慢指…
阅读更多...
线性表详解

线性表详解

目录 1.线性表的定义和特点 2.案例 2.1一元多项式的计算 可以通过下面这个题目简单练习一下 2.2稀疏多项式的计算 2.3图书信息管理系统 3.线性表的类型定义 4.线性表的顺序表示和实现 4.1线性表的顺序储存表示 4.2顺序表中基本操作的实现 5.线性表的链式表现和实现 …
阅读更多...
算法——双指针技巧总结

算法——双指针技巧总结

算法——双指针技巧总结 一、双指针二、链表快慢指针19.删除链表的倒数第 N 个结点双指针 206.反转链表思路&#xff1a;双指针法递归法 92.反转链表 II1.递归2.迭代&#xff08;双指针头插法&#xff09; 876.链表的中间结点常规思路双指针思路 141.环形链表&#xff08;判断链…
阅读更多...
【Java 数据结构】单链表经典面试题 (动图解析)

【Java 数据结构】单链表经典面试题 (动图解析)

&#x1f389;&#x1f389;&#x1f389;点进来你就是我的人了 博主主页&#xff1a;&#x1f648;&#x1f648;&#x1f648;戳一戳,欢迎大佬指点!人生格言&#xff1a;当你的才华撑不起你的野心的时候,你就应该静下心来学习! 欢迎志同道合的朋友一起加油喔&#x1f9be;&am…
阅读更多...
集合专题·拔高·壹

集合专题·拔高·壹

文章目录 1 Collection单列集合、Map双列集合1.1 Collection单列集合1.1.1 Collection单列集合及其实现类1.1.1.1 list集合与Array数组1.1.1.1.1 ArrayList1.1.1.1.2 LinekdList1.1.1.1.2 Vector1.1.1.1.2.1 ArrayList、Vector &#xff08;线程安全&#xff09;的区别是什么1.…
阅读更多...
单链表——“数据结构与算法”

单链表——“数据结构与算法”

各位CSDN的uu们你们好呀&#xff0c;今天&#xff0c;小雅兰的内容终于是我们心心念念的单链表啦&#xff0c;这一块呢&#xff0c;是一个很重要的部分&#xff0c;也是一个对目前的我来说&#xff0c;比较困难的部分&#xff0c;下面&#xff0c;就让我们进入单链表的世界吧 之…
阅读更多...
初学者入门C语言指针与链表

初学者入门C语言指针与链表

什么是链表&#xff1f; 链表是一种数据结构&#xff0c;用于在内存中存储一系列元素。与数组不同&#xff0c;链表中的元素可以不必顺序存储&#xff0c;而是通过指针链接在一起。链表的最简单形式是单向链表&#xff0c;其中每个节点包含一个值和一个指向下一个节点的指针。…
阅读更多...
LeetCode 114 二叉树展开为链表

LeetCode 114 二叉树展开为链表

题目描述&#xff1a; 给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左子指针始终为 null 。展开后的单链表应该与二叉树 先序遍历 顺序…
阅读更多...
Hot100- 将二叉展开化为链表

Hot100- 将二叉展开化为链表

1 前言 1.1 题目描述 给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左子指针始终为 null 。展开后的单链表应该与二叉树 先序遍历 顺序…
阅读更多...
详解删除链表的倒数第N个结点

详解删除链表的倒数第N个结点

LeetCode连接 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例1&#xff1a; 结果如下 【第一步】加入虚拟头结点&#xff0c;然后定义快慢指针指向虚拟头结点 【第二步】让fast指针移动n步(n2) 【第三步】移动fast指针和slow指针…
阅读更多...
单向链表结点的删除

单向链表结点的删除

头删 动头指针 p h; h h->next; free(p);中间(尾)删 待删结点的前驱结点有指针&#xff0c;两指针联动 rp->next delp->next; free(delp);注意 若不能确定删头还是删中间(尾)结点时&#xff1a; 两指针联动跑分情况讨论 删除非空单向链表关键值为key的结点 …
阅读更多...
链表相关的题（简单、中等）

链表相关的题（简单、中等）

例题一&#xff1a;力扣剑指offer.18 1、题目链接 力扣https://leetcode-cn.com/problems/shan-chu-lian-biao-de-jie-dian-lcof/2、题目&#xff1a; 给定单向链表的头指针和一个要删除的节点的值&#xff0c;定义一个函数删除该节点。 返回删除后的链表的头节点。 示例1&…
阅读更多...
详解反转链表

详解反转链表

LeetCode链接 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 情况一&#xff1a;头结点为空 情况二&#xff1a;链表只有一个节点 情况三&#xff1a;链表多于1个节点。 思路&#xff1a;让当前节点指向前一个节点。 如何才能做到当前…
阅读更多...
数据结构与算法面试2

数据结构与算法面试2

● 请你回答一下Array&List&#xff0c; 数组和链表的区别 参考回答&#xff1a; 数组的特点&#xff1a; 数组是将元素在内存中连续存放&#xff0c;由于每个元素占用内存相同&#xff0c;可以通过下标迅速访问数组中任何元素。数组的插入数据和删除数据效率低&#xf…
阅读更多...
LeetCode 86 分隔链表

LeetCode 86 分隔链表

给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你应当 保留 两个分区中每个节点的初始相对位置。 示例&#xff1a; 输入&#xff1a;head [1, 4, 3, 2, 5, 2]&#xff0c…
阅读更多...
哈希---邻接表（简单实现）

哈希---邻接表（简单实现）

设计用C语言来实现----实现的视图&#xff1a; 实现的代码为&#xff1a;(mod 5为例子)typedef int Element; struct node{ Element data; struct node *next;}Node[5];void iniList(){ for(int i0;i<5 i"" node"" i"" data"i;" vo…
阅读更多...
LeetCode 21 合并两个有序链表

LeetCode 21 合并两个有序链表

题目描述&#xff1a; 将两个升序链表合并为一个新的 升序 链表并返回。 新链表是通过拼接给定的两个链表的所有节点组成的。 示例&#xff1a; 输入&#xff1a;l1 [1, 2, 4]&#xff0c;l2 [1, 3, 4] 输出&#xff1a;[1, 1, 2, 3, 4, 4] 输入&#xff1a;l1 [ ]&#x…
阅读更多...
约瑟夫环问题--Java解

约瑟夫环问题--Java解

问题描述&#xff1a; 传送门 哈哈&#xff0c;拥有智慧的人总是能笑到最后。一起向他学习吧。 大致描述就是41个人&#xff0c;从第一个开始报数&#xff0c;谁报到3就原地爆炸&#xff0c;下一个继续从1开始数&#xff0c;如此往复。 解&#xff1a; 约瑟夫环可以看作一个…
阅读更多...
循环链表练习(二)--轮盘赌游戏

循环链表练习(二)--轮盘赌游戏

工科生一枚&#xff0c;热衷于底层技术开发&#xff0c;有强烈的好奇心&#xff0c;感兴趣内容包括单片机&#xff0c;嵌入式Linux&#xff0c;Uboot等&#xff0c;欢迎学习交流&#xff01; 爱好跑步&#xff0c;打篮球&#xff0c;睡觉。 欢迎加我QQ1500836631&#xff08;备…
阅读更多...
【剑指offer】从尾到头打印链表

【剑指offer】从尾到头打印链表

题目描述 输入一个链表&#xff0c;按链表从尾到头的顺序返回一个ArrayList。 解题思路 换句话说&#xff0c;题目要求从尾到头输出链表&#xff0c;遍历链表是少不了的。但是遍历链表是从头到尾的&#xff0c;怎么才能从尾到头呢&#xff1f; 思路一&#xff1a; 有一个小 …
阅读更多...
循环链表练习(一)--约瑟夫环

循环链表练习(一)--约瑟夫环

工科生一枚&#xff0c;热衷于底层技术开发&#xff0c;有强烈的好奇心&#xff0c;感兴趣内容包括单片机&#xff0c;嵌入式Linux&#xff0c;Uboot等&#xff0c;欢迎学习交流&#xff01; 爱好跑步&#xff0c;打篮球&#xff0c;睡觉。 欢迎加我QQ1500836631&#xff08;备…
阅读更多...
带头结点的双向循环链表

带头结点的双向循环链表

思路&#xff1a; 1、首先定义一个结构体&#xff0c;定义一个结构体指针类型&#xff0c;为创建结点做准备。 2、创建头指针&#xff0c;和空链表&#xff0c;这里注意一级指针和二级指针的实参和形参的传 递。 3、插入结点也要创建结点&#xff0c;再插入&#xff0c;后面再根…
阅读更多...
郝斌_数据结构_链表源代码

郝斌_数据结构_链表源代码

郝斌《数据结构》课程源代码 链表的实现 用者自取&#xff0c;自由分享 #include <stdio.h> #include <malloc.h> #include <stdlib.h>typedef struct Node {int data; //数据域struct Node * pNext; //指针域 }NODE, *PNODE; //NODE等价于struct Node PN…
阅读更多...
建立单链表并逆置（C语言实现）

建立单链表并逆置（C语言实现）

问题描述&#xff1a;任意输入 n 个整数&#xff0c;以 0 为结束符&#xff0c;建立带头结点的与输入顺序一致的单链表输出&#xff1b;然后将该表就地空间逆序输出。 下面是流程图 代码实现 #include<stdio.h>struct sqlist {int data[50];int last; };typedef struct…
阅读更多...
链表 -- 单链表 的创建以及插入、删除的基本操作

链表 -- 单链表 的创建以及插入、删除的基本操作

1 分类1.1 单向链表 vs 双向链表1.2 带傀儡节点的 vs 不带傀儡节点的1.3 带环的 vs 不带环的2 创建单链表2.1 节点定义2.2 创建链表3 单链表的遍历3.1 链表的最后一个节点3.2 倒数第二个节点3.3 第 N 个节点3.4 倒数第 N 个节点3.5 获取链表长度3.6 查找链表上是否有某个元素4 …
阅读更多...
Linux C语言链表详细分析

Linux C语言链表详细分析

链表是一种常见的基础数据结构&#xff0c;结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配&#xff0c;也就是说&#xff0c;链表是一个功能极为强大的数组&#xff0c;他可以在节点中定义多种数据类型&#xff0c;还可以根据需要随意增添&#xff0c;删除&…
阅读更多...
D1-读论文D1算法题D1（单链表、双链表）

D1-读论文D1算法题D1（单链表、双链表）

—0844昨晚没睡好&#xff0c;早上6点多起&#xff0c;7点多开始读论文。读了4篇&#xff0c;两篇中文两篇英文&#xff0c;现在吃饭啦~ ---------1131做一些算法题 单链表826 没什么大问题&#xff0c;就是在删除头结点的时候需要注意特别处理。 这次做*pt处理的时候处理的…
阅读更多...
严蔚敏数据结构 P36——算法2.18（前置程序） _双向循环链表的建立(利用前置指针和后置指针进行正序和逆序输出)

严蔚敏数据结构 P36——算法2.18（前置程序） _双向循环链表的建立(利用前置指针和后置指针进行正序和逆序输出)

严蔚敏数据结构 P36——算法2.18&#xff08;前置程序&#xff09; 双向循环链表的建立 利用前置指针和后置指针进行正序和逆序输出 /* 严蔚敏数据结构 P36——算法2.18&#xff08;前置程序&#xff09; 双向循环链表的建立 *///头文件 #include<stdio.h> #include<…
阅读更多...
LeetCode刷题学习

LeetCode刷题学习

学习第一天 我使用的C&#xff0c;错误的地方请见谅&#xff0c;文章初衷仅用来督促本人学习&#xff0c;如果恰巧能够给你带来帮助&#xff0c;我会十分开心。 文章目录学习第一天前言一、141. 环形链表1、unordered_set 容器2、Floyd 判圈算法&#xff08;又称龟兔赛跑算法&…
阅读更多...
链表力扣205题---反转链表

链表力扣205题---反转链表

206 反转链表 题目 反转一个单链表。 示例 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL解题思路 &#xff08;1&#xff09;反转链表&#xff0c;可以采用头插法的思想&#xff0c;将每个元素从头到尾依次遍历&#xff0c;每次都…
阅读更多...
数组结构-链表

数组结构-链表

链表&#xff08;Linked list&#xff09;&#xff1a;链表是一种非连续、非顺序的存储结构。链表本身没有大小的限制&#xff0c;天然地支持动态扩容 它并不需要一块连续的内存空间&#xff0c;它通过“指针”将一组零散的内存块串联起来使用 基础的链表有&#xff1a; 单链表…
阅读更多...
Leetcode链表题目

Leetcode链表题目

文章目录链表基础707. 设计链表206. 反转链表203. 移除链表元素328. 奇偶链表234. 回文链表138. 复制带随机指针的链表链表排序148. 排序链表21. 合并两个有序链表147. 对链表进行插入排序链表双指针141. 环形链表I / 142. 环形链表II19. 删除链表的倒数第N个结点以下为Datawha…
阅读更多...
面试题：说一说栈，队列，堆，链表数据结构的存储方式

面试题：说一说栈，队列，堆，链表数据结构的存储方式

栈 特点&#xff1a;先进先出 栈底固定&#xff0c;而栈顶浮动&#xff1b;栈中元素个数为零时称为空栈。插入一般称为进栈&#xff0c;删除则称为退栈。栈也称为后进先出表。 优点&#xff1a;添加速度快&#xff0c;允许重复&#xff1b; 缺点&#xff1a;只能在一头操作数…
阅读更多...
LeetCode-114. 二叉树展开为链表

LeetCode-114. 二叉树展开为链表

LeetCode-114. 二叉树展开为链表 难度&#xff1a;中等 给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左子指针始终为 null 。 展开后的…
阅读更多...
Java比较器(三) 利用二叉树链表进行对象数组排序

Java比较器(三) 利用二叉树链表进行对象数组排序

二叉树&#xff1a;一个节点有左右两个子节点&#xff0c;左节点比中节点小&#xff0c;右节点比中节点大 和单链表结构大同小异&#xff0c;无非就是将单链表中的next节点换成了left、right两个节点。 单链表结构 创建一个简单的二叉树链表模型&#xff1a; //实现二叉树模…
阅读更多...
Java编写简单 单链表结构

Java编写简单 单链表结构

二叉树链表简单模型 package myc.java.util;//链表类&#xff0c;供外界调用 public class Link {//内部封装类Note&#xff0c;进行链表的数据逻辑关系处理//采用内部类的原因为&#xff1a;Link类可以之间访问Note内部类的私有属性&#xff0c;并且Note对外界来说是安全的&a…
阅读更多...
链表的创建、逆序、合并、遍历

链表的创建、逆序、合并、遍历

功能&#xff1a; 将两个非递减次序排列的单链表归并为一个非递增次序排列的单链表&#xff0c;并计算表长。要求利用原来两个单链表的结点存放归并后的单链表。 效果图&#xff1a; 代码&#xff1a; #include <iostream> using namespace std;struct StNode {int d…
阅读更多...
LeetCode1720. 解码异或后的数组； 剑指offer21/22/23/24

LeetCode1720. 解码异或后的数组； 剑指offer21/22/23/24

LeetCode1720. 解码异或后的数组 题目描述 未知 整数数组 arr 由 n 个非负整数组成。 经编码后变为长度为 n - 1 的另一个整数数组 encoded &#xff0c;其中 encoded[i] arr[i] XOR arr[i 1] 。例如&#xff0c;arr [1,0,2,1] 经编码后得到 encoded [1,2,3] 。 给你编…
阅读更多...
链表查改增删及反转、合并

链表查改增删及反转、合并

1. 定义 class ListNode:def __init__(self, x):self.val xself.next None 1.1 遍历链表 def bian_li(head):if not head:print("list is null")returnp head.nextwhile p:print(p.val)p p.next 1.2 求表长 def get_length(head):if not head:return -1cnt …
阅读更多...
C语言 使用链表实现队列接口

C语言 使用链表实现队列接口

前言 1. 队列是一种常见的数据结合&#xff0c;具有先入先出的特点。数据从队列的头部&#xff08;front&#xff09;剥离&#xff0c;从队列的尾部&#xff08;rear&#xff09;插入。使用队列可以作为数据缓冲&#xff0c;也可以用作异步通讯。博主在实现OCPP 1.6J协议时&am…
阅读更多...
堆栈的链表实现（C语言）

堆栈的链表实现（C语言）

本文介绍堆栈及其C语言链表的实现 目录堆栈堆栈的操作初始化入栈出栈遍历查找堆栈的C语言链表实现堆栈 为了阅读方便和保持内容的完整性&#xff0c;这部分使用了堆栈的数组实现&#xff08;C语言&#xff09;中的内容 堆栈&#xff0c;也称为栈&#xff0c;是一种只能在一端…
阅读更多...
循环双链表及C语言实现

循环双链表及C语言实现

本文介绍循环双链表及C语言实现 目录循环双链表循环双链表的操作插入头结点插入尾结点插入指定位置插入删除头结点删除尾结点删除指定位置删除遍历查找循环双链表的C语言实现循环双链表 双链表中&#xff0c;每个结点单元都有一个数据域和两个指针域&#xff0c;每个结点的pre…
阅读更多...
复制含有随机指针节点的链表

复制含有随机指针节点的链表

题目描述 一种特殊的链表节点类描述如下: public class Node { public int value; public Node next; public Node rand;public Node(int data) { this.value data; } } Node类中的value是节点值&#xff0c;next指针和正常单链表中next指针的意义一样&#xff0c;都指向下一…
阅读更多...
c++实现单链表操作

c++实现单链表操作

c链表定义&#xff1a; typedef void LinkList; typedef void LinkNode;struct LKNode {LKNode* next; };class MyLinkList1 { public:MyLinkList1();~MyLinkList1();void mylist_create();void mylist_destroy();void mylist_clear();int mylist_length();int mylist_insert(…
阅读更多...
循环单链表及C语言实现

循环单链表及C语言实现

本博文介绍循环单链表及其C语言的实现 目录循环单链表循环单链表的操作插入头结点插入尾结点插入指定位置插入删除头结点删除尾结点删除指定位置删除遍历查找循环单链表的C语言实现循环单链表 单链表中&#xff0c;链表的最后一个结点的指针为NULL&#xff0c;每次遍历单链表都…
阅读更多...
反转链表 反转链表II【M】

反转链表 反转链表II【M】

92. 反转链表 II 很显然&#xff0c;对于反转链表的题来说&#xff0c;会有递归和迭代两种解法。 如果用递归&#xff0c;建议先熟悉下面的普通反转链表问题&#xff0c;一步步推导到指定范围内的链表反转问题&#xff1a; 迭代法&#xff1a; 这题&#xff0c;我的做法可行&…
阅读更多...
单链表的归并 noj

单链表的归并 noj

Description 假设两个按元素值非递减有序排列的线性表 A 和 B&#xff0c;均以单链表作为存储结构&#xff0c;试编写程序&#xff0c;将 A 表和 B 表归并成一个按元素值非递增有序排列的线性表 C&#xff0c;并要求利用原表&#xff08;即A表和B表的&#xff09;结点空间存放…
阅读更多...
单链表设计LC.707

单链表设计LC.707

LeetCode链接 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性&#xff1a;val 和 next。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。如果要使用双向链表&#xff0c;则还需要一个属性 prev 以指示链表中的上一个节点。…
阅读更多...
ReentrantLock的原理

ReentrantLock的原理

ReentrantLock例子自己实现ReentrantLock源码例子 我们还是制造一个计数器的线程安全问题&#xff1a; package reentrantlock;public class TestMySynchronizer {public static void main(String[] args) {Counter counter new Counter();//开10条线程对counter加数for (in…
阅读更多...
两数逆向相加

两数逆向相加

问&#xff1a; 给定两个非空链表来存储两个非负整数&#xff0c;位数按照逆序方式存储&#xff0c;每个节点存储单个数字。将两数相加后返回一个新链表。 example&#xff1a; input&#xff1a;2 -> 4 -> 3 5 -> 6 -> 4 output&#xff1a;7 -> 0 -> 8…
阅读更多...
字符串常考面试题（大数相加）

字符串常考面试题（大数相加）

字符串常考面试题大数相加大数相乘两数相加链表相加二进制求和数组中相加和为0的三元组把字符串转成整数第一个只出现一次的字符最长公共前缀反转字符串反转字符串II&#xff08;反转k个&#xff09;仅仅反转字母反转单词&#xff08;顺序改变&#xff09;反转单词&#xff08;…
阅读更多...
超详细的逐句介绍Java高级接口之LinkedList底层源码讲解（一）

超详细的逐句介绍Java高级接口之LinkedList底层源码讲解（一）

一、LinkedList LinkedList是基于链表结构的一种线性结构存储结构&#xff0c;他和ArrayList的结构类似&#xff0c;两者均可以创建动态数组结构&#xff0c;唯一区别在于ArrayList创建的动态数组在内存上是连续的&#xff0c;而LinkedList是离散的。 二、LinkedList的内部方…
阅读更多...
Java复习----集合/容器

Java复习----集合/容器

集合/容器java 容器都有哪些&#xff1f;java容器那些是线程安全的&#xff0c;那些是线程不安全的&#xff1f;Collection 和 Collections 有什么区别&#xff1f;List、Set、Map 之间的区别是什么&#xff1f;HashMap 和 Hashtable 有什么区别&#xff1f;如何决定使用 HashM…
阅读更多...
双向链表java实现

双向链表java实现

双向链表其实就比单链表多了一个前驱而已&#xff08;用来存放上一个节点的位置&#xff09; 但要注意的是头结点的prev为null&#xff0c;最后一个结点的next域为null。 实现代码如下 public class ListNode {public int val;public ListNode next;public ListNode prev;//a…
阅读更多...
循环链表解决拉丁方阵问题 数据结构 C/C++

循环链表解决拉丁方阵问题 数据结构 C/C++

循环链表解决拉丁方阵问题1.拉丁方阵2.问题描述3.main函数4.打印拉丁方阵代码5.循环链表基本操作实现1.拉丁方阵 拉丁方阵&#xff08;英语&#xff1a;Latin square&#xff09;是一种 n n 的方阵&#xff0c;在这种 n n 的方阵里&#xff0c;恰有 n 种不同的元素&#xff0…
阅读更多...
LeetCode61旋转链表

LeetCode61旋转链表

分析 题目中说的是旋转&#xff0c;但其实本质上是将尾部向前数第K个元素作为头&#xff0c;原来的头接到原来的尾上我们可以用快慢指针来解决这个问题。 cur当前节点&#xff08;用于遍历链表&#xff0c;得到链表的长度&#xff09;k代表链表的长度newHead旋转后链表的头部…
阅读更多...
数据结构之特殊线性结构：队列、栈

数据结构之特殊线性结构：队列、栈

线性结构 本专栏的上篇文章主要介绍了数据结构之顺序结构。基于这个数据结构的基础上衍生出一系列特殊的线性结构&#xff1a;队列和栈。 队列 队列&#xff0c;顾名思义就是类似于我们排队一样。该数据结构是基于队列和链表的基础上&#xff0c;对于数据的存取进行一系列的…
阅读更多...
LeetCode141环形链表

LeetCode141环形链表

分析 我们可以采用快慢指针来解决。让fast一次走两步fastfast.next.next&#xff1b;&#xff08;为什么是两步而不是散步或者四步呢&#xff0c;大家可以想一想&#xff09;&#xff0c;让slow一次走一步 slowslow.next;&#xff0c;如果有环&#xff08;则会有fastslow&#…
阅读更多...
2.18--2.19双向链表的基本操作

2.18--2.19双向链表的基本操作

2.18–2.19双向链表的基本操作 1.双向链表的定义 首先&#xff0c;双链表的结构声明如下&#xff1a;一个前驱节点的指针&#xff0c;一个后继节点的指针和数据域 typedef struct DouNode {ElemType data;struct DouNode* pre;struct DouNode* next; }DouNode;双向链表特点 …
阅读更多...
循环链表及线性表的应用

循环链表及线性表的应用

循环链表的应用之约瑟夫环问题以及线性表总结之顺序表与链表的比较 1.1问题说明 问题描述&#xff1a;编号为1&#xff0c;2&#xff0c;&#xff0c;n的n个人围坐在一圆桌旁&#xff0c;每人持有一个正整数的密码。从第一个人开始报数&#xff0c;报到一个预先约定的正整数m…
阅读更多...
玩转C语言链表-链表各类操作详解

玩转C语言链表-链表各类操作详解

链表概述 链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。它可以根据需要开辟内存单元。链表有一个“头指针”变量&#xff0c;以head表示&#xff0c;它存放一个地址。该地址指向一个元素。链表中每一个元素称为“结点”&#xff0c;每个结点都应包括两…
阅读更多...
链表基本操作（完整代码）

链表基本操作（完整代码）

链表基本操作&#xff08;完整代码&#xff09; 首先汇总一下单链表的基本操作&#xff08;带头结点&#xff09;&#xff1a; 1.单链表的创建 &#xff08;1&#xff09;头插法创建链表 &#xff08;2&#xff09;尾插法创建链表 2.单链表的打印 3.单链表的查询 4.结点插入 &…
阅读更多...
链表基本操作（详解）

链表基本操作（详解）

链表的基本操作 单链表链表的基本操作一&#xff1a;单链表的基础操作二&#xff1a;单链表的建立头插法尾插法三&#xff1a;单链表的遍历四&#xff1a;单链表结点数目判断五&#xff1a;单链表的插入链表头插入任意结点插入链表尾部插入六&#xff1a;单链表的删除七 &#…
阅读更多...
Linux C语言链表你学会了吗？

Linux C语言链表你学会了吗？

链表是一种常见的基础数据结构&#xff0c;结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配&#xff0c;也就是说&#xff0c;链表是一个功能极为强大的数组&#xff0c;他可以在节点中定义多种数据类型&#xff0c;还可以根据需要随意增添&#xff0c;删除&…
阅读更多...
LeetCode链表OJ题目 代码+思路分享

LeetCode链表OJ题目 代码+思路分享

目录 删除有序数组中的重复项合并两个有序数组移除链表元素 删除有序数组中的重复项 链接: link 题目描述&#xff1a; 题目思路&#xff1a; 本题使用两个指针dst和src一前一后 相同情况&#xff1a; 如果nums[dst]nums[src]&#xff0c;那么src 不相同情况&#xff1a; 此…
阅读更多...
LeetCode第141题——环形链表（Java）

LeetCode第141题——环形链表（Java）

题目描述&#xff1a; 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链…
阅读更多...
线性表之单链表（详解）

线性表之单链表（详解）

&#x1f355;博客主页&#xff1a;️自信不孤单 &#x1f36c;文章专栏&#xff1a;数据结构与算法 &#x1f35a;代码仓库&#xff1a;破浪晓梦 &#x1f36d;欢迎关注&#xff1a;欢迎大家点赞收藏关注 文章目录 &#x1f365;前言&#x1f349;链表1. 链表的概念及结构2. 链…
阅读更多...
leetcode 面试题 02.04. 分割链表

leetcode 面试题 02.04. 分割链表

原题为&#xff1a; 给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在大于或等于x 的节点之前。 你不需要 保留 每个分区中各节点的初始相对位置。 测试示例如下&#xff1a; 输入&#xff1a;head [1,4…
阅读更多...
数据结构——第二章 线性表（6）——线性表的应用

数据结构——第二章 线性表（6）——线性表的应用

线性表的应用1.两个线性表的合并2.一元多项式的运用2.1 一元多项式的插入2.2. 一元多项式的创建2.3.两个一元多项式的加法2.4.两个一元多项式的乘法2.5.一元多项式的显示1.两个线性表的合并 假设每个链表的存储结构为带头结点的单向链表&#xff0c;存放的数据是递增的。现在需…
阅读更多...
面试必刷101 Java题解 -- part 2

面试必刷101 Java题解 -- part 2

练习地址 面试必刷101 Java题解 -- part 246、用两个栈实现队列47、包含min函数的栈48、有效括号序列50、最小的K个数51、寻找第K大52、数据流中的中位数53、表达式求值54、两数之和55、数组中出现次数超过一半的数字56、数组中只出现一次的两个数字57、缺失的第一个正整数58、…
阅读更多...
LC-146-LRU 缓存

LC-146-LRU 缓存

原题链接&#xff1a;LRU 缓存 个人解法 思路&#xff1a; 用双向链表维护LRU中的key和value&#xff0c;若访问到则将对应的结点置换到链表尾部&#xff0c;若需要替换则直接替换链表头部&#xff0c;这个比较难debug&#xff0c;要注意细节。 时间复杂度&#xff1a;O(1)O…
阅读更多...
WRITE_ONCE-linux链表-3

WRITE_ONCE-linux链表-3

在__list_del接口中使用了WRITE_ONCE接口&#xff0c;为何这样做&#xff0c;参考&#xff1a; WRITE_ONCE函数和list.h https://www.kernel.org/doc/Documentation/memory-barriers.txt
阅读更多...
链表初始化-linux链表-2

链表初始化-linux链表-2

参考&#xff1a;链表初始化
阅读更多...
HashMap底层源码详解

HashMap底层源码详解

HashMap底层源码详解 package map; import java.util.HashMap; /** Author 雾潋 Version 1.0 */ public class HashMapSource { public static void main(String[] args) { HashMap hashMap new HashMap(); //1.执行构造器 new HashMap() // 初始化加载因子loadfactor 0.…
阅读更多...
【数据结构】链表：看我如何顺藤摸瓜

【数据结构】链表：看我如何顺藤摸瓜

&#x1f451;专栏内容&#xff1a;数据结构⛪个人主页&#xff1a;子夜的星的主页&#x1f495;座右铭&#xff1a;日拱一卒&#xff0c;功不唐捐 文章目录一、前言二、链表1、定义2、单链表Ⅰ、新建一个节点Ⅱ、内存泄漏Ⅲ、插入一个节点Ⅳ、销毁所有节点Ⅴ、反转一个链表3、…
阅读更多...
相交链表-力扣160-java

相交链表-力扣160-java

一、题目描述给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。图示两个链表在节点 c1 开始相交&#xff1a;题目数据 保证 整个链式结构中不存在环。注意&#xff0c;函数返回…
阅读更多...
LeetCode：142. 环形链表 II

LeetCode：142. 环形链表 II

&#x1f34e;道阻且长&#xff0c;行则将至。&#x1f353; &#x1f33b;算法&#xff0c;不如说它是一种思考方式&#x1f340; 算法专栏&#xff1a; &#x1f449;&#x1f3fb;123 题解目录 一、&#x1f331;[142. 环形链表 II](https://leetcode.cn/problems/linked-l…
阅读更多...
疑难问题定位案例复盘（二）

疑难问题定位案例复盘（二）

今天我们继续分析一个因野指针访问导致的内存异常、出现coredump问题。在上一篇案例中&#xff0c;我们分享了一个在内存被释放后&#xff0c;业务模块仍然在使用导致业务模块自身出现coredump的现象。其实&#xff0c;在使用野指针访问内存时还有一种可能&#xff0c;就是业务…
阅读更多...
链表查找（线性表）

链表查找（线性表）

最开始的错误代码以及做题思路和草稿纸上写的过程画的图&#xff1a; #include<stdio.h> #include<stdlib.h> //提供malloc()和free() #include<string.h> //提供strcpy()等 struct Node {int data; //数据域struct Node* next; //指针域(指向节点的指…
阅读更多...
数据结构 - 约瑟夫环

数据结构 - 约瑟夫环

文章目录约瑟夫问题由来约瑟夫环介绍单向环形列表约瑟夫问题由来 据说著名犹太历史学家Josephus有过以下的故事&#xff1a;在罗马人占领乔塔帕特后&#xff0c;39 个犹太人与Josephus及他的朋友躲到一个洞中&#xff0c;39个犹太人决定宁愿死也不要被敌人抓到&#xff0c;于是…
阅读更多...
链表及其实现

链表及其实现

链表数据结构 typedef struct NODE{int value;struct NODE* Next; }Node,*pNode; 单向链表结构简单&#xff0c;存储一个节点指针和数据类型。 链表常用操作 链表的创建链表中增加节点链表中删除节点链表中插入节点 创建链表 pNode CreateList(){pNode pHeadnew Node; // …
阅读更多...
leetcode环形链表

leetcode环形链表

141. 环形链表 解法一: 哈希表 func hasCycle(head *ListNode) bool {set : map[*ListNode]bool{}cur : headfor cur ! nil {if has : set[cur]; has {return true} else {set[cur] true}cur cur.Next}return false }解法二: 快慢指针 若链表为空或者链表只有一个节点&…
阅读更多...
C语言线性表结构的实现及基本操作（2020-10-30）

C语言线性表结构的实现及基本操作（2020-10-30）

C语言线性表结构的实现及基本操作 #include<stdio.h> #include<stdlib.h> #include<malloc.h>typedef int DataType; typedef struct Node {DataType data;struct Node *next; } Node;Node *CreatList(DataType a[],int n)//头插法建…
阅读更多...
实现单向队列的核心思想

实现单向队列的核心思想

目录 目标 特点 代码实现 目标 熟悉队列的特点&#xff0c;能实现单项队列的核心部分。特点 线性表&#xff0c;可以用数组或者链表实现&#xff1b;数据先进先出。代码实现 package com.ctx.data;import java.lang.reflect.Array; import java.util.ArrayDeque; import …
阅读更多...
常见的链表——单向链表双向链表循环链表

常见的链表——单向链表双向链表循环链表

目录 目标 结构图 单向链表的数据结构示意图 双向链表的数据结构示意图 循环单向链表的数据结构示意图 代码实现 单向链表 双向链表 单向循环链表 附加题 约瑟夫环 总结 目标 熟悉单向链表、双向链表、单向循环链表的数据结构&#xff0c;包括增删改查操作&#x…
阅读更多...
算法竞赛进阶指南---0x13（链表与邻接表） 邻值查找

算法竞赛进阶指南---0x13（链表与邻接表） 邻值查找

题面 题解 先考虑暴力做法&#xff0c;两重循环找与当前数差值最小的数&#xff0c;O(n2)超时&#xff0c;接下来考虑如何优化我们可以将这个序列从小到大排序&#xff0c;那么对于差值最小的肯定这这个数左右两边取一个最小差值&#xff0c;那么如何找到一个序列的前驱和后继&…
阅读更多...
阿里巴巴java性能调优实战：ArrayList还是LinkedList？使用不当性能差千倍

阿里巴巴java性能调优实战：ArrayList还是LinkedList？使用不当性能差千倍

ArrayList还是LinkedList&#xff1f;使用不当性能差千倍 集合作为一种存储数据的容器&#xff0c;是我们日常开发中使用最频繁的对象类型之一。JDK 为开 发者提供了一系列的集合类型&#xff0c;这些集合类型使用不同的数据结构来实现。因此&#xff0c;不同的集 合类型&…
阅读更多...
JAVA集合体系总结

JAVA集合体系总结

目录&#xff1a; 一、《疯狂Java讲义》整合片 二、CSDN解释篇 三、慕课篇 一、《疯狂Java讲义》整合片 (Map、Set、List、Queue) 0x01 Collection 接口 Collection接口比较宽泛&#xff0c;该集合就是单一对象的集合&#xff08;对比Map容器&#xff0c;是key-value这样…
阅读更多...
手写LinkList和arrayList

手写LinkList和arrayList

目录&#xff1a; 1、自己写的LinkList和arrayList。 2、基本数据结构&#xff1a;链表&#xff08;list&#xff09; 为了加深理解&#xff0c;我就自己写了下LinkList和arrayList。 下面贴下代码 链表代码 链表代码public class MyTwoLinkedList<AnyType> impleme…
阅读更多...
数据结构实验+顺序表的基本操作

数据结构实验+顺序表的基本操作

顺序表的基本操作 #include <stdio.h>//1-1存储结构 #define MAXSIZE 100 typedef struct {int *elem; //存储空间的基地址int length; }SqList;//1-2初始化顺序表并放入n个数据 void InitList(SqList &L) {L.elem new int[MAXSIZE];L.length0; }//1-3初始化顺序…
阅读更多...
数据结构 队列的实现--链式

数据结构 队列的实现--链式

数据结构c语言链式队列的实现与表示 代码如下&#xff1a; #include <stdio.h> #include <stdlib.h>typedef struct QNode {int data;struct QNode *next; }QNode,*QueuePtr; typedef struct {QueuePtr front;//队头指针 QueuePtr rear;//队尾指针 }LinkQueue;v…
阅读更多...
数据结构与算法之树和二叉树（一）：二叉树基本操作的实现及应用

数据结构与算法之树和二叉树（一）：二叉树基本操作的实现及应用

系列文章传送门&#xff1a; 数据结构与算法之树和二叉树&#xff08;一&#xff09;&#xff1a;二叉树基本操作的实现及应用 数据结构与算法之线性表&#xff08;二&#xff09;&#xff1a;链式表的实现和应用 数据结构与算法之线性表&#xff08;三&#xff09;&#xff1…
阅读更多...
剑指offer删除链表中的节点

剑指offer删除链表中的节点

class Solution { public: ListNode* deleteNode(ListNode* head, int val) { if(head->val val) return head->next;#注意这一点 ListNode *pre head, *cur head->next;#双指针问题 while(cur ! nullptr && cur->val ! val) { pre cur; cur cur->…
阅读更多...
【单链表】单链表的增删改查

【单链表】单链表的增删改查

链表&#xff08;Linked List) 链表是一种物理存储单元上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点&#xff08;链表中每一个元素称为结点&#xff09;组成&#xff0c;结点可以在运行时动态生成。每个结点…
阅读更多...
剑指offer 056、删除链表中重复的结点

剑指offer 056、删除链表中重复的结点

剑指offer 056、删除链表中重复的结点 题目 题解 首先添加一个头节点&#xff0c;以方便碰到第一个&#xff0c;第二个节点就相同的情况设置 pre &#xff0c;cur指针&#xff0c; pre指针指向当前确定不重复的那个节点&#xff0c;而cur指针相当于工作指针&#xff0c;一直往…
阅读更多...
学习日志day12（2021-07-20）（1、集合框架 2、ArrayList类 3、HashSet类和TreeSet类 4、HashMap类 5、泛型集合 ）

学习日志day12（2021-07-20）（1、集合框架 2、ArrayList类 3、HashSet类和TreeSet类 4、HashMap类 5、泛型集合 ）

学习内容&#xff1a;学习JavaSE&#xff08;Day12&#xff09; 1、集合框架 2、ArrayList类 3、HashSet类和TreeSet类 4、HashMap类 5、泛型集合 1、集合框架 &#xff08;1&#xff09;集合框架包含接口、实现类和算法。 接口&#xff1a;是代表集合的抽象数据类型。例如 C…
阅读更多...
链表--稀疏矩阵

链表--稀疏矩阵

稀疏矩阵&#xff0c;用链表实现这样可以大大节省空间&#xff0c;其运用也很简单&#xff1a; template<class T> struct Node{ T value; T colun; Node *next; }; template <class T> void IntialRetange(int n,Node<T> **p) { p(Node<T>**)malloc(n…
阅读更多...
数据结构-链表队列实现

数据结构-链表队列实现

实现的方法是非常简单的&#xff0c;队列是非常重要的基本存储数据的方式之一&#xff0c;同时也是创建数的基本之一。使后续学习的基础&#xff1a; 实现的代码&#xff1a; typedef int Element; typedef struct queue{ Element data; struct queue *next; }Node; typedef s…
阅读更多...
C++数据结构X篇_07_C++单向循环链表解决约瑟夫问题

C++数据结构X篇_07_C++单向循环链表解决约瑟夫问题

本篇参考单向循环链表解决约瑟夫问题&#xff08;C&#xff09;整理&#xff0c;先搞懂结构框架&#xff0c;后期根据视频利用c对内容实现&#xff0c;也可以对c有更高的提升。 文章目录 1. 链表创建与初始化2. 添加插入、删除和打印函数3. 插入数据并核验4. 解决约瑟夫问题&am…
阅读更多...
LinkedList源码学习

LinkedList源码学习

LinkedList 更多访问 基于双向链表实现&#xff0c;内部使用Node来存储链表的节点信息&#xff0c;也是实现了list接口。 private static class Node<E> {E item;Node<E> next;Node<E> prev;Node(Node<E> prev, E element, Node<E> next) {thi…
阅读更多...
LeetCode算法解析之“增序链表的合并”

LeetCode算法解析之“增序链表的合并”

输入两个递增排序的链表&#xff0c;合并这两个链表并使新链表中的节点仍然是递增排序的。 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode(int x) { val x; }* }*/ class Solution {public ListNode me…
阅读更多...
redis的五种基本数据类型及其内部实现详解

redis的五种基本数据类型及其内部实现详解

小伙伴们大家好呀&#xff0c;好久不见啦&#xff08;十天没写博客呢。hh&#xff09;&#xff0c;最近没有偷懒哦&#xff0c;而是在学习Redis。 好了废话不多说&#xff0c;上干货吧&#xff01; 一、redis的五种数据类型 redis作为目前最流行的Key-Value类型的内存数据库&…
阅读更多...
C++ bitset的用法实例

C++ bitset的用法实例

C bitset的用法实例一、bitset二、代码三、总结一、bitset 顾名思义&#xff0c;bitset是位bit的set集合&#xff0c;是可以当做容器使用的一种数据结构。 bitset提供了一些很实用的方法&#xff0c;能用来替代C语言的直接按位运算带来的不便。 二、代码 #include <iostr…
阅读更多...
数据结构(Java)---链表

数据结构(Java)---链表

1.概述 1.1 线性表简介 线性表是具有相同特性的数据元素的一个有限系列&#xff0c;可以简单的理解为就是一堆数据的存放方式&#xff0c;是一种典型并常见的一种数据存储结构。比如说常见的英文字母表或者成绩单之类的。线性表具有以下特性&#xff1a; 有穷性&#xff1a; …
阅读更多...
链表的增删改查排序删除等操作自实现

链表的增删改查排序删除等操作自实现

注意事项&#xff1a; 链表的函数中很容易出现备份当前指针的操作&#xff0c;注意使用时不要马虎在使用未typedef的结构体时&#xff0c;前一定要加struct其实所谓头插法的遍历就是一种栈 因其为“先进后出” 采用头插法插入(头插法&#xff1a;每个新来的节点都放在头结点的…
阅读更多...
有向图 十字链表的创建 - C语言

有向图 十字链表的创建 - C语言

代码还是要求严格的输入操作&#xff0c;没有判错能力。见谅&#xff01; 代码如下&#xff1a; #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX_VERTEX_NUM 20void Interrupt(void)//创建一个中断函数 {while(1)//用于检测换行…
阅读更多...
栈的链表实现 C语言

栈的链表实现 C语言

数据结构c语言链式栈 代码如下&#xff1a; #include <stdio.h> #include <stdlib.h> typedef struct StackNode {int data;struct StackNode *next; }SqStack,*LinkStack;void InitStack(LinkStack &S)//栈的初始化&#xff0c;只有创建一个栈顶结点这一…
阅读更多...
JZ35 复杂链表的复制

JZ35 复杂链表的复制

目前剑指offer中遇到过最麻烦&#xff08;实际上看懂后就不太麻烦&#xff09;的一题&#xff0c;目前想到的办法还是用哈希表去记录&#xff0c;先不管random的内容&#xff0c;先去把next这一圈给连接了。然后存放在哈希表中&#xff0c;然后再遍历哈希表&#xff0c;去把ran…
阅读更多...
LeetCode-2.两数相加

LeetCode-2.两数相加

2.两数相加&#xff1a; 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#x…
阅读更多...
【leetcode-python刷题】双指针(快慢指针)

【leetcode-python刷题】双指针(快慢指针)

目录141. 环形链表(easy)题目V1&#xff08;快慢指针&#xff09;V2&#xff08;哈希表&#xff09;283. 移动零(easy)题目V1V227. 移除元素(easy)题目V1V2V326. 删除排序数组中的重复项(easy)题目V1V280. 删除排序数组中的重复项 II(medium)题目V1141. 环形链表(easy) 题目 …
阅读更多...
数据结构-3.单链表的删除

数据结构-3.单链表的删除

一.带头结点按位序删除 删除单链表第i个位置&#xff0c;用e返回删除的元素。同插入一样找到第i-1个结点。 bool DeleteList(LinkList &L,int i,int &e){ //注意这里e是引用&#xff0c;因为要返回到函数的调用者处if(i<1)return false;LNode *p;pL;for(int j0;j…
阅读更多...
数据结构专练-链表

数据结构专练-链表

文章目录82. 删除排序链表中的重复元素 II剑指 Offer II 022. 求链表中环的入口节点&#xff08;判断链表中是否有环&#xff09;思路&#xff1a;当发现 slow 与 fast 相遇时&#xff0c;我们再额外使用一个指针 ptr。起始&#xff0c;它指向链表头部&#xff1b;随后&#xf…
阅读更多...
LintCode 翻转链表

LintCode 翻转链表

翻转一个链表 样例 给出一个链表1->2->3->null&#xff0c;这个翻转后的链表为3->2->1->null /*** Definition for ListNode.* public class ListNode {* int val;* ListNode next;* ListNode(int val) {* this.val val;* t…
阅读更多...
java连接kafka实现生产者消费者功能

java连接kafka实现生产者消费者功能

一、功能描述 利用Java连接Kafka&#xff0c;通过API实现生产者和消费者&#xff0c;对于Kafka生产或者消费数据。将日志信息进行输出。 二、依赖导入 首先&#xff0c;创建一个简单的maven的工程并将依赖导入 <dependency><groupId>org.apache.kafka</grou…
阅读更多...
2022Java学习笔记(初识Java_03)

2022Java学习笔记(初识Java_03)

2022Java031. 方法的定义2. 编译器的优化3. 选择结构4. switch语句5. 循环结构6. 循环控制语句7. IDEA常用快捷键1. 方法的定义 定义一个方法的格式&#xff1a; public static void 方法名称(){方法体; }方法名称的命名规则和变量一样 使用小驼峰方法体&#xff1a;也就是大…
阅读更多...
广州大学人工智能原理实验一：知识的表示与推理实验

广州大学人工智能原理实验一：知识的表示与推理实验

相关资料 广州大学人工智能原理实验一&#xff1a;知识的表示与推理实验 广州大学人工智能原理实验二&#xff1a;八数码问题 广州大学人工智能原理实验三&#xff1a;产生式系统推理 广州大学人工智能原理实验四&#xff1a;TSP问题的遗传算法实现 广州大学人工智能原理实验五…
阅读更多...
青岛大学_王卓老师【数据结构与算法】Week04_02_带尾结点的循环链表合并_学习笔记

青岛大学_王卓老师【数据结构与算法】Week04_02_带尾结点的循环链表合并_学习笔记

本文是个人学习笔记&#xff0c;素材来自青岛大学王卓老师的教学视频。 一方面用于学习记录与分享&#xff0c;另一方面是想让更多的人看到这么好的《数据结构与算法》的学习视频。 如有侵权&#xff0c;请留言作删文处理。 课程视频链接&#xff1a; 数据结构与算法基础–…
阅读更多...
【每天学习亿点点系列】——重温双向带头循环链表

【每天学习亿点点系列】——重温双向带头循环链表

&#x1f4a5;【每天学习亿点点系列】——重温双向带头循环链表头文件以及测试文件的实现各个接口的实现1.初始化2.创建节点3.尾插4.头插5.尾删6.头删7.打印8.查找9在任意位置之后插入10.在任意位置之前插入11.记录节点个数12.在任意位置之后删除13.在任意位置之前删除14.删除当…
阅读更多...
2021年 专插本考生 5万字精心整理 计算机基础与数据结构 笔记 建议直接收藏

2021年 专插本考生 5万字精心整理 计算机基础与数据结构 笔记 建议直接收藏

必做题整理与 Q&A - 时间 2021年4月11日&#xff0c;时间21点40分&#xff0c;考完试十分怀疑人生&#xff0c;本来想靠专业课拉点分&#xff0c;也预料到今年专插本报名人数多&#xff0c;加上改革专业课应该会简单点&#xff0c;但是没想到啊&#xff0c;没想到&#xf…
阅读更多...
2022数字逻辑笔记03

2022数字逻辑笔记03

2022数字逻辑笔记03内容预览笔记笔记内容为日常上课记录与整理&#xff0c;为图片格式&#xff0c;仅供学习。 内容预览 1.逻辑门电路 2.集成逻辑门电路的外部特性 3.多余输入端的处理 4.组合逻辑电路 5.小规模集成电路的分析和设计 6.二进制编码器 7.二进制优先编码器 8.74HC…
阅读更多...
C++数据结构——二叉树

C++数据结构——二叉树

二叉树 二叉树采用二叉链表存储&#xff0c;要求根据给定的先序遍历序列和中序遍历序列建立二叉树&#xff0c;并输出后序遍历序列、结点总数、叶子数、度为1的结点数、度为2的结点数。 输入格式: 测试数据有多组&#xff0c;处理到文件尾。每组测试数据的第一行输入结点数n&am…
阅读更多...
循环链表静态链表（及其操作）（考研数据结构）

循环链表静态链表（及其操作）（考研数据结构）

1循环单链表&#xff1a; 循环单链表&#xff1a;尾结点的next指针指向头结点&#xff0c;从一个结点出发&#xff0c;可以找到链表中任何一个结点(可以找到前驱结点)。单链表初始化&#xff1a; typedef struct LNode{ElemType data;struct LNode *prior,*next; }LNode,*Link…
阅读更多...
线性表的链式表示(不带头结点链表操作)

线性表的链式表示(不带头结点链表操作)

单链表定义&#xff1a;它是通过一组任意的存储单元来存储线性表中的数据元素&#xff0c;为了建立数据元素之间的线性关系对每个链表结点&#xff0c;除存放元素本身的信息外。还需要存放一个指向期&#xff0c;后继节点的指针。 数据描述&#xff1a; typedef stru…
阅读更多...
约瑟夫问题的解决(后面附有完整实现代码)

约瑟夫问题的解决(后面附有完整实现代码)

首先我们先明确什么是约瑟夫问题&#xff1a; 约瑟夫问题&#xff1a;设编号为1、2、....n的n个人围坐一圈&#xff0c;约定编号为k(1<k<n)的人从1开始报数&#xff0c;数到m的那个人出列&#xff0c;它的下一位又从1开始报数&#xff0c;数到m的那个人又出列&#xff0…
阅读更多...
C语言-广度优先遍历

C语言-广度优先遍历

图的基本操作 查找函数&#xff08;LocateVex查找坐标&#xff09;构建无向图&#xff08;Undirected Graph&#xff09;输出邻接矩阵&#xff08;print&#xff09; 循环队列基本操作 入队&#xff08;EnQueue&#xff09;出队&#xff08;DeQueue&#xff09;判断队是否为…
阅读更多...
C语言-深度优先遍历

C语言-深度优先遍历

查找函数&#xff08;LocateVex查找坐标&#xff09;构建无向图&#xff08;Undirected Graph&#xff09;输出邻接矩阵&#xff08;print&#xff09;深度优先查找函数&#xff08;DFS&#xff09;深度优先遍历&#xff08;DFSTraverse&#xff09; 图的遍历 深度优先遍历&a…
阅读更多...
C语言-线索化二叉树（中序）

C语言-线索化二叉树（中序）

二叉树的创建及初始化线索化Next函数&#xff08;根据线索找后继&#xff09;Prior函数&#xff08;根据线索找前驱&#xff09;非递归中序遍历&#xff08;根据线索遍历&#xff09; 为什么要将二叉树线索化&#xff1f; 首先就是我们在建立二叉树的时候提到的存储空间浪费的…
阅读更多...
C语言-二叉树的基本操作（test）

C语言-二叉树的基本操作（test）

创建二叉树节点&#xff08;递归&#xff09;先序遍历&#xff08;递归&#xff09;中序遍历&#xff08;递归&#xff09;后序遍历&#xff08;递归&#xff09;复制二叉树&#xff08;先序递归&#xff09;求二叉树的深度&#xff08;递归&#xff09;求二叉树的节点数&#…
阅读更多...
Java集合源码分析（十一）：LinkedList

Java集合源码分析（十一）：LinkedList

首先我们知道&#xff0c;LinkedList的底层实现是一个双向链表&#xff0c;链表与数组的差别我们更是清楚&#xff0c;所以LinkedList弥补了ArrayList增删较慢和效率较低的问题了&#xff0c;但是在改和查方面有逊色于ArrayList&#xff0c;所以在使用时要根据业务场景灵活选择…
阅读更多...
Java集合源码分析（三）：树与二叉树

Java集合源码分析（三）：树与二叉树

数组和链表都是用来解决一对一的问题的&#xff0c;而一对多问题则就需要树来解决。这里是为了后续的集合类相关来讲一些基础和概念&#xff0c;如果小伙伴们想更深一步了解的话&#xff0c;可以自己去翻阅相关资料。 首先来看看树的定义吧 一、树的定义 树是N&#xff08;N&…
阅读更多...
Golang每日一练(leetDay0055)

Golang每日一练(leetDay0055)

目录 159.至多包含两个不同字符的最长子串 Longest-substring-with-at-most-two-distinct-characters &#x1f31f;&#x1f31f; 160. 相交链表 Intersection-of-two-linked-lists &#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Golang每日一练 专栏 …
阅读更多...
C语言数据结构之队列的实现（链表实现）

C语言数据结构之队列的实现（链表实现）

C语言数据结构之队列的实现&#xff08;链表实现&#xff09; tips&#xff1a;前些天学习了链表和栈&#xff0c;今天来看看c语言数据结构之队列的实现以及队列的各种操作。 队列的特点是先进先出&#xff0c;后进后出&#xff0c;因此我们很容易就能够想到用单链表的尾插法&…
阅读更多...
数据结构——链表（python版）

数据结构——链表（python版）

一、链表简介 链表是一种在存储单元上非连续、非顺序的存储结构。数据元素的逻辑顺序是通过链表中的指针链接次序实现。链表是由一系列的结点组成&#xff0c;结点可以在运行时动态生成。每个结点包含两部分&#xff1a;数据域与指针域。数据域存储数据元素&#xff0c;指针域…
阅读更多...
初识数据结构——“数据结构与算法”

初识数据结构——“数据结构与算法”

各位CSDN的uu们你们好呀&#xff0c;今天小雅兰进入一个全新的内容的学习&#xff0c;就是算法和数据结构啦&#xff0c;话不多说&#xff0c;让我们进入数据结构的世界吧 什么是数据结构&#xff1f; 什么是算法&#xff1f; 数据结构和算法的重要性 如何学好数据结构和算…
阅读更多...
数据结构入门-顺序表链表

数据结构入门-顺序表链表

线性表 线性表&#xff08;linear list&#xff09;是n个具有相同特性的数据元素的有限序列。线性表是一种实际中广泛使用多个数据结构&#xff0c;常见的线性表&#xff1a;顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构&#xff0c;也就说是连续的一条直线。…
阅读更多...
c语言实现单向链表（增加注释版）

c语言实现单向链表（增加注释版）

链表&#xff1a; 一、创建 二、修改 三、删除 四、插入 五、输出 六、排序 七、反序 八、清空链表中的元素 九、求链表的长度 链表&#xff1a;由n个节点离散集成&#xff1b;每个节点通过指针连接&#xff1b;每一个节点由一个前驱节点和一个后驱节点组成&#xff1b;首节点…
阅读更多...
单向链表实现增删改查（c语言版）

单向链表实现增删改查（c语言版）

//新建结构体 typedef struct node {int member;struct node *next; } *linklist; //初始化链表 linklist create_list() {int i;linklist head (linklist) malloc(sizeof (linklist));linklist end head;for (i 0;i < 3;i){linklist temp_node (linklist) malloc(sizeo…
阅读更多...
LeetCode链表（单链表，双链表，反转链表）

LeetCode链表（单链表，双链表，反转链表）

文章目录前言1.链表定义2.链表操作3.技巧链表常见操作1.lc203 移除链表元素2.lc2 两数相加3.lc328 奇偶链表反转链表1.lc206 反转链表2.lc92 反转链表II链表双指针1.lc19 删除链表的倒数第 N 个结点2.lc21 合并两个有序链表3.lc24 两两交换链表中的节点4.lc234 回文链表前言 本…
阅读更多...
链表经典面试题【典中典】

链表经典面试题【典中典】

&#x1f4af;&#x1f4af;&#x1f4af;链表经典面试题❗❗❗炒鸡经典&#xff0c;本篇带有图文解析&#xff0c;建议动手刷几遍。&#x1f7e5;1.反转链表&#x1f7e7;2.合并两个有序链表&#x1f7e8;3.链表分割&#x1f7e9;4.链表的回文结构&#x1f7e6;5.相交链表&…
阅读更多...
2-2线性表-链表

2-2线性表-链表

一.单链表&#xff08;一&#xff09;特点1.优点不要求大片的连续空间&#xff0c;改变容量方便2.缺点不可以随机存取&#xff0c;要耗费一定的空间存放指针&#xff08;二&#xff09;代码定义 1.初步代码 struct LNode {//结点ElemType data;struct LNode *next; };2.新增结…
阅读更多...
对链表使用插入排序的C语言实现示例

对链表使用插入排序的C语言实现示例

#include <stdio.h> #include <stdlib.h>// 定义链表节点结构体 struct ListNode {int val;struct ListNode *next; };// 插入排序函数 struct ListNode* insertionSortList(struct ListNode* head) {if (head NULL || head->next NULL) {return head;}struct…
阅读更多...
【数据结构】线性表 ④ ( 循环链表 / 单循环链表 | 代码示例 - 使用 Java 实现 单循环链表 )

【数据结构】线性表 ④ ( 循环链表 / 单循环链表 | 代码示例 - 使用 Java 实现 单循环链表 )

文章目录 一、循环链表 ( 单循环链表 )二、代码示例 - 使用 Java 实现 单循环链表 一、循环链表 ( 单循环链表 ) 在 单链表 中 , 将 最后一个节点 的指针 指向 第一个节点 , 形成一个闭环 , 上述 头尾相连 的单链表 称为 " 单循环链表 " , 简称为 " 循环链表…
阅读更多...
2022数字逻辑笔记02

2022数字逻辑笔记02

2022数字逻辑笔记01内容预览笔记笔记内容为日常上课记录与整理&#xff0c;为图片格式&#xff0c;仅供学习。 内容预览 1.逻辑函数及其表示方法 2.逻辑函数的两种标准形式 3.逻辑函数的公式法化简 4.卡诺图化简法 5.相关作业 6.包含无关项的逻辑函数的化简 7.本章小结 笔记 —…
阅读更多...
超详细的逐句介绍Java高级接口之LinkedList底层源码讲解（三）

超详细的逐句介绍Java高级接口之LinkedList底层源码讲解（三）

一、LinkedList LinkedList是基于链表结构的一种线性结构存储结构&#xff0c;他和ArrayList的结构类似&#xff0c;两者均可以创建动态数组结构&#xff0c;唯一区别在于ArrayList创建的动态数组在内存上是连续的&#xff0c;而LinkedList是离散的。上一篇文章的超详细的逐句…
阅读更多...
深入理解链表：一种动态的线性数据结构

深入理解链表：一种动态的线性数据结构

文章目录 前言1. 概述2. 单向链表3. 单向链表&#xff08;带哨兵&#xff09;4. 双向链表&#xff08;带哨兵&#xff09;5. 环形链表&#xff08;带哨兵&#xff09;6. 结语 前言 链表是我们在日常编程中经常使用的一种数据结构&#xff0c;它相比于数组具有更好的动态性能。…
阅读更多...
静态链表 数据结构C语言版

静态链表 数据结构C语言版

静态链表相关操作实现0.说明1.初始定义2.创建空表3.获取使用长度4.添加数据5.添加数据6.静态链表遍历7.空间释放8.获得空闲分量9.查找操作10.插入操作11.删除操作输入举例0.说明 最后一个游标为第一个有数据元素的下标 第一个游标为第一个没有元素的下标 其他游标为下一元素的下…
阅读更多...
循环双向链表基本操作实现(双向链表改进) 数据结构 C/C++

循环双向链表基本操作实现(双向链表改进) 数据结构 C/C++

循环双向链表基本操作1.初始定义2.初始化双向循环链表3.输入指定长度数据4.插入元素操作5.删除元素操作7.遍历打印元素(正序)8.遍历打印元素(逆序)9.双向链表操作实现1.初始定义 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define …
阅读更多...
Java数据结构之链表的基本操作

Java数据结构之链表的基本操作

一、链表的定义 链表是数据结构中线性结构中最为重要的数据结构&#xff0c;关于Java链表的定义以及数据实例化&#xff0c;请查看数据结构之数组和链表&#xff08;Java语言描述&#xff09;。 二、插入元素操作 在介绍插入元素之前&#xff0c;我先对数据进行进行节点实例…
阅读更多...
反转链表（算法入门04）

反转链表（算法入门04）

题目&#xff1a;定义一个函数&#xff0c;输入一个链表的头节点&#xff0c;反转该链表并输出反转后链表的头节点。 实例&#xff1a; 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 解题思路&#xff1a;&#xff08;下面&#xff0c…
阅读更多...
3.1-栈的链式储存表示

3.1-栈的链式储存表示

链式存储结构 栈的链式存储结构&#xff0c;简称链栈。 　　由于栈只是栈顶在做插入和删除操作&#xff0c;所以栈顶应该放在单链表的头部。另外&#xff0c;都有了栈顶在头部了&#xff0c;单链表中的头结点也就失去了意义&#xff0c;通常对于链栈来说&#xff0c;是不需要头…
阅读更多...
学会LeetCode三道题

学会LeetCode三道题

系列文章目录 文章目录系列文章目录前言一、左旋转字符串1.题目描述2.解题思路二、回文链表1.题目描述2.解题思路三、两个链表第一个公共节点1.题目描述2.解题思路总结前言 一、左旋转字符串 左旋转字符串 1.题目描述 字符串的左旋转操作是把字符串前面的若干个字符转移到字…
阅读更多...
3.4栈和队列——链队列基本操作的实现

3.4栈和队列——链队列基本操作的实现

注意&#xff1a;以下内容均省略思路&#xff0c;只有代码。此内容为本人学习过程中的一些学习记录&#xff0c;如有错误&#xff0c;恳请各位指正、建议&#xff0c;末学将感激不尽&#xff01; 目录 1.链队列的类型定义 2.链队列的初始化 3.销毁链队列 4.链队列的入队 5…
阅读更多...
单链表_节点定义单链表基本操作

单链表_节点定义单链表基本操作

链表的引入 链表 顺序表的构建需要预先知道数据大小来申请连续的存储空间&#xff0c;而在进行扩充时又需要进行数据的搬迁&#xff0c;所以使用起来并不灵活。     链表结构可以充分利用计算机内存空间&#xff0c;实现灵活的内存动态管理。 链表的定义 链表&#xff08;L…
阅读更多...
最快合并链表（线性表）

最快合并链表（线性表）

#include<stdio.h> #include<stdlib.h> typedef struct Node {int data;struct Node* next; }LinkList;LinkList *CreateLinkList(LinkList *head, int x)//创建新链表 {LinkList *p, *q;head (LinkList*)malloc(sizeof(LinkList));qhead;for(int i0; i<x; i){…
阅读更多...
链表插入（线性表）

链表插入（线性表）

刚接触链表&#xff0c;有点迷糊&#xff0c;昨天和前天看视频看博客拼拼凑凑学了创建链表打印链表和插入节点什么的&#xff0c;之前写的被注释在后面了&#xff0c;还是请教学姐修改了很多才勉强把这道题弄出来。 放代码&#xff1a; #include<stdio.h> #include<s…
阅读更多...
Java中的LinkedList集合详解

Java中的LinkedList集合详解

LinkedList集合 基础概念 可以在任何位置高效插入和删除的一个有序序列&#xff0c;简而言之就是数据结构里的链表。 我们都清楚在链表很容易进行插入和删除&#xff0c;但是我们在使用c/c的时候需要新建一个链表项的结构体并且需要在里面设置指针&#xff0c;java不需要指针…
阅读更多...
【数据结构】线性表 ⑤ ( 双循环链表 | 双循环链表特点 | 双循环链表插入操作处理 | 代码示例 - 使用 Java 实现 双循环链表 )

【数据结构】线性表 ⑤ ( 双循环链表 | 双循环链表特点 | 双循环链表插入操作处理 | 代码示例 - 使用 Java 实现 双循环链表 )

文章目录 一、双循环链表二、双循环链表特点三、双循环链表插入操作处理四、代码示例 - 使用 Java 实现 双循环链表 一、双循环链表 " 双循环链表 " 是 在 单循环链表 的基础上 , 在每个 节点 中 , 新增一个 指针 , 指向 该节点 的 前驱节点 ; 双向循环链表 每个 节…
阅读更多...
Java语言实现单向链表的增删改遍历

Java语言实现单向链表的增删改遍历

这里写目录标题链表的简单介绍单向链表代码实现模拟结点遍历所有结点按顺序添加结点根据id添加结点根据id修改结点根据id删除结点链表的简单介绍 什么是链表 链表是一种物理存储单元上非连续、非顺序的存储结构。数据元素的逻辑顺序是通过链表的指针链接实现的链表当中的每一个…
阅读更多...
华为OD机试真题 Java 实现【寻找链表的中间结点】【2023Q1 100分】

华为OD机试真题 Java 实现【寻找链表的中间结点】【2023Q1 100分】

一、题目描述 给定一个单链表 L，请编写程序输出 L中间结点保存的数据。如果有两个中间结点，则输出第二个中间结点保存的数据。 例如： 给定 L 为 1 -> 7 -> 5，则输出应该为 7; 给定 L 为 1 -> 2 -> 3 -> 4，则输出应该为 3。 二、输入描述 每个输入包含…
阅读更多...
力扣 二叉树展开为链表(dfs)

力扣 二叉树展开为链表(dfs)

力扣 二叉树展开为链表(dfs) 题目链接&#xff1a;https://leetcode-cn.com/problems/flatten-binary-tree-to-linked-list/ 题目的意思是按照其先序遍历的顺序将二叉树展开为链表&#xff0c;要求使用O(1)的内存空间&#xff0c;所以先排除先序遍历出存储起来再构造链表的方法…
阅读更多...
《程序员面试金典（第6版）》面试题 02.03. 删除中间节点（特殊的删除节点操作）

《程序员面试金典（第6版）》面试题 02.03. 删除中间节点（特殊的删除节点操作）

题目描述 若链表中的某个节点&#xff0c;既不是链表头节点&#xff0c;也不是链表尾节点&#xff0c;则称其为该链表的「中间节点」。 题目传送门&#xff1a;面试题 02.03. 删除中间节点 假定已知链表的某一个中间节点&#xff0c;请实现一种算法&#xff0c;将该节点从链表中…
阅读更多...
C语言实现“队列“

C语言实现“队列“

&#x1f388;个人主页:&#x1f388; :✨✨✨初阶牛✨✨✨ &#x1f43b;推荐专栏: &#x1f354;&#x1f35f;&#x1f32f;C语言进阶 &#x1f511;个人信条: &#x1f335;知行合一 &#x1f349;本篇简介:>:分享数据结构之C语言实现"队列".各个接口分别分析…
阅读更多...
数据结构选择题（难题题解） 第五章 树

数据结构选择题（难题题解） 第五章 树

5.2 14. 法1&#xff1a;少一个叶子再多一个叶子&#xff0c;欠考虑了 选B 法2&#xff1a; 法三&#xff1a; 5.3 23.选D A. 如果是根 直接找孩子就能找到后继&#xff1b;如果是左孩子&#xff0c;有孩子就找孩子&#xff0c;无孩子&#xff0c;指针是空&#xff0c…
阅读更多...
算法篇：链表之删除链表中重复节点

算法篇：链表之删除链表中重复节点

算法&#xff1a;核心点在于如何找到重复节点&#xff0c;有序链表的话&#xff0c;只要下一个节点与当前节点数值一样就是重复节点&#xff0c;直接将当前节点指向下一个节点的下一个节点即可。本算法需要注意哨兵节点的小技巧。题目1:删除排序链表中的重复元素https://leetco…
阅读更多...
算法篇：链表之排序

算法篇：链表之排序

算法&#xff1a;对于链表的排序&#xff0c;一般要设计到拆分合并两步&#xff0c;拆分这一步&#xff1a;中间节点作为临界值&#xff0c;小的放左边&#xff0c;大的放右边合并操作步骤&#xff1a;将两个有序的链表中&#xff0c;串联起来题目1:分隔链表https://leetcode-c…
阅读更多...
Java中的阻塞队列

Java中的阻塞队列

什么是阻塞队列 阻塞队列&#xff08;BlockingQueue&#xff09;是一个支持两个附加操作的队列。这两个附加的操作支持阻塞的插入和移除方法。 附加操作解释支持阻塞的插入方法意思是当队列满时&#xff0c;队列会阻塞插入元素的线程&#xff0c;直到队列不满。支持阻塞的移除…
阅读更多...
算法：链表之环形链表

算法：链表之环形链表

算法&#xff1a;该类题目的核心点在于如何判断是环形链表&#xff0c;核心思想是&#xff1a;两个人在环上跑步&#xff0c;跑的快的早晚会追上跑的慢的。是快慢指针的典型使用场景。题目1: 环形链表https://leetcode-cn.com/problems/linked-list-cycle/代码实现&#xff1a;…
阅读更多...
【leetcode刷题之路】初级算法——链表+树+排序和搜索+动态规划

【leetcode刷题之路】初级算法——链表+树+排序和搜索+动态规划

文章目录 3 链表3.1 【链表】删除链表中的节点3.2 【双指针】删除链表的倒数第 N 个结点3.3 【链表】反转链表3.4 【链表】合并两个有序链表3.5 【链表】回文链表3.6 【双指针】环形链表 4 树4.1 【递归】二叉树的最大深度4.2 【递归】验证二叉搜索树4.3 【递归】对称二叉树4.4…
阅读更多...
剑指 Offer 26 树的子结构

剑指 Offer 26 树的子结构

题目&#xff1a; 输入两棵二叉树A和B&#xff0c;判断B是不是A的子结构。(约定空树不是任意一个树的子结构) B是A的子结构&#xff0c; 即 A中有出现和B相同的结构和节点值。 示例 1&#xff1a; 输入&#xff1a;A [1,2,3], B [3,1] 输出&#xff1a;false 示例 2&#x…
阅读更多...
《程序设计基础》 第十一章 指针进阶 6-11 奇数值结点链表 (20 分)

《程序设计基础》 第十一章 指针进阶 6-11 奇数值结点链表 (20 分)

本题要求实现两个函数&#xff0c;分别将读入的数据存储为单链表、将链表中奇数值的结点重新组成一个新的链表。链表结点定义如下&#xff1a; struct ListNode {int data;ListNode *next; };函数接口定义&#xff1a; struct ListNode *readlist(); struct ListNode *getodd…
阅读更多...
【LeetCode热题100】打卡第10天：删除链表倒数第N个节点

【LeetCode热题100】打卡第10天：删除链表倒数第N个节点

文章目录 删除链表倒数第N个节点⛅前言&#x1f512;题目&#x1f511;题解 删除链表倒数第N个节点 ⛅前言 大家好&#xff0c;我是知识汲取者&#xff0c;欢迎来到我的LeetCode热题100刷题专栏&#xff01; 精选 100 道力扣&#xff08;LeetCode&#xff09;上最热门的题目&a…
阅读更多...
双链表、循环链表、静态链表

双链表、循环链表、静态链表

目录 一、双链表1、为什么要引入双链表2、双链表的插入操作3、双链表的插入操作 二、循环链表1、循环单链表2、循环双链表 三、静态链表 一、双链表 1、为什么要引入双链表 单链表结点中只有一个指向其后继的指针&#xff0c;使得单链表只能从头结点依次顺序地向后遍历。要访…
阅读更多...
Dart 运算符重载，详细介绍

Dart 运算符重载，详细介绍

Dart 运算符重载&#xff0c;详细介绍 Dart 支持运算符重载&#xff0c;它允许我们重载内置的运算符以执行自定义操作。在 Dart 中&#xff0c;我们可以通过实现一些特定的方法来重载运算符。 下面是一些常用的运算符和它们对应的 Dart 方法&#xff1a; &#xff1a; operat…
阅读更多...
链表排序（自己鼓捣出一种递归建表）

链表排序（自己鼓捣出一种递归建表）

递归建表 是不是很优雅&#xff01; struct ListNode {int val;ListNode *next;ListNode() : val(0), next(nullptr) {}ListNode(int x) : val(x), next(nullptr) {}ListNode(int x, ListNode *next) : val(x), next(next) {}};ListNode* Create(int n) {if(!n) return NULL…
阅读更多...
数据结构之静态链表

数据结构之静态链表

定义 用两个数组实现链表&#xff0c;一个数组存储数据&#xff0c;另一个数组记录当前数据的后继的下标。 示例 数据&#xff1a;data[] {-1, 34, 28, 53, 16, 25, -1, -1, -1, -1} 后继&#xff1a;next[] { 1, 2, 3, 4, 5, -1, -1, -1, -1, -1} 说明 -1: 表示无效值 …
阅读更多...
计算机基础---＞数据结构（4）【优先队列】

计算机基础---＞数据结构（4）【优先队列】

文章目录 优先队列设置优先队列优先级例题23. 合并 K 个升序链表215. 数组中的第K个最大元素 优先队列 优先队列是一种特殊的队列&#xff0c;与普通队列不同的是&#xff0c;优先队列中的元素具有优先级&#xff0c;队列中高优先级的元素会被先出队。具体来说&#xff0c;优先…
阅读更多...
Flutter 小技巧之 ListView 和 PageView 的各种花式嵌套

Flutter 小技巧之 ListView 和 PageView 的各种花式嵌套

Flutter 小技巧之 ListView 和 PageView 的各种花式嵌套 在 Flutter 中&#xff0c;ListView 和 PageView 是两个常用的控件&#xff0c;它们可以用于滑动展示大量内容的场景&#xff0c;且支持各种嵌套方式&#xff0c;本文将介绍其中的一些花式嵌套方式。 ListView 嵌套 Li…
阅读更多...
王道视频-数据结构-笔记2：线性表

王道视频-数据结构-笔记2：线性表

文章目录0 笔记说明1 线性表1.1 线性表的定义1.2 线性表的基本操作2 顺序存储的线性表&#xff1a;顺序表2.1 静态分配的顺序表2.2 动态分配的顺序表2.3 顺序表的特点2.4 顺序表的基本操作2.4.1 插入元素操作2.4.2 删除元素操作2.4.3 查找元素操作2.4.3.1 按位置查找元素2.4.3.…
阅读更多...
Java并发编程的艺术学习笔记

Java并发编程的艺术学习笔记

Callable创建线程 // Callable 通过FutureTask进入线程 适配器 FutureTask 实现 RunnableFuture // RunnableFuture 继承Runnable, Future<V> FutureTask<String> task new FutureTask<>(new Callable<String>() {Overridepublic String call() thr…
阅读更多...
Map集合的获取功能

Map集合的获取功能

import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set;public static void main(String[] args) {//创建Map集合对象Map<Integer, String> map new HashMap<Integer, String>();//添加元素map.put(1, "张三&…
阅读更多...
迭代和递归反转链表

迭代和递归反转链表

反转链表 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 迭代思路 用两个指针分别指向链表的当前节点pCurNode,和当前节点的前驱节点pPrevNode,初始pCurNode head, pPrevNode nullptr, 遍历整个链表&#x…
阅读更多...
采用虚拟头尾节点的双向链表结构设计链表

采用虚拟头尾节点的双向链表结构设计链表

设计链表 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性&#xff1a;val 和next。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。如果要使用双向链表&#xff0c;则还需要一个属性 prev 以指示链表中的上一个节点。假设…
阅读更多...
LeetCode-92*. 反转链表 II

LeetCode-92*. 反转链表 II

给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], left 2, right 4 输出&#xff1a;[1,4,…
阅读更多...
链表后半部分节点倒序插入前半部分节点中

链表后半部分节点倒序插入前半部分节点中

问题描述 将链表后半部分的节点插入到前半部分节点&#xff0c;使得链表1->2->3->4变成1->4->2->3,或者1-2->3->4->5变成1->5->2->4->3 根据上述问题可知&#xff0c;将链表的后一半的节点从后往前依次插入到前半部分的节点中间&#…
阅读更多...
[牛客] -程序员面试宝典-CM11 链表分割

[牛客] -程序员面试宝典-CM11 链表分割

题目链接 题目&#xff1a; 现有一链表的头指针 ListNode* pHead&#xff0c;给一定值x&#xff0c;编写一段代码将所有小于x的结点排在其余结点之前&#xff0c;且不能改变原来的数据顺序&#xff0c;返回重新排列后的链表的头指针。 解读&#xff1a; 如果链表的内容为1 3 4…
阅读更多...
2019-2020山东大学软件学院数据结构期末考试回忆版

2019-2020山东大学软件学院数据结构期末考试回忆版

一 1、入栈序列为ABCDE&#xff0c;是否可能存在BCAED和DBACE的出栈序列&#xff0c; 说明原因。 2、给出四维矩阵的映射公式。 3、给了一串序列&#xff0c;要求写出AVL树。 4、一个m叉的B-树&#xff0c;非叶子节点有k个&#xff0c;至少有多少个关键字。 5、简述拓扑排序的…
阅读更多...
队列的实现：链式队列

队列的实现：链式队列

队列常常也使用链式存储的方式来实现。为了方便操作&#xff0c;同顺序存储一样&#xff0c;我们要维护一个头指针和一个尾指针。如下图&#xff1a; 在链式队列中显然不会出现假溢出的情况。但在出队时&#xff0c;要及时释放内存。由于在队列的实现&#xff1a;顺序队列中&am…
阅读更多...
数据结构位域分析

数据结构位域分析

数据结构位域定义&#xff1a; struct Time {unsigned long long valid_flag_or_idx : 4; unsigned long long year : 7;unsigned long long month : 12;unsigned long long day : 5;unsigned long long hour : 5;unsigned long long minute : 6;unsigned long long second…
阅读更多...
后端学习----java7集合及底层学习1集合理解、框架、iterator迭代器

后端学习----java7集合及底层学习1集合理解、框架、iterator迭代器

集合得理解和好处 数组长度开始时必须指定&#xff0c;一旦指定不能更改 必须保存同一类数据 使用数组删改数据麻烦 对于上面得缺点&#xff0c;集合可以动态保存任意个对象&#xff0c;添加和删改都很简单&#xff0c;提供一系列方法。&#xff08;增删改查&#xff09; 集…
阅读更多...
数据结构与算法6 - 单向链表 - Java

数据结构与算法6 - 单向链表 - Java

文章目录概念单链表 - 新元素直接添加到尾部代码实现测试单链表 - 新元素动态添加到链表代码实现测试代码单链表 - 链表元素删除代码实现单链表 - 获取链表有效节点的个数代码实现单链表 - 获取倒数第n个节点的数据代码实现单链表 - 节点反转代码实现单链表 - 从尾开始打印节点…
阅读更多...
剑指offer 35. 复杂链表的复制（三种解法）

剑指offer 35. 复杂链表的复制（三种解法）

剑指 Offer 35. 复杂链表的复制 - 力扣&#xff08;LeetCode&#xff09; (leetcode-cn.com) 目录 方案1 运行结果 代码 方案2 运行结果 代码 方案3&#xff08;最佳解法&#xff09; 运行结果 代码 方案1 首先把原链表节点逐个放入一个数组&#xff0c;然后把所有的…
阅读更多...
链表 详解（单链表、循环链表、双向链表、Linux内核“共享”双链表）C/C++

链表 详解（单链表、循环链表、双向链表、Linux内核“共享”双链表）C/C++

文章结尾附上了单链表、循环链表、双向链表及Linux内核“共享”双链表完整代码 目录 一、链表原理精讲 二、单链表算法实现 2.1单链表的概念 2.2单链表初始化 2.3单链表增加元素 2.3.1前插法 2.3.2尾插法 2.3.3任意位置插入 2.4单链表遍历 2.5单链表获取元素 2.6单…
阅读更多...
算法与数据结构 — 结合 Java 源码分析数据结构

算法与数据结构 — 结合 Java 源码分析数据结构

文章目录算法与数据结构 — 结合 Java 源码分析数据结构一、概念二、常见的数据结构1. 数组&#xff08;Array&#xff09;- 顺序表2. 链表&#xff08;Linked List&#xff09;3. 栈&#xff08;Stack&#xff09;4. 队列&#xff08;Queue&#xff09;5. 树&#xff08;Tree&…
阅读更多...
LeetCode-24.两两交换链表中的结点

LeetCode-24.两两交换链表中的结点

题目&#xff1a; 给定一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后的链表。 你不能只是单纯的改变节点内部的值&#xff0c;而是需要实际的进行节点交换。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4] 输出&#xff1a;[2,1,4,3] 示例 …
阅读更多...
有序链表转换二叉搜索树

有序链表转换二叉搜索树

题目描述&#xff1a; 给定一个单链表&#xff0c;其中的元素按升序排序&#xff0c;将其转换为高度平衡的二叉搜索树。 本题中&#xff0c;一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。 示例: 给定的有序链表&#xff1a; [-10, -3,…
阅读更多...
LeetCode-61.旋转链表

LeetCode-61.旋转链表

题目&#xff1a; 给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], k 2 输出&#xff1a;[4,5,1,2,3] 示例 2&#xff1a; 输入&#xff1a;head [0,1,2], k 4…
阅读更多...
[JavaScript]两个链表的第一个公共结点

[JavaScript]两个链表的第一个公共结点

两个链表的第一个公共结点描述示例1代码描述 输入两个无环的单向链表&#xff0c;找出它们的第一个公共结点&#xff0c;如果没有公共节点则返回空。&#xff08;注意因为传入数据是链表&#xff0c;所以错误测试数据的提示是用其他方式显示的&#xff0c;保证传入数据是正确的…
阅读更多...
LeetCode-19.删除链表的倒数第N个结点

LeetCode-19.删除链表的倒数第N个结点

19.删除链表的倒数第N个结点 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 进阶&#xff1a;你能尝试使用一趟扫描实现吗&#xff1f; 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] …
阅读更多...
leecode206 链表反转 三种方法

leecode206 链表反转 三种方法

第一种&#xff1a;记录前驱&#xff0c;从第一个节点开始 1.用一个指针记录其next的位置&#xff08;防止在其指向前面节点无法指向后面的节点的位置&#xff09; qp->next 2.记录了后面的位置&#xff0c;那我们可以大胆的将p->next指向前驱节点pre p->nextpre …
阅读更多...
分割链表

分割链表

题目描述&#xff1a; 给定一个链表和一个特定值 x&#xff0c;对链表进行分隔&#xff0c;使得所有小于 x 的节点都在大于或等于 x 的节点之前。 你应当保留两个分区中每个节点的初始相对位置。 示例: 输入: head 1->4->3->2->5->2, x 3 输出: 1->2->…
阅读更多...
面试题 02.02. 返回倒数第 k 个节点

面试题 02.02. 返回倒数第 k 个节点

面试题 02.02. 返回倒数第 k 个节点 实现一种算法&#xff0c;找出单向链表中倒数第 k 个节点。返回该节点的值。 示例&#xff1a; 输入&#xff1a; 1->2->3->4->5 和 k 2 输出&#xff1a; 4 说明&#xff1a; 给定的 k 保证是有效的。 利用双指针&#xff0c;…
阅读更多...
⭐LeetCode 题库⭐ 2. 两数相加

⭐LeetCode 题库⭐ 2. 两数相加

LeetCode | 2. 两数相加 文章目录LeetCode | 2. 两数相加一、题面二、题解思路和算法Java 代码复杂度分析执行结果一、题面 两数相加 给你两个非空的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照逆序的方式存储的&#xff0c;并且每个节点只能存储一位数字。 请…
阅读更多...
【PAT】1052. Linked List Sorting （链表）及测试点问题

【PAT】1052. Linked List Sorting （链表）及测试点问题

【PAT】1052. Linked List Sorting &#xff08;链表&#xff09;及测试点问题 题目原文: 1052 Linked List Sorting (25 分) A linked list consists of a series of structures, which are not necessarily adjacent in memory. We assume that each structure contains an …
阅读更多...
LeetCode 021、合并两个有序链表

LeetCode 021、合并两个有序链表

LeetCode 021、合并两个有序链表 题目 题解 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(int x) : val(x), next(nullptr) {}* ListNode(int x, ListNod…
阅读更多...
C的数据结构---非传统链表

C的数据结构---非传统链表

传统链表的缺点： 和具体结构绑定，不通用 链表逻辑试图包含业务逻辑（业务数据） 业务数据和链表逻辑耦合性太高 不能将大千世界，芸芸众生包含起来 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h>typedef str…
阅读更多...
剑指offer 016、合并两个排序的链表

剑指offer 016、合并两个排序的链表

剑指offer 016、合并两个排序的链表 题目 题解 迭代去做 /* struct ListNode {int val;struct ListNode *next;ListNode(int x) :val(x), next(NULL) {} };*/ class Solution { public:ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {if(pHead1 nullptr) return pH…
阅读更多...
二叉树之结点相关操作

二叉树之结点相关操作

文章目录结点的个数代码实现图解递归叶子结点的个数代码实现图解递归第k层结点的个数代码实现图解递归值为x的结点代码实现图解递归结点的个数 求解树的结点总数时&#xff0c;可以将问题拆解成子问题&#xff1a; 1.若为空&#xff0c;则结点个数为0。 2.若不为空&#xff0c;…
阅读更多...
数据结构与算法（栈与队列）

数据结构与算法（栈与队列）

2. 栈与队列 2.1 栈与队列的区别 栈和队列都是重要的线性数据结构&#xff0c;在一个特定范围内存储单元中存储的数据。与线性表相比&#xff0c;插入和删除受到更多的约束和限定&#xff0c;是限定性的线性表结构。栈是先进后出&#xff0c;队列是先进先出。 有时在数据结构…
阅读更多...
05-Java集合-LinkedList详解

05-Java集合-LinkedList详解

第1部分 LinkedList介绍 LinkedList简介 LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。 LinkedList 实现 List 接口&#xff0c;能对它进行队列操作。 LinkedList 实现 Deque 接口&#xff0c;即能将LinkedList当…
阅读更多...
剑指offer 003、从尾到头打印链表

剑指offer 003、从尾到头打印链表

剑指offer 003、从尾到头打印链表 题目 题解1 直接用C的reverse()函数 或 反向迭代器 /** * struct ListNode { * int val; * struct ListNode *next; * ListNode(int x) : * val(x), next(NULL) { * } * }; */ class Solution …
阅读更多...
HashMap夺命连环问

HashMap夺命连环问

1、说说HashMap的结构 在JDK7时&#xff0c;采用数组链表结构 在JDK8时&#xff0c;采用数组链表红黑树的结构&#xff0c;在一定条件下&#xff0c;链表会转化为红黑树。 以上图来源于&#xff1a;https://blog.csdn.net/goosson/article/details/81029729 2、数组和链表的用…
阅读更多...
图的广度优先遍历

图的广度优先遍历

图的广度优先遍历借助 队列 实现。 #include"stdio.h" #include"malloc.h"#define SIZE 10/*************队列************/ #define INITSIZE 10 #define INNCREASE 5typedef int ElemType;typedef struct{ElemType *base;ElemType *front;ElemType *rea…
阅读更多...
顺序表之双向链表

顺序表之双向链表

文章目录双向链表双向循环链表双向链表 双向链表的操作和单链表几乎相同&#xff0c;只是多了一个前域指针。 #include<stdio.h> #include<malloc.h>typedef int ElemType; typedef struct Node {struct Node *prior;ElemType data;struct Node *next; /* data *…
阅读更多...
redis源码分析 -- 链表结构

redis源码分析 -- 链表结构

redis源码分析 - 链表结构 redis 中链表结构如下 typedef struct listNode {struct listNode *prev; //指向前驱指针struct listNode *next; //指向后继指针void *value; } listNode; //节点typedef struct list {listNode *head; //头结点listNode *tail; //尾节点…
阅读更多...
数据结构-单链表和顺序表的基本操作

数据结构-单链表和顺序表的基本操作

单链表 #include<stdio.h> #include<stdlib.h> #include<time.h> #include<malloc.h> #define N 8 //最大节点数 //定义结构体 typedef struct node {int n;struct node *next; }Node; //释放链表所有结点 void freeAll(Node *p){Node *q;while(p!NU…
阅读更多...
判断链表是否存在环(有趣的题目+更有趣的解法)

判断链表是否存在环(有趣的题目+更有趣的解法)

判断链表是否存在环 问题描述 试编写算法实现检测单链表中是否存在回路。 思路 判断单链表是否存在环解决思路如下&#xff1a; 先判断它的next是否为它自己  如果是 则说明有环  如果不是 每次走过一个结点都把它的后继直接指向自己如果走到最后为NULL则无环 代码 // 结…
阅读更多...
建立一个单向链表的步骤(C语言)

建立一个单向链表的步骤(C语言)

建立一个单向链表建立一个单向链表的步骤要点总结导入假设题目分析建立单链表的具体步骤具体代码及相关注解建立一个单向链表的步骤要点总结 导入 在建立一个单向链表时&#xff0c;对于头结点head有两种情况&#xff0c;一是头结点不添加任何元素&#xff0c;仅作使用指针域&…
阅读更多...
C语言链表的简单的尾插法

C语言链表的简单的尾插法

C语言链表的简单的尾插法 今天简单的总结一下关于C语言的尾插法&#xff0c;简单来说就是在一堆的简单的数据节点当中&#xff0c;在一个指定的位置后方插入你想要插入的数据&#xff01;开整&#xff01;&#xff08;自己学习也不是很好哈!&#xff0c;请见谅&#xff09; 第…
阅读更多...
数据结构之双向链表的形式

数据结构之双向链表的形式

数据结构之双向列表的形式 双向链表 提示 博主&#xff1a;来自火星的萨满_906285288 博客地址&#xff1a;http://blog.csdn.net/qq_29924041 概念 在上一篇幅博客中&#xff0c;是关于单向链表的讲解&#xff0c;以及从linuxC一站式编程中引入的例子&#xff0c;那么除了…
阅读更多...
双向循环链表示例

双向循环链表示例

双向循环链表的各种操作 相对于单链表多了一个指针prev指向全面的节点 #include<stdio.h> #include<stdlib.h>typedef struct student{int socre;struct student *prev;struct student *next; } LinkList;LinkList *create(int n) { LinkList *head, *node…
阅读更多...
(java)leetcode21 合并两个有序链表

(java)leetcode21 合并两个有序链表

虽然是一个简单题&#xff0c;但是毕竟复习&#xff0c;也还是简单做一个笔记。 链表是数据结构最开始也最基础的内容了&#xff0c;此题的意思也比较简单&#xff0c;就是单纯进行链表排序的二合一而已。 核心思路&#xff1a; 首先创建一张空链表&#xff0c;用作存储我们…
阅读更多...
leetcode_101 Reverse Linked List II

leetcode_101 Reverse Linked List II

题目&#xff1a; everse a linked list from position m to n. Do it in one-pass. Note: 1 ≤ m ≤ n ≤ length of list. Example: Input: 1->2->3->4->5->NULL, m 2, n 4 Output: 1->4->3->2->5->NULL 算法分析&#xff0c;使用pm记录…
阅读更多...
通过一个实际案例，彻底搞懂 HashMap！

通过一个实际案例，彻底搞懂 HashMap！

我知道大家都很熟悉hashmap&#xff0c;并且有事没事都会new一个&#xff0c;但是hashmap的一些特性大家都是看了忘&#xff0c;忘了再记&#xff0c;今天这个例子可以帮助大家很好的记住。 场景 用户提交一张试卷答案到服务端&#xff0c;post报文可精简为 [{ "questi…
阅读更多...
链表和哈希Set

链表和哈希Set

1 LinkedList集合类 LinkedList集合类底层是使用双向链表实现的&#xff0c;相较于ArrayList&#xff0c;更方便进行增删操作。 在增删查改方面&#xff0c;新增了头尾操作&#xff0c;比如从头部插入、尾部插入、头部删除、尾部删除、头部查询和尾部查询等操作。由于有头尾的…
阅读更多...
【leetcode】142. 环形链表 II (medium)

【leetcode】142. 环形链表 II (medium)

给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数…
阅读更多...
LeetCode 热题 100 JavaScript--206. 反转链表

LeetCode 热题 100 JavaScript--206. 反转链表

/*** Definition for singly-linked list.* function ListNode(val, next) {* this.val (valundefined ? 0 : val)* this.next (nextundefined ? null : next)* }*/ /*** param {ListNode} head* return {ListNode}*/1、逐个断键&#xff0c;将后一个节点放到前面 …
阅读更多...
【脚踢数据结构】链表(2)

【脚踢数据结构】链表(2)

(꒪ꇴ꒪ )&#xff0c;Hello我是祐言QAQ我的博客主页&#xff1a;C/C语言,Linux基础,ARM开发板&#xff0c;软件配置等领域博主&#x1f30d;快上&#x1f698;&#xff0c;一起学习&#xff0c;让我们成为一个强大的攻城狮&#xff01;送给自己和读者的一句鸡汤&#x1f914;&…
阅读更多...
【链表OJ 2】反转链表

【链表OJ 2】反转链表

前言: &#x1f388;欢迎大家来到Dream_Chaser&#xff5e;的博客&#x1f388; &#x1f6a9;本文收录于 C--数据结构刷题的专栏中 -->http://t.csdn.cn/n6UEP 首先欢迎大家的来访&#xff0c;其次如有错误&#xff0c;非常欢迎大家的指正,互相学习进步。 一.反转链表 来…
阅读更多...
Leetcode算法练习：两数相加

Leetcode算法练习：两数相加

Leetcode算法练习&#xff1a;两数相加 题目链接点击跳转 代码展示 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* ListNode(int val, ListNod…
阅读更多...
【LeetCode-中等】剑指 Offer 36. 二叉搜索树与双向链表

【LeetCode-中等】剑指 Offer 36. 二叉搜索树与双向链表

题目链接 剑指 Offer 36. 二叉搜索树与双向链表 标签 后序遍历、二叉搜索树 步骤 二叉搜索树中的任一节点的直接前驱为其左子树的最右侧节点&#xff0c;直接后继为其右子树的最左侧节点。因此&#xff0c;可以通过这个关系来操作原来的二叉树。为了不影响深度较大的节点的…
阅读更多...
带你玩转双链表

带你玩转双链表

文章目录 前言一、双链表的思路二、带头循环双链表的实现分析二、带头循环双链表的实现11.带头循环双链表实现头文件总览2.带头循环双链表的初始化3.带头循环双链表的插入4.带头循环双链表的打印和销毁5.带头循环双链表的查找和删除 三、带头循环双链表的实现21.带头循环双链表…
阅读更多...
c++类模板，嵌套类模板，模板链表，动态数组

c++类模板，嵌套类模板，模板链表，动态数组

c类模板&#xff0c;嵌套类模板&#xff0c;模板链表&#xff0c;动态数组 一.类模板 1.类模板的书写 代码如下 template<typename T>//模板 class CTest {//类 public:T m_a;CTest(const T&a):m_a(a){}void fun1() {cout << typeid(m_a).name() << …
阅读更多...
面试热题（反转链表）

面试热题（反转链表）

给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 链表的题&#xff0c;大部分都可以用指针或者递归可以做&#xff0c;指针如果做不出来的话&#xff0c;…
阅读更多...
【数据结构】单链表OJ题（一）

【数据结构】单链表OJ题（一）

&#x1f525;博客主页&#xff1a;小王又困了 &#x1f4da;系列专栏&#xff1a;数据结构 &#x1f31f;人之为学&#xff0c;不日近则日退 ❤️感谢大家点赞&#x1f44d;收藏⭐评论✍️ 目录 一、移除链表元素 &#x1f4a1;方法一&#xff1a; &#x1f4a1;方法二…
阅读更多...
数据结构刷题训练：队列实现栈

数据结构刷题训练：队列实现栈

目录 前言 1. 题目&#xff1a;使用队列实现栈 2. 思路 3. 分析 3.1 创建栈 3.2入栈 3.3 出栈 3.4 栈顶数据 3.5 判空和 “ 栈 ” 的销毁 4. 题解 总结 前言 我们已经学习了栈和队列&#xff0c;也都实现了它们各自的底层接口&#xff0c;那么接下我们就要开始栈和队列的专项刷…
阅读更多...
合并两个有序链表(leetcode)

合并两个有序链表(leetcode)

题目 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4]思路 每次递归都会比较当前两个节点的值&#xff0c;选择较小的节点作为合并后的链…
阅读更多...
优先队列合并多个链表（23. 合并 K 个升序链表）

优先队列合并多个链表（23. 合并 K 个升序链表）

简易版&#xff1a; 合并多个升序数组&#xff1a; 直接将每一行的同一列加入到优先队列&#xff0c;依次取出队头加入新的数组&#xff0c;不断往下一列重复操作。 此题是链表&#xff0c;操作稍微麻烦的是自己定一个类&#xff0c;加入队列的是类&#xff0c;类里面负责存…
阅读更多...
Leetcode每日一题：23. 合并 K 个升序链表（2023.8.12 C++）

Leetcode每日一题：23. 合并 K 个升序链表（2023.8.12 C++）

目录 23. 合并 K 个升序链表 题目描述&#xff1a; 实现代码与解析&#xff1a; 优先级队列&#xff1a; 原理思路&#xff1a; 23. 合并 K 个升序链表 题目描述&#xff1a; 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表…
阅读更多...
【力扣每日一题】23. 合并 K 个升序链表 暴力法-快排 8.12打卡

【力扣每日一题】23. 合并 K 个升序链表 暴力法-快排 8.12打卡

文章目录 题目思路代码 题目 合并 K 个升序链表 难度&#xff1a; 困难 描述&#xff1a; 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 示例 1&#xff1a; 输入&#xff1a;lists [[1,4,5…
阅读更多...
c++ STL--容器 （第一部分）

c++ STL--容器 （第一部分）

C STL–容器 &#xff08;第一部分&#xff09; 一.STL 1.关于STL的一些知识 1.STL的全称为&#xff1a;Standard Template Library 2.STL中文名为标准模板库 3.STL是c标准库的一部分&#xff0c;是以源代码的形式提供的 4.STL体现了泛型编程的思想 &#xff08;可以对不…
阅读更多...
【脚踢数据结构】队列（顺序和链式）

【脚踢数据结构】队列（顺序和链式）

(꒪ꇴ꒪ )&#xff0c;Hello我是祐言QAQ我的博客主页&#xff1a;C/C语言,Linux基础,ARM开发板&#xff0c;软件配置等领域博主&#x1f30d;快上&#x1f698;&#xff0c;一起学习&#xff0c;让我们成为一个强大的攻城狮&#xff01;送给自己和读者的一句鸡汤&#x1f914;&…
阅读更多...
【LeetCode 算法】Merge k Sorted Lists 合并 K 个升序链表

【LeetCode 算法】Merge k Sorted Lists 合并 K 个升序链表

文章目录 Merge k Sorted Lists 合并 K 个升序链表问题描述&#xff1a;分析代码Heap Tag Merge k Sorted Lists 合并 K 个升序链表 问题描述&#xff1a; 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并…
阅读更多...
数据结构-带头双向循环链表的实现

数据结构-带头双向循环链表的实现

前言 带头双向循环链表是一种重要的数据结构&#xff0c;它的结构是很完美的&#xff0c;它弥补了单链表的许多不足&#xff0c;让我们一起来了解一下它是如何实现的吧&#xff01; 1.节点的结构 它的节点中存储着数据和两个指针&#xff0c;一个指针_prev用来记录前一个节点…
阅读更多...
手撕Java集合——链表

手撕Java集合——链表

链表 一、链表概念特性二、不带头单向非循环链表实现&#x1f351;1、定义结点&#x1f351;2、打印链表&#x1f351;3、使用递归逆序打印链表&#x1f351;4、头插&#x1f351;5、尾插&#x1f351;6、指定位置插入&#x1f351;7、查找是否包含关键字key是否在单链表当中&a…
阅读更多...
linux内核之双向链表实现原理

linux内核之双向链表实现原理

1. 内核中双向链表结构 Linux内核中广泛使用了一种称为循环双链&#xff08;Circular Doubly Linked&#xff09;链表的数据结构&#xff0c;即每个节点都有一个向前和向后的链接&#xff0c;而且首尾节点也相互连接。使用这样的链表&#xff0c;你可以很方便地访问任何一个元…
阅读更多...
每日一题 206反转链表

每日一题 206反转链表

题目 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&#xff1a;[2,1]示例 3&#xff1a; …
阅读更多...
单链表（C语言版）

单链表（C语言版）

单链表&#xff1a;理解、实现与应用 单链表&#xff08;Singly Linked List&#xff09;是一种常见的数据结构&#xff0c;用于存储一系列具有相同类型的元素&#xff0c;并通过节点之间的链接建立起它们的关系。每个节点包含一个数据元素和一个指向下一个节点的指针。相比于…
阅读更多...
链表2-移除链表元素设计链表反转链表

链表2-移除链表元素设计链表反转链表

这篇文章主要记录链表题目&#xff1a; ● 203.移除链表元素 ● 707.设计链表 ● 206.反转链表 移除链表元素 题目链接&#xff1a;203.移除链表元素 思路是找到链表中值为val的元素&#xff0c;修改前节点next指向&#xff0c;并删除查找到的节点。技巧&#xff1a;利用好临…
阅读更多...
单向--＞不带头--＞非循环链表（简称：单链表）

单向--＞不带头--＞非循环链表（简称：单链表）

目录 一、链表的介绍 1.链表的概念 2.单链表的节点类型 3.单链表简图 二、单链表的增删查改 1.单链表的头插 2.单链表的尾插 3.单链表的头删 4.单链表的尾删 5.单链表pos位置之后插入一个节点 6.单链表删除pos位置后的一个节点 一、链表的介绍 1.链表的概念 链表是一…
阅读更多...
链表OJ详解

链表OJ详解

&#x1f495;人生不满百&#xff0c;常怀千岁忧&#x1f495; 作者&#xff1a;Mylvzi 文章主要内容&#xff1a;链表oj详解 题目一&#xff1a;移除元素 题目要求&#xff1a; 画图分析&#xff1a; 代码实现&#xff1a; struct ListNode* removeElements(struct List…
阅读更多...
C语言链表操作

C语言链表操作

目录 链表基本操作 删除重复元素 查找倒数第N个节点 查找中间节点 约瑟夫环 循环链表 合并有序链表 逆置链表 逆置链表(双向链表) 链表基本操作 //linklist.c#include "linklist.h" #include <stdlib.h>struct node *head NULL; struct node *tail…
阅读更多...
数据结构-队列的实现（C语言版）

数据结构-队列的实现（C语言版）

前言 队列是一种特殊的线性表&#xff0c;它只允许在一端对数据进行插入操作&#xff0c;在另一端对数据进行删除操作的特殊线性表&#xff0c;队列具有先进先出的&#xff08;FIFO&#xff09;的 特性&#xff0c;进行插入操作的一端称为队尾&#xff0c;进行删除操作的一端称…
阅读更多...
【数据结构系列】链表

【数据结构系列】链表

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kuan 的首页,持续学…
阅读更多...
软件开发中常用数据结构介绍：C语言链表

软件开发中常用数据结构介绍：C语言链表

工作之余来写写C语言相关知识&#xff0c;以免忘记。今天就来聊聊C语言链表&#xff0c;我是分享人M哥&#xff0c;目前从事车载控制器的软件开发及测试工作。 学习过程中如有任何疑问&#xff0c;可底下评论&#xff01; 如果觉得文章内容在工作学习中有帮助到你&#xff0c;麻…
阅读更多...
6914. 翻倍以链表形式表示的数字

6914. 翻倍以链表形式表示的数字

题目描述&#xff1a; 给你一个 非空 链表的头节点 head &#xff0c;表示一个不含前导零的非负数整数。 将链表 翻倍 后&#xff0c;返回头节点 head 。 示例&#xff1a; 解题思路&#xff1a; 先计算第一位是否超出位数&#xff0c;超出新建存储该数值&#xff0c;再逐个翻倍…
阅读更多...
【力扣每日一题】2023.8.12 合并K个升序链表

【力扣每日一题】2023.8.12 合并K个升序链表

目录 题目&#xff1a; 示例&#xff1a; 分析&#xff1a; 代码&#xff1a; 题目&#xff1a; 示例&#xff1a; 分析&#xff1a; 题目给我们一个链表数组&#xff0c;数组里的链表都是升序的&#xff0c;让我们合并这些链表&#xff0c;要求合并之后还是升序的。 最简…
阅读更多...
82. 删除排序链表中的重复元素 II

82. 删除排序链表中的重复元素 II

题目链接&#xff1a;力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 解题思路&#xff1a;设置一个新的哑元节点result&#xff0c;作为头节点&#xff0c;将head中不重复地节点依次链接到哑元节点后面&#xff0c;最后返回result.next 初始值&…
阅读更多...
数据结构顺序表和链表（超详细）

数据结构顺序表和链表（超详细）

线性表&#xff1a; 线性表 &#xff08; linear list &#xff09; 是 n 个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使 用的数据结构&#xff0c;常见的线性表&#xff1a;顺序表、链表、栈、队列、字符串 ... 线性表在逻辑上是线性结构&#xff0c;也就…
阅读更多...
数据结构-20.二叉排序树BST

数据结构-20.二叉排序树BST

一.定义和查找指定值&#xff1a; 二叉排序树又称二叉查找树。Binary Search Tree 左子树<根节点<右子树 非递归算法&#xff1a; 常数级空间即可O&#xff08;1&#xff09; //定义二叉排序树 typedef struct BSTNode{int val;struct BSTNode *lChild,*rchild; }BSTN…
阅读更多...
华为机试：输出单向链表中倒数第k个结点

华为机试：输出单向链表中倒数第k个结点

输出单向链表中倒数第k个结点 题目描述 输入一个单向链表&#xff0c;输出该链表中倒数第k个结点&#xff0c;链表的倒数第1个结点为链表的尾指针。 链表结点定义如下&#xff1a; struct ListNode {int m_nKey;ListNode* m_pNext; };正常返回倒数第k个结点指针&#xff0c;…
阅读更多...
【leetcode】设计哈希集合（HashSet）、哈希映射(HashMap)

【leetcode】设计哈希集合（HashSet）、哈希映射(HashMap)

我们一般对于HashSet和HashMap都是直接使用数据结构&#xff0c;具体让自己实现一个HashSet和HashMap&#xff0c;又该怎样实现呢&#xff1f; 文章目录1. 设计哈希集合1.1 题目描述1.2 思路分析&#xff08;1&#xff09;简单数组&#xff08;2&#xff09;链表解法&#xff0…
阅读更多...
LeetCode-*143.重排列表

LeetCode-*143.重排列表

重排链表 给定一个单链表 L 的头节点 head &#xff0c;单链表 L 表示为&#xff1a; L0 → L1 → … → Ln-1 → Ln 请将其重新排列后变为&#xff1a; L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → … 不能只是单纯的改变节点内部的值&#xff0c;而是需要实际的进行节点交换…
阅读更多...
LeetCode-206.反转链表

LeetCode-206.反转链表

示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1] 示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&#xff1a;[2,1] 示例 3&#xff1a; 输入&#xff1a;head [] 输出&#xff1a;[] 提示&#xff1a; 链表中节点的数目范围是…
阅读更多...
LeetCode-142.环形链表II

LeetCode-142.环形链表II

给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 为了表示给定链表中的环&#xff0c;我们使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;索引从 0 开始&#xff09;。 如果 pos 是 -1&#xff0c;则在该链表中没有…
阅读更多...
两个链表的第一个公共节点（入门算法26）

两个链表的第一个公共节点（入门算法26）

题目&#xff1a;输入两个链表&#xff0c;找出它们的第一个公共节点。如下面的两个链表&#xff1a; 在节点 c1 开始相交。 示例&#xff1a; 这里有一个点要特别注意&#xff0c;他要找的是公共节点&#xff0c;意思是&#xff0c;A链表和B链表具有相同的地址空间的节点&am…
阅读更多...
LeetCode-141.环形列表

LeetCode-141.环形列表

给定一个链表&#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;我们使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;索引从 0 开始&#xff…
阅读更多...
树的子结构（入门算法15）——深度优先遍历

树的子结构（入门算法15）——深度优先遍历

题目&#xff1a;输入两棵二叉树A和B&#xff0c;判断B是不是A的子结构。(约定空树不是任意一个树的子结构) B是A的子结构&#xff0c; 即 A中有出现和B相同的结构和节点值。 例如: 给定的树 A: 给定的树 B&#xff1a; 返回 true&#xff0c;因为 B 与 A 的一个子树拥有相同…
阅读更多...
用两个栈实现队列（算法入门06）

用两个栈实现队列（算法入门06）

题目&#xff1a;用两个栈实现一个队列。队列的声明如下&#xff0c;请实现它的两个函数 appendTail 和 deleteHead &#xff0c;分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素&#xff0c;deleteHead 操作返回 -1 ) 实例&#xff1a; 输入&#…
阅读更多...
剑指Offer-JZ3-从尾到头打印链表

剑指Offer-JZ3-从尾到头打印链表

与你相识 博主介绍&#xff1a; – 本人是普通大学生一枚&#xff0c;每天钻研计算机技能&#xff0c;CSDN主要分享一些技术内容&#xff0c;因我常常去寻找资料&#xff0c;不经常能找到合适的&#xff0c;精品的&#xff0c;全面的内容&#xff0c;导致我花费了大量的时间&a…
阅读更多...
数据结构与算法——图

数据结构与算法——图

&#x1f60a;数据结构与算法——图 &#x1f680;前言&#x1f680;图的基本概念&#x1f6a2;图的定义&#x1f6a2;图的基本操作&#x1f6a2;无向图和有向图&#x1f6a2;完全图&#x1f6a2;顶点的度、入度和出度&#x1f6a2;子图&#x1f6a2;顶点关系常用术语&#x1f…
阅读更多...
单链表-头尾插法，遍历输出，查找删除。

单链表-头尾插法，遍历输出，查找删除。

1. 创建结构体 2. 头插法创建单链表 3.尾插法创建单链表 4.查找并且删除链表中的数字 5.遍历显示单链表元素 6.Main测试主函数 定义结构体&#xff1a; typedef struct LNode {int data;struct LNode* next; }LNode;头插法创建单链表&#xff1a; LNode* HeadInsert() …
阅读更多...
HashMap死循环问题

HashMap死循环问题

HashMap死循环主要是指JDK7中&#xff0c;HashMap扩容时采用头插法。如果在多线程情况下&#xff0c;2条线程同时进行扩容操作&#xff0c;会造成两个结点的next指针互相指向对方的情况 比如最简单的一个情况&#xff0c;一个链表只有A、B两个结点&#xff0c;线程1和线程2一开…
阅读更多...
【链表OJ】链表的回文结构

【链表OJ】链表的回文结构

⭐️ 往期相关文章 &#x1f4ab;链接1&#xff1a;链表分割 &#x1f4ab;链接2&#xff1a;链表中倒数第k个结点(快慢指针问题) &#x1f4ab;链接3&#xff1a;leetcode 876.链表的中间结点(快慢指针问题) &#x1f4ab;链接4&#xff1a;leetcode 206.反转链表 &#x1f4…
阅读更多...
Redis | 双端链表

Redis | 双端链表

目录 一、前言 二、链表和链表节点的实现 三、Redis的链表实现的特性 一、前言 链表在 Redis中的应用非常广泛，比如列表键的底层实现之一就是链表。当一个列表键包含了数量比较多的元素，又或者列表中包含的元素都是比较长的字符串时， Redis就会使用链表作为列表键的底层实…
阅读更多...
内存池的实现

内存池的实现

一、内存池 1、内存池的概念 内存池&#xff08;Memory Pool&#xff09;是一种内存分配方式。通常我们习惯直接使用new、malloc等API申请内存&#xff0c;这样做的缺点在于所申请内存块的大小不定&#xff0c;当频繁使用时会造成大量的内存碎片并进而降低性能。 内存池则是在…
阅读更多...
【数据结构(郝斌)】03线性结构-总结----【待补充】

【数据结构(郝斌)】03线性结构-总结----【待补充】

文章目录一、数据结构1.狭义2.广义:二、算法:1.狭义2.广义三、数据的存储结构有几种1.线性&#xff08;1&#xff09;连续存储[数组]优点缺点&#xff08;2&#xff09;离散存储|[链表]优点缺点&#xff08;3&#xff09;线性结构的应用-- 栈&#xff08;4&#xff09;线性结构…
阅读更多...
Linux内核10-list_head和hlist_head的理解

Linux内核10-list_head和hlist_head的理解

原文地址&#xff1a;Linux内核10-list_head和hlist_head的理解 1 概述 在Linux内核中&#xff0c;对于数据的管理&#xff0c;提供了2种类型的双向链表&#xff1a;一种是使用list_head结构体构成的环形双向链表&#xff1b;另一种是使用hlist_head和hlist_node2个结构体构成…
阅读更多...
AddressSanitizer: DEADLYSIGNAL

AddressSanitizer: DEADLYSIGNAL

剑指 Offer 25. 合并两个排序的链表 - 力扣&#xff08;LeetCode&#xff09; (leetcode-cn.com) 目录 错误信息 AddressSanitizer SEGV From Cadence Community From Wikipedia 调试与分析 未解决的疑问 错误信息 AddressSanitizer AddressSanitizer is a fast memor…
阅读更多...
容器：forward_list用法及示例

容器：forward_list用法及示例

forward_list用法及示例 文章目录forward_list用法及示例简介容器特性使用成员函数几种创建方式示例&#xff1a;demo1:demo2: 获取元素个数(forward_list没有size()成员函数)demo3: 可使用std::advance()更便捷的移动迭代器(注意不要越界)简介 forward_list是单链表容器 是 C…
阅读更多...
剑指offer 58. 左旋转字符串

剑指offer 58. 左旋转字符串

剑指 Offer 58 - II. 左旋转字符串 - 力扣&#xff08;LeetCode&#xff09; (leetcode-cn.com) 有没有搞错&#xff0c;这题怎么会上剑指offer&#xff1f;&#xff1f;&#xff1f; 运行结果 代码 class Solution { public:string reverseLeftWords(string s0, int n) {st…
阅读更多...
redis关于list的常用命令

redis关于list的常用命令

存储lists类型 1、lpush key value1 value2...&#xff1a;在指定的key的list的头部插入所有的values&#xff0c;如果该key不存在&#xff0c;该命令在插入的之前创建该key和空链表&#xff0c;之后再向该链表的头部插入数据。插入成功&#xff0c;返回元素的个数。 2、rpush…
阅读更多...
leetcode_69 Rotate List

leetcode_69 Rotate List

题目&#xff1a; Given a linked list, rotate the list to the right by k places, where k is non-negative. Example 1: Input: 1->2->3->4->5->NULL, k 2 Output: 4->5->1->2->3->NULL Explanation: rotate 1 steps to the right: 5-&g…
阅读更多...
数据结构——多项式加法

数据结构——多项式加法

#include <bits/stdc.h> using namespace std; typedef struct item {int coe; //系数int ind; //指数struct item *next; } item, *link; int n, m; void creatlink(link &head); void print(link &head); void linksum(link &head); int main() {link head…
阅读更多...
【刷题】142. 环形链表 II

【刷题】142. 环形链表 II

142. 环形链表 II 一、题目描述二、示例三、实现3.1 方法13.2 方法2 142. 环形链表 II 一、题目描述 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 nex…
阅读更多...
【C++】 类练习---封装链表、人物移动

【C++】 类练习---封装链表、人物移动

目录 前言 正文 结构体和类的区别 练习1&#xff1a;封装链表 用类封装链表的注意事项 定义一个链表的节点结构 链表类代码 主函数 运行结果 练习2&#xff1a;人物移动 说明 头文件以及宏 人物类 主函数 运行结果 结语 前言 在学完了【C】 类基础汇总&#x…
阅读更多...
数组模拟链表解决约瑟夫问题

数组模拟链表解决约瑟夫问题

数组模拟链表解决约瑟夫问题 package linkedlist;public class Josepfu {public static void main(String[] args) {CircleSingleLinkedList listnew CircleSingleLinkedList();list.addBoy(20);list.countBoy(1,19,20);}//创建一个环形的单项链表} class CircleSingleLinkedL…
阅读更多...
【数据结构】- 链表之带头(哨兵位)双向循环链表(上)

【数据结构】- 链表之带头(哨兵位)双向循环链表(上)

文章目录 前言&#x1f31f;一、带头双向循环链表&#x1f31f;二、带头双向循环链表结构图&#xff1a;&#x1f31f;三、带头双向循环链表代码实现&#xff1a;&#x1f30f;3.1头插&#xff1a;&#x1f30f;3.2头插流程图&#x1f30f;3.3 尾插&#x1f30f;3.4尾插流程图&…
阅读更多...
[数据结构 -- C语言] 栈(Stack)

[数据结构 -- C语言] 栈(Stack)

目录 1、栈 1.1 栈的概念及结构 2、栈的实现 2.1 接口 3、接口的实现 3.1 初始化 3.2 入栈/压栈 3.3 出栈 3.4 获取栈顶元素 3.5 获取栈中有效元素个数 3.6.1 bool 类型接口 3.6.2 int 类型接口 3.7 销毁栈 4、完整代码 5、功能测试 1、栈 1.1 栈的概念及结构 …
阅读更多...
【数据结构】--单链表力扣面试题①移除链表元素

【数据结构】--单链表力扣面试题①移除链表元素

题述&#xff1a; 给你一个链表的头结点head和一个整数val,请你删除链表中所有满足Node.val val的节点&#xff0c;并返回新的头结点。 思考&#xff1a; 为什么说要返回新的头结点&#xff0c;因为你删除的可能存在把原来的头结点删除的情况&#xff0c;这时就需要有新的头结…
阅读更多...
【学习笔记】数据结构学习

【学习笔记】数据结构学习

01 链表 1、结点&#xff08;node&#xff09;&#xff1a;数据元素的存储映像。由数据域和指针域两部分组成。 数据域&#xff1a;存储元素数值数据指针域&#xff1a;存储直接后继结点的存储位置 2、链表&#xff1a;n个结点由指针链组成的一个链表 头指针&#xff1a;是指…
阅读更多...
【力扣面试】面试题 02.01. 移除重复节点

【力扣面试】面试题 02.01. 移除重复节点

文章目录题目解题思路方法1&#xff1a;利用HashSet的唯一性题目 编写代码&#xff0c;移除未排序链表中的重复节点。保留最开始出现的节点。 示例1: 输入&#xff1a;[1, 2, 3, 3, 2, 1] 输出&#xff1a;[1, 2, 3] 示例2: 输入&#xff1a;[1, 1, 1, 1, 2] 输出&#xff1a;[…
阅读更多...
算法篇：树之转换为二叉搜索树

算法篇：树之转换为二叉搜索树

算法&#xff1a;核心思想是利用二分法&#xff0c;不过有序数组和有序链表找到中间节点的方法不一致。1.对有序数组或者有序链表来说&#xff0c;把中间节点当作根节点 2. 左边数组的值都小于根节点&#xff0c;作为左子树&#xff1b;右边数组的值都大于根节点&#xff0c;作…
阅读更多...
一篇文章让你精通：java集合讲解（二，LinkList）

一篇文章让你精通：java集合讲解（二，LinkList）

学习完ArrayList,就准备准备学习它兄弟LinkList了&#xff0c;它们是兄弟所以说有很多的方法是相同的。这样的目的是方便程序员记住它们&#xff0c;下面就让我们来看看它吧&#xff01; ​​​​​​​一篇文章让你精通&#xff1a;java集合讲解&#xff08;二&#xff0c;Arr…
阅读更多...
【数据结构之单链表】

【数据结构之单链表】

前言 上一篇我们已经写完顺序表了&#xff0c;那么顺序表有什么缺点呢&#xff0c;如何解决&#xff1f; 链表的概念及结构 概念︰链表是一种物理存储结构上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 单链表实现 SList.…
阅读更多...
第3课-数组、链表、跳表

第3课-数组、链表、跳表

文章目录1 数组Array2 链表LinkedList2.1 普通链表2.2 双向链表3 数组和链表时间复杂度3.1 链表时间复杂度3.2 数组时间复杂度4 跳表Skip List4.1 跳表原理4.2 跳表查询的时间复杂度分析4.3 现实中跳表的形态4.4 跳表的空间复杂度分析5 工程中的应用5.1 LRU Cache - Linked lis…
阅读更多...
链表中的节点每K个一组反转

链表中的节点每K个一组反转

class Solution { public:ListNode* reverseKGroup(ListNode* head, int k) {if(!head || k < 1) return head; //空指针及不需要翻转的情况直接返回headListNode* pre nullptr; //记录前一个ListNodeListNode* cur head; //记录当前ListNodeListNode* next nullptr; //记…
阅读更多...
链表与环(找相遇点和入口)

链表与环(找相遇点和入口)

链表与环题目一&#xff1a;判断链表中是否有环解法一&#xff1a;双指针解法二&#xff1a;哈希表题目二&#xff1a;链表中环的入口结点题目一&#xff1a;判断链表中是否有环 解法一&#xff1a;双指针 /** function ListNode(x){* this.val x;* this.next null;* }…
阅读更多...
反转链表(进阶：选用迭代和递归方式完成反转！)

反转链表(进阶：选用迭代和递归方式完成反转！)

反转链表描述示例JS代码迭代递归描述 输入一个链表&#xff0c;反转链表后&#xff0c;输出新链表的表头。 示例 输入&#xff1a; {1,2,3} 返回值&#xff1a; {3,2,1}JS代码 迭代 /*function ListNode(x){this.val x;this.next null; }*/ function ReverseList(pHead)…
阅读更多...
线程死锁_hashMap参数

线程死锁_hashMap参数

多线程 1、模拟一个线程死锁 package com.m.sort;public class Test2 {private static final Object obj1 new Object();private static final Object obj2 new Object();public static void main(String[] args) {new Thread(()->{synchronized (obj1){try {Thread.sle…
阅读更多...
链表排序之快排与归并(递归与非递归)

链表排序之快排与归并(递归与非递归)

链表排序之快排与归并(递归与非递归) 1.对链表进行快速排序 以【4&#xff0c;2&#xff0c;5&#xff0c;3&#xff0c;7&#xff0c;9&#xff0c;0&#xff0c;1】为例&#xff0c;我们来模拟一趟快排的过程。 **1、**初始化时&#xff0c;i指向链表首元素4&#xff1b;j i…
阅读更多...
[剑指offer]JT56---删除链表中重复的结点(戴上新表头，更加方便！)

[剑指offer]JT56---删除链表中重复的结点(戴上新表头，更加方便！)

剑指offer第五十六题题目如下解题思路与代码第一版另一种做法题目如下 解题思路与代码 思路其实挺简单得&#xff0c;只是大家对代码&#xff0c;链表有抵触情绪&#xff0c;别问我怎么知道得&#xff0c;我就是这样。 但是静下来&#xff0c;就是照着它说得做就好了。 三个指…
阅读更多...
数据结构：单链表实现反转

数据结构：单链表实现反转

实现思路&#xff1a; 如果链表只有一个或者没有节点&#xff0c;则无需反转原链表的第一个节点即为反转后的最后一个元素&#xff0c;需要将其固定&#xff0c;我们叫它final按原链表的顺序从第二个开始对所有节点node进行遍历&#xff0c;每次将final的next重新指向node的ne…
阅读更多...
[剑指offer]JT55---链表中环的入口结点(所有的偶遇都是蓄谋已久！详细图解哦！)

[剑指offer]JT55---链表中环的入口结点(所有的偶遇都是蓄谋已久！详细图解哦！)

剑指offer第五十五题题目如下思路与代码题目如下 思路与代码 1.双指针找到相遇点&#xff0c;慢指针走一步&#xff0c;快指针走两步&#xff0c;它们肯定会相遇的&#xff0c;因为相对速度是一步&#xff0c;不会错过&#xff0c;哎&#xff0c;快指针真的是个舔狗… 2.看图说…
阅读更多...
week2 leetcode面试题 [01.03. 两数相加] [206. 反转链表]

week2 leetcode面试题 [01.03. 两数相加] [206. 反转链表]

2. 两数相加 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0c;这两个…
阅读更多...
Go字符串输出格式

Go字符串输出格式

package mainimport ("fmt""strconv" )func main() {//printf 格式化//1. %v 只输出所有的值&#xff0c;是什么打印什么值&#xff0c;不管是什么//2. %v 先输出字段名字&#xff0c;再输出该字段的值//3. %#v 先输出结构体名字值&#xff0c;再输出结…
阅读更多...
Java hashCode()和equals()

Java hashCode()和equals()

Java hashCode和equals hashCode hashCode()的作用是获取哈希码&#xff08;也叫散列码&#xff09;&#xff0c;返回的是一个int值&#xff0c;哈希码的作用是确定某个对象在哈希表中的位置&#xff08;可以快速找到需要的对象&#xff09;&#xff0c;那么问题来了&#xff0…
阅读更多...
C++的链表操作

C++的链表操作

//--------------------------------链表------------------------------ // 描述:通过动态分配内存实现链表 //------------------------------------------------------------------//--------------------------------头文件---------------------------- // 描述:导入的头…
阅读更多...
python面试题3---递归实现链表快速倒转

python面试题3---递归实现链表快速倒转

案例&#xff1a;实现如下链表进行倒转 源代码&#xff1a; Node 用于表示队列中的节点&#xff1b;它包含两个域。 val 表示节点的值。 next指向下一个节点#定义链表的数据结构 class Node:def __init__(self,val):self.next Noneself.val valclass ListUtility:#生成一个用…
阅读更多...
826. 单链表（数组模拟链表）

826. 单链表（数组模拟链表）

826. 单链表 实现一个单链表&#xff0c;链表初始为空&#xff0c;支持三种操作&#xff1a; 向链表头插入一个数&#xff1b;删除第 k 个插入的数后面的数&#xff1b;在第 k 个插入的数后插入一个数。 现在要对该链表进行 M 次操作&#xff0c;进行完所有操作后&#xff0…
阅读更多...
算法-链表树

算法-链表树

链表 反转单向链表 该题⽬来⾃ LeetCode&#xff0c;题⽬需要将⼀个单向链表反转。思路很简单&#xff0c;使⽤三个变量分别表示当前节点和当前节点的前后节点&#xff0c;虽然这题很简单&#xff0c;但是却是⼀道⾯试常考题 var reverseList function(head) { // 判断下变…
阅读更多...
二分法搜索旋转链表中的最小值

二分法搜索旋转链表中的最小值

问题描述 假设按照升序排序的数组在预先未知的某个点上进行了旋转。例如&#xff0c;数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2]&#xff0c;请找出其中最小的元素 分析 a.数组有序首选二分法&#xff0c; b.由于数组经过旋转并非完全有序&#xff0c;但整体上仍然是有…
阅读更多...
单向环形链表与Josephu 问题

单向环形链表与Josephu 问题

单向环形链表图形 约瑟夫问题 思路&#xff1a; // 创建一个Boy类&#xff0c;表示一个节点 class Boy {private int no;// 编号private Boy next; // 指向下一个节点,默认nullpublic Boy(int no) {this.no no;}public int getNo() {return no;}public void setNo(int no) {th…
阅读更多...
【数据结构】链表常见题目-ToDone

【数据结构】链表常见题目-ToDone

文章目录 合并两个有序链表反转链表链表内指定区间反转复制带随机指针的链表环形链表环形链表II相交链表移除链表元素链表中倒数第k个节点链表分割链表的回文结构链表的中间节点旋转链表链表排序链表求和 (逆序求)链表求和II (正序求)重排链表链表的奇偶重排奇偶链表反转链表II…
阅读更多...
【数据结构OJ题】链表的中间结点

【数据结构OJ题】链表的中间结点

原题链接&#xff1a;https://leetcode.cn/problems/middle-of-the-linked-list/description/ 目录 1. 题目描述 2. 思路分析 3. 代码实现 1. 题目描述 2. 思路分析 快慢指针法 通过快慢指针找到中间结点&#xff0c;快指针每次走两步&#xff0c;慢指针每次走一步&#…
阅读更多...
数据结构——链表详解

数据结构——链表详解

链表 文章目录 链表前言认识链表单链表结构图带头单循环链表结构图双向循环链表结构图带头双向循环链表结构图 链表特点 链表实现(带头双向循环链表实现)链表结构体(1) 新建头节点(2) 建立新节点(3)尾部插入节点(4)删除节点(5)头部插入节点(6) 头删节点(7) 寻找节点(8) pos位置…
阅读更多...
链表OJ题

链表OJ题

今天讲一些关于链表的Oj题&#xff0c;相信你看完对链表又提升一个档次。 题目一 思路一 遍历一遍链表是Val值得时候free这个&#xff0c;然后我们往后走&#xff0c;一直走到末尾空指针得时候&#xff0c;新链表就是我们得答案&#xff0c;那我们用代码来表示一下吧。 struct…
阅读更多...
【数据结构OJ题】复制带随机指针的链表

【数据结构OJ题】复制带随机指针的链表

原题链接&#xff1a;https://leetcode.cn/problems/copy-list-with-random-pointer/description/ 目录 1. 题目描述 2. 思路分析 3. 代码实现 1. 题目描述 2. 思路分析 此题可以分三步进行&#xff1a; 1. 拷贝链表的每一个结点&#xff0c;拷贝的结点先链接到被拷贝结点…
阅读更多...
Java：ArrayList集合、LinkedList（链表）集合的底层原理及应用场景

Java：ArrayList集合、LinkedList（链表）集合的底层原理及应用场景

ArrayList集合的底层原理及应用场景 LinkedList&#xff08;链表&#xff09;集合的底层原理及应用场景 单向链表 增加数据 删除数据 双向链表 LinkedList的应用场景之一:可以用来设计队列 入队 出队 LinkedList的应用场景之一:可以用来设计栈 压栈&#xff08;push),addFirst…
阅读更多...
LeetCode 160.相交链表

LeetCode 160.相交链表

文章目录 &#x1f4a1;题目分析&#x1f4a1;解题思路&#x1f6a9;步骤一&#xff1a;找尾节点&#x1f6a9;步骤二&#xff1a;判断尾节点是否相等&#x1f6a9;步骤三&#xff1a;找交点&#x1f344;思路1&#x1f344;思路2 &#x1f514;接口源码 题目链接&#x1f449;…
阅读更多...
数据结构，链表，单链表，双链表，循环链表，双向循环链表

数据结构，链表，单链表，双链表，循环链表，双向循环链表

链表是数据结构中的一个基本概念&#xff0c;它是线性表的一种实现。链表与顺序表&#xff08;基于数组的线性表&#xff09;不同&#xff0c;链表的元素不需要在内存中连续存储。链表的每个元素由一个节点来表示&#xff0c;每个节点都有一个数据部分和一个指针部分。 以下是…
阅读更多...
剑指offer全集系列(1)

剑指offer全集系列(1)

目录 JZ3 数组中重复的数字 JZ4 二维数组中的查找 JZ5 替换空格 JZ6 从尾到头打印链表 JZ18 删除链表的节点 JZ22 链表中倒数最后k个结点 题目为剑指offer top100题目, 欢迎大家来学习&#x1f618; JZ3 数组中重复的数字 数组中重复的数字_牛客题霸_牛客网在一个长度为…
阅读更多...
【数据结构OJ题】链表的回文结构

【数据结构OJ题】链表的回文结构

原题链接&#xff1a;https://www.nowcoder.com/practice/d281619e4b3e4a60a2cc66ea32855bfa?tpId49&&tqId29370&rp1&ru/activity/oj&qru/ta/2016test/question-ranking 目录 1. 题目描述 2. 思路分析 3. 代码实现 1. 题目描述 2. 思路分析 在做这道…
阅读更多...
【算法刷题之链表篇（2）】

【算法刷题之链表篇（2）】

目录 1.leetcode-23. 合并 K 个升序链表&#xff08;较难&#xff09;&#xff08;1&#xff09;题目描述&#xff08;2&#xff09;方法一&#xff1a;顺序合并&#xff08;3&#xff09;方法二&#xff1a;分治合并&#xff08;4&#xff09;方法三&#xff1a;使用优先队列合…
阅读更多...
leetcode做题笔记92. 反转链表 II

leetcode做题笔记92. 反转链表 II

给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 示例 1&#xff1a; 思路一&#xff1a;头插法 struct ListNode *reverseBetween(struct ListNode *h…
阅读更多...
【数据结构】链表常见题目

【数据结构】链表常见题目

文章目录 链表合并两个有序链表反转链表复制带随机指针的链表环形链表环形链表II相交链表移除链表元素链表中倒数第k个节点链表分割链表的回文结构链表的中间节点旋转链表链表排序链表求和 (逆序求)链表求和II (正序求)重排链表奇偶链表反转链表II <==> 链表内指定区间反…
阅读更多...
15.树与二叉树基础

15.树与二叉树基础

目录 一. 树&#xff0c;基本术语 二. 二叉树 &#xff08;1&#xff09;二叉树 &#xff08;2&#xff09;满二叉树 &#xff08;3&#xff09;完全二叉树 三. 二叉树的性质 四. 二叉树的存储结构 &#xff08;1&#xff09;顺序存储结构 &#xff08;2&#xff09;链…
阅读更多...
【leetcode 力扣刷题】链表基础知识 基础操作

【leetcode 力扣刷题】链表基础知识 基础操作

链表基础知识 基础操作 链表基础操作链表基础知识插入节点删除节点查找节点 707. 设计链表实现&#xff1a;单向链表&#xff1a;实现&#xff1a;双向链表 链表基础操作 链表基础知识 在数据结构的学习过程中&#xff0c;我们知道线性表【一种数据组织、在内存中存储的形式】…
阅读更多...
什么是链表，前端如何理解链表

什么是链表，前端如何理解链表

一、什么是链表 多个元素存储的列表链表中的元素在内存中不是顺序存储的&#xff0c;而是通过“next”指针联系在一起的。 JS中的原型链 原理就是 链表结构 链表结构 {key: "A",next: {key: "B",next: {key: "C",next: null}} } //原型链 //对…
阅读更多...
C语言链式栈

C语言链式栈

链式栈 链式栈是一种 数据存储 结构&#xff0c;可以通过 单链表 的方式来实现&#xff0c;使用链式栈的优点在于它能够克服用数组实现的顺序栈空间利用率不高的特点&#xff0c;但是需要为每个栈元素分配额外的指针空间用来存放指针域。 文章目录链式栈前言一、链式栈的结构和…
阅读更多...
C语言双链表

C语言双链表

双链表 对双链表进行头插法&#xff0c;尾插法&#xff0c;删除节点&#xff0c;遍历打印 文章目录双链表前言一、双链表结构和初始化二、插入1.头插法2.尾插法3.删除节点总结前言 对双链表进行头插法&#xff0c;尾插法&#xff0c;删除节点&#xff0c;遍历打印 一、双链表…
阅读更多...
57. 插入区间(C++题解)

57. 插入区间(C++题解)

57. 插入区间 插入区间 给你一个无重叠的 &#xff0c;按照区间起始端点排序的区间列表。 在列表中插入一个新的区间&#xff0c;你需要确保列表中的区间仍然有序且不重叠&#xff08;如果有必要的话&#xff0c;可以合并区间&#xff09;。 示例 1&#xff1a; 输入&#x…
阅读更多...
【数据结构】带头双向循环链表---C语言版（单链表我们分手吧，不要再找我玩了！！！）

【数据结构】带头双向循环链表---C语言版（单链表我们分手吧，不要再找我玩了！！！）

文章目录 &#x1f438;一、前言&#x1f438;二、链表的分类&#x1f344;1. 单向或者双向链表&#x1f344;2. 带头或者不带头链表&#x1f344;3. 循环或者非循环&#x1f344;4. 最常用链表 &#x1f438;三、带头双向循环链表详解&#x1f34e;创建带头双向循环链表⭕接口…
阅读更多...
数据结构——C语言实现单向循环链表

数据结构——C语言实现单向循环链表

//循环单链表 #include <stdio.h> #include <stdlib.h> #include <math.h>#define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0typedef int Status; typedef int ElemType; typedef struct Node{ElemType data;struct Node *next; }Node;//定义Lin…
阅读更多...
C语言单循环链表

C语言单循环链表

单循环链表 文章目录单循环链表前言一、结构和初始化二、插入和删除1.头插法2.尾插法3.删除总结前言 C语言单循环链表的记录 一、结构和初始化 typedef struct Node { //定义一个Node的结构体int data; //data数据域struct Node* next; //next指针域 }No…
阅读更多...
【LeetCode-中等题】199. 二叉树的右视图

【LeetCode-中等题】199. 二叉树的右视图

文章目录 题目方法一&#xff1a;层序遍历取每一层最后一个元素方法二&#xff1a;深度优先搜索 题目 方法一&#xff1a;层序遍历取每一层最后一个元素 // 方法一 &#xff1a;层序 集合(取每层子集合最后一个元素)// List<List<Integer>> Rlist new ArrayList…
阅读更多...
【数据结构】带头双向循环链表及其实现

【数据结构】带头双向循环链表及其实现

目录 1.带头双向循环链表 2.带头双向循环链表实现 2.1初始化 2.2销毁 2.3头插 2.4链表打印 2.5头删数据 2.6尾插数据 2.7尾删数据 2.8链表判空 2.9查找一个数据 2.10在pos位置前插入数据 2.11删除pos位置 2.12求链表的长度 2.顺序表和链表的比较 1.带头双向循环…
阅读更多...
C语言单链表（头插法和尾插法）

C语言单链表（头插法和尾插法）

文章目录前言一、链表结构体以及初始化二、对链表的插入1.头插法2.尾插法3.删除链表中的某一个值总结前言 重新把c语言的算法与数据结构学一遍&#xff0c;并且进行记录。 一、链表结构体以及初始化 typedef struct Node { //声明节点的类型和指向指针的指针类型int dat…
阅读更多...
Hash冲突和一致性

Hash冲突和一致性

对于hash算法&#xff0c;有几个问题避无可避的。问题1: hash冲突的问题&#xff1f;1. 背景介绍&#xff1a;在数据量很大的时候&#xff0c;就会出现hash之后的数值&#xff0c;指向相同的位置&#xff0c;也就是所谓的hash冲突。这个取决于hash算法的好坏&#xff0c;以及数…
阅读更多...
算法篇：前缀树

算法篇：前缀树

算法&#xff1a;前缀树主要用于搜索算法&#xff0c;思想和实现并不复杂&#xff0c;属于典型题目&#xff0c;算法如下所示&#xff1a;1.最多 n个指向子结点的链接&#xff0c;其中每个链接对应字母表数据集中的一个字母&#xff0c; 本文中假定 n 为 26&#xff0c;小写拉丁…
阅读更多...
算法篇：链表之删除和为0的元素

算法篇：链表之删除和为0的元素

算法简介&#xff1a;利用前缀和的方法&#xff0c;例如前缀和[3,5,6,3,7],那么第一个3和最后一个3之间的节点之和就是0&#xff0c;不然的这两个数字不可能相等// 1.基于上面的原理&#xff0c;我们采用 两次hash的办法&#xff0c;第一次hash找到相同前缀和的最后一个位置的节…
阅读更多...
笔试面试题目：链表之两数相加

笔试面试题目：链表之两数相加

算法&#xff1a; 核心问题是进位的操作&#xff1a; 1&#xff09;不要忘记进位之后的哪一个1&#xff1b; 2&#xff09;不要忘记所有位都操作完了之后&#xff0c;最后的哪一个进位1 变形题目的话&#xff0c;需要想办法转换成 题目1这种原子操作的题目。 题目 1: 两数相加&…
阅读更多...
数据结构之带头结点的循环双向链表详细图片+文字讲解

数据结构之带头结点的循环双向链表详细图片+文字讲解

双向循环链表 文章目录双向循环链表前言文件的创建双向链表结构的定义创建返回链表的头结点值传递时&#xff1a;地址传递&#xff1a;双向链表的销毁双向链表的打印开辟一个新结点双向链表的尾插双向链表的头插双向链表的尾删双向链表的头删双向链表查找双向链表在pos的前面进…
阅读更多...
java从头开始--集合1

java从头开始--集合1

集合 泛型 package com.ff.javaCollection.day1;import java.util.ArrayList; /* 泛型&#xff1a;类型参数化&#xff0c;参数化类型&#xff0c;将类型作为参数传入 <一般为任意的单个大写字母&#xff0c;可以有多个> 泛型传入的类型只可以是类类型 如果没有写&…
阅读更多...
【leetcode】删除链表的中间节点，快慢指针和链表转数组再转回链表

【leetcode】删除链表的中间节点，快慢指针和链表转数组再转回链表

删除链表的中间节点 https://leetcode-cn.com/problems/delete-the-middle-node-of-a-linked-list/ var deleteMiddle function (head) {if (!head.next || !head) return nulllet dummy new ListNode(-1)dummy.next headlet slow dummy, fast dummywhile (slow &&…
阅读更多...
数据结构之.队列，循环队列，链式队列（一）

数据结构之.队列，循环队列，链式队列（一）

队列你真的懂了吗&#xff1f;队列用来干嘛&#xff1f;什么场景用队列有优势&#xff1f; 一、循环队列 颜色说明如下&#xff1a; 假设有一个空队列&#xff0c;长度为len 10 fornt对头&#xff0c;rear队尾初始化时&#xff0c;指向0位置。 注意&#xff0c;这里指向可不…
阅读更多...
五、双指针法（11）：总结

五、双指针法（11）：总结

一、数组篇 在数组&#xff1a;就移除个元素很难么&#xff1f; (opens new window)中&#xff0c;原地移除数组上的元素&#xff0c;我们说到了数组上的元素&#xff0c;不能真正的删除&#xff0c;只能覆盖。一些同学可能会写出如下代码&#xff08;伪代码&#xff09;&…
阅读更多...
五、双指针法（10）：四数之和

五、双指针法（10）：四数之和

力扣题目链接(opens new window) 题意&#xff1a;给定一个包含 n 个整数的数组 nums 和一个目标值 target&#xff0c;判断 nums 中是否存在四个元素 a&#xff0c;b&#xff0c;c 和 d &#xff0c;使得 a b c d 的值与 target 相等&#xff1f;找出所有满足条件且不重复的…
阅读更多...
五、双指针法（8）：环形链表II

五、双指针法（8）：环形链表II

力扣题目链接(opens new window) 题意&#xff1a; 给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。为了表示给定链表中的环&#xff0c;使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;索引从 0 开始&#xff09;。…
阅读更多...
Linked List Cycle find cycle begins 环形链表II 返回环的入口节点

Linked List Cycle find cycle begins 环形链表II 返回环的入口节点

文章目录Linked List Cycle find cycle begins 环形链表II [返回环的入口节点]双指针Linked List Cycle find cycle begins 环形链表II [返回环的入口节点] 双指针 快慢指针&#xff0c;快指针一次移动2个node&#xff0c;慢指针一次移动1个node&#xff0c; 通过公式推导的…
阅读更多...
五、双指针法（7）：链表相交

五、双指针法（7）：链表相交

力扣题目链接(opens new window) 给定两个&#xff08;单向&#xff09;链表&#xff0c;判定它们是否相交并返回交点。请注意相交的定义基于节点的引用&#xff0c;而不是基于节点的值。换句话说&#xff0c;如果一个链表的第k个节点与另一个链表的第j个节点是同一节点&#x…
阅读更多...
五、双指针法（6）：删除链表的倒数第N个节点

五、双指针法（6）：删除链表的倒数第N个节点

力扣题目链接(opens new window) 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 进阶&#xff1a;你能尝试使用一趟扫描实现吗&#xff1f; 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] 示…
阅读更多...
五、双指针法（5）：反转链表

五、双指针法（5）：反转链表

力扣题目链接(opens new window) 题意&#xff1a;反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 一、思路 如果再定义一个新的链表&#xff0c;实现链表元素的反转&#xff0c;其实这是对内存空间的浪费。其实…
阅读更多...
LeetCode50天刷题计划（Day 14—— 删除链表的倒数第 N 个结点（12.20-13.00）

LeetCode50天刷题计划（Day 14—— 删除链表的倒数第 N 个结点（12.20-13.00）

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录前言一、题目示例提示二、思路-双指针三、代码&#xff08;python&#xff09;前言 一看题目就有的惊才绝艳的思路&#xff08;你好&#xff0c;我飘了&#xff08;…
阅读更多...
力扣（LeetCode）题解（使用JavaScript）【4】

力扣（LeetCode）题解（使用JavaScript）【4】

&#xff08;1&#xff09;打印从1到最大的n位数 输入数字 n&#xff0c;按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3&#xff0c;则打印出 1、2、3 一直到最大的 3 位数 999。 示例 1: 输入: n 1 输出: [1,2,3,4,5,6,7,8,9] 说明&#xff1a; 用返回一个整数列表来…
阅读更多...
D4-读论文D4算法题D4（复习）

D4-读论文D4算法题D4（复习）

------0841emm看完论文了&#xff0c;还没吃早饭&#xff0c;先把题做了叭&#xff01; —0903墨迹了一会&#xff0c;把单词背完了&#xff0c;做题&#xff01;&#xff01; 单链表 m int(input()) N 100010 e,ne [0]*N,[0]*N h -1 idx 1def insert_head(x):global i…
阅读更多...
C语言 | 构建链表

C语言 | 构建链表

文章目录1、输入数字建立链表2、输入字符建立链表1、输入数字建立链表 代码&#xff1a; #include<stdio.h> #include<stdlib.h>typedef struct ListNode {int data;struct ListNode *next; }*PT_ListNode, T_ListNode;//输入数字建立链表 int main() {T_ListNode…
阅读更多...
C语言 | 动态创建链表

C语言 | 动态创建链表

leetcode第2题&#xff1a;2.两数相加 其中动态构造新链表的方法为&#xff1a;使用左右指针进行构造 struct ListNode* head NULL, tail NULL; ... ... if () {head tail (struct ListNode*)malloc(sizeof(struct ListNode));tail->val ...;tail->next NULL; } e…
阅读更多...
牛客高频Top200(1)

牛客高频Top200(1)

牛客高频Top200中的一些题-js代码NC78反转链表NC140排序NC93设计LRU缓存结构NC45实现二叉树先中后遍历NC119最小的k个数NC15二叉树层序遍历NC78反转链表 pre为上一个节点&#xff0c;cur为当前遍历节点&#xff0c;next用来保存下一个节点&#xff0c;每次遍历&#xff0c;先保…
阅读更多...
LeetCode142环形链表找入口节点

LeetCode142环形链表找入口节点

分析 这道题在之前那道判断链表是否有环的基础上增加了寻找入口节点的位置。 首先无环的话直接返回null有环的话返回环入口节点的位置 这里只分析有环后如何求位置&#xff0c;判断是否有环可以参考前面的文章。 求这个位置的话有涉及到数学的追击问题了&#xff08;哭&…
阅读更多...
五、双指针法（2）：反转字符串

五、双指针法（2）：反转字符串

力扣题目链接(opens new window) 编写一个函数&#xff0c;其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。不要给另外的数组分配额外的空间&#xff0c;你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。 你可以假设数组中的所有字符都…
阅读更多...
ArrayList和LinkedList在性能方面的差别，能有多大？

ArrayList和LinkedList在性能方面的差别，能有多大？

前言 在面试的时候&#xff0c;经常会被问到几个问题&#xff1a; ArrayList和LinkedList的区别&#xff0c;相信大部分朋友都能回答上&#xff1a; ArrayList是基于数组实现&#xff0c;LinkedList是基于链表实现 当随机访问List时&#xff0c;ArrayList比LinkedList的效率更高…
阅读更多...
二、链表（9）： 总结篇

二、链表（9）： 总结篇

一、链表的理论基础 在这篇文章关于链表&#xff0c;你该了解这些&#xff01; (opens new window)中&#xff0c;介绍了如下几点&#xff1a; 链表的种类主要为&#xff1a;单链表&#xff0c;双链表&#xff0c;循环链表链表的存储方式&#xff1a;链表的节点在内存中是分散…
阅读更多...
二、链表（8）：环形链表II

二、链表（8）：环形链表II

https://leetcode-cn.com/problems/linked-list-cycle-ii/ 题意&#xff1a; 给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 为了表示给定链表中的环&#xff0c;使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;索…
阅读更多...
二、链表（7）： 链表相交

二、链表（7）： 链表相交

题目链接&#xff1a;https://leetcode-cn.com/problems/intersection-of-two-linked-lists-lcci/ 给定两个&#xff08;单向&#xff09;链表&#xff0c;判定它们是否相交并返回交点。请注意相交的定义基于节点的引用&#xff0c;而不是基于节点的值。换句话说&#xff0c;如…
阅读更多...
剑指 Offer 25-----合并两个排序的链表

剑指 Offer 25-----合并两个排序的链表

剑指 Offer 25-----合并两个排序的链表1. 递归2. 迭代输入两个递增排序的链表&#xff0c;合并这两个链表并使新链表中的节点仍然是递增排序的。 示例1&#xff1a; 输入&#xff1a;1->2->4, 1->3->4 输出&#xff1a;1->1->2->3->4->4限制&…
阅读更多...
二、链表（6）：删除链表的倒数第N个节点

二、链表（6）：删除链表的倒数第N个节点

题目链接&#xff1a;https://leetcode-cn.com/problems/remove-nth-node-from-end-of-list/ 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。进阶&#xff1a;你能尝试使用一趟扫描实现吗&#xff1f; &#xff08;第一感觉就是双指针…
阅读更多...
jdk1.8 HashMap原理

jdk1.8 HashMap原理

目录哈希表哈希函数&#xff1a;哈希表哈希冲突HashMap原理概述HashMap数据结构确定哈希桶数据索引位置HashMap的put方法实现HashMap的get方法实现扩容机制附录哈希表 在学习hashmap前&#xff0c;先了解一下哈希表。 哈希函数&#xff1a; Hash函数就是根据key计算出应该存…
阅读更多...
API学习LinkedList

API学习LinkedList

package com.wonders.week01.collection;import java.util.LinkedList; import java.util.List;/*** JDK1.7* LinkedList学习* (1)是一种底层实现由双链表组成的集合* (2)实现了List和Deque接口。* (3)不是线程安全的集合* author liyongyong**/ public class LinkedListTest {…
阅读更多...
二、链表（5）：两两交换链表中的节点

二、链表（5）：两两交换链表中的节点

https://leetcode-cn.com/problems/swap-nodes-in-pairs/ 给定一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后的链表。你不能只是单纯的改变节点内部的值&#xff0c;而是需要实际的进行节点交换。一、思路 这道题目正常模拟就可以了。 建议使用虚拟头…
阅读更多...
二、链表（4）：反转链表

二、链表（4）：反转链表

https://leetcode-cn.com/problems/reverse-linked-list/ 题意&#xff1a;反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL输出: 5->4->3->2->1->NULL一、思路 如果再定义一个新的链表&#xff0c;实现链表元素的反转&#xff0c;其实这是对…
阅读更多...
leetcode BFS框架

leetcode BFS框架

BFS框架 当涉及求二叉树层级值时&#xff0c;就考虑用广度优先搜素; queue<item> myQueue; while (!queue.empty()){sz queue.size();for (int i 0; i < sz; i) {myQueue.front(), myQueue.pop();.......if (condition) {myQueue.push();}.......} } 102 二叉树的…
阅读更多...
3-1栈和队列

3-1栈和队列

一.栈 &#xff08;一&#xff09;卡特兰数 n个不同元素进栈&#xff0c;出栈元素不同排列的个数为1n1\frac{1}{n1}n11​C2nnC^{n}_{2n}C2nn​ &#xff08;二&#xff09;栈的顺序存储 1.初始化 #define MaxSize 10 typedef struct {ElemType data[MaxSize];int top;//栈顶指…
阅读更多...
JavaScript——合并两个有序链表

JavaScript——合并两个有序链表

题目描述 输入两个单调递增的链表&#xff0c;输出两个链表合成后的链表&#xff0c;当然我们需要合成后的链表满足单调不减规则。 例如&#xff1a; 输入&#xff1a;链表一&#xff1a;1->3->5->7 链表二&#xff1a;2->4->6->8 输出&#xff1a;链…
阅读更多...
java中的linkedlist的实现原理-动力节点

java中的linkedlist的实现原理-动力节点

LinkedList是Java List类型的集合类的一种实现&#xff0c;此外&#xff0c;LinkedList还实现了Deque接口。本文基于Java1.8&#xff0c;对于LinkedList的实现原理做一下详细讲解。 java中的linkedlist的实现原理 一、LinkedList实现原理总结 LinkedList的实现原理总结如下&…
阅读更多...
Leetcode 148. 排序链表（归并排序 （递归法）/ （非递归，从底至顶）

Leetcode 148. 排序链表（归并排序 （递归法）/ （非递归，从底至顶）

Leetcode 148. 排序链表&#xff08;归并排序 &#xff08;递归法&#xff09;/ &#xff08;非递归&#xff0c;从底至顶&#xff09;1.题目2.解题方法1:归并排序&#xff08;递归法&#xff0c;从顶至底&#xff09;方法2:归并排序&#xff08;非递归&#xff0c;从底至顶直接…
阅读更多...
梳理Java中关于集合的知识

梳理Java中关于集合的知识

常见接口简介 List 有序、可重复 ArrayList 查改速度快&#xff0c;初始大小10&#xff0c;扩容一次是原来的1.5倍。 LinkedList 增删速度快&#xff0c;双向链表结构。 Vector 线程安全&#xff0c;初始大小10&#xff0c;扩容一次是原来的2倍。其他集合可通过java.util.Colle…
阅读更多...
二、链表（3）：设计链表

二、链表（3）：设计链表

https://leetcode-cn.com/problems/design-linked-list/ 题意&#xff1a; 在链表类中实现这些功能&#xff1a; get(index)&#xff1a;获取链表中第 index 个节点的值。如果索引无效&#xff0c;则返回-1。addAtHead(val)&#xff1a;在链表的第一个元素之前添加一个值为 val…
阅读更多...
二、链表（2）：移除链表元素

二、链表（2）：移除链表元素

https://leetcode-cn.com/problems/remove-linked-list-elements/ 题意&#xff1a;删除链表中等于给定值 val 的所有节点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5] 示例 2&#xff1a; 输入&#xff1a;head [], va…
阅读更多...
二、链表（1）：链表理论基础

二、链表（1）：链表理论基础

一、关于链表&#xff0c;你该了解这些&#xff01; 什么是链表&#xff0c;链表是一种通过指针串联在一起的线性结构&#xff0c;每一个节点是又两部分组成&#xff0c;一个是数据域一个是指针域&#xff08;存放指向下一个节点的指针&#xff09;&#xff0c;最后一个节点的…
阅读更多...
Leetcode -＞ 21 合并两个有序链表

Leetcode -＞ 21 合并两个有序链表

题目 解题思路及代码实现 #include <iostream> using namespace std;struct ListNode {int val; //当前节点的值ListNode *next; //指向下一个节点的指针ListNode() : val(0), next(nullptr) {} //初始化当前结点值为默认值0,指针为空ListNode(int x) : val(x), ne…
阅读更多...
Java数据结构习题（对删除指定数据的所有结点的优化）：编写一个方法remove（），接受一条链表和一个字符串key作为参数，删除链表中所有item域为key的结点

Java数据结构习题（对删除指定数据的所有结点的优化）：编写一个方法remove（），接受一条链表和一个字符串key作为参数，删除链表中所有item域为key的结点

编写一个方法remove&#xff08;&#xff09;&#xff0c;接受一条链表和一个字符串key作为参数&#xff0c;删除链表中所有item域为key的结点 核心代码&#xff1a; //接受一条链表和一个字符串key作为参数&#xff0c;删除链表中所有item域为key的结点public void remove(Ob…
阅读更多...
Leetcode -＞ 19 删除链表的倒数第 N 个结点

Leetcode -＞ 19 删除链表的倒数第 N 个结点

题目 算法思路与代码实现 算法思路 在对链表进行操作时&#xff0c;一种常用的技巧是添加一个哑节点&#xff08;dummy node&#xff09;&#xff0c;它的 next 指针指向链表的头节点。这样一来&#xff0c;我们就不需要对头节点进行特殊的判断了。 例如&#xff0c;在本题中…
阅读更多...
容器——list

容器——list

目录简单介绍接口介绍构造函数赋值运算符迭代器容量操作访问操作内容操作部分内容操作函数清空函数带构造的首插操作链表有关操作拼接操作删除特定条件的结点删除满足特定条件的相邻元素的第二个元素合并有序对象排序操作逆置操作外部交换函数各种比较函数迭代器失效模拟实现要…
阅读更多...
LintCode 交换链表当中两个节点

LintCode 交换链表当中两个节点

给你一个链表以及两个权值v1和v2&#xff0c;交换链表中权值为v1和v2的这两个节点。保证链表中节点权值各不相同&#xff0c;如果没有找到对应节点&#xff0c;那么什么也不用做。 注意事项 你需要交换两个节点而不是改变节点的权值 样例 给出链表 1->2->3->4->…
阅读更多...
单向链表 ListNode定义，创建和打印

单向链表 ListNode定义，创建和打印

通过C进行单链表的创建、打印以及利用栈实现逆序打印 ListNode定义 struct ListNode{int val;ListNode *next;ListNode() : val(0),next(NULL){}ListNode(int x) : val(x), next(NULL){}ListNode(int x, ListNode *next) : val(x), next(next){} }; 单链表的创建和打印 #inc…
阅读更多...
哎，这让人抠脑壳的 LFU。

哎，这让人抠脑壳的 LFU。

这是why哥的第 83 篇原创文章 让人抠脑壳的 LFU 前几天在某APP看到了这样的一个讨论&#xff1a; 看到一个有点意思的评论&#xff1a; LFU 是真的难&#xff0c;脑壳都给我抠疼了。 如果说 LRU 是 Easy 模式的话&#xff0c;那么把中间的字母从 R&#xff08;Recently&#xf…
阅读更多...
2022离散数学图论笔记01

2022离散数学图论笔记01

2022离散数学图论笔记01内容预览笔记笔记内容为日常上课记录与整理&#xff0c;为图片格式&#xff0c;仅供学习。内容预览 1.图的基本概念 笔记 ——————END-2022-03-07——————个人学习笔记&#xff0c;如有纰漏&#xff0c;敬请指正。感谢您的阅读。
阅读更多...
一个基于运气的数据结构，你猜是啥？

一个基于运气的数据结构，你猜是啥？

排行榜 懂行的老哥一看这个小标题&#xff0c;就知道我要以排行榜作为切入点&#xff0c;去讲 Redis 的 zset 了。 是的&#xff0c;经典面试题&#xff0c;请实现一个排行榜&#xff0c;大部分情况下就是在考验你知不知道 Redis 的 zset 结构&#xff0c;和其对应的操作。 当然…
阅读更多...
解决关于单链表中存在环的问题 数据结构 C语言版

解决关于单链表中存在环的问题 数据结构 C语言版

解决关于单链表中存在环的问题1.单链表中环的概念2.快慢指针判断是否存在环3.环的起始结点4.环的长度5.单链表链式存储基本操作1.单链表中环的概念 所谓单链表中存在环 即在单链表中存在某个结点的指针指向的下一结点为其前方的某个结点位置 从而形成一个封闭的环状 2.快慢指针…
阅读更多...
双向链表基本操作实现 数据结构 C/C++

双向链表基本操作实现 数据结构 C/C++

双向链表基本操作实现1.初始定义2.初始化循环链表3.输入指定长度数据4.插入元素操作5.删除元素操作6.遍历打印元素1.初始定义 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 typedef int Status; typedef int Elem…
阅读更多...
【2022---计算机考研】数据结构之线性表总结（超详细适合背诵）

【2022---计算机考研】数据结构之线性表总结（超详细适合背诵）

文章目录一、顺序表&#xff08;一&#xff09;、数据类型定义&#xff08;二&#xff09;、插入操作&#xff08;三&#xff09;、删除操作&#xff08;四&#xff09;、按值查找二、单链表&#xff08;一&#xff09;、数据类型定义&#xff1a;&#xff08;二&#xff09;、…
阅读更多...
来几道Java面试题，让你不再摸鱼无聊！（一）

来几道Java面试题，让你不再摸鱼无聊！（一）

theme: smartblue 这是我参与更文挑战的第14天&#xff0c;活动详情查看&#xff1a; 更文挑战 今天我们来整理出一些Java面试题&#xff0c;基本上是面试的时候常问的&#xff0c;有一定的概率会遇到。 1. String和StringBuffer和StringBuild的区别&#xff1f; String类型的值…
阅读更多...
C语言链表基本操作

C语言链表基本操作

1.链表概述   链表是一种常见的数据结构。它与常见的数组是不同的&#xff0c;使用数组时先要指定数组包含元素的个数&#xff0c;即为数组的长度&#xff0c;但是如果向这个数组中加入的元素超过了数组的大小时&#xff0c;便不能将内容全部保存。   链表这种存储方式&…
阅读更多...
数据结构 之 带头循环双链表

数据结构 之 带头循环双链表

在数据结构中我们经常会接触到链表&#xff0c;链表也分好多种&#xff0c;带头结点和不带头结点、循环和不循环、单向链表和双向链表而在众多不同结构的链表中 带头循环双链表可以说是一种最优的链表结构相比于单链表只能访问当前结点的后续结点的局限性&#xff0c;双链表既可…
阅读更多...
剑指 Offer 24. 反转链表 Python3实现

剑指 Offer 24. 反转链表 Python3实现

定义一个函数&#xff0c;输入一个链表的头节点&#xff0c;反转该链表并输出反转后链表的头节点。示例:输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL限制&#xff1a;0 < 节点个数 < 5000来源&#xff1a;力扣&#xff08;LeetC…
阅读更多...
归并排序衍生之「单向链表归并排序」

归并排序衍生之「单向链表归并排序」

这道题算是一道比较综合的题&#xff1a; 快慢指针寻找中间节点合并两个有序的链表归并排序的思想 思想&#xff1a; 设置两个指针&#xff0c;一个步长为1&#xff0c; 一个步长为2&#xff0c;当快指针到达尾结点时&#xff0c;慢指针指向中间结点&#xff0c;时间复杂度为O…
阅读更多...
c++ list头文件及list的使用方法案例

c++ list头文件及list的使用方法案例

c++ list头文件 简介 list实际上是双向链表，故亦可称之为doubly-linked list 性质 双向 链表 双向 双向即给定一个元素，我们能够知道后一个元素和前一个元素 list的迭代器是双向迭代器 链表 优点：与向量(vectors)相比，它可以快速的插入和删除–插入和删除操作是常数时间…
阅读更多...
王道 数据结构 树与二叉树（树）

王道 数据结构 树与二叉树（树）

树的知识框架&#xff1a; 树的定义&#xff1a;是n(n>0)个有限数据元素的集合 在任意一颗非空树中&#xff1a; &#xff08;1&#xff09;有且只有一个特定的称为树根(Root)的结点&#xff0c;根结点无前驱结点。 &#xff08;2&#xff09;当n>1时&#xff0c;除根…
阅读更多...
删除链表的节点（入门算法23）

删除链表的节点（入门算法23）

题目&#xff1a;给定单向链表的头指针和一个要删除的节点的值&#xff0c;定义一个函数删除该节点。 返回删除后的链表的头节点。 示例&#xff1a; 输入: head [4,5,1,9], val 5 输出: [4,1,9] 解释: 给定你链表中值为 5 的第二个节点&#xff0c;那么在调用了你的函数之后…
阅读更多...
《数据结构》| 链表的具体实现（超详细）

《数据结构》| 链表的具体实现（超详细）

与你相识 博主介绍&#xff1a; – 本人是普通大学生一枚&#xff0c;每天钻研计算机技能&#xff0c;CSDN主要分享一些技术内容&#xff0c;因我常常去寻找资料&#xff0c;不经常能找到合适的&#xff0c;精品的&#xff0c;全面的内容&#xff0c;导致我花费了大量的时间&a…
阅读更多...
Leetcode-每日一题【725.分隔链表】

Leetcode-每日一题【725.分隔链表】

题目 给你一个头结点为 head 的单链表和一个整数 k &#xff0c;请你设计一个算法将链表分隔为 k 个连续的部分。每部分的长度应该尽可能的相等&#xff1a;任意两部分的长度差距不能超过 1 。这可能会导致有些部分为 null 。这 k 个部分应该按照在链表中出现的顺序排列&#…
阅读更多...
LeetCode 链表类、输出链表

LeetCode 链表类、输出链表

文章目录 说明代码 说明 这里给出的两个类是在刷力扣时的链表辅助类&#xff1a; ListNode 链表节点类ListNodeMgr 链表管理类(输出链表元素) 代码 ListNode public class ListNode {public int val;public ListNode next;public ListNode(int val 0, ListNode next nul…
阅读更多...
Leetcode-每日一题【143.重排链表】

Leetcode-每日一题【143.重排链表】

题目 给定一个单链表 L 的头节点 head &#xff0c;单链表 L 表示为&#xff1a; 请将其重新排列后变为&#xff1a; 不能只是单纯的改变节点内部的值&#xff0c;而是需要实际的进行节点交换。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5]输出&#xff1a;[1,5,2,…
阅读更多...
数据结构--串的存储结构

数据结构--串的存储结构

数据结构–串的存储结构 串的顺序存储 静态数组实现(定长顺序存储) #define MAXLEN 255 typedef struct {char ch[MAXLEN];int length; }SString;动态数组实现(堆分配存储) typedef struct {char* ch;int length; }HString;int main() {HString S;S.ch (char*)malloc(sizeo…
阅读更多...
leetcode---重排链表

leetcode---重排链表

/*** Definition for singly-linked list.* class ListNode {* int val;* ListNode next;* ListNode(int x) {* val x;* next null;* }* }*/ public class Solution {/*思路&#xff1a;1.使用快慢指针&#xff0c;将链表分成前后两个部分 L…
阅读更多...
C语言实现双向循环链表

C语言实现双向循环链表

双向循环链表一、为什么引入双向循环链表二、双向循环链表的实现三、代码部分1、结构的声明2、方法声明3、方法的实现总结&#xff1a;一、为什么引入双向循环链表 1、循环链表的特点&#xff1a; 循环链表建立在单项链表的基础之上&#xff0c;它的最后一个结点指向了头结点…
阅读更多...
leetcode 6914. 翻倍以链表形式表示的数字

leetcode 6914. 翻倍以链表形式表示的数字

给你一个 非空 链表的头节点 head &#xff0c;表示一个不含前导零的非负数整数。 将链表 翻倍 后&#xff0c;返回头节点 head 。 示例 1&#xff1a; 输入&#xff1a;head [1,8,9] 输出&#xff1a;[3,7,8] 解释&#xff1a;上图中给出的链表&#xff0c;表示数字 189 。返…
阅读更多...
【LeetCode-中等题】24. 两两交换链表中的节点

【LeetCode-中等题】24. 两两交换链表中的节点

文章目录 题目方法一&#xff1a;递归方法二&#xff1a;三指针迭代 题目 方法一&#xff1a;递归 图解&#xff1a; 详细版 public ListNode swapPairs(ListNode head) {/*递归法:宗旨就是紧紧抓住原来的函数究竟返回的是什么?作用是什么即可其余的细枝末节不要细究,编译器…
阅读更多...
leetcode 1171.从链表中删去总和值为零的连续节点

leetcode 1171.从链表中删去总和值为零的连续节点

⭐️ 题目描述 &#x1f31f; leetcode链接&#xff1a;从链表中删去总和值为零的连续节点 思路&#xff1a; 在链表的 head 前新增加一个哨兵卫的头结点&#xff0c;方便计算前缀和。遍历链表&#xff0c;依次把每个节点的 val 相加到 sum 中去&#xff0c;再判断 sum 0 依…
阅读更多...
【华为OD机试python】 阿里巴巴找黄金宝箱(Ⅱ)【2023 B卷|100分】

【华为OD机试python】 阿里巴巴找黄金宝箱(Ⅱ)【2023 B卷|100分】

题目描述 一贫如洗的樵夫阿里巴巴在去砍柴的路上，无意中发现了强盗集团的藏宝地， 藏宝地有编号从0-N的箱子，每个箱子上面贴有箱子中藏有金币的数量。 从金币数量中选出一个数字集合，并销毁贴有这些数字的每个箱子， 如果能销毁一半及以上的箱子，则返回这个数字集合的最小大…
阅读更多...
哈希表HashMap（基于vector和list）

哈希表HashMap（基于vector和list）

C数据结构与算法实现&#xff08;目录&#xff09; 1 什么是HashMap&#xff1f; 我们这里要实现的HashMap接口不会超过标准库的版本&#xff08;是一个子集&#xff09;。 HashMap是一种键值对容器&#xff08;关联容器&#xff09;&#xff0c;又叫字典。 和其他容易一样…
阅读更多...
#include ＜graphics.h＞ #include ＜conio.h＞ #include＜stdlib.h＞无法打开源文件解决方案

#include ＜graphics.h＞ #include ＜conio.h＞ #include＜stdlib.h＞无法打开源文件解决方案

一、问题描述 学习数据结构链表的过程中&#xff0c;在编写漫天星星闪烁的代码时&#xff0c;遇到了如下图所示的报错&#xff0c;#include <graphics.h> 、 #include <conio.h> 等无法打开源文件。 并且主程序中initgraph(初始化画布)、setfillcolor&#xff08;…
阅读更多...
D358周赛复盘：哈希表模拟⭐⭐+链表乘法翻倍运算（先反转）⭐⭐⭐

D358周赛复盘：哈希表模拟⭐⭐+链表乘法翻倍运算（先反转）⭐⭐⭐

文章目录 2815.数组中的最大数对和思路完整版 2816.翻倍以链表形式表示的数字&#xff08;先反转&#xff0c;再处理进位&#xff09;思路完整版 补充&#xff1a;206.反转链表&#xff08;双指针法&#xff09;完整版 2817.限制条件下元素之间的最小绝对差&#xff08;cpp不知…
阅读更多...
每日一题（复制带随机指针的链表）

每日一题（复制带随机指针的链表）

每日一题&#xff08;复制带随机指针的链表&#xff09; 138. 复制带随机指针的链表 - 力扣&#xff08;LeetCode&#xff09; 思路&#xff1a; 由于每个链表还包含了一个random节点指向了链表中的随机节点&#xff0c;所以并不能直接照搬复制原链表。首先想到的暴力思路是复…
阅读更多...
BM5 合并k个已排序的链表 javascript

BM5 合并k个已排序的链表 javascript

描述 合并 k 个升序的链表并将结果作为一个升序的链表返回其头节点。 数据范围&#xff1a; 示例1 输入&#xff1a; [{1,2,3},{4,5,6,7}] 返回值&#xff1a; {1,2,3,4,5,6,7}示例2 输入&#xff1a; [{1,2},{1,4,5},{6}] 返回值&#xff1a; {1,1,2,4,5,6}解题思路 利用两个…
阅读更多...
Leetcode 21. 合并两个有序链表

Leetcode 21. 合并两个有序链表

题目描述 题目链接&#xff1a;https://leetcode.cn/problems/merge-two-sorted-lists/description/ 思路 两个链表都是升序链表&#xff0c;新建一个链表&#xff0c;引入伪头节点作为辅助节点&#xff0c;将各节点添加到伪节点之后&#xff0c;再用一个cur节点指向新链表的…
阅读更多...
leetcode 面试题 02.05 链表求和

leetcode 面试题 02.05 链表求和

⭐️ 题目描述 &#x1f31f; leetcode链接&#xff1a;面试题 02.05 链表求和 ps&#xff1a; 首先定义一个头尾指针 head 、tail&#xff0c;这里的 tail 是方便我们尾插&#xff0c;每次不需要遍历找尾&#xff0c;由于这些数是反向存在的&#xff0c;所以我们直接加起来若…
阅读更多...
数据结构——数组与链表

数据结构——数组与链表

数据结构——数组与链表一、数组理论基础二、链表理论基础1.链表分类1&#xff09;单链表2&#xff09;双链表3&#xff09;循环链表4&#xff09;块状链表2.链表的存储方式3.链表的定义4.链表的操作1&#xff09;删除节点2&#xff09;插入节点3&#xff09;查找元素4&#xf…
阅读更多...
顺序表和模拟实现ArrayList的常用方法

顺序表和模拟实现ArrayList的常用方法

模拟实现ArrayList的常用方法ArrayListArrayList&#xff1a;顺序表顺序表和数组的区别&#xff1a;顺序表中的注意点&#xff1a;ArrayList的常用方法模拟实现ArrayList的常用方法ArrayList ArrayList&#xff1a;顺序表 我们可以将顺序表的底层理解成为一个数组&#xff08…
阅读更多...
【GDOI2014模拟】​Pty爬山

【GDOI2014模拟】​Pty爬山

Description 平面上有n个点&#xff0c;我们把ai和ai1连上边&#xff08;保证x坐标递增&#xff09;&#xff0c;从每个点出发&#xff0c;我们会朝着我们当前能看到的最高点走去。如果在某个点&#xff0c;看到了比当前还要高的点&#xff0c;那我们会向这个点走去。&#xf…
阅读更多...
C语言循环双链表

C语言循环双链表

循环双链表 文章目录循环双链表前言一、双链表的结构和初始化二、插入节点1.头插法2.尾插法3.删除节点总结前言 循环双链表的头插法、尾插法、删除节点和遍历打印 一、双链表的结构和初始化 typedef struct Node { //Node结构体int data; //data数据域struct N…
阅读更多...
bzoj 1098: [POI2007]办公楼biu

bzoj 1098: [POI2007]办公楼biu

Description FGD开办了一家电话公司。他雇用了N个职员&#xff0c;给了每个职员一部手机。每个职员的手机里都存储有一些同事的电话号码。由于FGD的公司规模不断扩大&#xff0c;旧的办公楼已经显得十分狭窄&#xff0c;FGD决定将公司迁至一些新的办公楼。 FGD希望职员被安置在…
阅读更多...
算法练习--链表相关

算法练习--链表相关

文章目录 合并两个有序链表删除排序链表中的重复元素 1删除排序链表中的重复元素 2环形链表1环形链表2相交链表反转链表 合并两个有序链表 将两个升序链表合并为一个新的 升序 链表并返回。 新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&…
阅读更多...
【力扣】61. 旋转链表 ＜快慢指针＞

【力扣】61. 旋转链表 ＜快慢指针＞

【力扣】61. 旋转链表&#xff08;每个节点向右移k个单位&#xff09; 给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], k 2 输出&#xff1a;[4,5,1,2,3] 示例 2&a…
阅读更多...
LC-删除排序链表中的重复元素

LC-删除排序链表中的重复元素

LC-删除排序链表中的重复元素 链接&#xff1a;https://leetcode.cn/problems/remove-duplicates-from-sorted-list/description/ 思路&#xff1a;这题其实不难&#xff0c;链表已经排序&#xff0c;我们只要把相邻的两个节点的值进行比较&#xff0c;如果相同&#xff0c;删…
阅读更多...
【数据结构】“单链表”的练习题（二）

【数据结构】“单链表”的练习题（二）

&#x1f490; &#x1f338; &#x1f337; &#x1f340; &#x1f339; &#x1f33b; &#x1f33a; &#x1f341; &#x1f343; &#x1f342; &#x1f33f; &#x1f344;&#x1f35d; &#x1f35b; &#x1f364; &#x1f4c3;个人主页 &#xff1a;阿然成长日记 …
阅读更多...
LeetCode83: 删除排序链表中的重复元素

LeetCode83: 删除排序链表中的重复元素

给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的链表 。示例 1&#xff1a; 输入&#xff1a;head [1,1,2] 输出&#xff1a;[1,2]示例 2&#xff1a; 输入&#xff1a;head [1,1,2,3,3] 输出&#xff1a;[…
阅读更多...
二叉树的存储结构（顺序存储）—— 数据结构与算法

二叉树的存储结构（顺序存储）—— 数据结构与算法

&#x1f636;‍&#x1f32b;️Take your time ! &#x1f636;‍&#x1f32b;️ &#x1f4a5;个人主页&#xff1a;&#x1f525;&#x1f525;&#x1f525;大魔王&#x1f525;&#x1f525;&#x1f525; &#x1f4a5;代码仓库&#xff1a;&#x1f525;&#x1f525;魔…
阅读更多...
递归实现链表的一些操作

递归实现链表的一些操作

递归作为一种重要的算法思想&#xff0c;在链表中也有特别大的作用&#xff0c;特别是逆序输出时&#xff0c;代码更加简单。 以一个题为例&#xff1a; 设head指向一个非空单向链表&#xff1a; 1.输出链表所有结点的值 2.逆向输出所有结点的值 3.返回链表所有结点的和 4.返回…
阅读更多...
【链表OJ】链表中倒数第k个结点 合并两个链表(含哨兵位) 分割链表 链表的回文结构

【链表OJ】链表中倒数第k个结点 合并两个链表(含哨兵位) 分割链表 链表的回文结构

前言: &#x1f4a5;&#x1f388;个人主页:​​​​​​Dream_Chaser&#xff5e; &#x1f388;&#x1f4a5; ✨✨刷题专栏:http://t.csdn.cn/UlvTc ⛳⛳本篇内容:力扣和牛客上链表OJ题目 目录 一、链表中倒数第k个结点 题目描述: 解题思路: 二.合并两个链表(含哨兵位) …
阅读更多...
【leetcode】链表part2

【leetcode】链表part2

24. 两两交换链表中的节点 迭代方法 public static ListNode swapPairs(ListNode head) {// 输入&#xff1a;head [1,2,3,4]// 输出&#xff1a;[2,1,4,3]ListNode dummy new ListNode(0);dummy.next head;ListNode cur dummy;while (cur.next ! null && cur.ne…
阅读更多...
单链表相关操作（插入，删除，查找）

单链表相关操作（插入，删除，查找）

通过上一节我们知道顺序表的优点&#xff1a; 可随机存储&#xff08;O(1)&#xff09;&#xff1a;查找速度快 存储密度高&#xff1a;每个结点只存放数据元素&#xff0c;而单链表除了存放数据元素之外&#xff0c;还需存储指向下一个节点的指针 http://t.csdn.cn/p7OQf …
阅读更多...
Redis数据结构——链表list

Redis数据结构——链表list

链表是一种常用的数据结构&#xff0c;提供了顺序访问的方式&#xff0c;而且高效地增删操作。 Redis中广泛使用了链表&#xff0c;例如&#xff1a;列表的底层实现之一就是链表。 在Redis中&#xff0c;链表分为两部分&#xff1a;链表信息 链表节点。 链表节点用来表示链表…
阅读更多...
7.2 C/C++ 实现动态链表

7.2 C/C++ 实现动态链表

动态链表是一种常用的动态数据结构&#xff0c;可以在运行时动态地申请内存空间来存储数据&#xff0c;相比于静态数组和静态链表&#xff0c;更加灵活和高效。在动态链表中&#xff0c;数据元素被组织成一条链表&#xff0c;每个元素包含了指向下一个元素的指针&#xff0c;这…
阅读更多...
【哈希表】138. 复制带随机指针的链表

【哈希表】138. 复制带随机指针的链表

138. 复制带随机指针的链表 解题思路 创建一个hashMap遍历原始链表 创建每一个节点 针对每一个节点 存入节点对再次遍历链表 将所有的新节点连接起来 /* // Definition for a Node. class Node {int val;Node next;Node random;public Node(int val) {this.val val;this.ne…
阅读更多...
7.5 C/C++ 实现链表队列

7.5 C/C++ 实现链表队列

链表队列是一种基于链表实现的队列&#xff0c;相比于顺序队列而言&#xff0c;链表队列不需要预先申请固定大小的内存空间&#xff0c;可以根据需要动态申请和释放内存。在链表队列中&#xff0c;每个节点包含一个数据元素和一个指向下一个节点的指针&#xff0c;头节点表示队…
阅读更多...
LC-相交链表（解法2）

LC-相交链表（解法2）

LC-相交链表&#xff08;解法2&#xff09; 链接&#xff1a;https://leetcode.cn/problems/intersection-of-two-linked-lists/description/ 描述&#xff1a;给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在…
阅读更多...
链表之第一回

链表之第一回

欢迎来到我的&#xff1a;世界 收录专栏&#xff1a;链表 希望作者的文章对你有所帮助&#xff0c;有不足的地方还请指正&#xff0c;大家一起学习交流 ! 目录 前言第一题&#xff1a;删除链表的倒数第n个节点第二题&#xff1a;链表的中间结点第三题&#xff1a;合并两个排序…
阅读更多...
二刷LeetCode--148. 排序链表(C++版本),必会题，思维题

二刷LeetCode--148. 排序链表(C++版本),必会题，思维题

思路&#xff0c;本题其实考察了两个点&#xff1a;合并链表、链表切分。首先从1开始&#xff0c;将链表切成一段一段&#xff0c;因为需要使用归并&#xff0c;所以下一次的切分长度应该是当前切分长度的二倍&#xff0c;每次切分&#xff0c;我们拿出两段&#xff0c;然后将第…
阅读更多...
【leetcode 力扣刷题】交换链表中的节点

【leetcode 力扣刷题】交换链表中的节点

24. 两两交换链表中的节点 24. 两两交换链表中的节点两两节点分组&#xff0c;反转两个节点连接递归求解 24. 两两交换链表中的节点 题目链接&#xff1a;24. 两两交换链表中的节点 题目内容&#xff1a; 题目中强调不能修改节点内部值&#xff0c;是因为如果不加这个限制的话…
阅读更多...
Rust踩雷笔记（5）——刷点链表的题（涉及智能指针Box，持续更新）

Rust踩雷笔记（5）——刷点链表的题（涉及智能指针Box，持续更新）

目录 leetcode 2 两数相加——模式匹配单链表Box 只能说Rust链表题的画风和C完全不一样&#xff0c;作为新手一时间还不太适应&#xff0c;于是单独为链表、智能指针开一篇&#xff0c;主要记录leetcode相关题型的答案以及注意事项。 leetcode 2 两数相加——模式匹配单链表Bo…
阅读更多...
【数据结构练习】单链表OJ题（二）

【数据结构练习】单链表OJ题（二）

目录 一、相交链表二、环形链表1三、环形链表2四、链表分割五、复制带随机指针的链表 一、相交链表 题目&#xff1a; 示例&#xff1a; 注意&#xff1a;不能根据节点的值来比较是否相交&#xff0c;而是根据节点在内存中是否指向相同的位置。 例如以上图&#xff1a; 链表…
阅读更多...
LeetCode21：合并两个有序链表

LeetCode21：合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4]示例 2&#xff1a; 输入&#xff1a;l1 [], l2 [] 输出&#xff1a;[]示例 …
阅读更多...
二叉树的建立，输出，查找，c/c++描述（上）理论篇

二叉树的建立，输出，查找，c/c++描述（上）理论篇

结束链表的学习后&#xff0c;我们接着学习树。链表是一个前继节点&#xff0c;一个后续节点。树是一个前继节点&#xff0c;多个后续节点。其中最广泛的应用是二叉树&#xff0c;一个节点最多只有两个后继节点。树可能有多个后继节点&#xff0c;也可以用二叉树表示&#xff0…
阅读更多...
约瑟夫环问题|循环单链表C语言

约瑟夫环问题|循环单链表C语言

约瑟夫环问题是经典的循环链表问题&#xff0c;具体描述如下&#xff1a; 题目&#xff1a;有n个人&#xff08;编号分别为1&#xff0c;2&#xff0c;…&#xff0c;n&#xff09;围成一圈&#xff0c;从编号为k的人开始顺时针报数&#xff0c;数到m的人出列&#xff1b;他的下…
阅读更多...
一脸懵逼？大厂为何都注重算法？字节的面试题到底有多难？

一脸懵逼？大厂为何都注重算法？字节的面试题到底有多难？

文章的开头大家先来看一看一道字节的算法题&#xff0c;看是否能做出来&#xff1a; 给定一个单链表的头节点 head,实现一个调整单链表的函数&#xff0c;使得每K个节点之间为一组进行逆序&#xff0c;并且从链表的尾部开始组起&#xff0c;头部剩余节点数量不够一组的不需要逆…
阅读更多...
推荐一位实力超强的平安前端算法大佬：瓶子君

推荐一位实力超强的平安前端算法大佬：瓶子君

今天给大家推荐一位平安大佬&#xff1a;前端瓶子君&#xff0c;一个专注于前端开发的小瓶子&#xff0c;五年大厂开发经验&#xff0c;掘金优秀作者。「前端进阶算法」系列是她4月初发起的活动&#xff0c;从 0 到 1 构建完整的前端数据结构与算法体系。这是一个专注于前端算法…
阅读更多...
跳跃表的推导和数学证明

跳跃表的推导和数学证明

skip list引子地铁的例子L1的理想数值让跳跃表更快重新设计地铁线引子 能够完成动态数据的增删改查最简便的数据结构是什么&#xff1f; 是链表。 链表查询的时间复杂度是O(n)。如何修改最简单的链表&#xff0c;能够让它查得快一点呢&#xff1f; 我们可以多增加一些连接&am…
阅读更多...
链表相关面试题

链表相关面试题

链表相关面试题链表中的节点每k个一组翻转两数相加链表求和&#xff08;两个链表生成相加链表&#xff09;正序排列链表求和(逆序排列)相交链表反转链表反转链表2&#xff08;指定区间内的反转&#xff09;链表中环的入口节点合并两个有序链表两个链表的第一个公共节点从有序链…
阅读更多...
C语言链表实例--玩转链表

C语言链表实例--玩转链表

下图为最一简单链表的示意图&#xff1a; 第 0 个结点称为头结点&#xff0c;它存放有第一个结点的首地址&#xff0c;它没有数据&#xff0c;只是一个指针变量。以下的每个结点都分为两个域&#xff0c;一个是数据域&#xff0c;存放各种实际的数据&#xff0c;如学号 num&…
阅读更多...
循环链表及线性表的情况分析

循环链表及线性表的情况分析

循环链表的应用之约瑟夫环问题以及线性表总结之顺序表与链表的比较 1.1问题说明 问题描述&#xff1a;编号为1&#xff0c;2&#xff0c;&#xff0c;n的n个人围坐在一圆桌旁&#xff0c;每人持有一个正整数的密码。从第一个人开始报数&#xff0c;报到一个预先约定的正整数m…
阅读更多...
数据结构之双链表(数组模拟)（Java）

数据结构之双链表(数组模拟)（Java）

import java.util.*;class Main {static int[] e new int[100010];static int[] l new int[100010];static int[] r new int[100010];static int idx;static Scanner in new Scanner(System.in);// 0:左端点 1:右端点static void init(){r[0] 1;l[1] 0;idx 2;}// 只要实…
阅读更多...
【算法设计与分析(课后答案)】List/Tree的递归

【算法设计与分析(课后答案)】List/Tree的递归

1 对于不带头结点的单链表L&#xff0c;设计一个递归算法正序输出所有结点值。 public class Solution1 {public void printL(ListNode node) {if (node null) {return;}System.out.println(node.val);printL(node.next);} }2 对于不带头结点的单链表L&#xff0c;设计一个…
阅读更多...
【经典专题】反转链表——如何在链表中穿针引线

【经典专题】反转链表——如何在链表中穿针引线

反转整个链表&#xff08;简单&#xff09; 很简单且经典的题目。就是将 1->2->3->4->5 反转为 5->4->3->2->1。 有两种思路&#xff0c;迭代和递归。先看图再看代码&#xff1a; 1&#xff09;迭代——经典的双/三指针 class Solution {public Lis…
阅读更多...
【力扣】203. 移除链表元素 ＜链表指针＞

【力扣】203. 移除链表元素 ＜链表指针＞

【力扣】203. 移除链表元素 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5] 示例 …
阅读更多...
【二叉树入门指南】链式结构的实现

【二叉树入门指南】链式结构的实现

【二叉树入门指南】链式结构的实现 一、前置说明二、二叉树的遍历2.1前序遍历2.2中序遍历2.3 后序遍历 三、以前序遍历为例&#xff0c;递归图解四、层序遍历五、节点个数以及高度等5.1 二叉树节点个数5.2二叉树叶子节点个数5.3 二叉树第k层节点个数5.4 二叉树查找值为x的节点5…
阅读更多...
顺序表之初

顺序表之初

欢迎来到我的&#xff1a;世界 希望作者的文章对你有所帮助&#xff0c;有不足的地方还请指正&#xff0c;大家一起学习交流 ! 目录 线性表简介顺序表定义动态顺序表的初始化尾插头插Cheak 判断是否增容尾删&#xff1a;头删&#xff1a;打印在pos位置前插入x删除pos位置的值查…
阅读更多...
链表常考操作总结

链表常考操作总结

链表常考操作总结&#xff1a; 遍历链表一般是去更新cur 即cur cur.next 返回链表长度 public int getLength(ListNode head){int len 0;while(head ! null){head head.next;len;}return len;}快慢指针 定义&#xff1a; 当快指针移到终点时&#xff0c;此时慢指针恰好移…
阅读更多...
数据结构例题代码及其讲解-链表

数据结构例题代码及其讲解-链表

链表 单链表的结构体定义及其初始化。 typedef struct LNode {int data;struct LNode* next; }LNode, *LinkList;①强调结点 LNode *p; ②强调链表 LinkList p; //初始化 LNode* initList() {//定义头结点LNode* L (LNode*)malloc(sizeof(LNode));L->next NULL;return …
阅读更多...
leetcode算法题--复杂链表的复制

leetcode算法题--复杂链表的复制

原题链接&#xff1a;https://leetcode.cn/problems/fu-za-lian-biao-de-fu-zhi-lcof/description/?envTypestudy-plan-v2&envIdcoding-interviews 感觉一开始想到的办法还是比较笨 /*** Definition for a Node.* type Node struct {* Val int* Next *Node* …
阅读更多...
代码随想录训练营二刷第四天 | 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 ● 142.环形链表II

代码随想录训练营二刷第四天 | 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 ● 142.环形链表II

代码随想录训练营二刷第四天 | 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 ● 142.环形链表II 一、24. 两两交换链表中的节点 题目链接&#xff1a;https://leetcode.cn/problems/swap-nodes-in-pairs/ 思路&#xff1a;使用头结点然后画图…
阅读更多...
JZ36 二叉搜索树与双向链表

JZ36 二叉搜索树与双向链表

题目来源&#xff1a;牛客网 题目描述&#xff1a; 输入一棵二叉搜索树&#xff0c;将该二叉搜索树转换成一个排序的双向链表。如下图所示 注意: 1.要求不能创建任何新的结点&#xff0c;只能调整树中结点指针的指向。当转化完成以后&#xff0c;树中节点的左指针需要指向前驱…
阅读更多...
(纯c)数据结构之------＞链表(详解)

(纯c)数据结构之------＞链表(详解)

目录 一. 链表的定义 1.链表的结构. 2.为啥要存在链表及链表的优势. 二. 无头单向链表的常用接口 1.头插\尾插 2.头删\尾删 3.销毁链表/打印链表 4.在pos位置后插入一个值 5.消除pos位置后的值 6.查找链表中的值并且返回它的地址 7.创建一个动态开辟的结点 三.顺序表与链表…
阅读更多...
【LeetCode-中等题】19. 删除链表的倒数第 N 个结点

【LeetCode-中等题】19. 删除链表的倒数第 N 个结点

文章目录 题目方法一&#xff1a;节点加入集合找索引方法二&#xff1a;直接计算长度,然后找出要删除的节点的前一个节点方法三&#xff1a;栈方法四&#xff1a;前后双指针 题目 这题的关键在与两个点 一定要设置一个哑结点&#xff0c;防止删除第一个元素时&#xff0c;导致空…
阅读更多...
数据结构：八种数据结构大全

数据结构：八种数据结构大全

数据结构 1.1 数据结构概述 数据结构是计算机存储、组织数据的方式&#xff1b;通常情况下&#xff0c;精心选择的数据结构可以带来更高的运行或者存储效率。数据结构的优良将直接影响着我们程序的性能&#xff1b;常用的数据结构有&#xff1a;数组&#xff08;Array&#xff…
阅读更多...
【leetcode 力扣刷题】移除链表元素 多种解法

【leetcode 力扣刷题】移除链表元素 多种解法

移除链表元素的多种解法 203. 移除链表元素解法①&#xff1a;头节点单独判断解法②&#xff1a;虚拟头节点解法③&#xff1a;递归 203. 移除链表元素 题目链接&#xff1a;203.移除链表元素 题目内容&#xff1a; 理解题意&#xff1a;就是单纯的删除链表中所有值等于给定的…
阅读更多...
顺序表链表OJ题(2)-＞【数据结构】

顺序表链表OJ题(2)-＞【数据结构】

W...Y的主页 &#x1f60a; 代码仓库分享 &#x1f495; 前言&#xff1a; 单链表的结构常常不完美&#xff0c;没有双向链表那么”优秀“&#xff0c;所以繁衍出很多OJ练习题。今天我们继续来look look数据结构习题。 下面就是OJ时间&#xff01;&#xff01;&#xff01; …
阅读更多...
【数据结构大全】你想要的都有，数组、链表、堆栈、二叉树、红黑树、B树、图......

【数据结构大全】你想要的都有，数组、链表、堆栈、二叉树、红黑树、B树、图......

目录 1.概述 2.线性结构 3.时间复杂度 4.查找算法 5.树 6.图 1.概述 博主之前写过一个完整的关于数据结构的系列文章&#xff0c;一共十三篇&#xff0c;内容包含&#xff0c;数组、链表、堆栈、队列、时间复杂度、顺序查找、二分查找、二叉树、二叉搜索树、平衡二叉树、…
阅读更多...
【LeetCode-中等题】98. 验证二叉搜索树

【LeetCode-中等题】98. 验证二叉搜索树

文章目录 题目方法一&#xff1a;BFS 层序遍历方法二&#xff1a; 题目 方法一&#xff1a;BFS 层序遍历 利用层序遍历 拿到每一个节点 并且给每一个结点配备一个最大值和最小值的队列 只要节点在最大值和最小值之间就满足二叉搜索树的条件 public boolean isValidBST(TreeNo…
阅读更多...
234. 回文链表

234. 回文链表

234. 回文链表 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* L…
阅读更多...
【数据结构】实现带头双向循环链表

【数据结构】实现带头双向循环链表

目录 前言&#xff1a;一、介绍带头双向循环链表1.带头双向循环链表的结构2.带头双向循环链表的功能 二、实现带头双向循环链表1.创建节点的结构2.函数的声明2.函数的实现&#xff08;1&#xff09;创建一个新节点&#xff08;2&#xff09;初始化哨兵位&#xff08;带头&#…
阅读更多...
【数据结构】十字链表的画法

【数据结构】十字链表的画法

十字链表的基本概念 有向边又称为弧 假设顶点 v 指向 w&#xff0c;那么 w 称为弧头&#xff0c;v 称为弧尾 顶点节点采用顺序存储 顶点节点 data&#xff1a;存放顶点的信息firstin&#xff1a;指向以该节点为终点&#xff08;弧头&#xff09;的弧节点firstout&#xff1…
阅读更多...
每日一题（反转链表）

每日一题（反转链表）

每日一题&#xff08;反转链表&#xff09; 206. 反转链表 - 力扣&#xff08;LeetCode&#xff09; 思路&#xff1a; 可以定义一个新的newhead结构体指针。再定义cur指针和next指针互相配合&#xff0c;将原链表中的节点从头到尾依次头插到newhead链表中&#xff0c;同时更…
阅读更多...
数据结构系列学习之用队列实现栈功能与用栈实现队列功能

数据结构系列学习之用队列实现栈功能与用栈实现队列功能

队列与栈&#xff1a;队列&#xff08;Queue&#xff09;是一种先进先出&#xff08;FIFO&#xff09;的线性表&#xff1b;栈&#xff08;Stack&#xff09;是一种后进先出&#xff08;LIFO&#xff09;的线性表&#xff1b;实例1&#xff1a;用队列实现栈的功能&#xff1b;算…
阅读更多...
【LeetCode-中等题】230. 二叉搜索树中第K小的元素

【LeetCode-中等题】230. 二叉搜索树中第K小的元素

文章目录 题目方法一&#xff1a;层序遍历 集合排序方法二&#xff1a;中序遍历&#xff08;栈 或者 递归 &#xff09;方法三&#xff08;方法二改进&#xff09;&#xff1a;中序遍历&#xff08;栈 &#xff09; 题目 该题最大的特点就是这个树是二叉树&#xff1a; 所以…
阅读更多...
基于AQS+双向链表实现队列先进先出

基于AQS+双向链表实现队列先进先出

学习AQS写的一个模拟案例 package com.tom.xiangyun.ch04_aqs;import com.tom.tuling.UnsafeFactory; import sun.misc.Unsafe;import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.locks.ReentrantLock;/*** 使用双向链表实现队列** author 钟棋…
阅读更多...
数据结构，队列，顺序表队列，链表队列

数据结构，队列，顺序表队列，链表队列

队列是一种常见的数据结构&#xff0c;它具有先进先出&#xff08;First-In-First-Out&#xff0c;FIFO&#xff09;的特性&#xff0c;类似于排队等候的场景。以下是队列的要点&#xff1a; 1. 定义&#xff1a;队列是一种线性数据结构&#xff0c;由一系列元素组成&#xff…
阅读更多...
《剑指Offer》链表题大全 9道题【9道经典链表题帮助你掌握链表】

《剑指Offer》链表题大全 9道题【9道经典链表题帮助你掌握链表】

《剑指Offer》链表题大全 9道题 链表1. 从尾到头打印链表本题考点栈 2. 在O(1)时间删除链表结点3. 删除链表中重复的节点总结&#xff1a;删除节点的两种方法1. a-》b 直接让a的值等于b的值&#xff0c;a的next等于b的next2. a-》b-》c 让a的next指向c&#xff08;只有修改next…
阅读更多...
相交链表00

相交链表00

题目链接 相交链表 题目描述 注意点 保证 整个链式结构中不存在环函数返回结果后&#xff0c;链表必须 保持其原始结构如果 listA 和 listB 没有交点&#xff0c;intersectVal 为 0 解答思路 两个链表从头开始遍历&#xff0c;如果其是在同一个位置处相交&#xff0c;则在…
阅读更多...
【leetcode 力扣刷题】双指针//哈希表 解决链表有环等问题

【leetcode 力扣刷题】双指针//哈希表 解决链表有环等问题

双指针//哈希表 解决链表有环等问题 19. 删除链表的倒数第N个结点遍历两次&#xff0c;先求得链表长度&#xff0c;再删除双指针&#xff0c;只遍历一次 141. 环形链表哈希表快慢双指针 142. 环形链表Ⅱ哈希表双指针 面试题02.07. 链表相交哈希表双指针思路Ⅰ思路Ⅱ 19. 删除链…
阅读更多...
探索链表：数据结构的精妙之处

探索链表：数据结构的精妙之处

前言 在计算机科学中&#xff0c;数据结构是构建和组织数据的基础&#xff0c;它们是解决复杂问题的关键。然而&#xff0c;在众多数据结构中&#xff0c;链表&#xff08;Linked List&#xff09;因其独特的特点和广泛的应用而备受关注。本文将带您深入探讨链表的概念、种类、…
阅读更多...
数据结构——栈和队列OJ题

数据结构——栈和队列OJ题

栈和队列小提升&#xff01; 前言一、用队列实现栈队列接口实现&#xff08;1&#xff09;栈的接口定义&#xff08;2&#xff09;栈的初始化&#xff08;3&#xff09;入栈函数的定义&#xff08;4&#xff09;出栈函数的定义&#xff08;5&#xff09;查找栈顶元素&#xff0…
阅读更多...
linux -- 链表

linux -- 链表

.与->的区别&#xff1a; 点“.”一般读作“的”&#xff0c;其前面是结构体。 ->读作“指向结构体的”&#xff0c;其前面一定是一个指向结构体的指针 链表概念 什么是链表–数据结构&#xff0c;是数据存放的思想&#xff0c;是一个集合 数组特点&#xff1a;元素地址…
阅读更多...
数据结构入门 — 链表详解_单链表

数据结构入门 — 链表详解_单链表

前言 数据结构入门 — 单链表详解* 博客主页链接&#xff1a;https://blog.csdn.net/m0_74014525 关注博主&#xff0c;后期持续更新系列文章 文章末尾有源码 *****感谢观看&#xff0c;希望对你有所帮助***** 系列文章 第一篇&#xff1a;数据结构入门 — 链表详解_单链表 第…
阅读更多...
【数据结构】C语言队列(详解)

【数据结构】C语言队列(详解)

前言: &#x1f4a5;&#x1f388;个人主页:​​​​​​Dream_Chaser&#xff5e; &#x1f388;&#x1f4a5; ✨✨专栏:http://t.csdn.cn/oXkBa ⛳⛳本篇内容:c语言数据结构--C语言实现队列 目录 一.队列概念及结构 1.1队列的概念 1.2队列的结构 二.队列的实现 2.1头文…
阅读更多...
【牛客网题目】合并两个排序的链表

【牛客网题目】合并两个排序的链表

目录 描述 题目分析 描述 输入两个递增的链表&#xff0c;单个链表的长度为n&#xff0c;合并这两个链表并使新链表中的节点仍然是递增排序的。 数据范围&#xff1a;0≤n≤1000&#xff0c;1000≤节点值≤1000 要求&#xff1a;空间复杂度 O(1)&#xff0c;时间复杂…
阅读更多...
数据结构学习系列之单向链表的三种插入方式

数据结构学习系列之单向链表的三种插入方式

方式1&#xff1a;在单向链表的头结点和第0个结点之间插入新结点&#xff0c;即头插法&#xff0c;代码如下&#xff1a;示例代码&#xff1a; int insert_link_list_1(node_t *phead,int data){if(NULL phead){printf("入参为NULL\n");return -1;}//创建新结点nod…
阅读更多...
单向链表和双向链表的增删改查以及排序问题

单向链表和双向链表的增删改查以及排序问题

文章目录 单向链表双向链表运行结果完整代码 本文介绍链表的增删改查以及排序问题&#xff0c;其中最重要的还是指针的使用&#xff01; 单向链表 定义一个单向链表&#xff0c;里面包含一个整型数据和一个指向后向的指针。 typedef struct linklist{int data;struct linkli…
阅读更多...
线性表之-单向链表(无头)

线性表之-单向链表(无头)

目录 什么是单向链表 顺序表和链表的区别和联系 顺序表&#xff1a; 链表&#xff1a; 链表表示(单项)和实现 1.1 链表的概念及结构 1.2单链表(无头)的实现 所用文件 将有以下功能&#xff1a; 链表定义 创建新链表元素 尾插 头插 尾删 头删 查找-给一个节点的…
阅读更多...
华为OD机试 - 关联子串 - 滑动窗口（Java 2023 B卷 100分）

华为OD机试 - 关联子串 - 滑动窗口（Java 2023 B卷 100分）

目录 专栏导读一、题目描述二、输入描述三、输出描述四、解题思路五、Java算法源码六、效果展示1、输入2、输出3、说明4、换个思路 华为OD机试 2023B卷题库疯狂收录中&#xff0c;刷题点这里 专栏导读 本专栏收录于《华为OD机试&#xff08;JAVA&#xff09;真题&#xff08;A…
阅读更多...
【数据结构】C++代码定义了一个动态数组（Vector）的数据结构，并实现了一些基本的操作，包括插入、删除、扩容和输出。

【数据结构】C++代码定义了一个动态数组（Vector）的数据结构，并实现了一些基本的操作，包括插入、删除、扩容和输出。

// 引入输入输出流库&#xff0c;用于在程序中输入和输出数据 #include <iostream> // 引入标准库函数库&#xff0c;提供rand()函数和srand()函数&#xff0c;用于生成随机数 #include <cstdlib> // 引入随机数生成函数库&#xff0c;提供time()函数&#x…
阅读更多...
王道书链表题目--有一个带头节点的单链表L，使其元素递增有序

王道书链表题目--有一个带头节点的单链表L，使其元素递增有序

答案的方法是使用头插法&#xff0c;我第一遍看的时候有点绕。补充的答案是将链表复制到一个数组中&#xff0c;再用时间复杂度为O&#xff08;nlogn&#xff09;的排序算法进行排序&#xff0c;这个很容易理解。 在此&#xff0c;我想记录一下自己写这个题目的方法。 思路 我…
阅读更多...
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 线性表 —— 链式描述 —— 应用

《数据结构、算法与应用 —— C++语言描述》学习笔记 — 线性表 —— 链式描述 —— 应用

这里写目录标题一、箱子排序1、学生记录结构2、实现3、作为链表模板类方法实现二、基数排序1、基数排序的原理2、实现3、代码测试&#xff1a;三、凸包问题1、算法2、实现&#xff08;1&#xff09;头文件及点的定义&#xff08;2&#xff09;判断是否共线并返回不共线的点&…
阅读更多...
剑指offer 06. 从尾到头打印链表

剑指offer 06. 从尾到头打印链表

剑指 Offer 06. 从尾到头打印链表 - 力扣&#xff08;LeetCode&#xff09; (leetcode-cn.com) 目录 方案1 运行结果 代码 方案2 运行结果 代码 方案1 遍历一遍链表&#xff0c;把所有元素按正序放进一个数组里面&#xff0c;并得出栈的元素个数&#xff0c;此时再将数…
阅读更多...
数据结构笔记（一）--------单链表的两种实现方式

数据结构笔记（一）--------单链表的两种实现方式

链表常见的定义与原理&#xff0c;这里不再赘述&#xff0c;不懂的可以去自己搜搜&#xff0c;这里主要记录常见的两种链表的实现方式&#xff0c;也就是动态链表与静态链表。 一、动态链表与静态链表 动态链表就是我们常见的用结构体实现的链表&#xff0c;因为结构体的内存…
阅读更多...
数据结构-----链表

数据结构-----链表

单链表 每个节点不仅包含数据结构&#xff0c;还包含链接到下一个结点的指针。通过这种方式&#xff0c;单链表可将所有结点有序组织起来。比如下面这样的例子&#xff08;每个结点存了个int型数据&#xff0c;然后有指向下一个结点的指针&#xff09;单链表的实现&#xff1a;…
阅读更多...
leetcode 141.环形链表(快慢指针追击问题)

leetcode 141.环形链表(快慢指针追击问题)

⭐️ 往期相关文章 &#x1f4ab;链接1&#xff1a;链表分割 &#x1f4ab;链接2&#xff1a;链表中倒数第k个结点(快慢指针问题) &#x1f4ab;链接3&#xff1a;leetcode 876.链表的中间结点(快慢指针问题) &#x1f4ab;链接4&#xff1a;leetcode 206.反转链表 &#x1f4…
阅读更多...
链表的应用：单元多项式的加法、减法、乘法

链表的应用：单元多项式的加法、减法、乘法

使用链表来实现单元多项式的加法、减法、乘法。一个单元多项式的节点结构无非是这样的&#xff1a;系数域、指数域、链域。 如下图&#xff1a; 我们使用链表来模拟单元多项式的常见运算。其中&#xff0c;加法是其它运算的基础&#xff0c;减法&#xff1a;poly1-poly2poly1(…
阅读更多...
单链表，单循环链表，约瑟夫问题

单链表，单循环链表，约瑟夫问题

线性表 线性表中的线性一词说的是一种逻辑结构&#xff0c;它表示除了首尾节点外&#xff0c;其它节点都只有一个前驱和一个后继&#xff0c;这是一对一的关系。要想实现线性表得考虑它的物理结构&#xff0c;即选用何种存储结构。线性表主要有两种存储结构&#xff1a; 1.顺序…
阅读更多...
c语言制作的学生成绩管理系统 加链表

c语言制作的学生成绩管理系统 加链表

原文地址为&#xff1a; c语言制作的学生成绩管理系统 加链表/*--------------------data.txt文件是存储学生成绩信息的文件---------------------------*//*--------------------time.txt文件是存储备份时间的文件-------------------------------*//*--------------------备份…
阅读更多...
【数据结构OJ题】环形链表

【数据结构OJ题】环形链表

原题链接&#xff1a;https://leetcode.cn/problems/linked-list-cycle/description/ 1. 题目描述 2. 思路分析 整体思路&#xff1a;定义快慢指针fast&#xff0c;slow&#xff0c;如果链表确实有环&#xff0c;fast指针一定会在环内追上slow指针。 即慢指针一次走一步&…
阅读更多...
【数据结构与算法】使用数组及链表 实现队列

【数据结构与算法】使用数组及链表 实现队列

Java编码: 使用数组及链表实现队列的数据结构 队列作为一种简单的数据结构&#xff0c;实现方式多种多样&#xff0c;即使只使用数组&#xff0c;不同的人的实现方式也不尽相同&#xff0c;关键在于对其结构的理解。 在这里我使用数组及链表两种方式来实现队列。 队列的具体操…
阅读更多...
算法通关村-----如何基于数组和链表实现栈

算法通关村-----如何基于数组和链表实现栈

实现栈的基本方法 push(T t)元素入栈 T pop() 元素出栈 Tpeek() 查看栈顶元素 boolean isEmpty() 栈是否为空 基于数组实现栈 import java.util.Arrays;public class ArrayStack<T> {private Object[] stack;private int top;public ArrayStack() {this.stack new…
阅读更多...
数据结构之手写单链表(数组)(Java)

数据结构之手写单链表(数组)(Java)

import java.util.*; import java.io.*;class Main {static int[] e new int[100010];// 存储值static int[] ne new int[100010];// 存储下一个节点的地址&#xff0c;充当指针static int head -1;// head&#xff1a;表示头节点的下标&#xff0c;NULL表示为-1&#xff08…
阅读更多...
数据结构速通-重点知识点回顾

数据结构速通-重点知识点回顾

数据结构 数据结构的定义 数据结构作为计算机的一门学科&#xff0c;主要研究和讨论以下三个方面&#xff1a; 数据集合中各数据元素之间所固有的逻辑关系&#xff0c;即数据的逻辑结构在对数据元素进行处理时&#xff0c;各数据元素在计算机中的存储关系&#xff0c;即数据…
阅读更多...
链表形式队列

链表形式队列

&#x1f308;队列相关概念 1.储存了数据的节点从一端&#xff08;队尾&#xff09;进入队列&#xff08;入队尾插&#xff09;&#xff0c;从另一端&#xff08;队头&#xff09;出队列&#xff08;出队头删&#xff09;&#xff0c;先进先出。进行插入操作的一端称为队尾&am…
阅读更多...
【经典专题】链表的归并排序——经典的cut/merge模板

【经典专题】链表的归并排序——经典的cut/merge模板

input&#xff1a;4 → 3 → 1 → 7 → 8 → 9 → 2 → 11 → 5 → 6 output&#xff1a;1 → 2 → 3 → 4 → 5 → 6 → 7 → 8 → 9 → 11 核心知识点 链表的截断&#xff08;cut&#xff09;链表的二路归并&#xff08;merge&#xff09;虚拟头节点(dummyHead)&#xff0…
阅读更多...
链表原地逆序

链表原地逆序

链表原地逆序题目信息前置代码测试样例解答题目信息 请编写函数 void inverse( LinkList )&#xff0c;实现单链表的原地置逆。 即利用原来的结点将线性表&#xff1a;L &#xff08;a1, a2, …… , an&#xff09; 变换为&#xff1a;L &#xff08; an, …… , a2, a1&#…
阅读更多...
单词压缩存储

单词压缩存储

单词压缩存储题目信息解答题目信息 如果采用单链表保存单词&#xff0c;可采用如下办法压缩存储空间。如果两个单词的后缀相同&#xff0c;则可以用同一个存储空间保存相同的后缀。例如&#xff0c;原来分别采用单链表保存的单词Str1“loading”和单词Str2“being”&#xff0…
阅读更多...
求循环节·链表

求循环节·链表

求循环节题目信息输入输出要求前置代码解答题目信息 对于任意的真分数 N/M &#xff08; 0 < N < M &#xff09;&#xff0c;均可以求出对应的小数。如果采用链表存储各位小数&#xff0c;对于循环节采用循环链表表示&#xff0c;则所有分数均可以表示为如下链表形式 …
阅读更多...
链表的部分OJ题目

链表的部分OJ题目

链表的部分OJ题目移除链表元素反转链表链表的中间结点链表中倒数第K个结点合并两个有序链表链表分割删除链表中重复结点相交链表链表的回文结构环形链表环形链表2移除链表元素 LeetCode-203 移除链表元素 203. 移除链表元素 给你一个链表的头节点 head 和一个整数 val &#x…
阅读更多...
初识链表

初识链表

链表链表的原理链表实现用引用和对象的知识理解链表具体实现结点的定义链表的创建链表的遍历遍历每个元素和计算链表中元素个数找到最后一个结点找到倒数第二个结点找到第n个结点找到链表中是否包含某个元素链表的插入和删除给定前驱结点后的插入给定前驱结点后的删除头插头删尾…
阅读更多...
数据结构 | 双向链表

数据结构 | 双向链表

一、数据结构定义 /* 链表结点 */ typedef int ListType; typedef struct node {ListType data; // 存放整型数据struct node* llink, * rlink; // 指向前驱和后继结点的指针 } *Node;/* 双向链表头结点 */ typedef struct headNode {struct node* head, * tail; // 指向双向链…
阅读更多...
leetcode 相交链表

leetcode 相交链表

160. 相交链表 哈希表 func getIntersectionNode(headA, headB *ListNode) *ListNode {hmap : make(map[*ListNode]struct{})for headA ! nil {hmap[headA] struct{}{}headA headA.Next}for headB ! nil {if _,ok : hmap[headB]; ok {return headB}headB headB.Next}retur…
阅读更多...
LintCode 带环链表

LintCode 带环链表

给定一个链表&#xff0c;判断它是否有环。 参考了网上一些资料&#xff0c;算是一个总结。 感谢sunflower_Yolanda的文章。 由这个问题可以引申出来几个问题&#xff0c;先解决本身。 1.判断是否有环。 利用两个指针slow、fast。初始时&#xff0c;两个指针都在表头。slo…
阅读更多...
动态内存分配之循环首次适应算法

动态内存分配之循环首次适应算法

首先说明一下&#xff0c;这个程序可能还有隐藏的问题&#xff0c;但是我懒得改了。 对于此程序&#xff0c;有几点需要说明&#xff1a; 1.已分配区和空闲区是分别表示的 2.采用的是单向链表 3.采用了尾指针tail&#xff0c;单纯的用来指向尾空闲区域 4.写了3天&#xff…
阅读更多...
【leetcode】206.反转链表

【leetcode】206.反转链表

问题描述&#xff1a;给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 解决方法&#xff1a;双指针第一步设置虚拟头节点&#xff0c;防止头节点丢失设置一个pre和temp指针 # Definition for singly-linked list. # class ListNode: # …
阅读更多...
C++vector容器erase和remove_if使用删除元素

C++vector容器erase和remove_if使用删除元素

vector中erase和remove_if的配合使用eraseremove_if使用代码c20中的erase_iferase >>vector容器函数汇总>>erase(); remove_if void remove_if( UnPred pr ); //remove_if()以一元谓词pr为判断元素的依据&#xff0c;遍历整个链表。如果pr返回true则删除该元素。…
阅读更多...
循环链表连接两个单链表 数据结构 C语言版

循环链表连接两个单链表 数据结构 C语言版

循环链表连接两个单链表1.代码实现2.循环链表基本操作说明3.单链表基本操作说明1.代码实现 CLinkList Connect(LinkList &La,LinkList &Lb){ //传递两个单链表头结点LinkList p La;LinkList q Lb;while(p->next!La)p p->next; //将p移动到La表尾while(q->…
阅读更多...
leetcode_206(链表反转)

leetcode_206(链表反转)

一、题目大意 反转一个单链表&#xff0c;实现递归和非递归两种形式 二、链表节点 public class ListNode {int val;ListNode next;public ListNode(int val) {this.val val;} } 三&#xff0c;分析 1&#xff0c;非递归解决方案&#xff1a;最容易想到的是使用三个指针&…
阅读更多...
数据结构：单向链表及其基本操作

数据结构：单向链表及其基本操作

1. 单向链表介绍 链表的定义&#xff1a;是一种物理存储结构上非连续、非顺序的存储结构&#xff0c;数据元素&#xff08;结点&#xff09;的逻辑顺序是通过链表中的指针链接次序实现的。 注&#xff1a;结点包含两个域&#xff1a;数据域和指针域&#xff1b;链表的特点&…
阅读更多...
【C语言】手动实现顺序表、链表(单、单循环、双循环)！！！！附详细代码及注释

【C语言】手动实现顺序表、链表(单、单循环、双循环)！！！！附详细代码及注释

这篇博客主要是对顺序表和带头节点链表的实现(单链表、单循环链表、双循环链表)。 目录一、顺序表&#xff1a;二、单链表&#xff1a;三、单循环链表&#xff1a;四、双循环链表&#xff1a;不带头节点的链表最后面也会附上代码链接。一、顺序表&#xff1a; 顺序表是使用一块…
阅读更多...
循环链表Java数据结构篇（即约瑟夫环问题）

循环链表Java数据结构篇（即约瑟夫环问题）

本章学习目录 问题的引出&#xff1a;17世纪的法国数学家加斯帕在《数目的游戏问题》中讲了这样一个故事&#xff1a;15个教徒和15 个非教徒在深海上遇险&#xff0c;必须将一半的人投入海中&#xff0c;其余的人才能幸免于难&#xff0c;于是想了一个办法&#xff1a;30个人围…
阅读更多...
C++/C 超市管理系统，结构体链表，文件读入/读出，排序，搜索等功能，流程图

C++/C 超市管理系统，结构体链表，文件读入/读出，排序，搜索等功能，流程图

C/C 超市管理系统&#xff0c;结构体链表&#xff0c;文件读入/读出&#xff0c;排序&#xff0c;搜索等功能&#xff0c;流程图 运行截图如下 功能函数如下: int Menu(void); //创建菜单 void AddGoods(goods *head); //添加商品 void updateG…
阅读更多...
刷题笔记----每日一题：力扣234. 回文链表

刷题笔记----每日一题：力扣234. 回文链表

234 思路一&#xff1a;利用双指针技巧找到链表中点&#xff0c;将后半段链表反转&#xff0c;然后与前半段链表比较。这些技巧也是之前我们用到过的。 class Solution { public:bool isPalindrome(ListNode* head) {ListNode *head1 mid(head);head1 head1->next;ListNo…
阅读更多...
Redis底层数据结构 ------＞ quicklist

Redis底层数据结构 ------＞ quicklist

之前的文章我曾总结到了Redis数据结构一链表和Redis数据结构一压缩列表这两种数据结构&#xff0c;他们是Redis List(列表)对象的底层实现方式。 但是考虑到艇表的附加空间相对太高,prev和next 指针就要占去 16个字节(64bit 系统的指针是8个字节)&#xff0c;另外每个节点的内…
阅读更多...
面试热题（合并K个升序链表）

面试热题（合并K个升序链表）

给定一个链表数组&#xff0c;每个链表都已经按升序排列。 请将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 输入&#xff1a;lists [[1,4,5],[1,3,4],[2,6]] 输出&#xff1a;[1,1,2,3,4,4,5,6] 解释&#xff1a;链表数组如下&#xff1a; [1->4->5,1…
阅读更多...
判断链表有环的证明

判断链表有环的证明

目录 1.问题 2.证明 3.代码实现 1.问题 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用…
阅读更多...
校招笔试，关于链表和二叉树以及图的读取处理，ACM模式

校招笔试，关于链表和二叉树以及图的读取处理，ACM模式

校招笔试链表acm模式&#xff0c;写好之后把head传给对应的方法即可&#xff0c;就可以自己实现acm的链表翻转&#xff0c;链表排序等等啦。 #define _CRT_SECURE_NO_WARNINGS 1 #include<iostream> #include<vector>using namespace std;struct LinkNode {int _v…
阅读更多...
【数据结构OJ题】反转链表

【数据结构OJ题】反转链表

原题链接&#xff1a;https://leetcode.cn/problems/reverse-linked-list/description/ 目录 1. 题目描述 2. 思路分析 3. 代码实现 1. 题目描述 2. 思路分析 方法一&#xff1a;三指针翻转法 使用三个结构体指针n1&#xff0c;n2&#xff0c;n3&#xff0c;原地修改结点…
阅读更多...
leetcode做题笔记83删除排序链表中的重复元素

leetcode做题笔记83删除排序链表中的重复元素

给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的链表 。 输入&#xff1a;head [1,1,2] 输出&#xff1a;[1,2] 思路一&#xff1a;模拟题意 struct ListNode* deleteDuplicates(struct ListNode* head){i…
阅读更多...
【数据结构OJ题】合并两个有序链表

【数据结构OJ题】合并两个有序链表

原题链接&#xff1a;https://leetcode.cn/problems/merge-two-sorted-lists/description/ 目录 1. 题目描述 2. 思路分析 3. 代码实现 1. 题目描述 2. 思路分析 可以先创建一个空链表&#xff0c;然后依次从两个有序链表中选取最小的进行尾插操作。&#xff08;有点类似双…
阅读更多...
【算法练习】4种反转链表的方法（Java实现）

【算法练习】4种反转链表的方法（Java实现）

目录 前言&#xff1a; 题目&#xff1a; 方法一&#xff1a;迭代法 方法二&#xff1a;头插法 方法三&#xff1a;递归法 方法四&#xff1a;栈辅助 总结&#xff1a; 前言&#xff1a; 本文阅读基础&#xff1a;有一定的数据结构知识&#xff0c;了解单向链表。 题目&…
阅读更多...
拒绝摆烂！C语言练习打卡第三天

拒绝摆烂！C语言练习打卡第三天

&#x1f525;博客主页&#xff1a;小王又困了 &#x1f4da;系列专栏&#xff1a;每日一练 &#x1f31f;人之为学&#xff0c;不日近则日退 ❤️感谢大家点赞&#x1f44d;收藏⭐评论✍️ 目录 一、选择题 &#x1f4dd;1.第一题 &#x1f4dd;2.第二题 &#x1f4…
阅读更多...
数据结构：二叉树的递归实现(C实现)

数据结构：二叉树的递归实现(C实现)

个人主页 &#xff1a; 个人主页 个人专栏 &#xff1a; 《数据结构》 《C语言》 文章目录 前言一、树的概念二、二叉树二叉树的概念二叉树的性质 三、二叉树链式结构实现二叉树节点定义创建二叉树节点遍历二叉树先序遍历二叉树(BinaryTreePrevOrder)中序遍历二叉树(BinaryTree…
阅读更多...
leetcode做题笔记86分隔链表

leetcode做题笔记86分隔链表

给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你应当 保留 两个分区中每个节点的初始相对位置。 示例 1&#xff1a; 输入&#xff1a;head [1,4,3,2,5,2], x 3 输出&am…
阅读更多...
删除链表中的节点（力扣）

删除链表中的节点（力扣）

目录 题目&#xff1a; 看着花里胡哨&#xff0c;小卡拉米四行代码秒杀&#xff01; 示例&#xff1a; 思路&#xff1a; 代码&#xff1a; 题目&#xff1a; 看着花里胡哨&#xff0c;小卡拉米四行代码秒杀&#xff01; 示例&#xff1a; 思路&#xff1a; 把后一个节点的…
阅读更多...
数据结构学习系列之单向链表的清空与销毁

数据结构学习系列之单向链表的清空与销毁

单向链表的清空&#xff1a;所谓的清空&#xff0c;就是清空除了头结点之外的所有结点的数据域和指针域&#xff0c;区别于顺序表的清空&#xff0c;代码如下&#xff1a; int clean_link_list(node_t *phead){if(NULL phead){printf("入参为NULL\n");return -1;}n…
阅读更多...
LeetCode 138. Copy List with Random Pointer【链表,DFS,迭代,哈希表】中等

LeetCode 138. Copy List with Random Pointer【链表,DFS,迭代,哈希表】中等

本文属于「征服LeetCode」系列文章之一&#xff0c;这一系列正式开始于2021/08/12。由于LeetCode上部分题目有锁&#xff0c;本系列将至少持续到刷完所有无锁题之日为止&#xff1b;由于LeetCode还在不断地创建新题&#xff0c;本系列的终止日期可能是永远。在这一系列刷题文章…
阅读更多...
数据结构：单向循环链表

数据结构：单向循环链表

单向循环链表和单向链表差不多&#xff0c;只需要记录头节点的位置把单向链表判断NULL的地方改为判断头节点即可 dxxhlb.h /** 文件名称&#xff1a;dxxhlb.h* 创 建 者&#xff1a; * 创建日期&#xff1a;2023年08月26日* 描 述&#xff1a;*/ #ifndef _DXX…
阅读更多...
单向链表(c/c++)

单向链表(c/c++)

链表是一种常见的数据结构&#xff0c;其中运用到了结构体指针&#xff0c;链表可以实现动态存储分配&#xff0c;换而言之&#xff0c;链表是一个功能强大的数组&#xff0c;可以在某个节点定义多种数据类型&#xff0c;可以实现任意的添加&#xff0c;删除&#xff0c;插入节…
阅读更多...
leetcode 2. 两数相加(java)

leetcode 2. 两数相加(java)

两数相加 题目描述哨兵技巧代码演示&#xff1a; 递归算法专题 题目描述 难度 - 中等 leetcode 2. 两数相加 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&…
阅读更多...
数据结构与算法（四）：栈与队列

数据结构与算法（四）：栈与队列

栈与队列 我们一般把栈与队列合在一块讨论&#xff0c;因为他们具有相似的性质。 栈&#xff1a;栈是限定仅在表尾进行插入和删除操作的线性表&#xff0c;所以栈又称为后进先出&#xff08;LastIn First Out&#xff09;的线性表&#xff0c;简称LIFO结构。 队列&#xff1…
阅读更多...
数据结构学习系列之单向链表的查找与修改

数据结构学习系列之单向链表的查找与修改

单向链表的查找&#xff1a;根据单向链表数据结点的位置查找数据&#xff0c;代码如下&#xff1a;示例代码&#xff1a; int search_link_list(node_t *phead,int pos,int *data){if(NULL phead || NULL data){printf("入参为NULL\n");return -1;}if(NULL phead…
阅读更多...
【数据结构初阶】三、 线性表里的链表（无头+单向+非循环链表）

【数据结构初阶】三、 线性表里的链表（无头+单向+非循环链表）

相关代码gitee自取&#xff1a; C语言学习日记: 加油努力 (gitee.com) 接上期&#xff1a; 【数据结构初阶】二、 线性表里的顺序表_高高的胖子的博客-CSDN博客 引言 通过上期对顺序表的介绍和使用 我们可以知道顺序表有以下优点和缺点&#xff1a; 顺序表优点 尾插 和 尾…
阅读更多...
【LeetCode】19. 删除链表的倒数第 N 个结点

【LeetCode】19. 删除链表的倒数第 N 个结点

19. 删除链表的倒数第 N 个结点&#xff08;中等&#xff09; 方法&#xff1a;快慢指针 思路 为了找到倒数第 n 个节点&#xff0c;我们应该先找到最后一个节点&#xff0c;然后从它开始往前数 n-1 个节点就是要删除的节点。 对于一般情况&#xff1a;设置 fast 和 slow 两个…
阅读更多...
leetcode725. 分隔链表(java)

leetcode725. 分隔链表(java)

分隔链表 题目描述拆分链表代码演示 题目描述 给你一个头结点为 head 的单链表和一个整数 k &#xff0c;请你设计一个算法将链表分隔为 k 个连续的部分。 每部分的长度应该尽可能的相等&#xff1a;任意两部分的长度差距不能超过 1 。这可能会导致有些部分为 null 。 这 k 个部…
阅读更多...
第六章 图 三、图的存储结构（邻接表、十字链表、邻接多重表）

第六章 图 三、图的存储结构（邻接表、十字链表、邻接多重表）

一、邻接表法 &#xff08;1&#xff09;无向图 1.定义 与树的孩子表示法相似&#xff0c;以顺序表的数据域为头结点&#xff0c;往后存储一个单向链表&#xff0c;链表内的值表示与此结点相邻的结点。 2.度的计算 只需遍历某一结点的后接链表&#xff0c;就可以算出该节点…
阅读更多...
链表指定区间反转

链表指定区间反转

题目&#xff1a;反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。 说明: 1 ≤ m ≤ n ≤ 链表长度。 输入&#xff1a;1->2->3->4->5->NULL, m 2, n 4 输出&#xff1a;1->4->3->2->5->NULL 头插法 Java实现 public static ListNode rev…
阅读更多...
LeetCode 725. Split Linked List in Parts【链表】中等

LeetCode 725. Split Linked List in Parts【链表】中等

本文属于「征服LeetCode」系列文章之一&#xff0c;这一系列正式开始于2021/08/12。由于LeetCode上部分题目有锁&#xff0c;本系列将至少持续到刷完所有无锁题之日为止&#xff1b;由于LeetCode还在不断地创建新题&#xff0c;本系列的终止日期可能是永远。在这一系列刷题文章…
阅读更多...
LeetCode 92. Reverse Linked List II【链表,头插法】中等

LeetCode 92. Reverse Linked List II【链表,头插法】中等

本文属于「征服LeetCode」系列文章之一&#xff0c;这一系列正式开始于2021/08/12。由于LeetCode上部分题目有锁&#xff0c;本系列将至少持续到刷完所有无锁题之日为止&#xff1b;由于LeetCode还在不断地创建新题&#xff0c;本系列的终止日期可能是永远。在这一系列刷题文章…
阅读更多...
【校招VIP】前端算法考察之链表算法

【校招VIP】前端算法考察之链表算法

考点介绍&#xff1a; 链表是一种物理存储结构上非连续的数据结构,数据的逻辑顺序是通过链表中的指针链接次序实现相互勾连。链表相对数组而言有很多不同之处,在特定场景下能发挥独特的优势。例如链表的插入和删除操作比数组效率高,数组需要改变其他元素的位置,而链表只需要改变…
阅读更多...
第 2 章 线性表 （线性表的静态单链表存储结构（一个数组只生成一个静态链表）实现）

第 2 章 线性表 （线性表的静态单链表存储结构（一个数组只生成一个静态链表）实现）

1. 背景说明 A { c, b, e, g, f, d }B { a, b, n, f } 2. 示例代码 1) status.h /* DataStructure 预定义常量和类型头文件 */#ifndef STATUS_H #define STATUS_H#define CHECK_RET(ret) if (ret ! RET_OK) { \printf("FuncName: %-15s Line: %-5d ErrorCode: %-3d\n&…
阅读更多...
【笔试强训选择题】Day34.习题（错题）解析

【笔试强训选择题】Day34.习题（错题）解析

作者简介&#xff1a;大家好&#xff0c;我是未央&#xff1b; 博客首页&#xff1a;未央.303 系列专栏&#xff1a;笔试强训选择题 每日一句&#xff1a;人的一生&#xff0c;可以有所作为的时机只有一次&#xff0c;那就是现在&#xff01;&#xff01;&#xff01;&#xff…
阅读更多...
leetcode386. 字典序排数(java)

leetcode386. 字典序排数(java)

字典序排数 题目描述递归法迭代 题目描述 难度 - 中等 leetcode386. 字典序排数 给你一个整数 n &#xff0c;按字典序返回范围 [1, n] 内所有整数。 你必须设计一个时间复杂度为 O(n) 且使用 O(1) 额外空间的算法。 示例 1&#xff1a; 输入&#xff1a;n 13 输出&#xff1a…
阅读更多...
C/C++之链表的建立

C/C++之链表的建立

个人主页&#xff1a;点我进入主页 专栏分类&#xff1a;C语言初阶 C语言程序设计————KTV C语言小游戏 C语言进阶 C语言刷题 欢迎大家点赞&#xff0c;评论&#xff0c;收藏。 一起努力&#xff0c;一起奔赴大厂。 目录 1.头插 1.1简介 1.2代码实现头插 …
阅读更多...
数据结构：线性表之-单向链表(无头)

数据结构：线性表之-单向链表(无头)

目录 什么是单向链表 顺序表和链表的区别和联系 顺序表&#xff1a; 链表&#xff1a; 链表表示(单项)和实现 1.1 链表的概念及结构 1.2单链表(无头)的实现 所用文件 将有以下功能&#xff1a; 链表定义 创建新链表元素 尾插 头插 尾删 头删 查找-给一个节点的…
阅读更多...
【牛客面试必刷TOP101】Day3.BM10两个链表的第一个公共结点和BM13判断一个链表是否为回文结构

【牛客面试必刷TOP101】Day3.BM10两个链表的第一个公共结点和BM13判断一个链表是否为回文结构

作者简介&#xff1a;大家好&#xff0c;我是未央&#xff1b; 博客首页&#xff1a;未央.303 系列专栏&#xff1a;牛客面试必刷TOP101 每日一句&#xff1a;人的一生&#xff0c;可以有所作为的时机只有一次&#xff0c;那就是现在&#xff01;&#xff01;&#xff01;&…
阅读更多...
LeetCode147之对链表进行插入排序（相关话题：链表）

LeetCode147之对链表进行插入排序（相关话题：链表）

题目描述 给定单个链表的头 head ，使用 插入排序 对链表进行排序，并返回 排序后链表的头 。 插入排序 算法的步骤: 插入排序是迭代的，每次只移动一个元素，直到所有元素可以形成一个有序的输出列表。每次迭代中，插入排序只从输入数据中移除一个待排序的元素，找到它在序列…
阅读更多...
【算法训练-链表 六】【查找】：链表中倒数第k个节点

【算法训练-链表 六】【查找】：链表中倒数第k个节点

废话不多说&#xff0c;喊一句号子鼓励自己&#xff1a;程序员永不失业&#xff0c;程序员走向架构&#xff01;本篇Blog的主题是【查找链表】&#xff0c;使用【链表】这个基本的数据结构来实现&#xff0c;这个高频题的站点是&#xff1a;CodeTop&#xff0c;筛选条件为&…
阅读更多...
【LeetCode】35.复杂链表的复制

【LeetCode】35.复杂链表的复制

题目 请实现 copyRandomList 函数&#xff0c;复制一个复杂链表。在复杂链表中&#xff0c;每个节点除了有一个 next 指针指向下一个节点&#xff0c;还有一个 random 指针指向链表中的任意节点或者 null。 示例 1&#xff1a; 输入&#xff1a;head [[7,null],[13,0],[11,4]…
阅读更多...
(牛客网)链表相加(二)

(牛客网)链表相加(二)

嗯哼~ 题目 描述 假设链表中每一个节点的值都在 0 - 9 之间&#xff0c;那么链表整体就可以代表一个整数。 给定两个这种链表&#xff0c;请生成代表两个整数相加值的结果链表。 数据范围&#xff1a;0 ≤ n,m ≤ 1000000&#xff0c;链表任意值 0 ≤ val ≤ 9 要求&#x…
阅读更多...
【数据结构OJ题】用栈实现队列

【数据结构OJ题】用栈实现队列

原题链接&#xff1a;https://leetcode.cn/problems/implement-queue-using-stacks/ 目录 1. 题目描述 2. 思路分析 3. 代码实现 1. 题目描述 2. 思路分析 用两个栈实现&#xff0c;一个栈进行入队操作&#xff0c;另一个栈进行出队操作。 出队操作&#xff1a; 当出队的栈…
阅读更多...
【力扣刷题】两数求和、移动零、相交链表、反转链表

【力扣刷题】两数求和、移动零、相交链表、反转链表

&#x1f40c;个人主页&#xff1a; &#x1f40c; 叶落闲庭 &#x1f4a8;我的专栏&#xff1a;&#x1f4a8; c语言 数据结构 javaEE 操作系统 Redis 石可破也&#xff0c;而不可夺坚&#xff1b;丹可磨也&#xff0c;而不可夺赤。 刷题篇 一、两数之和1.1题目描述1.2思路1.3…
阅读更多...
【leetcode 力扣刷题】反转链表+递归求解

【leetcode 力扣刷题】反转链表+递归求解

反转链表递归求解 206. 反转链表解法①&#xff1a;取下一个节点在当前头节点前插入解法②&#xff1a;反转每个节点next的指向解法③&#xff1a;递归 92.反转链表Ⅱ反转left到right间节点的next指向 234.回文链表解法①&#xff1a;将链表元素存在数组中&#xff0c;在数组上…
阅读更多...
每日一题——排序链表（递归 + 迭代）

每日一题——排序链表（递归 + 迭代）

排序链表&#xff08;递归 迭代&#xff09; 题目链接 注&#xff1a;本体的解法建立在归并排序的基础之上&#xff0c;如果对这一排序还不太了解&#xff0c;建议看看&#xff1a; &#x1f449;归并排序 &#x1f449;八大排序算法详解 &#x1f449;合并两个有序链表 既…
阅读更多...
C语言链表基础

C语言链表基础

实现一个简单的链表 #include<iostream> #include<cstdio> #include<cstdlib>using namespace std;typedef struct jiaowu {long num; //学号float score; //成绩struct jiaowu *next; }Node;//创建头结点&#xff0c;赋初值为0 Node* CreateInfoNode()…
阅读更多...
在应用程序中移植linux内核链表

在应用程序中移植linux内核链表

1.链表简介 链表是一种常用的数据结构&#xff0c;它通过指针将一系列数据节点连接成一条数据链。相对于数组&#xff0c;链表具有更好的动态性&#xff0c;建立链表时无需预先知道数据总量&#xff0c;可以随机分配空间&#xff0c;可以高效地在链表中的任意位置实时插入或删…
阅读更多...
线性数据结构：数组与链表的探索与应用

线性数据结构：数组与链表的探索与应用

文章目录 1. 数组&#xff1a;连续存储的有序元素集合1.1 创建和访问数组1.2 数组的搜索与排序 2. 链表&#xff1a;非连续存储的动态数据结构2.1 单链表与双链表2.2 链表的操作与应用 3. 数组与链表的比较与应用3.1 数组与链表的比较3.2 数组与链表的应用 4. 总结与展望 &…
阅读更多...
数据结构入门 — 链表详解_双向链表

数据结构入门 — 链表详解_双向链表

前言 数据结构入门 — 双向链表详解* 博客主页链接&#xff1a;https://blog.csdn.net/m0_74014525 关注博主&#xff0c;后期持续更新系列文章 文章末尾有源码 *****感谢观看&#xff0c;希望对你有所帮助***** 系列文章 第一篇&#xff1a;数据结构入门 — 链表详解_单链表…
阅读更多...
指向任意节点的带环链表

指向任意节点的带环链表

&#x1f308;图示指向任意节点的带环链表 如图&#xff1a; &#x1f308;快慢指针法判断链表是否带环 &#x1f31f;思路&#xff1a;快指针fast一次走2步&#xff0c;慢指针slow一次走1步&#xff0c;fast先进环在换中运动&#xff0c;随后slow进入环。两指针每同时移动…
阅读更多...
【LeetCode-中等题】148. 排序链表

【LeetCode-中等题】148. 排序链表

文章目录 题目方法一&#xff1a;集合排序&#xff08;核心是内部的排序&#xff09;方法二&#xff1a; 优先队列&#xff08;核心也是内部的排序&#xff09;方法三&#xff1a;归并排序&#xff08;带递归&#xff09; 从上往下方法四&#xff1a;归并排序&#xff08;省去递…
阅读更多...
LeetCode 面试题 02.05. 链表求和

LeetCode 面试题 02.05. 链表求和

文章目录 一、题目二、C# 题解 一、题目 给定两个用链表表示的整数&#xff0c;每个节点包含一个数位。 这些数位是反向存放的&#xff0c;也就是个位排在链表首部。 编写函数对这两个整数求和&#xff0c;并用链表形式返回结果。 点击此处跳转题目。 示例&#xff1a; 输入&a…
阅读更多...
【华为OD机试python】拔河比赛【2023 B卷|100分】

【华为OD机试python】拔河比赛【2023 B卷|100分】

【华为OD机试】-真题 !!点这里！！ 【华为OD机试】真题考点分类 !!点这里 !! 题目描述 公司最近准备进行拔河比赛，需要在全部员工中进行挑选。 选拔的规则如下： 按照身高优先、体重次优先的方式准备比赛阵容； 规定参赛的队伍派出10名选手。 请实现一个选拔队员的小程序。 输…
阅读更多...
数据结构 每日一练：将带头结点的单链表就地逆置（视频讲解两种方法）

数据结构 每日一练：将带头结点的单链表就地逆置（视频讲解两种方法）

目录 方法一 算法视频分析 方法二 算法视频分析 Q&#xff1a;什么是“就地”捏&#xff1f; A&#xff1a;就是指辅助空间复杂度为O(1)&#xff0c;通俗一点来说就是不需要再开辟一块空间来实现算法。 特别说明&#xff1a; 笔者第一次录制视频&#xff0c;言语有些不顺&…
阅读更多...
静态链表处理

静态链表处理

静态链表是指使用数组来表示节点。在C中&#xff0c;可以使用数组来创建静态列表&#xff0c;其中每个元素都有固定的位置和索引。可以通过下标寻址的方式来访问和操作列表中的元素。 单向列表&#xff1a; struct linkednode{int data;int next; }node[N]; 双向链表&#x…
阅读更多...
Redis数据结构底层原理

Redis数据结构底层原理

目录 一、底层结构 1、SDS 2、intSet 3、Dict 4、ziplist 5、SkipList 二、Redis数据结构原理 1、string 2、set 3、zset 4、Hash 一、底层结构 1、SDS SDS是可见字符串&#xff0c;没有直接用c语言的字符串&#xff0c;因为c长度要通过运算得到&#xff0c;非二进…
阅读更多...
数据结构与算法：数据结构基础

数据结构与算法：数据结构基础

目录 数组 定义 形式 顺序存储 基本操作 读取元素 更新元素 插入元素 删除元素 扩容 初始化 时机 步骤 优劣势 链表 定义 单向链表 特点 双向链表 随机存储 基本操作 查找节点 更新节点 插入节点 删除元素 数组VS链表 栈与队列 栈 定义 基本操作…
阅读更多...
【随想】每日两题Day.4

【随想】每日两题Day.4

题目&#xff1a;LeetCode 203.移除列表元素 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2…
阅读更多...
【数据结构】双向链表详解

【数据结构】双向链表详解

当我们学习完单链表后&#xff0c;双向链表就简单的多了&#xff0c;双向链表中的头插&#xff0c;尾插&#xff0c;头删&#xff0c;尾删&#xff0c;以及任意位置插&#xff0c;任意位置删除比单链表简单&#xff0c;今天就跟着小张一起学习吧&#xff01;&#xff01; 双向链…
阅读更多...
力扣刷题61-旋转链表

力扣刷题61-旋转链表

题目来源&#xff1a; 力扣61-旋转链表 题目描述&#xff1a; 思路&#xff1a;双指针 因为它倒得永远是倒数k个 class Solution {public ListNode rotateRight(ListNode head, int k) {ListNode slowhead,fasthead,lenhead;int l0;//1 求长度while(len!null){l;lenlen.next…
阅读更多...
嵌入式学习之链表

嵌入式学习之链表

对于链表&#xff0c;要重点掌握链表和数组区别和实现&#xff0c;链表静态添加和动态遍历&#xff0c;链表中pointpoint-next,链表节点个数的查找&#xff0c;以及链表从指定节点后方插入新节点的知识。
阅读更多...
【linux内核中的双向链表-02】list_for_each_safe

【linux内核中的双向链表-02】list_for_each_safe

在前面的文章《linux内核中的双向链表-01》中描述了双向链表的定义以及常用API&#xff0c;其中有个非常重要的宏定义&#xff1a;list_entry(ptr, type, member)。它可以在已知结构体成员地址的情况下&#xff0c;还原出结构体的首地址。 input子系统的事件处理层对应的内核对…
阅读更多...
LeetCode141.环形链表

LeetCode141.环形链表

这个题非常简单&#xff0c;我一下子就想到了用HashSet&#xff0c;从前往后把节点放入hashset中&#xff0c;如果set中存在这个节点说明存在环&#xff0c;如果把链表遍历完了说明不存在环&#xff0c;直接返回false&#xff0c;以下时我的代码&#xff1a; public class Sol…
阅读更多...
从零开始学习 Java：简单易懂的入门指南之HashMap及TreeMap源码解读（二十四）

从零开始学习 Java：简单易懂的入门指南之HashMap及TreeMap源码解读（二十四）

HashMap及TreeMap源码解读 HashMap源码TreeMap源码 HashMap源码 1.看源码之前需要了解的一些内容Node<K,V>[] table 哈希表结构中数组的名字DEFAULT_INITIAL_CAPACITY&#xff1a; 数组默认长度16DEFAULT_LOAD_FACTOR&#xff1a; 默认加载因子0.75HashMap里…
阅读更多...
栈和队列【栈和队列的基本概念和模拟实现】

栈和队列【栈和队列的基本概念和模拟实现】

全文目录 前言栈的实现栈的初始化栈的判空栈的扩容检查入栈出栈获取栈顶元素获取栈中有效元素的个数销毁栈 队列的实现队列的初始化队列的判空队列的新节点入队出队获取队头元素获取队尾元素获取队列中有效元素的个数销毁队列 循环队列总结 前言 栈的概念&#xff1a; 栈&…
阅读更多...
【数据结构】二叉树的基本概念

【数据结构】二叉树的基本概念

文章目录 一、树1、什么是树2、树的相关概念3、树的表示 二、二叉树1、二叉树的概念2、二叉树的几种情况3、特殊二叉树4、二叉树的性质5、二叉树的存储结构 一、树 1、什么是树 树是一种非线性的数据结构&#xff0c;它是由n&#xff08;n>0&#xff09;个有限结点组成一个…
阅读更多...
二刷力扣--链表

二刷力扣--链表

链表 链表类型&#xff1a; 单链表&#xff08;可以访问后面的一个节点&#xff09; 双链表&#xff08;可以访问前后节点&#xff09; 循环链表&#xff08;最后一个节点指向首节点&#xff09; 在Python中定义单链表节点&#xff1a; class ListNode:def __init__(self, v…
阅读更多...
无头单向非循环链表(详解)

无头单向非循环链表(详解)

无头单向非循环链表 链表的种类的简单介绍链表的定义typedef的运用 节点的创建遍历头插尾插头删尾删查找节点位置任意位置插入任意位置删除 链表的种类的简单介绍 链表的种类有很多 1.分有头链表和无头链表 2.分循环链表和非循环链表 3.分单向链表和双向链表 这里的话&#xff…
阅读更多...
单链表和双链表

单链表和双链表

单链表和双链表 单链表&#xff1a;只有一个指向下一节点的指针 --> 单向读取 双链表&#xff1a;既有指向下一节点的指针&#xff0c;也有指向上一节点的指针&#xff0c;可以通过此向前查找 单链表和双链表的反转&#xff1a;逆序 整个链表逆序、部分链表逆序&#…
阅读更多...
牛客: BM6 判断链表中是否有环

牛客: BM6 判断链表中是否有环

牛客: BM6 判断链表中是否有环 文章目录 牛客: BM6 判断链表中是否有环题目描述题解思路题解代码 题目描述 题解思路 一个慢指针,每次跳一次,一个快指针,每次跳两次,如果快指针遍历到链表终点,则链表无环,若慢指针和快指针相遇,则链表有环 题解代码 package main import . &…
阅读更多...
想要精通算法和SQL的成长之路 - 相交链表

想要精通算法和SQL的成长之路 - 相交链表

想要精通算法和SQL的成长之路 - 相交链表 前言一. 相交链表&#xff08;双指针&#xff09; 前言 想要精通算法和SQL的成长之路 - 系列导航 一. 相交链表&#xff08;双指针&#xff09; 原题链接 思路如下&#xff1a; 1.我们假设 headA链表的长度为 a。headB链表的长度为b…
阅读更多...
数据结构之洗牌算法

数据结构之洗牌算法

洗牌算法 1.买一副牌(生成一副牌)2.洗牌3.揭牌完整代码 1.买一副牌(生成一副牌) 2.洗牌 3.揭牌 完整代码 card中的代码: cardDemo中的代码 测试类代码
阅读更多...
Java版的数据结构——链表

Java版的数据结构——链表

目录 1.单向不带头链表 1.1 链表的概念及结构 1.2 代码部分 1.3 完整的全部代码 2. 双向不带头链表 2.1 代码部分 2.2 完整的代码 3. MySingleList与MyLinkedList代码上的区别 4. LinkedList的使用 4.1 什么是LinkedList 4.2 LinkedList的使用 4.2.1 LinkedList的构…
阅读更多...
牛客: BM7 链表中环的入口结点

牛客: BM7 链表中环的入口结点

牛客: BM7 链表中环的入口结点 文章目录 牛客: BM7 链表中环的入口结点题目描述题解思路题解代码 题目描述 题解思路 用一个哈希表存储链表节点,遍历链表,将节点加入哈希表,如果该节点在哈希表中出现过,意味着该节点是入口节点 题解代码 package mainfunc EntryNodeOfLoop(p…
阅读更多...
数据结构-leetcode-环形链表

数据结构-leetcode-环形链表

解题图解&#xff1a; 代码如下&#xff1a; bool hasCycle(struct ListNode *head) {struct ListNode * fasthead;//在这里fast是快指针//head作为low指针//因为这个题不需要做修改也只需返回true或false//就少开辟一个空间while(fast!NULL&&fast->next!NULL){hea…
阅读更多...
PTA：7-3 两个递增链表的差集

PTA：7-3 两个递增链表的差集

^两个递增链表的差集 题目输入样例输出样例 代码 题目 输入样例 5 1 3 5 7 9 3 2 3 5输出样例 3 1 7 9代码 #include <iostream> #include <list> #include <unordered_set> using namespace std; int main() {int n1, n2;cin >> n1;list<int&g…
阅读更多...
leetcode 92.反转链表II dummy节点的应用

leetcode 92.反转链表II dummy节点的应用

题目 方法 dummy节点 链表的第一个结点&#xff0c;因为没有前驱结点&#xff0c;存在同时删除前驱和后继的情况&#xff0c;这时候我们需要人为构造dummy节点——人为制造出来的第一个结点的前驱结点&#xff0c;也就是说&#xff0c;在可能操作head节点时&#xff0c;我们可…
阅读更多...
LeetCode-160. 相交链表

LeetCode-160. 相交链表

这是一道真的非常巧妙的题&#xff0c;题解思路如下&#xff1a; 如果让他们尾端队齐&#xff0c;那么从后面遍历就会很快找到第一个相交的点。但是逆序很麻烦。 于是有一个巧妙的思路诞生了&#xff0c;如果让短的先走完自己的再走长的&#xff0c;长的走完走短的&#xff0c;…
阅读更多...
算法通关村第一关|白银|链表经典问题【持续更新】

算法通关村第一关|白银|链表经典问题【持续更新】

1.两个链表第一个公共子节点 1.1 可以考虑将链表元素存储到一个集合里&#xff0c;然后一边遍历第二个链表&#xff0c;一边检测集合中是否存在该结点。本题只需要记录一个结点是否存在&#xff0c;而不需要其他的数据&#xff0c;所以使用 HashSet 。 public ListNode findF…
阅读更多...
【数据结构】线性表（三）循环链表的各种操作（创建、插入、查找、删除、修改、遍历打印、释放内存空间）

【数据结构】线性表（三）循环链表的各种操作（创建、插入、查找、删除、修改、遍历打印、释放内存空间）

目录 线性表的定义及其基本操作&#xff08;顺序表插入、删除、查找、修改&#xff09; 四、线性表的链接存储结构 1. 单链表 2. 循环链表 a. 循环链表节点结构体 b. 创建新节点 c. 在循环链表末尾插入节点 d. 删除循环链表中指定值的节点 e. 在循环链表中查找指定值的…
阅读更多...
【（数据结构）—— 基于单链表实现通讯录】

【（数据结构）—— 基于单链表实现通讯录】

&#xff08;数据结构&#xff09;—— 基于单链表实现通讯录 一.通讯录的功能介绍1.基于单链表实现通讯录(1). 知识要求(2). 功能要求 二.通讯录的代码实现1.通讯录的底层结构(单链表)(1).思路展示(2).底层代码实现(单链表)1.单链表头文件 —— &#xff08;函数的定义&#x…
阅读更多...
【面试HOT100】链表树

【面试HOT100】链表树

系列综述&#xff1a; &#x1f49e;目的&#xff1a;本系列是个人整理为了秋招面试的&#xff0c;整理期间苛求每个知识点&#xff0c;平衡理解简易度与深入程度。 &#x1f970;来源&#xff1a;材料主要源于LeetCodeHot100进行的&#xff0c;每个知识点的修正和深入主要参考…
阅读更多...
设计链表复习

设计链表复习

设计链表 class ListNode {int val;ListNode next;public ListNode() {}public ListNode(int val) {this.val val;}public ListNode(int val, ListNode next) {this.val val;this.next next;}}class MyLinkedList {//size存储链表元素的个数int size;//虚拟头节点ListNode…
阅读更多...
大学生毕业设计论文题目大全_kaic

大学生毕业设计论文题目大全_kaic

清远市北山亲子主题儿童公园景观设计 马斯洛需求层次理论下《一个叫欧维的男人决定去死》的生命延伸意义探究 云浮石牛山大榄村儿童自然教育营地规划设计 佛山市创意产业园智慧低碳办公空间设计 佛山市碧桂园智能化养老模式的居住空间设计 海绵城市湿地公园景观规划设计研究 跨…
阅读更多...
每日一题（链表中倒数第k个节点）

每日一题（链表中倒数第k个节点）

每日一题&#xff08;链表中倒数第k个节点&#xff09; 链表中倒数第k个结点_牛客网 (nowcoder.com) 思路: 如下图所示&#xff1a;此题仍然定义两个指针&#xff0c;fast指针和slow指针&#xff0c;假设链表的长度是5&#xff0c;k是3&#xff0c;那么倒数第3个节点就是值为…
阅读更多...
小白备战大厂算法笔试(二)——数组、链表、列表

小白备战大厂算法笔试(二)——数组、链表、列表

文章目录 常见数据结构数组初始化访问元素插入元素删除元素遍历数组查找元素扩容数组关于数组 链表初始化插入节点删除节点访问节点查找节点常见类型典型应用 数组VS链表列表初始化访问元素插入与删除元素遍历列表拼接列表排序列表简单实现 常见数据结构 常见的数据结构包括数…
阅读更多...
第 4 章 链表(2)(单链表面试题)

第 4 章 链表(2)(单链表面试题)

单链表面试题(新浪、百度、腾讯) 单链表的常见面试题有如下: 1.求单链表中有效节点的个数 /*** 单链表*/ public class SingleLinkedListDemo {public static void main(String[] args) {//进行测试//先创建节点HeroNode hero1 new HeroNode(1, "宋江", "及时…
阅读更多...
每日两题 83删除排序链表的重复元素 82删除排序链表的重复元素||

每日两题 83删除排序链表的重复元素 82删除排序链表的重复元素||

83 题目 给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,1,2] 输出&#xff1a;[1,2]示例 2&#xff1a; 输入&#xff1a;head [1,1,2,3,3] 输出&…
阅读更多...
数据结构学习系列之单向链表的去重

数据结构学习系列之单向链表的去重

单向链表的去重&#xff1a;所谓的去重&#xff0c;就是去除单向链表中重复的数据结点&#xff0c;代码如下&#xff1a;示例代码&#xff1a; int del_rep_link_list(node_t *phead){if(NULL phead){printf("入参为NULL,请检查..\n");return -1;}if(NULL phead-&…
阅读更多...
【双指针】 LCR 023. 相交链表

【双指针】 LCR 023. 相交链表

LCR 023. 相交链表 拆分链表一个链表元素全部小于x另一个链表元素全部大于或者等于x合并链表 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* Li…
阅读更多...
day22集合01

day22集合01

1.Collection集合 1.1数组和集合的区别【理解】 相同点 都是容器,可以存储多个数据 不同点 数组的长度是不可变的,集合的长度是可变的 数组可以存基本数据类型和引用数据类型 集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类 1.2集合类体系结构【理解】…
阅读更多...
leetcode 655. 输出二叉树(java)

leetcode 655. 输出二叉树(java)

输出二叉树 题目描述代码演示 题目描述 难度 - 中等 leetcode 655. 输出二叉树 给你一棵二叉树的根节点 root &#xff0c;请你构造一个下标从 0 开始、大小为 m x n 的字符串矩阵 res &#xff0c;用以表示树的 格式化布局 。构造此格式化布局矩阵需要遵循以下规则&#xff1a…
阅读更多...
【LeetCode-中等题】707. 设计链表

【LeetCode-中等题】707. 设计链表

文章目录 题目方法一&#xff1a;单向链表实现方法二&#xff1a; 题目 方法一&#xff1a;单向链表实现 新增或删除一个位置的节点找到这个位置的前一个节点即可 class MyLinkedList {int size;ListNode head;public MyLinkedList() {size 0;head new ListNode(0);}public…
阅读更多...
C++数据结构 -- 哈希表

C++数据结构 -- 哈希表

目录 一、哈希概念二、 哈希冲突三、 哈希函数四、 减少哈希冲突常用的方法4.1 闭散列4.1.1 闭散列的开放定址法的增容4.1.2 闭散列的开放定址法的哈希结构的实现 4.3 开散列4.3.1 开散列概念4.3.2 插入元素4.3.2 删除元素4.3.3 开散列的哈希桶的增容4.3.4 开散列的哈希桶(拉链…
阅读更多...
C++---链表

C++---链表

1、链表 1.1、链表的结构 每个链表开头都有一个头指针Head尾节点的指针域为NULL&#xff0c;用于判断此列表是否结束 如果一个链表开始就为NULL&#xff0c;那么该链表为空链表 链表中的先后不代表在真实内存中的位置&#xff0c;只是单纯的逻辑上关系 1.2、创建链表 我们首…
阅读更多...
二、链表（linked-list）

二、链表（linked-list）

文章目录 一、定义二、经典例题&#xff08;一&#xff09;[21.合并两个有序链表](https://leetcode.cn/problems/merge-two-sorted-lists/description/)1.思路2.复杂度分析3.注意4.代码 &#xff08;二&#xff09;[86.分割链表](https://leetcode.cn/problems/partition-list…
阅读更多...
旋转链表-双指针思想-LeetCode61

旋转链表-双指针思想-LeetCode61

题目要求&#xff1a;给定链表的头结点&#xff0c;旋转链表&#xff0c;将链表每个节点向右移动K个位置。 示例&#xff1a; 输入&#xff1a;head [1,2,3,4,5], k2 输出&#xff1a;[4,5,1,2,3] 双指针思想&#xff1a; 先用双指针策略找到倒数K的位置&#xff0c;也就是(…
阅读更多...
链表反转-LeetCode206

链表反转-LeetCode206

**题目&#xff1a;**给你单链表的头结点head&#xff0c;请反转链表&#xff0c;并返回反转后的链表。 示例&#xff1a; 输入&#xff1a;head [1&#xff0c;2&#xff0c;3&#xff0c;4&#xff0c;5] 输出&#xff1a;[5&#xff0c;4&#xff0c;3&#xff0c;2&#x…
阅读更多...
删除链表中所有含有val的节点

删除链表中所有含有val的节点

给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5] 思路1&#xff1a;遍历查找&#xf…
阅读更多...
链表oj题1(Leetcode)——移除链表元素，反转链表，链表的中间节点，

链表oj题1(Leetcode)——移除链表元素，反转链表，链表的中间节点，

链表OJ 一&#xff0c;移除链表元素1.1分析1.2代码 二&#xff0c;找到链表的中间节点2.1分析2.2代码 三&#xff0c;反转链表3.1分析3.2代码 四&#xff0c;找到链表中倒数第k个节点4.1分析4.2代码 一&#xff0c;移除链表元素 移除链表元素 1.1分析 这里的删除要分成两种…
阅读更多...
【嵌入式 MultiTimer】软件定时器原理+单向链表的使用详解

【嵌入式 MultiTimer】软件定时器原理+单向链表的使用详解

&#x1f4cb; 个人简介 &#x1f496; 作者简介&#xff1a;大家好&#xff0c;我是喜欢记录零碎知识点的小菜鸟。&#x1f60e;&#x1f4dd; 个人主页&#xff1a;欢迎访问我的 Ethernet_Comm 博客主页&#x1f525;&#x1f389; 支持我&#xff1a;点赞&#x1f44d;收藏⭐…
阅读更多...
【数据结构】链表C++编写的，它定义了一个链表，并实现了一些基本的链表操作，如创建新节点、插入节点、清空链表、输出链表以及查找节点

【数据结构】链表C++编写的，它定义了一个链表，并实现了一些基本的链表操作，如创建新节点、插入节点、清空链表、输出链表以及查找节点

// 引入标准输入输出流库&#xff0c;用于输出操作 #include <iostream> // 引入标准库中的stdlib&#xff0c;包含了rand()函数和其他相关函数 #include <cstdlib> // 引入标准库中的time&#xff0c;包含了time()函数和其他相关函数 #include <ctim…
阅读更多...
【校招VIP】测试算法考点之链表

【校招VIP】测试算法考点之链表

考点介绍&#xff1a; 链表是一种逻辑简单的、实用的数据结构&#xff0c;几乎被所有程序设计语言支持。单链表的操作算法是笔试面试中较为常见的题目。 测试算法考点之链表-相关题目及解析内容可点击文章末尾链接查看&#xff01; 一、考点题目 1.一个长度为n的单向链表&am…
阅读更多...
算法练习之反转链表

算法练习之反转链表

比较久没有写算法题了。还是应该复习回顾一下&#xff0c;这次用新学的 rust 语言来解决算法问题。个人认为学习算法题目重要的不是解法&#xff0c;而是解法背后的思想。要从每一道题目中学习到解决问题的思路。 定义一个函数&#xff0c;输入一个链表的头节点&#xff0c;反转…
阅读更多...
算法笔记——循环链表

算法笔记——循环链表

带环链表 算法题中&#xff0c;会有一种题目让我们去判断链表里的是否有循环。 力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 这里就需要我们要用快慢指针来进行搜索&#xff0c;直接提供代码 class Solution { public:bool hasCycle(ListNode *…
阅读更多...
典型数据结构-栈/队列/链表、哈希查找、二叉树（BT）、线索二叉树、二叉排序树（BST树）、平衡二叉树（AVL树）、红黑树（RB树）

典型数据结构-栈/队列/链表、哈希查找、二叉树（BT）、线索二叉树、二叉排序树（BST树）、平衡二叉树（AVL树）、红黑树（RB树）

目录 典型数据结构列举 栈/队列/链表 树 二叉树 线索二叉树 二叉排序树 平衡二叉树&#xff08;AVL树&#xff09; 红黑树 其它树种和应用介绍 典型数据结构列举 栈/队列/链表 描述略。 一些基本的简单实现参考/数据结构简单实现/文件夹里面。 线性表详解&#xff…
阅读更多...
算法通关村第一关——链表（黄金）

算法通关村第一关——链表（黄金）

算法通关村第一关——链表&#xff08;黄金&#xff09; 环形链表 II双向链表1 设计双向链表2 遍历链表3 链表插入4 链表删除 环形链表 II leetcode 142. 环形链表 II 详细过程可以看这个链接&#xff1a;142. 环形链表 II - 力扣&#xff08;LeetCode&#xff09; public c…
阅读更多...
leetcode做题笔记142. 环形链表 II

leetcode做题笔记142. 环形链表 II

给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整…
阅读更多...
【算法|链表】环形链表Ⅱ

【算法|链表】环形链表Ⅱ

环形链表Ⅱ 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统…
阅读更多...
双向链表的实现（增删查改）——最好理解的链表

双向链表的实现（增删查改）——最好理解的链表

双向链表的实现 一&#xff0c;双向链表的特点二&#xff0c;双向链表的结构三&#xff0c;双向链表的内容实现3.1创建node节点3.2初始化3.3打印3.4插入3.4.1尾插3.4.2头插3.4.3在pos位置上插入 3.5删除3.5.1尾删3.5.2头删3.5.3删除pos位置上的数据 四&#xff0c;调试技巧&…
阅读更多...
C语言之链表

C语言之链表

C语言之链表 定义&#xff1a; 链表是一种物理存储上非连续&#xff0c;数据元素的逻辑顺序通过链表中的指针链接次序&#xff0c;实现的一种线性存储结构。 特点&#xff1a; 链表由一系列节点&#xff08;链表中每一个元素称为节点&#xff09;组成&#xff0c;节点在运行时…
阅读更多...
leetcode23 合并K个有序列表

leetcode23 合并K个有序列表

题目 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 示例 输入&#xff1a;lists [[1,4,5],[1,3,4],[2,6]] 输出&#xff1a;[1,1,2,3,4,4,5,6] 解释&#xff1a;链表数组如下&#xff1a; […
阅读更多...
合并两个升序链表，哨兵位的理解

合并两个升序链表，哨兵位的理解

开始时也要判断是否有一个链表本来就是空&#xff0c;如果是&#xff0c;直接返回另外一个链表 代码&#xff1a; struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){if(list1NULL){return list2;}if(list2NULL){return list1;} struct ListN…
阅读更多...
数据结构与算法(C语言版)P4---顺序表、链表总结

数据结构与算法(C语言版)P4---顺序表、链表总结

顺序表和链表&#xff08;双向带头链表&#xff09;的区别 顺序表&#xff1a; 优点&#xff1a; 支持随机访问。需要随机访问结构支持算法可以很好的使用。cpu高速缓存利用率&#xff08;命中率&#xff09;更高。存储密度高 缺点&#xff1a; 头部中部插入删除时间效率低。…
阅读更多...
使用Java语言深度探索数据结构中的单向链表：完美结合详解与示例代码

使用Java语言深度探索数据结构中的单向链表：完美结合详解与示例代码

版本说明 当前版本号[20231007]。 版本修改说明20231007初版 目录 文章目录 版本说明目录2.2 链表1) 概述定义简单分类随机访问性能插入或删除性能 2) 单向链表头部添加循环遍历while遍历for 遍历迭代器遍历匿名内部类转换为带名字的内部类 尾部添加递归遍历 根据索引获取寻…
阅读更多...
【算法刷题】【反转链表】给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

【算法刷题】【反转链表】给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

题目 解决&#xff1a; import java.util.*;/** public class ListNode {* int val;* ListNode next null;* public ListNode(int val) {* this.val val;* }* }*/public class Solution {/*** 代码中的类名、方法名、参数名已经指定&#xff0c;请勿修改&#x…
阅读更多...
Linux编程——经典链表list_head

Linux编程——经典链表list_head

1. 关于list_head struct list_head是Linux内核定义的双向链表&#xff0c;包含一个指向前驱节点和后继节点的指针的结构体。其定义如下&#xff1a; struct list_head {struct list_head *next, *prev; //双向链表&#xff0c;指向节点的指针 };1.1 链表的定义和初始化 有两…
阅读更多...
链表经典面试题(四)

链表经典面试题(四)

分割链表 1.题目2.详细的图文分析3.详细的注释和代码 1.题目 2.详细的图文分析 我们会定义4个指向分割链表的指向指针,分别来表示两个链表的头和尾 并且将数据一一的放到两个链表中,最后再将它们串起来,代码中有详细注释. 3.详细的注释和代码 public class Partition {public…
阅读更多...
数据结构 第二章 线性表 作业（已批改）

数据结构 第二章 线性表 作业（已批改）

判断题 2-1-1 For a sequentially stored linear list of length N, the time complexities for query and insertion are O(1) and O(N), respectively. 译文&#xff1a;对于长度为N的顺序存储线性列表&#xff0c;查询和插入的时间复杂度分别为O(1)和O(N)。 T F 顺序存储…
阅读更多...
链表的基本操作(数据结构)

链表的基本操作(数据结构)

单链表 #include <stdlib.h> #include <iostream> #include <stdio.h> typedef struct LNode{int data;struct LNode *next; }LNode,*LinkList;打印链表 void PrintList(LNode *p) {LNode *temp;temp p->next;printf("链表的顺序:");while(t…
阅读更多...
链表（2）——带头双向循环链表

链表（2）——带头双向循环链表

&#x1f341;一、链表的分类 &#x1f315;1.单向或者双向 &#x1f315;2.带头或者不带头&#xff08;有无哨兵&#xff09; &#x1f315;3.循环或者不循环 &#x1f315;4.无头单向非循环链表&#xff08;常用&#xff09; &#x1f315;5.带头双向循环链表&#xff08;常用…
阅读更多...
CBA球员注册管理系统（计科课设）

CBA球员注册管理系统（计科课设）

⭐博客主页&#xff1a;️CS semi主页 ⭐欢迎关注&#xff1a;点赞收藏留言 ⭐系列专栏&#xff1a;数据结构初阶 ⭐代码仓库&#xff1a;Data Structure 家人们更新不易&#xff0c;你们的点赞和关注对我而言十分重要&#xff0c;友友们麻烦多多点赞&#xff0b;关注&#xff…
阅读更多...
【洛谷 P1996】约瑟夫问题 题解（循环链表+模拟+循环）

【洛谷 P1996】约瑟夫问题 题解（循环链表+模拟+循环）

约瑟夫问题 题目描述 n n n 个人围成一圈&#xff0c;从第一个人开始报数,数到 m m m 的人出列&#xff0c;再由下一个人重新从 1 1 1 开始报数&#xff0c;数到 m m m 的人再出圈&#xff0c;依次类推&#xff0c;直到所有的人都出圈&#xff0c;请输出依次出圈人的编号。…
阅读更多...
C/C++ 数据结构 - 链表

C/C++ 数据结构 - 链表

1.单链表 https://blog.csdn.net/qq_36806987/article/details/79858957 1 #include<stdio.h>2 #include<stdlib.h>3 4 /*结构体部分*/5 typedef struct Node6 {7 int data; //数值域8 struct Node *next; //指针域9 }N;10 11 N *Init() //初始化单…
阅读更多...
链表--合并多个有序链表

链表--合并多个有序链表

例 输入&#xff1a;lists [[1,4,5],[1,3,4],[2,6]] 输出&#xff1a;[1,1,2,3,4,4,5,6] 解释&#xff1a;链表数组如下&#xff1a; [1->4->5,1->3->4,2->6 ] 将它们合并到一个有序链表中得到。 1->1->2->3->4->4->5->6 如图&#xff…
阅读更多...
【LeetCode热题100】--114.二叉树展开为链表

【LeetCode热题100】--114.二叉树展开为链表

114.二叉树展开为链表 方法一&#xff1a;对二叉树进行先序遍历&#xff0c;得到各个节点被访问到的顺序&#xff0c;利用数组存储下来&#xff0c;然后在先序遍历之后更新每个节点的左右节点的信息&#xff0c;将二叉树展开为链表 /*** Definition for a binary tree node.* …
阅读更多...
数据结构与算法（二）：数组与链表

数据结构与算法（二）：数组与链表

参考引用 Hello 算法 Github&#xff1a;hello-algo 1. 数组 数组&#xff08;array&#xff09;是一种线性数据结构&#xff0c;其将相同类型元素存储在连续的内存空间中。将元素在数组中的位置称为该元素的索引&#xff08;index&#xff09; 1.1 数组常用操作 1.1.1 初始…
阅读更多...
数据结构--队列与循环队列的实现

数据结构--队列与循环队列的实现

数据结构–队列的实现 1.队列的定义 比如有一个人叫做张三,这天他要去医院看病,看病时就需要先挂号,由于他来的比较晚,所以他的号码就比较大,来的比较早的号码就比较小,需要到就诊窗口从小号到大依次排队,前面的小号就诊结束之后,才会轮到大号来,小号每就诊完毕就销毁,每新来…
阅读更多...
复习Day10：哈希表part03:41. 缺失的第一个正数、138. 随机链表的复制

复习Day10：哈希表part03:41. 缺失的第一个正数、138. 随机链表的复制

labuladong 题解思路 之前的blog&#xff1a;https://blog.csdn.net/weixin_43303286/article/details/131797610?spm1001.2014.3001.5501 我用的方法是在leetcode再过一遍例题&#xff0c;明显会的就复制粘贴&#xff0c;之前没写出来就重写&#xff0c;然后从拓展题目中找…
阅读更多...
6-6 两个有序链表序列的合并 分数 10

6-6 两个有序链表序列的合并 分数 10

List Merge(List L1, List L2) {if (L1 NULL)return L2;if (L2 NULL)return L1;// 定义指针p和q分别指向链表L1和L2的头结点List p L1->Next;List q L2->Next;// 定义新链表的头结点和指针rList head (List)malloc(sizeof(struct Node));head->Next NULL;List r…
阅读更多...
【软考】9.1 顺序表/链表/栈和队列

【软考】9.1 顺序表/链表/栈和队列

《线性结构》 顺序存储和链表存储 每个元素最多只有一个出度和一个入度&#xff0c;表现为一条线状链表存储结构&#xff1a;每个节点有两个域&#xff0c;即数据&#xff0c;指针域&#xff08;指向下一个逻辑上相邻的节点&#xff09; 时间复杂度&#xff1a;与其数量级成正…
阅读更多...
leetcode做题笔记138. 复制带随机指针的链表

leetcode做题笔记138. 复制带随机指针的链表

给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节点的值。新节点的 n…
阅读更多...
leetcode做题笔记147. 对链表进行插入排序

leetcode做题笔记147. 对链表进行插入排序

给定单个链表的头 head &#xff0c;使用 插入排序 对链表进行排序&#xff0c;并返回 排序后链表的头 。 插入排序 算法的步骤: 插入排序是迭代的&#xff0c;每次只移动一个元素&#xff0c;直到所有元素可以形成一个有序的输出列表。每次迭代中&#xff0c;插入排序只从输…
阅读更多...
链表经典面试题（二）

链表经典面试题（二）

返回中间结点 1.中间结点的题目2.中间结点的图文分析3.中间结点的基本代码4.中间结点的优化代码 1.中间结点的题目 2.中间结点的图文分析 方法1&#xff1a;先求整体长度&#xff0c;再除以2&#xff0c;所得到的就是中间结点 方法2&#xff1a;双指针法&#xff0c;快指针走两…
阅读更多...
【LeetCode热题100】--24.两两交换链表中的节点

【LeetCode热题100】--24.两两交换链表中的节点

24.两两交换链表中的节点 使用迭代的方法 创建一个头节点&#xff0c;避免链表的头节点丢失 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* Lis…
阅读更多...
链表经典面试题(六)

链表经典面试题(六)

判断链表是否有环 1.题目2.思路分析(文字)3.详细的注释和代码实现 1.题目 2.思路分析(文字) 3.详细的注释和代码实现 public class Solution {public boolean hasCycle(ListNode head) {//定义两个快慢指针ListNode fast head;ListNode slow head;//让快指针走两步,慢指针走…
阅读更多...
#力扣：206. 反转链表@FDDLC

#力扣：206. 反转链表@FDDLC

206. 反转链表 一、Java class Solution {public ListNode reverseList(ListNode head) {if (head null) return null;ListNode pre null, cur head, next head.next;while (next ! null) {cur.next pre;pre cur;cur next;next cur.next;}cur.next pre;return cur;}…
阅读更多...
C语言链表嵌套链表学生成绩管理系统

C语言链表嵌套链表学生成绩管理系统

一阶段考核标准&#xff1a;用C语言链表嵌套链表学生成绩管理系统 链表A&#xff0c;每个节点存放一个新的链表B1,B2,B3,B4,B5的头结点。 场景&#xff1a;一个年级&#xff0c;相当链表A 该年级5个班&#xff0c;每个班5个人&#xff0c;相当于链表B1--B5 做一个学生成绩管理…
阅读更多...
leetcode 817. 链表组件(java)

leetcode 817. 链表组件(java)

链表组件 题目描述HashSet 模拟 题目描述 给定链表头结点 head&#xff0c;该链表上的每个结点都有一个 唯一的整型值 。同时给定列表 nums&#xff0c;该列表是上述链表中整型值的一个子集。 返回列表 nums 中组件的个数&#xff0c;这里对组件的定义为&#xff1a;链表中一段…
阅读更多...
【LeetCode热题100】--206.反转链表

【LeetCode热题100】--206.反转链表

206.反转链表 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* ListNode(int val, ListNode next) { this.val val; this.next next; }* }*/ clas…
阅读更多...
LeetCode每日练习之链表常见题目

LeetCode每日练习之链表常见题目

1. 两个链表的第一个公共节点 输入两个链表&#xff0c;找出它们的第一个公共节点。 1.1 思路 哈希和集合&#xff0c;先将一个链表全部存到Map里&#xff0c;然后一边遍历第二个链表&#xff0c;一边检测Hash是否存在当前结点&#xff0c;如果有交点&#xff0c;那么一定能检…
阅读更多...
LeetCode: 高频链表题目总结 - Python

LeetCode: 高频链表题目总结 - Python

LeetCode:高频链表题目总结 问题描述&#xff1a; LeetCode: 2. 两数相加 , 注意是逆序存储&#xff0c;相加求和LeetCode: 19. 删除链表的倒数第 N 个结点LeetCode: 21. 合并两个有序链表LeetCode: 23. 合并 K 个升序链表LeetCode: 24. 两两交换链表中的节点 &#xff0c;两…
阅读更多...
【二叉树】二叉树展开为链表-力扣 114 题

【二叉树】二叉树展开为链表-力扣 114 题

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kuan 的首页,持续学…
阅读更多...
【算法|虚拟头节点|链表】移除链表元素

【算法|虚拟头节点|链表】移除链表元素

Leetcode203 移除链表元素 题目描述&#xff1a; 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xf…
阅读更多...
数据结构----链式栈

数据结构----链式栈

目录 前言 链式栈 操作方式 1.存储结构 2.初始化 3.创建节点 4.判断是否满栈 5.判断是否空栈 6.入栈 7.出栈 8.获取栈顶元素 9.遍历栈 10.清空栈 完整代码 前言 前面我们学习过了数组栈的相关方法&#xff0c;&#xff08;链接&#xff1a;线性表-----栈&#xff08;栈…
阅读更多...
leetcode25 K个一组反转链表

leetcode25 K个一组反转链表

题目 给你链表的头节点 head &#xff0c;每 k 个节点一组进行翻转&#xff0c;请你返回修改后的链表。 k 是一个正整数&#xff0c;它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍&#xff0c;那么请将最后剩余的节点保持原有顺序。 你不能只是单纯的改变节点内部…
阅读更多...
Java 复习笔记 - 集合进阶篇：数据结构

Java 复习笔记 - 集合进阶篇：数据结构

文章目录 数据结构 概述常见的数据结构示例&#xff08;一&#xff09;数组&#xff08;Array&#xff09;&#xff08;二&#xff09;链表&#xff08;LinkedList&#xff09;&#xff08;三&#xff09;栈&#xff08;Stack&#xff09;&#xff08;四&#xff09;队列&#…
阅读更多...
第 4 章 串（串的块链存储实现)

第 4 章 串（串的块链存储实现)

1. 背景说明 该实现和链表的实现极为相似&#xff0c;只是将链接的内存拆分为具体的大小的块。 2. 示例代码 1). status.h /* DataStructure 预定义常量和类型头文件 */#ifndef STATUS_H #define STATUS_H#define CHECK_NULL(pointer) if (!(pointer)) { \printf("FuncN…
阅读更多...
Rust踩雷笔记（7）——两个链表题例子初识裸指针

Rust踩雷笔记（7）——两个链表题例子初识裸指针

目录 leetcode 234leetcode 19 leetcode 234 题目在这https://leetcode.cn/problems/palindrome-linked-list/&#xff0c;leetcode 234的回文链表&#xff0c;思路很简单&#xff0c;就是fast和slow两个指针&#xff0c;fast一次移动两个、slow一次一个&#xff0c;最后slow指…
阅读更多...
栈与队列经典题目——用栈实现队列

栈与队列经典题目——用栈实现队列

上篇文章对栈和队列的一个经典题目——Leetcode.225-用队列实现栈进行讲解。本篇文章将对另一个题目Leetcode.232-用栈实现队列进行讲解 1. Leetcode.232——用栈实现队列&#xff1a; 题目如下&#xff1a; 1.1 大体思路分析&#xff1a; 题目要求需要实现下列函数所表示的…
阅读更多...
Linux内核链表(list)移植到任意平台

Linux内核链表(list)移植到任意平台

一、前言 linux内核链表在include/linux/list.h文件中&#xff0c;内核中实现的链表比较简洁&#xff0c;实用性很强&#xff0c;因此想把它单独移植出来使用。 内核中的代码只能使用gnuc编译器编译&#xff0c;stdc编译器编译是会报错的&#xff0c;主要是因为typeof这个宏是…
阅读更多...
【链表】删除链表的中间节点-力扣2095题

【链表】删除链表的中间节点-力扣2095题

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kuan 的首页,持续学…
阅读更多...
leetcode做题笔记148. 排序链表

leetcode做题笔记148. 排序链表

给你链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 思路一&#xff1a;归并排序 c语言解法 struct ListNode* merge(struct ListNode* head1, struct ListNode* head2) {struct ListNode* dummyHead malloc(sizeof(struct ListNode));dummyHead…
阅读更多...
day3| 203.移除链表元素、 707.设计链表、206.反转链表

day3| 203.移除链表元素、 707.设计链表、206.反转链表

203.移除链表元素 题目链接&#xff1a;https://leetcode.cn/problems/remove-linked-list-elements/discussion/ 文章地址&#xff1a;https://programmercarl.com/0203.%E7%A7%BB%E9%99%A4%E9%93%BE%E8%A1%A8%E5%85%83%E7%B4%A0.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E…
阅读更多...
【链表实现】一元多项式相加相乘【详解相加相乘】

【链表实现】一元多项式相加相乘【详解相加相乘】

目录 一、一元多项式的表示 1、概念 2、用什么数据结构实现&#xff1f; 二、一元多项式的实现 1、基本结构概况 2、创建一元多项式 3、节点的尾插 4、一元多项式相加 5、一元多项式相乘 6、多项式的打印 7、 Poly的析构函数 8、完整代码 Poly.h: Poly.cpp test…
阅读更多...
代码随想录算法训练营第三天（C） | ● 203.移除链表元素 ● 707.设计链表 ● 206.反转链表

代码随想录算法训练营第三天（C） | ● 203.移除链表元素 ● 707.设计链表 ● 206.反转链表

文章目录 前言一、203.移除链表元素二、707.设计链表三、206.反转链表总结 前言 java版&#xff1a; 代码随想录算法训练营第三天 | 203.移除链表元素&#xff0c;707.设计链表&#xff0c;206.反转链表_愚者__的博客-CSDN博客 C: typedef struct ListNodeT {int val;struc…
阅读更多...
【刷题-牛客】链表内指定区间反转

【刷题-牛客】链表内指定区间反转

链表定区间翻转链表 题目链接题目描述核心思想详细图解代码实现复杂度分析 题目链接 链表内指定区间反转_牛客题霸_牛客网 (nowcoder.com) 题目描述 核心思想 遍历链表的过程中在进行原地翻转 [m,n]翻转区间记作子链表,找到子链表的 起始节点 left 和 终止节点 right记录在…
阅读更多...
力扣刷题-链表理论基础

力扣刷题-链表理论基础

什么是链表 什么是链表&#xff0c;链表是一种通过指针串联在一起的线性结构&#xff0c;每一个节点由两部分组成&#xff0c;一个是数据域一个是指针域&#xff08;存放指向下一个节点的指针&#xff09;&#xff0c;最后一个节点的指针域指向null&#xff08;空指针的意思&a…
阅读更多...
30.链表练习题（1）（王道2023数据结构2.3.7节1-15题）

30.链表练习题（1）（王道2023数据结构2.3.7节1-15题）

【前面使用的所有链表的定义在第29节】 试题1&#xff1a; 设计一个递归算法&#xff0c;删除不带头结点的单链表L中所有值为x的结点。 首先来看非递归算法&#xff0c;暴力遍历&#xff1a; int Del(LinkList &L,ElemType x){ //此函数实现删除链表中为x的元素LNode *…
阅读更多...
力扣-234.回文链表

力扣-234.回文链表

Idea 用一个数组或者字符串将链表中的值依次存入&#xff0c;然后利用数组遍历方法比较双端元素 AC Code class Solution { public:bool isPalindrome(ListNode* head) {string s "";ListNode* p head;while(p ! nullptr){s.append(to_string(p->val));p p-&g…
阅读更多...
给定一个链表，判断链表中是否有环

给定一个链表，判断链表中是否有环

【思路】 快慢指针&#xff0c;即慢指针一次走一步&#xff0c;快指针一次走两步&#xff0c;两个指针从链表其实位置开始运行&#xff0c; **如果链表带环则一定会在环中相遇&#xff0c;**否则快指针率先走到链表的末尾。比如&#xff1a;陪女朋友到操作跑步减肥。 bool hasC…
阅读更多...
力扣刷题-链表-设计链表

力扣刷题-链表-设计链表

题意&#xff1a; 在链表类中实现这些功能&#xff1a; get(index)&#xff1a;获取链表中第 index 个节点的值。如果索引无效&#xff0c;则返回-1。 addAtHead(val)&#xff1a;在链表的第一个元素之前添加一个值为 val 的节点。插入后&#xff0c;新节点将成为链表的第一个节…
阅读更多...
15链表-交换节点

15链表-交换节点

目录 LeetCode之路——24. 两两交换链表中的节点 分析&#xff1a; 解法一&#xff1a;迭代 解法二&#xff1a;递归 LeetCode之路——24. 两两交换链表中的节点 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点…
阅读更多...
链表oj题2（Leetcode）（牛客）——合并两个有序链表；判断回文链表；链表分割

链表oj题2（Leetcode）（牛客）——合并两个有序链表；判断回文链表；链表分割

链表oj题2&#xff08;Leetcode&#xff09;&#xff08;牛客&#xff09; 一&#xff0c;合并两个有序链表1.1分析2.2代码 二&#xff0c;链表的回文结构2.1分析2.2代码 三&#xff0c;链表分割3.1分析3.2代码 四&#xff0c;小结 一&#xff0c;合并两个有序链表 合并两个有…
阅读更多...
【数据结构】单链表的基本操作（节点建立、插入删除）

【数据结构】单链表的基本操作（节点建立、插入删除）

单链表的基本操作 链表的定义链表的创建&#xff08;初始化&#xff09; 不带头结点的链表带头结点的链表 链表的插入和删除 按位序插入 带头结点不带头结点 指定节点的后插操作指定元素的前插操作按位序删除 带头结点不带头结点 指定元素的删除操作 1. 单链表的基本操作 链…
阅读更多...
力扣刷题-链表-翻转链表

力扣刷题-链表-翻转链表

反转链表是面试中高频题目&#xff0c;很考察面试者对链表操作的熟练程度。 如果再定义一个新的链表&#xff0c;实现链表元素的反转&#xff0c;其实这是对内存空间的浪费。 其实只需要改变链表的next指针的指向&#xff0c;直接将链表反转 &#xff0c;而不用重新定义一个新的…
阅读更多...
寻找环形链表的入环点

寻找环形链表的入环点

之前我们在判断一个链表是否为环&#xff0c; 是运用快慢指针的方法&#xff0c;且只能是慢指针走一步&#xff0c;快指针两步&#xff1b; 那么如何求带环链表的入环点的 思路一&#xff1a;数学方法&#xff08;找出带环链表各个特点量的关系&#xff09; 代码&#xff1a;…
阅读更多...
一起学数据结构（8）——二叉树中堆的代码实现

一起学数据结构（8）——二叉树中堆的代码实现

在上篇文章中提到&#xff0c;提到了二叉树中一种特殊的结构——完全二叉树。对于完全二叉树&#xff0c;在存储时&#xff0c;适合使用顺序存储。对于非完全二叉树&#xff0c;适合用链式存储。本文将给出完全二叉树的顺序结构以及相关的代码实现&#xff1a; 1. 二叉树的结构…
阅读更多...
【每日一题Day336】LC146最近最少使用缓存 | 哈希表+链表

【每日一题Day336】LC146最近最少使用缓存 | 哈希表+链表

最近最少使用缓存【LC146】 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类&#xff1a; LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存int get(int key) 如果关键字 key 存在于缓存中&#xff0c;则返回关键字的值…
阅读更多...
【数据结构】链表和LinkedList的理解和使用

【数据结构】链表和LinkedList的理解和使用

目录 1.前言 2.链表 2.1链表的概念以及结构 2.2链表的实现 3.LinkedList的使用 3.1什么是LinkedList 3.2LinkedList的使用 2.常用的方法介绍 4. ArrayList和LinkedList的区别 1.前言 在上一篇文章中我们介绍了顺序表&#xff0c;ArrayList的底层原理和具体的使用&#x…
阅读更多...
【算法练习Day3】 移除链表元素设计链表反转链表

【算法练习Day3】 移除链表元素设计链表反转链表

​ ​&#x1f4dd;个人主页&#xff1a;Sherry的成长之路 &#x1f3e0;学习社区&#xff1a;Sherry的成长之路&#xff08;个人社区&#xff09; &#x1f4d6;专栏链接&#xff1a;练题 &#x1f3af;长路漫漫浩浩&#xff0c;万事皆有期待 文章目录 移除链表元素其他问题 设…
阅读更多...
leetcode Top100(24) // 环形链表2

leetcode Top100(24) // 环形链表2

环形链表 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内…
阅读更多...
leetcodetop100(28) 两两交换链表中的节点

leetcodetop100(28) 两两交换链表中的节点

两两交换链表中的节点 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09; package TOP21_30;import Util.ListNode;//两两交换链表…
阅读更多...
力扣刷题-链表-移除链表元素

力扣刷题-链表-移除链表元素

203.移除链表元素 题意&#xff1a;删除链表中等于给定值 val 的所有节点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5] 示例 2&#xff1a; 输入&#xff1a;head [], val 1 输出&#xff1a;[] 示例 3&#xff1a; 输…
阅读更多...
2023-9-25 JZ6 从头到尾打印链表

2023-9-25 JZ6 从头到尾打印链表

题目链接&#xff1a;从头到尾打印链表 import java.util.*; /** * public class ListNode { * int val; * ListNode next null; * * ListNode(int val) { * this.val val; * } * } * */ import java.util.ArrayList; public c…
阅读更多...
leetcode Top100(23)回文链表

leetcode Top100(23)回文链表

给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 输入&#xff1a;head [1,2,2,1] 输出&#xff1a;true采用动态数组&#xff0c;判断数组对称就可以了&#xff08;这解法空间…
阅读更多...
算法系列-链表操作总结

算法系列-链表操作总结

我们做了单链表反转、求链表中间节点、删除链表第n个节点、链表中环的检测、判断回文链表5个练习&#xff0c;并且这5个练习都是针对单链表的&#xff1b; 在操作链表的过程中有哪些需要注意的地方呢&#xff1f; 我们可以声明一个哑结点&#xff0c;可以避免多余的判断&…
阅读更多...
链表（单链表、双链表）

链表（单链表、双链表）

前言&#xff1a;链表是算法中比较难理解的部分&#xff0c;本博客记录单链表、双链表学习&#xff0c;理解节点和指针的使用&#xff0c;主要内容包括&#xff1a;使用python创建链表、实现链表常见的操作。 目录 单链表 双链表 单链表 引入链表的背景&#xff1a; 先来看…
阅读更多...
数据结构_链表

数据结构_链表

查询慢&#xff1a;链表中地址不是连续的&#xff0c;每次查询元素都必须从 头 开始查询增删快&#xff1a;链表结构&#xff0c;增加/删除一个元素&#xff0c;对链表的整体结构没有影响&#xff0c;所以增删快链表中的每一个元素也称为一个 节点一个节点包含了一个数据源&…
阅读更多...
LeetcodeTop100 (30) 随机链表复制

LeetcodeTop100 (30) 随机链表复制

给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节点的值。新节点的 n…
阅读更多...
复习Day05：链表part01:203.移除链表元素、707.设计链表、206.反转链表、234. 回文链表

复习Day05：链表part01:203.移除链表元素、707.设计链表、206.反转链表、234. 回文链表

之前的blog链接&#xff1a;https://blog.csdn.net/weixin_43303286/article/details/131700482?spm1001.2014.3001.5501 我用的方法是在leetcode再过一遍例题&#xff0c;明显会的就复制粘贴&#xff0c;之前没写出来就重写&#xff0c;然后从拓展题目中找题目来写。辅以Lab…
阅读更多...
非递归遍历树找到某个节点的路径（队列、链表）

非递归遍历树找到某个节点的路径（队列、链表）

const getPathById (list,id) > {const root {val:{id:,children:list,},next:null,path:[]}// 将队列的头和尾指向节点let head root , tail root ;while(head){const {val,path} head;// 如果当前节点命中则返回pathif(val.id id){return [...path,val].slice(1);}i…
阅读更多...
算法通关村-----一图理解递归

算法通关村-----一图理解递归

递归的本质 递归的本质是方法调用&#xff0c;自己调用自己&#xff0c;系统为我们维护了不同调用之间的保存和返回功能。 递归的特征 执行范围不断缩小&#xff0c;这样才能触底反弹 终止判断在递归调用之前 如何写递归 以n的阶乘为例 第一步 从小到大递推 n1 f(1)1 …
阅读更多...
【数据结构】队列的基本操作——基本实现 | 初始化 | 出入队列

【数据结构】队列的基本操作——基本实现 | 初始化 | 出入队列

目录&#xff1a; 1. 队列 1.1. 循环数组实现1.2. 队列的指针实现1.3. 队列的初始化1.4. 入队列1.5. 出队列 1. 队列 队列的特性是先进后出&#xff0c;即先进入队列的元素&#xff0c;最后出队列。 队列的实现方式有两种&#xff0c;一种是循环数组实现&#xff0c;另一种…
阅读更多...
【数据结构初阶】六、线性表中的队列（链式结构实现队列）

【数据结构初阶】六、线性表中的队列（链式结构实现队列）

相关代码gitee自取&#xff1a; C语言学习日记: 加油努力 (gitee.com) 接上期&#xff1a; 【数据结构初阶】五、线性表中的栈&#xff08;顺序表实现栈&#xff09;_高高的胖子的博客-CSDN博客 1 . 队列&#xff08;Queue&#xff09; 队列的概念和结构&#xff1a; 队列…
阅读更多...
【刷题笔记9.25】LeetCode：相交链表

【刷题笔记9.25】LeetCode：相交链表

LeetCode&#xff1a;相交链表 一、题目描述 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 二、分析及代码 方法一&#xff1a;使用哈希Set集合 &#xff08;注意…
阅读更多...
面试问题之链表 （LinkedList）

面试问题之链表 （LinkedList）

今天的面试中有一个比较有意思的题目&#xff0c;其实应该主要还是考察思路吧&#xff0c;可能是链表有比较长的时间没有看了&#xff0c;感觉问了下被问得有点懵。 要实现的东西就是在链表中实现从链表的后面取倒数第二个元素。 ​编辑 * Assuming we have the following lis…
阅读更多...
leetcodeTop100(27) 删除链表的倒数第N个节点

leetcodeTop100(27) 删除链表的倒数第N个节点

给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 直接就是先遍历链表计算长度len&#xff0c;然后在遍历找到第len-n1个节点&#xff08;要删除的前一个节点&#xff09; 这个节点next指向他的next.next就可以了 时间复杂度o&#xf…
阅读更多...
C理解(四):链表

C理解(四):链表

本文主要探讨单链表与双链表相关知识。 linux内核链表(include/linux/list.h) 内核链表中纯链表封装,纯链表的各种操作函数&#xff08;节点创建、插入、删除、遍历&#xff09;,纯链表内嵌在驱动结构体中,实现驱动的创建、插入、删除、遍历等 单链表 单链表链表头插…
阅读更多...
【算法基础】数组和链表，动态数组，循环数组，链表的变种

【算法基础】数组和链表，动态数组，循环数组，链表的变种

目录 1 数组&#xff08;Array&#xff09; 1.1 定义和特点 1.2 基本操作 1.3 数组的时间复杂度 1.4 应用场景 2 链表&#xff08;Linked List&#xff09; 2.1 定义和特点&#xff1a; 2.1.1 单向链表&#xff08;Singly Linked List&#xff09; 2.1.2 双向链表&…
阅读更多...
2023-9-30 JZ36 二叉搜索树与双向链表

2023-9-30 JZ36 二叉搜索树与双向链表

题目链接&#xff1a;二叉搜索树与双向链表 import java.util.*; /** public class TreeNode {int val 0;TreeNode left null;TreeNode right null;public TreeNode(int val) {this.val val;}} */ public class Solution {TreeNode pre null;public TreeNode Convert(Tree…
阅读更多...
初阶数据结构（四）带头双向链表

初阶数据结构（四）带头双向链表

&#x1f493;博主csdn个人主页&#xff1a;小小unicorn ⏩专栏分类&#xff1a;数据结构 &#x1f69a;代码仓库&#xff1a;小小unicorn的代码仓库&#x1f69a; &#x1f339;&#x1f339;&#x1f339;关注我带你学习编程知识 带头双向链表 链表的相关介绍初始化链表销毁链…
阅读更多...
复习Day07：链表part03:21. 合并两个有序链表、2. 两数相加

复习Day07：链表part03:21. 合并两个有序链表、2. 两数相加

之前的blog链接&#xff1a;https://blog.csdn.net/weixin_43303286/article/details/131700482?spm1001.2014.3001.5501 我用的方法是在leetcode再过一遍例题&#xff0c;明显会的就复制粘贴&#xff0c;之前没写出来就重写&#xff0c;然后从拓展题目中找题目来写。辅以Lab…
阅读更多...
LCR 136. 删除链表的节点

LCR 136. 删除链表的节点

LCR 136. 删除链表的节点 题目链接&#xff1a;LCR 136. 删除链表的节点 代码如下&#xff1a; /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode(int x) : val(x), next(NULL) {}* };*/ class Solution { pub…
阅读更多...
数据结构：链表（1）

数据结构：链表（1）

顺序表的优缺点 缺点&#xff1a; 1.插入数据必须移动其他数据&#xff0c;最坏情况下&#xff0c;就是插入到0位置。时间复杂度O(N) 2.删除数据必须移动其他数据&#xff0c;最坏情况下&#xff0c;就是删除0位置。时间复杂度O(N) 3.扩容之后&#xff0c;有可能会浪费空间…
阅读更多...
面试算法25：链表中的数字相加

面试算法25：链表中的数字相加

题目 给定两个表示非负整数的单向链表&#xff0c;请问如何实现这两个整数的相加并且把它们的和仍然用单向链表表示&#xff1f;链表中的每个节点表示整数十进制的一位&#xff0c;并且头节点对应整数的最高位数而尾节点对应整数的个位数。例如&#xff0c;两个分别表示整数98…
阅读更多...
相交链表Java

相交链表Java

给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 nu11。 以下有两种解决方法: 一种是用Map,利用其key值唯一的方法去判断(也可以使用set,set在add时,已存在的元素会返回false,不存在的返回…
阅读更多...
LeetCode142：环形链表II

LeetCode142：环形链表II

给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数…
阅读更多...
双向链表C语言版本

双向链表C语言版本

1、声明链表节点操作函数 linklist.h #ifndef LINKLIST_H__ #define LINKLIST_H__ #include <stdio.h> #include <stdlib.h> #include <stdbool.h>//#define TAIL_ADD #define HEAD_ADD typedef int LinkDataType; // 构造节点 struct LinkNode {LinkDataTy…
阅读更多...
LCR 078. 合并 K 个升序链表

LCR 078. 合并 K 个升序链表

LCR 078. 合并 K 个升序链表 题目链接&#xff1a;LCR 078. 合并 K 个升序链表 代码如下&#xff1a; class Solution { public:ListNode* mergeKLists(vector<ListNode*>& lists) {ListNode *lsnullptr;for(int i0;i<lists.size();i){lsmergeList(ls,lists[i])…
阅读更多...
LCR 077. 排序链表

LCR 077. 排序链表

LCR 077. 排序链表 题目链接&#xff1a;LCR 077. 排序链表 代码如下&#xff1a; class Solution { public:ListNode* sortList(ListNode* head) {return msort(head,nullptr);}ListNode* msort(ListNode* head,ListNode* tail){if(headnullptr)return head;if(head->nex…
阅读更多...
在C语言中，单向链表的插入操作通常包括以下哪些步骤？

在C语言中，单向链表的插入操作通常包括以下哪些步骤？

#科技新势力# #极简极速学编程# 【小白从小学Python、C、Java】 【计算机等级考试500强双证书】 【C语言每日一题】 在C语言中&#xff0c;单向链表的插入操作通常包括以下哪些步骤&#xff1f; A选项&#xff1a;将新节点指针->指向->链表最后一个节点 B选项&#xff1…
阅读更多...
【代码随想录】算法训练营 第四天 第二章 链表 Part 2

【代码随想录】算法训练营 第四天 第二章 链表 Part 2

24. 两两交换链表中的节点 思路 为了使得头结点的处理不用特殊化&#xff0c;所以依然设置一个虚拟头结点dummy&#xff0c;每次要交换的时候都要判断接下来的两个结点是否为空结点&#xff0c;即nullptr&#xff0c;若非空即可交换&#xff1b; 交换的时候&#xff0c;用一个…
阅读更多...
C语言数据结构-----链表类型详解及链表练习题

C语言数据结构-----链表类型详解及链表练习题

0.前言 之前我讲解了循序表以及单链表&#xff0c;接下来我会在介绍几个不同的链表&#xff0c;并举例相关习题使大家能够更加深入的理解。 前期内容如下&#xff1a; 链接: 顺序表(动态顺序表增删查改的代码实现) 链接: 单链表(无头单向不循环)增删查改的代码实现 链接: [双向…
阅读更多...
【LeetCode刷题日志】138.随机链表的复制

【LeetCode刷题日志】138.随机链表的复制

&#x1f388;个人主页&#xff1a;库库的里昂 &#x1f390;C/C领域新星创作者 &#x1f389;欢迎 &#x1f44d;点赞✍评论⭐收藏✨收录专栏&#xff1a;LeetCode 刷题日志&#x1f91d;希望作者的文章能对你有所帮助&#xff0c;有不足的地方请在评论区留言指正&#xff0c;…
阅读更多...
【数据结构】树与二叉树（十四）：二叉树的基础操作：查找给定结点的父亲（算法Father ）

【数据结构】树与二叉树（十四）：二叉树的基础操作：查找给定结点的父亲（算法Father ）

文章目录 5.2.1 二叉树二叉树性质引理5.1&#xff1a;二叉树中层数为i的结点至多有 2 i 2^i 2i个&#xff0c;其中 i ≥ 0 i \geq 0 i≥0。引理5.2&#xff1a;高度为k的二叉树中至多有 2 k 1 − 1 2^{k1}-1 2k1−1个结点&#xff0c;其中 k ≥ 0 k \geq 0 k≥0。引理5.3&…
阅读更多...
单链表经典OJ题（三）

单链表经典OJ题（三）

目录 1、反转链表 2、合并两个有序链表 3、链表的中间结点 4、环形链表的约瑟夫问题 5、移除链表元素 6、移除元素 1、反转链表 206. 反转链表 - 力扣&#xff08;LeetCode&#xff09; 翻转链表的实质就是更改当前结点的前驱结点和后继结点 假设原链表为:1->2->…
阅读更多...
160. 相交链表-哈希表法O（n）时间复杂度

160. 相交链表-哈希表法O（n）时间复杂度

160. 相交链表-o&#xff08;n&#xff09;时间复杂度 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个…
阅读更多...
算法-中等-链表-两数相加

算法-中等-链表-两数相加

记录一下算法题的学习11 两数相加 题目&#xff1a;给你两个非空的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照逆序的方式存储的&#xff0c;并且每个节点只能存储一位数字。请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。你可以假设除了数字…
阅读更多...
力扣160：相交链表

力扣160：相交链表

力扣160&#xff1a;相交链表 题目描述&#xff1a; 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式…
阅读更多...
【数据结构初阶】链表OJ

【数据结构初阶】链表OJ

链表OJ 题目一&#xff1a;移除链表元素题目二&#xff1a;反转链表题目三&#xff1a;链表的中间节点题目四&#xff1a;链表中倒数第k个结点题目五&#xff1a;合并两个有序链表题目六&#xff1a;链表分割题目七&#xff1a;链表的回文结构题目八&#xff1a;相交链表题目九…
阅读更多...
链表——移除链表元素

链表——移除链表元素

文章目录 一、题目二、题解 题目顺序&#xff1a;代码随想录算法公开课&#xff0c;b站上有相应视频讲解 一、题目 203. Remove Linked List Elements Given the head of a linked list and an integer val, remove all the nodes of the linked list that has Node.val val…
阅读更多...
LCR 026. 重排链表

LCR 026. 重排链表

LCR 026. 重排链表 题目链接&#xff1a;LCR 026. 重排链表 注&#xff1a;该题与 143. 重排链表完全一样 代码如下&#xff1a; class Solution { public:void reorderList(ListNode* head){if(headnullptr||head->nextnullptr||head->next->nextnullptr)return;L…
阅读更多...
Java【手撕链表】LeetCode 143. “重排链表“, 图文详解思路分析 + 代码

Java【手撕链表】LeetCode 143. “重排链表“, 图文详解思路分析 + 代码

文章目录 前言一、两数相加1, 题目2, 思路分析2,1 找到中间结点2.2, 逆序后半段链表2.3, 合并两个链表 3, 代码 前言 各位读者好, 我是小陈, 这是我的个人主页, 希望我的专栏能够帮助到你: &#x1f4d5; JavaSE基础: 基础语法, 类和对象, 封装继承多态, 接口, 综合小练习图书管…
阅读更多...
算法通关村第二关|白银|链表反转拓展【持续更新】

算法通关村第二关|白银|链表反转拓展【持续更新】

1.指定区间反转 1.1 头插法&#xff1a;将区间内遍历到的结点插入到起始处之前。 public ListNode reverseBetween(ListNode head, int left, int right) {ListNode dummyNode new ListNode(-1);dummyNode.next head;ListNode pre dummyNode;// 将pre移动到区间的前一位&a…
阅读更多...
深入浅出之链表

深入浅出之链表

深入浅出之链表 文章目录&#xff1a; 深入浅出之链表一、链表的定义二、单链表三、双链表四、链表的插入五、链表的删除六、一些特殊的链表 一、链表的定义 链表是一种链式存储结构&#xff0c;由多个节点&#xff08;结点&#xff09;组成&#xff0c;每个节点包含一个数据元…
阅读更多...
c语言练习94：分割链表

c语言练习94：分割链表

分割链表 给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你不需要 保留 每个分区中各节点的初始相对位置。 示例 1&#xff1a; 输入&#xff1a;head [1,4,3,2,5,2], x…
阅读更多...
『力扣刷题本』：相交链表

『力扣刷题本』：相交链表

咳咳&#xff0c;实在抱歉&#xff0c;刚开始心气太高了&#xff0c;叫『每日一题』&#xff0c;我是真的坚持不下了。 经过这次打击&#xff0c;我算是摸明白自己在写博客这件事情上几斤几两了&#xff0c;现在预计一周两更&#xff0c;再慢慢把更新频率提上来。 正在努力补…
阅读更多...
Leetcode 21 合并两个有序链表 （链表）

Leetcode 21 合并两个有序链表 （链表）

Leetcode 21 合并两个有序链表 &#xff08;链表&#xff09; 解法1 复杂的第一版本&#xff08;优化大于和等于合并见方法二&#xff09;解法2 注意注意&#xff1a;先添加元素toadd.next list1&#xff0c;添加之后才可以移动指针toadd toadd.next 解法1 复杂的第一版本&a…
阅读更多...
【LeetCode:86. 分隔链表 | 链表】

【LeetCode:86. 分隔链表 | 链表】

&#x1f680; 算法题 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;…
阅读更多...
特定深度节点链表

特定深度节点链表

题目链接&#xff1a;力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 经典BFS与简单链表结合的题目。 #define MAX_DEPTH (1000)struct ListNode** listOfDepth(struct TreeNode* tree, int* returnSize) {*returnSize 0;struct ListNode **ans (…
阅读更多...
【力扣刷题】回文链表、环形链表、合并两个有序链表

【力扣刷题】回文链表、环形链表、合并两个有序链表

&#x1f40c;个人主页&#xff1a; &#x1f40c; 叶落闲庭 &#x1f4a8;我的专栏&#xff1a;&#x1f4a8; c语言 数据结构 javaEE 操作系统 Redis 石可破也&#xff0c;而不可夺坚&#xff1b;丹可磨也&#xff0c;而不可夺赤。 刷题篇 一、回文链表1.1 题目描述1.2 思路分…
阅读更多...
二叉树，堆排序及TopK问题

二叉树，堆排序及TopK问题

要讲二叉树的概念&#xff0c;就要先讲树的概念。 树是什么呢&#xff1f; 树其实是一种储存数据的结构&#xff0c;因为他的结构倒过来和生活中的树很相似所以才被称之为树。 这是一颗多叉树&#xff0c;从最顶端的节点可以找到下边的几个节点&#xff0c;下边的节点又可以找…
阅读更多...
单链表的相关操作（初阶）

单链表的相关操作（初阶）

链表的概念 链表是线性表的一种&#xff0c;它是⼀种物理存储结构上⾮连续、⾮顺序的存储结构&#xff0c;数据元素的逻 辑顺序是通过链表中的指针链接次序实现的 。其实链表就相当于一列火车&#xff1a; 链表的结构跟⽕⻋⻋厢相似&#xff0c;淡季⻋厢会相应减少&#xff0c…
阅读更多...
【（数据结构）— 双向链表的实现】

【（数据结构）— 双向链表的实现】

&#xff08;数据结构&#xff09;— 双向链表的实现 一.双向链表的结构二. 双向链表的实现2.1 头文件 ——双向链表的创建及功能函数的定义2.2 源文件 ——双向链表的功能函数的实现2.3 源文件 ——双向链表功能的测试2.4 双向链表各项功能测试运行展示2.4.1 双向链表的初始化…
阅读更多...
【数据结构】线性表（七）堆栈：链式栈及其基本操作（初始化、判空、入栈、出栈、存取栈顶元素、清空栈）；顺序栈与链式栈之比较

【数据结构】线性表（七）堆栈：链式栈及其基本操作（初始化、判空、入栈、出栈、存取栈顶元素、清空栈）；顺序栈与链式栈之比较

文章目录 一、堆栈1. 定义2. 基本操作 二、顺序栈三、链式栈0. 链表1. 头文件和常量2. 栈结构体3. 栈的初始化4. 判断栈是否为空5. 入栈6. 出栈7. 存取栈顶元素8. 清空栈9. 主函数10. 代码整合 四、 顺序栈与链式栈的比较 堆栈&#xff08;Stack&#xff09;和队列&#xff08;…
阅读更多...
牛客TOP101-判断链表中是否有环

牛客TOP101-判断链表中是否有环

前言 本文以Java为语言讲解【判断链表中是否有环】这一题&#xff0c;题目来源【牛客TOP101】 题目描述 输入用例 解题思路 Hash表法 对于这道题&#xff0c;比较容易想到的可能是使用hash表&#xff0c;因为如果是有环&#xff0c;那么就意味着&#xff0c;在遍历过程中…
阅读更多...
链表专题回顾

链表专题回顾

移除链表元素 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 /*** Definition for singly-linked list.//注意基本的链表定义方法* public class ListNode {* int val;* List…
阅读更多...
数据结构与算法—双向链表

数据结构与算法—双向链表

目录 一、链表的分类 二、双向链表原理 三、实现双向链表 1、声明链表结构体 2、初始化链表 3、创建新节点 4、打印链表 5、头插&尾插 头插 尾插 6、头删&尾删 头删 尾删 7、 查找节点 8、指定节点前插入 9、删除指定节点 10、销毁链表 完整版 L…
阅读更多...
力扣一.链表的运用

力扣一.链表的运用

一.合并生序链表 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1： 输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4] 输入：l1 = [], l2 = [] 输出：[] 输入：l1 = [], l2 = [0] 输出：[0]提示： 两个链表的…
阅读更多...
【C语言数据结构】图-邻接链表法(没写完，以后再补)

【C语言数据结构】图-邻接链表法(没写完，以后再补)

图-邻接链表法 代码实现 代码实现 #include<stdio.h> #include<stdlib.h> #include<stdbool.h>//定义最大结点数为100(我也不知道为什么都邻接链表法了&#xff0c;结点还用数组存储。直接整两个链表存储得了&#xff0c;但课本上就是用数组存储结点的) #de…
阅读更多...
【数据结构】链表与LinkedList

【数据结构】链表与LinkedList

作者主页&#xff1a;paper jie 的博客 本文作者&#xff1a;大家好&#xff0c;我是paper jie&#xff0c;感谢你阅读本文&#xff0c;欢迎一建三连哦。 本文录入于《JAVA数据结构》专栏&#xff0c;本专栏是针对于大学生&#xff0c;编程小白精心打造的。笔者用重金(时间和精…
阅读更多...
数据结构与算法(C语言版)P9---哈夫曼树

数据结构与算法(C语言版)P9---哈夫曼树

1、哈夫曼树的基本概念 &#xff08;1&#xff09;路径&#xff1a;从树中一个结点到另一个结点之间的__分支__构成这两个结点间的路径。 &#xff08;2&#xff09;__结点的路径长度&#xff1a;__两结点间路径上的分支树。 练习&#xff1a;计算下面二叉树结点之间的路径长…
阅读更多...
两条链表相同位数相加[中等]

两条链表相同位数相加[中等]

优质博文IT-BLOG-CN 一、题目 给你两个非空的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照逆序的方式存储的&#xff0c;并且每个节点只能存储一位数字。请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。你可以假设除了数字0之外&#xff0c;这…
阅读更多...
带头双向循环链表解析|画图理解

带头双向循环链表解析|画图理解

前言&#xff1a; 链表中常用的的两种结构就是无头单向非循环链表和带头双向循环链表&#xff0c;在前面我们已经学习了无头单向非循环链表&#xff0c;今天我们将学习带头双向循环链表。 1、链表的分类 实际中链表的结构非常多样&#xff0c;一下情况结合起来就有8种链表结构。…
阅读更多...
线性表的链式存储结构——链表

线性表的链式存储结构——链表

一、顺序表优缺点 优点&#xff1a;我们知道顺序表结构简单&#xff0c;便于随机访问表中任一元素&#xff1b; 缺点&#xff1a;顺序存储结构不利于插入和删除&#xff0c;不利于扩充&#xff0c;也容易造成空间浪费。 二、链表的定义 ①&#xff1a;概念&#xff1a; 用一组任…
阅读更多...
【LeetCode热题100】--148.排序链表

【LeetCode热题100】--148.排序链表

148.排序链表 对链表进行排序最适合的算法就是归并排序&#xff1a; 对链表自顶向下归并排序的过程&#xff1a; 找到链表的中点&#xff0c;以中点为分界&#xff0c;将链表拆分成两个子链表&#xff0c;寻找链表的中点可以使用快慢指针的做法&#xff0c;快指针每次移动 2步…
阅读更多...
想要精通算法和SQL的成长之路 - 旋转链表

想要精通算法和SQL的成长之路 - 旋转链表

想要精通算法和SQL的成长之路 - 旋转链表 前言一. 旋转链表 前言 想要精通算法和SQL的成长之路 - 系列导航 一. 旋转链表 原题链接 由于k的大小可能超过链表长度&#xff0c;因此我们需要根据链表长度取模。那么我们首先需要去计算链表的长度是多少&#xff1a; if (head …
阅读更多...
DS线性表之链表

DS线性表之链表

前言 我们上一期介绍了顺序表&#xff0c;它的底层就是数组&#xff0c;我们也分别对顺序表的动态版本和静态版本进行了实现&#xff01;并且分析了顺序表的优缺点&#xff0c;优点是&#xff1a;尾插、尾删效率很高&#xff0c;其时间复杂度是O(1)&#xff1b;缺点是&#xff…
阅读更多...
剑指offer——JZ6 从尾到头打印链表 解题思路与具体代码

剑指offer——JZ6 从尾到头打印链表 解题思路与具体代码

一、题目描述与要求 从尾到头打印链表_牛客题霸_牛客网 (nowcoder.com) 题目描述 输入一个链表的头节点&#xff0c;按链表从尾到头的顺序返回每个节点的值&#xff08;用数组返回&#xff09;。 如输入{1,2,3}的链表如下图: 返回一个数组为[3,2,1] 0 < 链表长度 < …
阅读更多...
力扣练习——链表在线OJ

力扣练习——链表在线OJ

目录 提示&#xff1a; 一、移除链表元素 题目&#xff1a; 解答&#xff1a; 二、反转链表 题目&#xff1a; 解答&#xff1a; 三、找到链表的中间结点 题目&#xff1a; 解答&#xff1a; 四、合并两个有序链表&#xff08;经典&#xff09; 题目&#xff1a; 解…
阅读更多...
复习Day09：哈希表part02:141.环形链表、142. 环形链表II、454.四数相加II、383赎金信

复习Day09：哈希表part02:141.环形链表、142. 环形链表II、454.四数相加II、383赎金信

之前的blog&#xff1a;https://blog.csdn.net/weixin_43303286/article/details/131765317 我用的方法是在leetcode再过一遍例题&#xff0c;明显会的就复制粘贴&#xff0c;之前没写出来就重写&#xff0c;然后从拓展题目中找题目来写。辅以Labuladong的文章看。然后刷题不用…
阅读更多...
剑指offer——JZ18 删除链表的节点 解题思路与具体代码【C++】

剑指offer——JZ18 删除链表的节点 解题思路与具体代码【C++】

一、题目描述与要求 删除链表的节点_牛客题霸_牛客网 (nowcoder.com) 题目描述 给定单向链表的头指针和一个要删除的节点的值&#xff0c;定义一个函数删除该节点。返回删除后的链表的头节点。 1.此题对比原题有改动 2.题目保证链表中节点的值互不相同 3.该题只会输出返回…
阅读更多...
9.3 链表从指定节点插入新节点

9.3 链表从指定节点插入新节点

一、从指定节点后方插入 插入逻辑如图&#xff1a; 插入前&#xff1a;A指向B&#xff0c;B指向C 插入后&#xff1a;B为插入点&#xff0c;当要插入D时就要让B指向D&#xff0c;D再指向C&#xff08;插入前B的指向&#xff09; #include <stdio.h>struct Test {int d…
阅读更多...
数据结构—栈、队列、链表

数据结构—栈、队列、链表

一、栈 Stack&#xff08;存取O(1)&#xff09; 先进后出&#xff0c;进去123&#xff0c;出来321。 基于数组&#xff1a;最后一位为栈尾&#xff0c;用于取操作。 基于链表&#xff1a;第一位为栈尾&#xff0c;用于取操作。 1.1、数组栈 /*** 基于数组实现的顺序栈&#…
阅读更多...
链表（3）：双链表

链表（3）：双链表

引入 我们之前学的单向链表有什么缺点呢&#xff1f; 缺点&#xff1a;后一个节点无法看到前一个节点的内容 那我们就多设置一个格子prev用来存放前面一个节点的地址&#xff0c;第一个节点的prev存最后一个节点的地址&#xff08;一般是null&#xff09; 这样一个无头双向…
阅读更多...
leetcode做题笔记160. 相交链表

leetcode做题笔记160. 相交链表

给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c;函数返回结果后&…
阅读更多...
14链表-环形链表、龟兔赛跑算法

14链表-环形链表、龟兔赛跑算法

目录 LeetCode之路——141. 环形链表 分析&#xff1a; 解法一&#xff1a;哈希表 解法二&#xff1a;龟兔赛跑 LeetCode之路——141. 环形链表 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针…
阅读更多...
剑指offer——JZ76 删除链表中重复的结点 解题思路与具体代码【C++】

剑指offer——JZ76 删除链表中重复的结点 解题思路与具体代码【C++】

一、题目描述与要求 删除链表中重复的结点_牛客题霸_牛客网 (nowcoder.com) 题目描述 在一个排序的链表中&#xff0c;存在重复的结点&#xff0c;请删除该链表中重复的结点&#xff0c;重复的结点不保留&#xff0c;返回链表头指针。 例如&#xff0c;链表 1->2->3-&…
阅读更多...
LRU 缓存 -- 哈希链表

LRU 缓存 -- 哈希链表

相关题目 146. LRU 缓存 要让 put 和 get ⽅法的时间复杂度为 O(1)&#xff0c;我们可以总结出 cache 这个数据结构必要的条件&#xff1a; 1、显然 cache 中的元素必须有时序&#xff0c;以区分最近使⽤的和久未使⽤的数据&#xff0c;当容量满了之后要删除最久未使⽤的那个元…
阅读更多...
验证回文串[简单]

验证回文串[简单]

优质博文&#xff1a;IT-BLO-CN 一、题目 如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后&#xff0c;短语正着读和反着读都一样。则可以认为该短语是一个回文串。 字母和数字都属于字母数字字符。 给你一个字符串s&#xff0c;如果它是回文串&#xff0…
阅读更多...
【数据结构】单链表代码实现

【数据结构】单链表代码实现

&#x1f40c;个人主页&#xff1a; &#x1f40c; 叶落闲庭 &#x1f4a8;我的专栏&#xff1a;&#x1f4a8; c语言 数据结构 javaEE 操作系统 Redis 石可破也&#xff0c;而不可夺坚&#xff1b;丹可磨也&#xff0c;而不可夺赤。 链表 一、创建链表初始化值二、向链表头部添…
阅读更多...
【数据结构】链表栈

【数据结构】链表栈

目录&#xff1a; 链表栈 1. 链式栈的实现2. 链表栈的创建3. 压栈4. 弹栈 链表栈 栈的主要表示方式有两种&#xff0c;一种是顺序表示&#xff0c;另一种是链式表示。本文主要介绍链式表示的栈。 链栈实际上和单链表差别不大&#xff0c;唯一区别就在于只需要对链表限定从头…
阅读更多...
数据结构之带头双向循环链表

数据结构之带头双向循环链表

目录 链表的分类 带头双向循环链表的实现 带头双向循环链表的结构 带头双向循环链表的结构示意图 空链表结构示意图 单结点链表结构示意图 多结点链表结构示意图 链表创建结点 双向链表初始化 销毁双向链表 打印双向链表 双向链表尾插 尾插函数测试 双向链表头插 …
阅读更多...
一点C知识：数据类型和内存地址。

一点C知识：数据类型和内存地址。

当你需要存储一份数据到内存里的时候&#xff0c;你需要通过需要存储的方式和精度&#xff0c;向操作系统申请一份内存地址&#xff0c;形容怎么样申请地址的关键字就是数据类型。 例如&#xff0c;32位的处理器就有着32位的地址位宽&#xff0c;定义了一个char类型的数据&…
阅读更多...
C : DS双向链表—前驱后继

C : DS双向链表—前驱后继

Description 在双向链表中&#xff0c;A有一个指针指向了后继节点B&#xff0c;同时&#xff0c;B又有一个指向前驱节点A的指针。这样不仅能从链表头节点的位置遍历整个链表所有节点&#xff0c;也能从链表尾节点开始遍历所有节点。 对于给定的一列数据&#xff0c;按照给定的…
阅读更多...
数据结构——多重链表的实现

数据结构——多重链表的实现

//多重列表的实现 #include<stdio.h> #include<stdlib.h> struct lnode {int row,col,value; }; //没有用到down指针 //没有用到tag和next指针 typedef struct node {int tag;//区分头结点(0)和非零元素结点(1)struct node* right;struct node* down;//共用体与结…
阅读更多...
数据结构与算法（七）--使用链表实现栈

数据结构与算法（七）--使用链表实现栈

一、前言 之前我们已经学习了链表的所有操作及其时间复杂度分析&#xff0c;我们可以了解到对于链表头的相关操作基本都是O(1)的&#xff0c;例如链表头增加、删除元素&#xff0c;查询元素等等。那我们其实有一个数据结构其实可以完美利用到这些操作的特点&#xff0c;都是在…
阅读更多...
合并 K 个升序链表

合并 K 个升序链表

题目 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 示例 1&#xff1a; 输入&#xff1a;lists [[1,4,5],[1,3,4],[2,6]] 输出&#xff1a;[1,1,2,3,4,4,5,6] 解释&#xff1a;链表数组如下&a…
阅读更多...
面试算法22：链表中环的入口节点（2）

面试算法22：链表中环的入口节点（2）

题目 如果一个链表中包含环&#xff0c;那么应该如何找出环的入口节点&#xff1f;从链表的头节点开始顺着next指针方向进入环的第1个节点为环的入口节点。 例如&#xff0c;在如图4.3所示的链表中&#xff0c;环的入口节点是节点3。 分析 第1步&#xff1a;确认是否包含环…
阅读更多...
链表（7.27）

链表（7.27）

3.3 链表的实现 3.3.1头插 原理图&#xff1a; newnode为新创建的节点 实现&#xff1a; //头插 //让新节点指向原来的头指针&#xff08;节点&#xff09;&#xff0c;即新节点位于开头 newnode->next plist; //再让头指针&#xff08;节点&#xff09;指向新节点&#…
阅读更多...
【160】相交链表

【160】相交链表

方法一&#xff1a;双指针法 算法思想&#xff1a; 使用两个指针p1&#xff0c;p2分别遍历headA和headB。 当p1遍历完headA或p2遍历完headB&#xff0c;我们让该指针去遍历另一个链表。 由于两个指针走的路程相同&#xff0c;所以若两链表相交&#xff0c;则p1&#xff0c;p2一…
阅读更多...
数据结构 - 3（链表12000字详解）

数据结构 - 3（链表12000字详解）

一&#xff1a;LinkedList的使用 1.1 ArrayList的缺陷 上篇文章我们已经基本熟悉了ArrayList的使用&#xff0c;并且进行了简单模拟实现。由于其底层是一段连续空间&#xff0c;当在ArrayList任意位置插入或者删除元素时&#xff0c;就需要将后序元素整体往前或者往后搬移&am…
阅读更多...
数据结构学习系列之双向链表的三种删除方式

数据结构学习系列之双向链表的三种删除方式

头删法&#xff1a;删除双向链表头结点后的结点&#xff0c;即头删法&#xff0c;代码如下&#xff1a;示例代码&#xff1a; int delete_dplink_list_1(node_t *phead){if(NULL phead){printf("入参为NULL\n");return -1;}if(NULL phead->next){printf("链…
阅读更多...
数据结构学习系列之双向链表的三种插入方式

数据结构学习系列之双向链表的三种插入方式

头插法&#xff1a;在双向链表的头结点和第0个结点之间插入新结点&#xff0c;即头插法&#xff0c;代码如下&#xff1a;示例代码&#xff1a; int insert_dplink_list_1(node_t *phead,int data){if(NULL phead){printf("入参为NULL\n");return -1;}//创建新结点n…
阅读更多...
【软考】9.2 串/数组/矩阵/广义表/树

【软考】9.2 串/数组/矩阵/广义表/树

《字符串》 一种特殊的线性表&#xff0c;数据元素都为字符模式匹配&#xff1a;寻找子串第一次在主串出现的位置 模式匹配算法 1. 暴力破解法&#xff08;布鲁特-福斯算法&#xff09; 主串与子串一个个匹配效率低 2. KMP算法 主串后缀和子串前缀能否找到一样的元素&#xf…
阅读更多...
链表oj (7.29)

链表oj (7.29)

203. 移除链表元素 - 力扣&#xff08;LeetCode&#xff09; 思路1&#xff1a;使用结构体指针 cur 遍历链表&#xff0c;遇到值为 val 时删除&#xff0c;删除之前需要判断是头删还是正常的删除&#xff0c;头删需要改变头指针&#xff1b; 正常的删除需要 cur(待删除节点&am…
阅读更多...
力扣环形链表（1）进阶环形链表（2）及环形链表的约瑟夫问题

力扣环形链表（1）进阶环形链表（2）及环形链表的约瑟夫问题

为了加深对环形链表的理解和掌握&#xff0c;这两道题是很不错的选择。 这里所说环形链表不是一个圈圈的结构&#xff0c;而是带环链表。 链接&#xff1a;环形链表&#xff08;1&#xff09; 注意这里链表的长度 所以要注意链表是否为空 第一种方法&#xff0c;应该是比较容易…
阅读更多...
多数元素[简单]

多数元素[简单]

优质博文&#xff1a;IT-BLOG-CN 一、题目 给定一个大小为n的数组nums&#xff0c;返回其中的多数元素。多数元素是指在数组中出现次数大于n/2的元素。你可以假设数组是非空的&#xff0c;并且给定的数组总是存在多数元素。 示例 1&#xff1a; 输入&#xff1a;nums [3,2,3…
阅读更多...
【数据结构】线性表（一）线性表的定义及其基本操作（顺序表插入、删除、查找、修改）

【数据结构】线性表（一）线性表的定义及其基本操作（顺序表插入、删除、查找、修改）

目录 一、线性表 1. 线性表的定义 2. 线性表的要素 二、线性表的基本操作 三、线性表的顺序存储结构 1. 定义 2. 顺序表的操作 a. 插入操作 b. 删除操作 c. 查找操作 d. 修改操作 e. 代码实例 一、线性表 1. 线性表的定义 一个线性表是由零个或多个具有相同…
阅读更多...
算法-堆/归并排序-排序链表

算法-堆/归并排序-排序链表

算法-堆/归并排序-排序链表 1 题目概述 1.1 题目出处 https://leetcode.cn/problems/sort-list/description/?envTypestudy-plan-v2&envIdtop-interview-150 1.2 题目描述 2 优先级队列构建大顶堆 2.1 思路 优先级队列构建小顶堆链表所有元素放入小顶堆依次取出堆顶…
阅读更多...
面试算法29：排序的循环链表

面试算法29：排序的循环链表

问题 在一个循环链表中节点的值递增排序&#xff0c;请设计一个算法在该循环链表中插入节点&#xff0c;并保证插入节点之后的循环链表仍然是排序的。 分析 首先分析在排序的循环链表中插入节点的规律。当在图4.15&#xff08;a&#xff09;的链表中插入值为4的节点时&…
阅读更多...
c语言练习91：合并两个有序链表

c语言练习91：合并两个有序链表

合并两个有序链表 力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 代码1&#xff1a; /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/typedef struct ListNode ListNode; struct Li…
阅读更多...
Leetcode 142 环形链表II（链表：快2慢1指针相遇即有环）

Leetcode 142 环形链表II（链表：快2慢1指针相遇即有环）

Leetcode 142 环形链表II&#xff08;链表&#xff1a;快2慢1指针相遇即有环&#xff09; 解法1 https://leetcode.cn/problems/linked-list-cycle-ii/description/ 解法1 &#x1f534;1.【有无环】快慢指针&#xff0c;快指针每次走两步&#xff0c;慢指针每次走一步&#xf…
阅读更多...
你知道如何使用队列实现栈吗？（C语言）

你知道如何使用队列实现栈吗？（C语言）

这时一道非常经典的题型&#xff0c;因为栈和队列的性质是相反的&#xff0c;队列的数据是先入先出&#xff0c;栈的数据是后入先出&#xff0c;那么怎样使用两个队列实现栈呢&#xff1f; 225. 用队列实现栈https://leetcode.cn/problems/implement-stack-using-queues/ 这是…
阅读更多...
数据结构重点知识点复习——第七章 查找

数据结构重点知识点复习——第七章 查找

目录 一、查找的基本概念和顺序查找 二、分块查找 分块查找思想&#xff1a; 分块查找分析&#xff1a; 三、折半查找 折半查找判定树&#xff1a; 算法思路&#xff1a; 四、平衡二叉树(AVL树) 平衡因子&#xff1a; AVL树插入&#xff1a; AVL树删除&#xff1a; …
阅读更多...
环形链表问题

环形链表问题

给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;…
阅读更多...
算法通关村第一关|链表基础

算法通关村第一关|链表基础

1. 单链表概念 对于所有的数据结构的基础都是创建增删改查&#xff0c;学习链表重点也是学习链表的五种基本操作。 单向链表就像一个铁链一样&#xff0c;元素之间相互连接&#xff0c;包含多个结点&#xff0c;每个结点有一个指向后继元素的next指针。表中最后一个元素的nex…
阅读更多...
C语言每日一题（30）分割链表

C语言每日一题（30）分割链表

牛客网NC23 划分链表 题目描述 给出一个长度为 n 的单链表和一个值 x &#xff0c;单链表的每一个值为 list&#xff0c;请返回一个链表的头结点&#xff0c;要求新链表中小于 x 的节点全部在大于等于 x 的节点左侧&#xff0c;并且两个部分之内的节点之间与原来的链表要保持…
阅读更多...
面试算法28：展平多级双向链表

面试算法28：展平多级双向链表

问题 在一个多级双向链表中&#xff0c;节点除了有两个指针分别指向前后两个节点&#xff0c;还有一个指针指向它的子链表&#xff0c;并且子链表也是一个双向链表&#xff0c;它的节点也有指向子链表的指针。请将这样的多级双向链表展平成普通的双向链表&#xff0c;即所有节…
阅读更多...
数据结构—LinkedList与链表

数据结构—LinkedList与链表

目录 一、链表 1. 链表的概念及结构 1. 单向或者双向 2. 带头或者不带头 3. 循环或者非循环 二.LinkedList的使用 1.LinkedList概念及结构 2. LinkedList的构造 3. LinkedList的方法 三. ArrayList和LinkedList的区别 一、链表 1. 链表的概念及结构 链表是一种 物理…
阅读更多...
力扣83. 删除排序链表中的重复元素（java常规解法 + 建立虚拟头节点）

力扣83. 删除排序链表中的重复元素（java常规解法 + 建立虚拟头节点）

Problem: 83. 删除排序链表中的重复元素 文章目录 思路解题方法复杂度Code 思路 常规解法&#xff1a;一次遍历&#xff0c;每次判断若当前节点值和其下一个节点值&#xff0c;若相等则当前节点指向其下一个节点的下一个节点。 建立虚拟头节点和尾指针&#xff08;准确来说应该…
阅读更多...
散列表：为什么散列表和链表经常会一起使用？

散列表：为什么散列表和链表经常会一起使用？

文章来源于极客时间前google工程师−王争专栏。 链表那一节&#xff0c;我们用链表来实现LRU缓存淘汰算法&#xff0c;但是链表实现的LRU时间复杂度是O(n)&#xff0c;可以通过散列表将时间复杂度降低为O(1) 跳表那一节&#xff0c;Redis的有序集合是使用跳表来实现的&#xf…
阅读更多...
LeetCode刷题---链表

LeetCode刷题---链表

目录 一、反转链表1.分析2.翻转指针3.头插法 二、链表的中间结点1.分析1.求长度&#xff0c;找中点2.快慢指针 三、合并两个有序链表1.分析2.尾插法3.带哨兵位的头节点 四、环形链表1.分析2.快慢指针 一、反转链表 1.分析 给定单链表头结点&#xff0c;反转链表之后返回新的头…
阅读更多...
【LeetCode】19. 删除链表的倒数第 N 个结点（中等）——代码随想录算法训练营Day04

【LeetCode】19. 删除链表的倒数第 N 个结点（中等）——代码随想录算法训练营Day04

题目链接&#xff1a;19. 删除链表的倒数第 N 个结点 题目描述 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] 示例 2&#xff1a; 输入&a…
阅读更多...
leetcode 每日一题 2024年01月14日 删除排序链表中的重复元素

leetcode 每日一题 2024年01月14日 删除排序链表中的重复元素

题目 83. 删除排序链表中的重复元素 给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,1,2] 输出&#xff1a;[1,2]示例 2&#xff1a; 输入&#xff…
阅读更多...
数据结构与算法-栈和队列小练习

数据结构与算法-栈和队列小练习

&#x1f31e; 这里给大家分享一道栈的练习和一道队列的练习&#xff01; &#x1f388;1.练习一 利用栈的基本操作实现将任何一个十进制整数转化为R进制整数。 &#x1f52d;1.1栈的初始化 Sqstack::Sqstack() {base top new SElemType[InitStacksize];stacksize InitStac…
阅读更多...
算法通关村第二关-白银挑战链表反转的拓展问题

算法通关村第二关-白银挑战链表反转的拓展问题

大家好我是苏麟 , 今天聊一聊链表反转拓展问题 . 反转链表拓展问题 描述 : 给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 LeetCode 92.反转链表…
阅读更多...
算法刷题-链表

算法刷题-链表

算法刷题-链表 203. 移除链表元素 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5]…
阅读更多...
数据结构与算法—单链表

数据结构与算法—单链表

目录 一、链表 1、链表的概念及结构 2、分类 二、实现单向链表 1、声明链表结构体 2、输出 3、头插&尾插 4、头删尾删 5、查找 6、指定位置插入 7、删除指定节点 8、删除指定节点的后一个节点 9、单链表的销毁 完整版 LList.h LList.c text.c 一、链表 …
阅读更多...
《算法通关村第一关——链表青铜挑战笔记》

《算法通关村第一关——链表青铜挑战笔记》

《算法通关村第一关——链表青铜挑战笔记》 Java如何构造出链表 概念 如何构造出链表&#xff0c;首先必须了解什么是链表&#xff01; 单向链表就像一个铁链一样&#xff0c;元素之间相互链接&#xff0c;包含多个节点&#xff0c;每个节点有一个指向后继元素的next指针。…
阅读更多...
面试算法27：回文链表

面试算法27：回文链表

问题 如何判断一个链表是不是回文&#xff1f;要求解法的时间复杂度是O&#xff08;n&#xff09;&#xff0c;并且不得使用超过O&#xff08;1&#xff09;的辅助空间。如果一个链表是回文&#xff0c;那么链表的节点序列从前往后看和从后往前看是相同的。 分析 如果不考虑…
阅读更多...
Python数据结构（链表）

Python数据结构（链表）

Python数据结构&#xff08;链表&#xff09; 单向链表 单向链表也叫单链表&#xff0c;是链表中最简单的一种形式&#xff0c;它的每个节点包含两个域&#xff0c;一个信息域(元素域)和一个链接域。这个链接指向链表中的下一个节点&#xff0c;而最后一个节点的链接域则指向…
阅读更多...
【剑指Offer】36.二叉搜索树与双向链表

【剑指Offer】36.二叉搜索树与双向链表

题目 输入一棵二叉搜索树&#xff0c;将该二叉搜索树转换成一个排序的双向链表。如下图所示 数据范围&#xff1a;输入二叉树的节点数 0≤n≤1000&#xff0c;二叉树中每个节点的值 0≤val≤1000 要求&#xff1a;O(1)&#xff08;即在原树上操作&#xff09;&#xff0c;时间…
阅读更多...
计算机考研自命题(7)

计算机考研自命题(7)

1、C语言–最大公约数 1、求两个数的最大公约数&#xff0c;分别用递归和非递归方法。&#xff08;往年考题有&#xff09; # include<stdio.h>/* 解题思路&#xff1a; 最大公约数指的是两个或多个整数共有约数中最大的一个 采用的是欧几里得算法&#xff0c;也叫辗转相…
阅读更多...
【剑指Offer】：删除链表中的倒数第N个节点（此题是LeetCode上面的）剑指Offer上面是链表中的倒数第K个节点

【剑指Offer】：删除链表中的倒数第N个节点（此题是LeetCode上面的）剑指Offer上面是链表中的倒数第K个节点

给定一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] 示例 2&#xff1a; 输入&#xff1a;head [1], n 1 输出&#xff1a;[] 示例 3&#xff1a;…
阅读更多...
数据结构与算法（八）--使用链表实现队列

数据结构与算法（八）--使用链表实现队列

一、前言 我们上一章通过链表实现了栈这样一个数据结构&#xff0c;此次我们实现另一个数据结构–队列。我们知道链表的增删查操作只对链表头进行操作才有O(1)的时间复杂度&#xff0c;如果我们对链表的尾部进行操作&#xff0c;它的复杂度都是O(n)级别了。但是对于队列这种数…
阅读更多...
Leetcode链表问题汇总

Leetcode链表问题汇总

目录 [2. 两数相加](https://leetcode.cn/problems/add-two-numbers/)[206. 反转链表](https://leetcode.cn/problems/reverse-linked-list/)[92. 反转链表 II](https://leetcode.cn/problems/reverse-linked-list-ii/)[19. 删除链表的倒数第 N 个结点](https://leetcode.cn/pr…
阅读更多...
经典链表试题（二）

经典链表试题（二）

文章目录 一、移除链表元素1、题目介绍2、思路讲解3、代码实现 二、反转链表1、题目介绍2、思路讲解3、代码实现 三、相交链表1、题目介绍2、思路讲解3、代码实现 四、链表的中间结点1、题目介绍2、思路讲解3、代码实现 五、设计循环队列1、题目介绍2、思路讲解3、代码实现 六、…
阅读更多...
【单链表，循环链表和双向链表的时间效率比较，顺序表和链表的比较，有序表的合并------用顺序表实现，用链表实现】

【单链表，循环链表和双向链表的时间效率比较，顺序表和链表的比较，有序表的合并------用顺序表实现，用链表实现】

文章目录 一、单链表&#xff0c;循环链表和双向链表的时间效率比较二、顺序表和链表的比较三、线性表的应用1.线性表的合并1.1有序表的合并------用顺序表实现1.2有序表的合并--------用链表实现 一、单链表&#xff0c;循环链表和双向链表的时间效率比较 查找表头结点&#…
阅读更多...
(链表) 25. K 个一组翻转链表 ——【Leetcode每日一题】

(链表) 25. K 个一组翻转链表 ——【Leetcode每日一题】

❓ 25. K 个一组翻转链表 难度&#xff1a;困难 给你链表的头节点 head &#xff0c;每 k 个节点一组进行翻转&#xff0c;请你返回修改后的链表。 k 是一个正整数&#xff0c;它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍&#xff0c;那么请将最后剩余的节点保…
阅读更多...
【Java】数据结构链表

【Java】数据结构链表

链表数据结构特点&#xff1a;增删效率非常高、查询效率非常低 时间复杂度为O(n)链表分类&#xff1a;单链表、双链表、环形链表等。链表数据结构 增加操作——不需要扩容的。 直接找到链表中最后一个节点&#xff08;尾结点&#xff09;. next 新增结点 示例代码 单向链表-&…
阅读更多...
【JavaScript】leetcode链表相关题解

【JavaScript】leetcode链表相关题解

【JavaScript】leetcode链表相关题解 一、什么是链表&#xff1f;二、Javascript中的链表三、leetcode相关链表2.两数相加237.删除链表中的节点206.反转链表 &#x1f48e;个人主页: 阿选不出来 &#x1f48e;个人简介: 大三学生&#xff0c;热爱Web前端&#xff0c;随机掉落学…
阅读更多...
2023NOIP A层联测19-多边形

2023NOIP A层联测19-多边形

有一个正 n n n 边形&#xff0c;每个点的颜色为红色&#xff0c;蓝色&#xff0c;绿色中的其中一种。保证每种颜色至少出现一次且 n n n 边形上相邻的两个点颜色不同。你想要连接 n − 3 n−3 n−3 条对角线&#xff0c;使得对角线把整个图形分成了 n − 2 n−2 n−2 个三…
阅读更多...
刷题笔记day03-链表

刷题笔记day03-链表

前言 今天是刷题的第三天&#xff0c;坚持就是胜利 203.移除链表元素 增加一个头结点&#xff0c;这样可以统一删除操作 另外&#xff0c;遇到等于的值&#xff0c;就让 prev 指向 curr.Next &#xff0c;同时将curr更新指向 prev.Next。 /*** Definition for singly-linked…
阅读更多...
深入理解数据结构（2）——用数组实现队列

深入理解数据结构（2）——用数组实现队列

数组是一种数据结构&#xff0c;队列也是一种数据结构。它们都是由基础的语法实现的。 如果一个数据结构可以用另外的数据结构来实现&#xff0c;那么可以有力的证明——“数据结构是一种思想”&#xff0c;是一种讲语法组合起来实现某种功能的手段 “整体大于局部” 一、队列的…
阅读更多...
【数据结构】数组和字符串（八）：稀疏矩阵的链接存储：十字链表的创建、插入元素、遍历打印（按行、按列、打印矩阵）、销毁

【数据结构】数组和字符串（八）：稀疏矩阵的链接存储：十字链表的创建、插入元素、遍历打印（按行、按列、打印矩阵）、销毁

文章目录 4.2.1 矩阵的数组表示4.2.2 特殊矩阵的压缩存储a. 对角矩阵的压缩存储b~c. 三角、对称矩阵的压缩存储d. 稀疏矩阵的压缩存储——三元组表4.2.3三元组表的转置、加法、乘法、操作4.2.4十字链表0. 十字链表结构1. 创建2. 销毁3. 插入4. 打印矩阵形式5. 按行打印6.按列打…
阅读更多...
【王道代码】【2.3链表】d3

【王道代码】【2.3链表】d3

关键字&#xff1a; 奇偶序号拆分、a1&#xff0c;b1&#xff0c;a2&#xff0c;b2...an&#xff0c;bn拆分a1&#xff0c;a2...&#xff0c;bn&#xff0c;...b2&#xff0c;b1、删除相同元素
阅读更多...
二叉树的后续遍历（迭代法）

二叉树的后续遍历（迭代法）

迭代法实现二叉树的后续遍历 1、递归版本 public static void dfs(TreeNode root){if(rootnull){return;}if(root.left!null)dfs(root.left);if(root.right!null)dfs(root.right);System.out.println(root.val); }从递归版本可以看出我们第一步需要遍历完所有的左节点 这里我…
阅读更多...
算法训练营第三天 | 203.移除链表元素、707.设计链表 、206.反转链表

算法训练营第三天 | 203.移除链表元素、707.设计链表 、206.反转链表

关于链表我们应该了解什么&#xff1a; 代码随想录 在实际开发中&#xff0c;遇到指针我们要做好防御性编程。 问题&#xff08; 一 &#xff09; 题目描述 &#xff1a; 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点…
阅读更多...
C语言--单链表的创建及使用详解

C语言--单链表的创建及使用详解

C语言--单链表的创建及使用详解 1. 单链表定义1.1 工作原理1.2 优点 2. 单链表的创建2.1 文件创建2.2 节点创建2.3 链表显示 3. 链表操作3.1 尾插3.2 头插3.3 尾删3.4 头删3.5 指定数据寻找3.6 指定位置前插入3.7 指定位置删除 4. 单链表总内容4.1 test.c文件4.2 SList.h文件4.…
阅读更多...
链表的中间结点-力扣

链表的中间结点-力扣

1、题目描述 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结点。 题目链接&#xff1a;力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台备战技术面试&#xff1f;力扣提供海…
阅读更多...
链表题（4）

链表题（4）

本章内容 正文开始前给大家推荐个网站&#xff0c;前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家。点击跳转到网站。 今天继续给大家带来链表的相关练习题。 相交链表 这道题来自力扣网&#xff0c;链接…
阅读更多...
单链表相关面试题--3.给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点

单链表相关面试题--3.给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点

/* 解题思路&#xff1a; 通过快慢指针找到中间节点&#xff0c;快指针每次走两步&#xff0c;慢指针每次走一步&#xff0c;当快指针走到结尾的时候&#xff0c;慢指针正好走到中间位置 */ typedef struct ListNode Node; struct ListNode* middleNode(struct ListNode* head)…
阅读更多...
单链表相关面试题--1.删除链表中等于给定值 val 的所有节点

单链表相关面试题--1.删除链表中等于给定值 val 的所有节点

/* 解题思路&#xff1a;从头节点开始进行元素删除&#xff0c;每删除一个元素&#xff0c;需要重新链接节点 */ struct ListNode* removeElements(struct ListNode* head, int val) {if(head NULL)return NULL;struct ListNode* cur head;struct ListNode* prev NULL;while…
阅读更多...
leetcode刷题日记:202. Happy Number( 快乐数)和203. Remove Linked List Elements(移除链表元素)

leetcode刷题日记:202. Happy Number( 快乐数)和203. Remove Linked List Elements(移除链表元素)

202. Happy Number( 快乐数) 这一题的解决与之前的循环链表比较类似&#xff0c;因为如果不是快乐数的话&#xff0c;在数字变化的过程中必然遇到了数字变换的循环&#xff0c;所以我们需要在变换的过程中判断是否遇到了循环&#xff0c;判断是否在一个序列中存在循环&#xf…
阅读更多...
【数据结构】C语言实现带头双向循环链表万字详解(附完整运行代码)

【数据结构】C语言实现带头双向循环链表万字详解(附完整运行代码)

&#x1f984;个人主页:修修修也 &#x1f38f;所属专栏:数据结构 ⚙️操作环境:Visual Studio 2022 一.了解项目功能 在本次项目中我们的目标是实现一个带头双向循环链表: 该带头双向循环链表使用动态内存分配空间,可以用来存储任意数量的同类型数据. 带头双向循环链表结点(No…
阅读更多...
经典链表试题（一）

经典链表试题（一）

文章目录 一、两数相加1、题目介绍2、思路讲解3、代码实现 二、合并两个有序链表1、题目介绍2、思路讲解3、代码实现 三、环形链表&#xff08;二&#xff09;1、题目介绍2、思路讲解3、代码实现 四、环形链表&#xff08;一&#xff09;1、题目介绍2、思路讲解3、代码实现 五、…
阅读更多...
python查找算法_顺序查找

python查找算法_顺序查找

顺序查找&#xff08;Sequential Search&#xff09;是一种简单直观的搜索算法&#xff0c;用于在无序数组中查找特定元素。它的基本思想是逐个遍历数组中的元素&#xff0c;直到找到目标元素或遍历完整个数组。本文将介绍顺序查找的基本原理&#xff0c;并通过Python代码进行详…
阅读更多...
单链表OJ--8.相交链表

单链表OJ--8.相交链表

8.相交链表 160. 相交链表 - 力扣&#xff08;LeetCode&#xff09; /* 解题思路&#xff1a; 此题可以先计算出两个链表的长度&#xff0c;让长的链表先走相差的长度&#xff0c;然后两个链表同时走&#xff0c;直到遇到相同的节点&#xff0c;即为第一个公共节点 */struct Li…
阅读更多...
06 _ 链表（上）：如何实现LRU缓存淘汰算法

06 _ 链表（上）：如何实现LRU缓存淘汰算法

今天我们来聊聊“链表（Linked list）”这个数据结构。学习链表有什么用呢？为了回答这个问题，我们先来讨论一个经典的链表应用场景，那就是LRU缓存淘汰算法。 缓存是一种提高数据读取性能的技术，在硬件设计、软件开发中都有着非常广泛的应用，比如常见的CPU缓存、数据库缓存…
阅读更多...
【数据结构】——线性表简答题模板

【数据结构】——线性表简答题模板

目录 一、顺序表二、链表三、顺序表与链表的对比四、循环链表五、静态链表 一、顺序表 【顺序表是什么/数组与顺序表的区别】 1、数组和顺序表的区别在哪里&#xff1f; 答&#xff1a;顺序表体现了数据元素之间的线性关系&#xff0c;即一对一的关系&#xff0c;以及对数据元…
阅读更多...
环形链表（C++解法）

环形链表（C++解法）

题目 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&#…
阅读更多...
【206.反转链表】

【206.反转链表】

目录 一、题目描述二、算法原理三、代码实现 一、题目描述 二、算法原理 三、代码实现 class Solution { public:ListNode* reverseList(ListNode* head) {if(headnullptr) return nullptr;if(head->nextnullptr) return head;ListNode* newheadreverseList(head->next)…
阅读更多...
【数据结构】数组和字符串（十）：稀疏矩阵的链接存储：十字链表的矩阵操作（加法、乘法、转置）

【数据结构】数组和字符串（十）：稀疏矩阵的链接存储：十字链表的矩阵操作（加法、乘法、转置）

文章目录 4.2.1 矩阵的数组表示4.2.2 特殊矩阵的压缩存储a. 对角矩阵的压缩存储b~c. 三角、对称矩阵的压缩存储d. 稀疏矩阵的压缩存储——三元组表4.2.3三元组表的转置、加法、乘法、操作4.2.4十字链表0. 十字链表的基本操作1. 矩阵加法2. 矩阵乘法3. 矩阵转置4. 主函数 5. 代码…
阅读更多...
Leetcode—21.合并两个有序链表【简单】

Leetcode—21.合并两个有序链表【简单】

2023每日刷题&#xff08;十三&#xff09; Leetcode—21.合并两个有序链表 直接法实现代码 /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/ struct ListNode* mergeTwoLists(struct ListNode* list1, struct…
阅读更多...
25期代码随想录算法训练营第三天 | 203.移除链表元素、707.设计链表、206.反转链表

25期代码随想录算法训练营第三天 | 203.移除链表元素、707.设计链表、206.反转链表

目录 203.移除链表元素707.设计链表206.反转链表 203.移除链表元素 链接 使用虚拟头 # Definition for singly-linked list. # class ListNode: # def __init__(self, val0, nextNone): # self.val val # self.next next class Solution:def removeEl…
阅读更多...
力扣 203 移除链表元素

力扣 203 移除链表元素

目录 1.解题思路2.代码实现 1.解题思路 利用快慢指针&#xff0c;如果快指针此时的值为val则将此时满指针的next指向快指针的next利用循环&#xff0c;其次&#xff0c;要特意判断链表的头部为val的情况以及链表为空的情况. 2.代码实现 struct ListNode* removeElements(str…
阅读更多...
删除链表的倒数第n个节点（C++解法）

删除链表的倒数第n个节点（C++解法）

题目 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5]示例 2&#xff1a; 输入&#xff1a;head [1], n 1 输出&#xff1a;[]示例 3&#…
阅读更多...
【面试经典150 | 链表】循环链表

【面试经典150 | 链表】循环链表

文章目录 Tag题目来源题目解读解题思路方法一&#xff1a;哈希集合方法二&#xff1a;快慢指针方法三&#xff1a;计数 拓展其他语言python3 写在最后 Tag 【快慢指针】【哈希集合】【计数】【链表】 题目来源 141. 环形链表 题目解读 判断一个链表中是否存在环。 解题思路 …
阅读更多...
【队列的顺序表示，链式表示】

【队列的顺序表示，链式表示】

文章目录 队列的表示和实现相关术语队列的表示链队的表示链队的定义链队的初始化销毁链队列 链队列的入队出栈 队列的表示和实现 相关术语 队列&#xff08;Queue&#xff09;是仅在表尾进行插入操作&#xff0c;在表头进行删除操作的线性表。表尾即an端&#xff0c;称为队尾…
阅读更多...
寻找倒数第K个节点

寻找倒数第K个节点

这篇文章也是凑数的 ... 寻找倒数第K个节点 描述 : 找出单向链表中倒数第 k 个节点。返回该节点的值。 题目 : LeetCode 返回倒数第K个节点 : 面试题 02.02. 返回倒数第 k 个节点 说明 : 给定的 k 保证是有效的。 分析 : 我们给出个例子 : 首先&#xff0c;我们创建两个…
阅读更多...
21. 合并两个有序链表、Leetcode的Python实现

21. 合并两个有序链表、Leetcode的Python实现

博客主页&#xff1a;&#x1f3c6;看看是李XX还是李歘歘 &#x1f3c6; &#x1f33a;每天不定期分享一些包括但不限于计算机基础、算法、后端开发相关的知识点&#xff0c;以及职场小菜鸡的生活。&#x1f33a; &#x1f497;点关注不迷路&#xff0c;总有一些&#x1f4d6;知…
阅读更多...
ConcurrentLinkedDeque详解-Deque接口链表实现方案

ConcurrentLinkedDeque详解-Deque接口链表实现方案

简介 ConcurrentLinkedDeque是一种基于链表实现的线程安全的双端队列Deque。它提供了高效的并发访问和操作&#xff0c;适用于高并发场景下的数据共享和交互。 主要特点 线程安全 &#xff1a;ConcurrentLinkedDeque通过使用线程安全的并发控制机制&#xff0c;如内部分锁和C…
阅读更多...
考研数据结构线性表看这篇就够了之顺序表（一）

考研数据结构线性表看这篇就够了之顺序表（一）

目录 一.线性表 1.1 线性表的概念 1.2线性表的种类 1.2.1 静态线性表 1.2.2 线性表的动态存储 二动态顺序表的操作 2.1. 定义结构体与函数 2.2 初始化 2.2.1实参和形参的区别 2.2.2 用实参改变形参 题外话 int *p和int* p的区别 2.3 销毁 2.4 尾插 2.4.1 首先要判…
阅读更多...
LinkedList详解-Deque接口链表实现方案

LinkedList详解-Deque接口链表实现方案

简介 LinkedList实现了List和Deque接口。List是一个有序的集合&#xff0c;可以包含重复元素&#xff0c;它提供了在列表的头部、尾部或指定位置进行插入、删除和查找等操作的方法。Deque是双端队列&#xff0c;提供了在列表的头部和尾部进行插入和删除操作的方法。通过实现这…
阅读更多...
宏观角度认识递归之合并两个有序链表

宏观角度认识递归之合并两个有序链表

21. 合并两个有序链表 - 力扣&#xff08;LeetCode&#xff09; 依旧是利用宏观角度来看待问题&#xff0c;其中最主要的就是要找到重复的子问题&#xff1b; 题目中要求把两个有序链表进行合并&#xff0c;同时不能够创建新的节点&#xff0c;并返回链表的起始点&#xff1a;因…
阅读更多...
循环链表（单循环、双循环）(数据结构与算法)

循环链表（单循环、双循环）(数据结构与算法)

循环链表&#xff1a;循环单链表、循环双链表 1. 循环单链表 循环单链表&#xff08;Circular Singly Linked List&#xff09;是一种特殊类型的单链表&#xff0c;其中最后一个节点的指针指向头节点&#xff0c;形成一个循环。 循环单链表与普通单链表的主要区别在于&#xf…
阅读更多...
链表相关代码

链表相关代码

NodeList.h // // NodeList.hpp // FirstP // // Created by 赫赫 on 2023/10/31. // 链表相关代码&#xff1a;单链表、循环单链表、静态链表#ifndef NodeList_hpp #define NodeList_hpp #define MaxSize 10//定义静态链表最大长度#include <stdio.h> #include <…
阅读更多...
单链表OJ题——11.随机链表的复制

单链表OJ题——11.随机链表的复制

11.随机链表的复制 138. 随机链表的复制 - 力扣&#xff08;LeetCode&#xff09; /* 解题思路&#xff1a; 此题可以分三步进行&#xff1a; 1.拷贝链表的每一个节点&#xff0c;拷贝的节点先链接到被拷贝节点的后面 2.复制随机指针的链接&#xff1a;拷贝节点的随机指针指向…
阅读更多...
CSDN每日一题学习训练——Java版（两数相加、二叉树的锯齿形层序遍历、解数独）

CSDN每日一题学习训练——Java版（两数相加、二叉树的锯齿形层序遍历、解数独）

版本说明 当前版本号[20231106]。 版本修改说明20231106初版 目录 文章目录 版本说明目录两数相加题目解题思路代码思路补充说明参考代码 二叉树的锯齿形层序遍历题目解题思路代码思路参考代码 解数独题目解题思路代码思路补充说明参考代码 两数相加 题目 给你两个 非空 的…
阅读更多...
单链表（无头单项非循环）

单链表（无头单项非循环）

文章目录 前言概述链表的实现初始化遍历单链表创建新节点尾插头插尾删头删单链表的查找在pos位置之前插入一个节点在pos位置删除节点在pos位置后插入节点删除pos后一个节点销毁 结尾 前言 链表是一种物理存储结构上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通…
阅读更多...
【数据结构】单链表之--无头单向非循环链表

【数据结构】单链表之--无头单向非循环链表

前言&#xff1a;前面我们学习了动态顺序表并且模拟了它的实现&#xff0c;今天我们来进一步学习&#xff0c;来学习单链表&#xff01;一起加油各位&#xff0c;后面的路只会越来越难走需要我们一步一个脚印&#xff01; &#x1f496; 博主CSDN主页:卫卫卫的个人主页 &#x…
阅读更多...
NowCoder | 环形链表的约瑟夫问题

NowCoder | 环形链表的约瑟夫问题

NowCoder | 环形链表的约瑟夫问题 OJ链接 思路&#xff1a; 创建带环链表带环链表的删除节点 代码如下&#xff1a; #include<stdlib.h>typedef struct ListNode ListNode; ListNode* ListBuyNode(int x) {ListNode* node (ListNode*)malloc(sizeof(ListNode));node…
阅读更多...
python特殊循环队列_队中元素个数代替队尾指针

python特殊循环队列_队中元素个数代替队尾指针

对于循环队列来说&#xff0c;如果知道队头指针和队中元素个数&#xff0c;则可以计算出队尾指针。也就是说&#xff0c;可以用队中元素个数代替队尾指针。设计出这种循环队列的判队空、进队、出队和取队头元素的算法。 本例的循环队列包含data 数组、队头指针 front和队中元素…
阅读更多...
SCAUoj实验11 链表操作

SCAUoj实验11 链表操作

SCAU链表oj题目 文章目录 前言一、堂前习题1099 [填空题]链表的合并 二、堂上练习1098 [填空]链表结点的插入1104 [填空题]链表的倒序1101 [填空题]链表的排序 前言 刚开始学习链表可能会看得比较头晕&#xff0c;关键在于先理解链表的逻辑结构和物理结构&#xff0c;尤其是逻辑…
阅读更多...
【树的存储结构,孩子链表】

【树的存储结构,孩子链表】

文章目录 树和森林树的存储结构孩子链表 树和森林 森林&#xff1a;是m(m>0)棵互不相交的树的集合。 树的存储结构 1.双亲表示法 实现&#xff1a;定义结构数组存放树的结点&#xff0c;每个结点含两个域。 数据域&#xff1a;存放结点本身信息。 双亲域&#xff1a;指…
阅读更多...
随机链表的复制

随机链表的复制

题目描述 给你一个长度为n的链表&#xff0c;每个节点包含一个额外增加的随机指针random&#xff0c;该指针可以指向链表中的任何节点或空节点。构造这个链表的深拷贝。 深拷贝应该正好由n个全新节点组成&#xff0c;其中每个新节点的值都设为其对应的原节点的值。新节点的nex…
阅读更多...
《LeetCode力扣练习》代码随想录——链表（环形链表II---Java）

《LeetCode力扣练习》代码随想录——链表（环形链表II---Java）

《LeetCode力扣练习》代码随想录——链表&#xff08;环形链表II—Java&#xff09; 刷题思路来源于 代码随想录 142. 环形链表 II 双指针 /*** Definition for singly-linked list.* class ListNode {* int val;* ListNode next;* ListNode(int x) {* val…
阅读更多...
【数据结构】一题带你出师链表!

【数据结构】一题带你出师链表!

&#x1f984;个人主页:修修修也 &#x1f38f;所属专栏:数据结构 ⚙️操作环境:Visual Studio 2022 题目链接 138. 随机链表的复制https://leetcode.cn/problems/copy-list-with-random-pointer/ 题目描述 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机…
阅读更多...
每日一题(LeetCode)----链表--链表最大孪生和

每日一题(LeetCode)----链表--链表最大孪生和

每日一题(LeetCode)----链表–链表最大孪生和 1.题目&#xff08;2130. 链表最大孪生和&#xff09; 在一个大小为 n 且 n 为 偶数 的链表中&#xff0c;对于 0 < i < (n / 2) - 1 的 i &#xff0c;第 i 个节点&#xff08;下标从 0 开始&#xff09;的孪生节点为第 (n…
阅读更多...
【LeetCode】每日一题 2023_11_28 设计前中后队列（数组/链表/双端队列）

【LeetCode】每日一题 2023_11_28 设计前中后队列（数组/链表/双端队列）

文章目录 刷题前唠嗑题目&#xff1a;设计前中后队列题目描述代码与解题思路偷看大佬题解 结语 刷题前唠嗑 LeetCode&#xff1f;启动&#xff01;&#xff01;&#xff01; 这道题的难度&#xff0c;才是我想象中的中等题的难度好吧&#xff0c;昨天那玩意对我来说还是太难了…
阅读更多...
重排链表，剑指offerII 26,力扣 120

重排链表，剑指offerII 26,力扣 120

目录 力扣题目地址&#xff1a; 题目&#xff1a; 那我们直接看题解吧&#xff1a; 解题方法&#xff1a; 难度分析&#xff1a; 审题目事例提示&#xff1a; 解题分析&#xff1a; 解题思路&#xff1a; 解题补充&#xff1a; 力扣题目地址&#xff1a; 143. 重排链表 - 力扣&…
阅读更多...
【力扣206】反转链表

【力扣206】反转链表

【力扣206】反转链表 一.题目描述 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1 &#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2 &#xff1a; 输入&#xff1a;head [1,2] 输出&#x…
阅读更多...
【数据结构初阶】单链表

【数据结构初阶】单链表

各位读者老爷好&#xff0c;鼠鼠我又来了哈。鼠鼠我呀现在来基于C语言实现一下单链表&#xff0c;希望对你有所帮助&#xff01; 目录 1.链表的概念及结构 2.链表的分类 3.无头单向非循环链表的实现 3.1.单链表打印 3.2.单链表尾插 3.3.单链表头插 3.4.单链表尾删 3.5…
阅读更多...
掌握反转链表的艺术：LeetCode 206 深入解析与优化 - 双指针与递归方法精讲

掌握反转链表的艺术：LeetCode 206 深入解析与优化 - 双指针与递归方法精讲

LeetCode.206反转链表 1.问题描述2.解题思路3.代码 1.问题描述 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&#xff1a; 输入&#xff1a…
阅读更多...
中缀表达式转后缀表达式（详解）

中缀表达式转后缀表达式（详解）

**中缀表达式转后缀表达式的一般步骤如下&#xff1a; 1&#xff1a;创建一个空的栈和一个空的输出列表。 2&#xff1a;从左到右扫描中缀表达式的每个字符。 3&#xff1a;如果当前字符是操作数&#xff0c;则直接将其加入到输出列表中。 4&#xff1a;如果当前字符是运算符&a…
阅读更多...
【力扣】160.相交链表

【力扣】160.相交链表

160.相交链表 这个题目因为我之前在学指针的时候没学好&#xff0c;所以总感觉有一种畏难&#xff0c;我害怕。但是当真正的开始学习之后&#xff0c;发现现在的脑袋还是能用的&#xff0c;所以不要放弃&#xff0c;你可以的&#xff01; 题解&#xff1a; 总的来说还是挺简…
阅读更多...
【C/PTA】结构体进阶练习

【C/PTA】结构体进阶练习

本文结合PTA专项练习带领读者掌握结构体&#xff0c;刷题为主注释为辅&#xff0c;在代码中理解思路&#xff0c;其它不做过多叙述。 目录 7-1 一帮一7-2 考试座位号7-3 新键表输出7-4 可怕的素质7-5 找出同龄者7-6 排队7-7 军训7-8 双链表 7-1 一帮一 “一帮一学习小组”是中…
阅读更多...
LeetCode-23. 合并 K 个升序链表

LeetCode-23. 合并 K 个升序链表

问题分析 先建立一个小顶堆将每一路的最小元素都加入小顶堆&#xff0c;此时堆顶元素就是全局的最小值将堆顶元素弹出。若堆顶元素所在的数组不为空&#xff0c;则将下一元素加入堆中重复2、3操作&#xff0c;直到所有数据都读取完毕将堆内元素按顺序读出&#xff0c;并清空堆…
阅读更多...
数据结构之----数组、链表、列表

数据结构之----数组、链表、列表

数据结构之----数组、链表、列表 什么是数组&#xff1f; 数组是一种线性数据结构&#xff0c;它将相同类型的元素存储在连续的内存空间中。 我们将元素在数组中的位置称为该元素的索引。 数组常用操作 1. 初始化数组 我们可以根据需求选用数组的两种初始化方式&#xff…
阅读更多...
算法模板之单链表图文讲解

算法模板之单链表图文讲解

&#x1f308;个人主页&#xff1a;聆风吟 &#x1f525;系列专栏&#xff1a;算法模板、数据结构 &#x1f516;少年有梦不应止于心动&#xff0c;更要付诸行动。 文章目录 &#x1f4cb;前言一. ⛳️使用数组模拟单链表讲解1.1 &#x1f514;为什么我们要使用数组去模拟单链表…
阅读更多...
Golang leetcode206 翻转链表 迭代 递归 双指针

Golang leetcode206 翻转链表 迭代 递归 双指针

文章目录 翻转链表 leetcode206题解第一版 直接建立新的链表双指针迭代递归法 翻转链表 leetcode206 至此走到这里&#xff0c;我们对于链表的结构应当已经比较熟悉&#xff0c;下面的就是敢于操作 题解第一版 直接建立新的链表 时间复杂度太高 // 初始方法&#xff0c;建立…
阅读更多...
力扣25题： K 个一组翻转链表

力扣25题： K 个一组翻转链表

【题目链接】力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台&#xff0c;解题代码如下&#xff1a; class Solution {public ListNode reverseKGroup(ListNode head, int k) {ListNode curNode head;ListNode groupHead, groupTail head, lastGrou…
阅读更多...
104 二叉树的垂序遍历

104 二叉树的垂序遍历

问题描述&#xff1a;给你二叉树的根节点root&#xff0c;请你设计算法计算二叉树的垂序遍历序列。对位于(row,col)的每个节点而言&#xff0c;其左右子节点分别为(row1,col-1)和(row1,col1),根节点位于(0,0),二叉树的垂序遍历是从最左边的列开始直到最右边的列结束&#xff0c…
阅读更多...
【leetcode】力扣热门之反转链表【简单难度】

【leetcode】力扣热门之反转链表【简单难度】

题目描述 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 用例 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1] 输入&#xff1a;head [1,2] 输出&#xff1a;[2,1] 输入&#xff1a;head [] 输出&#xff1a;[…
阅读更多...
用尾插的思想实现移除链表中的元素

用尾插的思想实现移除链表中的元素

目录 一、介绍尾插 1.链表为空 2.链表不为空 二、题目介绍 三、思路 四、代码 五、代码解析 1. 2. 3. 4. 5. 6. 六、注意点 1. 2. 一、介绍尾插 整体思路为 1.链表为空 void SLPushBack(SLTNode** pphead, SLTDataType x) {SLTNode* newnode BuyLTNode(x); …
阅读更多...
15届蓝桥杯备赛(2)

15届蓝桥杯备赛(2)

文章目录 刷题笔记(2)二分查找在排序数组中查找元素的第一个和最后一个位置寻找旋转排序数组中的最小值搜索旋转排序数组 链表反转链表反转链表II 二叉树相同的树对称二叉树平衡二叉树二叉树的右视图验证二叉搜索树二叉树的最近公共祖先二叉搜索树的最近公共祖先二叉树层序遍历…
阅读更多...
【链表】算法例题

【链表】算法例题

目录 八、 链表 57. 环形链表 ① 58. 两数相加 ② √ 59. 合并两个有序链表 ① √- 60. 随机链表的复制 ② 61. 反转链表II ② 62. K个一组翻转链表 ③ 63. 删除链表的倒数第N个结点 ② √- 64. 删除排序链表中的重复元素II ② √- 65. 旋转链表 ② √- 66. 分隔链…
阅读更多...
【数据结构】顺序表和链表详解顺序表和链表的实现

【数据结构】顺序表和链表详解顺序表和链表的实现

主页&#xff1a;醋溜马桶圈-CSDN博客 专栏&#xff1a;数据结构_醋溜马桶圈的博客-CSDN博客 gitee&#xff1a;mnxcc (mnxcc) - Gitee.com 目录 1.线性表 1.1 顺序表 1.1.1 概念及结构 1.1.2 静态顺序表 1.1.3 动态顺序表 1.2 链表 1.2.1 链表的概念及结构 1.2.2 链表…
阅读更多...
20240313-1-链表linklist

20240313-1-链表linklist

linklist 链表也是面试中常问道的题目&#xff0c;链表定义简单很容易考察面试者的水平&#xff0c;比如在数组中很简单的题目转换成链表就有很大的变动。例如链表的插入和归并排序、查找倒数第k个节点等. 1.回文链表&#xff08;234&#xff09; 请判断一个链表是否为回文链…
阅读更多...
回文链表Java

回文链表Java

我们可以采用双指针的办法进行,如下图: 如果链表长度为偶数,则直接从第二个指针的位置开始对链表进行反转;如果是奇数,则从第二指针的下一位进行链表反转 代码实现: public static void main(String[] args) {ListNode next4 new ListNode(1, null);ListNode next3 new Lis…
阅读更多...
算法通关村第四关-青铜挑战基于链表完成栈

算法通关村第四关-青铜挑战基于链表完成栈

大家好我是苏麟 , 今天聊聊. 本期大纲 栈的基础知识栈的特征栈的操作Java中的栈 基于链表实现栈 栈的基础知识 栈的特征 栈和队列是比较特殊的线性表&#xff0c;又称之为访问受限的线性表。栈是很多表达式、符号等运算的基础&#xff0c;也是递归的底层实现。理论上递归能做…
阅读更多...
c++通过对象的地址初始化指针，需要对指针进行释放么（企业链表衍生）

c++通过对象的地址初始化指针，需要对指针进行释放么（企业链表衍生）

在C中&#xff0c;如果你通过对象的地址来初始化指针&#xff0c;通常情况下是不需要手动释放指针的。这是因为对象的生存期与指针所指向的对象的生存期相关联。当对象超出其作用域或被销毁时&#xff0c;指向该对象的指针也会自动成为悬挂指针&#xff0c;这种情况下再访问该指…
阅读更多...
堆栈与队列算法-以链表来实现队列

堆栈与队列算法-以链表来实现队列

目录 堆栈与队列算法-以链表来实现队列 C代码 堆栈与队列算法-以链表来实现队列 队列除了能以数组的方式来实现外&#xff0c;也可以用链表来实现。在声明队列的类中&#xff0c;除了和队列相关的方法外&#xff0c;还必须有指向队列前端和队列末尾的指针&#xff0c;即fron…
阅读更多...
队列（定义，基本操作，顺序存储，链式存储）

队列（定义，基本操作，顺序存储，链式存储）

目录 1.队列的定义1.重要术语2.基本操作 2.队列的顺序存储1.基本操作1.初始化2.判空3.入队&#xff08;循环队列&#xff09;4.出队5.读队头 2.判断队列已满/已空 3.队列的链式存储1.基本操作&#xff08;带头结点&#xff09;1.初始化2.判空3.入队4.出队5.队满条件 1.队列的定…
阅读更多...
【面试经典150 | 链表】随机链表的复制

【面试经典150 | 链表】随机链表的复制

文章目录 Tag题目来源题目解读解题思路方法一&#xff1a;哈希表递归方法二&#xff1a;哈希表方法三&#xff1a;迭代拆分节点 写在最后 Tag 【递归】【迭代】【链表】 题目来源 138. 随机链表的复制 题目解读 对一个带有随机指向的链表进行深拷贝操作。 解题思路 本题一共…
阅读更多...
141. 环形链表、Leetcode的Python实现

141. 环形链表、Leetcode的Python实现

博客主页&#xff1a;&#x1f3c6;看看是李XX还是李歘歘 &#x1f3c6; &#x1f33a;每天分享一些包括但不限于计算机基础、算法等相关的知识点&#x1f33a; &#x1f497;点关注不迷路&#xff0c;总有一些&#x1f4d6;知识点&#x1f4d6;是你想要的&#x1f497; ⛽️今…
阅读更多...
链表指定节点的插入

链表指定节点的插入

向现有链表中插入结点&#xff0c;根据插入位置的不同&#xff0c;可分为以下 3 种情况&#xff1a; 插入到链表的头部&#xff0c;作为新的链表中第一个存有数据的结点&#xff08;又称为”首元结点”&#xff09;&#xff1b;插入到链表中某两个结点之间的位置&#xff1b;插…
阅读更多...
61. 旋转链表、Leetcode的Python实现

61. 旋转链表、Leetcode的Python实现

博客主页&#xff1a;&#x1f3c6;李歘歘的博客 &#x1f3c6; &#x1f33a;每天不定期分享一些包括但不限于计算机基础、算法、后端开发相关的知识点&#xff0c;以及职场小菜鸡的生活。&#x1f33a; &#x1f497;点关注不迷路&#xff0c;总有一些&#x1f4d6;知识点&am…
阅读更多...
链表的结点个数统计及查找

链表的结点个数统计及查找

链表节点个数统计 要统计链表中的节点个数&#xff0c;只需要遍历整个链表&#xff0c;并在遍历的过程中计数即可。具体实现代码如下&#xff1a;(仍然使用C#) 先定义一个整型函数(节点个数的返回值一定是整型变量) int getLinkNodeNum(struct Test *head) {int cnt 0;whil…
阅读更多...
【24.两两交换链表中的节点】

【24.两两交换链表中的节点】

目录 一、题目描述二、算法原理三、代码实现 一、题目描述 二、算法原理 三、代码实现 class Solution { public:ListNode* swapPairs(ListNode* head) {if(headnullptr||head->nextnullptr) return head;ListNode* curhead,*nexthead->next;ListNode* nnextswapPairs(n…
阅读更多...
数据结构实验二停车场

数据结构实验二停车场

内容仅供个人复习 *设停车场内只有一个的停放 n 辆汽车的狭长通道&#xff0c;且只有一个大门可供汽车进出。汽车 在停车场内按车辆到达时间的先后顺序&#xff0c;依次由北向南排列&#xff08;大门在最南端&#xff0c;最先到达的第 一辆车停放在车场的最北端&#xff09;&am…
阅读更多...
线性表（顺序表，单链表，双链表，循环链表，静态链表）

线性表（顺序表，单链表，双链表，循环链表，静态链表）

目录 1.线性表的定义1.几个重要的概念2.逻辑结构 2.线性表的基本操作3.顺序表&#xff08;线性表的顺序存储&#xff09;1.静态分配2.动态分配3.顺序表的特点4.顺序表的基本操作1.插入2.删除3.查找1.按位查找2.按值查找 4.链表&#xff08;线性表的链式存储&#xff09;1.单链表…
阅读更多...
LeetCode_Java_递归系列（题目+思路+代码）

LeetCode_Java_递归系列（题目+思路+代码）

206.反转链表 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]以此类推&#xff0c;直到反转结束返回头结点 class Solution {public ListNode rever…
阅读更多...
链表的分割、哨兵位

链表的分割、哨兵位

目录 一、描述 二、解析 三、代码 四、代码解析 1. 2. 3. 4. 五、注意 一、描述 现有一链表的头指针 ListNode* pHead&#xff0c;给一定值x&#xff0c;编写一段代码将所有小于x的结点排在其余结点之前&#xff0c;且不能改变原来的数据顺序&#xff0c;返回重新排列…
阅读更多...
嵌入式学习第三十天！（单向链表练习）

嵌入式学习第三十天！（单向链表练习）

1. 单向链表的逆序&#xff1a; int Is_Empty_Link(LINK_LIST *plist) {return plist->phead NULL; }void Reverse_Link(LINK_LIST *plist) {LINK_NODE *ptmp plist->phead;LINK_NODE *pinsert NULL;plist->phead NULL;if(Is_Empty_Link(plist)){return;}else{wh…
阅读更多...
数据结构基础（三）链表

数据结构基础（三）链表

链表&#xff08;Linked List&#xff09;是一种常见的线性数据结构&#xff0c;由一系列称为节点&#xff08;Node&#xff09;的元素组成&#xff0c;每个节点包含两部分&#xff1a;数据&#xff08;Data&#xff09;和指向下一个节点的引用&#xff08;Pointer 或者 Link&a…
阅读更多...
LeetCode 热题100 链表专题解析

LeetCode 热题100 链表专题解析

LeetCode 热题100 链表专题解析 链表是计算机科学中非常基础且重要的数据结构&#xff0c;同时也是面试和算法竞赛中的常客。在 LeetCode 热题100 中&#xff0c;链表相关的题目涉及多种技巧和算法思维。本文将深入解析这些题目&#xff0c;帮助读者掌握链表相关问题的解决方法…
阅读更多...
面试算法-98-随机链表的复制

面试算法-98-随机链表的复制

题目 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节点的值。新节…
阅读更多...
力扣|两数相加|链表

力扣|两数相加|链表

给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0c;这两个数都不会以 0 …
阅读更多...
每日一题 --- 反转链表[力扣][Go]

每日一题 --- 反转链表[力扣][Go]

反转链表 题目&#xff1a;206. 反转链表 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&a…
阅读更多...
【数据结构和算法初阶(C语言)】二叉树的顺序结构--堆的实现/堆排序/topk问题详解---二叉树学习日记②12

【数据结构和算法初阶(C语言)】二叉树的顺序结构--堆的实现/堆排序/topk问题详解---二叉树学习日记②12

目录 ​编辑 1.二叉树的顺序结构及实现 1.1 二叉树的顺序结构 2 堆的概念及结构 3 堆的实现 3.1堆的代码定义 3.2堆插入数据 3.3打印堆数据 3.4堆的数据的删除 3.5获取根部数据 3.6判断堆是否为空 3.7 堆的销毁 4.建堆以及堆排序 4.1堆排序---是一种选择排序 4.2升序建大堆&a…
阅读更多...
面试算法-96-二叉树展开为链表

面试算法-96-二叉树展开为链表

题目 给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左子指针始终为 null 。 展开后的单链表应该与二叉树 先序遍历 顺序相同。 示例 1…
阅读更多...
【数据结构】双向奔赴的爱恋 --- 双向链表

【数据结构】双向奔赴的爱恋 --- 双向链表

关注小庄 顿顿解馋๑ᵒᯅᵒ๑ 引言&#xff1a;上回我们讲解了单链表(单向不循环不带头链表)&#xff0c;我们可以发现他是存在一定缺陷的&#xff0c;比如尾删的时候需要遍历一遍链表&#xff0c;这会大大降低我们的性能&#xff0c;再比如对于链表中的一个结点我们是无法直接…
阅读更多...
线性数据结构----(数组,链表,栈,队列，哈希表)

线性数据结构----(数组,链表,栈,队列，哈希表)

线性数据结构 数组链表栈使用场景 队列应用场景 哈希表特点哈希函数&#xff0c;哈希值&#xff0c;哈希冲突键值对 Entry 开放寻址法和拉链法 参考文档 数组 数组(Array) 是一种很常见的数据结构。由相同类型的元素组成&#xff0c;并且是使用一块连续的内存来存储的。 在数组…
阅读更多...
LeetCode 热题100——链表专题（二）

LeetCode 热题100——链表专题（二）

一、环形链表 141.环形链表&#xff08;题目链接&#xff09; 思路&#xff1a;使用快慢指针&#xff0c;慢指针走一步&#xff0c;快指针走俩步&#xff0c;如果是环形链表&#xff0c;那么快慢指针一定相遇&#xff0c;如果不是环形结构那么快指针或者快指针的next一定先为N…
阅读更多...
LeetCode75——Day29

LeetCode75——Day29

文章目录 一、题目二、题解 一、题目 2095. Delete the Middle Node of a Linked List You are given the head of a linked list. Delete the middle node, and return the head of the modified linked list. The middle node of a linked list of size n is the ⌊n / 2⌋…
阅读更多...
经典OJ题：环形节点是否存在！

经典OJ题：环形节点是否存在！

题目&#xff1a; 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位…
阅读更多...
【数据结构】线性表的链式存储结构

【数据结构】线性表的链式存储结构

&#x1f984;个人主页:修修修也 &#x1f38f;所属专栏:数据结构 ⚙️操作环境:Visual Studio 2022 顺序存储结构的不足的解决办法 从上一节我们对顺序表的讨论中可见,线性表的顺序存储结构的特点是: 逻辑关系上相邻的两个元素在物理位置(内存)上也相邻,因此可以随机存取表中…
阅读更多...
20 _ 散列表（下）：为什么散列表和链表经常会一起使用？

20 _ 散列表（下）：为什么散列表和链表经常会一起使用？

有两种数据结构，散列表和链表，经常会被放在一起使用。 例如，如何用链表来实现LRU缓存淘汰算法，但是链表实现的LRU缓存淘汰算法的时间复杂度是O(n)，当时我也提到了，通过散列表可以将这个时间复杂度降低到O(1)。 Redis的有序集合是使用跳表来实现的，跳表可以看作一种改进…
阅读更多...
多种方法解决leetcode经典题目-LCR 155. 将二叉搜索树转化为排序的双向链表， 同时弄透引用变更带来的bug

多种方法解决leetcode经典题目-LCR 155. 将二叉搜索树转化为排序的双向链表， 同时弄透引用变更带来的bug

1 描述 2 解法一: 使用list列表粗出中序遍历的结果&#xff0c;然后再依次处理list中的元素并且双向链接 public Node treeToDoublyList2(Node root) {if(rootnull)return root;Node dummynew Node(-10000);List<Node>ansnew ArrayList<>();dfs2(root,ans);Node p…
阅读更多...
Leetcode—707.设计链表【中等】双链表的设计明天再写

Leetcode—707.设计链表【中等】双链表的设计明天再写

2023每日刷题&#xff08;十七&#xff09; Leetcode—707.设计链表 设计单链表实现代码 typedef struct Node {int val;struct Node* next; } MyLinkedList;MyLinkedList* myLinkedListCreate() {MyLinkedList* mList (MyLinkedList *)malloc(sizeof(MyLinkedList));mList-&…
阅读更多...
151. 反转字符串中的单词

151. 反转字符串中的单词

151. 反转字符串中的单词 原题链接&#xff1a;完成情况&#xff1a;解题思路&#xff1a;参考代码&#xff1a;错误经验吸取 原题链接&#xff1a; 151. 反转字符串中的单词 https://leetcode.cn/problems/reverse-words-in-a-string/description/ 完成情况&#xff1a; 解…
阅读更多...
【LeetCode刷题-链表】--203.移除链表元素

【LeetCode刷题-链表】--203.移除链表元素

203.移除链表元素 方法&#xff1a;定义一个节点指向头节点head&#xff0c;避免头结点单独操作 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* …
阅读更多...
【LeetCode刷题-链表】--82.删除排序链表中的重复元素II

【LeetCode刷题-链表】--82.删除排序链表中的重复元素II

82.删除排序链表中的重复元素II 由于链表是排好序的&#xff0c;所以只需要对其进行一次遍历即可&#xff0c;比较相邻节点对应的值 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(…
阅读更多...
(复刷) 面试题02.07.链表相交

(复刷) 面试题02.07.链表相交

原题链接&#xff1a;面试题02.07.链表相交 思路&#xff1a; 求相交的起始结点&#xff0c;并不是值相交&#xff0c;而是结点相交&#xff0c;那么也就代表判断条件是指针指向的位置相等即可 A、B链表长度可能不一致&#xff0c;假设他们一定有相交的结点 那么需要做的 就是…
阅读更多...
day2链表

day2链表

单循环链表&#xff1a;&#xff08;典型应用&#xff09;约瑟夫环 自行了解 #include<iostream> using namespace std;class CircleLink { public:CircleLink(){_head new Node();_tail _head;_head->_next _head;}~CircleLink(){Node* p _head->_next;while…
阅读更多...
每日一题 --- 删除链表的倒数第 N 个结点[力扣][Go]

每日一题 --- 删除链表的倒数第 N 个结点[力扣][Go]

删除链表的倒数第 N 个结点 题目&#xff1a;19. 删除链表的倒数第 N 个结点 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5]示例 2&#x…
阅读更多...
【链表】Leetcode 138. 随机链表的复制【中等】

【链表】Leetcode 138. 随机链表的复制【中等】

随机链表的复制 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节点…
阅读更多...
第2章顺序表与链表

第2章顺序表与链表

顺序表 整体大小为9-size 元素个数为5-count 插入的时候size&#xff0c;count不变 扩充&#xff1a;size不变&#xff0c;count加容量 结构定义&#xff1a;size count 连续存储区 realloc 直接往后扩容&#xff0c;没空间呢&#xff1f;找一篇新的空间&#xff0c;并删除…
阅读更多...
带头双向循环链表的实现及注释教学

带头双向循环链表的实现及注释教学

首先需要借助三个文件 test.c list.h list.c 目录 list.h list.c test.c list.h 用于声明函数及创建结构体、包含头文件 #pragma once #include<stdio.h> #include<stdlib.h> #include<assert.h> #include<stdbool.h>typedef int LTDa…
阅读更多...
【数据结构】链表习题之反转链表和删除链表中等于给定值 val 的所有节点

【数据结构】链表习题之反转链表和删除链表中等于给定值 val 的所有节点

&#x1f451;个人主页&#xff1a;啊Q闻 &#x1f387;收录专栏&#xff1a;《数据结构》 &#x1f389;道阻且长&#xff0c;行则将至 前言 今天的博客是关于链表的题目&#xff0c;力扣上的题目之反转链表和删除链表中等于给定值 val 的所有节点 一.反转…
阅读更多...
面试算法-87-分隔链表

面试算法-87-分隔链表

题目 给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你应当 保留 两个分区中每个节点的初始相对位置。 示例 1&#xff1a; 输入&#xff1a;head [1,4,3,2,5,2], x …
阅读更多...
力扣_876_ 链表的中间结点(c语言）

力扣_876_ 链表的中间结点(c语言）

题目描述&#xff1a; 解题方法&#xff1a; struct ListNode* middleNode(struct ListNode* head) {struct ListNode* l1,*l2;l1l2head;while(l2&&l2->next){l1l1->next;l2l2->next->next;}return l1; }
阅读更多...
从链表中移除节点(leetcode)

从链表中移除节点(leetcode)

题目链接&#xff1a;. - 力扣&#xff08;LeetCode&#xff09; 方法一&#xff1a;翻转链表 思路&#xff1a; 当右侧有更大值 就需要移除 翻转后 左侧有更大值 就需要移除 翻转后 8 3 13 2 5 定义一个最大值max 第一个节点的值依次迭代 max 8 max …
阅读更多...
【算法刷题】总结规律 算法题目第2讲 [234] 回文链表，因为深浅拷贝引出的bug

【算法刷题】总结规律 算法题目第2讲 [234] 回文链表，因为深浅拷贝引出的bug

配合b站视频讲解食用更佳:https://www.bilibili.com/video/BV1vW4y1P7V7 核心提示&#xff1a;好几道题是处理有序数组的&#xff01; 适合人群&#xff1a;考研/复试/面试 解决痛点&#xff1a;1. 刷了就忘 2.换一道相似的题就不会 学完后会输出&#xff1a;对每类题目的框架…
阅读更多...
【数据结构与算法】之数组系列-20240113

【数据结构与算法】之数组系列-20240113

这里写目录标题 一、66. 加一二、121. 买卖股票的最佳时机三、136. 只出现一次的数字四、268. 丢失的数字五、350. 两个数组的交集 II 一、66. 加一 简单 给定一个由 整数 组成的 非空 数组所表示的非负整数&#xff0c;在该数的基础上加一。 最高位数字存放在数组的首位&…
阅读更多...
【每日一题】删除排序链表中的重复元素

【每日一题】删除排序链表中的重复元素

文章目录 Tag题目来源解题思路方法一&#xff1a;比较相邻两节点 写在最后 Tag 【遍历】【链表】【2024-01-14】 题目来源 83. 删除排序链表中的重复元素 解题思路 方法一&#xff1a;比较相邻两节点 思路 比较两个相邻的节点&#xff0c;如果下一个节点值和当前节点值一样…
阅读更多...
【数据结构】 双链表的基本操作 （C语言版）

【数据结构】 双链表的基本操作 （C语言版）

目录 一、双链表 1、双链表的定义&#xff1a; 2、双链表表的优缺点&#xff1a; 二、双链表的基本操作算法&#xff08;C语言&#xff09; 1、宏定义 2、创建结构体 3、双链表的初始化 4、双链表表插入 5、双链表的查找 6、双链表的取值 7、求双链表长度 8、双链表…
阅读更多...
【nowcoder】链表分割

【nowcoder】链表分割

牛客题目链接 链表分割 /* struct ListNode {int val;struct ListNode *next;ListNode(int x) : val(x), next(NULL) {} };*/ #include <cstddef> class Partition {public:ListNode* partition(ListNode* pHead, int x) {if (pHead ! NULL) {// 1.两个链表&#xff0c…
阅读更多...
力扣 138. 随机链表的复制

力扣 138. 随机链表的复制

题目描述&#xff1a; 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的…
阅读更多...
数据结构-链表的简单操作实现

数据结构-链表的简单操作实现

目录 0.链表前序工作 1.构建出一个链表 2.展示链表中的所有存储数据 3.查找关键字key是否在链表中 4.求链表的长度 5.头插法 6.尾插法 7.插入任意位置&#xff08;规定第一个元素位置为0下标&#xff09; 8.删除第一次出现的值为key的关键字 9.删除所有值为key的关键字…
阅读更多...
python JZ35 复杂链表的复制（剑指offer）

python JZ35 复杂链表的复制（剑指offer）

题目要求: 思路: 思路1&#xff1a;引入dict 思路1&#xff1a;双指针 代码如下: 思路1代码&#xff1a; # -*- coding:utf-8 -*- # class RandomListNode: # def __init__(self, x): # self.label x # self.next None # self.random None …
阅读更多...
数据结构：链表的冒泡排序

数据结构：链表的冒泡排序

法一&#xff1a;修改指针指向 //法二 void maopao_link(link_p H){if(HNULL){printf("头节点为空\n");return;}if(link_empty(H)){printf("链表为空\n");return;}link_p tailNULL;while(H->next->next!tail){link_p pH;link_p qH->next;while(q…
阅读更多...
【数据结构】队列OJ题《用队列实现栈》（题库+解析+代码）

【数据结构】队列OJ题《用队列实现栈》（题库+解析+代码）

1.前言 通过前面队列的实现和详解大家对队列应该有一定熟悉了&#xff0c;现在上强度开始做题吧 队列详解&#xff1a;http://t.csdnimg.cn/dvTsW 2.OJ题目训练225. 用队列实现栈 题目分析 请你仅使用两个队列实现一个后入先出&#xff08;LIFO&#xff09;的栈&#xff0…
阅读更多...
Linux内核基础 - list_splice_tail_init函数详解

Linux内核基础 - list_splice_tail_init函数详解

解析 Linux Kernel 4.19 的 list_splice_tail_init 函数 摘要 本文档旨在解析 Linux 内核 4.19 版本中 list_splice_tail_init 函数的作用&#xff0c;这是一个处理内核链表的重要函数。通过此函数&#xff0c;可以将一个链表插入到另一个链表的尾部&#xff0c;并将源链表初…
阅读更多...
【leetcode热题】环形链表 II

【leetcode热题】环形链表 II

难度&#xff1a; 中等通过率&#xff1a; 30.1%题目链接&#xff1a;. - 力扣&#xff08;LeetCode&#xff09; 题目描述 给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 为了表示给定链表中的环&#xff0c;我们使用整数…
阅读更多...
【Python刷题】环形链表

【Python刷题】环形链表

问题描述 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&a…
阅读更多...
代码随想录算法训练营第四天|24.两两交换链表中的节点、19.删除链表的倒数第N的节点、07.链表相交、142.环形链表II

代码随想录算法训练营第四天|24.两两交换链表中的节点、19.删除链表的倒数第N的节点、07.链表相交、142.环形链表II

代码随想录算法训练营第四天|24.两两交换链表中的节点、19.删除链表的倒数第N的节点、07.链表相交、142.环形链表II 24.两两交换链表中的节点 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成…
阅读更多...
数据结构从入门到精通——队列

数据结构从入门到精通——队列

队列 前言一、队列1.1队列的概念及结构1.2队列的实现1.3队列的实现1.4扩展 二、队列面试题三、队列的具体实现代码Queue.hQueue.ctest.c队列的初始化队列的销毁入队列出队列返回队头元素返回队尾元素检测队列是否为空检测元素个数 前言 队列是一种特殊的线性数据结构&#xff…
阅读更多...
集合实现类研究底层（部分）：手撕ArrayList底层源码、手撕LinkedList底层源码、手写单向链表和双向链表

集合实现类研究底层（部分）：手撕ArrayList底层源码、手撕LinkedList底层源码、手写单向链表和双向链表

day26上 集合框架图 标绿已经学习底层&#xff0c;深入底层主要是研究实现类底层 继承关系图 手撕ArrayList底层源码 ps:研究添加元素的过程 思路&#xff1a; 1.研究继承关系 2.研究属性 3.理解创建集合的过程 – 构造方法的底层原理 4.研究添加元素的过程 提升&#xff1a…
阅读更多...
数据结构：静态链表（编程技巧）

数据结构：静态链表（编程技巧）

链表的元素用数组存储&#xff0c; 用数组的下标模拟指针。 一、理解 如果有些程序设计语言没有指针类型&#xff0c;如何实现链表&#xff1f; 在使用指针类型实现链表时&#xff0c;我们很容易就可以直接在内存中新建一块地址用于创建下一个结点&#xff0c;在逻辑上&#x…
阅读更多...
数据结构 之 链表LinkedList

数据结构 之 链表LinkedList

目录 1. ArrayList的缺陷&#xff1a; 2. 链表&#xff1a; 2.1 链表的概念及结构&#xff1a; 3. 链表的使用和模拟实现&#xff1a; 3.1 构造方法&#xff1a; 3.2 模拟实现&#xff1a; 4. 源码分享&#xff1a; 在我学习顺序表之后&#xff0c;我就立马开始了链表的学…
阅读更多...
【LeetCode热题100】234. 回文链表（链表）

【LeetCode热题100】234. 回文链表（链表）

一.题目要求 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 二.题目难度 三.输入样例 示例 1&#xff1a; 输入&#xff1a;head [1,2,2,1] 输出&#xff1a;true 示…
阅读更多...
【LeetCode热题100】148. 排序链表（链表）

【LeetCode热题100】148. 排序链表（链表）

一.题目要求 给你链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 二.题目难度 中等 三.输入样例 示例 1&#xff1a; 输入&#xff1a;head [4,2,1,3] 输出&#xff1a;[1,2,3,4] 示例 2&#xff1a; 输入&#xff1a;head [-1,5,3,4,0] 输…
阅读更多...
【LeetCode热题100】24. 两两交换链表中的节点（链表）

【LeetCode热题100】24. 两两交换链表中的节点（链表）

一.题目要求 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 二.题目难度 中等 三.输入样例 示例 1&#xff1a; 输入&am…
阅读更多...
day-10 删除排序链表中的重复元素

day-10 删除排序链表中的重复元素

思路 先统计每个值出现的次数&#xff0c;然后将出现次数为一的节点链接为一个链表即可 解题方法 while(t!null){ //统计每个值出现次数 arr[t.val100]1; tt.next; } while(t!null&&arr[t.val100]!1) tt.next;//确定返回的头结点 ttt; while(t!null&&t.next…
阅读更多...
第14章_集合与数据结构拓展练习(前序、中序、后序遍历,线性结构,单向链表构建,单向链表及其反转,字符串压缩)

第14章_集合与数据结构拓展练习(前序、中序、后序遍历,线性结构,单向链表构建,单向链表及其反转,字符串压缩)

文章目录 第14章_集合与数据结构拓展练习选择填空题1、前序、中序、后序遍历2、线性结构3、其它 编程题4、单向链表构建5、单向链表及其反转6、字符串压缩 第14章_集合与数据结构拓展练习 选择填空题 1、前序、中序、后序遍历 分析&#xff1a; 完全二叉树&#xff1a; 叶结点…
阅读更多...
CM11 链表分割

CM11 链表分割

链表分割_牛客题霸_牛客网 (nowcoder.com) 一、思路分析 二、源码 一、思路分析 创建两个链表small、big 遍历原来链表 比X小的节点尾插到small 比X大的节点尾插到big 最后来链接起来 这样不会改变各个节点的相对顺序 二、源码 ListNode* partition(ListNode* pHead,…
阅读更多...
206.反转链表（附带源码）

206.反转链表（附带源码）

一、思路 二、代码 一、思路 将指针调转一个方向就行&#xff0c;很简单 做法&#xff1a; 定义2个指针&#xff1a;prev、 cur、 next 当next为空时&#xff0c;循环结束 思路清晰&#xff0c;操作清楚&#xff0c;开始敲代码。 二、代码 struct ListNode* reverseList(s…
阅读更多...
企业链表实现-C语言

企业链表实现-C语言

LinkList.h #ifndef LINKLIST_H #define LINKLIST_H#include <stdlib.h> #include <stdio.h>//链表小结点 typedef struct LINKNODE {struct LINKNODE* next; }LinkNode;//链表结点 typedef struct LINKLIST {LinkNode head;int size; }LinkList;//遍历函数指针 /…
阅读更多...
如何处理，存储结构的线性表的中间元素删除后的处理方法

如何处理，存储结构的线性表的中间元素删除后的处理方法

在基于数组的链表中&#xff0c;删除中间元素后&#xff0c;我们需要注意这个被删除的元素留下的空间&#xff0c;以便在后续向链表添加元素时能够正确地找到并使用这个空间。 由于我们无法直接在数组中删除元素&#xff0c;而是通过标记来表示已删除&#xff0c;因此添加新元素…
阅读更多...
反转链表 II（leetcode）

反转链表 II（leetcode）

题目链接&#xff1a;. - 力扣&#xff08;LeetCode&#xff09; 分享两道解题思路&#xff1a; 第一个&#xff1a; 将left~right之间的节点翻转&#xff0c;首先left前的节点的next置为空&#xff0c;right的指针置为空&#xff0c; 然后拼接 p1指的是left前面的一个 p1-…
阅读更多...
C语言——调试技巧

C语言——调试技巧

1.Debug和Release的介绍 Debug 通常称为调试版本&#xff0c;它包含调试信息&#xff0c;并且不作任何优化&#xff0c;便于程序员调试程序。Release 称为发布版本&#xff0c;它往往是进行了各种优化&#xff0c;使得程序在代码大小和运行速度上都是最优 的&#xff0c;以便用…
阅读更多...
LeetCode 142.环形链表II（数学公式推导）

LeetCode 142.环形链表II（数学公式推导）

给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整…
阅读更多...
[C语言][数据结构][链表] 单链表的从零实现!

[C语言][数据结构][链表] 单链表的从零实现!

目录 零.必备知识 1.一级指针 && 二级指针 2. 节点的成员列表 a.数据 b.指向下一个节点的指针. 3. 动态内存空间的开辟 (malloc-calloc-realloc) 一.单链表的实现与销毁 1.1 节点的定义 1.2 单链表的尾插 1.3 单链表的头插 1.4 单链表的尾删 1.5 单链表的头删 1…
阅读更多...
穿越代码之海：探寻结构体深层逻辑，展望未来应用新天地

穿越代码之海：探寻结构体深层逻辑，展望未来应用新天地

欢迎来到白刘的领域 Miracle_86.-CSDN博客 系列专栏 C语言知识 先赞后看&#xff0c;已成习惯 创作不易&#xff0c;多多支持&#xff01; 结构体作为一种数据结构&#xff0c;其定义和特点决定了它在各种应用中的广泛适用性。随着科技的进步和新兴行业的不断涌现&#xf…
阅读更多...
面试算法-166-排序链表

面试算法-166-排序链表

题目 给你链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [4,2,1,3] 输出&#xff1a;[1,2,3,4] 解 class Solution {public ListNode sortList(ListNode head) {if (head null || head.next null…
阅读更多...
LeetCode-热题100：146. LRU 缓存

LeetCode-热题100：146. LRU 缓存

题目描述 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类&#xff1a; LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存int get(int key) 如果关键字 key 存在于缓存中&#xff0c;则返回关键字的值&#xff0c;否…
阅读更多...
【Hello算法】 ＞ 第 2 关 ＞数据结构 之 数组与链表

【Hello算法】 ＞ 第 2 关 ＞数据结构 之 数组与链表

数据结构 之 数组与链表 1&#xff1a;Understanding data structures &#xff01;——了解数据结构——1.1&#xff1a;Classification-分类-1.2&#xff1a;Type-类型- 2&#xff1a;Arrays are the bricks that make up the wall of data structures *——数组是组成数据结…
阅读更多...
C语言中的数据结构--链表的应用1（2）

C语言中的数据结构--链表的应用1（2）

前言 上一节我们学习了链表的概念以及链表的实现&#xff0c;那么本节我们就来了解一下链表具体有什么用&#xff0c;可以解决哪些实质性的问题&#xff0c;我们借用习题来加强对链表的理解&#xff0c;那么废话不多说&#xff0c;我们正式进入今天的学习 单链表相关经典算法O…
阅读更多...
代码随想录算法训练营第四天-链表part2

代码随想录算法训练营第四天-链表part2

day2和day3回家太晚&#xff0c;刷完题忘记写笔记了 - -&#xff01; 24.两两交换链表中的节点 给自己的笔记&#xff1a; 虚拟节点法是创建一个节点&#xff0c;它的next指针指向链表的头节点&#xff0c;这样便于&#xff1a; current指向虚拟节点&#xff0c;然后对链表进…
阅读更多...
【链表】-Lc23-合并K个有序链表（优先级队列）

【链表】-Lc23-合并K个有序链表（优先级队列）

写在前面 最近想复习一下数据结构与算法相关的内容&#xff0c;找一些题来做一做。如有更好思路&#xff0c;欢迎指正。 目录 写在前面一、场景描述二、具体步骤1.环境说明2.代码 写在后面 一、场景描述 合并 k 个排序链表&#xff0c;返回合并后的排序链表。请分析和描述算法的…
阅读更多...
二叉树及其相关例题

二叉树及其相关例题

目录 1.树 1.树的基本概念 2.结点之间的的关系描述&#xff08;还是看上面的图&#xff09; 3.结点之间的属性描述 4.有序树和无序树 5.森林 6.遍历顺序 1.前序遍历&#xff1a;从根结点——>根结点左子树——>根结点的右子树&#xff08;中 左 右&#xff…
阅读更多...
力扣0114——二叉树展开为链表

力扣0114——二叉树展开为链表

[二叉树展开为链表] 难度&#xff1a;中等 题目描述 给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左子指针始终为 null 。展开后的单…
阅读更多...
【代码随想录-链表】反转链表

【代码随想录-链表】反转链表

💝💝💝欢迎来到我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。 推荐:kwan 的首页,持续学习,不断总结,共同进步,活到老学到老导航 檀越剑指大厂系列:全面总结 jav…
阅读更多...
排序链表---归并--链表OJ

排序链表---归并--链表OJ

https://leetcode.cn/problems/sort-list/submissions/499363940/?envTypestudy-plan-v2&envIdtop-100-liked 这里我们直接进阶&#xff0c;用时间复杂度O(nlogn)&#xff0c;空间复杂度O(1)&#xff0c;来解决。 对于归并&#xff0c;如果自上而下的话&#xff0c;空间复…
阅读更多...
【数据结构与算法】之哈希表系列-20240130

【数据结构与算法】之哈希表系列-20240130

这里写目录标题 一、383. 赎金信二、387. 字符串中的第一个唯一字符三、389. 找不同四、409. 最长回文串五、448. 找到所有数组中消失的数字六、594. 最长和谐子序列 一、383. 赎金信 简单 给你两个字符串&#xff1a;ransomNote 和 magazine &#xff0c;判断 ransomNote 能不…
阅读更多...
环形链表（快慢指针）

环形链表（快慢指针）

给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环…
阅读更多...
【数据结构】链表OJ面试题2(题库+解析)

【数据结构】链表OJ面试题2(题库+解析)

1.前言 前五题在这http://t.csdnimg.cn/UeggB 休息一天&#xff0c;今天继续刷题&#xff01; 2.OJ题目训练 1. 编写代码&#xff0c;以给定值x为基准将链表分割成两部分&#xff0c;所有小于x的结点排在大于或等于x的结点之前 。链表分割_牛客题霸_牛客网 思路 既然涉及…
阅读更多...
go语言每日一练——链表篇(六)

go语言每日一练——链表篇(六)

传送门 牛客面试必刷101题—— 判断链表中是否有环 牛客面试必刷101题—— 链表中环的入口结点 题目及解析 题目一 代码 package mainimport . "nc_tools"/** type ListNode struct{* Val int* Next *ListNode* }*//**** param head ListNode类* return bool…
阅读更多...
数据结构——单向链表和双向链表的实现（C语言版）

数据结构——单向链表和双向链表的实现（C语言版）

目录 前言 1. 链表 1.1 链表的概念及结构 1.2 链表的分类 2. 单链表接口实现 2.1 数据结构设计与接口函数声明 2.2 创建结点&#xff0c;打印&#xff0c;查找 2.3 尾插&#xff0c;头插&#xff0c;尾删&#xff0c;头删 2.4 插入或删除 2.4.1在指定位置后 2.4.2在…
阅读更多...
19 删除链表的倒数第 N 个结点

19 删除链表的倒数第 N 个结点

19. 删除链表的倒数第 N 个结点 中等 相关标签 相关企业 提示 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 这段代码使用了双指针的方法&#xff0c;其中一个指针先走 n 步&#xff0c;然后两个指针一起走&#xff0c;直到第一…
阅读更多...
[力扣 Hot100]Day27 合并两个有序链表

[力扣 Hot100]Day27 合并两个有序链表

题目描述 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 出处 思路 简单题&#xff0c;两个指针就能解决。 代码 class Solution { public:ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {if(!list1)…
阅读更多...
【数据结构】单向链表的增删查改以及指定pos位置的插入删除

【数据结构】单向链表的增删查改以及指定pos位置的插入删除

目录 单向链表的概念及结构 尾插 头插 尾删 ​编辑 头删 查找 在pos位置前插 在pos位置后插 删除pos位置 删除pos的后一个位置 总结 代码 单向链表的概念及结构 概念&#xff1a;链表是一种 物理存储结构上非连续 、非顺序的存储结构&#xff0c;数据元素的 逻辑顺序 是…
阅读更多...
动态创建链表

动态创建链表

动态创建链表的好处 相比于之前链表的几种功能介绍&#xff0c;都是在设定好的链表基础之上进行插入、删除等&#xff0c;那么如果我们要创建链表元素很多&#xff0c;就得去定义很多个元素结构体&#xff0c;非常不方便&#xff0c;这个时候应该用到动态创建链表。 动态创建…
阅读更多...
LeetCode----23. 合并 K 个升序链表

LeetCode----23. 合并 K 个升序链表

 题目 给你一个链表数组，每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中，返回合并后的链表。 示例 1： 输入：lists = [[1,4,5],[1,3,4],[2,6]] 输出：[1,1,2,3,4,4,5,6] 解释：链表数组如下： [ 1->4->5, 1->3->4, 2->6 ] 将它们合并到…
阅读更多...
【LeetCode刷题-链表】--1290.二进制链表转整数

【LeetCode刷题-链表】--1290.二进制链表转整数

1290.二进制链表转整数 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* ListNode(int val, ListNode next) { this.val val; this.next next; }*…
阅读更多...
LeetCode | 203. 移除链表元素

LeetCode | 203. 移除链表元素

LeetCode | 203. 移除链表元素 OJ链接 这里有两个思路我接下来看 当cur不等于6就一直找&#xff0c;找到了6就删除&#xff0c;但是能不能直接删除&#xff1f;不能&#xff0c;直接free了就找不到下一个了 这个时候我们就要定义next指针&#xff0c;和prev指针&#xff0c…
阅读更多...
旋转链表（C++解法）

旋转链表（C++解法）

题目 给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], k 2 输出&#xff1a;[4,5,1,2,3]示例 2&#xff1a; 输入&#xff1a;head [0,1,2], k 4 输出&#xff1a;[…
阅读更多...
数据结构与算法【02】—线性表

数据结构与算法【02】—线性表

CSDN系列专栏&#xff1a;数据结构与算法专栏 针对以前写的数据结构与算法系列重写(针对文字描述、图片、错误修复)&#xff0c;改动会比较大&#xff0c;一直到更新完为止 前言 通过前面数据结构与算法基础知识我们知道了数据结构的一些概念和重要性&#xff0c;那么本章总结…
阅读更多...
只用C语言解决环形链表的约瑟夫问题

只用C语言解决环形链表的约瑟夫问题

事情起因与我的老师把答卷发错了&#xff0c;大家都把C学完了而我刚学到数据结构还在吃奶的阶段&#xff0c;就让我遇到他了&#xff0c;所以这次只靠C语言的知识不用链表来解决&#xff0c;等我学成C归来再把它做一次 链接&#xff1a;环形链表的约瑟夫问题__牛客网 来源&…
阅读更多...
Leetcode刷题详解——反转链表

Leetcode刷题详解——反转链表

1. 题目链接&#xff1a;206. 反转链表 2. 题目描述&#xff1a; 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&#xff1a; 输入&#xff1…
阅读更多...
Day13反转链表两两交换链表中的节点删除链表的倒数第N个节点链表相交环形链表II

Day13反转链表两两交换链表中的节点删除链表的倒数第N个节点链表相交环形链表II

反转链表 struct ListNode* reverseList(struct ListNode* head){struct ListNode* preNULL;while(head){struct ListNode* temphead->next;head->nextpre;prehead;headtemp;}return pre; }两两交换链表中的节点 struct ListNode* swapPairs(struct ListNode* head){st…
阅读更多...
静态链表的定义与实现(数据结构与算法)

静态链表的定义与实现(数据结构与算法)

1. 静态链表 用数组的方式实现的链表 单链表&#xff1a; 各个结点在内存中星罗棋布、散落天涯 静态链表&#xff1a;分配一整片连续的内存空间&#xff0c; 各个结点集中安置。 1.1 静态链表的优点 不需要像动态链表那样频繁地进行内存分配和释放&#xff0c;可以节省内存…
阅读更多...
【每日一题】移除链表元素（C语言）

【每日一题】移除链表元素（C语言）

移除链表元素&#xff0c;链接奉上 目录 思路&#xff1a;代码实现&#xff1a;链表题目小技巧&#xff1a; 思路&#xff1a; 在正常情况&#xff1a; 下我们移除链表元素时&#xff0c;需要该位置的前结点与后节点&#xff0c; 在特别情况时&#xff1a; 例如 我们发现&…
阅读更多...
算法通关村第五关-黄金挑战LRU问题

算法通关村第五关-黄金挑战LRU问题

大家好我是苏麟 , 今天聊聊LRU问题 , 相信学过操作系统的小伙伴并不陌生 . LRU问题 LRU的含义 LRU是Least Recently Used的缩写&#xff0c;即最近最少使用&#xff0c;是一种常用的页面置换算法&#xff0c;选择最近最久未使用的页面予以淘汰。 图解 : 如果再有其他元素就依…
阅读更多...
力扣 203.移除链表元素第二种解法

力扣 203.移除链表元素第二种解法

目录 1.解题思路2.代码实现 1.解题思路 利用双指针&#xff0c;开辟一个新的头结点并依次向头结点尾插不为val的结点如果遇到值为val的结点就跳过并释放掉 2.代码实现 struct ListNode* removeElements(struct ListNode* head, int val) { if(headNULL)return NULL;struct …
阅读更多...
数据结构与算法-二叉树的遍历

数据结构与算法-二叉树的遍历

&#x1f31e; “少年没有乌托邦&#xff0c;心向远方自明朗&#xff01;” 二叉树 &#x1f388;1.二叉树的遍历&#x1f52d;1.1先序遍历&#x1f52d;1.2中序遍历&#x1f52d;1.3后序遍历&#x1f52d;1.4层次遍历&#x1f52d;1.5二叉树遍历的递归算法&#x1f4dd;1.5.1先…
阅读更多...
每日一练——返回链表的中间结点

每日一练——返回链表的中间结点

&#x1d649;&#x1d65e;&#x1d658;&#x1d65a;!!&#x1f44f;&#x1f3fb;‧✧̣̥̇‧✦&#x1f44f;&#x1f3fb;‧✧̣̥̇‧✦ &#x1f44f;&#x1f3fb;‧✧̣̥̇:Solitary-walk ⸝⋆ ━━━┓ - 个性标签 - &#xff1a;来于“云”的“羽球人”。…
阅读更多...
深入理解数据结构（1）—用链表实现栈

深入理解数据结构（1）—用链表实现栈

栈是一种数据结构&#xff0c;链表也是一种数据结构。它们都是由基础的语法实现的。 如果一个数据结构可以用另外的数据结构来实现&#xff0c;那么可以有力的证明——“数据结构是一种思想”&#xff0c;是一种讲语法组合起来实现某种功能的手段 一、栈的特点——要实现哪些功…
阅读更多...
带你拿捏链表

带你拿捏链表

本专栏内容为&#xff1a;数据结构学习专栏&#xff0c;分为初阶和进阶两部分。 通过本专栏的深入学习&#xff0c;你可以了解并掌握数据结构。 &#x1f493;博主csdn个人主页&#xff1a;小小unicorn ⏩专栏分类&#xff1a;数据结构 &#x1f69a;代码仓库&#xff1a;小小u…
阅读更多...
LeetCode 热题100——链表专题

LeetCode 热题100——链表专题

一、俩数相加 2.俩数相加&#xff08;题目链接&#xff09; 思路&#xff1a;这题题目首先要看懂&#xff0c;以示例1为例 即 342465807&#xff0c;而产生的新链表为7->0->8. 可以看成简单的从左向右&#xff0c;低位到高位的加法运算&#xff0c;4610&#xff0c;逢…
阅读更多...
[LeetCode]-160. 相交链表-141. 环形链表-142.环形链表II-138.随机链表的复制

[LeetCode]-160. 相交链表-141. 环形链表-142.环形链表II-138.随机链表的复制

目录 160.相交链表 题目 思路 代码 141.环形链表 题目 思路 代码 142.环形链表II 题目 思路 代码 160.相交链表 160. 相交链表 - 力扣&#xff08;LeetCode&#xff09;https://leetcode.cn/problems/intersection-of-two-linked-lists/description/ 题目 给你两个…
阅读更多...
力扣 141.环形链表和142.环形链表2

力扣 141.环形链表和142.环形链表2

目录 1.环形链表Ⅰ解题思路2.环形链表Ⅰ代码实现3.环形链表Ⅱ解题思路4.环形链表Ⅱ代码实现 1.环形链表Ⅰ解题思路 利用快慢指针&#xff0c;快指针一次走两个&#xff0c;慢指针一次走一个&#xff0c;如果出现了快指针为空或者快指针的next为空的现象则说明不带环&#xff0…
阅读更多...
LeetCode题：83删除排序链表中的重复元素 141环形链表

LeetCode题：83删除排序链表中的重复元素 141环形链表

83删除排序链表中的重复元素 题目内容 给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,1,2] 输出&#xff1a;[1,2]示例 2&#xff1a; 输入&#xf…
阅读更多...
算法题：203. 移除链表元素（递归法、设置虚拟头节点法等3种方法）Java实现创建链表与解析链表

算法题：203. 移除链表元素（递归法、设置虚拟头节点法等3种方法）Java实现创建链表与解析链表

1、算法思路 讲一下设置虚拟头节点的那个方法&#xff0c;设置一个新节点指向原来链表的头节点&#xff0c;这样我们就可以通过判断链表的当前节点的后继节点值是不是目标删除值&#xff0c;来判断是否删除这个后继节点了。如果不设置虚拟头节点&#xff0c;则需要将头节点和后…
阅读更多...
【CSDN 每日一练 ★★☆】【双指针】环形链表 II

【CSDN 每日一练 ★★☆】【双指针】环形链表 II

【CSDN 每日一练 ★★☆】【双指针】环形链表 II 双指针 题目 给定一个链表&#xff0c;返回链表开始入环的第一个节点。如果链表无环&#xff0c;则返回null。 为了表示给定链表中的环&#xff0c;我们使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;索引从 0 开…
阅读更多...
LeetCode热题100——链表

LeetCode热题100——链表

链表 1. 相交链表2. 反转链表3. 回文链表4. 环形链表5. 合并两个有序链表 1. 相交链表 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 // 题解&#xff1a;使用A/B循环遍…
阅读更多...
LeetCode | 141. 环形链表

LeetCode | 141. 环形链表

LeetCode | 141. 环形链表 OJ链接 思路&#xff1a; 这里我们可以使用快慢指针来解决问题 slow一次走两步fast一次走一步当slow和fast相遇的时候就说明带环&#xff0c;否则就是否 代码如下&#xff1a; bool hasCycle(struct ListNode *head) {struct ListNode*slow head,*…
阅读更多...
【每日OJ题—— 141. 环形链表（链表）】

【每日OJ题—— 141. 环形链表（链表）】

每日OJ题—— 141. 环形链表&#xff08;链表&#xff09; 1.题目&#xff1a;141. 环形链表2.方法讲解2.1 解法2.1.1 图文解析2.1.2 代码的实现2.1.3提交通过展示 1.题目&#xff1a;141. 环形链表 2.方法讲解 2.1 解法 2.1.1 图文解析 我们可以根据上述思路来解决本题。具体…
阅读更多...
宏观角度认识递归之反转链表和两两交换链表中的节点

宏观角度认识递归之反转链表和两两交换链表中的节点

206. 反转链表 - 力扣&#xff08;LeetCode&#xff09; 对于反转链表&#xff0c;如果是考虑从头到尾开始的话&#xff0c;就会出现&#xff1a;从第二个节点开始&#xff0c;它的next指向第一个节点&#xff0c;导致第三个节点失去方向&#xff0c;这样无法解决问题。因此考虑…
阅读更多...
NowCoder | 链表中倒数第k个结点

NowCoder | 链表中倒数第k个结点

NowCoder | 链表中倒数第k个结点 OJ链接 思路&#xff1a;定义两个快慢指针&#xff0c;让快指针先提前走k个节点&#xff0c;然后再让慢结点和快结点一起走&#xff0c;当快指针 NULL时&#xff0c;慢指针就是倒数第k个节点 代码如下&#xff1a; struct ListNode* FindK…
阅读更多...
Java中数据结构（基本数据类型+引用数据类型）介绍+整理+例子+对比

Java中数据结构（基本数据类型+引用数据类型）介绍+整理+例子+对比

一、Java数据类型分类 在Java中&#xff0c;数据类型可以分为两大类&#xff1a;内置数据类型&#xff08;Primitive Data Types&#xff09;和引用数据类型&#xff08;Reference Data Types&#xff09;。 **内置数据类型&#xff08;Primitive Data Types&#xff09;**是…
阅读更多...
【简单】160. 相交链表

【简单】160. 相交链表

题目 【相交链表】五种解法~ 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 题解 暴力解法。时间复杂度&#xff1a;O(n^2)。哈希表。挨个节点放到哈希表中&#xff0c;…
阅读更多...
【算法-链表1】移除链表元素 和 设计链表

【算法-链表1】移除链表元素 和 设计链表

今天&#xff0c;带来链表相关算法的讲解。文中不足错漏之处望请斧正&#xff01; 理论基础点这里 移除链表元素 1. 思路 链表的删除和插入&#xff0c;都是改变链接关系。 如图&#xff1a;要删除值为2的结点&#xff0c;要找到其上一个节点&#xff0c;让上一个节点指向值…
阅读更多...
python链队_队列的链式存储结构

python链队_队列的链式存储结构

队列是一种先进先出&#xff08;first in first out,FIFO&#xff09;的线性表&#xff0c;是一种常用的数据结构。 它只允许在表的前端&#xff08;front&#xff09;进行删除操作&#xff0c;而在表的后端&#xff08;rear&#xff09;进行插入操作&#xff0c;和栈一样&…
阅读更多...
LeetCode | 面试题 02.02. 返回倒数第 k 个节点

LeetCode | 面试题 02.02. 返回倒数第 k 个节点

LeetCode | 面试题 02.02. 返回倒数第 k 个节点 OJ链接 思路&#xff1a;定义两个快慢指针&#xff0c;让快指针先提前走k个节点&#xff0c;然后再让慢结点和快结点一起走&#xff0c;当快指针 NULL时&#xff0c;慢指针就是倒数第k个节点 代码如下&#xff1a; int kthT…
阅读更多...
【数据结构】树与二叉树（六）：二叉树的链式存储

【数据结构】树与二叉树（六）：二叉树的链式存储

文章目录 5.1 树的基本概念5.1.1 树的定义5.1.2 森林的定义5.1.3 树的术语5.1.4 树的表示 5.2 二叉树5.2.1 二叉树1. 定义2. 特点3. 性质引理5.1&#xff1a;二叉树中层数为i的结点至多有 2 i 2^i 2i个&#xff0c;其中 i ≥ 0 i \geq 0 i≥0。引理5.2&#xff1a;高度为k的二叉…
阅读更多...
【数据结构】链表经典OJ题，常见几类题型（一）

【数据结构】链表经典OJ题，常见几类题型（一）

目录 题型一&#xff1a;反转单链表思路解析OJ题实例解题代码 题型二&#xff1a;快慢指针思路解析OJ题实例解题代码 两类题型的结合 题型一&#xff1a;反转单链表 思路解析 反转一个链表主要是想让第一个节点指向NULL&#xff0c;第二个节点指向第一个&#xff0c;以此类推。…
阅读更多...
Java：如何判断一个链表是否为回文结构？（画图+代码 详解）

Java：如何判断一个链表是否为回文结构？（画图+代码 详解）

一、判断思想 我们设计一个时间复杂度为O(n),额外空间复杂度为O(1)的算法&#xff0c;我们在不创建额外空间的基础上来判断是否为回文结构。 思想&#xff1a; 1、使用快慢指针法&#xff0c;找到链表的中间节点。 2、翻转中间节点的后半部分。 3、分别从头节点和尾节点向中间遍…
阅读更多...
数据结构链表力扣例题AC（2）——代码以及思路记录

数据结构链表力扣例题AC（2）——代码以及思路记录

206. 反转链表 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 AC方法1 struct ListNode* reverseList(struct ListNode* head) {if(head NULL)return NULL;struct ListNode* n1, *n2, *n3;n1 NULL;n2 head;n3 head->next;while…
阅读更多...
LinkedList数据结构链表

LinkedList数据结构链表

LinkedList在Java中是一个实现了List和Deque接口的双向链表。它允许我们在列表的两端添加或删除元素&#xff0c;同时也支持在列表中间插入或移除元素。在分析LinkedList之前&#xff0c;需要理解链表这种数据结构&#xff1a; 链表&#xff1a;链表是一种动态数据结构&#x…
阅读更多...
【无标题】力扣报错：member access within null pointer of type ‘struct ListNode‘

【无标题】力扣报错：member access within null pointer of type ‘struct ListNode‘

项目场景&#xff1a; 做单链表反转题目&#xff0c;报错&#xff1a;member access within null pointer of type ‘struct ListNode’ 题目链接:LINK 问题描述 我明明在初始化指针时候&#xff0c;已经处理了n2->next情况却依然报错 这个报错提示含义是&#xff1a;大概就…
阅读更多...
顺序表详解（SeqList）

顺序表详解（SeqList）

本文使用C语言进行顺序表的代码实现。 博主将使用代码和相关知识相结合的方式进行讲解&#xff0c;简单易懂&#xff0c;懵懂的大学生一听就会~ 顺序表是一种线性表的存储结构&#xff0c;它将数据元素存储在一段连续的存储空间中&#xff0c;每个元素占据一个存储单元&#x…
阅读更多...
【链表算法题记录】两两交换链表中的节点

【链表算法题记录】两两交换链表中的节点

题目链接 我自己第一遍做的时候没有想到用虚拟头节点&#xff0c;就是直接进行操作&#xff1a; 设置要交换的两个节点p1和p2&#xff0c;还有交换需要用到的临时节点temp。进行交换后还要注意p1换到后面去之后它的指向&#xff0c;它实际上是指向后面一组交换节点交换后位于…
阅读更多...
备战蓝桥杯—— 双指针技巧巧答链表1

备战蓝桥杯—— 双指针技巧巧答链表1

对于单链表相关的问题&#xff0c;双指针技巧是一种非常广泛且有效的解决方法。以下是一些常见问题以及使用双指针技巧解决&#xff1a; 合并两个有序链表&#xff1a; 使用两个指针分别指向两个链表的头部&#xff0c;逐一比较节点的值&#xff0c;将较小的节点链接到结果链表…
阅读更多...
数据结构——队列（C语言版）

数据结构——队列（C语言版）

前言&#xff1a; 在学习完数据结构顺序表和链表之后&#xff0c;其实我们就可以做很多事情了&#xff0c;后面的栈和队列&#xff0c;其实就是对前面的顺序表和链表的灵活运用&#xff0c;今天我们就来学习一下队列的原理和应用。 准备工作&#xff1a;本人习惯将文件放在test…
阅读更多...
数据结构初阶：顺序表和链表

数据结构初阶：顺序表和链表

线性表 线性表 （ linear list ） 是 n 个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使 用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串 ... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的， 线性…
阅读更多...
数据结构__顺序表和单链表

数据结构__顺序表和单链表

顺序表的改进 问题&#xff1a; 1. 中间/头部的插入删除&#xff0c;时间复杂度为O(N) 2. 增容需要申请新空间&#xff0c;拷贝数据&#xff0c;释放旧空间。会有不小的消耗。 3. 增容一般是呈2倍的增长&#xff0c;势必会有一定的空间浪费。例如当前容量为100&#xff0c;满了…
阅读更多...
面试算法-156-反转链表

面试算法-156-反转链表

题目 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1] 解 class Solution {public ListNode reverseList(ListNode head) {ListNode pre null;L…
阅读更多...
【力扣】19. 删除链表的倒数第 N 个结点

【力扣】19. 删除链表的倒数第 N 个结点

19. 删除链表的倒数第 N 个结点 题目描述 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] 示例 2&#xff1a; 输入&#xff1a;head [1],…
阅读更多...
【数据结构（三）】链表与LinkedList

【数据结构（三）】链表与LinkedList

❣博主主页: 33的博客❣ ▶️文章专栏分类:数据结构◀️ &#x1f69a;我的代码仓库: 33的代码仓库&#x1f69a; &#x1faf5;&#x1faf5;&#x1faf5;关注我带你学更多数据结构知识 目录 1. 前言2.链表3.链表的实现3.1 IList接口3.2MyLinkList实现3.3 Test 4.LinkedList…
阅读更多...
C语言每日一题（27）链表中倒数第k个结点

C语言每日一题（27）链表中倒数第k个结点

牛客网 链表中倒数第k个结点 题目描述 描述 输入一个链表&#xff0c;输出该链表中倒数第k个结点。 思路分析 这是一道经典的快慢指针题&#xff0c;fast和slow最开始都指向头结点&#xff0c;对于输入值k&#xff0c;先让快指针fast先走k步&#xff0c;之后再让两个指针一…
阅读更多...
数据结构：串（定义，基本操作，存储结构）

数据结构：串（定义，基本操作，存储结构）

目录 1.串的定义2.串的基本操作3.字符集编码4.串的存储结构1.顺序存储2.链式存储 1.串的定义 串&#xff0c;即字符串( String&#xff09;是由零个或多个字符组成的有限序列。 一般记为s ‘a1a2……an’ (n ≥0) 其中&#xff0c;S是串名&#xff0c;单引号括起来的字符序列是…
阅读更多...
力扣876：链表的中间结点

力扣876：链表的中间结点

力扣876&#xff1a;链表的中间结点 题目描述&#xff1a; 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[3,4,5]…
阅读更多...
Leetcode:876. 链表的中间结点 【详解】

Leetcode:876. 链表的中间结点 【详解】

目录 题目 题目解析&#xff1a; 代码展示 图解​ 题目 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结点。 难度&#xff1a;简单 题目链接&#xff1a;876. 链表的中间结点 提示&#xff1a; 链…
阅读更多...
单链表（增删改查）【超详细】

单链表（增删改查）【超详细】

目录 单链表 1.单链表的存储定义 2.结点的创建 3.链表尾插入结点 4.单链表尾删结点 5.单链表头插入结点 6.单链表头删结点 7.查找元素&#xff0c;返回结点 8.在pos结点前插入一个结点 ​编辑 9.在pos结点后插入一个结点 10.删除结点 11.删除pos后面的结点 12.修改…
阅读更多...
环形链表(力扣oj）

环形链表(力扣oj）

给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;…
阅读更多...
【C语言】【数据结构】【环形链表判断是否带环并返回进环节点】有数学推导加图解

【C语言】【数据结构】【环形链表判断是否带环并返回进环节点】有数学推导加图解

1.判断是否带环&#xff1a; 用快慢指针 slow指针一次走一步&#xff0c;fast指针一次走两步 当两个指针相遇时&#xff0c;链表带环&#xff1b;两个指针不能相遇时&#xff0c;当fast走到倒数第一个节点或为空时&#xff0c;跳出循环返回空指针。 那么slow指针一次走一步&a…
阅读更多...
Leetcode-394 字符串解码（不会，复习）

Leetcode-394 字符串解码（不会，复习）

此题不会&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01; 题解思路&#xff1a;元组思想&#xff1a;数字[字符串]&#xff0c;每次遇到中括号意味着要重复数字次字符串…
阅读更多...
数据结构之双向链表

数据结构之双向链表

目录 引言 链表的分类 双向链表的结构 双向链表的实现 定义 创建新节点 初始化 打印 尾插 头插 判断链表是否为空 尾删 头删 查找与修改 指定插入 指定删除 销毁 顺序表和双向链表的优缺点分析 源代码 dlist.h dlist.c test.c 引言 数据结构…
阅读更多...
「题解」反转链表 返回中间节点

「题解」反转链表 返回中间节点

文章目录 &#x1f349;题目1&#xff1a;反转链表&#x1f349;解析&#x1f34c;解法一&#xff1a;创建一个新链表&#x1f34c;解法二&#xff1a;直接操作原链表 &#x1f349;题目2&#xff1a;返回中间节点&#x1f34c;解法一&#xff1a;快慢指针&#x1f34c;解法二&…
阅读更多...
经典OJ题：链表中的倒数第K个节点

经典OJ题：链表中的倒数第K个节点

题目&#xff1a; 输入一个链表&#xff0c;输出该链表中倒数第k个结点。 题源&#xff1a;链表中倒数第k个结点_牛客题霸_牛客网 (nowcoder.com) 方法一&#xff1a;暴力求解法 可以线统计链表的节点个数&#xff0c;然后用链表节点的个数减去K&#xff0c;得出倒数第K个节点…
阅读更多...
链表经典面试题之一讲

链表经典面试题之一讲

什么是链表&#xff1f; 链表是一种物理存储结构上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。 今天给大家分享一道经典的单链表面试题 力扣题目——反转链表https://leetcode.cn/problems/reverse-linked-list/ 只给了头…
阅读更多...
力扣题目 19：删除链表的倒数第N个节点 【python】

力扣题目 19：删除链表的倒数第N个节点 【python】

&#x1f464;作者介绍&#xff1a;10年大厂数据\经营分析经验&#xff0c;现任大厂数据部门负责人。 会一些的技术&#xff1a;数据分析、算法、SQL、大数据相关、python 作者专栏每日更新&#xff1a; LeetCode解锁1000题: 打怪升级之旅 LeetCode解锁1000题: 打怪升级之旅htt…
阅读更多...
两种C链表接口构造方式

两种C链表接口构造方式

记录下C语言中数据结构链表的2种方式&#xff0c;其中内核的表达方式可谓是经典。 一、数据和指针域混合 数据域和指针域定义在同一个结构体定义中&#xff0c;C语言中没有模板&#xff0c;意味着一个代码工程有多少数据结构就需要多少对链表的.c和.h&#xff0c;事实上这样会…
阅读更多...
【Python】快速排序法 Leetcode 148. 排序链表

【Python】快速排序法 Leetcode 148. 排序链表

题目 给你链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [4,2,1,3] 输出&#xff1a;[1,2,3,4] 代码 第一次使用朴素快速排序&#xff0c;基准值为头节点值&#xff0c;居然超时了&#xff0c;然后…
阅读更多...
【数据结构】顺序表与链表

【数据结构】顺序表与链表

摘要&#xff1a; 顺序表和链表是两种常见的线性数据结构&#xff0c;它们在存储和操作数据时具有各自的特点和优势。本文将介绍顺序表和链表的概念、特点以及基本操作&#xff0c;并通过C语言代码实现一个简单的顺序表和链表结构&#xff0c;以帮助读者更好地理解它们的原理和…
阅读更多...
反转链表 - LeetCode 热题 23

反转链表 - LeetCode 热题 23

大家好&#xff01;我是曾续缘&#x1f497; 今天是《LeetCode 热题 100》系列 发车第 23 天 链表第 2 题 ❤️点赞 &#x1f44d; 收藏 ⭐再看&#xff0c;养成习惯 反转链表 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#…
阅读更多...
C++之双向链表与哈希链表用法区别实例(二百六十八)

C++之双向链表与哈希链表用法区别实例(二百六十八)

简介&#xff1a; CSDN博客专家&#xff0c;专注Android/Linux系统&#xff0c;分享多mic语音方案、音视频、编解码等技术&#xff0c;与大家一起成长&#xff01; 优质专栏&#xff1a;Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 优质专栏&#xff1a;多媒…
阅读更多...
专题【链表】【考试题】刷题日记

专题【链表】【考试题】刷题日记

题目列表 考试题&#xff08;22题&#xff09; 2024.04.04 146. LRU 缓存 707. 设计链表 138. 随机链表的复制 160. 相交链表 622. 设计循环队列 109. 有序链表转换二叉搜索树 460. LFU 缓存 355. 设计推特 725. 分隔链表 2487. 从链表中移除节点 日常复习题 876. 链表的中…
阅读更多...
力扣热题100_链表_19_删除链表的倒数第 N 个结点

力扣热题100_链表_19_删除链表的倒数第 N 个结点

文章目录 题目链接解题思路解题代码 题目链接 19. 删除链表的倒数第 N 个结点 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] 示例 2&am…
阅读更多...
算法——链表(1)

算法——链表(1)

T04BF &#x1f44b;专栏: 算法|JAVA|MySQL|C语言 &#x1faf5; 小比特 大梦想 此篇文章与大家分享链表专题的第一部分 如果有不足的或者错误的请您指出! 1.链表常用技巧总结 1.1引入虚拟头结点 在力扣上,基本提供的链表题目都是"无头的",但是针对无头链表,我们最…
阅读更多...
面试经典150题——删除链表的倒数第 N 个结点

面试经典150题——删除链表的倒数第 N 个结点

1. 题目描述 2. 题目分析与解析 这个题目整体来讲还是比较简单的&#xff0c;因此直接给出解题思路&#xff1a; 遍历链表计数 计算要删除的节点的位置 创建虚拟头节点 创建指针指向虚拟头节点 移动指针到要删除的节点的前一个节点 删除节点 返回头节点 3. 代码实现 …
阅读更多...
【数据结构与算法】力扣 707. 设计链表

【数据结构与算法】力扣 707. 设计链表

题目描述 你可以选择使用单链表或者双链表&#xff0c;设计并实现自己的链表。 单链表中的节点应该具备两个属性&#xff1a;val 和 next 。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。 如果是双向链表&#xff0c;则还需要属性 prev 以指示链表中的…
阅读更多...
go语言实现无头单向链表

go语言实现无头单向链表

什么是无头单向链表 无头单向链表是一种线性数据结构&#xff0c;它的每个元素都是一个节点&#xff0c;每个节点都有一个指向下一个节点的指针。"无头"意味着这个链表没有一个特殊的头节点&#xff0c;链表的第一个节点就是链表的头。 优点&#xff1a; 动态大小&…
阅读更多...
Java单链表和LinkedList的实现

Java单链表和LinkedList的实现

一、单链表的实现 无头单向非循环链表 定义异常用于判断所给位置是否合法 public class IndexNotLegal extends RuntimeException{public IndexNotLegal(){}public IndexNotLegal(String smg){super(smg);} } class ListNode中包含当前节点的值和下一个节点指向 实现链表的…
阅读更多...
力扣234. 回文链表

力扣234. 回文链表

Problem: 234. 回文链表 文章目录 题目描述思路复杂度Code 题目描述 思路 1.定义指针fast&#xff0c;slow分别指向head&#xff0c;int 类型变量n记录链表的长度&#xff1b; 2.将fast指针移动至 n 2 \frac{n}{2} 2n​处&#xff1b; 3.若n为奇数则从fast -> next处反转链表…
阅读更多...
力扣热题100_链表_142_环形链表 II

力扣热题100_链表_142_环形链表 II

文章目录 题目链接解题思路解题代码 题目链接 142. 环形链表 II 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中…
阅读更多...
链表删除练习

链表删除练习

1.链表删除练习(题目链接) 题目描述 试图编写一个链表&#xff0c;实现插入后&#xff0c;试着编写一下删除操作。&#xff08;这种使用数组的方式可能会浪费内存&#xff0c;但是请暂时忽略这点&#xff09; 作为练习的判断&#xff0c;请输出删除链表内所有元素x后的序列。…
阅读更多...
链表之单链表

链表之单链表

上一篇博客我们学习了线性表中的顺序表&#xff0c;这一篇博客让我们继续往下了解线性表的链表&#xff0c;链表分为好几种结构&#xff0c;活不多说&#xff0c;让我们开始学习吧&#xff01; 目录 1.链表 2.链表的结构 3.单链表的实现 1.链表 1.概念&#xff1a;它是一种物…
阅读更多...
反转链表1

反转链表1

/*** 代码中的类名、方法名、参数名已经指定&#xff0c;请勿修改&#xff0c;直接返回方法规定的值即可*** param head ListNode类* return ListNode类*/ListNode* ReverseList(ListNode* head) {// write code hereif (headNULL) {return nullptr;}ListNode* start(ListNode*…
阅读更多...
环形链表问题（判环+寻找入环点）

环形链表问题（判环+寻找入环点）

文章目录 题目1.判断链表中是否有环1.1 思路分析&#xff08;快慢指针&#xff09;1.2 思考&#xff1a;为什么快指针每次走两步&#xff0c;慢指针每次走一步两者一定可以相遇&#xff1f;1.3 快指针一次走3步&#xff0c;走4步&#xff0c;...n步行吗&#xff1f; 题目2. 寻找…
阅读更多...
力扣热题100_链表_21_合并两个有序链表

力扣热题100_链表_21_合并两个有序链表

文章目录 题目链接解题思路解题代码 题目链接 21. 合并两个有序链表 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4] 示例…
阅读更多...
LeetCode-热题100：2. 两数相加

LeetCode-热题100：2. 两数相加

题目描述 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0c;这两个数都…
阅读更多...
代码随想录算法训练营第三天 | 链表理论基础 ● 203.移除链表元素 ● 707.设计链表 ● 206.反转链表

代码随想录算法训练营第三天 | 链表理论基础 ● 203.移除链表元素 ● 707.设计链表 ● 206.反转链表

203. 移除链表元素 简单 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; [图片] 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5] 示…
阅读更多...
【算法-链表3】删除链表倒数第n个节点 + 链表相交

【算法-链表3】删除链表倒数第n个节点 + 链表相交

今天&#xff0c;带来XXX的讲解。文中不足错漏之处望请斧正&#xff01; 理论基础点这里 删除链表倒数第n个节点 1. 思路 直接计算 倒数第n个 正数第size-n1个 比如要删除size为5的链表的倒数第2个节点。 其实就是正数size-n1个。那么&#xff0c;从第一个走到底size-n1个…
阅读更多...
第四天||24. 两两交换链表中的节点 ● 19.删除链表的倒数第N个节点 ● 面试题 02.07. 链表相交 ● 142.环形链表II

第四天||24. 两两交换链表中的节点 ● 19.删除链表的倒数第N个节点 ● 面试题 02.07. 链表相交 ● 142.环形链表II

24. 两两交换链表中的节点 中等 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 示例 1&#xff1a; [图片] 输入&#xff1a…
阅读更多...
数据结构 | 带头双向循环链表专题

数据结构 | 带头双向循环链表专题

数据结构 | 带头双向循环链表专题 前言 前面我们学了单链表&#xff0c;我们这次来看一个专题带头的双向循环链表~~ 文章目录 数据结构 | 带头双向循环链表专题前言带头双向循环链表的结构实现双向链表头文件的定义哨兵位初始化创建节点尾插尾删头插头删打印查找指定位置前插入…
阅读更多...
Leetcode82删除排序链表中重复元素2

Leetcode82删除排序链表中重复元素2

代码&#xff1a; 为了找到结果的head 可以在head前加一个dummy dummy->head 再顺序去重 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* Lis…
阅读更多...
《LeetCode力扣练习》代码随想录——链表（链表相交---Java）

《LeetCode力扣练习》代码随想录——链表（链表相交---Java）

《LeetCode力扣练习》代码随想录——链表&#xff08;链表相交—Java&#xff09; 刷题思路来源于 代码随想录 面试题 02.07. 链表相交 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode(int x) {* …
阅读更多...
c语言-数据结构-栈和队列的实现和解析

c语言-数据结构-栈和队列的实现和解析

目录 一、栈 1、栈的概念 1.2 栈的结构 2、栈的创建及初始化 3、压栈操作 4、出栈操作 5、显示栈顶元素 6、显示栈空间内元素的总个数 7、释放栈空间 8、测试栈 二、队列 1、队列的概念 1.2 队列的结构 2、队列的创建及初始化 3、入队 4、出队 5、显示队头、队…
阅读更多...
c语言实现两个有序链表的合并

c语言实现两个有序链表的合并

合并两个有序链表是c语言数据结构中比较经典的问题&#xff0c;首先两个链表都是有序的&#xff0c;即节点的顺序是按照各个节点中的值从小到大排序&#xff0c;而且合并之后的新链表中的各个节点顺序也要满足从小到大的排序&#xff0c;具体如下图所示。 思路&#xff1a;用ma…
阅读更多...
leetCode 92.反转链表 II + 图解

leetCode 92.反转链表 II + 图解

92. 反转链表 II - 力扣&#xff08;LeetCode&#xff09; 给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 206. 反转链表 - 力扣&#xff08;LeetCode&am…
阅读更多...
Leetcode_203.移除链表元素—C语言

Leetcode_203.移除链表元素—C语言

目录 ❣️1.题目❣️ ❣️2.解答❣️ &#x1f49e;方法一&#xff1a;暴力法 &#x1f49e;方法二&#xff1a; 尾插法 &#x1f49e;方法三&#xff1a;哨兵位法 ❣️1.题目❣️ 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.va…
阅读更多...
c语言-数据结构-链表分割

c语言-数据结构-链表分割

链表分割实际上是给定一个值&#xff0c;遍历链表把链表中小于该值的节点与大于该值的节点分开&#xff0c;一般是将小于该值的节点放到链表的前面部分&#xff0c;大于该值的节点放在链表的后面部分。 链表分割示意图如下&#xff1a; 思路&#xff1a; 首先创建两条带哨兵位节…
阅读更多...
【C++代码】最接近的三数之和，括号生成，合并两个有序链表，合并 K 个升序链表

【C++代码】最接近的三数之和，括号生成，合并两个有序链表，合并 K 个升序链表

题目&#xff1a;最长公共前缀 编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀&#xff0c;返回空字符串 ""。 class Solution { public:string longestCommonPrefix(vector<string>& strs) {string res"";int index 0; f…
阅读更多...
leetcode：138. 随机链表的复制

leetcode：138. 随机链表的复制

一、题目&#xff1a; 138. 随机链表的复制 - 力扣&#xff08;LeetCode&#xff09; 函数原型&#xff1a; struct Node* copyRandomList(struct Node* head) 二、思路 本题是给出一个单链表&#xff0c;单链表的每个结点还额外有一个随机指针&#xff0c;随机指向其他结点&am…
阅读更多...
算法笔记-第七章-链表(未完成)

算法笔记-第七章-链表(未完成)

算法笔记-第七章-链表 链表的遍历链表结点的个数链表的头插法!链表删除元素链表反转例题思路一：原地反转思路二：头插法链表去除重复元素(有些复杂了)思路题目一题目二链表的遍历 #include<cstdio> const int N = 100; struct Node {int data, next;//表示的是当前数据和…
阅读更多...
「题解」相交链表

「题解」相交链表

&#x1f349;题目 题目链接 &#x1f349;解析 “提示”部分有提示链表数不为零&#xff0c;所以讨论链表为空的情况。 最简单粗暴的思路就是&#xff1a;遍历链表&#xff0c;先使用循环遍历A链表&#xff0c;然后嵌套循环遍历B&#xff0c;比对A、B是否存在地址相同的…
阅读更多...
C语言每日一题（29）合并两个有序链表

C语言每日一题（29）合并两个有序链表

力扣网 21合并两个有序链表 题目描述 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 思路分析 最基本的一种思路就是&#xff0c;遍历两个链表&#xff0c;将对应结点的值进行比较&#xff0c;题目要求是要升序排…
阅读更多...
力扣203：移除链表元素

力扣203：移除链表元素

力扣203&#xff1a;移除链表元素 题目描述&#xff1a; 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&a…
阅读更多...
【CSDN 每日一练 ★☆☆】【蛮力/双指针】删除排序链表中的重复元素

【CSDN 每日一练 ★☆☆】【蛮力/双指针】删除排序链表中的重复元素

【CSDN 每日一练 ★☆☆】【蛮力/双指针】删除排序链表中的重复元素 蛮力 双指针 题目 给定一个已按照 非递减顺序排列 的整数数组 numbers &#xff0c;请你从数组中找出两个数满足相加之和等于目标数target 。 函数应该以长度为 2 的整数数组的形式返回这两个数的下标值。…
阅读更多...
【数据结构 | 链表】leetcode 2. 两数相加

【数据结构 | 链表】leetcode 2. 两数相加

个人主页&#xff1a;兜里游客棉花糖 欢迎 点赞&#x1f44d; 收藏✨ 留言✉ 加关注&#x1f493;本文由 兜里游客棉花糖 原创 收录于专栏【LeetCode】 原题链接&#xff1a;点击直接跳转到该题目 目录 题目描述解题代码 题目描述 给你两个 非空 的链表&#xff0c;表示两个非…
阅读更多...
《LeetCode力扣练习》代码随想录——链表（反转链表---Java）

《LeetCode力扣练习》代码随想录——链表（反转链表---Java）

《LeetCode力扣练习》代码随想录——链表&#xff08;反转链表—Java&#xff09; 刷题思路来源于 代码随想录 206. 反转链表 双指针法 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNod…
阅读更多...
删除链表的倒数第N个结点（双指针）

删除链表的倒数第N个结点（双指针）

19. 删除链表的倒数第 N 个结点 - 力扣&#xff08;LeetCode&#xff09; 题目描述 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 样例输入 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5]示例 2&#xff1…
阅读更多...
『力扣刷题本』:获取链表的中间节点

『力扣刷题本』:获取链表的中间节点

一、题目 描述 输入一个链表&#xff0c;输出该链表中倒数第k个结点。 示例1 输入&#xff1a; {1,2,3,4,5}&#xff0c;1 返回值&#xff1a; {5}二、思路解析 这是一道非常经典的链表问题&#xff0c;通常需要使用快慢指针来解决。 首先&#xff0c;我们来看下题目的要…
阅读更多...
【带头学C++】----- 七、链表 ---- 7.1 链表的概述

【带头学C++】----- 七、链表 ---- 7.1 链表的概述

目录 七、链表 7.1 链表的是什么&#xff1f; 7.2数组和链表的优点和缺点 7.3 链表概述 ​编辑 7.4 设计静态链表 7.4.1 定义一个结点&#xff08;结构体&#xff09; 7.4.2 使用头结点构建一个单向链表 七、链表 7.1 链表的是什么&#xff1f; C链表是一种数据结构&a…
阅读更多...
【数据结构】树与二叉树（十八）：树的存储结构——Father链接结构、儿子链表链接结构

【数据结构】树与二叉树（十八）：树的存储结构——Father链接结构、儿子链表链接结构

文章目录 5.1 树的基本概念5.1.1 树的定义5.1.2 森林的定义5.1.3 树的术语 5.2 二叉树5.3 树5.3.1 树的存储结构1. 理论基础2. 典型实例 5.3.2 Father链接结构a. 定义树节点结构b. 创建新节点c. 主函数d. 代码整合 5.3.3 儿子链表链接结构a. 定义树节点结构b. 创建新节点c. 添加…
阅读更多...
【数据结构】图的存储结构及实现（邻接表和十字链表）

【数据结构】图的存储结构及实现（邻接表和十字链表）

一.邻接矩阵的空间复杂度 假设图G有n个顶点e条边&#xff0c;则存储该图需要O&#xff08;n^2) 不适用稀疏图的存储 二.邻接表 1.邻接表的存储思想&#xff1a; 对于图的每个顶点vi&#xff0c;将所有邻接于vi的顶点链成一个单链表&#xff0c;称为顶点vi的边表&#xff08…
阅读更多...
【数据结构】树与二叉树（十九）：树的存储结构——左儿子右兄弟链接结构（树、森林与二叉树的转化）

【数据结构】树与二叉树（十九）：树的存储结构——左儿子右兄弟链接结构（树、森林与二叉树的转化）

文章目录 5.1 树的基本概念5.1.1 树的定义5.1.2 森林的定义5.1.3 树的术语 5.2 二叉树5.3 树5.3.1 树的存储结构1. 理论基础2. 典型实例3. Father链接结构4. 儿子链表链接结构5. 左儿子右兄弟链接结构a. 定义树节点b. 创建树节点c. 使用左儿子右兄弟链接结构将树转化为二叉树d.…
阅读更多...
PTA平台-2023年软件设计综合实践_5(指针及引用)

PTA平台-2023年软件设计综合实践_5(指针及引用)

第一题 6-1 调和平均 - C/C 指针及引用 函数hmean()用于计算整数x和y的调和平均数&#xff0c;结果应保存在指针r所指向的浮点数对象中。当xy等于0时&#xff0c;函数返回0表示无法计算&#xff0c;否则返回1。数学上&#xff0c;两个数x和y的调和平均数 z 2xy/(xy) 。 直接…
阅读更多...
【刷题专栏—突破思维】LeetCode 138. 随机链表的复制

【刷题专栏—突破思维】LeetCode 138. 随机链表的复制

前言 随机链表的复制涉及到复制一个链表&#xff0c;该链表不仅包含普通的next指针&#xff0c;还包含random指针&#xff0c;该指针指向链表中的任意节点或空节点。 文章目录 原地修改链表 题目链接&#xff1a; LeetCode 138. 随机链表的复制 原地修改链表 题目介绍&#xf…
阅读更多...
C/C++---------------LeetCode第LCR. 024.反转链表

C/C++---------------LeetCode第LCR. 024.反转链表

反转链表 题目及要求双指针 题目及要求 双指针 思路&#xff1a;遍历链表&#xff0c;并在访问各节点时修改 next 引用指向&#xff0c;首先&#xff0c;检查链表是否为空或者只有一个节点&#xff0c;如果是的话直接返回原始的头节点&#xff0c;然后使用三个指针来迭代整个…
阅读更多...
【数据结构】10道经典面试题目带你玩转链表

【数据结构】10道经典面试题目带你玩转链表

&#x1f984;个人主页:修修修也 &#x1f38f;所属专栏:数据结构 ⚙️操作环境:Visual Studio 2022 目录 一.移除链表元素 二.反转链表 三.链表的中间结点 四.链表中倒数第K个结点 五.合并两个有序链表 六.链表分割 七.链表的回文结构 八.相交链表 九.环形链表 一.移…
阅读更多...
数据结构初阶leetcodeOJ题（二）

数据结构初阶leetcodeOJ题（二）

目录 第一题 思路&#xff1a; 第二题 思路 第三题 描述 示例1 思路 总结&#xff1a;这种类似的题&#xff0c;都是用快慢指针&#xff0c;相差一定的距离然后输出慢指针。 第一题 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val…
阅读更多...
【数据结构】栈与队列面试题（C语言）

【数据结构】栈与队列面试题（C语言）

我们再用C语言做题时&#xff0c;是比较不方便的&#xff0c;因此我们在用到数据结构中的某些时只能手搓或者Ctrlcv 我们这里用到的栈或队列来自栈与队列的实现 有效的括号 有效的括号&#xff0c;链接奉上。 解题思路&#xff1a; 先说结论&#xff1a; 因为我们是在讲栈与…
阅读更多...
牛客网刷题笔记三 寻找第K大+两数之和+合并两个排序的链表+用两个栈实现队列

牛客网刷题笔记三 寻找第K大+两数之和+合并两个排序的链表+用两个栈实现队列

算法题牛客网NC88 寻找第K大 题目&#xff1a; 思路就是做个排序&#xff0c;要求时间复杂度 O ( n log ⁡ n ) O(n\log n) O(nlogn)&#xff0c;因此选用快排。代码&#xff1a; class Solution:def quickSort(self, a, start, end):if start > end:returnval a[start]…
阅读更多...
线性表--链表-1

线性表--链表-1

文章目录 主要内容一.链表练习题1.设计一个递归算法&#xff0c;删除不带头结点的单链表 L 中所有值为 X 的结点代码如下&#xff08;示例&#xff09;: 2.设 L为带头结点的单链表&#xff0c;编写算法实现从尾到头反向输出每个结点的值代码如下&#xff08;示例&#xff09;: …
阅读更多...
数据结构之双向带头循环链表函数功能实现与详细解析

数据结构之双向带头循环链表函数功能实现与详细解析

个人主页&#xff1a;点我进入主页 专栏分类&#xff1a;C语言初阶 C语言程序设计————KTV C语言小游戏 C语言进阶 C语言刷题 数据结构初阶 欢迎大家点赞&#xff0c;评论&#xff0c;收藏。 一起努力&#xff0c;一起奔赴大厂。 目录 1.前言 2.带头双…
阅读更多...
合并两个有序链表(冒泡排序实现)

合并两个有序链表(冒泡排序实现)

实例要求&#xff1a;将两个升序链表合并为一个新的 升序 链表并返回&#xff1b;新链表是通过拼接给定的两个链表的所有节点组成的&#xff1b;实例分析&#xff1a;先拼接两个链表&#xff0c;在使用冒泡排序即可&#xff1b;示例代码&#xff1a; struct ListNode* mergeTwo…
阅读更多...
C语言实现带头双向循环链表

C语言实现带头双向循环链表

文章目录 写在前面1. 链表节点的定义2. 链表的初始化3. 插入数据3.1 头插3.2 尾插3.3 在指定位置的前面插入数据 4 删除数据4.1 头删4.2 尾删4.3 删除指定位置的数据 5 查找并修改数据5. 链表的销毁 写在前面 上面文章用C语言实现了单链表的增删查改&#xff0c;我们知道&…
阅读更多...
【力扣面试经典150题】（链表）K 个一组翻转链表

【力扣面试经典150题】（链表）K 个一组翻转链表

题目描述 力扣原文链接 给你链表的头节点 head &#xff0c;每 k 个节点一组进行翻转&#xff0c;请你返回修改后的链表。 k 是一个正整数&#xff0c;它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍&#xff0c;那么请将最后剩余的节点保持原有顺序。 你不能只…
阅读更多...
牛客 —— 链表中倒数第k个结点（C语言，快慢指针，配图）

牛客 —— 链表中倒数第k个结点（C语言，快慢指针，配图）

目录 1. 思路1&#xff1a;倒数第K个节点&#xff0c;就是整数第N-K1的节点 2. 思路2&#xff1a;快慢指针 1. 思路1&#xff1a;倒数第K个节点&#xff0c;就是整数第N-K1的节点 链表中&#xff0c;一共有N个节点&#xff0c;如果我们想要得出倒数第K个节点&#xff0c;我们…
阅读更多...
【带头学C++】----- 七、链表 ---- 7.5 学生管理系统（链表--上）

【带头学C++】----- 七、链表 ---- 7.5 学生管理系统（链表--上）

目录 1.main函数设计 2.定义Node节点类型 3.链表插入结点 在main函数中调用插入函数、打印函数 插入结点函数实现&#xff08;头插法&#xff09; 插入结点函数实现&#xff08;尾插法&#xff09; 遍历链表函数实现 4.演示插入、遍历结果 目录 1.main函数设计 2.定义…
阅读更多...
Leetcode—剑指OfferII LCR 022.环形链表II【中等】

Leetcode—剑指OfferII LCR 022.环形链表II【中等】

2023每日刷题&#xff08;三十三&#xff09; Leetcode—LCR 022.环形链表II 算法思想 参考k神的博客 实现代码 /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/ struct ListNode *detectCycle(struct List…
阅读更多...
快慢指针之：链表中倒数第k个结点

快慢指针之：链表中倒数第k个结点

题目描述 题目链接&#xff1a;链表中倒数第k个结点_牛客题霸_牛客网 (nowcoder.com) 题目分析 我们可以利用快慢指针来解决问题&#xff1a; 思路一&#xff1a; 先让fast走k步&#xff0c;这时候fast和slow之间的距离就是k&#xff0c;然后让fast和slow同时同步往后走&am…
阅读更多...
【数据结构】链表的八种形态

【数据结构】链表的八种形态

&#x1f984;个人主页:修修修也 &#x1f38f;所属专栏:数据结构 ⚙️操作环境:Visual Studio 2022 目录 链表的三大"性状" 一.带头链表和不带头链表 头指针与头结点的异同 头指针 头结点 二.循环链表和非循环链表 三.双向链表和单向链表 链表的八大形态 结语…
阅读更多...
【数据结构(三)】单向环形链表和约瑟夫问题（3）

【数据结构(三)】单向环形链表和约瑟夫问题（3）

文章目录 1. 单向环形链表应用场景2. 思路分析3. 代码实现3.1. 实现单向环形链表3.2. 产生出队编号序列3.2.1. 思路分析3.2.2. 代码实现 1. 单向环形链表应用场景 Josephu(约瑟夫、约瑟夫环) 问题&#xff1a; 设编号为 1&#xff0c;2&#xff0c;… n 的 n 个人围坐一圈&…
阅读更多...
【手撕数据结构】（三）顺序表和链表

【手撕数据结构】（三）顺序表和链表

文章目录 一、线性表二、顺序表1.概念及结构2.关于数组3.顺序表分类&#x1f397;️静态顺序表&#x1f397;️动态顺序表 4.接口实现&#xff08;1&#xff09;思路&#xff08;2&#xff09;SeqList.h文件代码功能1&#xff1a;顺序表初始化功能2&#xff1a;销毁顺序表功能3…
阅读更多...
一篇博客读懂双向链表

一篇博客读懂双向链表

目录 一、双向带头循环链表的格式 二、链表的初始化和销毁 2.1链表的初始化 2.2链表的销毁 三、链表的检查与准备 3.1链表的打印 3.2创建新结点 四、链表增删查改 4.1尾插 4.2尾删 4.3头插 4.4头删 4.5查找 4.6任意位置前插入 4.7删除任意位置 一、双向带…
阅读更多...
「C++」AVL树的实现（动图）

「C++」AVL树的实现（动图）

&#x1f4bb;文章目录 AVL树概念AVL的查找AVL树的插入 代码部分AVL树的定义查找插入旋转 &#x1f4d3;总结 AVL树 概念 AVL树又名高度平衡的二叉搜索树&#xff0c;由G. M. Adelson-Velsky和E. M. Landis发明&#xff0c;顾名思义&#xff0c;其任意节点的左右子树最大高度…
阅读更多...
快速生成力扣链表题的链表，实现快速调试

快速生成力扣链表题的链表，实现快速调试

关于力扣链表题需要本地调试创建链表的情况 我们在练习链表题&#xff0c;力扣官方需要会员&#xff0c;我们又不想开会员&#xff0c;想在本地调试给你们提供的代码 声明&#xff1a;本人也是参考的别人的代码&#xff0c;给你们提供不同语言生成链表 参考链接&#xff1a; 参…
阅读更多...
Leetcode—142.环形链表II【中等】

Leetcode—142.环形链表II【中等】

2023每日刷题&#xff08;三十三&#xff09; Leetcode—142.环形链表II 实现代码 /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/ struct ListNode *detectCycle(struct ListNode *head) {struct ListNode* …
阅读更多...
Leetcode—141.环形链表【简单】

Leetcode—141.环形链表【简单】

2023每日刷题&#xff08;三十三&#xff09; Leetcode—141.环形链表 快慢指针算法思想 关于快慢指针为什么能检测出环&#xff0c;可以这么思考。 假设存在一个环: 慢指针进入环后&#xff0c;快指针和慢指针之间相距为d&#xff0c;每一次移动&#xff0c;d都会缩小1&…
阅读更多...
单链表的实现（Single Linked List）---直接拿下！

单链表的实现（Single Linked List）---直接拿下！

单链表的实现&#xff08;Single Linked List&#xff09;—直接拿下&#xff01; 文章目录 单链表的实现&#xff08;Single Linked List&#xff09;---直接拿下&#xff01;一、单链表的模型二、代码实现&#xff0c;接口函数实现①初始化②打印链表③创建一个结点④尾插⑤尾…
阅读更多...
LeetCode | 19. 删除链表的倒数第 N 个结点

LeetCode | 19. 删除链表的倒数第 N 个结点

LeetCode | 19. 删除链表的倒数第 N 个结点 OJ链接 思路&#xff1a; 定义虚拟头节点dummy并初始化使其指向head然后定义快慢指针让快指针先走n步然后一起走最后删除倒数第n个节点然后释放虚拟节点dummy struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {…
阅读更多...
【链表的说明、方法---顺序表与链表的区别】

【链表的说明、方法---顺序表与链表的区别】

文章目录 前言什么是链表链表的结构带头和不带头的区别 链表的实现&#xff08;方法&#xff09;遍历链表头插法尾插法任意位置插入一个节点链表中是否包含某个数字删除链表某个节点删除链表中所有关键字key清空链表所有节点 ArrayList 和 LinkedList的区别总结 前言 什么是链…
阅读更多...
[数据结构]—栈和队列

[数据结构]—栈和队列

&#x1f493;作者简介&#x1f389;&#xff1a;在校大二迷茫大学生 &#x1f496;个人主页&#x1f389;&#xff1a;小李很执着 &#x1f497;系列专栏&#x1f389;&#xff1a;数据结构 每日分享✨&#xff1a;到头来&#xff0c;有意义的并不是结果&#xff0c;而是我们度…
阅读更多...
算法通关村第一关挑战——帮鱼皮打印算法学员名单

算法通关村第一关挑战——帮鱼皮打印算法学员名单

package com.yugutou.charpter1_linklist.hk;/*** 第一关挑战*/ public class StudentLinkList {public static void main(String[] args) {Student head init();Student ccPython new Student("cc", "Python");add(head, ccPython);Student bcCPP new …
阅读更多...
【追求卓越03】数据结构--链表练习题

【追求卓越03】数据结构--链表练习题

引导 链表是我们工作和面试的中常常会遇到的知识点&#xff0c;只有长时间的练习和思考才能游刃有余。故总结以下几个比较经典的链表题和对应的代码&#xff0c;进行参考。 链表的反转 思路&#xff1a; 将链表遍历&#xff0c;将每个节点拷贝一份&#xff0c;之后再将所有的…
阅读更多...
每日一题(LeetCode)----链表--分隔链表

每日一题(LeetCode)----链表--分隔链表

每日一题(LeetCode)----链表–分隔链表 1.题目&#xff08;86. 分隔链表&#xff09; 给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你应当 保留 两个分区中每个节点的初…
阅读更多...
链表？细啊！超详细的知识点总结！

链表？细啊！超详细的知识点总结！

链表 定义&#xff1a;链表是一种递归的数据结构&#xff0c;它或者为空&#xff08;null)&#xff0c;或者是指向一个结点&#xff08;node&#xff09;的引用&#xff0c;该结点含有一个泛型的元素和一个指向另一条链表的引用。 ​ 其实链表就是有序的列表&#xff0c;它在内…
阅读更多...
链表的有序构建和查找/构建链表【数据结构】

链表的有序构建和查找/构建链表【数据结构】

链表的有序构建和查找 题目描述 单链表结点的存储结构包含两部分&#xff1a;数据、下一结点指针&#xff08;默认为空&#xff09;。 单链表包含头结点&#xff0c;存储实际数据的结点位置从1开始。 现输入一批无序的整数队列&#xff0c;编写程序完成以下要求 1&#xff09;…
阅读更多...
单链表相关面试题--5.合并有序链表

单链表相关面试题--5.合并有序链表

5.合并有序链表 21. 合并两个有序链表 - 力扣&#xff08;LeetCode&#xff09; /* 解题思路&#xff1a; 此题可以先创建一个空链表&#xff0c;然后依次从两个有序链表中选取最小的进行尾插操作进行合并。 */ typedef struct ListNode Node; struct ListNode* mergeTwoList…
阅读更多...
数据结构重点知识点复习——第二章 线性表（链表）

数据结构重点知识点复习——第二章 线性表（链表）

目录 一、线性表的链式存储结构 ​编辑 二、单链表 1头插法 2尾插法 3按序号查找 4按值查找 5插入 6删除 三、双链表 1定义 2插入 3删除 四、循环与静态链表 1循环链表 1循环单链表&#xff1a; 2循环双链表&#xff1a; 3应用场景&#xff1a; 2静态链表 应…
阅读更多...
【数据结构】深入浅出理解链表中二级指针的应用

【数据结构】深入浅出理解链表中二级指针的应用

&#x1f984;个人主页:修修修也 &#x1f38f;所属专栏:数据结构 ⚙️操作环境:Visual Studio 2022 (注:为方便演示本篇使用的x86系统,因此指针的大小为4个字节) 目录 &#x1f4cc;形参的改变不影响实参! 1.调用函数更改整型时传值调用与传址调用的区别 &#x1f38f;传值…
阅读更多...
链表OJ--上

链表OJ--上

文章目录 前言一、反转链表二、移除链表元素三、链表中倒数第K个结点四、相交链表五、链表的中间结点 前言 一、反转链表 力扣206&#xff1a;反转链表- - -点击此处传送 思路图&#xff1a; 方法一&#xff1a;改变指向 方法二&#xff1a; 代码&#xff1a; //方法一 /…
阅读更多...
手把手教你实现一个循环队列（C语言）

手把手教你实现一个循环队列（C语言）

这是一道leetcode关于队列的经典题&#xff1a; 622. 设计循环队列https://leetcode.cn/problems/design-circular-queue/ 思路&#xff1a; 大家注意这个题目要求&#xff0c;这个队列是定长的&#xff0c;如果满了则不能再添加数据。那么我们设计一个队头front和队尾rear&…
阅读更多...
已知两个链表L1和L2分别表示两个集合，其中元素递增排列。请设计一个算法，用于求出L1与L2的交集，并存放在L1链表中

已知两个链表L1和L2分别表示两个集合，其中元素递增排列。请设计一个算法，用于求出L1与L2的交集，并存放在L1链表中

已知两个链表L1和L2分别表示两个集合&#xff0c;其中元素递增排列。请设计一个算法&#xff0c;用于求出L1与L2的交集&#xff0c;并存放在L1链表中。 代码思路&#xff1a; 我们创建一个辅助链表L3&#xff0c;用于存储L1和L2链表的交集&#xff0c;用s遍历L3各个元素 用p和…
阅读更多...
【Qt】判断QList链表内是否有重复数据

【Qt】判断QList链表内是否有重复数据

QList<int> listInt;listInt.push_back(1);listInt.push_back(1);listInt.push_back(2);listInt.push_back(3);qDebug().noquote() << listInt.toSet().toList();
阅读更多...
leetcode算法之链表

leetcode算法之链表

目录 1.两数相加2.两两交换链表中的节点3.重排链表4.合并K个升序链表5.K个一组翻转链表 1.两数相加 两数相加 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(…
阅读更多...
【算法萌新闯力扣】：合并两个有序链表

【算法萌新闯力扣】：合并两个有序链表

力扣题目&#xff1a;合并两个有序链表 开篇 今天是备战蓝桥杯的第24天及算法村开营第2天。根据算法村的讲义&#xff0c;来刷链表的相关题目。今天要分享的是合并两个有序链表。 题目链接: 21.合并两个有序链表 题目描述 代码思路 通过创建一个新链表&#xff0c;然后遍历…
阅读更多...
【无头双向链表和链表练习题2】

【无头双向链表和链表练习题2】

文章目录 以给定值x为基准将链表分割成两部分&#xff0c;所有小于x的结点排在大于或等于x的结点之前输入两个链表&#xff0c;找出它们的第一个公共结点。给定一个链表&#xff0c;判断链表中是否有环无头双向链表的模拟实现ArrayList&#xff08;顺序表&#xff09;和LinkedL…
阅读更多...
算法通关村第二关—手写链表反转(青铜)

算法通关村第二关—手写链表反转(青铜)

链表反转的三种方式 一、建立虚拟头结点辅助反转 为了方便反转&#xff0c;可以创建一个ans结点&#xff0c;让ans.next head,然后后面的结点一次插入到ans.next 在下图中&#xff0c;对&#xff08;1->2->3->4->5&#xff09;进行反转&#xff0c;可以创建ans&…
阅读更多...
LeetCode.24两两交换链表中的节点

LeetCode.24两两交换链表中的节点

LeetCode.24两两交换链表中的节点 1.问题描述2.解题思路3.代码 1.问题描述 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 示…
阅读更多...
删除链表的节点,剑指offer 18,力扣

删除链表的节点,剑指offer 18,力扣

目录 题目地址&#xff1a; 题目&#xff1a; 我们直接看题解吧&#xff1a; 解题方法&#xff1a; 审题目事例提示&#xff1a; 解题分析&#xff1a; 解题思路&#xff08;双指针&#xff09;&#xff1a; 代码实现&#xff1a; 代码实现&#xff08;直接遍历&#xff09;&am…
阅读更多...
回文链表，剑指offer 27，力扣 61

回文链表，剑指offer 27，力扣 61

目录 题目&#xff1a; 我们直接看题解吧&#xff1a; 解题方法&#xff1a; 难度分析&#xff1a; 审题目事例提示&#xff1a; 解题分析&#xff1a; 解题思路&#xff08;数组列表双指针&#xff09;&#xff1a; 代码说明补充&#xff1a; 代码实现&#xff1a; 代码实现&a…
阅读更多...
LRU缓存淘汰策略的实现——LinkedHashMap哈希链表

LRU缓存淘汰策略的实现——LinkedHashMap哈希链表

LRU&#xff08;最近最少使用&#xff09;缓存淘汰策略可以通过使用哈希链表实现。LinkedHashMap 是 Java 中提供的一种数据结构&#xff0c;它综合了哈希表和双向链表的特点&#xff0c;非常适合用来实现 LRU 缓存。 LinkedHashMap 内部维护了一个哈希表和一个双向链表。哈希…
阅读更多...
C语言每日一题（43）旋转链表

C语言每日一题（43）旋转链表

力扣 61 旋转链表 题目描述 给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], k 2 输出&#xff1a;[4,5,1,2,3]示例 2&#xff1a; 输入&#xff1a;head [0,1,2], …
阅读更多...
单链表OJ题--9.环形链表

单链表OJ题--9.环形链表

9.环形链表 141. 环形链表 - 力扣&#xff08;LeetCode&#xff09; /* 解题思路&#xff1a; 定义快慢指针fast,slow, 如果链表确实有环&#xff0c;fast指针一定会在环内追上slow指针。 */typedef struct ListNode Node; bool hasCycle(struct ListNode *head) {Node* slow …
阅读更多...
C/C++---------------LeetCode第876. 链表的中间结点

C/C++---------------LeetCode第876. 链表的中间结点

链表的中间结点 题目及要求双指针在main内使用 题目及要求 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结点。 示例 1&#xff1a; 示例 2&#xff1a; 双指针 思路&#xff1a;分别定义快慢指针…
阅读更多...
P4 链表的节点数统计与链表数据查找替换

P4 链表的节点数统计与链表数据查找替换

目录 前言 01 链表的节点数统计 02 链表数据查找替换 2.1 残疾的数据查找 2.2 数据查找优化 前言 &#x1f3ac; 个人主页&#xff1a;ChenPi &#x1f43b;推荐专栏1: 《C 》✨✨✨ &#x1f525; 推荐专栏2: 《 Linux C应用编程&#xff08;概念类&#xff09;》✨…
阅读更多...
数据结构：带头双向循环链表的实现

数据结构：带头双向循环链表的实现

引言 单链表存在缺陷&#xff1a;需要从头开始找前一个节点 解决方法&#xff1a;双向链表 链表的结构&#xff08;8种&#xff09;&#xff1a; 1. 单向&#xff0c;双向 2. 带头、不带头 带头即为带哨兵位的头节点&#xff0c;第一个节点不存储有效数据。带头节点&#…
阅读更多...
数据结构基础（不带头节点的单向非循环链表）

数据结构基础（不带头节点的单向非循环链表）

单链表完整代码 LinkList.hLinkList.ctest.c LinkList.h #pragma once#include <stdio.h> #include <stdlib.h> #include <assert.h> #include <string.h>typedef int ElemType; typedef struct LNode {ElemType data;struct LNode* next; }LNode;voi…
阅读更多...
超详细实现【贪吃蛇】（1）

超详细实现【贪吃蛇】（1）

目录 技术要点介绍 &#x1f642;Win32 API &#x1f642;控制台程序 &#x1f387;标题 &#x1f387;大小 在Windows终端上&#xff1a; 在VS上&#xff1a; &#x1f387;坐标 &#x1f642;光标 &#x1f636;‍&#x1f32b;️GetStdHandle &#x1f636;‍&am…
阅读更多...
【LeeCode】24. 两两交换链表中的节点

【LeeCode】24. 两两交换链表中的节点

给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4] 输出&#xff1a;[2,1,4…
阅读更多...
算法通关村第五关—队栈和Hash的经典问题(白银)

算法通关村第五关—队栈和Hash的经典问题(白银)

emsp;emsp;emsp队栈和Hash的经典问题 用栈实现队列 栈是先进后出&#xff0c;队列是先进先出&#xff0c;所以可以使用两个栈来实现队列的功能。 LeetCode232&#xff1a; 请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作(push、pop、peek、 empty): …
阅读更多...
C语言之实现贪吃蛇小游戏篇（2）

C语言之实现贪吃蛇小游戏篇（2）

目录 &#x1f387;测试游戏test.c &#x1f387;游戏头文件包含&函数声明snake.h &#x1f387;游戏实现snake.c &#x1f387;测试游戏test.c #define _CRT_SECURE_NO_WARNINGS 1 #include "snake.h" void test() {int ch 0;do{Snake snake { 0 };//创建…
阅读更多...
Java LeetCode篇-深入了解关于栈的经典解法（栈实现：中缀表达式转后缀）

Java LeetCode篇-深入了解关于栈的经典解法（栈实现：中缀表达式转后缀）

&#x1f525;博客主页&#xff1a; 【小扳_-CSDN博客】 ❤感谢大家点赞&#x1f44d;收藏⭐评论✍ 文章目录 1.0 中缀表达式转后缀说明 1.1 实现中缀表达式转后缀思路 2.0 逆波兰表达式求值 2.1 实现逆波兰表达式求值思路 3.0 有效的括号 3.1 实现有效的括号思路 4.0 栈的压…
阅读更多...
数据结构：图文详解单链表的各种操作（头插法，尾插法，任意位置插入，删除节点，查询节点，求链表的长度，清空链表）

数据结构：图文详解单链表的各种操作（头插法，尾插法，任意位置插入，删除节点，查询节点，求链表的长度，清空链表）

目录 一.什么是链表 二.链表的实现 节点的插入 头插法 尾插法 指定位置插入 节点的删除 删除第一次出现的关键字节点 删除所有关键字节点 节点的查找 链表的清空 链表的长度 前言&#xff1a;在上一篇文章中&#xff0c;我们认识了线性数据结构中的顺序表&#xff0…
阅读更多...
数据结构奇妙旅程之顺序表和链表

数据结构奇妙旅程之顺序表和链表

꒰˃͈꒵˂͈꒱ write in front ꒰˃͈꒵˂͈꒱ ʕ̯•͡˔•̯᷅ʔ大家好&#xff0c;我是xiaoxie.希望你看完之后,有不足之处请多多谅解&#xff0c;让我们一起共同进步૮₍❀ᴗ͈ . ᴗ͈ აxiaoxieʕ̯•͡˔•̯᷅ʔ—CSDN博客 本文由xiaoxieʕ̯•͡˔•̯᷅ʔ 原创 CSDN …
阅读更多...
leetcode 142.环形链表2

leetcode 142.环形链表2

我来更新 leetcode 题目了&#xff0c;接着上一次&#xff0c;这一次是上一道题目的提升&#xff08;有点数学题的感觉&#xff09; 142.环形链表2 题目 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表…
阅读更多...
队列实现栈VS栈实现队列

队列实现栈VS栈实现队列

目录 【1】用队列实现栈 思路分析 ​ 易错总结 Queue.c&Queue.h手撕队列 声明栈MyStack 创建&初始化栈myStackCreate 压栈myStackPush 出栈&返回栈顶元素myStackPop 返回栈顶元素myStackTop 判断栈空否myStackEmpty 释放空间myStackFree MyStack总代码…
阅读更多...
基于C#实现十字链表

基于C#实现十字链表

上一篇我们看了矩阵的顺序存储&#xff0c;这篇我们再看看一种链式存储方法“十字链表”&#xff0c;当然目的都是一样&#xff0c;压缩空间。 一、概念 既然要用链表节点来模拟矩阵中的非零元素&#xff0c;肯定需要如下 5 个元素(row,col,val,down,right)&#xff0c;其中&…
阅读更多...
删除链表的倒数第N个节点，剑指offerII（21）,力扣

删除链表的倒数第N个节点，剑指offerII（21）,力扣

目录 题目地址&#xff1a; 题目&#xff1a; 相似类型题&#xff1a; 我们直接看本题题解吧&#xff1a; 解题方法&#xff1a; 难度分析&#xff1a; 解题分析&#xff1a; 解题思路&#xff08;双指针&#xff09;&#xff1a; 代码实现&#xff1a; 代码说明&#xff1a; 代…
阅读更多...
算法通关村第六关—序列恢复二叉树(青铜)

算法通关村第六关—序列恢复二叉树(青铜)

根据序列恢复二叉树 示例 给定序列恢复二叉树(1)前序&#xff1a;1 2 3 4 5 6 8 7 9 10 11 12 13 15 14(2)中序&#xff1a;3 4 8 6 7 5 2 1 10 9 11 15 13 14 123)后序&#xff1a;8 7 6 5 4 3 2 10 15 14 13 12 11 9 1 一、前中序列恢复二叉树 (1)前序&#xff1a;1 2 3…
阅读更多...
C //习题 9.8 写一个函数insert，用来向一个动态链表插入结点。

C //习题 9.8 写一个函数insert，用来向一个动态链表插入结点。

C程序设计 &#xff08;第四版&#xff09; 谭浩强 习题9.8 习题 9.8 写一个函数insert&#xff0c;用来向一个动态链表插入结点。 IDE工具&#xff1a;VS2010 Note: 使用不同的IDE工具可能有部分差异。 代码块: 由于链表是动态链表&#xff0c;不能按照结构体变量为数组的…
阅读更多...
C语言链表学习实例，链表初始化，利用尾指针将两个链表链接在一起。

C语言链表学习实例，链表初始化，利用尾指针将两个链表链接在一起。

C语言链表学习实例&#xff0c;链表初始化&#xff0c;利用尾指针将两个链表链接在一起。 这个实例中&#xff0c;讲解了如何使用两个单循环链表利用尾指针连接&#xff0c;代码如下&#xff1a; #include<stdio.h> #include<stdlib.h> typedef struct CLinkList {…
阅读更多...
【LeetCode刷题-链表】--92.反转链表II

【LeetCode刷题-链表】--92.反转链表II

92.反转链表II /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* ListNode(int val, ListNode next) { this.val val; this.next next; }* }*/ cla…
阅读更多...
【链表Linked List】力扣-114 二叉树展开为链表

【链表Linked List】力扣-114 二叉树展开为链表

目录 题目描述 解题过程 官方题解 题目描述 给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左子指针始终为 null 。展开后的单链表应…
阅读更多...
C++刷题 -- 链表

C++刷题 -- 链表

C刷题 – 链表 文章目录 C刷题 -- 链表1.删除链表的倒数第 N 个结点2.链表相交3.环形链表 1.删除链表的倒数第 N 个结点 https://leetcode.cn/problems/remove-nth-node-from-end-of-list/ 快慢指针的应用 fast指针先移动N步&#xff0c;slow依然指向head&#xff1b;然后fa…
阅读更多...
【C++数据结构 | 图速通】10分钟掌握邻接矩阵 邻接表 | 快速掌握图论基础 | 快速上手抽象数据类型图

【C++数据结构 | 图速通】10分钟掌握邻接矩阵 邻接表 | 快速掌握图论基础 | 快速上手抽象数据类型图

图 by.Qin3Yu 请注意&#xff1a;严格来说&#xff0c;图不是一种数据结构&#xff0c;而是一种抽象数据类型。但为了保证知识点之间的相关性&#xff0c;也将其列入数据结构专栏。 本文需要读者掌握顺序表和单链表的操作基础&#xff0c;若需学习&#xff0c;可参阅我的往期文…
阅读更多...
【算法集训】基础数据结构：三、链表

【算法集训】基础数据结构：三、链表

链表就是将所有数据都用一个链子串起来&#xff0c;其中链表也有多种形式&#xff0c;包含单向链表、双向链表等&#xff1b; 现在毕竟还是基础阶段&#xff0c;就先学习单链表吧&#xff1b; 链表用头结点head表示一整个链表&#xff0c;每个链表的节点包含当前节点的值val和下…
阅读更多...
【链表Linked List】力扣-203 移除链表元素

【链表Linked List】力扣-203 移除链表元素

目录 题目描述 解题过程 题目描述 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5…
阅读更多...
【力扣】移除链表元素203

【力扣】移除链表元素203

目录 1.前言2. 题目描述3. 题目分析3.1 不带哨兵位3.2 带哨兵位 4. 附代码4.1 不带哨兵位4.2 带哨兵位 1.前言 这里开始介绍从网上一些刷题网站上的题目&#xff0c;在这里做一些分享&#xff0c;和学习记录。 先来介绍一些力扣的OJ题目。 这里的OJ就是我们不需要写主函数&…
阅读更多...
【nowcoder】BM2 链表内指定区间反转

【nowcoder】BM2 链表内指定区间反转

题目 题目分析&#xff1a; # 代码实现&#xff1a; package BMP2;class ListNode {int val;ListNode next null;public ListNode(int val) {this.val val;} } public class BM2 {/*** 代码中的类名、方法名、参数名已经指定&#xff0c;请勿修改&#xff0c;直接返回方法…
阅读更多...
创建第一个 Flink 项目

创建第一个 Flink 项目

一、运行环境介绍 Flink执行环境主要分为本地环境和集群环境&#xff0c;本地环境主要为了方便用户编写和调试代码使用&#xff0c;而集群环境则被用于正式环境中&#xff0c;可以借助Hadoop Yarn、k8s或Mesos等不同的资源管理器部署自己的应用。 环境依赖&#xff1a; 【1】…
阅读更多...
leetcode系列：反转链表的形象表示

leetcode系列：反转链表的形象表示

反转链表是一道比较简单的题&#xff0c;主要考察的是对链表数据结构的理解和双指针应用&#xff0c;比较容易出错的地方是指针的移动顺序。在练习的过程中想到了一个比较形象的表示方法&#xff0c;于是记录下来。 # Definition for singly-linked list. # class ListNode: #…
阅读更多...
【RTOS学习】FreeRTOS中的链表 | 堆的管理

【RTOS学习】FreeRTOS中的链表 | 堆的管理

&#x1f431;作者&#xff1a;一只大喵咪1201 &#x1f431;专栏&#xff1a;《RTOS学习》 &#x1f525;格言&#xff1a;你只管努力&#xff0c;剩下的交给时间&#xff01; 目录 &#x1f969;FreeRTOS中的链表&#x1f95e;初始化&#x1f95e;尾部插入&#x1f95e;按顺…
阅读更多...
【力扣】206.反转链表

【力扣】206.反转链表

206.反转链表 这道题有两种解法&#xff0c;但不只有两种&#xff0c;嘿嘿。 法一&#xff1a;迭代法 就是按循序遍历将每一个指针的指向都给改了。比如说1——>2——>3改为null<——1<——2<——3这样。那这里以第二个结点为例&#xff0c;想一想。我想要指向…
阅读更多...
数据结构-二叉树（1）

数据结构-二叉树（1）

1.树概念及结构 1.1树的概念 树是一种非线性的数据结构&#xff0c;它是由n&#xff08;n>0&#xff09;个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树&#xff0c;也就是说它是根朝上&#xff0c;而叶朝下的。 1.有一个特殊的结点&…
阅读更多...
数据结构：图文详解双向链表的各种操作（头插法，尾插法，任意位置插入，查询节点，删除节点，求链表的长度... ...）

数据结构：图文详解双向链表的各种操作（头插法，尾插法，任意位置插入，查询节点，删除节点，求链表的长度... ...）

目录 一.双向链表的概念 二.双向链表的数据结构 三.双向链表的实现 节点的插入 头插法 尾插法 任意位置插入 节点的删除 删除链表中第一次出现的目标节点 删除链表中所有与关键字相同的节点 节点的查找 链表的清空 链表的长度 四.模拟实现链表的完整代码 前言&am…
阅读更多...
LeetCode141. Linked List Cycle

LeetCode141. Linked List Cycle

文章目录 一、题目二、题解 一、题目 Given head, the head of a linked list, determine if the linked list has a cycle in it. There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the next poi…
阅读更多...
【自用数据结构】—将链表中的奇数全部移动到偶数前面

【自用数据结构】—将链表中的奇数全部移动到偶数前面

void move(LNode*& L){ LNode* pL; while(p!null){ if((p->next->data)%21) //判断该元素是否为奇函数 LNode *s p->next; p->nexts->next; s->nextL->next; L->nexts; else pp->next; } }
阅读更多...
【力扣 面试题02.07链表相交】一种思路极其清晰的解法

【力扣 面试题02.07链表相交】一种思路极其清晰的解法

力扣一单简单题&#xff0c;看完大佬的题解真是佩服得五体投地&#xff01; 虽是一道简单题&#xff0c;当我吭哧吭哧写了几十行后&#xff0c;看到大佬仅仅几行直接秒掉&#xff0c;只能说算法的本质还是数学&#xff0c;数学逻辑思维真是太重要了&#xff0c;有时候真得慢慢去…
阅读更多...
链表【3】

链表【3】

文章目录 &#x1f433;23. 合并 K 个升序链表&#x1f41f;题目&#x1f42c;算法原理&#x1f420;代码实现 &#x1f437;25. K 个一组翻转链表&#x1f416;题目&#x1f43d;算法原理&#x1f367;代码实现 &#x1f433;23. 合并 K 个升序链表 &#x1f41f;题目 题目链…
阅读更多...
LeetCode（58）随机链表的复制【链表】【中等】

LeetCode（58）随机链表的复制【链表】【中等】

目录 1.题目2.答案3.提交结果截图 链接&#xff1a; 随机链表的复制 1.题目 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节…
阅读更多...
链表基础知识（一、单链表）

链表基础知识（一、单链表）

一、链表表示和实现 顺序表的问题及思考 问题&#xff1a; 1. 中间/头部的插入删除&#xff0c;时间复杂度为O(N) 2. 增容需要申请新空间&#xff0c;拷贝数据&#xff0c;释放旧空间。会有不小的消耗。 3. 增容一般是呈2倍的增长&#xff0c;势必会有一定的空间浪费。例如当…
阅读更多...
初级数据结构（四）——队列

初级数据结构（四）——队列

文中代码源文件已上传&#xff1a;数据结构源码 <-上一篇 初级数据结构&#xff08;三&#xff09;——栈 | NULL 下一篇-> 本篇是属于上一篇的补充篇&#xff0c;因为队列和栈的属性特别类似&#xff0c;很多细节部分可以查看上一篇或者初级据结构的第二…
阅读更多...
LeetCode-2487. 从链表中移除节点【栈 递归 链表 单调栈】

LeetCode-2487. 从链表中移除节点【栈 递归 链表 单调栈】

LeetCode-2487. 从链表中移除节点【栈 递归 链表 单调栈】 题目描述&#xff1a;解题思路一&#xff1a;可以将链表转为数组&#xff0c;然后从后往前遍历&#xff0c;遇到大于等于当前元素的就入栈&#xff0c;最终栈里面的元素即是最终的答案。解题思路二&#xff1a;递归&am…
阅读更多...
力扣刷题笔记——反转链表

力扣刷题笔记——反转链表

力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 经典问题反转链表 这里给出四种解法 1.双指针 这种方法是用一个next指针记录当前节点的下一个节点&#xff0c;一个pre指针记录当前节点的前一个节点。 只需要遍历一遍链表就可以完成链表的反转 c…
阅读更多...
链表OJ—相交链表

链表OJ—相交链表

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言 1、相交链表的题目&#xff1a; 方法讲解&#xff1a; 图文解析&#xff1a; 代码实现&#xff1a; 总结 前言 世上有两种耀眼的光芒&#xff0c;一种是正在升…
阅读更多...
qt 链表QList,QLinkedList的常见使用

qt 链表QList,QLinkedList的常见使用

QList,QLinkedList这俩个链表是qt里面常用的模板类容器,QLinkedList继承自QList.下面先说说QList. QList类------------------------------------------- QList,QLinkedList是一个模板类容器,它可以存储多种数据类型.与先前介绍的QString,QStringList,它的方法也非常的类似,常…
阅读更多...
day4 链表（2）

day4 链表（2）

Day4 2023.12.3&#xff08;昨天有事没写&#xff0c;按训练营时间&#xff0c;周天休息&#xff0c;我把第三天的补上&#xff09; 代码随想录 1. 24两两交换链表中的节点 对于交换节点&#xff0c;不仅仅是值得交换&#xff0c;不然就很简单了&#xff0c;我们要交换的是节点…
阅读更多...
【LeetCode刷题-链表】-- 143.重排链表

【LeetCode刷题-链表】-- 143.重排链表

143.重排链表 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* ListNode(int val, ListNode next) { this.val val; this.next next; }* }*/ clas…
阅读更多...
静态链表（模拟链表）数据的插入

静态链表（模拟链表）数据的插入

链表中的每一个结点只有两个部分。我们可以用一个数组 data 来存储每序列中的每一个 数。那每一个数右边的数是谁&#xff0c;这一点该怎么解决呢&#xff1f;上一节中是使用指针来解决的&#xff0c;这里 我们只需再用一个数组right来存放序列中每一个数右边的数是谁就可以了&…
阅读更多...
【力扣】141和142环形链表

【力扣】141和142环形链表

141.环形链表 法一&#xff1a;快慢指针 思路&#xff1a; 用两个指针slow,fast,后者能比前者多走一步路&#xff0c;那判断是不是有环&#xff0c;只需要判断是否会相遇。 就是有一个能比乌龟跑2倍快的兔子&#xff0c;两小只都在有环的路上跑&#xff0c;那是不是肯定会相…
阅读更多...
12.12_黑马数据结构与算法笔记Java

12.12_黑马数据结构与算法笔记Java

目录 079 优先级队列 无序数组实现 080 优先级队列 有序数组实现 081 优先级队列 堆实现 1 082 优先级队列 堆实现 2 083 优先级队列 堆实现 3 084 优先级队列 e01 合并多个有序链表1 084 优先级队列 e01 合并多个有序链表2 085 阻塞队列 问题提出 086 阻塞队列 单锁实…
阅读更多...
leetcode19. 删除链表的倒数第 N 个结点

leetcode19. 删除链表的倒数第 N 个结点

题目描述 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5]示例 2&#xff1a; 输入&#xff1a;head [1], n 1 输出&#xff1a;[]示例 3…
阅读更多...
数据结构入门到入土——链表（完）LinkedList

数据结构入门到入土——链表（完）LinkedList

目录 一&#xff0c;双向链表 1.单向链表的缺点 2.什么是双向链表&#xff1f; 3.自主实现双向链表 接口实现&#xff1a; 二&#xff0c;LinkedList 1.LinkedList的使用 1.1 什么是LinkedList&#xff1f; 1.2 LinkedList的使用 1.LinkedList的构造 2.LinkedList的…
阅读更多...
C语言项目搭建-图书管理系统（链表详解）

C语言项目搭建-图书管理系统（链表详解）

项目介绍 项目名称&#xff1a;图书管理系统 图书管理系统设计与实现项目的背景&#xff1a; 图书馆人员结构复杂&#xff0c;人员数量有限&#xff0c;涉及方面很广&#xff0c;如果还使用手工操作处理图书借阅问题&#xff0c;工作将非常繁琐&#xff0c;需要大量的人力、物…
阅读更多...
力扣刷题——两两交换链表的节点：24题

力扣刷题——两两交换链表的节点：24题

交换后的链表如下&#xff1a; 然后cur指针后移&#xff0c;交换下两个节点&#xff0c;需要使得pre指向cur的前一个&#xff0c;因此使pre先指向cur 最后可以写出一次循环应该进行的处理&#xff1a; pre.next temp; cur.next temp.next; temp.next cur; pre cur; cur …
阅读更多...
第一个动态结构：链表

第一个动态结构：链表

王有志&#xff0c;一个分享硬核Java技术的互金摸鱼侠加入Java人的提桶跑路群&#xff1a;共同富裕的Java人 今天我们一起学习线性表中的第二种数据结构&#xff1a;链表&#xff0c;也是真正意义上的第一个动态数据结构。今天的内容分为3个部分&#xff1a;认识链表&#xff0…
阅读更多...
MergeTwoSortedLists 【合并有序链表】

MergeTwoSortedLists 【合并有序链表】

有种归并排序的感觉 链表好久不用有些生疏了&#xff0c;思想思路是对的&#xff0c;但是代码写出来有问题&#xff0c;。 写完说点感受&#xff1a; 当时在学校学习链表的时候&#xff0c;就了解到链表分为“有头节点”和“无头节点”的链表&#xff0c;所以这里好像就不练&am…
阅读更多...
【LeetCode】142. 环形链表 II（中等）——代码随想录算法训练营Day04

【LeetCode】142. 环形链表 II（中等）——代码随想录算法训练营Day04

题目链接&#xff1a;142. 环形链表 II 题目描述 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了…
阅读更多...
LeetCode 232.用栈实现队列（详解） (๑•̌.•๑)

LeetCode 232.用栈实现队列（详解） (๑•̌.•๑)

题目描述&#xff1a; 解题思路&#xff1a; 创建两个栈&#xff0c;一个用于入数据&#xff0c;一个用于出数据。分别是pushST和popST; 1.如果是入数据就直接入进pushST 2.如果是出数据&#xff0c;先检查popST中有无数据&#xff0c;如果有数据&#xff0c;就直接出。如果没…
阅读更多...
61. 旋转链表 86. 分隔链表 |面试经典题

61. 旋转链表 86. 分隔链表 |面试经典题

题目&#xff1a;给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 题目链接&#xff1a;61. 旋转链表 截断拼接即可 class Solution {public ListNode rotateRight(ListNode head, int k) {if(headnull||k0){return head;}List…
阅读更多...
代码随想录算法训练营第四天| 24. 两两交换链表中的节点、19.删除链表的倒数第N个节点面试题 02.07. 链表相交、142.环形链表II

代码随想录算法训练营第四天| 24. 两两交换链表中的节点、19.删除链表的倒数第N个节点面试题 02.07. 链表相交、142.环形链表II

文档讲解&#xff1a;虚拟头节点&#xff0c;三指针&#xff0c;快慢指针&#xff0c;链表相交&#xff0c;环形链表&#xff0c; 技巧&#xff1a; 1、对于指针的操作要画图&#xff0c;明确步骤后好做了 2、使用虚拟头节点可以避免对头节点单独讨论&#xff0c;且方便对头节点…
阅读更多...
LeetCode刷题：142. 环形链表 II

LeetCode刷题：142. 环形链表 II

题目&#xff1a; 是否独立解决&#xff1a;否&#xff0c;参考了解题思路解决问题&#xff0c;思考了用快慢指针&#xff0c;栈&#xff0c;统计链表数量定位尾巴节点&#xff08;因为是环形链表所以是死循环&#xff0c;链表数量用while循环统计不出来&#xff09;都没解决 解…
阅读更多...
LeetCode（59）反转链表 II【链表】【中等】

LeetCode（59）反转链表 II【链表】【中等】

目录 1.题目2.答案3.提交结果截图 链接&#xff1a; 反转链表 II 1.题目 给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 示例 1&#xff1a; 输入&am…
阅读更多...
创建链表时的一个小bug

创建链表时的一个小bug

问题 Linklist p new LNode;pL;Linklist p L;有区别吗&#xff1f; 是的&#xff0c;这两种写法是有区别的。 在 Linklist p new LNode; pL; 这段代码中&#xff0c;首先创建了一个新的节点 p&#xff0c;然后将 L 的值赋给了 p。但是&#xff0c;这并不会改变 L 本身。因…
阅读更多...
力扣链表OJ面试题，那些你不懂的全新版本解法

力扣链表OJ面试题，那些你不懂的全新版本解法

孤独的时候看世界更清晰 前言 数据结构的逻辑性是非常强的&#xff0c;所以单单看代码很难搞懂&#xff0c;这里博主对每一道题目都进行了非常细致的图文详解&#xff0c;每一道题目都是非常经典的面试OJ题&#xff0c;每一道题我都附上了对应的力扣链接&#xff0c;本文主要是…
阅读更多...
LeetCode（63）旋转链表【链表】【中等】

LeetCode（63）旋转链表【链表】【中等】

目录 1.题目2.答案3.提交结果截图 链接&#xff1a; 旋转链表 1.题目 给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], k 2 输出&#xff1a;[4,5,1,2,3]示例 2&…
阅读更多...
【力扣100】206.反转链表

【力扣100】206.反转链表

添加链接描述 # Definition for singly-linked list. # class ListNode: # def __init__(self, val0, nextNone): # self.val val # self.next next class Solution:def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:preNone…
阅读更多...
LeetCode（60）K 个一组翻转链表【链表】【困难】

LeetCode（60）K 个一组翻转链表【链表】【困难】

目录 1.题目2.答案3.提交结果截图 链接&#xff1a; K 个一组翻转链表 1.题目 给你链表的头节点 head &#xff0c;每 k 个节点一组进行翻转&#xff0c;请你返回修改后的链表。 k 是一个正整数&#xff0c;它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍&#xf…
阅读更多...
代码随想录算法训练营Day4 | 24.两两交换链表中的节点、19.删除链表的倒数第 N 个节点、面试题. 链表相交、142.环形链表II

代码随想录算法训练营Day4 | 24.两两交换链表中的节点、19.删除链表的倒数第 N 个节点、面试题. 链表相交、142.环形链表II

LeetCode 24 两两交换链表中的节点 本题要注意的条件&#xff1a; 遍历终止条件改变引用指向的时候&#xff0c;需要保存一些节点记录 为了更好的操作链表&#xff0c;我定义了一个虚拟的头节点 dummyHead 指向链表。如下图所示 既然要交换链表中的节点&#xff0c;那么肯定…
阅读更多...
链表基础知识（二、双向链表头插、尾插、头删、尾删、查找、删除、插入）

链表基础知识（二、双向链表头插、尾插、头删、尾删、查找、删除、插入）

目录 一、双向链表的概念 二、 双向链表的优缺点分析​与对比 2.1双向链表特点&#xff1a; 2.2双链表的优劣&#xff1a; 2.3循环链表的优劣 2.4 顺序表和双向链表的优缺点分析​ 三、带头双向循环链表增删改查实现 3.1SList.c 3.2创建一个新节点、头节点 3.3头插 3.…
阅读更多...
C++容器系列之list详解与应用

C++容器系列之list详解与应用

C容器系列之list详解与应用 引言list的元素排列特性优缺点与其他容器的区别应用场景常见函数代码示例 引言 C标准模板库&#xff08;STL&#xff09;提供了丰富的容器类&#xff0c;其中之一就是list。list是一个双向链表实现的容器&#xff0c;与数组和向量等容器有很大的区别…
阅读更多...
使用双向链表实现栈的相关操作【1.3】

使用双向链表实现栈的相关操作【1.3】

创建节点&#xff1a; class Node {private Node next;private Node pre;private int no;public Node getNext() {return next;}public void setNext(Node next) {this.next next;}public Node(int no) {this.no no;}public Node getPre() {return pre;}public void setPre(…
阅读更多...
【力扣100】【好题】148.排序链表

【力扣100】【好题】148.排序链表

添加链接描述 # Definition for singly-linked list. # class ListNode: # def __init__(self, val0, nextNone): # self.val val # self.next next class Solution:def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:# 思路是使…
阅读更多...
数据结构：图文详解 队列 | 循环队列 的各种操作（出队，入队，获取队列元素，判断队列状态）

数据结构：图文详解 队列 | 循环队列 的各种操作（出队，入队，获取队列元素，判断队列状态）

目录 队列的概念 队列的数据结构 队列的实现 入队 出队 获取队头元素 获取队列长度 循环队列的概念 循环队列的数据结构 循环队列的实现 判断队列是否为空 判断队列是否已满 入队 出队 得到队头元素 得到队尾元素 队列的概念 队列&#xff08;Queue&#xff0…
阅读更多...
LeetCode21. Merge Two Sorted Lists

LeetCode21. Merge Two Sorted Lists

文章目录 一、题目二、题解 一、题目 You are given the heads of two sorted linked lists list1 and list2. Merge the two lists into one sorted list. The list should be made by splicing together the nodes of the first two lists. Return the head of the merged…
阅读更多...
【经典LeetCode算法题目专栏分类】【第7期】快慢指针与链表

【经典LeetCode算法题目专栏分类】【第7期】快慢指针与链表

《博主简介》 小伙伴们好&#xff0c;我是阿旭。专注于人工智能AI、python、计算机视觉相关分享研究。 ✌更多学习资源&#xff0c;可关注公-仲-hao:【阿旭算法与机器学习】&#xff0c;共同学习交流~ &#x1f44d;感谢小伙伴们点赞、关注&#xff01; 快慢指针 移动零 class…
阅读更多...
链表常见题型(1)

链表常见题型(1)

1.反转链表 1.1反转链表 如果我们想要反转链表&#xff0c;那应该有head的next指针指向空&#xff0c;其余结点的next指针反过来&#xff0c;指向它的上一个结点&#xff0c;那我们在执行该操作的时候就需要定义变量cur(current)表示我们当前遍历到的结点&#xff0c;变量pre(…
阅读更多...
合并两个有序链表算法(leetcode第21题)

合并两个有序链表算法(leetcode第21题)

题目描述&#xff1a; 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a;输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4] 示例 2&#xff1a;输入&#xff1a;l1 [], l2 [] 输…
阅读更多...
Codeforces Round 916 (Div. 3)(A~E2)

Codeforces Round 916 (Div. 3)(A~E2)

A 统计一下每个字母的出现次数然后输出即可 #include <bits/stdc.h> #define rep(i,a,b) for(register int i (a); i < (b); i) #define fep(i,a,b) for(register int i (a); i > (b); --i) #define ls p<<1 #define rs p<<1|1 #define PII pair&l…
阅读更多...
C++ 两个链表的第一个公共结点

C++ 两个链表的第一个公共结点

输入两个链表&#xff0c;找出它们的第一个公共结点。 当不存在公共节点时&#xff0c;返回空节点。 数据范围 链表长度 [1,2000] 。 保证两个链表不完全相同&#xff0c;即两链表的头结点不相同。 样例 给出两个链表如下所示&#xff1a; A&#xff1a; a1 → a2 ↘ c1 → …
阅读更多...
反转链表算法(leetcode第206题)

反转链表算法(leetcode第206题)

题目描述&#xff1a; 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1] 示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&#xff1a;[2,1] 示例…
阅读更多...
Leetcode—86.分隔链表【中等】

Leetcode—86.分隔链表【中等】

2023每日刷题&#xff08;六十九&#xff09; Leetcode—86.分隔链表 实现代码 /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/ struct ListNode* partition(struct ListNode* head, int x) {struct ListNode…
阅读更多...
双向链表的实现及头尾插入删除

双向链表的实现及头尾插入删除

双链表的增删查改 一.双向链表的初始化二.创建返回链表的头结点三.双向链表销毁四. 双向链表打印五.双向链表尾插六. 双向链表尾删七. 双向链表头插八.双向链表头删九.双向链表的查找十.双向链表在pos的前面进行插入十一. 双向链表删除pos位置的节点 一.双向链表的初始化 Lis…
阅读更多...
labuladong日常刷题-双指针 | LeetCode 83删除排序链表中的重复元素 5最长回文子串

labuladong日常刷题-双指针 | LeetCode 83删除排序链表中的重复元素 5最长回文子串

双指针操作链表与字符串 LeetCode 83 删除排序链表中的重复元素 2023.12.28 题目链接labuladong讲解[链接] ListNode* deleteDuplicates(ListNode* head) {/*暴力求解ListNode* cur new ListNode();ListNode* prenode cur;cur->next head;cur cur->next;while(cu…
阅读更多...
golang leetcode203移除链表元素

golang leetcode203移除链表元素

文章目录 移除链表元素 leetcode203初版方法 迭代 虚拟头节点改进 迭代 虚拟头节点使用迭代 直接使用原链表 不使用头节点递归方法 移除链表元素 leetcode203 初版方法 迭代 虚拟头节点 使用迭代解决 &#xff0c;虚拟头节点 没有使用给出的链表&#xff0c;选择重建了一个链…
阅读更多...
面试算法78：合并排序链表

面试算法78：合并排序链表

题目 输入k个排序的链表&#xff0c;请将它们合并成一个排序的链表。 分析&#xff1a;利用最小堆选取值最小的节点 用k个指针分别指向这k个链表的头节点&#xff0c;每次从这k个节点中选取值最小的节点。然后将指向值最小的节点的指针向后移动一步&#xff0c;再比较k个指…
阅读更多...
链表总结（2）

链表总结（2）

theme: fancy 又是链表专题啦&#xff0c;老样子&#xff0c;标题就是leetcode链接&#xff0c;在这里只放我的代码答案和注释 141环形链表 public class Solution {public boolean hasCycle(ListNode head) {if(head null || head.next null) return false;if(head.nex…
阅读更多...
二叉搜索树与双向链表

二叉搜索树与双向链表

解题思路一&#xff1a; /** public class TreeNode {int val 0;TreeNode left null;TreeNode right null;public TreeNode(int val) {this.val val;} } */ // 一定要用自己的理解真正弄出来才行&#xff0c;否则没有用&#xff01; // 再次提醒&#xff0c;计算机这种工科…
阅读更多...
【LeetCode:114. 二叉树展开为链表 | 二叉树 + 递归】

【LeetCode:114. 二叉树展开为链表 | 二叉树 + 递归】

&#x1f680; 算法题 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;…
阅读更多...
day19【LeetCode力扣】160.相交链表

day19【LeetCode力扣】160.相交链表

day19【LeetCode力扣】160.相交链表 1.题目描述 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交**&#xff1a;** 题目数据 保证 整个链…
阅读更多...
LeetCode 2：两数相加

LeetCode 2：两数相加

一、题目描述 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外&#xff0c;这两个…
阅读更多...
数据结构 模拟实现LinkedList双向不循环链表

数据结构 模拟实现LinkedList双向不循环链表

目录 一、双向不循环链表的概念 二、链表的接口 三、链表的方法实现 &#xff08;1&#xff09;display方法 &#xff08;2&#xff09;size方法 &#xff08;3&#xff09;contains方法 &#xff08;4&#xff09;addFirst方法 &#xff08;5&#xff09;addLast方法 …
阅读更多...
【leetcode100-032】【链表/回溯/哈希】随机链表的复制

【leetcode100-032】【链表/回溯/哈希】随机链表的复制

【题干】 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节点的值。…
阅读更多...
约瑟夫环问题解决

约瑟夫环问题解决

链表 struct List {int data;struct List* next; }创建链表 单链表 实现 struct List* listCreate() {int data;struct List* head NULL;struct List* pre NULL;struct List* current NULL;while(scanf("%d",&data) && data ! -1){current (stru…
阅读更多...
算法每日一题： 删除排序列表中的重复元素 | 链表的删除

算法每日一题： 删除排序列表中的重复元素 | 链表的删除

大家好&#xff0c;我是星恒 今天给大家带来的是一道简单的链表删除题&#xff0c;题目很简单&#xff0c;不过可以帮助我们很好的复习链表的删除&#xff0c;尤其适合基础薄弱的友友们学习 ~ 题目&#xff1a;leetcode 83 给定一个已排序的链表的头 head &#xff0c; 删除所有…
阅读更多...
【力扣·每日一题】83. 删除排序链表中的重复元素（链表 思维 一次遍历 C++ Go）

【力扣·每日一题】83. 删除排序链表中的重复元素（链表 思维 一次遍历 C++ Go）

题目链接 题意 给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的链表 。 提示&#xff1a; 链表中节点数目在范围 [0, 300] 内 -100 < Node.val < 100 题目数据保证链表已经按升序 排列 思路 因为给出…
阅读更多...
LeetCode每日一题 | 2807. 在链表中插入最大公约数

LeetCode每日一题 | 2807. 在链表中插入最大公约数

文章目录 LeetCode-2807. 在链表中插入最大公约数题目描述问题分析程序代码&#xff08;Golang 版本&#xff09; LeetCode-2807. 在链表中插入最大公约数 题目描述 原题链接 给你一个链表的头 head &#xff0c;每个结点包含一个整数值。 在相邻结点之间&#xff0c;请你插入…
阅读更多...
第 4 章 链表

第 4 章 链表

文章目录 4.1 链表(Linked List)介绍4.2 单链表的应用实例4.3 单链表面试题(新浪、百度、腾讯)4.4 双向链表应用实例4.4.1 双向链表的操作分析和实现4.4.2 课堂作业和思路提示 4.5 单向环形链表应用场景4.6 单向环形链表介绍4.7 Josephu 问题4.8 Josephu 问题的代码实现 4.1 链…
阅读更多...
C语言中线性表的合并有序表的合并以及案例分析和实现

C语言中线性表的合并有序表的合并以及案例分析和实现

**线性列表合并&#xff1a;** 案例分析&#xff1a; 要合并两个线性列表&#xff0c;我们考虑以下情况&#xff1a; 1. 两个列表都是空的&#xff1a;在这种情况下&#xff0c;合并的列表也将是空的。 2. 一个列表是空的&#xff1a;如果其中一个列表是空的&#xff0c;则合…
阅读更多...
[数据结构与算法]数据结构基础、排序算法详解、算法思想详解、领域算法详解------

[数据结构与算法]数据结构基础、排序算法详解、算法思想详解、领域算法详解------

# 数据结构基础 学习思路 避免孤立的学习知识点&#xff0c;要关联学习。比如实际应用当中&#xff0c;我们经常使用的是查找和排序操作&#xff0c;这在我们的各种管理系统、数据库系统、操作系统等当中&#xff0c;十分常用&#xff0c;我们通过这个线索将知识点串联起来&am…
阅读更多...
【数据结构和算法】删除链表的中间节点

【数据结构和算法】删除链表的中间节点

其他系列文章导航 Java基础合集数据结构与算法合集 设计模式合集 多线程合集 分布式合集 ES合集 文章目录 其他系列文章导航 文章目录 前言 一、题目描述 二、题解 三、代码 四、复杂度分析 前言 这是力扣的1657题&#xff0c;难度为中等&#xff0c;解题方案有很多种&…
阅读更多...
K 个一组翻转链表（链表反转，固定长度反转）（困难）

K 个一组翻转链表（链表反转，固定长度反转）（困难）

优质博文&#xff1a;IT-BLOG-CN 一、题目 给你链表的头节点head&#xff0c;每k个节点一组进行翻转&#xff0c;请你返回修改后的链表。 k是一个正整数&#xff0c;它的值小于或等于链表的长度。如果节点总数不是k的整数倍&#xff0c;那么请将最后剩余的节点保持原有顺序。…
阅读更多...
数据结构：队列的链表结构（含完整代码，可复制）

数据结构：队列的链表结构（含完整代码，可复制）

1.输出队列 void outlin(LinkQueue qq) {pqq.front->next;while(p!NULL){printf(" data%4d\n",p->data);pp->next;}printf("\n outend \n\n"); } 2.入队一个元素 void insert(LinkQueue *qe,int x) {s(NodeType *)malloc(sizeof(NodeType));s-…
阅读更多...
C++ | 四、指针、链表

C++ | 四、指针、链表

指针 指针用来储存地址定义方式&#xff0c;int *ptr;&#xff0c;使用*来表示所定义的变量是指针取地址符&#xff0c;ptr &a;&#xff0c;通过&来取得一个普通变量的地址&#xff0c;并储存到指针中取值&#xff08;解引用&#xff09;&#xff0c;想要取得一个指针…
阅读更多...
leetcode 24两两交换链表中的节点

leetcode 24两两交换链表中的节点

题目 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 思想 对于操作链表节点的时候&#xff0c;首先需要就是创建一个虚拟的…
阅读更多...
day20【LeetCode力扣】142.环形链表Ⅱ

day20【LeetCode力扣】142.环形链表Ⅱ

day20【LeetCode力扣】142.环形链表Ⅱ 1.题目描述 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了…
阅读更多...
数据结构:2_顺序表和链表

数据结构:2_顺序表和链表

顺序表和链表 一.线性表 线性表&#xff08;linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构&#xff0c;常见的线性表&#xff1a;顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构&#xff0c;也就说…
阅读更多...
初阶数据结构：链表

初阶数据结构：链表

目录 1. 引子&#xff1a;什么是链表2. 简单数据结构&#xff1a;链表2.1 链表简介与功能分析2.2 单链表的实现2.2.1 单链表&#xff1a;存储数据的结构体2.2.2 单链表&#xff1a;结点创建与链表数据清理2.2.2 单链表插入数据与删除2.2.3 单链表查询与修改 1. 引子&#xff1a…
阅读更多...
Golang leetcode142 环形链表 暴力map 快慢指针法

Golang leetcode142 环形链表 暴力map 快慢指针法

文章目录 环形链表 leetcode142暴力遍历 map哈希记录快慢指针法 环形链表 leetcode142 该题目要求找到入环的第一个节点 我们可以通过map进行记录&#xff0c;没到新的节点查询是否经过原有节点 入环节点&#xff0c;上两个节点的next相同 若有入环节点&#xff0c;则一定能检…
阅读更多...
Go语言数据结构（一）双向链表

Go语言数据结构（一）双向链表

list容器 Go语言中list容器定义在"container/list"包中&#xff0c;实现了一个双向链表。本文第一部分总结源码包中的方法&#xff0c;第二部分展示使用list包的常见示例用法以及刷题时的用法。 食用指南&#xff1a;先看第二部分的常用示例用法然后再用到时在第一部…
阅读更多...
数据结构（链表）

数据结构（链表）

文章目录 一、单链表1、单链表定义2、初始化单链表2.1、不带头结点的单链表2.2、带头结点的单链表 3、单链表基本操作3.1、按位序插入&#xff08;带头结点&#xff09;3.2、按位序插入&#xff08;不带头结点&#xff09;3.3、指定结点的后插操作3.4、指定结点的前插操作3.5、…
阅读更多...
链 表

链 表

3_1 删除链表中的节点 Answer-将被删节点下一个val复制到待删除节点&#xff0c;然后将待删节点直接连接到下下一个节点即可。 学到&#xff1a; /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) …
阅读更多...
leetcode.在链表中插入最大公约数

leetcode.在链表中插入最大公约数

文章目录 题目解题方法复杂度Code Problem: 2807. 在链表中插入最大公约数 题目 给你一个链表的头 head &#xff0c;每个结点包含一个整数值。 在相邻结点之间&#xff0c;请你插入一个新的结点&#xff0c;结点值为这两个相邻结点值的 最大公约数 。 请你返回插入之后的链表。…
阅读更多...
数据结构-线性表-链接存储

数据结构-线性表-链接存储

关于线性表计顺序存储可看上篇文章&#xff1a;数据结构-线性表-顺序存储-CSDN博客 线性表的链接存储 链接方式存储的线性表简称为链表LinkList&#xff0c;链表的具体存储表示为&#xff1a;用一组任意的存储单元来存放&#xff1b;链表中结点的逻辑次序和物理次序不一定相同…
阅读更多...
数据结构 模拟实现LinkedList单向不循环链表

数据结构 模拟实现LinkedList单向不循环链表

目录 一、链表的简单介绍 二、链表的接口 三、链表的方法实现 &#xff08;1&#xff09;display方法 &#xff08;2&#xff09;size得到单链表的长度方法 &#xff08;3&#xff09;addFirst头插方法 &#xff08;4&#xff09;addLast尾插方法 &#xff08;5&#xf…
阅读更多...
2024.1.6力扣每日一题——在链表中插入最大公约数

2024.1.6力扣每日一题——在链表中插入最大公约数

2024.1.6 题目来源我的题解方法一 模拟数学 题目来源 力扣每日一题&#xff1b;题序&#xff1a;2807 我的题解 方法一 模拟数学 正常模拟插入&#xff0c;通过辗转相除法计算出两个节点值之间的最大公约数&#xff0c;然后将其作为新节点插入到两个节点之间 时间复杂度&…
阅读更多...
力扣92. 反转链表 II

力扣92. 反转链表 II

链表 思路&#xff1a; 使用一个 dummy 指针迭代到 left&#xff1b;然后反转 (right - left) 个 node&#xff1b;之后将剩余的 node 继续串起来即可&#xff1b; class Solution { public:ListNode *reverseBetween(ListNode *head, int left, int right) {// 设置 dummyNo…
阅读更多...
力扣hot100 二叉树展开为链表 递归 特殊遍历

力扣hot100 二叉树展开为链表 递归 特殊遍历

&#x1f468;‍&#x1f3eb; 题目地址 &#x1f469;‍&#x1f3eb; 参考题解 &#x1f60b; 将左子树插入到右子树上 /*** Definition for a binary tree node.* public class TreeNode {* int val;* TreeNode left;* TreeNode right;* TreeNode() {}* …
阅读更多...
删除链表的倒数第 N 个结点【链表】

删除链表的倒数第 N 个结点【链表】

Problem: 19. 删除链表的倒数第 N 个结点 文章目录 思路 & 解题方法复杂度Code 思路 & 解题方法 模拟。 复杂度 时间复杂度: 添加时间复杂度, 示例&#xff1a; O ( n ) O(n) O(n) 空间复杂度: 添加空间复杂度, 示例&#xff1a; O ( n ) O(n) O(n) Code # Definit…
阅读更多...
[java数据结构] ArrayList和LinkedList介绍与使用

[java数据结构] ArrayList和LinkedList介绍与使用

目录 (一) 线性表 (二) ArrayList 1. ArrayList的介绍 2. ArrayList的常见方法和使用 3. ArrayList的遍历 4. ArrayList的模拟实现 5. ArrayList的优缺点 (三) LinkedList 1. LinkedList的介绍 2. LinkedList的常见方法和使用 3. LinkedList的遍历 4. LinkedList的…
阅读更多...
Leetcode-114.二叉树展开为链表（Python）

Leetcode-114.二叉树展开为链表（Python）

题目链接 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val0, leftNone, rightNone): # self.val val # self.left left # self.right right class Solution:def flatten(self, root: Optional[TreeNode]) -…
阅读更多...
Golang leetcode24两两交换链表中的节点 递归 迭代

Golang leetcode24两两交换链表中的节点 递归 迭代

两两交换链表中的节点 leetcode24 递归 两个节点一递归 第一次即成功&#xff0c;泪目&#xff01;&#xff01; // 每两个进行一次交换 func swapPairs(head *ListNode) *ListNode {//每两个的第一个节点var pre *ListNode//递归结束条件&#xff0c;即当剩下的节点不满足两…
阅读更多...
Golang leetcode160相交链表 map 双指针迭代

Golang leetcode160相交链表 map 双指针迭代

文章目录 相交链表 leetcode160暴力求解 map双指针1双指针2 巧妙 该部分源于leetcode官方题解 相交链表 leetcode160 由于链表深度不一致&#xff0c;所以不太好使用递归 检测方法 &#xff1a; 相交链表&#xff0c;即两个链表上一个节点的Next指向 同一个地址先检测同样Val…
阅读更多...
leecode-代码随想录-学习笔记1

leecode-代码随想录-学习笔记1

编程语言基础课&#xff0c;重新学习 kamacoder.com 基础语法&#xff1b;ACM输入输出通用模板&#xff1b;之前Java狂神说的学习笔记&#xff08;但是还是按照编程习惯用了C&#xff0c;感觉更底层好写代码&#xff09;。 正式开始&#xff1a; 下面按照题目-我的解答思路和…
阅读更多...
LeetCode 2807. 在链表中插入最大公约数【链表,迭代,递归】1279

LeetCode 2807. 在链表中插入最大公约数【链表,迭代,递归】1279

本文属于「征服LeetCode」系列文章之一&#xff0c;这一系列正式开始于2021/08/12。由于LeetCode上部分题目有锁&#xff0c;本系列将至少持续到刷完所有无锁题之日为止&#xff1b;由于LeetCode还在不断地创建新题&#xff0c;本系列的终止日期可能是永远。在这一系列刷题文章…
阅读更多...
【力扣每日一题】力扣2478从链表中移除节点

【力扣每日一题】力扣2478从链表中移除节点

题目来源 2478.从链表中移除节点 题目描述 给你一个链表的头节点 head 。 移除每个右侧有一个更大数值的节点。 返回修改后链表的头节点 head 。 示例 示例1&#xff1a; 输入&#xff1a;head [5,2,13,3,8] 输出&#xff1a;[13,8] 解释&#xff1a;需要移除的节点是 5 …
阅读更多...
【数据结构和算法】小行星碰撞

【数据结构和算法】小行星碰撞

其他系列文章导航 Java基础合集数据结构与算法合集 设计模式合集 多线程合集 分布式合集 ES合集 文章目录 其他系列文章导航 文章目录 前言 一、题目描述 二、题解 2.1 什么情况会用到栈 2.2 方法一&#xff1a;模拟 栈 三、代码 3.1 方法一&#xff1a;模拟 栈 四…
阅读更多...
「优选算法刷题」:有效三角形的个数

「优选算法刷题」:有效三角形的个数

一、题目 给定一个包含非负整数的数组 nums &#xff0c;返回其中可以组成三角形三条边的三元组个数。 示例 1: 输入: nums [2,2,3,4] 输出: 3 解释:有效的组合是: 2,3,4 (使用第一个 2) 2,3,4 (使用第二个 2) 2,2,3示例 2: 输入: nums [4,2,3,4] 输出: 4二、思路解析 这道…
阅读更多...
链表|数据结构|C语言深入学习

链表|数据结构|C语言深入学习

什么是链表 离散&#xff0c;就是“分离的、散开的” 链表是什么样子的&#xff1a; 有限个节点离散分配 彼此间通过指针相连 除了首尾节点&#xff0c;每个节点都只有一个前驱节点和一个后继节点 首节点没有前驱结点&#xff0c;尾节点没有后继节点 基本概念术语&#xf…
阅读更多...
力扣hot100 环形链表 快慢指针 计步器

力扣hot100 环形链表 快慢指针 计步器

Problem: 141. 环形链表 文章目录 思路&#x1f496; 快慢指针法&#x1f496; 计步器法 思路 &#x1f468;‍&#x1f3eb; 参考题解 &#x1f496; 快慢指针法 时间复杂度: O ( n ) O(n) O(n) 空间复杂度: O ( 1 ) O(1) O(1) /*** Definition for singly-linked list…
阅读更多...
【数据结构】二叉树算法讲解（定义+算法原理+源码）

【数据结构】二叉树算法讲解（定义+算法原理+源码）

博主介绍&#xff1a;✌全网粉丝喜爱、前后端领域优质创作者、本质互联网精神、坚持优质作品共享、掘金/腾讯云/阿里云等平台优质作者、擅长前后端项目开发和毕业项目实战✌有需要可以联系作者我哦&#xff01; &#x1f345;附上相关C语言版源码讲解&#x1f345; &#x1f44…
阅读更多...
143 找出两个链表的第一个公共节点

143 找出两个链表的第一个公共节点

问题描述&#xff1a;输入两个链表&#xff1a;找出他们的第一个公共节点&#xff0c;即两条链表均指向某个节点&#xff0c;两条不同的链表组合成同一条链表。 集合Set求解&#xff1a;首先将第一条链表中所有的list节点放入集合中&#xff0c;再来遍历。 public TreeNode f…
阅读更多...
力扣24-两两交换链表中的节点

力扣24-两两交换链表中的节点

两两交换链表中的节点 题目链接 解题思路&#xff1a; 直接交换相邻节点之间的值即可 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(int x) : val(x), next(nu…
阅读更多...
如何判断两个链表相等

如何判断两个链表相等

要判断两个链表是否相等&#xff0c;需要比较它们的节点值以及节点的顺序。下面是一种常见的方法来判断两个链表是否相等&#xff1a; 首先&#xff0c;判断两个链表的长度是否相等。如果长度不相等&#xff0c;则链表肯定不相等。然后&#xff0c;逐个比较两个链表对应位置的…
阅读更多...
数据结构——链表的实现（Java版）

数据结构——链表的实现（Java版）

目录 一、链表 二、代码实现 1.创建结点 2.构造函数 3.链表的相关属性 4.添加虚拟节点 5.判断链表是否为空 6.添加方法 &#xff08;1&#xff09;在头部添加 &#xff08;2&#xff09;在尾部添加 &#xff08;3&#xff09;在索引位置添加 &#xff08;4&#xff…
阅读更多...
链表-两两交换链表中的节点

链表-两两交换链表中的节点

给定一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后的链表。 你不能只是单纯的改变节点内部的值&#xff0c;而是需要实际的进行节点交换。 // 递归版本 class Solution {public ListNode swapPairs(ListNode head) {// base case 退出提交if(head nu…
阅读更多...
单向不带头链表的使用

单向不带头链表的使用

单向不带头链表的使用 链表的创建&#xff1a; typedef struct LNode {SLDataType data;struct LNode* next; }LNode,*LinkList; 按位查找 LNode* GetElem(LinkList L, int i) {int j 1;LNode* p L->next;if (i < 0)return NULL;if (i 0)return L;while (p &&…
阅读更多...
Java反转链表，简单算法

Java反转链表，简单算法

文章目录 一、题目二、答案三、我的解决思路总结 Java 单向链表&#xff0c;指的是一种数据结构&#xff0c;用于存储一系列的元素。每个元素包含两部分&#xff1a;一个存储数据的值和一个指向下一个元素的引用。 单向链表由多个节点组成&#xff0c;每个节点都包含一个数据元…
阅读更多...
【数据结构与算法】(5)基础数据结构之队列 链表实现、环形数组实现详细代码示例讲解

【数据结构与算法】(5)基础数据结构之队列 链表实现、环形数组实现详细代码示例讲解

目录 2.4 队列1) 概述2) 链表实现3) 环形数组实现 2.4 队列 1) 概述 计算机科学中&#xff0c;queue 是以顺序的方式维护的一组数据集合&#xff0c;在一端添加数据&#xff0c;从另一端移除数据。习惯来说&#xff0c;添加的一端称为尾&#xff0c;移除的一端称为头&#xf…
阅读更多...
【计算机系统组成原理】操作系统处理器深入介绍

【计算机系统组成原理】操作系统处理器深入介绍

博主介绍&#xff1a;✌全网粉丝喜爱、前后端领域优质创作者、本质互联网精神、坚持优质作品共享、掘金/腾讯云/阿里云等平台优质作者、擅长前后端项目开发和毕业项目实战✌有需要可以联系作者我哦&#xff01; &#x1f345;附上相关C语言版源码讲解&#x1f345; &#x1f44…
阅读更多...
中间件存储设计 - 数组与链表

中间件存储设计 - 数组与链表

文章目录 数组ArrayListLinkedListHashMap小结 中间件主要包括如下三方面的基础&#xff1a;数据结构、JUC 和 Netty&#xff0c;接下来&#xff0c;我们先讲数据结构。 数据结构主要解决的是数据的存储方式问题&#xff0c;是程序设计的基座。 按照重要性和复杂程度&#xf…
阅读更多...
freertos 源码分析二 list链表源码

freertos 源码分析二 list链表源码

list.c 一、链表初始化 void vListInitialise( List_t * const pxList ) { pxList->pxIndex ( ListItem_t * ) &…
阅读更多...
【数据结构】链表OJ面试题(题库+解析)

【数据结构】链表OJ面试题(题库+解析)

前言 还不清楚链表的码喵们可以看看前篇关于链表的详解 http://t.csdnimg.cn/X6t6P 1.链表面试题 既然已经懂得了链表该如何实现&#xff0c;那么现在就趁热打铁开始练习&#xff01;这里给码喵们整理了相对不错的一些OJ题来练习 1. 删除链表中等于给定值 val 的所有结点。 力…
阅读更多...
链表OJ---排序链表

链表OJ---排序链表

https://leetcode.cn/problems/7WHec2/description/ //合并 struct ListNode* merge_link(struct ListNode* head1, struct ListNode* head2) {struct ListNode* temhead malloc(sizeof(struct ListNode));temhead->val 0;struct ListNode *tmp temhead, *cur1 head1, *…
阅读更多...
【链表】-Lc21-合并两个有序链表（同时遍历）

【链表】-Lc21-合并两个有序链表（同时遍历）

写在前面 最近想复习一下数据结构与算法相关的内容&#xff0c;找一些题来做一做。如有更好思路&#xff0c;欢迎指正。 目录 写在前面一、场景描述二、具体步骤1.环境说明2.代码 写在后面 一、场景描述 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两…
阅读更多...
带头 + 双向 + 循环链表增删查改实现

带头 + 双向 + 循环链表增删查改实现

目录 源码&#xff1a; List.c文件&#xff1a; List.h文件&#xff1a; 简单的测试&#xff1a; 很简单&#xff0c;没什么好说的&#xff0c;直接上源码。 源码&#xff1a; List.c文件&#xff1a; #include"DLList.h"ListNode* creadNode(LTDataType x) {L…
阅读更多...
LeetCode 热题 100 | 链表（上）

LeetCode 热题 100 | 链表（上）

目录 1 基础知识 1.1 空指针 1.2 结构体 1.3 指针访问 1.4 三目运算符 2 160. 相交链表 3 206. 反转链表 4 234. 回文链表 菜鸟做题第三周&#xff0c;语言是 C 1 基础知识 1.1 空指针 使用 nullptr 来判断是否为空指针&#xff1a; if (headA nullptr) …
阅读更多...
有关链表的题目

有关链表的题目

目录 1.环形链表的约瑟夫问题 2.链表的中间节点 3.合并两个有序链表 4.反转链表 5.移除链表元素 1.环形链表的约瑟夫问题 环形链表的约瑟夫问题_牛客题霸_牛客网 (nowcoder.com) 思路&#xff1a;题目给出结构是环形链表&#xff0c;且题目已经定义好了环形链表的结构。 1…
阅读更多...
链表--102. 二叉树的层序遍历/medium 理解度C

链表--102. 二叉树的层序遍历/medium 理解度C

102. 二叉树的层序遍历 1、题目2、题目分析3、复杂度最优解代码示例4、适用场景 1、题目 给你二叉树的根节点 root &#xff0c;返回其节点值的 层序遍历 。 &#xff08;即逐层地&#xff0c;从左到右访问所有节点&#xff09;。 示例 1&#xff1a; 输入&#xff1a;root […
阅读更多...
c实现链表

c实现链表

目录 c实现链表 链表的结构定义&#xff1a; 链表的结构操作&#xff1a; 1、初始化链表 2、销毁链表 3、插入结点 4、输出链表数据 5、查找链表数据 扩展 代码实现 c实现链表 链表的结构定义&#xff1a; /*** 链表结构定义 ***/ typedef struct Node {int data; //…
阅读更多...
算法题 — 链表反转

算法题 — 链表反转

将单链表的链接顺序反转过来 例&#xff1a;输入&#xff1a;1->2->3->4->5输出&#xff1a;5->4->3->2->1 使用两种方式解题 1 迭代 static class ListNode {int val;ListNode next;public ListNode(int val, ListNode next) {this.val val;this.n…
阅读更多...
顺序表和链表【数据结构】【基于C语言实现】【一站式速通】

顺序表和链表【数据结构】【基于C语言实现】【一站式速通】

目录 顺序表 顺序表的优点 顺序表的实现 1.结构体的定义 2.初始化数组 3.插入数据 4.其余接口函数的实现 5.释放内存 顺序表的缺陷 单向链表 单向链表的优点 单向链表的实现 1.链表的定义 2.链表的初始化 3.其余接口函数的实现 5.释放内存 单向链表的缺陷 双…
阅读更多...
Leetcode HOT 100 - 2. 两数相加（Java + 链表）

Leetcode HOT 100 - 2. 两数相加（Java + 链表）

文章目录 题目思路Java 链表第 1 步&#xff1a;第 2 步&#xff1a; 复杂度Code 题目 Problem: 2. 两数相加给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。请你将两个数相加&am…
阅读更多...
707.设计链表（力扣LeetCode）

707.设计链表（力扣LeetCode）

707. 设计链表 你可以选择使用单链表或者双链表&#xff0c;设计并实现自己的链表。 单链表中的节点应该具备两个属性&#xff1a;val 和 next 。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。 如果是双向链表&#xff0c;则还需要属性 prev 以指示链表…
阅读更多...
203.移除链表元素（力扣LeetCode）

203.移除链表元素（力扣LeetCode）

文章目录 203.移除链表元素题目描述原链表删除元素虚拟头节点 203.移除链表元素 题目描述 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head …
阅读更多...
链表--108. 将有序数组转换为二叉搜索树/medium 理解度C

链表--108. 将有序数组转换为二叉搜索树/medium 理解度C

108. 将有序数组转换为二叉搜索树 1、题目2、题目分析3、复杂度最优解代码示例4、适用场景 1、题目 给你一个整数数组 nums &#xff0c;其中元素已经按 升序 排列&#xff0c;请你将其转换为一棵 高度平衡 二叉搜索树。 高度平衡 二叉树是一棵满足「每个节点的左右两个子树的…
阅读更多...
C++数据结构与算法——链表

C++数据结构与算法——链表

C第二阶段——数据结构和算法&#xff0c;之前学过一点点数据结构&#xff0c;当时是基于Python来学习的&#xff0c;现在基于C查漏补缺&#xff0c;尤其是树的部分。这一部分计划一个月&#xff0c;主要利用代码随想录来学习&#xff0c;刷题使用力扣网站&#xff0c;不定时更…
阅读更多...
链表中的数字相加

链表中的数字相加

不能简单认为将两条链表转变为整数后进行运算&#xff0c;然后将结果转变为链表。因为如果链表很长&#xff0c;这可能会导致整数溢出。 在正常的两个整数加法运算时&#xff0c;我们是从低位开始&#xff0c;然后依次相加更高位的数字&#xff0c;所以不难想到我们需要将链表反…
阅读更多...
力扣、牛客例题-----链表

力扣、牛客例题-----链表

文章目录 例题1 203.移除链表元素例题2 206.反转链表例题3 876.链表的中间节点例题4 链表中倒数第k个结点例题5 21. 合并两个有序链表例题6 OR36 链表的回文结构例题7 CM11 链表分割例题8 160.相交链表例题9 141.环形链表例题10 142.环形链表|| 例题1 203.移除链表元素 【题目…
阅读更多...
【数据结构】单向链表实现 超详细

【数据结构】单向链表实现 超详细

目录 一. 单链表的实现 1.准备工作及其注意事项 1.1 先创建三个文件 1.2 注意事项&#xff1a;帮助高效记忆和理解 2.链表的基本功能接口 2.0 创建一个 链表 2.1 链表的打印 3.链表的创建新节点接口 4.链表的节点插入功能接口 4.1 尾插接口 4.2 头插接口 4.3 指定位…
阅读更多...
OR36 链表的回文结构

OR36 链表的回文结构

目录 一、思路 二、代码 一、思路 找到中间节点 后半部分逆置链表 定义两个指针&#xff0c;一个从头开始出发 一个从中间位置开始出发 但是注意&#xff1a;链表个数可能是奇数或者偶数&#xff0c;需要注意中间节点的计算 二、代码 struct ListNode* reverseList(str…
阅读更多...
Leetcode—382. 链表随机节点【中等】（水塘抽样法）

Leetcode—382. 链表随机节点【中等】（水塘抽样法）

2024每日刷题&#xff08;一零九&#xff09; Leetcode—382. 链表随机节点 算法思想 我们可以在初始化时&#xff0c;用一个数组记录链表中的所有元素&#xff0c;这样随机选择链表的一个节点&#xff0c;就变成在数组中随机选择一个元素 实现代码 /*** Definition for si…
阅读更多...
详解顺序结构双指针处理算法

详解顺序结构双指针处理算法

&#x1f380;个人主页&#xff1a; https://zhangxiaoshu.blog.csdn.net &#x1f4e2;欢迎大家&#xff1a;关注&#x1f50d;点赞&#x1f44d;评论&#x1f4dd;收藏⭐️&#xff0c;如有错误敬请指正! &#x1f495;未来很长&#xff0c;值得我们全力奔赴更美好的生活&…
阅读更多...
数据结构（C语言版）代码实现（五）——双向循环链表的部分实现

数据结构（C语言版）代码实现（五）——双向循环链表的部分实现

目录 参考材料与格式 线性表的有关知识 头文件 库、宏定义、数据类型声明 线性表的双向链表存储结构 构造空链表 销毁链表 链表长度 按位查找 插入元素 删除元素 打印链表 完整头文件DuLinkList.h 测试函数&#xff08;主函数&#xff09; 测试结果 收获 参考材…
阅读更多...
K个一组翻转链表---链表OJ

K个一组翻转链表---链表OJ

https://leetcode.cn/problems/reverse-nodes-in-k-group/?envType=study-plan-v2&envId=top-100-liked K个一组进行翻转，大体上是和前面两两翻转是类似的，区别就在于，这里需要自己判断是否需要翻转，如何翻转，怎么记录。这里我们用递归来实现。 是否需要翻转…
阅读更多...
数据结构（二）------单链表

数据结构（二）------单链表

制作不易&#xff0c;三连支持一下呗&#xff01;&#xff01;&#xff01; 文章目录 前言一.什么是链表二.链表的分类三.单链表的实现总结 前言 上一节&#xff0c;我们介绍了顺序表的实现与一些经典算法。 但是顺序表这个数据结构依然有不少缺陷&#xff1a; 1.顺序表指定…
阅读更多...
Leetcode92:反转链表II（区间反转链表）

Leetcode92:反转链表II（区间反转链表）

一、题目 给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 示例&#xff1a; 输入&#xff1a;head [1,2,3,4,5], left 2, right 4 输出&#xff1a…
阅读更多...
基于链表实现贪吃蛇游戏

基于链表实现贪吃蛇游戏

本文中&#xff0c;我们将使用链表和一些Win32 API的知识来实现贪吃蛇小游戏 一、功能 &#xff08;1&#xff09;游戏载入界面 &#xff08;2&#xff09;地图的绘制 &#xff08;3&#xff09;蛇身的移动和变长 &#xff08;4&#xff09;食物的生成 &#xff08;5&…
阅读更多...
java数据结构与算法刷题-----LeetCode328. 奇偶链表

java数据结构与算法刷题-----LeetCode328. 奇偶链表

java数据结构与算法刷题目录&#xff08;剑指Offer、LeetCode、ACM&#xff09;-----主目录-----持续更新(进不去说明我没写完)&#xff1a;https://blog.csdn.net/grd_java/article/details/123063846 解题思路 将链表按奇偶顺序&#xff0c;分成两个链表。最后将偶数链表放在…
阅读更多...
面试题 02.07. 链表相交（力扣LeetCode）

面试题 02.07. 链表相交（力扣LeetCode）

文章目录 面试题 02.07. 链表相交题目描述解题思路c代码优化后c代码 面试题 02.07. 链表相交 题目描述 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 图示两个链表在节点 c1 …
阅读更多...
LeetCode707.设计链表

LeetCode707.设计链表

707. 设计链表 你可以选择使用单链表或者双链表&#xff0c;设计并实现自己的链表。 单链表中的节点应该具备两个属性&#xff1a;val 和 next 。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。 如果是双向链表&#xff0c;则还需要属性 prev 以指示链表…
阅读更多...
Leetcode 203 移除链表元素

Leetcode 203 移除链表元素

Leetcode 203 移除链表元素 准备工作1&#xff09;ListNode基本结构2&#xff09;初始化ListNode集合 解法一&#xff1a;遍历判定解法二&#xff1a;递归判定 Leetcode 203 移除链表元素 准备工作 1&#xff09;ListNode基本结构 public class ListNode {public int val;pu…
阅读更多...
图灵之旅--ArrayList顺序表LinkedList链表栈Stack队列Queue

图灵之旅--ArrayList顺序表LinkedList链表栈Stack队列Queue

目录 线性表顺序表ArrayList简介ArrayList使用ArrayList的构造ArrayList常见操作ArrayList的遍历ArrayList的扩容机制利用ArrayList洗牌ArrayList的优缺点 链表链表的实现双向链表的实现 LinkedListLinkedList引入LinkedList的使用LinkedList的构造LinkedList的常用方法介绍Lin…
阅读更多...
「优选算法刷题」：只出现一次的数字Ⅲ

「优选算法刷题」：只出现一次的数字Ⅲ

一、题目 给你一个整数数组 nums&#xff0c;其中恰好有两个元素只出现一次&#xff0c;其余所有元素均出现两次。 找出只出现一次的那两个元素。你可以按 任意顺序 返回答案。 你必须设计并实现线性时间复杂度的算法且仅使用常量额外空间来解决此问题。 示例 1&#xff1a; …
阅读更多...
批量创建链表节点（推荐智能指针）

批量创建链表节点（推荐智能指针）

一、手动创建链表节点 ListNode* l1 new ListNode(2); l1->next new ListNode(4); l1->next->next new ListNode(3);二、循环创建链表节点 采用 std::vector 来存储链表的数值&#xff0c;而后&#xff0c;循环遍历这些数值&#xff0c;并逐个创建节点&#xff0…
阅读更多...
142. 环形链表 II（力扣LeetCode）

142. 环形链表 II（力扣LeetCode）

文章目录 142. 环形链表 II题目描述解题思路判断链表是否有环如果有环&#xff0c;如何找到这个环的入口 c代码 142. 环形链表 II 题目描述 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个…
阅读更多...
【详解】贪吃蛇游戏----下篇（完整源码）

【详解】贪吃蛇游戏----下篇（完整源码）

目录 引入&#xff1a; 本片文章目的&#xff1a; 整个游戏的实现流程图如下&#xff1a; 游戏实现 GameRun PrintHelpInfo Pause NextIsFood printSnake EatFood NoFood KillByWall KillBySelf GameRun GameEnd 总代码&#xff1a; &#xff08;1&#xff09…
阅读更多...
【数据结构】链表(单链表实现+测试+原码)

【数据结构】链表(单链表实现+测试+原码)

1.链表 1.1 链表的概念及结构 概念&#xff1a;链表是一种物理存储结构上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表 中的指针链接次序实现的 。 现实中&#xff1a;链表就像是一列动车&#xff0c;一节连着一节 数据结构中的链表 注意: 1.从上图可看出…
阅读更多...
【刷题】牛客网 NC132 环形链表的约瑟夫问题

【刷题】牛客网 NC132 环形链表的约瑟夫问题

NC132 环形链表的约瑟夫问题 题目描述思路一&#xff08;链表直通版&#xff09;思路二&#xff08;数组巧解版&#xff09;思路三&#xff08;变态秒杀版&#xff09;Thanks♪(&#xff65;ω&#xff65;)&#xff89;谢谢阅读下一篇文章见&#xff01;&#xff01;&#xff…
阅读更多...
我的数据结构c（给自己用的）

我的数据结构c（给自己用的）

目录 顺序表&#xff1a; 链表&#xff1a; 栈&#xff1a; 队列&#xff1a; 我想在之后的大学数据结构课上需要自己写来做题&#xff0c;但每次都自己写&#xff0c;那太麻烦了&#xff0c;所以我就将这个博客来把所有的C语言的数据结构弄上去&#xff0c; 问我为什么不…
阅读更多...
【链表】-Lc83-删除有序链表中的重复元素（快慢双指针，slow，fast）

【链表】-Lc83-删除有序链表中的重复元素（快慢双指针，slow，fast）

写在前面 最近想复习一下数据结构与算法相关的内容&#xff0c;找一些题来做一做。如有更好思路&#xff0c;欢迎指正。 目录 写在前面一、场景描述二、具体步骤1.环境说明2.代码 写在后面 一、场景描述 删除有序链表中的重复元素。 示例&#xff1a; 输入&#xff1a;1->2…
阅读更多...
AMEYA360-村田商品化2016尺寸、低直流电阻、支持大电流且高耐压的车载用金属功率电感器

AMEYA360-村田商品化2016尺寸、低直流电阻、支持大电流且高耐压的车载用金属功率电感器

株式会社村田制作所开发了采用绕线金属合金的新系列车载用功率电感器“DFE2MCPH_JL系列”。本产品是2016尺寸(2.0x1.6mm)的小型车载用功率电感器&#xff0c;既实现了40V的高耐压&#xff0c;又实现了行业超高水平的直流电阻和额定电流(注&#xff1a;基于本公司调查结果&#…
阅读更多...
复习单向，双向链表，并且实现两种链表的增加和删除功能。

复习单向，双向链表，并且实现两种链表的增加和删除功能。

单链表头插 Linklist insert_head(datatype element,Linklist head) {//创建新节点 Linklist screate_node();if(NULLs)return head; s->dataelement;//1,判断链表为空if(NULLhead){heads;}else //链表不为空{s->nexthead;heads;}return head; } 单链表尾插 Linklist …
阅读更多...
【数据结构】链式队列

【数据结构】链式队列

链式队列实现&#xff1a; 1.创建一个空队列 2.尾插法入队 3.头删法出队 4.遍历队列 一、main函数 #include <stdio.h> #include "./3.linkqueue.h" int main(int…
阅读更多...
算法练习-环形链表（思路+流程图+代码）

算法练习-环形链表（思路+流程图+代码）

难度参考 难度&#xff1a;中等 分类&#xff1a;链表 难度与分类由我所参与的培训课程提供&#xff0c;但需要注意的是&#xff0c;难度与分类仅供参考。且所在课程未提供测试平台&#xff0c;故实现代码主要为自行测试的那种&#xff0c;以下内容均为个人笔记&#xff0c;旨在…
阅读更多...
【leetcode热题100】删除排序链表中的重复元素 II

【leetcode热题100】删除排序链表中的重复元素 II

难度&#xff1a; 中等通过率&#xff1a; 31.7%题目链接&#xff1a;力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 题目描述 给定一个排序链表&#xff0c;删除所有含有重复数字的节点&#xff0c;只保留原始链表中 没有重复出现 的数字。 示例…
阅读更多...
数据结构：顺序表 模拟实现及详解

数据结构：顺序表 模拟实现及详解

目录 一、线性表 二、顺序表 2.1顺序表的概念及结构 2.1.1静态顺序表 2.2.2动态顺序表 2.2动态顺序表接口实现 一、线性表 线性表&#xff08; linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使 用的数据结构&#xff0c;常见…
阅读更多...
83. 删除排序链表中的重复元素

83. 删除排序链表中的重复元素

83. 删除排序链表中的重复元素 给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的链表 。 题解&#xff1a;双指针 public ListNode deleteDuplicates(ListNode head) {if (head null) return null;ListNod…
阅读更多...
java复习篇 数据结构：链表第一节

java复习篇 数据结构：链表第一节

目录 单向链表 初始 头插 思路 情况一 情况二 代码 尾插 思路 遍历 优化遍历 遍历验证头插 尾插代码 优化 尾插测试 get 思路 代码 测试 insert 思路 代码 优化 测试 remove 移除头结点 提问 移除指定位置 测试 单向链表 每个元素只知道自己的下一个…
阅读更多...
数据结构链表力扣例题AC（3）——代码以及思路记录

数据结构链表力扣例题AC（3）——代码以及思路记录

160. 相交链表 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 AC写法一 struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {//思…
阅读更多...
java复习篇 数据结构：链表第二节 哨兵

java复习篇 数据结构：链表第二节 哨兵

目录 单向链表哨兵 初始 头插 思路 代码 尾插 思路 遍历 遍历验证头插 尾插代码 尾插测试 get 思路 代码 测试 insert 思路 代码 测试 remove 移除头结点 提问 移除指定位置 测试 单向链表哨兵 单向链表里面有一个特殊的节点称为哨兵节点&#xff0c;…
阅读更多...
链表/双向循环链表（C/C++）

链表/双向循环链表（C/C++）

本篇将给出双向循环链表的有关操作&#xff0c;以及对应的一些解释&#xff0c;大多都以注释给出。本篇给出的双向循环链表全称为带头双向循环链表。即如下图所示&#xff1a; 在本篇中一共包含三个代码片段&#xff0c;分别为&#xff1a;双向链表需要实现的内容、双向链表函数…
阅读更多...
【力扣 - 回文链表】

【力扣 - 回文链表】

题目描述 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 提示&#xff1a; 链表中节点数目在范围[1, 100000] 内 0 < Node.val < 9 方法一&#xff1a;将值复制到数…
阅读更多...
链表常见操作及解题思路

链表常见操作及解题思路

1.迭代。 链表最常见的操作就是迭代。 while (head.next ! null) {head head.next;}2.链表转化为数组 涉及到下标的问题&#xff0c;都可以将链表转化为数组解决&#xff0c;数组的每一个元素都是一个节点。。 示例题目LeetCode 876. 返回链表的中间节点 public ListNode midd…
阅读更多...
Go语言每日一练——链表篇(四)

Go语言每日一练——链表篇(四)

传送门 牛客面试笔试必刷101题 ----------------合并两个排序的链表 题目以及解析 题目 解题代码及解析 package main import _"fmt" import . "nc_tools" /** type ListNode struct{* Val int* Next *ListNode* }*//*** 代码中的类名、方法名、参…
阅读更多...
【leetcode】206. 反转链表（简单）题解学习

【leetcode】206. 反转链表（简单）题解学习

题目描述&#xff1a; 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&#xff1a;[2,1]示例 …
阅读更多...
拿捏循环链表

拿捏循环链表

目录&#xff1a; 一&#xff1a;单链表&#xff08;不带头单向不循环&#xff09;与循环链表&#xff08;带头双向循环&#xff09;区别 二&#xff1a;循环链表初始化 三&#xff1a;循环链表头插 四&#xff1a;循环链表尾插 五&#xff1a;循环链表头删 六&#xff1…
阅读更多...
「递归算法」：合并两个有序链表

「递归算法」：合并两个有序链表

一、题目 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4]示例 2&#xff1a; 输入&#xff1a;l1 [], l2 [] 输出&#…
阅读更多...
Go语言每日一练——链表篇(八)

Go语言每日一练——链表篇(八)

传送门 牛客面试笔试必刷101题 ----------------两个链表的第一个公共结点 题目以及解析 题目 解题代码及解析 解析 这一道题使用的还是双指针算法&#xff0c;我们先求出两个链表的长度差n&#xff0c;然后定义快慢指针&#xff0c;让快指针先走n步&#xff0c;最后快慢指…
阅读更多...
【数据结构与算法】【腾讯阿里链表面试题】算法题--链表易懂版讲解

【数据结构与算法】【腾讯阿里链表面试题】算法题--链表易懂版讲解

&#x1f389;&#x1f389;欢迎光临&#x1f389;&#x1f389; &#x1f3c5;我是苏泽&#xff0c;一位对技术充满热情的探索者和分享者。&#x1f680;&#x1f680; &#x1f31f;特别推荐给大家我的最新专栏《Spring 狂野之旅&#xff1a;底层原理高级进阶》 &#x1f680…
阅读更多...
leetcode9. 回文数|详细深入讲解算法

leetcode9. 回文数|详细深入讲解算法

前往题目有 反转一半数字 思路 映入脑海的第一个想法是将数字转换为字符串&#xff0c;并检查字符串是否为回文。但是&#xff0c;这需要额外的非常量空间来创建问题描述中所不允许的字符串。 第二个想法是将数字本身反转&#xff0c;然后将反转后的数字与原始数字进行比较&…
阅读更多...
【数据结构】链表OJ面试题5(题库+解析)

【数据结构】链表OJ面试题5(题库+解析)

1.前言 前五题在这http://t.csdnimg.cn/UeggB 后三题在这http://t.csdnimg.cn/gbohQ 给定一个链表&#xff0c;判断链表中是否有环。http://t.csdnimg.cn/Rcdyc 给定一个链表&#xff0c;返回链表开始入环的第一个结点。 如果链表无环&#xff0c;则返回 NULLhttp://t.cs…
阅读更多...
★【递归】【链表】Leetcode 21. 合并两个有序链表

★【递归】【链表】Leetcode 21. 合并两个有序链表

★【递归】【链表】Leetcode 21. 合并两个有序链表 解法1 &#xff1a;递归链表 简直是好题啊好题多做做 ---------------&#x1f388;&#x1f388;题目链接&#x1f388;&#x1f388;------------------- 解法1 &#xff1a;递归链表 简直是好题啊好题多做做 >>>…
阅读更多...
顺序表、链表（ArrayList、LinkedList）

顺序表、链表（ArrayList、LinkedList）

目录 前言&#xff1a; 顺序表&#xff08;ArrayList&#xff09;&#xff1a; 顺序表的原理&#xff1a; ArrayList源码&#xff1a; 的含义&#xff1a;​编辑 ArrayList的相关方法&#xff1a;​编辑 向上转型List&#xff1a; 练习题&#xff08;杨辉三角&#x…
阅读更多...
【C语言】实现双向链表

【C语言】实现双向链表

目录 &#xff08;一&#xff09;头文件 &#xff08;二&#xff09; 功能实现 &#xff08;1&#xff09;初始化 &#xff08;2&#xff09;打印链表 &#xff08;3&#xff09; 头插与头删 &#xff08;4&#xff09;尾插与尾删 &#xff08;5&#xff09;指定位置之后…
阅读更多...
算法沉淀——链表（leetcode真题剖析）

算法沉淀——链表（leetcode真题剖析）

算法沉淀——链表 01.两数相加02.两两交换链表中的节点03.重排链表04.合并 K 个升序链表05.K个一组翻转链表 链表常用技巧 1、画图->直观形象、便于理解 2、引入虚拟"头节点" 3、要学会定义辅助节点&#xff08;比如双向链表的节点插入&#xff09; 4、快慢双指针…
阅读更多...
【C语言】实现单链表

【C语言】实现单链表

目录 &#xff08;一&#xff09;头文件 &#xff08;二&#xff09;功能实现 &#xff08;1&#xff09;打印单链表 &#xff08;2&#xff09;头插与头删 &#xff08;3&#xff09;尾插与尾删 &#xff08;4&#xff09; 删除指定位置节点 和 删除指定位置之后的节点 …
阅读更多...
【数据结构】链表OJ面试题5《链表的深度拷贝》(题库+解析)

【数据结构】链表OJ面试题5《链表的深度拷贝》(题库+解析)

1.前言 前五题在这http://t.csdnimg.cn/UeggB 后三题在这http://t.csdnimg.cn/gbohQ 给定一个链表&#xff0c;判断链表中是否有环。http://t.csdnimg.cn/Rcdyc 给定一个链表&#xff0c;返回链表开始入环的第一个结点。 如果链表无环&#xff0c;则返回 NULLhttp://t.cs…
阅读更多...
【每日一题】牛客网——链表的回文结构

【每日一题】牛客网——链表的回文结构

✨专栏&#xff1a;《Java SE语法》 | 《数据结构与算法》 | 《C生万物》 ❤️感谢大家点赞&#x1f44d;&#x1f3fb;收藏⭐评论✍&#x1f3fb;&#xff0c;您的三连就是我持续更新的动力❤️ &#x1f64f;小杨水平有限&#xff0c;欢迎各位大佬指点&#xff0c;相互学习…
阅读更多...
输出链表，递归从根到当前节点输出某个属性

输出链表，递归从根到当前节点输出某个属性

文章目录 简介传统代码改进后的代码 简介 递归输出&#xff0c;递归获取从根到当前节点的某个属性 传统代码 class LinkNode:def __init__(self, name, parent_nodeNone):self.name nameself.parent_node parent_nodedef __repr__(self):return fLinkNode({self.name}, {s…
阅读更多...
【数据结构】链表OJ面试题3《判断是否有环》(题库+解析)

【数据结构】链表OJ面试题3《判断是否有环》(题库+解析)

1.前言 前五题在这http://t.csdnimg.cn/UeggB 后三题在这http://t.csdnimg.cn/gbohQ 记录每天的刷题&#xff0c;继续坚持&#xff01; 2.OJ题目训练 9. 给定一个链表&#xff0c;判断链表中是否有环。 力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成…
阅读更多...
Map和Set（哈希表）

Map和Set（哈希表）

目录 map&#xff1a; map说明&#xff1a; Map.Entry的说明&#xff1a;,v> Map 的常用方法: 演示&#xff1a; 注意&#xff1a; TreeMap和HashMap的区别 Set&#xff1a; 常见方法说明&#xff1a; 注意&#xff1a; TreeSet和HashSet的区别 哈希表: 冲突&a…
阅读更多...
牛客JZ 36二叉搜索树与双向链表

牛客JZ 36二叉搜索树与双向链表

描述 输入一棵二叉搜索树&#xff0c;将该二叉搜索树转换成一个排序的双向链表。如下图所示 数据范围&#xff1a;输入二叉树的节点数 0≤n≤10000≤n≤1000&#xff0c;二叉树中每个节点的值 0≤val≤10000≤val≤1000 要求&#xff1a;空间复杂度O(1)&#xff08;即在原树上…
阅读更多...
【算法随想录02】环形链表 ||

【算法随想录02】环形链表 ||

题目&#xff1a;142. 环形链表|| 难度&#xff1a;MEDIUM 算法思想 在第一节的时候&#xff0c;我们使用快慢指针解决了链表中存在环的问题。现在我们考虑怎么可以找到开始入环的第一个节点。 设慢指针走了k步&#xff0c;那么快指针走了2*k步。如果二者相遇&#xff0c;该…
阅读更多...
反转链表【基础算法精讲 06】

反转链表【基础算法精讲 06】

视频地址 反转链表【基础算法精讲 06】_哔哩哔哩_bilibili 概念 链表的每一个结点都包含节点值 和1指向下一个结点的next指针 , 链表的最后一个结点指向空; 206 . 反转链表 用cur记录当前遍历到的结点 &#xff0c; 用pre表示下一个结点 &#xff0c; 用nxt表示cur的下一个…
阅读更多...
链式结构实现队列

链式结构实现队列

链式结构实现队列 1.队列1.1队列的概念及结构1.2队列的实现 2. 队列的各种函数实现3. 队列的全部代码实现 1.队列 1.1队列的概念及结构 队列&#xff1a;只允许在一端进行插入数据操作&#xff0c;在另一端进行删除数据操作的特殊线性表&#xff0c;队列具有先进先出 FIFO(Fi…
阅读更多...
【每日一题】06 排序链表

【每日一题】06 排序链表

问题描述 给你链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 求解 /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/ struct ListNode* sortList(struct ListNode* head) {struct…
阅读更多...
数据结构链表力扣例题AC（1）——代码以及思路记录（含链表本机调试tips）

数据结构链表力扣例题AC（1）——代码以及思路记录（含链表本机调试tips）

链表力扣例题 876. 链表的中间结点 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结点。 AC struct ListNode* middleNode(struct ListNode* head) {struct ListNode* slow head, *fast head;w…
阅读更多...
数据结构对链表的初步认识（一）

数据结构对链表的初步认识（一）

已经两天没有更新了&#xff0c;今天就写一篇数据结构的链表吧&#xff0c;巩固自己也传授知识&#xff0c;不知道各位是否感兴趣看看这一篇有关联表的文章。 目录 链表的概念与结构 单向链表的实现 链表各个功能函数 首先我在一周前发布了一篇有关顺序表的文章&#xff0c;…
阅读更多...
详解 leetcode_078. 合并K个升序链表.小顶堆实现

详解 leetcode_078. 合并K个升序链表.小顶堆实现

/*** 构造单链表节点*/ class ListNode{int value;//节点值ListNode next;//指向后继节点的引用public ListNode(){}public ListNode(int value){this.valuevalue;}public ListNode(int value,ListNode next){this.valuevalue;this.nextnext;} }package com.ag; import java.ut…
阅读更多...
每日OJ题_算法_递归⑤力扣50. Pow(x, n)

每日OJ题_算法_递归⑤力扣50. Pow(x, n)

目录 力扣50. Pow(x, n) 解析代码 力扣50. Pow(x, n) 50. Pow(x, n) 难度 中等 实现 pow(x, n) &#xff0c;即计算 x 的整数 n 次幂函数&#xff08;即&#xff0c;xn &#xff09;。 示例 1&#xff1a; 输入&#xff1a;x 2.00000, n 10 输出&#xff1a;1024.0000…
阅读更多...
【详解】图的概念和存储结构（邻接矩阵，邻接表）

【详解】图的概念和存储结构（邻接矩阵，邻接表）

目录 图的基本概念&#xff1a; 图的存储结构 邻接矩阵&#xff08;GraphByMatrix&#xff09;&#xff1a; 基本参数&#xff1a; 初始化&#xff1a; 获取顶点元素在其数组中的下标 &#xff1a; 添加边和权重&#xff1a; 获取顶点的度&#xff1a; 打印图&#xf…
阅读更多...
【牛客 NC253455】小红走排列 题解（链表+位集合+贪心算法）

【牛客 NC253455】小红走排列 题解（链表+位集合+贪心算法）

题目描述 对于一个排列&#xff0c;小红定义该排列的总消耗为&#xff1a;1走到2&#xff0c;2走到3&#xff0c;……&#xff0c;最终从 n − 1 n-1 n−1走到 n n n所需的最少的总步数。其中&#xff0c;每一步可以向左走一步&#xff0c;也可以向右走一步。 现在&#xff0…
阅读更多...
【玩转408数据结构】线性表——单链表的定义以及增删改查（线性表的链式表示 上）

【玩转408数据结构】线性表——单链表的定义以及增删改查（线性表的链式表示 上）

知识回顾 到这里我们已经了解到线性表是具有相同数据类型的有限个数据元素序列&#xff0c;而线性表的顺序存储也就是顺序表&#xff0c;顺序表的存储形式十分直观&#xff0c;我们在实现时使用数组进行实现&#xff0c;但顺序表在插入或者删除元素时需要移动大量元素&#xff…
阅读更多...
LeetCode23.合并K个升序链表

LeetCode23.合并K个升序链表

题目 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并到一个升序链表中&#xff0c;返回合并后的链表。 示例 &#xff1a; 输入&#xff1a;lists [[1,4,5],[1,3,4],[2,6]] 输出&#xff1a;[1,1,2,3,4,4,5,6] 解释&#xff1a;链表数组如下&…
阅读更多...
数据结构第十六天（二叉树层序遍历/广度优先搜索（BFS）/队列使用)

数据结构第十六天（二叉树层序遍历/广度优先搜索（BFS）/队列使用)

目录 前言 概述 接口 源码 测试函数 运行结果 往期精彩内容 前言 从前的日色变得慢&#xff0c;车&#xff0c;马&#xff0c;邮件都慢&#xff0c;一生,只够爱一个人。 概述 二叉树的层序遍历可以使用广度优先搜索&#xff08;BFS&#xff09;来实现。具体步骤如下&…
阅读更多...
数据结构---单向循环链表的基本操作

数据结构---单向循环链表的基本操作

头插法遍历链表尾插法头删法尾删法按位置插入数据按位置删除数据按位置查找 linklist_xh.c #include <stdio.h> #include <stdlib.h>#include "linklist_xh.h"loopLinkList* create_loopLinkList(void) {loopLinkList* head (loopLinkList*)malloc(siz…
阅读更多...
挑战！贪吃蛇小游戏的实现（1）

挑战！贪吃蛇小游戏的实现（1）

引言 相信大家都玩过贪吃蛇这个游戏&#xff01; 玩家控制一个不断移动的蛇形角色&#xff0c;在一个封闭空间内移动。随着时间推进&#xff0c;这个蛇形角色会逐渐增长&#xff0c;通常是通过吞食屏幕上出现的物品&#xff08;如点或者其他标志&#xff09;来实现。每当贪吃…
阅读更多...
初阶数据结构之---顺序表和链表（C语言）

初阶数据结构之---顺序表和链表（C语言）

引言-线性表 线性表&#xff1a; 线性表&#xff08;linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构。线性表在逻辑上是线性结构&#xff0c;也就是说是连续的一条直线。但在物理上并不一定是连续的。线性表在物理上…
阅读更多...
【数据结构】链表OJ面试题3(题库+解析)

【数据结构】链表OJ面试题3(题库+解析)

1.前言 前五题在这http://t.csdnimg.cn/UeggB 后三题在这http://t.csdnimg.cn/gbohQ 记录每天的刷题&#xff0c;继续坚持&#xff01; 2.OJ题目训练 9. 给定一个链表&#xff0c;判断链表中是否有环。 力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成…
阅读更多...
[力扣 Hot100]Day33 排序链表

[力扣 Hot100]Day33 排序链表

题目描述 给你链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 出处 思路 归并排序即可。 代码 class Solution { public:ListNode* merge(ListNode *h1,ListNode *h2) {ListNode *head nullptr;if(h1->val<h2->val){head h1;h1h1-…
阅读更多...
【算法随想录01】环形链表

【算法随想录01】环形链表

题目&#xff1a;141. 环形链表 难度&#xff1a;EASY 代码 哈希表遍历求解&#xff0c;表中存储的是元素地址。 时间复杂度 O ( N ) O(N) O(N)&#xff0c;空间复杂度 O ( N ) O(N) O(N) /*** Definition for singly-linked list.* struct ListNode {* int val;* …
阅读更多...
算法详解（力扣141——环形链表系列）

算法详解（力扣141——环形链表系列）

博主ID&#xff1a;代码小豪 文章目录 环形链表环形链表的性质分析快慢指针法指针的追及相遇问题 环形链表&#xff08;2&#xff09; 环形链表 先来看看环形链表的原题&#xff1a; 中间的部分叙述有点繁杂&#xff0c;简单来概括就是&#xff0c;假如有一个节点&#xff0c…
阅读更多...
力扣OJ题——随机链表的复制

力扣OJ题——随机链表的复制

题目&#xff1a; 138. 随机链表的复制 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 要求&#xff1a;构造这个链表的 深拷贝 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中…
阅读更多...
C语言---链表

C语言---链表

一.定义 链表是由一系列节点组成&#xff0c;每个结点包含两个域&#xff0c;一个是数据域&#xff0c;数据域用来保存用户数据&#xff0c;另一个是指针域&#xff0c;保存下一个节点的地址。链表在内存中是非连续的。 二.分类 静态链表 动态链表 单向链表 双向链表 循环链…
阅读更多...
【leetcode热题】二叉树展开为链表

【leetcode热题】二叉树展开为链表

难度&#xff1a; 中等通过率&#xff1a; 40.2%题目链接&#xff1a;. - 力扣&#xff08;LeetCode&#xff09; 题目描述 给定一个二叉树&#xff0c;原地将它展开为链表。 例如&#xff0c;给定二叉树 1/ \2 5/ \ \ 3 4 6 将其展开为&#xff1a; 1\2\3\4\5\6 …
阅读更多...
搜索回溯算法（DFS）1------递归

搜索回溯算法（DFS）1------递归

目录 简介&#xff1a; 递归问题解题的思路模板 例题1&#xff1a;汉诺塔 例题2&#xff1a;合并两个有序链表 例题3&#xff1a;反转链表 例题4&#xff1a;两两交换链表中的节点 例题5&#xff1a;Pow&#xff08;x,n&#xff09;-快速幂 结语&#xff1a; 简介&…
阅读更多...
数据结构——链表OJ题

数据结构——链表OJ题

目录 1.给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 2.给定一个带有头结点 head 的非空单链表&#xff0c;返回链表的中间结点。如果有两个中间结点&#xff0c;则返回第二个中间结点…
阅读更多...
【数据结构】每天五分钟，快速入门数据结构（二）——链表

【数据结构】每天五分钟，快速入门数据结构（二）——链表

目录 一 构建一个单向链表 二 特点 三 时间复杂度 四 相关算法 1.判断链表是否成环及成环位置 2.链表反转 五 Java中的LinkedList 类 1.使用 2.LinkedList 方法 一 构建一个单向链表 // 设计链表结构class ListNode {int val;ListNode next;ListNode(){}ListNode(int…
阅读更多...
备战蓝桥杯—— 双指针技巧巧答链表2

备战蓝桥杯—— 双指针技巧巧答链表2

对于单链表相关的问题&#xff0c;双指针技巧是一种非常广泛且有效的解决方法。以下是一些常见问题以及使用双指针技巧解决&#xff1a; 合并两个有序链表&#xff1a; 使用两个指针分别指向两个链表的头部&#xff0c;逐一比较节点的值&#xff0c;将较小的节点链接到结果链表…
阅读更多...
循环队列和链表队列

循环队列和链表队列

循环队列&#xff1a; #include <iostream> using namespace std; const int MAX_SIZE 100; template <class DataType> /* 循环队列可以想象成一个环形&#xff0c;里面有一个个的格子&#xff0c;也就是环形数组 front表示首个&#xff08;但是这不会一直是0&a…
阅读更多...
力扣链表篇

力扣链表篇

以下刷题思路来自代码随想录以及官方题解 文章目录 203.移除链表元素707.设计链表206.反转链表24.两两交换链表中的节点19.删除链表的倒数第N个节点面试题 02.07. 链表相交142.环形链表II 203.移除链表元素 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链…
阅读更多...
数据结构--双向链表专题

数据结构--双向链表专题

目录 1. 双向链表的结构2. 实现双向链表预先的准备初始化尾插、头插尾删、头删查找在pos位置之后插⼊数据删除pos位置的数据 3. 顺序表和双向链表的分析 1. 双向链表的结构 注意&#xff1a;这里的“带头”跟前面我们说的“头结点”是两个概念&#xff0c;为了更好的理解直接称…
阅读更多...
C语言--贪吃蛇

C语言--贪吃蛇

目录 1. 实现目标2. 需掌握的技术3. Win32 API介绍控制台程序控制台屏幕上的坐标COORDGetStdHandleGetConsoleCursorinfoCONSOLE_CURSOR_INFOSetConsoleCursorInfoSetConsoleCursorPositionGetAsyncKeyState 4. 贪吃蛇游戏设计与分析地图<locale.h>本地化类项setlocale函…
阅读更多...
线性表——单链表的增删查改（上）

线性表——单链表的增删查改（上）

本节复习链表的增删查改 首先&#xff0c; 链表不是连续的&#xff0c; 而是通过指针联系起来的。 如图&#xff1a; 这四个节点不是连续的内存空间&#xff0c; 但是彼此之间使用了一个指针来连接。 这就是链表。 现在我们来实现链表的增删查改。 目录 本节函数接口列表…
阅读更多...
备战蓝桥杯Day17 - 链表

备战蓝桥杯Day17 - 链表

链表 基本概念 链表是由一系列节点组成的元素集合。 每个节点包含两部分&#xff1a;数据域 item 、指向下一个节点的指针 next 通过节点之间的相互链接&#xff0c;形成一个链表 1. 链表的初始化 # 手动建立链表 # 链表的初始化 class Node(object):def __init__(self, …
阅读更多...
【数据结构】栈OJ题《用栈实现队列》（题库+解析+代码）

【数据结构】栈OJ题《用栈实现队列》（题库+解析+代码）

1. 前言 通过前面栈的实现和详解大家对队列应该有一定熟悉了&#xff0c;现在上强度开始做题吧 栈详解&#xff1a;http://t.csdnimg.cn/9Fsbs 本体的做题思路也可以参考上一篇文章&#xff0c;就是有一点点不同。 用队列实现栈&#xff1a;http://t.csdnimg.cn/V2qjW 2. …
阅读更多...
【数据结构和算法初阶(C语言)】链表-单链表（手撕详讲单链表增删查改）

【数据结构和算法初阶(C语言)】链表-单链表（手撕详讲单链表增删查改）

目录 1.前言&#xff1a;顺序表回顾&#xff1a; 1.1顺序表的优缺点 2.主角----链表 2.1链表的概念 2.2定义一个单链表的具体实现代码方式 3.单链表对数据的管理----增删查改 3.1单链表的创建 3.2单链表的遍历实现 3.2.1利用遍历实现一个打印我们链表内容的函数的函数…
阅读更多...
C#单向链表实现：使用泛型的方法设计

C#单向链表实现：使用泛型的方法设计

目录 1.先设计一个泛型节点类Node 2.再设计一个泛型链表类LinkedList 3.创建一个LinkedList类的实例 4.完整的实例 再发一篇使用泛型的方法设计单向链表。 以下是一个使用泛型节点类和LinkedList<T>类的示例&#xff0c;其中包含Insert方法用于插入新节点&#xff0c…
阅读更多...
链表之“带头双向循环链表”

链表之“带头双向循环链表”

目录 ​编辑 1.链表的分类 2.带头双向循环链表的实现 1.创建结构体 2.创建返回链表的头节点 3.双向链表销毁 4.双向链表打印 5.双向链表尾插 6.双向链表尾删 7.双向链表头插 8.双向链表头删 9.双向链表查找 10.双向链表在pos的前面进行插入 11.双向链表删除pos位…
阅读更多...
线性表——单链表的增删查改

线性表——单链表的增删查改

本节复习链表的增删查改 首先&#xff0c; 链表不是连续的&#xff0c; 而是通过指针联系起来的。 如图&#xff1a; 这四个节点不是连续的内存空间&#xff0c; 但是彼此之间使用了一个指针来连接。 这就是链表。 现在我们来实现链表的增删查改。 目录 单链表的全部接口…
阅读更多...
LeetCode 刷题 [C++] 第148题.排序链表

LeetCode 刷题 [C++] 第148题.排序链表

题目描述 给你链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 题目分析 根据题意&#xff0c;可以使用归并排序来对链表进行排序。归并排序是基于分治的思想&#xff0c;比较容易实现的就是自顶向下的递归方式来实现。 先找出链表的中点&#x…
阅读更多...
C#单向链表实现：对链表初始数据进行冒泡排序的方法

C#单向链表实现：对链表初始数据进行冒泡排序的方法

目录 一、涉及到的知识点 1.冒泡排序 2.什么时候需要对链表数据排序 二、对链表初始数据冒泡排序算法实现 1.首先&#xff0c;检查输入的链表头节点head是否为空或者只有一个节点 2.接下来&#xff0c;进入一个do-while循环 3.在每次循环中&#xff0c;首先将当前节点cu…
阅读更多...
C语言数据结构基础-单链表

C语言数据结构基础-单链表

1.链表概念 在前面的学习中&#xff0c;我们知道了线性表&#xff0c;其中逻辑结构与物理结构都连续的叫顺序表&#xff0c;那么&#xff1a; 链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表 中的指针链接次序实现的 。 2.链表组…
阅读更多...
[LeetCode]143.重排链表

[LeetCode]143.重排链表

143. 重排链表 - 力扣&#xff08;LeetCode&#xff09;https://leetcode.cn/problems/reorder-list/description/ 题目 示例 解题思路 寻找链表中点 链表逆序 合并链表 注意到目标链表即为将原链表的左半端和反转后的右半端合并后的结果。 这样我们的任务即可划分为三步&a…
阅读更多...
数据结构------栈（Stack）和队列（Queue）

数据结构------栈（Stack）和队列（Queue）

也是好久没写博客了&#xff0c;那今天就回归一下&#xff0c;写一篇数据结构的博客吧。今天要写的是栈和队列&#xff0c;也是数据结构中比较基础的知识。那么下面开始今天要写的博客了。 目录 栈&#xff08;Stack&#xff09; 队列&#xff08;Queue&#xff09; 喜欢就点…
阅读更多...
C#，双向链表（Doubly Linked List）归并排序（Merge Sort）算法与源代码

C#，双向链表（Doubly Linked List）归并排序（Merge Sort）算法与源代码

1 双向链表 双向链表也叫双链表&#xff0c;是链表的一种&#xff0c;它的每个数据结点中都有两个指针&#xff0c;分别指向直接后继和直接前驱。所以&#xff0c;从双向链表中的任意一个结点开始&#xff0c;都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循…
阅读更多...
【海贼王的数据航海：利用数据结构成为数据海洋的霸主】链表—双向链表

【海贼王的数据航海：利用数据结构成为数据海洋的霸主】链表—双向链表

目录 往期 1 -> 带头双向循环链表(双链表) 1.1 -> 接口声明 1.2 -> 接口实现 1.2.1 -> 双向链表初始化 1.2.2 -> 动态申请一个结点 1.2.3 -> 双向链表销毁 1.2.4 -> 双向链表打印 1.2.5 -> 双向链表判空 1.2.6 -> 双向链表尾插 1.2.7 -&…
阅读更多...
数据结构（C语言版）02---链表

数据结构（C语言版）02---链表

链表&#xff1a; 声明&#xff1a;LNode* LinkList在链表里面这两个是等价的; #include<stdio.h> #include<stdlib.h> typedef int Elemtype; typedef struct LNode{Elemtype data;struct LNode* next; }LNode,*LinkList; 链表打印函数&#xff1a; //打印v…
阅读更多...
Java基础数据结构之LinkedList与链表

Java基础数据结构之LinkedList与链表

一.链表 链表的形式从如下三个角度考虑&#xff1a; 1.有头还是无头 对于有头的&#xff0c;head节点的value域为空&#xff0c;而且插入数据时&#xff0c;必须插在head之后&#xff08;不一定紧挨着&#xff09;&#xff0c;对于无头的&#xff0c;差在哪里都可以 2.单向…
阅读更多...
LeetCode---【链表的操作】

LeetCode---【链表的操作】

目录 206反转链表【链表结构基础】21合并两个有序链表【递归】我的答案【错误】自己修改【超出时间限制】在官方那里学到的【然后自己复写,错误】对照官方【自己修改】 160相交链表【未理解题目目的】在b站up那里学到的【然后自己复写,错误】【超出时间限制】对照官方【自己修改…
阅读更多...
链表习题-力扣oj （附加思路版）

链表习题-力扣oj （附加思路版）

LCR 140. 训练计划 IIhttps://leetcode.cn/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/ 给定一个头节点为 head 的链表用于记录一系列核心肌群训练项目编号&#xff0c;请查找并返回倒数第 cnt 个训练项目编号。 思路&#xff1a;双指针&#xff0c;快指针先走cnt…
阅读更多...
LeetCode234题：回文链表（python3）

LeetCode234题：回文链表（python3）

代码思路&#xff1a;将链表的值复制到数组列表中&#xff0c;再使用双指针法判断&#xff0c;不断更新current_node的值。 # Definition for singly-linked list. # class ListNode: # def __init__(self, val0, nextNone): # self.val val # self.next…
阅读更多...
C#双向链表：只用泛型节点类ListNode＜T＞设计的最短的双向链表包含初始化链表数据和遍历链表各节点

C#双向链表：只用泛型节点类ListNode＜T＞设计的最短的双向链表包含初始化链表数据和遍历链表各节点

目录 一、涉及到的知识点&#xff1a; 1.ListNode 类使用自动属性设计 2. 泛型节点类设计的误区 二、仅仅定义泛型节点类&#xff0c;实现最短的双向链表 一、涉及到的知识点&#xff1a; 1.ListNode 类使用自动属性设计 public class ListNode {public object Object { …
阅读更多...
检查链表是否有环，返回值为bool和从头节点进入环的第一个节点两种情况

检查链表是否有环，返回值为bool和从头节点进入环的第一个节点两种情况

题目1&#xff08;不返回节点&#xff09; 给定单链表&#xff0c;检查链表是否有环。 代码实现&#xff1a; bool IsCircle(List plist) {assert(plist ! NULL);if (plist NULL||plist->nextNULL)return false;Node* p plist->next;//慢指针,一次走一步Node* q pl…
阅读更多...
[数据结构]链表OJ--环形链表判断是否有环(快慢指针法)

[数据结构]链表OJ--环形链表判断是否有环(快慢指针法)

141. 环形链表 - 力扣&#xff08;LeetCode&#xff09; 这里我采用的是快慢指针法,这是我认为最容易理解的方法,这个方法的思路是这样的. 我们可以定义两个指针一个快一个慢,如果这个链表有环,则快慢指针一定会相遇. 这里我画图举个例子: 我们很明显的可以看出,有环链表,快指…
阅读更多...
数据结构界的幻神(First)----链表

数据结构界的幻神(First)----链表

一.链表的概念 链表是一种常见的数据结构&#xff0c;它由一系列节点组成&#xff0c;每个节点包含数据和指向下一个节点的指针。链表的结构类似于一条链子&#xff0c;因此得名。 相比于传统的数组&#xff0c;链表具有以下特点&#xff1a; 1. 动态增长&#xff1a; 链表的…
阅读更多...
力扣61：旋转链表

力扣61：旋转链表

题目 给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], k 2输出&#xff1a;[4,5,1,2,3] 示例 2&#xff1a; 输入&#xff1a;head [0,1,2], k 4输出&#xff1a;…
阅读更多...
有头链表初始化的三种方法

有头链表初始化的三种方法

背景&#xff1a; 在数据结构里的链表&#xff0c;无论是图&#xff0c;二叉树&#xff0c;等等都会用到他 但我们常常会对于Linklist L,和Linklist *L&#xff0c;前个L是指针&#xff0c;后面那个是指针的指针。本来想写这成没基础都能听懂&#xff0c;这是我的初心。但我发现…
阅读更多...
一道OJ题 ——《环形链表II》的C语言题解

一道OJ题 ——《环形链表II》的C语言题解

刷到了这样一道题目&#xff0c;非常有意思&#xff0c;让我的大脑感受到了前所未有的重创&#xff0c;现在把这道题目的题解分享一下。 1.题目 图片看不清的话这里有原题文字&#xff1a; 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环…
阅读更多...
数据结构从入门到精通——链表

数据结构从入门到精通——链表

链表 前言一、链表1.1 链表的概念及结构1.2 链表的分类1.3 链表的实现1.4 链表面试题1.5 双向链表的实现 二、顺序表和链表的区别三、单项链表实现具体代码text.htext.cmain.c单链表的打印空间的开辟链表的头插、尾插链表的头删、尾删链表中元素的查找链表在指定位置之前、之后…
阅读更多...
数据结构——lesson4带头双向循环链表实现

数据结构——lesson4带头双向循环链表实现

前言✨✨ &#x1f4a5;个人主页&#xff1a;大耳朵土土垚-CSDN博客 &#x1f4a5; 所属专栏&#xff1a;数据结构学习笔记​​​​​​ &#x1f4a5;双链表与单链表的区分&#xff1a;单链表介绍与实现 &#x1f4a5;对于malloc函数有疑问的:动态内存函数介绍 感谢大家的观看…
阅读更多...
LeetCode206题：反转链表（python3）

LeetCode206题：反转链表（python3）

采用递归 class Solution:def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:cur headpre Nonewhile cur:temp cur.next # 保存下一轮循环的节点cur.next pre # 将当前节点 cur 的指针指向上一个节点 prepre curcur tempreturn pre
阅读更多...
leetcode热题100学习计划-链表-反转链表

leetcode热题100学习计划-链表-反转链表

思路 使用头插法逆转链表 注&#xff1a;链表一般为操作方便&#xff0c;头结点不存值&#xff0c;是一个虚拟节点 代码 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val)…
阅读更多...
C语言利用函数创建链表，修改链表（插入，删除，添加），指针函数的返回

C语言利用函数创建链表，修改链表（插入，删除，添加），指针函数的返回

这段代码是一个简单的链表操作程序&#xff0c;包括创建节点、在链表末尾添加节点、在指定位置插入节点和删除指定位置的节点。以下是详细的注释&#xff1a; #include<stdio.h> #include<stdlib.h>// 定义链表节点结构体 struct listnode{int i; // 节点存储的整…
阅读更多...
数据结构 - 链表 (四)

数据结构 - 链表 (四)

这篇博客将介绍带头循环的双向链表&#xff0c;实现链表的头部插入/删除&#xff0c;尾部插入/删除&#xff0c;查找&#xff0c;以及任意位置的插入删除。 1.结构 带头循环的双向链表的结构如下图所示&#xff0c;一个结点内部包含数据&#xff0c;以及分别指向前一个以及后…
阅读更多...
回文链表（leetcode）

回文链表（leetcode）

我自己第一个写的代码&#xff1a; bool isPalindrome(struct ListNode* head){struct ListNode* tail NULL;struct ListNode* pos NULL;if( head->next NULL){return true;}while( 1 ){if( head->next NULL || (head->next->next NULL && head->…
阅读更多...
从键盘输入5个整数，将这些整数插入到一个链表中，并按从小到大次序排列，最后输出这些整数。

从键盘输入5个整数，将这些整数插入到一个链表中，并按从小到大次序排列，最后输出这些整数。

设节点定义如下struct Node {int Element; // 节点中的元素为整数类型struct Node * Next; // 指向下一个节点 }; 从键盘输入5个整数&#xff0c;将这些整数插入到一个链表中&#xff0c;并按从小到大次序排列&#xff0c;最后输出这些整数。注释那段求指出错误&#xff0c;求解…
阅读更多...
C#双向链表实现：在当前节点后插入新数据的方法Insert()

C#双向链表实现：在当前节点后插入新数据的方法Insert()

目录 1.定义一个泛型节点类并自动属性 2.定义链表类&#xff0c;并实现Append、Print、MoveFirst、 Insert 3.Main方法 1.定义一个泛型节点类并自动属性 /// <summary> /// 定义泛型节点类 /// </summary> /// <typeparam name"T">泛型运算符&…
阅读更多...
⭐每天一道leetcode：21.合并两个有序链表（简单；双指针）

⭐每天一道leetcode：21.合并两个有序链表（简单；双指针）

⭐今日份题目 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例1 输入&#xff1a;l1 [1,2,4], l2 [1,3,4] 输出&#xff1a;[1,1,2,3,4,4] 示例2 输入&#xff1a;l1 [], l2 [] 输出&#xff1a;[] 示例3 输入…
阅读更多...
【数据结构】顺序表+链表

【数据结构】顺序表+链表

目录 1.顺序表 1.1初始化顺序表 1.2销毁顺序表 1.3检查容量并扩容 1.4把某个元素插入到下标为pos的位置 1.5头插和尾插 1.6删除下标为pos的元素 1.7头删和尾删 2.顺序表的问题及思考 3.链表 3.1链表的访问 3.2链表的增删查改 1.顺序表 顺序表的本质其实就是一个数组…
阅读更多...
[数据结构]OJ一道------用栈实现队列

[数据结构]OJ一道------用栈实现队列

题目来源:232. 用栈实现队列 - 力扣&#xff08;LeetCode&#xff09; 解题思路来源:力扣官方题解 https://leetcode.cn/problems/implement-queue-using-stacks/solutions/632369/yong-zhan-shi-xian-dui-lie-by-leetcode-s-xnb6/ 首先我们先来看题目: 给的代码: typedef s…
阅读更多...
C++中常见的数据结构，包括数组、链表、栈、队列、树和图

C++中常见的数据结构，包括数组、链表、栈、队列、树和图

在C编程中&#xff0c;数据结构是一种组织和存储数据的方式&#xff0c;它定义了数据之间的关系&#xff0c;使得数据能够被有效地访问和修改。选择适当的数据结构对于解决特定的问题至关重要&#xff0c;因为它能直接影响到程序的效率和性能。下面是一些在C中常见的数据结构&a…
阅读更多...
Leetcode : 147. 对链表进行插入排序

Leetcode : 147. 对链表进行插入排序

给定单个链表的头 head &#xff0c;使用 插入排序 对链表进行排序&#xff0c;并返回 排序后链表的头 。 插入排序 算法的步骤: 插入排序是迭代的&#xff0c;每次只移动一个元素&#xff0c;直到所有元素可以形成一个有序的输出列表。 每次迭代中&#xff0c;插入排序只从输…
阅读更多...
如何实现双向循环链表

如何实现双向循环链表

博主主页&#xff1a;17_Kevin-CSDN博客 收录专栏&#xff1a;《数据结构》 引言 双向带头循环链表是一种常见的数据结构&#xff0c;它具有双向遍历的特性&#xff0c;并且在表头和表尾之间形成一个循环。本文将深入探讨双向带头循环链表的结构、操作和应用场景&#xff0c;帮…
阅读更多...
C语言项目实战——贪吃蛇

C语言项目实战——贪吃蛇

C语言实现贪吃蛇 前言一、 游戏背景二、游戏效果演示三、课程目标四、项目定位五、技术要点六、Win32 API介绍6.1 Win32 API6.2 控制台程序6.3 控制台屏幕上的坐标COORD6.4 GetStdHandle6.5 GetConsoleCursorInfo6.5.1 CONSOLE_CURSOR_INFO 6.6 SetConsoleCursorInfo6.7 SetCon…
阅读更多...
每日一题-合成两个有序链表

每日一题-合成两个有序链表

&#x1f308;个人主页: 会编辑的果子君 &#x1f4ab;个人格言:“成为自己未来的主人~” 以上是题目信息&#xff1a; 下面是解答过程 /*** Definition for singly-linked list.* struct ListNode {* int val;* struct ListNode *next;* };*/ typedef struct Lis…
阅读更多...
剑指offer面试题26 复杂链表的复制

剑指offer面试题26 复杂链表的复制

考察点 链表遍历知识点 题目 分析 这道题目要求复制链表&#xff0c;链表结点除了值和next指针以外还有一个指针指向该链表中任意一个结点。这道题目最直观的解法就是先把含有next指针的链表复制出来&#xff0c;然后再次遍历链表设置第二个指针&#xff0c;方法是判断下第二…
阅读更多...
力扣经典题目解析--反转链表

力扣经典题目解析--反转链表

原题地址: . - 力扣&#xff08;LeetCode&#xff09; 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1] 题目解析 链表&#xff08;Linked List&…
阅读更多...
ZJGSU 1737 链表

ZJGSU 1737 链表

题目描述 请根据输入数据构造一个带头结点的单链表&#xff0c;链表结点的数据结构为struct node {int data; struct node *next;}&#xff0c;试设计算法&#xff1a;按递增次序输出单链表中各结点的数据元素&#xff0c;并释放结点所占用的存储空间。 要求&#xff1a;不允…
阅读更多...
力扣刷题Days11第二题--141. 环形链表（js）

力扣刷题Days11第二题--141. 环形链表（js）

目录 1,题目 2&#xff0c;代码 2.1快慢指针 2.2&#xff0c;哈希表 3&#xff0c;学习与总结 3.1自己尝试写快慢指针 反思 1,题目 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&…
阅读更多...
【玩转408数据结构】线性表——双链表、循环链表和静态链表（线性表的链式表示 下）

【玩转408数据结构】线性表——双链表、循环链表和静态链表（线性表的链式表示 下）

知识回顾 在前面的学习中&#xff0c;我们已经了解到了链表&#xff08;线性表的链式存储&#xff09;的一些基本特点&#xff0c;并且深入的研究探讨了单链表的一些特性&#xff0c;我们知道&#xff0c;单链表在实现插入删除上&#xff0c;是要比顺序表方便的&#xff0c;但是…
阅读更多...
【华为OD机试】转盘寿司【C卷|100分】

【华为OD机试】转盘寿司【C卷|100分】

【华为OD机试】-真题 !!点这里！！ 【华为OD机试】真题考点分类 !!点这里 !! 题目描述 寿司店周年庆，正在举办优惠活动回馈新老客户。 寿司转盘上总共有 n 盘寿司，prices[i] 是第 i 盘寿司的价格， 如果客户选择了第 i 盘寿司，寿司店免费赠送客户距离第 i 盘寿司最近的下一…
阅读更多...
链表|707.设计链表

链表|707.设计链表

力扣题目链接 typedef struct MyLinkedList {int val;struct MyLinkedList* next; }MyLinkedList;/** Initialize your data structure here. */MyLinkedList* myLinkedListCreate() {//这个题必须用虚拟头指针,参数都是一级指针,头节点确定后没法改指向了!!!MyLinkedList* he…
阅读更多...
算法Day05_707.设计链表

算法Day05_707.设计链表

推荐阅读 算法day01_ 27. 移除元素、977.有序数组的平方 算法day02_209.长度最小的子数组 算法day03_ 59.螺旋矩阵II 算法Day04_203.移除链表元素 目录 推荐阅读707.设计链表题目思路解法单链表解法双链表解法 707.设计链表 题目 你可以选择使用单链表或者双链表&#xff0c;设…
阅读更多...
【数据结构】汇总二、线性表（逻辑结构、物理（存储）结构、基本操作、1.顺序表2.单链表3.双链表4.循环链表5.静态链表6.顺序表与链表的对比不同）

【数据结构】汇总二、线性表（逻辑结构、物理（存储）结构、基本操作、1.顺序表2.单链表3.双链表4.循环链表5.静态链表6.顺序表与链表的对比不同）

文章目录 线性表linear list逻辑结构物理&#xff08;存储&#xff09;结构基本操作1.顺序表1.0特点1.1静态分配1.2动态分配1.3插入1.4删除1.5查找1.5.1按位查找1.5.2按值查找 2.单链表2.1不带头结点的单链表2.2带头结点的单链表2.3插入2.3.1按位序插入2.3.1.1带头结点2.3.1.2不…
阅读更多...
142.环形链表II

142.环形链表II

142.环形链表II 力扣题目链接(opens new window) 题意&#xff1a; 给定一个链表&#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 为了表示给定链表中的环&#xff0c;使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;索引从 0…
阅读更多...
C#双向链表：只用泛型节点类ListNode＜T＞设计的最短小的双向链表包含初始化链表数据和遍历链表各节点

C#双向链表：只用泛型节点类ListNode＜T＞设计的最短小的双向链表包含初始化链表数据和遍历链表各节点

目录 一、涉及到的知识点&#xff1a; 1.ListNode 类使用自动属性设计 2. 泛型节点类设计的误区 二、仅仅定义泛型节点类&#xff0c;实现最短的双向链表 一、涉及到的知识点&#xff1a; 1.ListNode 类使用自动属性设计 public class ListNode {public object Object { …
阅读更多...
【数据结构】二、线性表：4.循环链表的定义及其基本操作（循环单链表,循环双链表的初始化、判空、判断头结点、尾结点、插入、删除）

【数据结构】二、线性表：4.循环链表的定义及其基本操作（循环单链表,循环双链表的初始化、判空、判断头结点、尾结点、插入、删除）

文章目录 4.循环链表4.1循环单链表4.1.1初始化4.1.2判断单链表是否为空4.1.3判断p结点是否为循环单链表的表尾结点 4.2循环双链表4.2.1初始化4.2.2判断循环链表是否为空4.2.3判断结点p是否为循环双链表的表尾结点4.2.4双链表的插入4.2.5双链表的删除 4.循环链表 4.1循环单链表…
阅读更多...
[力扣 Hot100]Day46 二叉树展开为链表

[力扣 Hot100]Day46 二叉树展开为链表

题目描述 给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左子指针始终为 null 。 展开后的单链表应该与二叉树 先序遍历 顺序相同。 出…
阅读更多...
初阶数据结构：链表相关题目练习（补充）

初阶数据结构：链表相关题目练习（补充）

目录 1. 单链表相关练习题1.1 移除链表元素1.2 反转链表1.3 链表的中间结点1.4 链表的倒数第k个结点1.5 合并两个有序链表1.6 链表分割1.7 链表的回文结构1.8 相交链表1.9 判断一个链表中是否有环1.10 寻找环状链表相遇点1.11 链表的深度拷贝 1. 单链表相关练习题 注&#xff1…
阅读更多...
数据结构知识点总结03-(第二章.线性表)-线性表的链式表示、单链表定义及基本操作

数据结构知识点总结03-(第二章.线性表)-线性表的链式表示、单链表定义及基本操作

专栏主页：计算机专业基础知识总结（适用于期末复习考研刷题求职面试）系列文章https://blog.csdn.net/seeker1994/category_12585732.html ...... 数据结构知识点总结04-(第二章.线性表)-双向链表定义、循环单链表、、循环双向链表、静态链表、顺序表与链表的比较 数据结构…
阅读更多...
【leetcode】链表的中间节点

【leetcode】链表的中间节点

大家好&#xff0c;我是苏貝&#xff0c;本篇博客带大家刷题&#xff0c;如果你觉得我写的还不错的话&#xff0c;可以给我一个赞&#x1f44d;吗&#xff0c;感谢❤️ 目录 点击查看题目 思路: slow和fast都初始化为head&#xff0c;之后slow每走1步&#xff0c;fast走2步…
阅读更多...
数据结构之二叉树的精讲

数据结构之二叉树的精讲

&#x1d649;&#x1d65e;&#x1d658;&#x1d65a;!!&#x1f44f;&#x1f3fb;‧✧̣̥̇‧✦&#x1f44f;&#x1f3fb;‧✧̣̥̇‧✦ &#x1f44f;&#x1f3fb;‧✧̣̥̇:Solitary_walk ⸝⋆ ━━━┓ - 个性标签 - &#xff1a;来于“云”的“羽球人”。…
阅读更多...
【leetcode】链表的回文结构

【leetcode】链表的回文结构

大家好&#xff0c;我是苏貝&#xff0c;本篇博客带大家刷题&#xff0c;如果你觉得我写的还不错的话&#xff0c;可以给我一个赞&#x1f44d;吗&#xff0c;感谢❤️ 点击查看题目 思路: 1.找中间节点 找中间节点的方法在下面这个博文中详细提过 【点击进入&#xff1a;【l…
阅读更多...
代码随想录算法训练营第33期day04:第二章 链表 part02

代码随想录算法训练营第33期day04:第二章 链表 part02

24. 两两交换链表中的节点 10分05 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 示例 1&#xff1a; 输入&#xff1a;head …
阅读更多...
leetcode刷题（javaScript）——链表相关场景题总结

leetcode刷题（javaScript）——链表相关场景题总结

链表中的元素在内存中不是顺序存储的&#xff0c;而是通过next指针联系在一起的。常见的链表有单向链表、双向链表、环形链表等 在 JavaScript 刷题中涉及链表的算法有很多&#xff0c;常见的包括&#xff1a; 1. 遍历链表&#xff1a;从头到尾遍历链表&#xff0c;处理每个节点…
阅读更多...
数据结构从入门到精通——栈

数据结构从入门到精通——栈

栈 前言一、栈1.1栈的概念及结构1.2栈的实现1.3栈的面试题 二、栈的具体实现代码栈的初始化栈的销毁入栈出栈返回栈顶元素返回栈中的元素个数检测是否为空Stack.hStack.ctest.c 前言 栈&#xff0c;作为一种后进先出&#xff08;LIFO&#xff09;的数据结构&#xff0c;在计算…
阅读更多...
【C语言】Leetcode 206.反转链表

【C语言】Leetcode 206.反转链表

博主主页&#xff1a;17_Kevin-CSDN博客 收录专栏&#xff1a;《Leetcode》 题目 解决思路 思路一&#xff1a;翻转链表 struct ListNode* reverseList(struct ListNode* head) {if(head NULL){return NULL;}struct ListNode* n1 NULL,*n2 head,*n3 n2 -> next;while(…
阅读更多...
链表（Linked List）算法的使用场景和使用例子详解

链表（Linked List）算法的使用场景和使用例子详解

链表&#xff08;Linked List&#xff09;是一种常见的数据结构&#xff0c;它由一系列节点组成&#xff0c;每个节点包含数据部分和指向下一个节点的指针。链表算法在软件开发程序中有着广泛的应用场景。 链表算法基础知识&#xff1a; 链表算法基础知识主要包括链表的基本概…
阅读更多...
LeetCode142题：环形链表II（python3）

LeetCode142题：环形链表II（python3）

代码思路&#xff1a; 双指针的第一次相遇&#xff1a; 设两指针 fast&#xff0c;slow 指向链表头部 head 。 令 fast 每轮走 2 步&#xff0c;slow 每轮走 1 步。 fast 指针走过链表末端&#xff0c;说明链表无环&#xff0c;此时直接返回 null。 如果链表存在环&#xff0c;…
阅读更多...
链表|面试题 02.07.链表相交

链表|面试题 02.07.链表相交

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {ListNode *l NULL, *s NULL;int lenA 0, lenB 0, gap 0;// 求出两个链表的长度s headA;while (s) {lenA ;s s->next;}s headB;while (s) {lenB ;s s->next;}// 求出两个链表长度差if (lenA &…
阅读更多...
每日OJ题_路径dp①_力扣62. 不同路径

每日OJ题_路径dp①_力扣62. 不同路径

目录 力扣62. 不同路径 解析代码 力扣62. 不同路径 62. 不同路径 难度 中等 一个机器人位于一个 m x n 网格的左上角 &#xff08;起始点在下图中标记为 “Start” &#xff09;。 机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角&#xff08;在下图中标…
阅读更多...
拿捏带头循环双向循环链表

拿捏带头循环双向循环链表

目录 引言 一&#xff1a;结构定义 二&#xff1a;带头循环双向链表的各种操作 1.初始化 2.创建节点 3.尾插 4.头插 5.打印数据 6.判空 7.尾删 8.头删 9.查找 10.销毁 11.pos位置之前插入 12.删除pos位置的值 三&#xff1a;结束语 接下来的日子…
阅读更多...
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点

问题是删除链表的倒数第 n 个节点&#xff0c;并返回链表的头节点。你可以使用两个指针来实现这个目标&#xff0c;一个快指针和一个慢指针。首先&#xff0c;快指针先移动 n 步&#xff0c;然后两个指针同时移动&#xff0c;直到快指针到达链表的末尾。这时&#xff0c;慢指针…
阅读更多...
LeetCode:143.重排链表

LeetCode:143.重排链表

143. 重排链表 解题过程 /*** Definition for singly-linked list.* public class ListNode {* int val;* ListNode next;* ListNode() {}* ListNode(int val) { this.val val; }* ListNode(int val, ListNode next) { this.val val; this.next next; …
阅读更多...
每日OJ题_链表⑤_力扣25. K 个一组翻转链表

每日OJ题_链表⑤_力扣25. K 个一组翻转链表

目录 力扣25. K 个一组翻转链表 解析代码 力扣25. K 个一组翻转链表 25. K 个一组翻转链表 难度 困难 给你链表的头节点 head &#xff0c;每 k 个节点一组进行翻转&#xff0c;请你返回修改后的链表。 k 是一个正整数&#xff0c;它的值小于或等于链表的长度。如果节点总…
阅读更多...
力扣中档题的简单写法：在链表中插入最大公约数

力扣中档题的简单写法：在链表中插入最大公约数

其实暴力遍历开数组也可以&#xff0c;但不如以下新建链表块的方法简单 int FindCommDivisor(int num1, int num2) {int n;int i;n fmin(num1, num2);for (i n; i > 1; i--) {if (num1 % i 0 && num2 % i 0) {return i;}}return 0; }struct ListNode *insertGr…
阅读更多...
数据结构系列-链表实现

数据结构系列-链表实现

&#x1f308;个人主页: 会编辑的果子君 &#x1f4ab;个人格言:“成为自己未来的主人~” #define _CRT_SECURE_NO_WARNINGS #include"List.h" void ListTest01() {LTNode* plist LTInit();LTPushFront(plist, 1);LTPushFront(plist, 2);LTPushFront(plist, 3);…
阅读更多...
用链表实现顺序表的插入和删除操作（操作封装在函数中）

用链表实现顺序表的插入和删除操作（操作封装在函数中）

#include <iostream> using namespace std; struct node{int val;node * next; }; void print(node * head){if(headNULL ||head->nextNULL){cout<<"链表中已经无元素";return;}cout<<"打印列表:";node * phead->next;while(p){co…
阅读更多...
ZJGSU 1738 链表查找（线性表）（一些恶心的手搓链表题）

ZJGSU 1738 链表查找（线性表）（一些恶心的手搓链表题）

已知非空线性链表由list指出&#xff0c;链结点的构造为&#xff08;data,link&#xff09;.请写一算法&#xff0c;将链表中数据域值最小的那个链结点移到链表的最前面。要求&#xff1a;不得额外申请新的链结点 输入样例 1 点击复制 5 11 6 8 7 9 输出样例 1 6 11 8 7 9…
阅读更多...
链表——单链表的C实现（保姆级代码、注释教学）

链表——单链表的C实现（保姆级代码、注释教学）

首先需要借助三个文件 SList.h SList.c test.c 目录 SList.h &#xff1a;用来建立结构体、头文件、函数声明、全局变量建立 SList.c&#xff1a;对头文件中声明的函数的实现 void SLTPrint(SLTNode* phead) SLTNode* BuyLTNode(SLTDataType x) voi…
阅读更多...
[LeetCode][426]【学习日记】将二叉搜索树转化为排序的双向链表——前驱节点pre 和 当前节点cur 的使用

[LeetCode][426]【学习日记】将二叉搜索树转化为排序的双向链表——前驱节点pre 和 当前节点cur 的使用

题目 426. 将二叉搜索树转化为排序的双向链表 将一个 二叉搜索树 就地转化为一个 已排序的双向循环链表 。 对于双向循环列表&#xff0c;你可以将左右孩子指针作为双向循环链表的前驱和后继指针&#xff0c;第一个节点的前驱是最后一个节点&#xff0c;最后一个节点的后继是第…
阅读更多...
刷题第3天（中等题）：LeetCode707--设计链表--练习单链表和双链表的增删查操作

刷题第3天（中等题）：LeetCode707--设计链表--练习单链表和双链表的增删查操作

LeetCode707: 你可以选择使用单链表或者双链表&#xff0c;设计并实现自己的链表。 单链表中的节点应该具备两个属性&#xff1a;val 和 next 。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。 如果是双向链表&#xff0c;则还需要属性 prev 以指示链表…
阅读更多...
字节算法-链表翻转与变形

字节算法-链表翻转与变形

文章目录 题目与变形解法 题目与变形 字节一面中关于 K个一组链表反转 的题目变形。 K个一组链表反转。K个一组链表反转&#xff0c;链表尾不足K个的元素也需要反转。K个一组链表反转&#xff0c;但是从链表尾部开始反转。反转从位置 left 到位置 right 的链表节点 解法 四…
阅读更多...
9实现操作系统里面的链表结构

9实现操作系统里面的链表结构

为了方便后面进程切换之类的,需要就绪队列,阻塞队列等所以需要链表数据结构 //D:\code\x86\code\start\start\source\kernel\include\tools\list.h #ifndef LIST_H #define LIST_H// 已知结构体中的某个字段的指针&#xff0c;求所在结构体的指针 // 例如&#xff1a; // struc…
阅读更多...
算法：数据结构链表的增删查

算法：数据结构链表的增删查

输入3 4 5 6 7 9999一串整数&#xff0c;9999代表结束&#xff0c;通过尾插法新建链表&#xff0c;查找第二个位置的值并输出&#xff0c;在2个位置插入99&#xff0c;输出为 3 99 4 5 6 7&#xff0c;删除第4个位置的值&#xff0c;打印输出为 3 99 4 6 7。 #include…
阅读更多...
C语言经典面试题目（十二）

C语言经典面试题目（十二）

1、如何在C语言中实现栈和队列数据结构&#xff1f; 栈&#xff08;Stack&#xff09;&#xff1a; 栈是一种后进先出&#xff08;LIFO&#xff09;的数据结构&#xff0c;可以使用数组或链表来实现。以下是一个使用数组实现的简单栈的示例&#xff1a; #define MAX_SIZE 10…
阅读更多...
力扣24. 两两交换链表中的节点

力扣24. 两两交换链表中的节点

新建虚拟头节点&#xff0c;用3个指针记录前3个节点&#xff0c;然后再相互赋值指向&#xff0c;再移动当前节点&#xff0c;当前节点所在的位置&#xff0c;只能交换该节点的后两个节点&#xff08;所以必须建立虚拟头节点&#xff0c;才能操作第1&#xff0c;2个节点&#xf…
阅读更多...
数据结构的美之链表和树

数据结构的美之链表和树

有种感觉叫做&#xff0c;不同的场景&#xff0c;应用不同的数据结构和算法&#xff0c;可以大大滴优化增删改查以及存储方面等等的性能。笔者这里呢也是在最近复习准备面试的时候&#xff0c;去阅读源码&#xff0c;觉得设计这种数据结构和引用的人真的是非常牛逼&#xff0c;…
阅读更多...
【Leetcode每日一题】 递归 - 两两交换链表中的节点（难度⭐）（38）

【Leetcode每日一题】 递归 - 两两交换链表中的节点（难度⭐）（38）

1. 题目解析 题目链接&#xff1a;24. 两两交换链表中的节点 这个问题的理解其实相当简单&#xff0c;只需看一下示例&#xff0c;基本就能明白其含义了。 2.算法原理 一、理解递归函数的含义 首先&#xff0c;我们需要明确递归函数的任务&#xff1a;给定一个链表&#xf…
阅读更多...
力扣203. 移除链表元素

力扣203. 移除链表元素

写法1、头节点 和 后面的节点 删除规则不一致 class Solution {public ListNode removeElements(ListNode head, int val) {//如果不建虚拟头节点&#xff0c;那删头节点和删后面的节点&#xff0c;逻辑是不一样的//头节点可能连续多个命中val,所以有while&#xff0c;不是ifwh…
阅读更多...
单向链表——数据结构——day01

单向链表——数据结构——day01

今天主要了解了数据结构&#xff0c;什么叫数据结构&#xff0c;以及数据结构中的单向链表 数据结构 1.数据结构的定义&#xff1a;一组用来保存一种或者多种特定关系的数据的集合&#xff08;组织和存储数据&#xff09;程序的设计&#xff1a;将现实中大量而复杂的问题以特…
阅读更多...
【华为OD机试】找座位【C卷|100分】

【华为OD机试】找座位【C卷|100分】

【华为OD机试】-真题 !!点这里！！ 【华为OD机试】真题考点分类 !!点这里 !! 题目描述 在一个大型体育场内举办了一场大型活动，由于疫情防控的需要， 要求每位观众的必须间隔至少一个空位才允许落座。 现在给出一排观众座位分布图，座位中存在已落座的观众，请计算出， 在不移…
阅读更多...
二叉搜索树题目：将有序链表转换为二叉搜索树

二叉搜索树题目：将有序链表转换为二叉搜索树

文章目录 题目标题和出处难度题目描述要求示例数据范围 前言解法一思路和算法代码复杂度分析 解法二思路和算法代码复杂度分析 题目 标题和出处 标题&#xff1a;将有序链表转换为二叉搜索树 出处&#xff1a;109. 将有序链表转换为二叉搜索树 难度 5 级 题目描述 要求 …
阅读更多...
嵌入式学习第二十九天！（数据结构的概念、单向链表）

嵌入式学习第二十九天！（数据结构的概念、单向链表）

数据结构&#xff1a; 1. 定义&#xff1a; 一组用来保存一种或者多种特定关系的数据的集合&#xff08;组织和存储数据&#xff09; 1. 程序设计&#xff1a; 将现实中大量而复杂的问题以特定的数据类型和特定的数据结构存储在内存中&#xff0c;并在此基础上实现某个特定的功…
阅读更多...
【Leetcode-19.删除链表的第N个节点】

【Leetcode-19.删除链表的第N个节点】

题目详情&#xff1a; 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5]示例 2&#xff1a; 输入&#xff1a;head [1], n 1 输出&#xff1…
阅读更多...
第十四届蓝桥杯省赛C++B组题解

第十四届蓝桥杯省赛C++B组题解

考点 暴力枚举&#xff0c;搜索&#xff0c;数学&#xff0c;二分&#xff0c;前缀和&#xff0c;简单DP&#xff0c;优先队列&#xff0c;链表&#xff0c;LCA&#xff0c;树上差分 A 日期统计 暴力枚举&#xff1a; #include<bits/stdc.h> using namespace std; int …
阅读更多...
内存泄漏检测、单向链表的操作

内存泄漏检测、单向链表的操作

我要成为嵌入式高手之3月19日数据结构第二天&#xff01;&#xff01; ———————————————————————————— valgrind内存测试工具 让虚拟机上网、在虚拟机上下载软件&#xff0c;参考笔记&#xff1a; 我要成为嵌入式高手之2月3日Linux高编第一天&am…
阅读更多...
嵌入式驱动学习第三周——linux内核链表

嵌入式驱动学习第三周——linux内核链表

前言 在 Linux 内核中使用最多的数据结构就是链表了&#xff0c;其中就包含了许多高级思想。 比如面向对象、类似C模板的实现、堆和栈的实现。 嵌入式驱动学习专栏将详细记录博主学习驱动的详细过程&#xff0c;未来预计四个月将高强度更新本专栏&#xff0c;喜欢的可以关注本博…
阅读更多...
数据结构 --- 复杂度概念及计算讲解（时间复杂度，空间复杂度）

数据结构 --- 复杂度概念及计算讲解（时间复杂度，空间复杂度）

今天没有sao话&#xff0c;今天认真学习 一、时间复杂度 1、概念讲解 2、计算讲解 二、空间复杂度 1、概念讲解 2、计算讲解 三、常见复杂度对比 四、完结撒❀ 前言&#xff1a; 经常刷题的人都知道&#xff0c;我们在解决一道题时可能有多个解法&#xff0c;那么如何…
阅读更多...
【c语言篇】每日一题-pta-实验11-2-9 链表逆置

【c语言篇】每日一题-pta-实验11-2-9 链表逆置

题目如下&#xff1a; 裁判测试程序样例&#xff1a; #include <stdio.h> #include <stdlib.h>struct ListNode {int data;struct ListNode *next; };struct ListNode *createlist(); /*裁判实现&#xff0c;细节不表*/ struct ListNode *reverse( struct ListNod…
阅读更多...
链表取反、查找中间值、删除倒数第几个值、删除链表指定数据的结点、插入排序——数据结构——day02

链表取反、查找中间值、删除倒数第几个值、删除链表指定数据的结点、插入排序——数据结构——day02

建议和上一篇一起看 链表取反 void reverse_link(LINK_LIST *plist) {if (is_empty_link(plist)) //首先查看链表是否为空{return ;}LINK_NODE *pinsert NULL;LINK_NODE *ptmp plist->phead;plist->phead NULL;while (ptmp ! NULL){pinsert ptmp;ptmp ptmp->pn…
阅读更多...
数据结构-单向链表-002

数据结构-单向链表-002

1无头单向链表 2有头单向链表 2.1链表结点结构体定义 typedef struct link_node {int data;//数据域struct link_node *pnext;//指向下一个结点的指针 }NODE;2.2链表头结点结构体定义 typedef struct link_lable{NODE *pnext;//指向首节点的指针int clen;//记录链表节点数量…
阅读更多...
逆序数据建立链表

逆序数据建立链表

本题要求实现一个函数&#xff0c;按输入数据的逆序建立一个链表。 函数接口定义&#xff1a; struct ListNode *createlist(); 函数createlist利用scanf从输入中获取一系列正整数&#xff0c;当读到−1时表示输入结束。按输入数据的逆序建立一个链表&#xff0c;并返回链表…
阅读更多...
206.翻转链表

206.翻转链表

给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&#xff1a; 输入&#xff1a;head [1,2] 输出&#xff1a;[2,1]示例 3&#xff1a; 输入&#xff1a;head [] 输…
阅读更多...
面试算法-56-二叉树展开为链表

面试算法-56-二叉树展开为链表

题目 给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左子指针始终为 null 。 展开后的单链表应该与二叉树 先序遍历 顺序相同。 示例 1…
阅读更多...
反转链表综合（力扣）

反转链表综合（力扣）

206. 反转链表 代码 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(int x) : val(x), next(nullptr) {}* ListNode(int x, ListNode *next) : val(x), nex…
阅读更多...
手撕算法-二叉搜索树与双向链表

手撕算法-二叉搜索树与双向链表

牛客BM30。 描述&#xff1a;https://www.nowcoder.com/practice/947f6eb80d944a84850b0538bf0ec3a5?tpId295&tqId23253&ru/exam/oj&qru/ta/format-top101/question-ranking&sourceUrl%2Fexam%2Foj分析&#xff1a;二叉搜索树的中序遍历是递增序列。可以利用…
阅读更多...
119.设计链表（力扣）

119.设计链表（力扣）

代码解决 class MyLinkedList { public:// 定义链表节点结构体struct LinkedNode {int val;LinkedNode* next;LinkedNode(int val):val(val), next(nullptr){}};MyLinkedList() {dummyhead new LinkedNode(0);size0;}int get(int index) {if (index > (size - 1) || index…
阅读更多...
带头循环双向链表的实现

带头循环双向链表的实现

文章目录 带头循环双向链表的实现头文件接口函数完整代码 带头循环双向链表的实现 文章文章代码解析在代码块的注释中。 头文件 我们将代码分为三个文件实现&#xff0c;分别为&#xff1a; List.h: 包含所有需要的头文件&#xff0c;定义以及接口函数的声明。 List.c: 保…
阅读更多...
Day 3.双向链表

Day 3.双向链表

双向链表 为什么在有时候销毁掉链表时会显示多销毁出一块空间&#xff1f; 定义链表的结构体类型 /* 学生信息结构体 */ typedef struct student {int id;char name[32];int score;}DATA_STU;/* 结点 */ typedef struct node {DATA_STU data;struct node *ppre; //前驱…
阅读更多...
顺序表和链表的比较（详解）

顺序表和链表的比较（详解）

一. 存储结构 顺序表和链表都属于线性表&#xff0c;逻辑上是线性结构&#xff0c;但是物理结构上&#xff0c;顺序表物理结构是&#xff08;内存空间&#xff09;连续的&#xff0c;而链表不是&#xff08;内存空间&#xff09;连续的 这样的结构差异就造成了顺序表支持按下标…
阅读更多...
c++中list的简单实现

c++中list的简单实现

文章目录 list介绍节点类(listNode)__list__iterator(迭代器类)operator-> list的成员函数empty_init() 初始化节点list(list<T>& lt) 拷贝构造clear() 清除链表~list() 析构insert() 插入erase() 删除push_back() 尾插push_front() 头插pop_back() 尾删pop_front…
阅读更多...
Java 数据结构之链表

Java 数据结构之链表

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {if (headA null || headB null) return null;ListNode pA headA, pB headB;while (pA ! pB) {pA pA null ? headB : pA.next;pB pB null ? headA : pB.next;}return pA;} public ListNode rev…
阅读更多...
基于Python3的数据结构与算法 - 16 链表

基于Python3的数据结构与算法 - 16 链表

目录 链表 1. 创建链表 2. 链表的插入和删除 3. 双链表 4. 链表总结 链表 链表是由一系列节点组成的元素集合。每个节点包含两部分&#xff0c;数据域item和指向下一个节点得指针next。通过节点之间的相互连接&#xff0c;最终串联成一个链表。 class Node:def __init…
阅读更多...
面试算法-39-删除链表的倒数第 N 个结点

面试算法-39-删除链表的倒数第 N 个结点

题目 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] 解 class Solution {public ListNode removeNthFromEnd(ListNode head, int n) {L…
阅读更多...
链表递归-leetcode两两交换相邻链表中的结点

链表递归-leetcode两两交换相邻链表中的结点

两两交换相邻链表中的结点 题目&#xff1a; 给定一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后的链表。 你不能只是单纯的改变节点内部的值&#xff0c;而是需要实际的进行节点交换。 示例1 输入&#xff1a;head [1,2,3,4] 输出&#xff1a;[2,1…
阅读更多...
【每日算法】理论：图像分割相关 刷题：设计链表

【每日算法】理论：图像分割相关 刷题：设计链表

上期文章 【每日算法】理论&#xff1a;AIGC微调技术 刷题&#xff1a;滑动窗口、循环 文章目录 上期文章一、上期问题二、理论问题1、变形自注意力模块的特别之处2、GroundingDino模型的损失函数是什么&#xff1f;3、Dice Loss4、UNet的网络架构5、VQVAE模型相对于VAE的改进…
阅读更多...
【算法刷题day3】Leetcode: 203.移除链表元素、707.设计链表、 206.反转链表

【算法刷题day3】Leetcode: 203.移除链表元素、707.设计链表、 206.反转链表

链表基础知识 分类&#xff1a; 单链表、双链表、循环连链表 存储方式&#xff1a; 链表中的节点在内存中不是连续分布的 &#xff0c;而是散乱分布在内存中的某地址上&#xff0c;分配机制取决于操作系统的内存管理。 链表的定义&#xff1a; struct ListNode{int val; //节…
阅读更多...
【算法刷题day4】Leetcode:24. 两两交换链表中的节点、19.删除链表的倒数第N个节点、面试题 02.07. 链表相交、142.环形链表II

【算法刷题day4】Leetcode:24. 两两交换链表中的节点、19.删除链表的倒数第N个节点、面试题 02.07. 链表相交、142.环形链表II

24. 两两交换链表中的节点 文档链接&#xff1a;[代码随想录] 题目链接&#xff1a;24. 两两交换链表中的节点 状态&#xff1a;ok 题目&#xff1a; 给定一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后的链表。 你不能只是单纯的改变节点内部的值&#…
阅读更多...
【STL】stack栈容器与list链表容器

【STL】stack栈容器与list链表容器

1.栈stack 栈具有先进后出的特性&#xff0c;最先进入的数据压在最底下&#xff0c;最后出来 2.list链表容器 list链表容器是一种双向链表&#xff0c;两端都可插入与删除&#xff0c;是双向访问迭代器&#xff0c;与vertor随机访问迭代器有不同的区别 reverse&#xff08;&…
阅读更多...
wpa_supplicant 扫描不全问题处理--链表学习

wpa_supplicant 扫描不全问题处理--链表学习

最近遇到一个wpa_supplicant 多次扫描后扫描结果未按照顺序进行排列的问题，这里针对扫描结果的链表进行排序，达到扫描列表根据rssi进行排序的效果 -----再牛逼的梦想，也抵不住傻逼般的坚持！ --2024-03-22 11:21 一、问题背景 当周边存在大量ap热点时，通过wpa_supplican…
阅读更多...
【剑指offer】17. 从尾到头打印链表（java选手）

【剑指offer】17. 从尾到头打印链表（java选手）

题目链接 题目链接 题目描述 输入一个链表的头结点&#xff0c;按照 从尾到头 的顺序返回节点的值。 返回的结果用数组存储。 数据范围 0≤ 链表长度 ≤1000。 样例 输入&#xff1a;[2, 3, 5] 返回&#xff1a;[5, 3, 2] 思路 &#xff08;1&#xff09;从头到尾遍历链…
阅读更多...
【数据结构】猛猛干7道链表OJ

【数据结构】猛猛干7道链表OJ

前言知识点 链表的调试技巧 int main() {struct ListNode* n1(struct ListNode*)malloc(sizeof(struct ListNode));assert(n1);struct ListNode* n2(struct ListNode*)malloc(sizeof(struct ListNode));assert(n2);struct ListNode* n3(struct ListNode*)malloc(sizeof(struc…
阅读更多...
链表oj测试题（上）

链表oj测试题（上）

链表的申明&#xff1a; struct ListNode {int val;struct ListNode* next; }; 1.题1 删除指定元素 例如&#xff1a;链表1 2 6 3 4 5 6&#xff0c;然后选择删除元素6&#xff0c;返回的链表为1 2 3 4 5 。 代码演示&#xff1a; typedef struct ListNode ListNode;List…
阅读更多...
相交链表：寻找链表的公共节点

相交链表：寻找链表的公共节点

目录 一、公共节点 二、题目 三、思路 四、代码 五、代码解析 1.计算长度 2.等长处理 3.判断 六、注意点 1.leetcode的尿性 2.仔细观察样例 3.经验总结 一、公共节点 链表不会像两直线相交一样&#xff0c;相交之后再分开。 由于单链表只有一个next指针&#xff0…
阅读更多...
每日一题 --- 设计链表[力扣][Go]

每日一题 --- 设计链表[力扣][Go]

设计链表 题目&#xff1a;707. 设计链表 你可以选择使用单链表或者双链表&#xff0c;设计并实现自己的链表。 单链表中的节点应该具备两个属性&#xff1a;val 和 next 。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。 如果是双向链表&#xff0c;则…
阅读更多...
面试算法-78-两两交换链表中的节点

面试算法-78-两两交换链表中的节点

题目 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4] 输出&#xff…
阅读更多...
算法系列--链表刷题(二)

算法系列--链表刷题(二)

&#x1f495;"轻舟已过万重山"&#x1f495; 作者&#xff1a;Mylvzi 文章主要内容&#xff1a;算法系列–链表刷题(二) 今天为大家带来的是算法系列--链表刷题(二),带来了几道经典的有关链表的面试题(合并K个有序列表) 1.两数相加 https://leetcode.cn/problems/a…
阅读更多...
二叉树（链表实现）

二叉树（链表实现）

二叉树链式结构的实现 二叉树的遍历 1. 前序、中序以及后序遍历 学习二叉树结构&#xff0c;最简单的方式就是遍历。 所谓二叉树遍历(Traversal)是按照某种特定的规则&#xff0c;依次对二叉树中的节点进行相应的操作&#xff0c;并且每个节点只操作一次。访问结点所做的操作依…
阅读更多...
数据结构——双向链表（C语言版）

数据结构——双向链表（C语言版）

上一章&#xff1a;数据结构——单向链表&#xff08;C语言版&#xff09;-CSDN博客 目录 什么是双向链表&#xff1f; 双向链表的节点结构 双向链表的基本操作 完整的双向链表示例 总结 什么是双向链表&#xff1f; 双向链表是一种常见的数据结构&#xff0c;它由一系列节…
阅读更多...
力扣---随机链表的复制

力扣---随机链表的复制

给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节点的值。新节点的 n…
阅读更多...
Rust 双向链表 LinkedList 和安全删除元素的方法

Rust 双向链表 LinkedList 和安全删除元素的方法

一、LinkedList 基本用法 在Rust中&#xff0c;LinkedList 是标准库中 std::collections 模块提供的一个双向链表实现。这个双向链表在每个节点中都保存了其前一个和后一个节点的引用&#xff0c;允许在链表的任一端进行有效的添加和移除操作。 以下是一个简单的示例&#xf…
阅读更多...
数据结构-双向链表-003

数据结构-双向链表-003

1双向链表 1.1链表结点结构体定义 typedef struct student_data {char name[32];char sex;int age; }STU_DATA;typedef struct double_link_node {STU_DATA data;//数据域struct double_link_node *ppre;//指向上一个结点的指针struct double_link_node *pnext;//指向下一个结…
阅读更多...
[leetcode] 138. 随机链表的复制

[leetcode] 138. 随机链表的复制

给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&#xff0c;其中每个新节点的值都设为其对应的原节点的值。新节点的 n…
阅读更多...
数据结构--链表刷题(一)快慢指针

数据结构--链表刷题(一)快慢指针

1.快慢指针 先看一道简单的题目&#xff1a;返回中间结点 这道题有一个最朴素的做法就是先遍历一边链表&#xff0c;设置计数器求出链表长度&#xff0c;再重新走1/2的链表长度&#xff0c;即可返回中间节点 // 第二种解法 //这种解法需要遍历两次链表ListNode cur1 head;int…
阅读更多...
C++ 简单模拟实现 STL 中的 list 与 queue

C++ 简单模拟实现 STL 中的 list 与 queue

目录 一&#xff0c;list 1&#xff0c; list 的节点与迭代器 2&#xff0c;list 的数据结构、一些简单的功能、构造函数 3&#xff0c;list 的对元素操作 4&#xff0c;C 11 的一些功能 5&#xff0c;完整代码&#xff1a; 二&#xff0c;queue 一&#xff0c;list std…
阅读更多...
【链表】Leetcode 146. LRU 缓存【中等】

【链表】Leetcode 146. LRU 缓存【中等】

LRU 缓存 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类&#xff1a; LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存int get(int key) 如果关键字 key 存在于缓存中&#xff0c;则返回关键字的值&#xff0c;否…
阅读更多...
【数据结构】非线性结构——二叉树

【数据结构】非线性结构——二叉树

文章目录 前言1.树型结构1.1树的概念1.2树的特性1.3树的一些性质1.4树的一些表示形式1.5树的应用2.二叉树 2.1 概念2.2 两种特殊的二叉树2.3 二叉树的性质2.4 二叉树的存储2.5 二叉树的基本操作 前言 前面我们都是学的线性结构的数据结构&#xff0c;接下来我们就需要来学习非…
阅读更多...
哨兵位、链表的链接

哨兵位、链表的链接

哨兵位&#xff1a; 通俗的话讲就是额外开辟一块空间&#xff0c;指向链表的头部。 合并两个有序链表 已解答 简单 相关标签 相关企业 将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例 1&#xff1a; 输入&#…
阅读更多...
用指针处理链表(二)

用指针处理链表(二)

4建立动态链表 所谓建立动态链表是指在程序执行过程中从无到有地建立起一个链表&#xff0c;即一个一个地开辟结点和输入各结点数据,并建立起前后相链的关系。 例11.8 写一函数建立一个有3名学生数据的单向动态链表。 先考虑实现此要求的算法(见图11.12)。 设3个指针变量:he…
阅读更多...
面试算法-103-对链表进行插入排序

面试算法-103-对链表进行插入排序

题目 给定单个链表的头 head &#xff0c;使用 插入排序 对链表进行排序&#xff0c;并返回 排序后链表的头 。 插入排序 算法的步骤: 插入排序是迭代的&#xff0c;每次只移动一个元素&#xff0c;直到所有元素可以形成一个有序的输出列表。 每次迭代中&#xff0c;插入排序…
阅读更多...
力扣链表（反转、有无环）

力扣链表（反转、有无环）

LCR 024. 反转链表 给定单链表的头节点 head &#xff0c;请反转链表&#xff0c;并返回反转后的链表的头节点。 当我们谈论反转单链表时&#xff0c;我们指的是改变链表中元素的链接方向&#xff0c;使得链表的最后一个节点成为头节点&#xff0c;原本的头节点成为最后一个节…
阅读更多...
【华为OD机试】查找接口成功率最优时间段【C卷|100分】

【华为OD机试】查找接口成功率最优时间段【C卷|100分】

【华为OD机试】-真题 !!点这里！！ 【华为OD机试】真题考点分类 !!点这里 !! 题目描述 服务之间交换的接口成功率作为服务调用关键质量特性，某个时间段内的接口失败率使用一个数组表示， 数组中每个元素都是单位时间内失败率数值，数组中的数值为0~100的整数， 给定一个数值(…
阅读更多...
C++ Lists（链表）基本用法

C++ Lists（链表）基本用法

Lists将元素按顺序储存在链表中&#xff0c;与向量(vectors)相比&#xff0c;它允许快速的插入和删除&#xff0c;但是随机访问却比较慢。以下是Lists的一些基本用法&#xff1a; 1. assign 语法&#xff1a; void assign(input_iterator start, input_iterator end); void a…
阅读更多...
【nowCoder】判断链表中是否有环(Java自用版)

【nowCoder】判断链表中是否有环(Java自用版)

快慢指针 public class Solution {public boolean hasCycle(ListNode head) {ListNode fast head;ListNode slow head;while (fast ! null && fast.next ! null) {slow slow.next;fast fast.next.next;if (fast slow) {return true;}}return false;} }这段代码是…
阅读更多...
每日一题 --- 两两交换链表中的节点[力扣][Go]

每日一题 --- 两两交换链表中的节点[力扣][Go]

两两交换链表中的节点 题目&#xff1a;24. 两两交换链表中的节点 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 示例 1&a…
阅读更多...
数据结构进阶篇 之 【二叉树顺序（堆）】的整体实现讲解（赋完整实现代码）

数据结构进阶篇 之 【二叉树顺序（堆）】的整体实现讲解（赋完整实现代码）

做人要谦虚&#xff0c;多听听别人的意见&#xff0c;然后记录下来&#xff0c;看看谁对你有意见 一、二叉树的顺序&#xff08;堆&#xff09;结构及实现 1.二叉树的顺序结构 2.堆的概念及结构 3.堆的实现 3.1 向下调整算法 AdJustDown 3.2 向上调整算法 AdJustUP 3.3 …
阅读更多...
数据结构进阶篇 之 【二叉树顺序存储（堆）】的整体实现讲解（赋完整实现代码）

数据结构进阶篇 之 【二叉树顺序存储（堆）】的整体实现讲解（赋完整实现代码）

做人要谦虚&#xff0c;多听听别人的意见&#xff0c;然后记录下来&#xff0c;看看谁对你有意见 一、二叉树的顺序&#xff08;堆&#xff09;结构及实现 1.二叉树的顺序结构 2.堆的概念及结构 3.堆的实现 3.1 向下调整算法 AdJustDown 3.2 向上调整算法 AdJustUP 3.3 …
阅读更多...
Collection与数据结构 链表与LinkedList (一):链表概述与单向无头非循环链表实现

Collection与数据结构 链表与LinkedList (一):链表概述与单向无头非循环链表实现

1.ArrayList的缺点 上篇文章我们已经对顺序表进行了实现,并且对ArrayList进行了使用,我们知道ArrayList底层是使用数组实现的. 由于其底层是一段连续空间&#xff0c;当在ArrayList任意位置插入或者删除元素时&#xff0c;就需要将后序元素整体往前或者往后搬移&#xff0c;时…
阅读更多...
每日一题--- 环形链表[力扣][Go]

每日一题--- 环形链表[力扣][Go]

环形链表 题目&#xff1a;142. 环形链表 II 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给…
阅读更多...
数据结构（四）顺序表与链表的深层次讲解

数据结构（四）顺序表与链表的深层次讲解

我们在数据结构&#xff08;二&#xff09;&#xff0c;对链表和顺序表已经讲解过了。但很多同学表示有点晦涩难懂那我就出一篇深层次讲解&#xff0c;一步一步来带领大家学习。 我们从头&#xff08;数据结构&#xff09;开始完整的来为大家讲解&#xff0c;大家好好看好好学。…
阅读更多...
爱上数据结构：顺序表和链表

爱上数据结构：顺序表和链表

一、线性表 线性表&#xff08;linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使 用的数据结构&#xff0c;常见的线性表&#xff1a;顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构&#xff0c;也就说是连续的一条…
阅读更多...
移除链表元素 C++

移除链表元素 C++

1、题目描述 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 2、代码 一、使用虚拟头结点 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode…
阅读更多...
【数据结构】双向链表及LRU缓存的实现

【数据结构】双向链表及LRU缓存的实现

目录 前言 1. 在原有的自定义链表类 Linked 的基础上&#xff0c;添加新的 “节点添加”方法 addNode(Node node) 测试用例 测试结果 2. 在自定义链表类的基础上&#xff0c;使用双重循环“强力” 判断两个节点是否发生相交 测试用例 测试结果 3. 在自定义链表类的基础上…
阅读更多...
用C语言链表实现图书管理

用C语言链表实现图书管理

#include <stdio.h> #include <stdlib.h> #include <string.h> struct ListNode {int val;//编号char title[50];//书名float price;//价格struct ListNode* next; };// 在尾部插入节点 struct ListNode* insertAtTail(struct ListNode* head, int val,char …
阅读更多...
数据结构：6、栈

数据结构：6、栈

一、栈的概念 栈&#xff1a;一种特殊的线性表&#xff0c;其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端 称为栈顶&#xff0c;另一端称为栈底。栈中的数据元素遵守后进先出LIFO&#xff08;Last In First Out&#xff09;的原则。 压栈&#x…
阅读更多...
数据结构：8、堆

数据结构：8、堆

一、树的概念 树是一种非线性的数据结构&#xff0c;它是由n&#xff08;n>0&#xff09;个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树&#xff0c;也就是说它是根朝上&#xff0c;而叶朝下的。 有一个特殊的结点&#xff0c;称为根结点…
阅读更多...
数据结构-链表（二）

数据结构-链表（二）

1.两两交换列表中的节点 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交换&#xff09;。 输入&#xff1a;head [1,2,3,4] 输出&#xff1a;[2…
阅读更多...
链表学习（java、python）

链表学习（java、python）

目录 链表的定义例题1 删除某个值例题2 翻转链表例题3 翻转两个结点例题4 删除链表的倒数第 N 个结点 链表的定义 public class ListNode {int val;ListNode next;public ListNode(){}public ListNode(int val){this.valval;}public ListNode(int val,ListNode next){this.val…
阅读更多...
【LeetCode热题100】142. 环形链表 II（链表）

【LeetCode热题100】142. 环形链表 II（链表）

一.题目要求 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统…
阅读更多...
链表详解-leetcode203.移除链表元素

链表详解-leetcode203.移除链表元素

链表 移除链表元素 题目&#xff1a; 题意&#xff1a;删除链表中等于给定值 val 的所有节点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5] 示例 2&#xff1a; 输入&#xff1a;head [], val 1 输出&#xff1a;[…
阅读更多...
代码随想录算法训练营第三天|203.移除链表元素

代码随想录算法训练营第三天|203.移除链表元素

题目&#xff1a; 203. 移除链表元素 已解答 简单 相关标签 相关企业 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val …
阅读更多...
leetcode:反转链表II 和k个一组反转链表的C++实现

leetcode:反转链表II 和k个一组反转链表的C++实现

反转链表II 问题描述 给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 ListNode* reverseBetween(ListNode* head, int left, int right) {ListNode *…
阅读更多...
【嵌入式高级C语言】9：万能型链表懒人手册

【嵌入式高级C语言】9：万能型链表懒人手册

文章目录 序言单向不循环链表拼图框架搭建 - Necessary功能拼图块1 创建链表头信息结构体 - Necessary2 链表头部插入 - Optional3 链表的遍历 - Optional4 链表的销毁 - Necessary5 链表头信息结构体销毁 - Necessary6 获取链表中节点的个数 - Optional7 链表尾部插入 - Optio…
阅读更多...
算法刷题Day3 | 203.移除链表元素、707.设计链表、206.反转链表

算法刷题Day3 | 203.移除链表元素、707.设计链表、206.反转链表

目录 0 容易被大家忽略的问题1 移除链表元素1.1 开始的错误解题1.2 头结点和头指针的区别1.2.1 区别1.2.2 思考 1.3 正确的题解1.3.1 直接移除法1.3.2 添加虚拟头节点辅助移除法1.3.3 总结 2 设计链表2.1 我的解题 3 反转链表3.1 我的解题3.2 其他方法&#xff08;双指针法、递…
阅读更多...
【数据结构】单向链表的创建及4种应用

【数据结构】单向链表的创建及4种应用

目录 前言 自定义“单向”链表类 1. 自定义一个链表类&#xff0c;并完成“初始化链表”、“添加元素&#xff08;头插法/尾插法&#xff09;”、“计算链表长度”操作&#xff1b; 自定义链表 向链表中插入元素&#xff08;头插法&#xff09; 向链表中插入元素&#xf…
阅读更多...
探索数据结构：双向链表的灵活优势

探索数据结构：双向链表的灵活优势

✨✨ 欢迎大家来到贝蒂大讲堂✨✨ &#x1f388;&#x1f388;养成好习惯&#xff0c;先赞后看哦~&#x1f388;&#x1f388; 所属专栏&#xff1a;数据结构与算法 贝蒂的主页&#xff1a;Betty’s blog 1. 前言 前面我们学习了单链表&#xff0c;它解决了顺序表中插入删除需…
阅读更多...
刨析数据结构（三）

刨析数据结构（三）

&#x1f308;个人主页&#xff1a;小田爱学编程 &#x1f525; 系列专栏&#xff1a;数据结构-带你无脑刨析 &#x1f3c6;&#x1f3c6;关注博主&#xff0c;随时获取更多关于IT的优质内容&#xff01;&#x1f3c6;&#x1f3c6; &#x1f600;欢迎来到小田代码世界~ &…
阅读更多...
每日OJ题_链表④_力扣23. 合并 K 个升序链表（小根堆_归并）

每日OJ题_链表④_力扣23. 合并 K 个升序链表（小根堆_归并）

目录 力扣23. 合并 K 个升序链表 解析代码1&#xff08;小根堆优化&#xff09; 解析代码2&#xff08;递归_归并&#xff09; 力扣23. 合并 K 个升序链表 23. 合并 K 个升序链表 难度 困难 给你一个链表数组&#xff0c;每个链表都已经按升序排列。 请你将所有链表合并…
阅读更多...
答题01 单链表打印

答题01 单链表打印

今天心情不太好&#xff0c;跑出来答疑了&#xff0c;其中需要很长篇幅的回答&#xff0c;或者对我现阶段有帮助的问题会单列一个博文~&#x1f95d;&#x1f95d; 第1版&#xff1a;更改代码~&#x1f9e9;&#x1f9e9; 编辑&#xff1a;梅头脑&#x1f338; 审核&#xf…
阅读更多...
数据结构（二）顺序表和链表

数据结构（二）顺序表和链表

1.线性表 线性表&#xff08;linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使 用的数据结构&#xff0c;常见的线性表&#xff1a;顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构&#xff0c;也就说是连续的一条直…
阅读更多...
链表|19.删除链表的倒数第N个节点

链表|19.删除链表的倒数第N个节点

力扣题目链接 struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {//定义虚拟头节点dummy 并初始化使其指向headstruct ListNode* dummy malloc(sizeof(struct ListNode));dummy->val 0;dummy->next head;//定义 fast slow 双指针struct ListNode* f…
阅读更多...
【力扣】234. 回文链表

【力扣】234. 回文链表

题目描述 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,2,1] 输出&#xff1a;true 示例 2&#xff1a; 输入&#xff1…
阅读更多...
链表中二级指针与一级指针的深度剖析（保姆级代码示例教学）

链表中二级指针与一级指针的深度剖析（保姆级代码示例教学）

以如下为例&#xff1a; typedef int SLTDataType; typedef struct SListNode { SLTDataType data; struct SListNode* next; }SLTNode; 若想在此链表中尾插一个数据&#xff08;新的结构体&#xff09;&#xff1a; 思路&#xff1a; 利用一个指针tail&#xff0c;…
阅读更多...
链表快慢指针合集（力扣）

链表快慢指针合集（力扣）

876. 链表的中间结点 代码 /*** Definition for singly-linked list.* struct ListNode {* int val;* ListNode *next;* ListNode() : val(0), next(nullptr) {}* ListNode(int x) : val(x), next(nullptr) {}* ListNode(int x, ListNode *next) : val(x…
阅读更多...
707.（力扣）设计链表 C++

707.（力扣）设计链表 C++

1、题目描述 理解题目&#xff1a;这道题目设计链表的五个接口 获取链表第index个节点的数值在链表的最前面插入一个节点在链表的最后面插入一个节点在链表第index个节点前面插入一个节点删除链表的第index个节点 2、设计单链表 &#xff08;1&#xff09;这里是单链表的设计…
阅读更多...
排序链表的三种写法

排序链表的三种写法

题目链接&#xff1a;https://leetcode.cn/problems/sort-list/?envTypestudy-plan-v2&envIdtop-100-liked 第一种&#xff0c;插入排序&#xff0c;会超时 class Solution {public ListNode sortList(ListNode head) {//插入排序&#xff0c;用较为简单的方式解决ListNo…
阅读更多...
单向链表模版实现（c++）

单向链表模版实现（c++）

关于单向链表 单向链表是链表最常用的一种&#xff0c;一个列表节点有两个字段&#xff0c;即数据域和指针域。在单向链表中&#xff0c;指向第一个节点的节点称为“头结点”&#xff0c;最后一个节点的指针域设为null。 如图即是{1,3,1,4,5,2,1}存在在单向链表的示意图&…
阅读更多...
C#，图论与图算法，图（Graph）的数据结构设计与源代码

C#，图论与图算法，图（Graph）的数据结构设计与源代码

因为后面即将发布的大量有关“图”的算法与源代码都需要用到下面的这些基础数据&#xff0c;为避免大家去下载&#xff0c;特意先发布于此。 一、图&#xff08;Graph&#xff09;的基础知识 图&#xff08;Graph&#xff09;是一组对象的图示&#xff0c;其中一些对象对通过链…
阅读更多...
面试经典-21-分隔链表

面试经典-21-分隔链表

题目 给你一个链表的头节点 head 和一个特定值 x &#xff0c;请你对链表进行分隔&#xff0c;使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。 你应当 保留 两个分区中每个节点的初始相对位置。 示例 1&#xff1a; 输入&#xff1a;head [1,4,3,2,5,2], x 3…
阅读更多...
【数据结构和算法初阶(C语言)】队列实操（概念实现+oj题目栈和队列的双向实现以及循环链表难点题目详解！）

【数据结构和算法初阶(C语言)】队列实操（概念实现+oj题目栈和队列的双向实现以及循环链表难点题目详解！）

目录 1. 队列的概念及结构 2.队列结构存在的意义应用 3.队列实现的结构选择 4.队列实现 5.队列对数据的处理 5.1队列初始化 5.2队尾入数据 5.3队头出数据 5.4获取队列尾部元素 5.5获取队列头部元素 5.6获取队列中元素个数 5.7检测队列是否为空 5.8销毁队列 6.循环队列补充 7.使…
阅读更多...
【LeetCode热题100】146. LRU 缓存（链表）

【LeetCode热题100】146. LRU 缓存（链表）

一.题目要求 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类&#xff1a; LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存int get(int key) 如果关键字 key 存在于缓存中&#xff0c;则返回关键字的值&#xff0c…
阅读更多...
82.删除排序链表中的重复元素II

82.删除排序链表中的重复元素II

给定一个已排序的链表的头 head &#xff0c; 删除原始链表中所有重复数字的节点&#xff0c;只留下不同的数字 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,3,4,4,5] 输出&#xff1a;[1,2,5]示例 2&#xff1a; 输入&#xff1a;head [1,1,1,2…
阅读更多...
Java中实现双向链表

Java中实现双向链表

一、目标 最近项目中实现双向链表&#xff0c;同时转为满二叉树。 二、代码 用java实现双向链表的代码如下&#xff1a; class TreeNode {int val;TreeNode left;TreeNode right;TreeNode(int x) { val x; } }public class FullBinaryTree {public TreeNode createTree(int[…
阅读更多...
MySQL 篇-深入了解索引的内部结构（哈希表、红黑树与 B+ 树）

MySQL 篇-深入了解索引的内部结构（哈希表、红黑树与 B+ 树）

&#x1f525;博客主页&#xff1a; 【小扳_-CSDN博客】 ❤感谢大家点赞&#x1f44d;收藏⭐评论✍ 文章目录 1.0 索引概述 2.0 索引内部结构特点 2.1 那么哪些数据结构&#xff0c;能够加快查询速度呢&#xff1f; 2.2 二叉搜索树、AVL 树存储结构特点 2.3 红黑树存储结构特…
阅读更多...
数据结构入门（3）顺序表和链表

数据结构入门（3）顺序表和链表

1.线性表 线性表&#xff08;linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使 用的数据结构&#xff0c;常见的线性表&#xff1a;顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构&#xff0c;也就说是连续的一条直…
阅读更多...
练习题+题解：链表+dp

练习题+题解：链表+dp

目录 1.链表指定区间反转题目描述输入格式:输出格式:输入样例:输出样例:题目分析代码实现 2.hxj和他的甜品盲盒I输入格式:输入样例:输出样例:样例解释 输入样例:输出样例:样例解释 题目分析Java代码实现 3.First 50 Prime Numbers输入格式输出格式输入样例输出样例题目解析代码…
阅读更多...
数据结构从入门到精通——快速排序

数据结构从入门到精通——快速排序

快速排序 前言一、快速排序的基本思想常见方式通用模块 二、快速排序的特性总结三、三种快速排序的动画展示四、hoare版本快速排序的代码展示普通版本优化版本为什么要优化快速排序代码三数取中法优化代码 五、挖坑法快速排序的代码展示六、前后指针快速排序的代码展示七、非递…
阅读更多...
LeetCode_Java_二叉搜索树系列(题目+思路+代码)

LeetCode_Java_二叉搜索树系列(题目+思路+代码)

目录 108.将有序数组转化为二叉搜索树 109.有序链表转换二叉搜索树 876.链表的中间节点 108.将有序数组转化为二叉搜索树 给你一个整数数组 nums &#xff0c;其中元素已经按 升序 排列&#xff0c;请你将其转换为一棵 平衡二叉搜索树。 示例 1&#xff1a; 输入&#xf…
阅读更多...
数据结构-链表(一)

数据结构-链表(一)

一、链表简介 链表&#xff08;Linked List&#xff09;是一种常见的数据结构&#xff0c;用于存储和组织数据。与数组不同&#xff0c;链表的元素&#xff08;节点&#xff09;在内存中不必连续存储&#xff0c;而是通过指针链接在一起。 链表由多个节点组成&#xff0c;每个…
阅读更多...
❤️算法笔记❤️-(每日一刷-141、环形链表)

❤️算法笔记❤️-(每日一刷-141、环形链表)

文章目录 题目思路解法 题目 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接…
阅读更多...
力扣- 876. 链表的中间结点（双指针解决）

力扣- 876. 链表的中间结点（双指针解决）

给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[3,4,5] 解释&#xff1a;链表只有一个中间结点&#xff0c;值为 3 。 …
阅读更多...
力扣-160. 相交链表（双指针）

力扣-160. 相交链表（双指针）

给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c;函数返回结果后&a…
阅读更多...
代码随想录算法训练营第33期day03: 第一章链表 part01

代码随想录算法训练营第33期day03: 第一章链表 part01

203. 移除链表元素 10分18 给你一个链表的头节点 head 和一个整数 val &#xff0c;请你删除链表中所有满足 Node.val val 的节点&#xff0c;并返回 新的头节点 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5] 示例 2&am…
阅读更多...
【LeetCode热题100】141. 环形链表（链表）

【LeetCode热题100】141. 环形链表（链表）

一.题目要求 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置…
阅读更多...
【数据结构和算法初阶(C语言)】队列实操（概念实现+oj题目栈和队列的双向实现，超级经典！！！）

【数据结构和算法初阶(C语言)】队列实操（概念实现+oj题目栈和队列的双向实现，超级经典！！！）

1. 队列的概念及结构 队列&#xff1a;只允许在一端进行插入数据操作&#xff0c;在另一端进行删除数据操作的特殊线性表&#xff0c; 队列具有先进先出 FIFO(First In First Out) 入队列&#xff1a;进行插入操作的一端称为队尾 出队列&#xff1a;进行删除操作的一端称为…
阅读更多...
【Leetcode每日一题】 递归 - 合并两个有序链表（难度⭐）（35）

【Leetcode每日一题】 递归 - 合并两个有序链表（难度⭐）（35）

1. 题目解析 题目链接&#xff1a;21. 合并两个有序链表 这个问题的理解其实相当简单&#xff0c;只需看一下示例&#xff0c;基本就能明白其含义了。 2.算法原理 1. 递归函数定义与功能 递归函数的主要任务是将两个有序链表合并成一个新的有序链表&#xff0c;并返回合并后…
阅读更多...
ArrayList 和 LinkedList 有什么区别？

ArrayList 和 LinkedList 有什么区别？

1、典型回答 ArrayList 和 LinkedList 是 Java 中常用的集合类&#xff0c;它们都实现了 List 接口&#xff0c;如下图所示&#xff1a; 但二者有以下几点不同&#xff1a; 1、底层数据结构实现不同&#xff1a; ArrayList 底层使用数组实现&#xff0c;它通过一个可调整大小…
阅读更多...
【数据结构和算法初阶(C语言)】栈的概念和实现（后进先出---后来者居上的神奇线性结构带来的惊喜体验）

【数据结构和算法初阶(C语言)】栈的概念和实现（后进先出---后来者居上的神奇线性结构带来的惊喜体验）

目录 1.栈 1.1栈的概念及结构 2.栈的实现 3.栈结构对数据的处理方式 3.1对栈进行初始化 3.2 从栈顶添加元素 3.3 打印栈元素 3.4移除栈顶元素 3.5获取栈顶元素 3.6获取栈中的有效个数 3.7 判断链表是否为空 3.9 销毁栈空间 4.结语及整个源码 1.栈 1.1栈的概念及结构 栈&am…
阅读更多...
每日一题 --- 链表相交[力扣][Go]

每日一题 --- 链表相交[力扣][Go]

链表相交 题目&#xff1a;面试题 02.07. 链表相交 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交**&#xff1a;** 题目数据 保证 整个链式结…
阅读更多...
数据结构——链表（练习题）

数据结构——链表（练习题）

大家好&#xff0c;我是小锋我们继续来学习链表。 我们在上一节已经把链表中的单链表讲解完了&#xff0c;大家感觉怎么样我们今天来带大家做一些练习帮助大家巩固所学内容。 1. 删除链表中等于给定值 val 的所有结点 . - 力扣&#xff08;LeetCode&#xff09; 我们大家来分…
阅读更多...
如何在C语言中实现链表、栈和队列等数据结构？

如何在C语言中实现链表、栈和队列等数据结构？

如何在C语言中实现链表、栈和队列等数据结构&#xff1f; 在C语言中实现链表、栈和队列等数据结构需要定义相关的数据结构和操作。下面我会给出每种数据结构的简单实现示例。 链表&#xff08;LinkedList&#xff09; 链表是由一系列节点组成&#xff0c;每个节点包含数据部…
阅读更多...
【数据结构】带头双向链表的实现

【数据结构】带头双向链表的实现

&#x1f451;个人主页&#xff1a;啊Q闻 &#x1f387;收录专栏&#xff1a;《数据结构》 &#x1f389;道阻且长&#xff0c;行则将至 前言 带头双向链表是链表的一种&#xff0c;相较于单链表的实现&#xff0c;其更为简单 一.初识带头双向循环链表 带头…
阅读更多...
如何使用python链表

如何使用python链表

在Python中&#xff0c;可以使用类来实现链表的数据结构。链表是一种数据结构&#xff0c;它由一系列节点组成&#xff0c;每个节点包含一个数据元素和一个指向下一个节点的引用。 下面是一个简单的链表类的示例&#xff1a; class Node:def __init__(self, data):self.data …
阅读更多...
链表中两两交换结点（力扣24）

链表中两两交换结点（力扣24）

文章目录 题目题解一、思路二、解题方法三、Code 总结 题目 Problem: 24. 两两交换链表中的节点 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题&#xff08;即&#xff0c;只能进行节点交…
阅读更多...
数据结构刷题篇 之 【力扣二叉树基础OJ】详细讲解（含每道题链接及递归图解）

数据结构刷题篇 之 【力扣二叉树基础OJ】详细讲解（含每道题链接及递归图解）

有没有一起拼用银行卡的&#xff0c;取钱的时候我用&#xff0c;存钱的时候你用 1、相同的树 难度等级&#xff1a;⭐ 直达链接&#xff1a;相同的树 2、单值二叉树 难度等级&#xff1a;⭐ 直达链接&#xff1a;单值二叉树 3、对称二叉树 难度等级&#xff1a;⭐⭐ 直达…
阅读更多...
141.环形链表 142.环形链表II

141.环形链表 142.环形链表II

给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置&#xff08;索…
阅读更多...
234-回文链表

234-回文链表

题目 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,2,1] 输出&#xff1a;true 示例 2&#xff1a; 输入&#xff1a;he…
阅读更多...
数据结构02：线性表 链表习题02[C++]

数据结构02：线性表 链表习题02[C++]

考研笔记整理~&#x1f95d;&#x1f95d; 之前的博文链接在此&#xff1a;数据结构02&#xff1a;线性表[顺序表链表]_线性链表-CSDN博客~&#x1f95d;&#x1f95d; 本篇作为链表的代码补充&#xff0c;供小伙伴们参考~&#x1f95d;&#x1f95d; 第1版&#xff1a;王道…
阅读更多...
【3】3道链表力扣题：删除链表中的节点、反转链表、判断一个链表是否有环

【3】3道链表力扣题：删除链表中的节点、反转链表、判断一个链表是否有环

3道链表力扣题 一、删除链表中的节点&#x1f30f; 题目链接&#x1f4d5; 示例&#x1f340; 分析&#x1f4bb; 代码 二、反转链表&#x1f30f; 题目链接&#x1f4d5; 示例&#x1f340; 分析① 递归② 迭代 三、判断一个链表是否有环&#x1f30f; 题目链接&#x1f4d5; …
阅读更多...
【实现报告】学生信息管理系统（链表实现）

【实现报告】学生信息管理系统（链表实现）

目录 实验一　线性表的基本操作 一、实验目的 二、实验内容 三、实验提示 四、实验要求 五、实验代码如下&#xff1a; &#xff08;一&#xff09;链表的构建及初始化 学生信息结构体定义 定义元素类型 链表节点结构体定义 初始化链表 &#xff08;二&#xff09;…
阅读更多...
删除单链表中重复出现的元素

删除单链表中重复出现的元素

算法思想&#xff1a;通过冒泡排序将无序单链表变成有序单链表&#xff0c;然后访问有序单链表中的每一对前驱和后继&#xff0c;若后继结点中的数据与前驱结点中的数据相同&#xff0c;则将后继结点删除&#xff1b;重复上述步骤&#xff0c;直到访问完链表中的每一对前驱和后…
阅读更多...
单链表求集合的交集

单链表求集合的交集

#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> typedef int ElemType; typedef struct LinkNode {ElemType data;LinkNode* next; }LinkNode, * LinkList; //尾插法建立单链表 void creatLinkList(LinkList& L) {L (LinkNode*)mallo…
阅读更多...
【初阶数据结构】——牛客：OR36 链表的回文结构

【初阶数据结构】——牛客：OR36 链表的回文结构

文章目录 1. 题目介绍2. 思路分析3. 代码实现 1. 题目介绍 链接: link 这道题呢是让我们判断一个链表是否是回文结构。但是题目要求设计一个时间复杂度为O(n)&#xff0c;额外空间复杂度为O(1)的算法。 所以如果我们想把链表的值存到一个数组中再去判断就不可行了。 2. 思路…
阅读更多...
leetcode.203. 移除链表元素

leetcode.203. 移除链表元素

题目 题意&#xff1a;删除链表中等于给定值 val 的所有节点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,6,3,4,5,6], val 6 输出&#xff1a;[1,2,3,4,5] 示例 2&#xff1a; 输入&#xff1a;head [], val 1 输出&#xff1a;[] 示例 3&#xff1a; 输入&#…
阅读更多...
LeetCode 707. 设计链表（单链表、（非循环）双链表 模板）

LeetCode 707. 设计链表（单链表、（非循环）双链表 模板）

你可以选择使用单链表或者双链表&#xff0c;设计并实现自己的链表。 单链表中的节点应该具备两个属性&#xff1a;val 和 next 。val 是当前节点的值&#xff0c;next 是指向下一个节点的指针/引用。 如果是双向链表&#xff0c;则还需要属性 prev 以指示链表中的上一个节点…
阅读更多...
第十四届蓝桥杯省赛大学B组（C/C++）整数删除

第十四届蓝桥杯省赛大学B组（C/C++）整数删除

原题链接&#xff1a;整数删除 给定一个长度为 N 的整数数列&#xff1a;A1,A2,...,AN。 你要重复以下操作 K 次&#xff1a; 每次选择数列中最小的整数&#xff08;如果最小值不止一个&#xff0c;选择最靠前的&#xff09;&#xff0c;将其删除&#xff0c;并把与它相邻的…
阅读更多...
删除排序链表中的重复元素

删除排序链表中的重复元素

先看第一道&#xff1a; 83. 删除排序链表中的重复元素 给定一个已排序的链表的头 head &#xff0c; 删除所有重复的元素&#xff0c;使每个元素只出现一次 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,1,2] 输出&#xff1a;[1,2]示例 2&#xff1…
阅读更多...
力扣热题100_链表_2_两数相加

力扣热题100_链表_2_两数相加

文章目录 题目链接解题思路解题代码 题目链接 2. 两数相加 给你两个 非空 的链表&#xff0c;表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的&#xff0c;并且每个节点只能存储 一位 数字。 请你将两个数相加&#xff0c;并以相同形式返回一个表示和的链表。 …
阅读更多...
反转链表（leetcode 206）

反转链表（leetcode 206）

迭代核心逻辑&#xff1a; 原链表的新的下一个结点&#xff0c;作为新反转链表的头结点 代码分析&#xff1a; 初始化prev为nullptr&#xff08;之后是作为反转后链表的最后一个结点&#xff09;&#xff0c; 遍历原链表时保存当前结点的下一个结点&#xff0c;将curr的nex…
阅读更多...
【LeetCode】手撕系列—206. 反转链表_三个指针

【LeetCode】手撕系列—206. 反转链表_三个指针

原题链接&#xff1a;206. 反转链表 目录 1- 思路2- 题解⭐反转链表 ——题解思路 3-ACM模式 1- 思路 定义三个指针prev&#xff1a;记录 cur 的前一个结点cur&#xff1a;记录当前需要翻转的结点tmp&#xff1a;记录 cur 的 next 防止遍历过程中找不到链表的剩余部分 2- 题解…
阅读更多...
leetcode.面试题 02.07. 链表相交

leetcode.面试题 02.07. 链表相交

题目 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 思路 假a在链表A上移动,b在链表B上移动&#xff0c;a移动完在B上开始&…
阅读更多...
leetcode.24. 两两交换链表中的节点

leetcode.24. 两两交换链表中的节点

题目 给定一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后的链表。 你不能只是单纯的改变节点内部的值&#xff0c;而是需要实际的进行节点交换。 思路 创建虚拟头节点&#xff0c;画图&#xff0c;确认步骤。 实现 /*** Definition for singly-li…
阅读更多...
leetcode.19. 删除链表的倒数第 N 个结点

leetcode.19. 删除链表的倒数第 N 个结点

题目 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 进阶&#xff1a;你能尝试使用一趟扫描实现吗&#xff1f; 思路 先遍历一遍得到链表的长度l,在从头开始删除第l-n个节点即可 实现 class Solution {public ListNode removeNt…
阅读更多...
Collection与数据结构 链表与LinkedList(三):链表精选OJ例题(下)

Collection与数据结构 链表与LinkedList(三):链表精选OJ例题(下)

1. 分割链表 OJ链接 class Solution {public ListNode partition(ListNode head, int x) {if(head null){return null;//空链表的情况}ListNode cur head;ListNode formerhead null;ListNode formerend null;ListNode latterhead null;ListNode latterend null;//定义…
阅读更多...
LeetCode 19.删除链表的倒数第N个结点

LeetCode 19.删除链表的倒数第N个结点

给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], n 2 输出&#xff1a;[1,2,3,5] 示例 2&#xff1a; 输入&#xff1a;head [1], n 1 输出&#xff1a;[] 示例 3&#x…
阅读更多...
环形链表的约瑟夫问题

环形链表的约瑟夫问题

著名的 Josephus 问题&#xff1a; 据说著名犹太历史学家Josephus&#xff08;弗拉维奥约瑟夫斯&#xff09;有过以下的故事&#xff1a;在罗马人占领乔塔帕特后&#xff0c;39 个犹太人与Josephus及他的朋友躲到一个洞中&#xff0c;39个犹太人决定宁愿死也不要被敌人抓到&…
阅读更多...
讲讲你对数据结构-线性表了解多少？

讲讲你对数据结构-线性表了解多少？

线性表 - 数组和矩阵 当谈到线性表时&#xff0c;数组和矩阵是两种常见的数据结构。 数组&#xff08;Array&#xff09;&#xff1a; 数组是有序的元素集合&#xff0c;可以通过索引来访问和操作其中的元素。它是最简单、最基本的数据结构之一。数组的特点包括&#xff1a; …
阅读更多...
数据结构（二）----线性表（顺序表，链表）

数据结构（二）----线性表（顺序表，链表）

目录 1.线性表的概念 2.线性表的基本操作 3.存储线性表的方式 &#xff08;1&#xff09;顺序表 •顺序表的概念 •顺序表的实现 静态分配&#xff1a; 动态分配&#xff1a; 顺序表的插入&#xff1a; 顺序表的删除&#xff1a; 顺序表的按位查找&#xff1a; 顺序…
阅读更多...
深入理解 Linux 内核链表：C 链表的实用性和优势

深入理解 Linux 内核链表：C 链表的实用性和优势

深入理解 Linux 内核链表&#xff1a;C 链表的实用性和优势 在 Linux 内核的设计和实现中&#xff0c;链表是一种非常关键的数据结构&#xff0c;尤其是因为它在处理动态数据集合时的高效性和灵活性。本文将深入探讨链表在 Linux 内核中的作用以及内核开发者如何利用 C 语言中…
阅读更多...
LeetCode-24. 两两交换链表中的节点【递归 链表】

LeetCode-24. 两两交换链表中的节点【递归 链表】

LeetCode-24. 两两交换链表中的节点【递归 链表】 题目描述&#xff1a;解题思路一&#xff1a;双指针1解题思路二&#xff1a;双指针2解题思路三&#xff1a;递归 题目描述&#xff1a; 给你一个链表&#xff0c;两两交换其中相邻的节点&#xff0c;并返回交换后链表的头节点…
阅读更多...
redis链表结构和简单动态字符串(SDS)

redis链表结构和简单动态字符串(SDS)

1.双向链表 redis中的普通链表是双向链表。通过链表节点结构体可知有全驱节点和后继节点。 1.链表节点和链表 //adlist.h typedef struct listNode {struct listNode *prev; //前驱节点struct listNode *next; //后继节点void *value; //节点值 } list…
阅读更多...
LeetCode-19. 删除链表的倒数第 N 个结点【链表 双指针】

LeetCode-19. 删除链表的倒数第 N 个结点【链表 双指针】

LeetCode-19. 删除链表的倒数第 N 个结点【链表 双指针】 题目描述&#xff1a;解题思路一&#xff1a;双指针解题思路二&#xff1a;优化解题思路三&#xff1a;0 题目描述&#xff1a; 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。…
阅读更多...
LeetCode-148. 排序链表【链表 双指针 分治 排序 归并排序】

LeetCode-148. 排序链表【链表 双指针 分治 排序 归并排序】

LeetCode-148. 排序链表【链表 双指针 分治 排序 归并排序】 题目描述&#xff1a;解题思路一&#xff1a;递归的归并排序&#xff0c;两个关键点&#xff0c;找到中点mid和分割链表。前者通过快慢指针&#xff0c;后者通过指向None。即mid, slow.next slow.next, None解题思路…
阅读更多...
数据结构——栈(C语言版)

数据结构——栈(C语言版)

前言&#xff1a; 在学习完数据结构顺序表和链表之后&#xff0c;其实我们就可以做很多事情了&#xff0c;后面的栈和队列&#xff0c;其实就是对前面的顺序表和链表的灵活运用&#xff0c;今天我们就来学习一下栈的原理和应用。 准备工作&#xff1a;本人习惯将文件放在test.c…
阅读更多...
2024牛客春招冲刺题单 ONT97 牛牛的递增之旅 【中等 链表 Java,Go,PHP】

2024牛客春招冲刺题单 ONT97 牛牛的递增之旅 【中等 链表 Java,Go,PHP】

题目 题目链接&#xff1a; https://www.nowcoder.com/practice/e463addab7d548819d6b6483335651b5 思路 核心&#xff1a;链表中删除节点。链表中增删改查节点&#xff0c;最好新建一个虚拟头结点start,end&#xff0c; 然后end链接上符合条件的已经存在的节点&#xff0c;最…
阅读更多...
LeetCode-热题100：160. 相交链表

LeetCode-热题100：160. 相交链表

给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节点 c1 开始相交&#xff1a; 题目数据 保证 整个链式结构中不存在环。 注意&#xff0c;函数返回结果后&…
阅读更多...
链表的中间结点——每日一题

链表的中间结点——每日一题

题目链接&#xff1a; OJ链接 题目&#xff1a; 给你单链表的头结点 head &#xff0c;请你找出并返回链表的中间结点。 如果有两个中间结点&#xff0c;则返回第二个中间结点。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[3,4,5] 解释&…
阅读更多...
【零基础学数据结构】链表

【零基础学数据结构】链表

目录 1.链表的概念 ​编辑 2.链表的雏形 ​编辑 3.链表的组成 ​编辑 4.链表代码 4.1创建节点 4.2链表的打印 4.3链表的尾插 4.4链表的头插 4.5链表的尾删 4.6链表的头删 4.7链表的查找 4.8链表在指定位置之前插⼊数据 4.9链表在指定位置之后插⼊数据 4.9-1删除pos节点 4.9…
阅读更多...
数组与链表：JavaScript中的数据结构选择

数组与链表：JavaScript中的数据结构选择

&#x1f90d; 前端开发工程师、技术日更博主、已过CET6 &#x1f368; 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 &#x1f560; 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》 &#x1f35a; 蓝桥云课签约作者、上架课程《Vue.js 和 E…
阅读更多...
嵌入式开发学习--数据结构--顺序表、链表、双向链表、顺序栈、链式栈、循环队列、链式队列（含代码）

嵌入式开发学习--数据结构--顺序表、链表、双向链表、顺序栈、链式栈、循环队列、链式队列（含代码）

顺序表 特点&#xff1a;内存连续&#xff0c;数组 1&#xff09;逻辑结构&#xff1a;线性结构 2&#xff09;存储结构&#xff1a;顺序存储 3&#xff09;操作&#xff1a;增删改查 函数名命名规则&#xff1a; 下滑线法&#xff1a;create_empty_seqlist 小驼峰法&#xff…
阅读更多...
面试经典算法系列之链表3 -- 反转链表Ⅱ

面试经典算法系列之链表3 -- 反转链表Ⅱ

面试经典算法9-反转链表Ⅱ LeetCode.92 公众号&#xff1a;阿Q技术站 问题描述 给你单链表的头指针 head 和两个整数 left 和 right &#xff0c;其中 left < right 。请你反转从位置 left 到位置 right 的链表节点&#xff0c;返回 反转后的链表 。 示例 1&#xff1a;…
阅读更多...
【华为OD机试C++】简单密码设置

【华为OD机试C++】简单密码设置

《最新华为OD机试题目带答案解析》：最新华为OD机试题目带答案解析，语言包括C、C++、Python、Java、JavaScript等。订阅专栏，获取专栏内所有文章阅读权限，持续同步更新！ 文章目录 描述输入描述输出描述示例代码描述 现在有一种密码变换算法。 九键手机键盘上的数字与字母的…
阅读更多...
使用c++自建循环链表和自建队列分别解决约瑟夫问题

使用c++自建循环链表和自建队列分别解决约瑟夫问题

//自建循环链表解决约瑟夫问题 void CircleLinkList::yuesefu(int go_num) { CircleLinkNode* curr head; CircleLinkNode* prev nullptr; while (size > 0) { for (int i 1; i < go_num; i) { prev curr; …
阅读更多...
MySQL——链表

MySQL——链表

一、两张表连接 将两张表格拼接成一个表 1、格式&#xff1a;select 列A&#xff0c;列B from 表A&#xff0c;表 where 表A.列C表B.列C 2、格式&#xff1a;select 列A&#xff0c;列B from 表A inner join表B on 表A.列C表B.列C #效率不高 二、多表连接 三张表相连ABC AC没…
阅读更多...
结构体和结构体指针的区别

结构体和结构体指针的区别

1.定义区别 结构体的定义如下&#xff1a; struct 结构体名 {数据类型 成员变量名1;数据类型 成员变量名2;// 可以有更多的成员变量 };例如&#xff0c;定义一个表示学生的结构体&#xff1a; struct Student {int id;char name[20];int age; };上述定义了一个名为Student的…
阅读更多...
【数据结构（四）】链表经典练习题

【数据结构（四）】链表经典练习题

❣博主主页: 33的博客❣ ▶️文章专栏分类:数据结构◀️ &#x1f69a;我的代码仓库: 33的代码仓库&#x1f69a; &#x1faf5;&#x1faf5;&#x1faf5;关注我带你学更多数据结构知识 目录 1.前言2.删除值为key的所有结点3.反转链表4.返回中间结点5.输出倒数第k个结点6.链表…
阅读更多...
蓝桥杯23年第十四届省赛-整数删除|STL优先队列、双向链表

蓝桥杯23年第十四届省赛-整数删除|STL优先队列、双向链表

题目链接&#xff1a; 蓝桥杯2023年第十四届省赛真题-整数删除 - C语言网 (dotcpp.com) 0整数删除 - 蓝桥云课 (lanqiao.cn) 学习&#xff1a;蓝桥杯真题讲解&#xff1a;整数删除_蓝桥杯整数删除 c语言-CSDN博客 说明&#xff1a; 在暴力做法里面&#xff0c;每次都要花费…
阅读更多...
算法系列之链表删除节点JS/TS版

算法系列之链表删除节点JS/TS版

链表删除节点 JS/TS的链表节点表示方法 // Definition for singly-linked list. function ListNode(val, next) {this.val (val undefined ? 0 : val)this.next (next undefined ? null : next) }// Definition for singly-linked list. class ListNode {val: numberne…
阅读更多...
数据结构进阶篇 之 【二叉树】详细概念讲解（带你认识何为二叉树及其性质）

数据结构进阶篇 之 【二叉树】详细概念讲解（带你认识何为二叉树及其性质）

有朋自远方来&#xff0c;必先苦其心志&#xff0c;劳其筋骨&#xff0c;饿其体肤&#xff0c;空乏其身&#xff0c;鞭数十&#xff0c;驱之别院 一、二叉树 1、二叉树的概念 1.1 二叉树中组分构成名词概念 1.2 二叉树的结构概念 1.3 特殊的二叉树 2、二叉树的存储结构 …
阅读更多...
力扣热题100_链表_141_环形链表

力扣热题100_链表_141_环形链表

文章目录 题目链接解题思路解题代码 题目链接 141. 环形链表 给你一个链表的头节点 head &#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达&#xff0c;则链表中存在环。 为了表示给定链表中的环&#xff0c;评测系统…
阅读更多...
list(链表)容器（二）

list(链表)容器（二）

一、list 插入和删除 函数原型&#xff1a; push_back(elem);//在容器尾部加入一个元素 pop_back();//删除容器中最后一个元素 push_front(elem);//在容器开头插入一个元素 pop_front();//从容器开头移除第一个元素 insert(pos,elem);//在pos位置插elem元素的拷贝&#xff0c…
阅读更多...
深入理解数据结构——堆

深入理解数据结构——堆

前言&#xff1a; 在前面我们已经学习了数据结构的基础操作&#xff1a;顺序表和链表及其相关内容&#xff0c;今天我们来学一点有些难度的知识——数据结构中的二叉树&#xff0c;今天我们先来学习二叉树中堆的知识&#xff0c;这部分内容还是非常有意思的&#xff0c;下面我们…
阅读更多...
算法第三十七天-旋转链表

算法第三十七天-旋转链表

旋转链表 题目要求 解题思路 题意&#xff1a;将链表中每个元素向后移动k个位置&#xff0c;相当于把链表的后面k%len节点移到链表的最前面。 所以本题步骤为&#xff1a; 1.求出链表长度&#xff1b; 2.找出倒数第k1个节点 3.链表重整&#xff1a;将连败哦的倒数第k1个节点和…
阅读更多...
【LeetCode】热题100：排序链表

【LeetCode】热题100：排序链表

题目&#xff1a; 给你链表的头结点 head &#xff0c;请将其按 升序 排列并返回 排序后的链表 。 示例 1&#xff1a; 输入&#xff1a;head [4,2,1,3] 输出&#xff1a;[1,2,3,4] 示例 2&#xff1a; 输入&#xff1a;head [-1,5,3,4,0] 输出&#xff1a;[-1,0,3,4,5] …
阅读更多...
爱上数据结构：栈和队列的OJ及选择题

爱上数据结构：栈和队列的OJ及选择题

​ ​ &#x1f525;个人主页&#xff1a;guoguoqiang. &#x1f525;专栏&#xff1a;数据结构 ​ 一、 栈和队列的OJ题 1.括号匹配问题 括号匹配问题 typedef char STDataType; typedef struct Stack {STDataType* a;int top;int capacity; }ST; void STInit(ST* ps)…
阅读更多...
数据结构--循环链表（C语言实现）

数据结构--循环链表（C语言实现）

一.循环链表的设计 typedef struct CNode{ int data; struct CNode* next; }CNode ,*CList; 2.循环链表的示意图: 3.循环链表和单链表的区别: 唯一区别,没有空指针,尾节点的后继为头,为循环之意. 二.循环链表的实现 //初始化return true; }//返回key的前驱地址&#xff0c;如果…
阅读更多...
每日一题（相交链表 ）

每日一题（相交链表 ）

欢迎大家来我们主页进行指导 LaNzikinh-CSDN博客 160. 相交链表 - 力扣&#xff08;LeetCode&#xff09; 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 图示两个链表在节…
阅读更多...
【二叉树】Leetcode 114. 二叉树展开为链表【中等】

【二叉树】Leetcode 114. 二叉树展开为链表【中等】

二叉树展开为链表 给你二叉树的根结点 root &#xff0c;请你将它展开为一个单链表&#xff1a; 展开后的单链表应该同样使用 TreeNode &#xff0c;其中 right 子指针指向链表中下一个结点&#xff0c;而左子指针始终为 null 。展开后的单链表应该与二叉树 先序遍历 顺序相同…
阅读更多...
链表：一种灵活的数据存储方式

链表：一种灵活的数据存储方式

&#x1f464;作者介绍&#xff1a;10年大厂数据\经营分析经验&#xff0c;现任大厂数据部门负责人。 会一些的技术&#xff1a;数据分析、算法、SQL、大数据相关、python 作者专栏每日更新LeetCode解锁1000题: 打怪升级之旅https://blog.csdn.net/cciehl/category_12625714.ht…
阅读更多...
【经典算法】LeetCode 21:合并两个有序链表Java/C/Python3实现含注释说明,Easy)

【经典算法】LeetCode 21:合并两个有序链表Java/C/Python3实现含注释说明,Easy)

合并两个有序链表 题目描述思路及实现方式一&#xff1a;迭代&#xff08;推荐&#xff09;思路代码实现Java版本C语言版本Python3版本 复杂度分析 方式二&#xff1a;递归&#xff08;不推荐&#xff09;思路代码实现Java版本C语言版本Python3版本 复杂度分析 总结相似题目 标…
阅读更多...
【华为OD机试C++】提取不重复的整数

【华为OD机试C++】提取不重复的整数

《最新华为OD机试题目带答案解析》：最新华为OD机试题目带答案解析，语言包括C、C++、Python、Java、JavaScript等。订阅专栏，获取专栏内所有文章阅读权限，持续同步更新！ 文章目录 描述输入描述输出描述示例代码描述 输入一个 int 型整数，按照从右向左的阅读顺序，返回一个…
阅读更多...
数据结构——二叉树——堆

数据结构——二叉树——堆

前言&#xff1a; 在前面我们已经学习了数据结构的基础操作&#xff1a;顺序表和链表及其相关内容&#xff0c;今天我们来学一点有些难度的知识——数据结构中的二叉树&#xff0c;今天我们先来学习二叉树中堆的知识&#xff0c;这部分内容还是非常有意思的&#xff0c;下面我们…
阅读更多...
LeetCode刷题【链表，图论，回溯】

LeetCode刷题【链表，图论，回溯】

目录 链表138. 随机链表的复制148. 排序链表146. LRU 缓存 图论200. 岛屿数量994. 腐烂的橘子207. 课程表 回溯 链表 138. 随机链表的复制 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节…
阅读更多...
链表常见题型分析及代码汇总

链表常见题型分析及代码汇总

链表 结构 //单链表的节点结构 Class Node<V>{V value;Node next;} 由以上结构的节点依次连接起来所形成的链叫单链表结构。//双链表的节点结构 Class Node<V>{V value;Node next;Node last;} 由以上结构的节点依次连接起来所形成的链叫双链表结构。1、主要方法 1…
阅读更多...
Collection与数据结构链表与LinkedList(三):链表精选OJ例题(下)

Collection与数据结构链表与LinkedList(三):链表精选OJ例题(下)

1. 分割链表 OJ链接 class Solution {public ListNode partition(ListNode head, int x) {if(head null){return null;//空链表的情况}ListNode cur head;ListNode formerhead null;ListNode formerend null;ListNode latterhead null;ListNode latterend null;//定义…
阅读更多...
[leetcode] 61. 旋转链表

[leetcode] 61. 旋转链表

给你一个链表的头节点 head &#xff0c;旋转链表&#xff0c;将链表每个节点向右移动 k 个位置。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5], k 2 输出&#xff1a;[4,5,1,2,3]示例 2&#xff1a; 输入&#xff1a;head [0,1,2], k 4 输出&#xff1a;[2,0…
阅读更多...
ONT60 旋转链表 思路分享

ONT60 旋转链表 思路分享

题干链接&#xff1a;ONT60 旋转链表 ​ 这道题是反转链表题的pro升级版&#xff0c;但比反转链表略微复杂一些。如果有做过旋转数组那道题&#xff08;链接在这里&#xff1a;https://blog.csdn.net/wyd_333/article/details/126712919&#xff0c;但当时刷这道题的时候我用的…
阅读更多...
Java数据结构-链表OJ题

Java数据结构-链表OJ题

目录 1. 移除链表元素2. 反转链表3. 返回中间结点4. 返回倒数第k个结点5. 合并两个有序链表6. 分割链表7. 回文链表8. 找相交链表的公共结点9. 判断链表是否有环10. 返回链表环的入口 老铁们好&#xff0c;学习完链表这个数据结构之后&#xff0c;怎么能少了OJ题呢&#xff1f;…
阅读更多...
Java数据结构-双向不带头非循环链表(模拟实现LinkedList)

Java数据结构-双向不带头非循环链表(模拟实现LinkedList)

目录 1. 双向不带头非循环链表的介绍2. 相关功能的实现2.1 基本框架2.2 size2.3 addFirst2.4 addLast2.5 addIndex2.6 contains2.7 remove2.8 removeAllKey2.9 clear 3. 全部代码 前面我们学习了最简单的链表&#xff1a;单链表&#xff0c;今天我们学习双向不带头非循环链表&a…
阅读更多...
【初阶数据结构】——牛客：CM11 链表分割

【初阶数据结构】——牛客：CM11 链表分割

文章目录 1. 题目介绍2. 思路分析3. 代码实现 1. 题目介绍 链接: link 这道题是给我们一个链表和一个值X &#xff0c;要求我们以给定值x为基准将链表分割成两部分&#xff0c;所有小于x的结点排在大于或等于x的结点之前。 最终返回重新排列之后的链表的头指针。 2. 思路分析…
阅读更多...
数据结构：链表的双指针技巧

数据结构：链表的双指针技巧

文章目录 一、链表相交问题二、单链表判环问题三、回文链表四、重排链表结点 初学双指针的同学&#xff0c;请先弄懂删除链表的倒数第 N 个结点。 并且在学习这一节时&#xff0c;不要将思维固化&#xff0c;认为只能这样做&#xff0c;这里的做法只是技巧。 一、链表相交问题 …
阅读更多...
leetcode.206.反转链表

leetcode.206.反转链表

题目 题意&#xff1a;反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 思路 双指针:创建指针p,curr&#xff0c;初始分别指向null和头节点&#xff0c;每轮循环移动一个节点的指向&#xff0c;直到指到最后一…
阅读更多...
[leetcode] 25. K 个一组翻转链表

[leetcode] 25. K 个一组翻转链表

给你链表的头节点 head &#xff0c;每 k 个节点一组进行翻转&#xff0c;请你返回修改后的链表。 k 是一个正整数&#xff0c;它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍&#xff0c;那么请将最后剩余的节点保持原有顺序。 你不能只是单纯的改变节点内部的值…
阅读更多...
删除有序链表中的重复元素

删除有序链表中的重复元素

. - 力扣&#xff08;LeetCode&#xff09; 给定一个已排序的链表的头 head &#xff0c; 删除原始链表中所有重复数字的节点&#xff0c;只留下不同的数字 。返回 已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,3,4,4,5] 输出&#xff1a;[1,2,5]示例 2&…
阅读更多...
力扣热题100_链表_138_随机链表的复制

力扣热题100_链表_138_随机链表的复制

文章目录 题目链接解题思路解题代码 题目链接 138. 随机链表的复制 给你一个长度为 n 的链表&#xff0c;每个节点包含一个额外增加的随机指针 random &#xff0c;该指针可以指向链表中的任何节点或空节点。 构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成&a…
阅读更多...
算法题 — 环形链表

算法题 — 环形链表

给定一个链表&#xff0c;判断链表中是否有环。 如果链表中有某个节点&#xff0c;可以通过连续跟踪 next 指针再次到达该节点&#xff0c;则链表中存在环 如果链表中存在环&#xff0c;则返回 true&#xff0c;否则&#xff0c;返回 false public class ListNode {int val;…
阅读更多...
【LeetCode: 21. 合并两个有序链表 + 链表】

【LeetCode: 21. 合并两个有序链表 + 链表】

&#x1f680; 算法题 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;…
阅读更多...
良辰当五日，“双向链表”还 (Java篇)

良辰当五日，“双向链表”还 (Java篇)

本篇会加入个人的所谓鱼式疯言 ❤️❤️❤️鱼式疯言:❤️❤️❤️此疯言非彼疯言 而是理解过并总结出来通俗易懂的大白话, 小编会尽可能的在每个概念后插入鱼式疯言,帮助大家理解的. &#x1f92d;&#x1f92d;&#x1f92d;可能说的不是那么严谨.但小编初心是能让更多人能接…
阅读更多...
牛客NC93 设计LRU缓存结构【hard 链表，Map Java】

牛客NC93 设计LRU缓存结构【hard 链表，Map Java】

题目 题目链接&#xff1a; https://www.nowcoder.com/practice/5dfded165916435d9defb053c63f1e84 思路 双向链表map最新的数据放头结点&#xff0c;尾节点放最老的数据&#xff0c;没次移除尾巴节点本地考察链表的新增&#xff0c;删除&#xff0c;移动节点参考答案Java im…
阅读更多...
【STL】链表(list)

【STL】链表(list)

链表是一种物理存储单元上非连续、非顺序的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表由一系列结点&#xff08;链表中每一个元素称为结点&#xff09;组成&#xff0c;结点可以在运行时动态生成。每个结点包括两个部分&#xff1a;一个…
阅读更多...
【数据结构】双向链表 C++

【数据结构】双向链表 C++

一、什么是双向链表 1、定义 双向链表也叫双链表&#xff0c;是链表的一种&#xff0c;它的每个数据结点中都有两个指针&#xff0c;分别指向直接后继和直接前驱。所以&#xff0c;从双向链表中的任意一个结点开始&#xff0c;都可以很方便地访问它的前驱结点和后继结点。 双…
阅读更多...
链表之双向链表的实现

链表之双向链表的实现

铁汁们大家好&#xff0c;我们上一篇博客学习了单链表&#xff0c;这节课让我们继续往深学习&#xff0c;学习一下双线链表&#xff0c;话不多说&#xff0c;我们开始吧&#xff01; 目录 1.双向链表 2.顺序表和链表的优缺点 3.双向链表的实现 1.双向链表 1.我们要实现的双线…
阅读更多...
数据结构：内核list的实践

数据结构：内核list的实践

记录下C语言中数据结构链表的2种方式&#xff0c;其中内核的表达方式可谓是经典。 一、数据和指针域混合 数据域和指针域定义在同一个结构体定义中&#xff0c;C语言中没有模板&#xff0c;意味着一个代码工程有多少数据结构就需要多少对链表的.c和.h&#xff0c;事实上这样会…
阅读更多...
数据结构——二叉树(OJ练习)

数据结构——二叉树(OJ练习)

大家好&#xff0c;本期是二叉树的最后一期&#xff0c;这一期我们来看看二叉树的编程题 单值二叉树 . - 力扣&#xff08;LeetCode&#xff09; 首先我们的思路是&#xff1a;遍历二叉树&#xff0c;把每个节点去比较一次&#xff0c;按照要求返回 我们来看代码 bool isUn…
阅读更多...
【数据结构与算法】力扣 19. 删除链表的倒数第 N 个结点

【数据结构与算法】力扣 19. 删除链表的倒数第 N 个结点

题目描述 给你一个链表&#xff0c;删除链表的倒数第 n 个结点&#xff0c;并且返回链表的头结点。 示例 1&#xff1a; 输入&#xff1a; head [1,2,3,4,5], n 2 输出&#xff1a; [1,2,3,5]示例 2&#xff1a; 输入&#xff1a; head [1], n 1 输出&#xff1a; []示例…
阅读更多...
Leetcode 142. 环形链表 II和Leetcode 242. 有效的字母异位词

Leetcode 142. 环形链表 II和Leetcode 242. 有效的字母异位词

文章目录 Leetcode 142. 环形链表 II题目描述C语言题解解题思路 Leetcode 242. 有效的字母异位词题目描述C语言题解和思路解题思路 Leetcode 142. 环形链表 II 题目描述 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返…
阅读更多...
HarmonyOS 应用开发-使用colorPicker实现背景跟随主题颜色转换

HarmonyOS 应用开发-使用colorPicker实现背景跟随主题颜色转换

介绍 本示例介绍使用image库以及effectKit库中的colorPicker对目标图片进行取色&#xff0c;将获取的颜色作为背景渐变色&#xff0c;通过swiper组件对图片进行轮播&#xff0c; 效果图预览 使用说明 直接进入页面&#xff0c;对图片进行左右滑动&#xff0c;或者等待几秒&a…
阅读更多...
环形链表 II - LeetCode 热题 26

环形链表 II - LeetCode 热题 26

大家好&#xff01;我是曾续缘&#x1f61b; 今天是《LeetCode 热题 100》系列 发车第 26 天 链表第 5 题 ❤️点赞 &#x1f44d; 收藏 ⭐再看&#xff0c;养成习惯 环形链表 II 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xf…
阅读更多...
【LeetCode】热题100：LRU缓存

【LeetCode】热题100：LRU缓存

题目&#xff1a; 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类&#xff1a; LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中&#xff0c;则返回关键字的值&…
阅读更多...
【C++】手搓 list 容器

【C++】手搓 list 容器

送给大家一句话&#xff1a; 若结局非你所愿&#xff0c;就在尘埃落定前奋力一搏。—— 《夏目友人帐》 手搓 list 容器 1 前言1.1 底层结构1.2 使用场景1.3 功能简介 2 框架搭建2.1 节点类2.2 list 类2.3 迭代器类 3 功能实现3.1 begin() 与 end()3.2 插入操作3.3 删除操作3…
阅读更多...
[leetcode]从链表中删去总和值为零的连续节点

[leetcode]从链表中删去总和值为零的连续节点

. - 力扣&#xff08;LeetCode&#xff09; 给你一个链表的头节点 head&#xff0c;请你编写代码&#xff0c;反复删去链表中由 总和 值为 0 的连续节点组成的序列&#xff0c;直到不存在这样的序列为止。 删除完毕后&#xff0c;请你返回最终结果链表的头节点。 你可以返回任…
阅读更多...
【数据结构】线性表部分习题2（顺序表与链表）

【数据结构】线性表部分习题2（顺序表与链表）

数据结构&#xff08;线性表部分2&#xff09; 数据结构习题持续更新中&#xff01;&#xff01;&#xff01; 目录 一、单选题二、简答题1. 顺序表就地逆置2. 循环单项链表的就地逆置 作业习题笔记&#xff1a; 该部分是线性表部分习题的补充、更多习题见: 数据结构&#xf…
阅读更多...
二叉树链式存储详解

二叉树链式存储详解

文章目录 二叉树链式存储详解前言二叉树的基本概念二叉树节点的定义创建二叉树节点插入节点二叉树的遍历前序遍历中序遍历后序遍历 示例程序总结 二叉树链式存储详解 前言 二叉树是数据结构中一个非常重要的概念&#xff0c;它广泛应用于各种算法和程序设计中。在C语言中&…
阅读更多...

Copyright @ 2022~2023