链表

相交链表 判断两个链表是否 矩阵旋转 要求把n*n的矩阵顺时针旋转90°，空间复杂度为O（n） 菱形输出 有序链表相加 有两个有序链表，将他们组成一个有序链表 括号匹配 字符串相加 有两个字符串类型的数字，实现一个方法将它们进行相加，并返回相加后的数值 来源： CSDN 作者： zzz131313 链接： https://blog.csdn.net/sisil/article/details/104464235

今天剖析学习了LinkedBlockingQueue,总结下笔记 我们从类注释上大概可以得到如下信息： 1.基于链表的阻塞队列，其底层的数据结构是链表； 2.链表维护先入先出队列，新元素被放在队尾，获取元素从队头部拿； 3.链表大小在初始化的时候可以设置，默认是 Integer 的最大值； 4.可以使用 Collection 和 Iterator 两个接口的所有操作，因为实现了两者的接口。 LinkedBlockingQueue 内部构成简单来说，分成三个部分：链表存储 + 锁 + 迭代器，我们来看下源码。 static class Node < E > { E item ; /** * One of: * - the real successor Node * - this Node, meaning the successor is head.next * - null, meaning there is no successor (this is the last node) */ Node < E > next ; Node ( E x ) { item = x ; } } /** The capacity bound, or Integer.MAX_VALUE if none */ private final int capacity ; /** Current

昨天整理了链表的知识点，可以发现不管是单链表、循环链表、静态链表还是双向链表，原理都差不多，大家要多敲几遍代码。今天我们来整理 栈和队列 的知识点并做一个小实例看一下。 4.1初识栈 栈（stack）是限定仅在表尾插入和删除操作的线性表，允许插入和删除的一端称为“栈顶（top）”，另一端称为“栈底（bottom）”，不含任何数据元素的栈被称为空栈； 栈的特点：先进后出、后进先出。 注意： 栈又被称为后进先出（Last In First Out）结构的线性表，简称LIFO结构； 栈的插入操作，称为进栈，也称压栈、入栈（push）； 栈的删除操作，称为出栈，也成为弹栈（pop）。 可以将栈想象为一口井，入栈就是往井里扔东西，每扔一个都会落在前一个的上面，出栈就是从井里取东西，取的时候只能从最上面的开始取。那么当我们初始化一个栈时，栈顶和栈底都是一样的，当开始入栈的时候栈顶就会移动到入账的数据处，而出栈时也会从栈顶数据开始取出。 栈的抽象数据类型 ADT 栈 (Stack) Data 栈的数据对象集合为{a1, a2, a3, ..., an}，每个元素的类型均为DataType。其中，除第一个元素a1外，每个元素有且只有一个 直接前驱元素，除了最后一个元素an外，每个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。 Operation initStack(*S);

前段时间，小白经过日夜兼程，有了那么一丢丢基础，那么咋们现在拿起武器来进行刷怪吧！ 一、小怪篇 1.矩阵不仅是表示多维数组，而且是表示图的重要工具，这样的说法正确吗？ 这样的说话正确；图的表示方法有两种，分别是邻接矩阵和邻接表； 2.优化的起泡排序的排序趟数与参加排序的序列原始状态有关() 肯定的，优化过的气泡排序与序列有关，最初的与序列无关 3.对待排序的元素序列进行划分，将其分为左、右两个子序列，再对两个子序列施加同样的排序操作，直到子序列为空或只剩一个元素为止。这样的排序方法是 __ 快速排序 __ 。 快排思想：第一次排序，根据选取的枢纽元将序列分为两部分，枢纽元左边的A部分都比枢纽元小，枢纽元右边的B部分都比枢纽元大再分别对AB两部分进行枢纽元选取和划分 快速排序的思想就是分治法。 4.内部排序方法的稳定性是指该排序算法不允许有相同的关键字记录。 错误 排序方法的稳定性是指在排序过程中是否改变相同元素的相对位置，若不变则稳定，否则不稳定。 举个例子： 稳定：如果 a 原本在 b 前面，而 a = b ，排序之后 a 仍然在 b 的前面； 不稳定：如果 a 原本在 b 的前面，而 a = b ，排序之后 a 可能会出现在 b 的后面； 5.若串S=′software′,其子串的数目是() 37 刚开始，我填的是9 字串（包含空串）： n（n+1）/2 + 1 非空子串：n

一、哈希表 哈希表又称散列表。 哈希表存储的基本思想是：以数据表中的每个记录的关键字k为自变量，通过一种函数H(k)计算出函数值。把这个值解释为一块连续存储空间（即数组空间）的单元地址（即下标），将该记录存储到这个单元中。 在此称该函数H为哈希函数或散列函数。按这种方法建立的表称为哈希表或散列表。 例如，要将关键字值序列（3，15，22，24），存储到编号为0到4的表长为5的哈希表中。 计算存储地址的哈希函数可取除5的取余数算法H(k)=k% 5。则构造好的哈希表如图所示。 理想情况下，哈希函数在关键字和地址之间建立了一个一一对应关系，从而使得查找只需一次计算即可完成。由于关键字值的某种随机性，使得这种一一对应关系难以发现或构造。因而可能会出现不同的关键字对应一个存储地址。即 k1≠k2 ， 但 H(k1)=H(k2 )， 这种现象称为 冲突 。 把这种具有不同关键字值而具有相同哈希地址的对象称 “ 同义词 ” 。 在大多数情况下，冲突是不能完全避免的。这是因为所有可能的关键字的集合可能比较大，而对应的地址数则可能比较少。 对于哈希技术，主要研究两个问题： （1）如何设计哈希函数以使冲突尽可能少地发生。 （2）发生冲突后如何解决 。 二、哈希函数 构造好的 哈希函数 的方法，应能使冲突尽可能地少，因而应具有较好的随机性。这样可使一组关键字的散列地址均匀地分布在整个地址空间

.NET程序员，大多数时候是不需要数学的。因为，有了.NET, 数据结构和算法的重要性被弱化了，操作系统接口相关的东西被强化了。程序员只要求管理好代码，而不是设计好算法。 计算机，我只学会了技术，所以很多问题我都感觉似是而非，感觉是在学习一个API，而不是在学一门科学。 最近要实现一个哈希表，我查找了很多哈希函数，高下难分。而且，网上有很多人做了实验，但是，很多数据居然是矛盾的，有的说这个好，有的说那个好。于是我在想，有没有一种理想的最优函数，这样的函数的效率是多少。我的函数，只要接近于这个值就可以了。这样的理想函数的分析，就必须理解计算机的科学部分，这个是计算机科学永恒的部分。 首先，是一个很简单的也是很实用的问题： “给一个url 做一个hash 值，通过这个hash 值，查找这个url 是否已经在数据库中存在了，我相信很多人都做过这个问题，很多人采用把一个url 转换成一个无符号的int 类型，然后通过这个int 类型进行查找。现在的问题是，如果我的网站有1000万个url，会有多少个url 是发生哈希冲突呢，也就是说，url链接不一样，但是映射成了相同的哈希值。”有多少冲突，读完这篇文章你也就会算了。 我今天讲的只是哈希表中的一种类型：链地址哈希表。这种哈希表是最常用的哈希表，PHP数组的内部实现，就是采用这样的哈希表。估计.net 的字典类，也是通过这样的方法。

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。 示例: 输入: [ 1->4->5, 1->3->4, 2->6 ] 输出: 1->1->2->3->4->4->5->6 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/merge-k-sorted-lists 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 思路：简单的说就是建立一个堆，这个堆是排序的。使用Python库 在这里插入代# Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution: def mergeKLists(self, lists: List[ListNode]) -> ListNode: import heapq dummy = ListNode(0) p =start head = [] for i in range(len(lists)): if lists[i] : heapq.heappush(head,(lists[i].val,i)) lists[i] = lists[i].next while head

题目 输入两个链表，找出它们的第一个公共节点。 如下面的两个链表： 在节点 c1 开始相交。 示例 1： 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Reference of the node with value = 8 输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。 示例 2： 输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1 输出：Reference of the node with value = 2 输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。 示例 3： 输入：intersectVal = 0, listA = [2,6,4], listB =

160. 相交链表 编写一个程序，找到两个单链表相交的起始节点。 如下面的两个链表： 在节点 c1 开始相交。 示例 1： 输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3 输出：Reference of the node with value = 8 输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。 示例 2： 输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1 输出：Reference of the node with value = 2 输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。 示例 3： 输入：intersectVal = 0, listA = [2,6,4]

第一种做法，将链表放进数组里，然后在数组中间运用双指针从中间向左右开始比较，比较到有不同的这不是 但是第一种做法的空间不是O（1） 所以，第二种做法，上面有道题是反转整个链表，那么这里就可以只反转一半的链表，然后和剩下的一般进行比较，需要注意的是，可能有奇数个节点，可能有偶数个节点，这两种情况是要判断的。如果是奇数个节点，那么中间值在前半部分，这时候是要抛弃的，因为奇数个节点的话中间节点应该属于双方。 代码如下： 我是翻转的前半部分，有些题解我看是翻转的后半部分，而且他们是用了快慢指针，感觉更方便 来源： CSDN 作者： qq_40058686 链接： https://blog.csdn.net/qq_40058686/article/details/104448607