努力找工作呀

题目：设计LRU缓存结构，该结构在构造时确定大小，假设大小为K，并有如下两个功能set(key, value)：将记录(key, value)插入该结构 get(key)：返回key对应的value值[要求]set和get方法的时间复杂度为O(1) 某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。 当缓存的大小超过K时，移除最不经常使用的记录，即set或get最久远的。若opt=1，接下来两个整数x, y，表示set(x, y) 若opt=2，...

题目一：给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { if(root==null) { return null; } if(root==p || root==q) { return root; }

1.前序遍历递归： public List<Integer> preorderTraversal(TreeNode root) { List<Integer> list=new ArrayList<>(); preL(root,list); return list; } public void preL(TreeNode node,List<Integer> list) {

题目：HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)方法一：找出规律public class Solutio

求出1~13的整数中1出现的次数,并算出100~1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。方法一：...

题目：数字以0123456789101112131415…的格式序列化到一个字符序列中。在这个序列中，第5位（从下标0开始计数）是5，第13位是1，第19位是4，等等。请写一个函数，求任意第n位对应的数字。方法一：从0开始进行枚举。每枚举一个数字的时候，求出该数字是几位数，然后把该数字的位数与前面所有数字的位数进行累加。如果位数之和小于或等于n,继续枚举下一个。当大于n的时候，那么n位数字就一定在这个数字里，然后在这个数字中找出对应的一位。方法二：找出规律，跳过某些数字。例如序列的第1001位是什么

题目：如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。方法一：使用数组来存储读出来的数据。如果数组没有排序，可以使用Partition方法找出中位数。在没有排序的数组插入一个数和找出中位数的时间复杂度是o(1)和o(n）方法二：可以在插入新数据时让数组保持排序，因为是数

题目：输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。方法一：最简单的方法就是排序，然后找出最小的K个数。可以使用快排，冒泡等。还可以调用工具类Arrays.sort方法进行排序方法二：使用分治的方法。如果基于数组的第K个数来调整，则使得比第K个数小的所有数字都位于数组的左边，比K个数字大的所有数字都位于数组的右边。这样调整后，位于数组左边的K个数字就是最小的K个数组。这个时间复杂度是o(n)方法三：方法二的缺点在于会改变数

题目描述：输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则按字典序打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。方法：求整个字符串的排列，可以看做两步。第一步求可能出现在第一个位置的字符，把第一个字符和后面的字符进行交换。第二步就是固定第一个字符，求后面的字符排列。仍然把后面的字符分成两部分：后面第一个字符，以及这个字符后面的所有字符，然后把第一个字符和后面的字符进行交换。另外题目中说明可能存在重复的字符，因此在进行交换的时

题目：输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）方法一：复制原始链表上的节点，然后用next指针串起来，然后设置每个节点的random指针。设置random指针的时候，需要从链表头结点开始经过o(n)步才能找到，这个时间复杂度是o(n^2)方法二：使用HashMap，将链表的节点放入HashMap中，然后在复制

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.方法：定义四个变量代表范围，up、down、left、right向右走存入整行的值，当存入后，该行再也不会被遍历，代表上边界的 up 加一，同时判断是否和代表下边界的 down 交错 向下走存入整列的值，当存入后，该列再也不会被遍历

题目描述：请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。 但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。 方法一（字符串匹配）：表示字符串遵循模式A[.[B]][e|EC]或者.B[e|EC]，A是整数部分，B是小数点部分，C是紧跟着E|e的数值。A和C是带正负号的整数，且正负号位于A和C的首部，且B是不带正负号的整数 ...

题目：请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配。方法：有两个指针s和p,s指向字符串，p指向模式1.首先我们分析出现'.'的情况，从题目中可以知道，这个符号可以代表任意一个字符，也就是这两个指针同时后移一位（或者是这两个字符相等）2.当出现'*

回溯法可以看做暴力法的升级版。从解决问题的每一步的所有可能选择里系统选择一个可行的解决方案。这个方法非常适合多个步骤组成的问题，并且每个步骤有多个选项。可以形象的用树状结构表示。在某一步有n个可能的选项，那么该步骤可以看做是树状结构的一个节点，每个选项都看作是树中节点的连接线，经过这些连接线到达该节点的n个子节点，树的叶节点对应终结状态，如果叶节点的状态满足题目的约束条件，就找到了一个可行的解决方案。如果不满足，就回溯到上一个节点继续尝试其他选项，如果上一节点的所有可能的选项都被选择，还是不满足约束条件

题目：把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组[3,4,5,1,2]为[1,2,3,4,5]的一个旋转，该数组的最小值为1。NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。方法一：暴力破解法，从头到尾遍历数组一次，时间复杂度为o(n)方法二：旋转之后的数组实际上可以划分为两个排序的子数组，而且前面子数组的元素都大于或等于后面子数组的元素。最小的元素刚好是这两个子数组的分界线，可以在排序数组使用二

题目：大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）n<=39。方法一：使用递归 public int Fibonacci(int n) { if(n==0){ return 0; } if(n==1){ return 1; } return Fibonacci(n-1)+Fibonacci(n-2)

给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。方法一（递归）：因为二叉搜索树中序遍历后是已经排序好的，所以使用中序遍历/*public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = ..

请实现两个函数，分别用来序列化和反序列化二叉树二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。例如，我们可以把一个只有根节点为1的二叉树序列化为"1,"，然后通过自己的函数来

题目：请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。方法一： 这个方法和深度遍历没啥区别，BFS每次只取一个，但是这里得到队列的长度size，这里的size就是这一层的节点的个数。然后通过poll方法循环出这个size的节点。这里之字形取值的核心思路就是： (1)list.add(T): 按照索引顺序从小到大依次添加 (2)list.add(index, T): 将元素插入in...

题目：输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。方法一：在转换的时候，原先指向左子节点的指针调整为链表中指向前一节点的指针，原先指向右子节点的指针调整为链表中指向后一节点的指针。先递归转换左右子树，然后把左右子树排序转换成排序后的双向链表再和根节点连接起来。import java.util.ArrayList;/**public class TreeNode { int val = 0; TreeNode

题目：输入一颗二叉树的根节点和一个整数，按字典序打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径本题要求找到从根节点到各个叶子节点的每一条路径，并把路径上的所有节点之和与某个数相比较，这符合深度优先遍历（DFS）的特点。执行步骤如下：1. 将传入方法的节点的值加入路径列表的list 2.判断该节点有无孩子节点 (1) 若没有孩子节点，则该节点为叶子节点，表示该路径已经走完。比较该节点值和目标值tar...

题目：输入一棵二叉树，判断该二叉树是否是平衡二叉树。在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树方法一：得到左右子树的深度，如果每个节点左右子树的高度之差的绝对值不超过1，就是一颗平衡二叉树。（借助递归的形式）缺点：一个节点会被重复遍历很多次，时间效率不高。public class Solution { //递归判断左右子树的高度差 //以每个节点为根的树的高度，然后根据左右子树高度差来判断是否满足定义 //每个节点被遍历了很多次 public

题目：输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则返回true,否则返回false。假设输入的数组的任意两个数字都互不相同。在后序遍历得到的序列中，最后一个数字是树的根节点的值。数组中前面中数字可以分为两个部分，第一部分是左子树节点的值，它们都比根节点的值小；第二部分是右子树的值，它们都比根节点的值大。用同样的方法确定与数组每一部分对应的子树的结构，这就是一个递归的过程。public class Solution { public boolean VerifyS

题目：给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。解法：（1）有右子树，下一节点是右子树中的最左节点；（2）无右子树，且节点是该父节点的左子树，则下一节点是节点的父节点；（3）无右子树，且节点是该节点的父节点的右子树，则沿着父节点追溯，直到找到某个节点是父节点的左子树，如果存在这样的节点，那么这个节点的父节点就是要找的节点；/*public class TreeLinkNode { in

题目：输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。方法一：递归的方式。如果一棵树只有一个节点，那么它的深度为1。如果根节点只有左子树而没有右子树，树的深度就是其左子树深度加一。同样，如果根节点只有右子树而没有左子树，树的深度就是其右子树深度加一。如果既有左子树和右子树，该树的深度就是其左右子树的深度的较大值再加一。/**public class TreeNode { int val = 0; TreeNo

题目一：输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）第一步：在树A中查找与根节点的值一样的节点。一定要注意边界条件的检查，即检查空指针。当树A和树B为空的时候，定义相应的输出。第二步：判断树A中以R为根节点的子树是不是和树B有相同的结构。还是使用递归处理：如果节点R的值和树B的根节点的值不相同，则以R为根节点的子树和树B肯定不具有相同的节点。如果它们的值相同，则递归的判断它们各自左右节点是不是相同。递归的终止条件是我们达到了树A或者树B的叶子节点/

题目：从上往下打印出二叉树的每个节点，同层节点从左至右打印。进行层次遍历需要借助一个队列。先将二叉树的根节入队，然后出队，访问该节点，如果有左子树，则将左子树入队；如果有右子树，则将右子树入队。然后出队，对出队节点进行访问，直到队列为空。在Java中Queue是和List、Map同等级别的接口，LinkedList中也实现了Queue接口，该接口中的主要函数有：容量不够或队列为空时不会抛异常：offer（添加队尾元素）、peek（访问队头元素）、poll（访问队头元素并移除） 容量不够或队列为

题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。解法：在二叉树的前序遍历序列中，第一个数字总是树的根节点的值，在中序遍历序列中，根节点的值位于中序序列的中间，左子树的节点的值位于根节点的值得左边，右子树的节点的值位于根节点的值的右边，需要扫描中序序列，才能得到根节点的位置。根据这个位置，我们可以知道左子树和右

题目：给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。解题步骤：1.先确定这个链表中包含一个环。定义两个指针，同时从链表出发，一个指针一次走一步，另一个指针一次走两步。 如果走的快的指针追上了走的慢的指针，那么链表就包含环。2.从两个指针相遇的节点出发，一边继续向前移动一边计数，当再次回到这个节点的时候，就可以得到环节点的个数了。3.让两个指针再次指向链表的头部，如果环中有n个节点，则一个指针现在链表上向前移动n步，然后两个指针以相同的速度移动。当第二个指针指向环的

题目一：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分。解法：这个题目的意思是奇数出现在偶数前面。也就是说，如果发现了偶数出现在奇数前面，则交换这两个的顺序 。第一个指针指向数组的第一个数字，只向后移动。第二个指针指向数组的最后一个数字，只向前移动。在两个指针相遇之前，第一个指针总是位于第二个指针前面。如果第一个指针指向的数字是偶数，第二哥指针指向的是奇数，则交换两个数字。 public static void reOrder

题目：定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。(1)在栈里添加一个成员变量存放最小的元素。每次压入一个新元素进栈的时候，如果该元素比当前最小的元素还小，则更新最小元素。 但是这个方法存在一个缺陷，如果当前最小的元素被出栈了，如何得到下一个最小元素？(2)把每次的最小元素（之前的最小元素和新压入栈的元素两者的最小值的较小值）都保存起来存放在另一个辅助栈里。 *就能保证辅助栈的栈顶一直是最小的元素，当最小元素从数据栈内被弹出后，同时弹出辅助栈

题目：输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）借助一个辅助栈，如果下一个弹出的数字刚好是栈顶数字，那么直接弹出。如果下一个弹出的数字不在栈顶， 则把压栈队列中还没有压栈的数字压入，直到把下一个需要弹出的数字压入栈顶为止。 如果所有数字都压入栈后.

题目一：用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。利用两个栈s1和s2模拟一个队列。当需要向队列中插入一个元素，用s1来存放已输入的元素，即s1执行入栈操作。当需要出队的时候，需要对s2进行出栈的操作。由于从栈中取出的元素的顺序是逆序，所以必须将s1中的所有元素全部出栈并入栈到s2中，再在s2中执行出栈操作，即可实现出队列操作，而在执行此操作之前必须判断s2是否为空。public class StackToQueue { Stack<Inte

题目一：在o(1)的时间内删除指定的节点常规的做法就是从链表的头结点开始，顺序遍历查找要删除的节点。因为要找到一个删除节点的前节点，时间复杂度为o(n)。这并不符合题目要求。方法：可以把下一个节点的内容复制到需要删除的节点上覆盖原有内容，再把下一个节点删除注意：（1）如果要删除的节点位于链表的尾部，那么就没有下一个节点了，仍然从链表的头结点开始，顺序遍历得到该节点的前序节点，并完成删除操作（2）如果链表中只有一个节点，又要删除这个链表的节点，删除节点之后，需要把链表的头结点设置为null

题目：输入两个链表，找出它们的第一个公共结点。方法一：两个单链表有公共节点，也就是说两个链表从某一个节点开始，next域都指向同一个节点，由于每个单链表节点只有一个Next域，因此从第一个公共节点开始，之后所有的节点都是重合的，不可能再出现分叉，所以，两个有公共节点而部分重合的单链表，形状看起来Y。 所以只要分别遍历两个链表到最后一个节点。如果两个尾节点是一样的，说明它们有公共节点，否则两个链表没有公共的节点。假设一个链表比另一个长K个节点，我们在长的链表上遍历K个节点，之后再同步遍历，此时我们就能保证

题目：输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。方法：两个链表已经是递增的，将其合并的时候，从第一个节点开始进行比较，将小的节点放入链表中，同时后移指针。要求合并后的链表满足单调不减的规则（也还是递增），采用尾插法。如果要求的递减的，采用的头插法。 //这个是新建了一个链表，并有头结点，返回的是头结点下一个节点 public ListNode Merge(ListNode list1,ListNode list2) { i

题目一：输入一个链表，反转链表后，输出新链表的表头。方法一：取下头结点，然后将后面的节点使用头插法进行插入，直到最后一个节点为止，实现了链表的反转。 //第一种方法：将头结点取下，然后从第一个节点开始，依次插入到头结点的后面（头插法），直到最后一个节点为止 //在有头节点下 public ListNode ReverseList(ListNode head) { if(head==null || head.next==null) {

题目一：输入一个链表，输出该链表中倒数第k个结点。方法一：假设整个链表有n个节点，那么倒数第k个节点就是从头节点开始的第n-k+1个节点。第一次遍历统计出链表中节点的个数，第二次就能找到倒数第k个节点。 /** * * 得到链表节点个数m * 注意的是不要使用head统计节点，因为链表指针移动过去了，还得移动回来 */ public ListNode FindKthToTail(ListNode head,int k) { if(h

题目一：输入一个链表的头结点，从尾到头打印出每个节点的值。链表的定义如下：public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; }}方法一：遍历链表的输出顺序是从头到尾，但是现在是从尾到头。也就是第一个遍历的节点最后一个输出，最后一个遍历的节点第一个输出，这就是先进后出。这个让我们想到了这个栈的结构。

题目：请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。方法一：这个字符串是StringBuffer类型的，不需要考虑这个的长度。 //给的是StringBuffer,可以直接修改 public String replaceSpace1(StringBuffer stringBuffer) { if(stringBuffer==null) {