链表

Map hashMap：存放键值对的容器 ConcurrentHashMap(1.7) 1.8中ConcurrentHashMap SynchronizedMap&HashTable hashMap：存放键值对的容器 1、数据结构： 1.7：数组+链表 1.8：数组+链表+红黑树 （1.7Entry类；1.8Node类。本质一样） 内部包含了一个 Entry 类型的数组 table。Entry 存储着键值对，又存放了下一个Entry。所以Entry其实是一个链表。即数组中的每个位置被当成一个桶，一个桶存放一个链表。HashMap 使用拉链法来解决冲突，同一个链表中存放哈希值和散列桶取模运算结果相同的 Entry。 1.8较1.7引入了红黑树对hashMap数据结构进行优化； 引入原因：提高性能 当链表过长导致索引效率慢，利用红黑树快速增删改查优点，将时间复杂度由O(n)–>O(log(n)) 应用场景：链表长度 >8,转化为红黑树 2、主要使用API： 1.7与1.8基本相同 V get ( Object key ) ; // 获得指定键的值 V put ( K key , V value ) ; // 添加键值对 void putAll ( Map < ? extends K , ? extends V > m ) ; // 将指定Map中的键值对 复制到 此Map中 V

原帖地址：http://hi.baidu.com/passionlh/blog/item/bb3a8181d18819debd3e1e6a.html (1) 堆栈。驻留于常规RAM（随机访问存储器）区域，但可通过它的“堆栈指针”获得处理的直接支持。堆栈指针若向下移，会创建新的内存；若向上移，则会释放那些内存。这是一种特别快、特别有效的数据保存方式，仅次于寄存器。创建程序时，Java编译器必须准确地知道堆栈内保存的所有数据的“长度”以及“存在时间”。这是由于它必须生成相应的代码，以便向上和向下移动指针。这一限制无疑影响了程序的灵活性，所以尽管有些Java数据要保存在堆栈里——特别是对象句柄，但Java对象并不放到其中。 (2) 堆。一种常规用途的内存池（也在RAM区域），其中保存了Java对象。和堆栈不同，“内存堆”或“堆”（Heap）最吸引人的地方在于编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间。因此，用堆保存数据时会得到更大的灵活性。要求创建一个对象时，只需用new命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存。当然，为达到这种灵活性，必然会付出一定的代价：在堆里分配存储空间时会花掉更长的时间！ (3) 静态存储。这儿的“静态”（Static）是指“位于固定位置”（尽管也在RAM里）。程序运行期间

(1) 堆栈。驻留于常规RAM（随机访问存储器）区域，但可通过它的“堆栈指针”获得处理的直接支持。堆栈指针若向下移，会创建新的内存；若向上移，则会释放那些内存。这是一种特别快、特别有效的数据保存方式，仅次于寄存器。创建程序时，Java编译器必须准确地知道堆栈内保存的所有数据的“长度”以及“存在时间”。这是由于它必须生成相应的代码，以便向上和向下移动指针。这一限制无疑影响了程序的灵活性，所以尽管有些Java数据要保存在堆栈里——特别是对象句柄，但Java对象并不放到其中。 (2) 堆。一种常规用途的内存池（也在RAM区域），其中保存了Java对象。和堆栈不同，“内存堆”或“堆”（Heap）最吸引人的地方在于编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间。因此，用堆保存数据时会得到更大的灵活性。要求创建一个对象时，只需用new命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存。当然，为达到这种灵活性，必然会付出一定的代价：在堆里分配存储空间时会花掉更长的时间！ (3) 静态存储。这儿的“静态”（Static）是指“位于固定位置”（尽管也在RAM里）。程序运行期间，静态存储的数据将随时等候调用。可用static关键字指出一个对象的特定元素是静态的。但Java对象本身永远都不会置入静态存储空间。 堆：顺序随意 栈：先进后出 堆和栈的区别

题目描述 给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。 示例 给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后，链表变为 1->2->3->5. 说明：给定的 n 保证是有效的。 你能尝试使用一趟扫描实现吗？ 解题思路 1.快慢指针一次扫描法 要注意的是可能是要删除第一个节点 java代码如下： public class Solution { private class ListNode { int val ; ListNode next ; ListNode ( int x ) { val = x ; } } public ListNode removeNthFromEnd ( ListNode head, int n ) { ListNode pre = new ListNode ( Integer.MIN_VALUE ) ; ListNode later = new ListNode ( Integer.MIN_VALUE ) ; pre.next = head ; //引入虚拟头结点 later.next = head ; for ( int i = 0 ; i < n ; i++ ) { pre = pre.next ; //pre先行n步 if ( pre == null ) { //说明链表节点个数不足n

题目描述 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 示例 给定 1- > 2- > 3- > 4, 你应该返回 2- > 1- > 4- > 3. 思路 迭代 链表两两位置交换，具体看代码。 代码 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution { public ListNode swapPairs ( ListNode head ) { //新建一个头节点放在head前面 ListNode pre = new ListNode ( - 1 ) ; pre . next = head ; //头结点复制一份，用来操作，另一份用来输出的时候用 ListNode temp = pre ; while ( temp . next != null && temp . next . next != null ) { //在交换时，head即temp.next是第一个数，head.next是第二个数 ListNode firstNode = temp . next ;

这是发生在很多年以前的故事…… 几天以前…… 几天之后…… 拍卖行的商品总数量有几十万件，对应数据库商品表的几十万条记录。 如果是按照商品名称精确查询还好办，可以直接从数据库查出来，最多也就上百条记录。 如果是没有商品名称的全量查询怎么办？总不可能把数据库里的所有记录全查出来吧，而且还要支持不同字段的排序。 所以，只能提前在内存中存储有序的全量商品集合，每一种排序方式都保存成独立的集合，每次请求的时候按照请求的排序种类，返回对应的集合。 比如按价格字段排序的集合： 比如按等级字段排序的集合： 需要注意的是，当时还没有Redis这样的内存数据库，所以小灰只能自己实现一套合适的数据结构来存储。 拍卖行商品列表是线性的，最容易表达线性结构的自然是数组和链表。可是，无论是数组还是链表，在插入新商品的时候，都会存在性能问题。 按照商品等级排序的集合为例，如果使用数组，插入新商品的方式如下： 如果要插入一个等级是3的商品，首先要知道这个商品应该插入的位置。使用二分查找可以最快定位，这一步时间复杂度是O（logN）。 插入过程中，原数组中所有大于3的商品都要右移，这一步时间复杂度是O（N）。所以总体时间复杂度是O（N）。 如果使用链表，插入新商品的方式如下： 如果要插入一个等级是3的商品，首先要知道这个商品应该插入的位置。链表无法使用二分查找，只能和原链表中的节点逐一比较大小来确定位置

# -*- coding:utf-8 -*- # class ListNode: # def __init__(self, x): # self.val = x # self.next = None class Solution: def FindKthToTail(self, head, k): # write code here # 先考虑k若大于链表的长度，返回None,链表的长度咋算，不太会,可以在遍历的时候count+1 # 我的思路是，从头到尾遍历链表，将其存在list中，如果len(list)<k,返回None；如果k=0，也返回None result = [] while head: result.append(head) head = head.next if k > len(result) or k == 0: return None return result[len(result)-k] 　思路2：参考书书中的解题思路，只遍历一遍链表，就可以找到倒数第k个节点。我们这样思考，倒数第k个就是正数第n-k+1个。可以设置2个指针，2个指针相差k-1步，当前面的走的指针走到最后了，那我们的后指针就走到了n-k+1的位置。 # -*- coding:utf-8 -*- # class ListNode: # def __init__(self, x): # self

题目：输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如一个链表有6个节点，从头节点开始它们的值一次是1,2,3,4,5,6。这个链表的倒数第三个节点是值为4的节点。 链表节点定义如下： struct ListNode{ 　　　　int m_nValue; 　　　　ListNode* m_pNext; 　　} 解析：有两种方法可以实现，一种是第一遍遍历链表，得到链表节点的个数n，之后再一次遍历，n-k+1节点即为倒数第k个节点，这种方法要先遍历一遍，复杂度高。第二种方法是用两个指针，移动两个指针，保证两个指针间隔为k，等到前面的指针遍历到链表的结尾时，后面指针所指即为倒数第k个节点。代码如下： 1 struct ListNode{ 2 int m_nValue; 3 　　ListNode* m_pNext; 4 }; 5 //注重代码的鲁棒性，pListHead为NULL的情况，k-1大于整个链表长度的情况都要考虑到 6 ListNode* FindKthToTail(ListNode* pListHead,int k){ 7 if(pListHead == NULL || k <= 0) 8 return NULL; 9 ListNode* pAhead = pListHead; 10 ListNode*

环形链表 题目描述 public class Solution { public bool hasCycle ( ListNode head ) { if ( head == null || head . next == null ) return false ; ListNode slow = head ; ListNode fast = head . next ; while ( slow != fast ) { if ( fast == null || fast . next == null ) return false ; slow = slow . next ; fast = fast . next . next ; } return true ; } } 来源： CSDN 作者： qq_45100348 链接： https://blog.csdn.net/qq_45100348/article/details/104903574

概述 HashMap是线程不安全的map, ConcurrentHashMap 是线程安全的map，并能适应高并发的场景。 核心属性和数据结构 final int segmentMask; final int segmentShift; key生成的hash值 位移segmentShift 并与上segmentMask 就是 这个key的Segment在segments数组中的索引位置。 final Segment<K,V>[] segments;//存储数据的segment数组 ConcurrentHashMap数据由segment数组存储，每个segment都是哈希表的结构。多线程下，命中同一个Segment才会 锁排队，这样设计减少了锁竞争的几率。 源码分析 构造方法分析 public ConcurrentHashMap() { this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL); } // 默认 initialCapacity ==16，loadFactor==0.75，concurrencyLevel==16 public ConcurrentHashMap(int initialCapacity, float loadFactor, int