可可

在足球比赛中，有2k个球队，其中强队k-1个，弱队k+1个，求强队相遇的概率。解题思路：假设，k为6，共有12个球队，7个弱队，5个强队1.先求总的比赛次数对于第一个球队有11种可能，第2个球队有9种，第3个球队是7种，最后的两个球队只有1种11*9*7*5*3*1=103952.再求强队不相遇的概率强队不相遇，则对于第一个强队，有7种选择，对于第二个强队，有6种。。7*6*5*...

二叉树的题目，大部分都能用分治的思路来解题。求二叉树的最大深度，就是求左、右子数的最大深度+1即可。给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的距离。样例给出一棵如下的二叉树: 1 / \ 2 3 / \ 4 5这个二叉树的最大深度为3./** * Definition of TreeNode:

样例给出一棵二叉树 {1,#,2,3}, 1 \ 2 / 3 返回 [1,2,3]./** * Definition of TreeNode: * public class TreeNode { * public int val; * public TreeNode left, right; * p

二叉树的中序遍历样例给出二叉树 {1,#,2,3}, 1 \ 2 / 3返回 [1,3,2]./** * Definition of TreeNode: * public class TreeNode { * public int val; * public TreeNode left, right; *

给定一个字符串和一个偏移量，根据偏移量旋转字符串(从左向右旋转)样例对于字符串 "abcdefg".offset=0 => "abcdefg"offset=1 => "gabcdef"offset=2 => "fgabcde"offset=3 => "efgabcd"挑战 在数组上原地旋转，使用O(1)的额外空间解题：pu

给定一个旋转排序数组，在原地恢复其排序。什么是旋转数组？比如，原始数组为[1,2,3,4], 则其旋转数组可以是[1,2,3,4], [2,3,4,1], [3,4,1,2], [4,1,2,3]样例[4, 5, 1, 2, 3] -> [1, 2, 3, 4, 5]解题思路：可采用三次翻转的思路，第一次翻转5,4第二

两个排序的数组A和B分别含有m和n个数，找到两个排序数组的中位数，要求时间复杂度应为O(log (m+n))。样例给出数组A = [1,2,3,4,5,6] B = [2,3,4,5]，中位数3.5给出数组A = [1,2,3] B = [4,5]，中位数 3解题：class Solution { /** * @param A: An inte

将两个排序链表合并为一个新的排序链表。样例给出 1->3->8->11->15->null，2->null， 返回 1->2->3->8->11->15->null。解题分析：（1）当l1为空时，直接返回l2。当l2为空时，直接返回l1。（2）因为第一个节点不确定是l1还是l2的，因此采用虚节点的方法，设一个dummy节点，然后把dummy节点的next

样例给出 A = [1, 2, 3, empty, empty], B = [4, 5]合并之后 A 将变成 [1,2,3,4,5]分析思路：为了和占用额外的空间，从最后一个数开始比较，每次将比较大的数放入A的后面，依次向前。class Solution { /** * @param A: sorted integer array A whic

假设一个旋转排序的数组其起始位置是未知的（比如0 1 2 4 5 6 7 可能变成是4 5 6 7 0 1 2）。你需要找到其中最小的元素。数组中可能存在重复的元素。给出[4,4,5,6,7,0,1,2]  返回 0解题思路：还是采用二分的思想，每次取中间mid，如果A[mid]>A[end],说明最小值在mid和end之间。如果A[mid]

假设有一个排序的按未知的旋转轴旋转的数组(比如，0 1 2 4 5 6 7 可能成为4 5 6 7 0 1 2)。给定一个目标值进行搜索，如果在数组中找到目标值返回数组中的索引位置，否则返回-1。你可以假设数组中不存在重复的元素。样例给出[4, 5, 1, 2, 3]和target=1，返回 2给出[4, 5, 1, 2, 3]和target=0，返回 -1

你给出一个整数数组(size为n)，其具有以下特点：相邻位置的数字是不同的A[0] A[n - 1]假定P是峰值的位置则满足A[P] > A[P-1]且A[P] > A[P+1]，返回数组中任意一个峰值的位置。 注意事项数组可能包含多个峰值，只需找到其中的任何一个即可样例给出数组[1, 2, 1, 3, 4, 5, 7, 6]返回1,

思路分析：树的问题都可以考虑分治的思路。平衡二叉树，就是要求左、右子数都是平衡的，而且高度差不超过-1给定一个二叉树,确定它是高度平衡的。对于这个问题,一棵高度平衡的二叉树的定义是：一棵二叉树中每个节点的两个子树的深度相差不会超过1。 样例给出二叉树 A={3,9,20,#,#,15,7}, B={3,#,20,15,7}A) 3 B)

题目：例如矩阵如下：1     2      3      45     6      7      89    10    11    1213  14    15    16顺时针输出，结果应为：1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10。参考剑指offer上的思路：打印的顺序如上图所示。循环结束的条件。

1、最大公约数最大公约数缩写为gcb，假设m>n.2、最小公倍数可以利用最大公约数来求得，lcm(a,b)=(a*b)/gcb(a,b)

排序算法总结冒泡排序：时间复杂度O（N^2）冒泡的思想：第一个数和第二个数比较，如果第一个大就交换，接着第二个数和第三个数比较。                     这样第一次循环结束，就能把最大的一个数放在最底部。实现的代码：import java.util.*;public class BubbleSort { public int[] bubble

java队列队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。LinkedList类实现了Queue接口，因此我们可以把LinkedList当成Queue来用。二叉树的层序遍历思路：设置两个标志last和nlast，last为本层的最右结点，nlast为队列尾部的结点。node为当前结点，当

上台阶问题，一次上一层或两层，请问上n层的时候，有多少种方案。f(n)=f(n-1)+f(n-2)import java.util.*;public class GoUpstairs { public int countWays(int n) { // write code here int[] arr=new int[n+1];

字符串APPAPT中包含了两个单词“PAT”，其中第一个PAT是第2位(P),第4位(A),第6位(T)；第二个PAT是第3位(P),第4位(A),第6位(T)。现给定字符串，问一共可以形成多少个PAT？输入描述:输入只有一行，包含一个字符串，长度不超过105，只包含P、A、T三种字母。输出描述:在一行中输出给定字符串中包含多少个PAT。由于结果可能比较大，只输出对10000000

最大子数组的和思路：采用动态规划的思路，假设对于元素i，所有以它前面的元素结尾的子数组的长度都已经求得，那么以第i个元素结尾且和最大的连续子数组实际上，要么是以第i-1个元素结尾且和最大的连续子数组加上这个元素，要么是只包含第i个元素。当i-1个元素的最大和大于0时，加上第i个元素自然会更大。当i-1个元素的最大和小于0时，第i个元素本身更大。import java.util.

第k大的数。思路：利用java自带的排序函数进行排序。int[] a={1,4,-1,5,0};Arrays.sort(a);(1)Arrays类中的sort()使用的是“经过调优的快速排序法”;(2)Arrays类之只是提供了默认的升序排列，没有提供相应的降序排列方法。(默认从小到大排序)。import java.util.*;public class

最长公共子字符串 这是一个非常的经典的动态规划问题。 解题思路： 创建一个二维数组，dp[n][m]，其中dp[i][j]表示取到s1[i]和s2[j]时的最大连续子串长度。如果s1[i]等于s2[j]时，dp[i][j]=dp[i-1][j-1]+1。public class day43 { public static void main(String[] args) {

topK问题是数据分析中常见的问题。 比如找出1000个数中，第5大的数， 或1000个数中，前5大的数。topK问题，比较好的一种解法，就是用小顶堆来实现。 小顶堆（min-heap）有个重要的性质——每个结点的值均不大于其左右孩子结点的值，则堆顶元素即为整个堆的最小值。JDK中PriorityQueue实现了数据结构堆，通过指定comparator字段来表示小顶堆或大顶堆，默认为null，

数组是最简单的一种数据结构，它占据一块连续的内存，并按照顺序存储数据，创建数组时，我们需要首先指定数组的容量大小，然后根据大小分配内存。由于数组中的内存是连续的，于是可以根据下标在O(1)时间读/写任何元素。因此它的时间效率是很高的。我们可以感觉数组时间效率高的优点，用数组来实现简单的哈希表，把数组的下标设为哈希表的键值key，而把数组中每一个元素设为哈希表的value，这样每一个下标及数

题目内容：此题有三种做法:(1)使用java的replace方法(2)使用一个额外的字符串做辅助(3)在原字符串上修改这三种做法的难度依次上升。我主要来分析一下第三种做法，也是O(n)的一个做法。第三种方法的思路：先遍历一遍字符串，这样就能统计出字符串中空格的总数，并可以由此计算出替换之后的字符串长度。每替换一个空格，长度增加2，因此替换以后字符串的长度

在一个字符串(1import java.util.HashMap;public class test7 { public static void main(String[] args) { String str="abacc"; System.out.println(FirstNotRepeatingChar(str)); } static int FirstNotRepeat

二叉树的深度思路：如果一棵树，既有右子树又有左子树，该树的深度就是其左右子树深度的较大值再加1解答：/**public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) { this.v

前序：根-左-右中序：左-根-右后序：左-右-根实现：class TreeNode1 { int val = 0; TreeNode1 left = null; TreeNode1 right = null; public TreeNode1(int val) { this.val = val; }}public cla

题目：从尾到头打印链表思路：利用栈的特性，后进先出。使用push，pop方法。/*** public class ListNode {* int val;* ListNode next = null;** ListNode(int val) {* this.val = val;* }*

题目：删除链表中等于给定值val的所有节点给出链表 1->2->3->3->4->5->3, 和 val = 3, 你需要返回删除3之后的链表：1->2->4->5。分析思路：这道题的思路，与之前删除链表中重复的结点相似。因为头结点可能被删除，因此解题的关键在于，创建一个虚结点，将虚结点的next指向原本的头结点。/** * Definition for singly

剑指offer上的算法题目，删除链表中重复的结点。例子：1->2->3->3，结果1->2例子：1->1->1->1，结果null例子：1->1->1->3，结果3分析：头结点也可能是重复的元素，因此头结点也可能被删除。此种情况下，应创建一个虚拟结点，将虚拟结点指向头结点。/* public class ListNode { int val;

写出一个高效的算法来搜索m×n矩阵中的值，返回这个值出现的次数。这个矩阵具有以下特性：每行中的整数从左到右是排序的。每一列的整数从上到下是排序的。在每一行或每一列中没有重复的整数。样例考虑下列矩阵：[    [1, 3, 5, 7],    [2, 4, 7, 8],    [3, 5, 9, 10]]给出target = 3

给定一个排序数组和一个目标值，如果在数组中找到目标值则返回索引。如果没有，返回到它将会被按顺序插入的位置。你可以假设在数组中无重复元素。样例[1,3,5,6]，5 → 2[1,3,5,6]，2 → 1[1,3,5,6]， 7 → 4[1,3,5,6]，0 → 0public class Solution { /** * param A

二分查找是一种高效的查找方法。要求待查表为有序表。package test;public class binarySearch { public static void main(String[] args) { int[] a={2,4,6,7,8,9}; System.out.println(binarySearch(a, 6)); } public stati

在java5中新增加了java.util.Queue接口，用以支持队列的常见操作。Queue接口与List、Set同一级别，都是继承了Collection接口。Queue使用时要尽量避免Collection的add()和remove()方法，而是要使用offer()来加入元素，使用poll()来获取并移出元素。它们的优点是通过返回值可以判断成功与否，add()和remove()方法在失

这是一个典型的动态规划问题。public class Solution { public int FindGreatestSumOfSubArray(int[] array) { if(array==null||array.length==0){ return 0; } int result=array[0];

希尔排序插入排序的一种。package test;public class MergeSort { public static void main(String[] args) { int[] a={4,2,1,6,3,6,0,-5,1,1}; shellsort(a); for(int i=0;i<a.length;i++){ System.out.pri

插入排序：package test;public class insert { public static void main(String[] args) { int[] a={4,2,1,6,3,6,0,-5,1,1}; insertSort(a); for(int i=0;i<a.length;i++){ System.out.print(a[i]+" "

归并排序部分参考：http://blog.youkuaiyun.com/yinjiabin/article/details/8265827/假设我们有一个没有排好序的序列，那么首先我们使用分割的办法将这个序列分割成一个个已经排好序的子序列。然后再利用归并的方法将一个个的子序列合并成排序好的序列。分割和归并的过程可以看下面的图例。从上图可以看出，我们首先把一个未排序的序列从中间分割成2部

算法题目：删除链表中重复的节点在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5/* public class ListNode { int val; ListNode next = null; ListNode(int val) {