链表

HashTable的特点 HashTable继承自Dictionary类，Dictionary 类是一个抽象类，在JDK 1.0中提供用来存储键/值对，作用和Map类相似。 HashTable类中，其数据结构与HashMap是相同的。依然是采用“链地址法”实现的哈希表，保存实际数据的，依然是Entry对象。 Entry<K,V> implements Map.Entry<K,V> { int hash; final K key; V value; Entry<K,V> next; } 和HashMap很类似 不同点： 1、HashTable是线程安全的（synchronized），HashMap线程不安全 2、HashTable是key和value不能为null,而HashMap允许key和value为空。 3、使用的迭代器不同，Hashtable的迭代器（enumerator）。 put方法 put方法的主要逻辑如下： 1. 先获取synchronized锁。 2. put方法不允许null值，如果发现是null，则直接抛出异常(key和value都不能为null)。 3. 计算key的哈希值和index 4. 遍历对应位置的链表，如果发现已经存在相同的hash和key，则更新value，并返回旧值。 5. 如果不存在相同的key的Entry节点，则增加节点。在新增节点时

题目一 代码实现 1 package class_03; 2 3 public class Code_07_ReverseList { 4 5 public static class Node { 6 public int value; 7 public Node next; 8 9 public Node(int data) { 10 this.value = data; 11 } 12 } 13 14 public static Node reverseList(Node head) { 15 Node pre = null; 16 Node next = null; 17 while (head != null) { 18 next = head.next; 19 head.next = pre; 20 pre = head; 21 head = next; 22 } 23 return pre; 24 } 25 26 public static class DoubleNode { 27 public int value; 28 public DoubleNode last; 29 public DoubleNode next; 30 31 public DoubleNode(int data) { 32 this.value = data; 33 } 34 } 35 36

​题目描述 给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序的方式存储的，并且它们的每个节点只能存储一位数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 之外，这两个数都不会以 0 开头。 1 示例： 2 输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 3 输出：7 -> 0 -> 8 4 原因：342 + 465 = 807 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/add-two-numbers 题目解析 本题是将两个链表形式的数字相加，计算结果也同样用链表来表示。链表在python中可以用类来描述，题中已经给出，其中包含数据域和指针域。关于链表在python中的实现我会再写一篇文章来阐述。对于本题来说数据在链表中的存储按逆序排列，也就是说链表的第一个节点就是数字的个位，依次为十位、百位等。两数相加完全可以按照小学列竖式加法来计算，也就是个位相加，向十位进位，以此类推。 需要注意的一点是，两个数字的位数不一定相等，那么可以先将存在的对应位相加，多出来的数位直接与进位相加即为结果。看程序会更容易理解一些。 1 # Definition for singly-linked list. 2 class ListNode: 3 def

再不会我就是猪 package dynamic ; /** * @Author free-go * @Date Created in 19:18 2020/2/11 **/ class MyLinkedList { ListNode head ; ListNode last ; int total ; class ListNode { //成员内部类 ListNode next ; int val ; public ListNode ( int val ) { this . val = val ; this . next = null ; } } /** Initialize your data structure here. */ public MyLinkedList ( ) { this . head = null ; //构造方法初始化 this . last = head ; this . total = 0 ; } /** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */ public int get ( int index ) { if ( index > total - 1 || index < 0 ) return - 1 ;

适可而止，见好就收 来源主要是 牛客 的Java实习面经。下面的回答直接背就可以，需要一定的Java基础，适合春招实习的同学，但是我会在每个问题下把有助于理解的博客贴出来。如果发现有问题欢迎私聊我或留言我会在下面更新 Map 1. Map的底层结构 腾讯19年秋招 这个题乍一看没有什么思路（因为Map是个集合，当然也有可能是我记错了），所以我们可以先介绍一下Map然后转到HashMap中 Map是一种使用键值对存储的集合。Map会维护与Key有关联的值。两个Key可以引用相同的对象，但Key不能重复，典型的Key是String类型，但也可以是任何对象。 在整个Map系列中，AbstractMap抽象类实现了Map，SortedMap接口继承了Map。而我们常用的HashMap，HashTable，TreeMap和ConcurrentHashMap有继承了AbstractMap类。 其中，HashTable和ConcurrentHashMap是线程安全的。前者是通过synchronized实现的，后者是通过AQS实现的。其中要注意HashTable不能存空值，HashMap是线程不安全的，key可以为空。TreeMap通过二叉树算法实现有序集合，它实现了SortedMap接口 2. HashMap的原理 阿里17年实习,小米19年秋招本科,滴滴19年秋招本科,网易19年秋招本科

A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null. Return a deep copy of the list. Example 1: Input: {"$id":"1","next":{"$id":"2","next":null,"random":{"$ref":"2"},"val":2},"random":{"$ref":"2"},"val":1} Explanation: Node 1's value is 1, both of its next and random pointer points to Node 2. Node 2's value is 2, its next pointer points to null and its random pointer points to itself. Note: You must return the copy of the given head as a reference to the cloned list. 这道链表的深度拷贝题的难点就在于如何处理随机指针的问题，由于每一个节点都有一个随机指针

顺序表 顺序表是用一段 物理地址连续 的存储单元依次存储数据元素的线性结构，一般采用 数组存储 。在数组上完成数据的增删查改。 顺序表一般可以分为： 静态顺序表：使用定长数组存储 #define N 100 typedef int SLDataType; typedef struct Seqlist { SLDataType* a[N]; //定长数组 size_t size; // 有效数据的个数 }SeqList; 动态顺序表：使用动态开辟的数组存储 typedef int SLDataType; //定义数据类型方便更改 typedef struct SeqList { SLDataType* a; //指向动态开辟的数组 size_t size; //有效数据个数 size_t capacity; //容量大小 }SeqList; 动态顺序表增删查改等实现： https://github.com/Ellyn-jia/Data-structure/tree/master/SeqList/SeqList 链表 链表是一种 物理存储结构上非连续、非顺序 的存储结构，数据元素的 逻辑顺序 是通过链表中的 指针链接 次序实现的。 链表的结构是多样的： 单向、双向 带头指针、不带头指针 单链表、循环单链表 常见的两种链表结构： 无头指针单向不循环链表：结构简单，在考察中出现较多 实现

题目： 在O(n log n)的时间内使用常数级空间复杂度对链表进行排序。 思路： 由于题目要求，时间复杂度要求为O(n log n)，所以，需要用归并排序。 找到链表的中间节点 通过中间节点将链表1分为2 两个链表进行比较，比较完之后进行合并。 代码： package com.company; import java.util.List; public class TestNo24 { //定义单链表 static class ListNode{ int val; ListNode next; ListNode(int x){ val = x; next = null; } public String toString(){ if(this.next == null){ return String.valueOf(this.val); } return this.val + "->" + this.next.toString(); } } public static void main(String[] args) { TestNo24 t = new TestNo24(); ListNode head = new ListNode(4); head.next = new ListNode(5); head.next.next= new ListNode(7); head

1、Collection接口和Collections包装类： 　　 Collection概念： 是一个集合接口，提供了对集合对象进行基本操作的通用接口方法。 　 有以下结构： 　　　　|--List 　　　　|　　|--LinkedList 　　　　|　　|--ArrayList 　　　　|　　|--Vector 　　　　|　　　　|--stack 　　　　|--Set 　　 Collections: 包含各种有关集合操作的静态多态方法，且该类无法实例化，相当于一个工具类。 2、HashMap、HashTable和ConcurrentHashMap： 　　 HashMap的特点 ：线程不安全，允许传入 null值，不能保存映射的顺序。由数组（默认长度为16）+链表组成，jdk1.8后，若其链表长度大于8，就会转变成红黑树。 　　　　ps：HashMap线程不安全，是因为多个对象同时对同一HashMap进行操作时，会导致脏读、数据丢失的发生。 　　详细参考：https://www.cnblogs.com/aspirant/p/8908399.html 　　 HashTable： 可以理解为线程安全的HashMap，为什么是线程安全的，因为它的put、remove、get方法都被synchronized修饰，使其同步，自然是线程安全的了。 　　 ConcurrentHashMap：

4.2 画图 题目-二叉树的镜像 操作给定的二叉树，将其变换为源二叉树的镜像。 思路 求二叉树镜像的过程：1）交换根结点的左右子树；2）交换值为10的结点的左右子结点；3）交换值为6的结点的左右子结点。 总结这个过程就是：前序遍历这棵树的每个结点，如果遍历到的结点有子结点，就交换它的两个子结点。 直到交换完所有非叶子结点的左右子结点。 解答 /** public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = val; } } */ public class Solution { public void Mirror(TreeNode root) { if((root==null) || (root.left==null && root.right==null)) return; //交换根结点的左右子树 TreeNode temp=root.left; root.left=root.right; root.right=temp; //交换原来根结点的左子结点的左右子结点 if(root.left!=null) Mirror(root.left); //交换原来根结点的右子结点的左右子结点 if(root