链表

思路 1 ：两个指针 p1 ,p2 ，p1从头开始遍历，当 p1 到达第 k 个节点时，p2 开始； 当 P1 到达链表的最后一个节点时，p2 所指的节点则为链表中倒数第 k 个节点。 public class Node{ public int data; public Node next; public Node(int data){ this.data = data; } public Node removeLastKNode(Node head,int k){ if(head == null || k < 1){ return head; } Node p1 = head; Node p2 = head; int num = 1; while(p1.next != null && num < k){ ++num; p1 = p1.next; } while(p1.next != null){ p1 = p1.next; p2 = p2.next; } p2.next = p2.next.next; return head; } } 思路 2：时间复杂度 O（n） ,空间复杂度 O（1）。 1>若链表为空或 K < 1，直接返回； 2>链表从头走到尾，每移动一步，k 值减 1 ; 3>若 k > 0，则没有倒数第 k 个节点，返整个链表； 若 k = 0，则头结点为倒数第 k

目录 存储结构 初始化 put resize 树化 get 为什么HashMap中equals()和hashCode()要同时重写？ 为何HashMap的数组长度一定是2的次幂？ 线程安全 参考 存储结构 JDK1.8前是数组+链表，JDK1.8之后是数组+链表+红黑树。本文分析基于JDK1.8源代码。 HashMap的基础结构是Node ，它存着hash、键值对，Node类型的指针next。 主干是桶数组，链表bin用于解决hash冲突，当链表的Node超过阈值(8)，执行树化操作，将该链表改造成红黑树。 图片来源：Java核心技术36讲 初始化 HashMap有4个构造器，其他构造器如果用户没有传入initialCapacity （容量）和loadFactor（负载因子）这两个参数， 会使用默认值 ，initialCapacity默认为16，loadFactory默认为0.75。 基于lazy-load原则，主干数组table的内存空间分配不在初始化中，而是在put中。 public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " +

将链表里面的数字取出来，再倒着放回去就好了 /** Definition for singly-linked list. struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; / class Solution { public: ListNode reverseList(ListNode* head) { ListNode* tem=new ListNode(sizeof(ListNode)); ListNode* t=tem; vector<int>cc; while(head!=NULL) { cc.push_back(head->val); head=head->next; } for(int i=cc.size()-1;i>=0;i--) { ListNode* ret=new ListNode(sizeof(ListNode)); ret->val=cc[i]; t->next=ret; t=t->next; } t->next=NULL; return tem->next; } }; 来源： CSDN 作者： qq_40742888 链接： https://blog.csdn.net/qq_40742888/article/details

http://www.importnew.com/16301.html 好的链接 HashMap的工作原理？ 1. HashMap的底层结构是 数组加链表 ； a.HashMap包含一个Entry(key,value,next,hash)的内部类，key/value放入HashMap 的时候都会被包装成Entry的 对象 b.HashMap成员就有Entry数组，该数组的大小默认是16，永远都是2的次方数，如果自己给出的不是 2的次方数会转换成大 于并接近自己给的2 的次方数。 put(key,value)就是转换成Entry对象并放入数组中。 2.put方法的实现； c.1 根据key的HashCode进行Hash运算，得到hash值 c.2 根据hash值去确定数组的位置， hash&(table.length-1)等价于hash%(table.length) length是2的次方数该 公式成立， 正获取数组的位置 <bucket>。 c.3 如果这个位置没有元素存在，直接包装成Entry实例，给元素数组附值； 如果计算出的位置有元素已经存在，就会判断key是否相同，如果相同就会覆盖，并且遍历整个链表 如果都不覆盖插入到链表的头部 。 for (Entry<K,V> e = table [ i ]; e != null ; e = e . next ) 注意1

创建两个同地址表头，再将其中一个对两个链表进行排序 返回另一个表头->next，因为地址相同，所以返回的是排序好的链表 /** Definition for singly-linked list. struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; / class Solution { public: ListNode mergeTwoLists(ListNode* l1, ListNode* l2) { ListNode *l3 = new ListNode(sizeof(ListNode)); ListNode *tem=l3; while(l1!=NULL&&l2!=NULL) { if(l1->valval) { tem->next=l1; tem=tem->next; l1=l1->next; } else { tem->next=l2; tem=tem->next; l2=l2->next; } } if(l1!=NULL)tem->next=l1; if(l2!=NULL)tem->next=l2; return l3->next; } }; 来源： CSDN 作者： qq_40742888 链接： https://blog.csdn.net/qq

LeetCode 142 链表 Linked List Cycle II LeetCode Given a linked list, return the node where the cycle begins. If there is no cycle, return null. To represent a cycle in the given linked list, we use an integer pos which represents the position (0-indexed) in the linked list where tail connects to. If pos is -1, then there is no cycle in the linked list. Note: Do not modify the linked list. Example 1: Input: head = [3,2,0,-4], pos = 1 Output: tail connects to node index 1 Explanation: There is a cycle in the linked list, where tail connects to the second node. 代码： public class Solution { public

此题设快慢两个指针，先判断是否有环：如果为环快慢指针终会相遇； 找入口节点：快慢指针相遇的节点到入口节点的距离，与从头节点开始新的慢指针到相遇点的距离相同。 可画图演示。因为快指针是慢指针的两倍速，且他们在q点相遇，则我们可以得到等式 2(A+B) = A+B+C+B.得出C=A function EntryNodeOfLoop(pHead){ if(pHead == null || pHead.next == null||pHead.next.next==null){ return null; } let fast = pHead; let slow = pHead; while(fast != null && fast.next != null){ fast = fast.next.next; slow = slow.next; if(fast == slow){ let slow2 = pHead; while(slow2 != slow){ slow2 = slow2.next; slow = slow.next; } return slow2; } } } 来源： https://www.cnblogs.com/mlebk/p/12396046.html

所谓序列容器，即以线性排列（类似普通数组的存储方式）来存储某一指定类型（例如 int、double 等）的数据，需要特殊说明的是，该类容器并不会自动对存储的元素按照值的大小进行排序。 1.array<T,N> (数组容器) ：是一个长度固定的序列，有 N 个 T 类型的对象，不能增加或删除元素。 2.vector (向量容器) ：是一个长度可变的序列，用来存放T类型的对象。是一个长度可变的序列容器，即在存储空间不足时，会自动申请更多的内存。使用此容器，在尾部增加或删除元素的效率最高（时间复杂度为 O(1) 常数阶），在其它位置插入或删除元素效率较差（时间复杂度为 O(n) 线性阶，其中 n 为容器中元素的个数）； 3.deque (双向队列容器) ：和 vector 非常相似，区别在于使用该容器不仅尾部插入和删除元素高效，在头部插入或删除元素也同样高效，时间复杂度都是 O(1) 常数阶，但是在容器中某一位置处插入或删除元素，时间复杂度为 O(n) 线性阶； 4.list (链表容器) 是一个长度可变的、由 T 类型对象组成的序列，它以双向链表的形式组织元素，在这个序列的任何地方都可以高效地增加或删除元素。访问容器中任意元素的速度要比前三种容器慢，这是因为 list 必须从第一个元素或最后一个元素开始访问，需要沿着链表移动，直到到达想要的元素。 5.forward list

单链表 ：链表中的每个元素实际上是一个单独的对象，而所有对象都通过每个元素中的引用字段链接在一起。 双链表 ：与单链表不同的是，双链表的每个结点中都含有两个引用字段。 链表的优点如下 ： 链表能灵活地分配内存空间； 能在 O(1)时间内删除或者添加元素，前提是该元素的前一个元素已知，当然也取决于是单链表还是双链表，在双链表中，如果已知该元素的后一个元素，同样可以在O(1) 时间内删除或者添加该元素。 链表的缺点是 ： 不像数组能通过下标迅速读取元素，每次都要从链表头开始一个一个读取； 查询第 k 个元素需要 O(k) 时间。 **应用场景：**如果要解决的问题里面需要很多快速查询，链表可能并不适合；如果遇到的问题中，数据的元素个数不确定，而且需要经常进行数据的添加和删除，那么链表会比较合适。而如果数据元素大小确定，删除插入的操作并不多，那么数组可能更适合。 相关LeetCode经典的练习题请关注公众号，从『菜单-算法-数据结构』对应文章中获取。 来源： CSDN 作者： BaryLeo 链接： https://blog.csdn.net/weixin_41878312/article/details/104619822

目录 【LeetCode题解】2_两数相加 描述 方法一：小学数学 思路 Java 代码（非递归写法） Java 代码（递归写法） Python 代码（非递归写法） 【LeetCode题解】2_两数相加 描述 给定两个 非空 链表来表示两个非负整数。位数按照 逆序 方式存储，它们的每个节点只存储单个数字。将两数相加返回一个新的链表。 你可以假设除了数字 0 之外，这两个数字都不会以零开头。 示例： 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 原因：342 + 465 = 807 方法一：小学数学 思路 按照小学数学中求两数之和的做法，从最低位（链表表头）开始加起，用变量 carry 保存进位的结果（初始值为0），每次求和之后更新变量 carry 的值。 Java 代码（非递归写法） /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { ListNode dummyHead =