A Little Blog

package 上楼梯;public class GoUpstairs { private static final int MOD = 1000000007; public int countWays(int n) { // write code here if (n == 1) return 1; if (n

一段String 连接字符串的用法public String joinWords(String[] words){ String init = ""; for(String s:words){ init+=s;//每次拼接两个字符串 } return init; } 分析：每次拼接两个字符串时，包含

StringBuffer is synchronized, and StringBuilder is not. It is the main difference between StringBuffer and StringBuilder.Here's a simple benchmark test:public class Main { public static void main

参考链接：http://stackoverflow.com/questions/40471/differences-between-hashmap-and-hashtable 总结：1. hashmap不是线程安全的 2. hashtable是线程安全的 3. 单线程使用hashmap，因为它更快，或者说时间效率更高

package 链表分割;import java.util.*;class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; }}public class Partition { public ListNode partition(ListN

package 访问单个节点的删除;import java.util.*;class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; }}public class Remove { public boolean removeNode(Lis

我用的是deepin sudo apt-get install openjdk-8-source搞定

更加有趣的是： 如果你对此感兴趣，请自己深入探讨。 参考： http://stackoverflow.com/questions/2986296/what-are-the-differences-between-arraylist-and-vector 更新： 我今天打开ArrayList的源码，（如上图所示）如果空间不够，再次分配时增加的空间大小为(oldCapacity >>

package 双栈排序;import java.util.*;public class TwoStacks { public ArrayList<Integer> twoStacksSort(int[] numbers) { // write code here Stack<Integer> number = new Stack<Integer>();

import java.util.ArrayList;public class Solution { public static ArrayList<Integer> printMatrix(int[][] matrix) { ArrayList<Integer> als = new ArrayList<Integer>(); if (null == ma

package 清除行列;public class Clearer { public int[][] clearZero(int[][] mat, int n) { // write code here boolean[] row = new boolean[n]; boolean[] col = new boolean[n];

package 实时中位数;import java.util.Comparator;import java.util.PriorityQueue;public class Middle { public int[] getMiddle(int[] A, int n) { int[] res = new int[n]; // 小根堆存比较大的一半数

package 硬币表示;public class Solution { // 25, 10, 5, 1 public int countWays(int n) { final int mod = 1000000007; int[][] dp = new int[4][n + 1]; for (int i = 0; i < 4; i++)

package 数据流中的中位数;import java.util.Comparator;import java.util.PriorityQueue;public class Solution { private PriorityQueue<Integer> smallHeap = new PriorityQueue<Integer>(); private PriorityQue

package 数据流中的中位数;import java.util.ArrayList;import java.util.HashMap;//import java.util.ArrayList;import java.util.LinkedList;import java.util.Queue;public class Solution { public int FirstNotR

package 删除链表中重复节点;class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; }}public class Solution { public ListNode deleteDuplication(ListNode pH

package 合并两个有序的链表;class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; }}public class Solution { public ListNode Merge(ListNode list1,ListNod

package 找到第一个公共的节点;import java.util.HashMap;class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; }}public class Solution { HashMap<ListNode,

package 扑克牌的顺子;public class Solution { public boolean isContinuous(int[] numbers) { int len = numbers.length; if(len == 0){ return false; } int[] sortArray

package 输出单层节点;class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; }}class TreeNode { int val = 0; TreeNode left = null; TreeNode rig

package 求二叉树的深度;class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = val; }}public class Solution { public int

package 对称的二叉树;class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = val; }}public class Solution { boolean is

package 最近公共祖先;public class LCA { public int getLCA(int a, int b) { // write code here while (a != b) { if (a > b) { a >>= 1; } else {

package 求1到n的和;public class Solution { private static int N = 0, sum = 0; public Solution() { N++; sum += N; } public static int getSum(){ return sum; } pu

package 回文链表;class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; }}public class Palindrome { public boolean isPalindrome(ListNode pHead) {

//只需要2行代码，nowcoder上的题import java.util.*;public class BinInsert { public int binInsert(int n, int m, int j, int i) { // write code here m<<=j; return n | m; }}

参考：http://www.cnblogs.com/xiaomoxian/p/5161428.html一、只用2GB内存在20亿个整数（32位）中找到出现次数最多的数 解题思路： 想要在很多整数中找到出现次数最多的数，通常的做法是使用哈希表对出现的每一个数做词频统计，哈希表的key是某一个整数，value是这个数出现的次数。就本题来说，一共有20亿个数，哪怕只是一个数出现了20亿次，

//strcpy()函数char * strcpy(char * strDest, const char * strSrc){ assert((strDest != NULL) && (strSrc != NULL)); char * address = strDest;//为了实现链式表达式，最后返回具体值 while( (*strDest++ = * strSrc++)

1.哈希分流到多台机器2.哈希表统计每个机器中的每个小文件3.最小堆（想一想为什么是最小堆？）

package 把数组排成最小的数;public class Solution { public int MoreThanHalfNum_Solution(int[] array) { if (null == array) { return 0; } int len = array.length; if (

package 判断直线相交;public class Solution { static double a = Math.pow(10, -6); public boolean checkCrossLine(double s1, double s2, double y1, double y2) { // write code here return M

package 平分的直线;class Point { int x; int y; public Point(int x, int y) { this.x = x; this.y = y; } public Point() { this.x = 0; this.y = 0; }}public

问题A 有 n 个硬币,B 有 n+1 个硬币,谁丢的正面多谁赢,问 A 不输的概率？ 注意：不输二字解法我看了一些网上的答案，大多数写的不是很流畅，所以我尝试写一个清晰易懂的解法，相信小白也可以看懂。 首先考察另一个问题：我们分两个阶段来扔硬币，假设在第一阶段A扔了 n 枚硬币，B扔了 n 枚硬币。并且我们设 P(A>B) 是这个阶段A扔出的硬币出现正面的次数 > B扔出的硬币出现正面的

解题思路题意题目链接：这是题目链接 题目内容：HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？ 例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,

package 判断一棵树是否是平衡二叉树;class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.val = val; }}public class Solution { publ

package 数组中重复的数字;public class Solution { // Parameters: // numbers: an array of integers // length: the length of array numbers // duplication: (Output) the duplicated number in the arr

一个简单的说明 网上大多数的代码都是差不多的，它们的代码单次查询的时间复杂度是O（n），下面的代码时间复杂度是O（1）的，想想为什么？ 注意事项：不要被while欺骗了package 字符流中第一个不重复的字符;import java.util.HashMap;import java.util.LinkedList;import java.util.Queue;public cl

第一种解法这道题是这样思考的，n表示有n个台阶。那么-->if(n==1) ans?if(n==2) ans?if(n==3) ans?if(n==4) ans?相信你算前四项后，会有很大的发现。（just do it）package 变态跳台阶;public class Solution { static final int MAX = 32; static int[]

解题思路 这道题是这样思考的，请回答下面我写的几个问题？一 节点2的下一个节点是什么？二 节点1的下一个节点是什么？三 节点3的下一个节点是什么？（看上面的一副图）四 节点4的下一个节点是什么？ 最后的思考（重要的是）自己如何用递归独立实现代码。package 二叉树的下一个节点;class TreeLinkNode { int val; TreeLinkN

package 机器人走方格1;public class Robot { public int countWays(int x, int y) { int[][] dp = new int[12][12]; int maxn = 12; for(int i=1;i<maxn;i++){ dp[1][i] = 1;