我的梦境传说

原型模式即使用已经创建的对象作为原型，通过复制该原型对象得到一个和原型完全相同的新对象。

反转链表的两种方法

/*解题思路分别使用两个hashmap来计数（每个字符出现的次数），如果要组成的字符串中字符出现的次数大于提供的字符数量，就返回false,否则为true。*///代码class Solution { public boolean canConstruct(String ransomNote, String magazine) { HashMap<Character,Integer> map1 = new HashMap<>(); .

class Solution { public boolean containsDuplicate(int[] nums) { Set<Integer> set = new HashSet<>(); for(int i=0;i <nums.length;i++){ if(set.contains(nums[i])){ return true; }else{.

/** * Definition for singly-linked list. * class ListNode { * int val; * ListNode next; * ListNode(int x) { * val = x; * next = null; * } * } */public class Solution { public boolean hasCycle(ListNode head) {.

class Solution { public void merge(int[] nums1, int m, int[] nums2, int n) { int[] result = new int[m+n]; int index = 0; int i=0,j=0; for(;i < m && j < n; ){ if(nums1[i] <= nums2[j]){ .

import java.util.Arrays;//167. 两数之和 II - 输入有序数组public class TwoSum { /** * 思路是使用二分搜索，因为是升序的数组，如果low+high得到的值大于target， * 则high--，等于target则退出，否则是low++ */ public static int[] twoSum(int[] arr, int target){ int[] result = {-1,.

解题思路计算此数的各个位置的平方和，将结果放入map中，如果在map中出现的次数大于1则证明出现了无限循环，就可以返回false，否则的话，看是否此数的平方和为1，则返回true代码class Solution { public boolean isHappy(int n) { int sum = 0; HashMap<Integer,Integer> map = new HashMap<>(); map.p

/** * * * 面试题 16.11. 跳水板 * 你正在使用一堆木板建造跳水板。有两种类型的木板，其中长度较短的木板长度为shorter，长度较长的 * 木板长度为longer。你必须正好使用k块木板。编写一个方法，生成跳水板所有可能的长度。 * 返回的长度需要从小到大排列。https://leetcode-cn.com/problems/diving-board-lcci/ * ### 解题思路 * 看短板和长板的数量，用它们的长度相乘得到结果， *.

public class FibArray { //非递归实现 public static int fib(int N) { if(N <= 1){ return N; } return memorize(N); } public static int memorize(int N){ int[] cache = new int[N + 1]; cache[1].

public class SwapNode2 { public static ListNode swapNode(ListNode head){ if(head == null || head.next == null){ return head; } ListNode firstNode = head; ListNode secondNode = head.next; firstNode.n.

/** * 两两交换链表中的节点 * 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 * 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 * 给定 1->2->3->4, 你应该返回 2->1->4->3. */public class SwapNode { /** * 解题思路 * 先按照奇偶性把链表分解成两个链表l1,l2， * 然后再合并，先先合并后面的链表l2，再合并前面的l1，也是按.

import java.util.Arrays;public class MyHeapSort { public static void heapSort(int[] nums){ for(int i = (nums.length - 1)/2; i >= 0; i--){ adjustHeap(nums, i, nums.length - 1); } for(int i = nums.length - 1; i&.

import java.util.Arrays;public class MyMergeSort { public static void mergeSort(int[] nums, int low,int high){ if(low < high){ int mid = low + (high - low) / 2; mergeSort(nums, low, mid); mergeSort(nums.

import java.util.Arrays;public class MyQuickSort { public static void quickSort(int[] nums){ quickSort(nums, 0, nums.length - 1); } public static void quickSort(int[] nums, int low, int high){ if(low < high){ .

/** * 给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。 * 如果数组中不存在目标值，返回[-1, -1]。 * 链接：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array */public class SearchRange { public static int[] searchRange(..

/** * 给定一个n个元素有序的（升序）整型数组nums 和一个目标值target ， * 写一个函数搜索nums中的 target，如果目标值存在返回下标，否则返回 -1。 * 链接：https://leetcode-cn.com/problems/binary-search */public class BinarySearch { public static int search(int[] nums, int target) { int high =...

package com.code.binary;/** * 颠倒给定的 32 位无符号整数的二进制位。 * 示例 1： * 输入: 00000010100101000001111010011100 * 输出: 00111001011110000010100101000000 * 解释: 输入的二进制串 00000010100101000001111010011100 表示无符号整数 43261596， * 因此返回 964176192，其二进制表示形式为 001110010111.

/** * 给定一个非负整数num。对于0 ≤ i ≤ num 范围中的每个数字i，计算其二进制数中的 1 的数目并将它们作为数组返回。 * 示例 1: * 输入: 2 * 输出: [0,1,1] * 示例2: * 输入: 5 * 输出: [0,1,1,2,1,2] * 链接：https://leetcode-cn.com/problems/counting-bits */public class CountBits { //遍历获取，存入数组中 public...

public class HammingWeight { public static int hammingWeight(int n) { int num = 0; int mask = 1; for(int i = 0; i < 32; i ++){ if((n & mask) != 0){ num ++; } mask <&.

import java.util.HashMap;import java.util.LinkedList;/** * 给定一个整数数组nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。 找出只出现一次的那两个元素。 * 示例 : * 输入: [1,2,1,3,2,5] * 输出: [3,5] * 链接：https://leetcode-cn.com/problems/single-number-iii */public class SingleNumber3 { ..

import java.util.HashMap;/** * 137. 只出现一次的数字 II * 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现了三次。找出那个只出现了一次的元素。 * 说明： * 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？ * 示例 1: * 输入: [2,2,3,2] * 输出: 3 * 示例 2: * 输入: [0,1,0,1,0,1,99] * 输出: 99 */public class SingleNumb.

/** * 只出现一次的数字 * 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 * 说明： * 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？ * https://leetcode-cn.com/problems/single-number/ */public class SingleNumber { public static int singleNumber(int[] nums){ fo.

import java.util.Stack;/** * 使用栈实现队列的下列操作： push(x) -- 将一个元素放入队列的尾部。 pop() -- 从队列首部移除元素。 peek() -- 返回队列首部的元素。 empty() -- 返回队列是否为空。 示例: MyQueue queue = new MyQueue(); queue.push(1); queue.push(2); queue.peek(); // 返回 1 queue.pop(); // 返回 1.

import java.util.Stack;/** * 逆波兰表达式求值 * 整数除法只保留整数部分。 * 给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。 * 示例1： * 输入: ["2", "1", "+", "3", "*"] * 输出: 9 * 解释: 该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9 * 来源：力扣（LeetCode） * 链接：https://leetcode-cn.com/problems..

类的加载过程分为三步： 加载-->链接-->初始化，其中链接又包含 验证-->准备-->解析 三个步骤。如下图所示：类的加载过程加载：在加载阶段，主要是在内存中生成一个对应这个类的java.lang.Class对象，作为方法区的这个类的各种数据的入口。这里的后缀名为.class文件不一定是从本地获取的，可以是从网络获取的，还可以是动态生成的。验证：主要是为了验证当前的文件是否符合Java虚拟机的要求，保证虚拟机的安全。准备：为类变量分配内存地址，...

/** * 对称二叉树 * 给定一个二叉树，检查它是否是镜像对称的。 * 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。 */public class IsSymmetric { public static boolean check(TreeNode p, TreeNode q){ //对比根节点是否相同 if(p == null && q == null){ return true; .

import java.util.Stack;public class MiniStack { public MiniStack(){ data = new Stack<>(); minValue = new Stack<>(); } Stack<Integer> data; Stack<Integer> minValue; public void push(int num){.

/** * 判断链表是不是回文链表 */public class IsPalindrome { //先找到链表的中间位置分开，然后把后半部分反转，遍历作比较，遇到不等就返回false public static boolean isPalindrome(ListNode head){ if(head == null){ return true; } ListNode fast = head; L.

/** * 判断一个链表是否有环， * 思路是快慢指针法，通过判断两个节点是否==， * 即内存地址相同则证明链表有环存在 *返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 */public class LinkedListCycle02 { /** * @param head 链表的头 * @return 是否有环 */ public static ListNode hasCycle(ListNode head){ .

/** *快慢指针，前面是慢指针一次走一个节点，快指针一次走两个节点， *直到快指针的后继节点为空。返回慢节点即可。/class Solution { public ListNode middleNode(ListNode head) { ListNode fast = head; ListNode slow = head; while(fast != null && fast.next != null){ .

/** * 判断一个链表是否有环， * 思路是快慢指针法，通过判断两个节点是否==， * 即内存地址相同则证明链表有环存在 */public class LinkedListCycle { /** * 给定一个链表，判断链表中是否有环。 * 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 * 如果 pos 是 -1，则在该链表中没有环。 * 示例 1： * 输入：head = [3,2.

/** * 在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序。 */public class SortList { //排序链表 public static ListNode sortList(ListNode list){ if(list == null || list.next == null){ return list; } //获取中间节点 ListNode mid.

/** * 给定一个链表和一个特定值 x，对链表进行分隔，使得所有小于 x 的节点都在大于或等于 x 的节点之前。 * 你应当保留两个分区中每个节点的初始相对位置。 * 示例: * 输入: head = 1->4->3->2->5->2, x = 3 * 输出: 1->2->2->4->3->5 * 来源：力扣（LeetCode） * 链接：https://leetcode-cn.com/problems/partition-lis.

/** * 将两个升序链表合并为一个新的升序链表并返回。 * 新链表是通过拼接给定的两个链表的所有节点组成的。 */public class MergeTwoList { /** * 思路是新建一个带头节点的链表，然后根据比较两个节点的值得大小， * 把小的那个存到新建的链表中，之后判断是否两个链表中有一个没有遍历完， * 把它添加到尾部即可，然后返回头节点的下一个节点即可。 * @param list1 链表一 * @param lis.

/** * 反转从位置 m 到 n 的链表。请使用一趟扫描完成反转 */public class ReverseListNode02 { public static ListNode reverseList(ListNode head, int m, int n){ ListNode temp = head; ListNode before = new ListNode(0); ListNode mid = null; Lis.

public class Solution1 { /** * 删除有序链表中重复的节点，只保留出现一次的节点 * @param head 链表 * @return 链表头 */ public static ListNode deleteDuplicates(ListNode head) { //链表的长度小于等于1，直接返回 if(head == null || head.next == null){ ...

/** * 反转单链表 */public class ReverseListNode { /** * 反转单链表,方法一使用的是链表的头插法 * @param head 传入的单链表 * @return 单链表的头 */ public static ListNode reverseList01(ListNode head){ ListNode temp = head; ListNode newList = nu.

public class MyCode { /** *链表比如1->2->,......->100；然后转化成1->100->2->99->3。。要求空间复杂度o1,时间复杂度On * 用奇偶性来把链表分成两个链表，然后合并，其中偶数的要使用头插法，奇数的使用尾插法。 * @param head */ public static Node dealLinkedList(Node head){ .

/** * 删除有序链表中的重复节点 */public class RemoveDuplicateFromSortedList { /** * 删除有序链表中的重复节点,第一种方法，双指针，当遇到不相同的值时用前面的指针的next指向后面指针的内容 * @param head 链表 */ public static void deleteDuplicateNode01(Node head){ //判断链表的长度必须大于1 .