利用“夹逼准则”最简单！
如果没有学过“夹逼准则”，那就只好利用定义了：
【命题】若对一切n有|Bn|≤M，lim(n→∞)An=0，则lim(n→∞) An*Bn=0.
【证明】因为lim(n→∞)An=0，所以对于任意的ε＞0，存在N＞0，当n＞N时，|An|＜ε/M，那么 |An*Bn|=|An|*|Bn|＜(ε/M)*M=ε，
所以 lim(n→∞)An*Bn=0
其他答案（共1个回答）
啊　　用夹逼准则很简单！！假设一下就可以了！
黄线部分就是楼主蓝线部分的运用，解释下蓝线部分就明白了。
| Xnk | 为原数列的 | Xn |
子数列，而且子数列保持原数列的排序未变，则Xnk是子数列|...
这样是可以的。
这是无穷小运算法则定理的第二条：
1，两个无穷小的和仍是无穷小：
2，无穷小与有界变量的乘积是无穷小。
严格来说就是：
一有界变量：...
我教过微积分，今年数学三考了142分,在考东北大学工商管理学院的一千二百多名考生中数学名列第一。
你的想法也可以，一个数列可分成若干个数列，若每个的极限都存在且...
1.不一定，数列的前有限项不影像散敛性，而这些项可以是无界的。
2.对，不一定单调，可能从上下两侧收敛于一点。
lim无穷&|an|=|a|=&lim无穷&an=a
成立的条件是：当n-&无穷时，an与a同号。即存在M&0，当n&M时，
an与a同为正数或负数。若满足该条...
答: 我来帮帮你吧！！！！
解： 设A,B各取X,Y张.
且z=2x 3y取最小值 解之得,x=3,y=7
答: 对于那些有志于穷尽数学奥秘的学生，他总是循循善诱地予以启发和教育，而对于那些急功近利、在学习上不肯刻苦钻研的人，则毫不客气地予以批评
答: 很简单,水沸腾也就100度左右,而纸要燃烧的着火点远远高于100度,在纸远达不到着火点的时候,纸锅上的水就因为水对流把热量带走,使纸锅底的温度远低于纸着火点温度...
答: 补课是比较错误的方式。我一直到高中毕业没补过课。爸妈也不管我，随我学什么。我打游戏和化学都挺好。现在在大学读书，很深刻地感受到教育是钱买不来的。在实验室做小型的...
铝属于两性金属，遇到酸性或碱性都会产生不同程度的腐蚀，尤其是铝合金铸件的孔隙较多，成分中还含有硅和几种重金属，其防腐蚀性能比其他铝合金更差，没有进行防护处理的铝铸件只要遇到稍带碱性或稍带酸性的水，甚至淋雨、水气、露水等就会受到腐蚀，产生白锈。
解决的办法。
铝铸件完成铸造后，在机械加工前，先要进行表面预处理，如预先对铸件进行喷砂，涂上一道底漆（如锌铬黄底漆），在此基础上再进行机械加工，以避免铸铝件在没有保护的情况下放久了被腐蚀。
销售额：指企业在销售商品、提供劳务及让渡资产使用权等日常活动中所形成的经济利益的总流入。税法上这一概念是不含任何税金的收入。销售额适用于制造业、商业等。
营业额会计上指的是营业收入，税法指的是应税营业收入。营业额属于含税收入，适用于饮食业、运输业、广告业、娱乐业、建筑安装业等 。
这个问题有点不知所问了。
公务员并不由单位性质决定，行政单位行政编的是公务员，但并不是说行政单位的就是公务员，事业单位里面参照管理的也是公务员。
所以你的问题只能回答为：按公务员管理的是公务员。
有。各地略有不同，大致上是：
养老保险，单位交缴费基数的20％，个人交8％；
医疗保险，单位交8％，个人交2％；
失业保险，单位交2％，个人交1％；
生育保险和工伤保险都由单位交纳，总共为1.3%。
另外，可能还有公积金，单位和个人各交8％左右。
其中，缴费基数通常为个人工资，但有最低和最高限。
那不是一言两语能说清楚 的。
做为一位局长，又要管内部的事，又要管外部的事，我想第一部，是跟手下的人打好关系。
先会做人，再慢慢学者去做事
这需要公司的业绩，经营状况，还有大众对公司认可度的高低决定的。刚上市的时候行情的好大家也愿意买公司的股票的话翻倍很容易。但如果行情不景气，或者大家对公司认可度不高的话，上市跌破开盘价也是可能的。至于公司之后涨多少，就要视公司的质地等各方面情况而定，一般来说中小企业股价定价较高，成长性较大；大型企业的话股票定价较低，股价会平稳增长。原始股是公司上市之前发行的股票。在中国证券市场上，“原始股”一向是赢利和发财的代名词。在中国股市初期，在股票一级市场上以发行价向社会公开发行的企业股票，投资者若购得数百股，日后上市，涨至数十元，可发一笔小财，若购得数千股，可发一笔大财，若是资金实力雄厚，购得数万股，数十万股，日后上市，利润便是数以百万计了。
借款时，借：其他应收款，贷：现金；报销时，如果借条已经跨月做账了，就开张收据（借条不能退回），借：管理费用等，贷：其他应收款。
对员工的吸引和满意情况。离职率计算方法：举例说明现假设某公司一年的前六个月中每个月的期初人数、期末人数、录用人数、离职人数如下表所示：该公司在一月份时跳槽员工的较多，故二、三月份开始大量招聘新员工，四、五、六月份员工的变动则较为平稳。我们来讨论用不同的计算方法来求离职率。一月份二月份三月份四月份五月份六月份合计期初人数-录用人数离职人数期末人数-1.
成都机电工程学校是经国家教育主管部门批准成立的全日制中等专业学校，位于成都郫都区，与很多部省级单位都有合作，想了解更多可以去学校官网看看
.我个人觉得 成都铁路职业学校的话就是成都机电工程学校比较好，很大，3000多亩占地，三个校区，我感觉是真的很大了，风景也不错，交通也方便，铁路方面的专业也挺火的。你可以去看看，也挺方便的。
只要没有大问题都是容易过得哈，成都铁路学校的招生条件是这样的，我就拿成都机电工程学校的招生条件来说吧，高铁、动车乘务，女生：身高163cm-172cm，男生：173cm-185cm，铁路客运员，女生：160cm-173cm,男生：170cm-184cm。当然还要身体健康啦，到时候会体检的哦。
永隆厂家专业从事于高档彩盒包装哦，我看到很多高档彩盒都是永隆厂家生产的，质量有保障，抗破碎，抗压力强，一流的厂家一流的产品。
学校环境挺好的，又大，教学楼，行政楼这些应有尽有，在学校的学生还挺多的，在校学生有16000左右。师资方面都是一些专家，教授，工程师，研博生这些。是莘莘学子学习的圣地和成人、成才、就业、创业的摇篮。
正在加载...
Copyright &
Corporation, All Rights Reserved
确定举报此问题
举报原因(必选)：
广告或垃圾信息
激进时政或意识形态话题
不雅词句或人身攻击
侵犯他人隐私
其它违法和不良信息
报告，这不是个问题
报告原因(必选)：
这不是个问题
这个问题分类似乎错了
这个不是我熟悉的地区头脑风暴时间~一道比较有意思的算法题,该如何处理 - 数据结构与算法当前位置:& &&&头脑风暴时间~一道比较有意思的算法题,该如何处理头脑风暴时间~一道比较有意思的算法题,该如何处理www.MyException.Cn&&网友分享于：&&浏览：2次头脑风暴时间~一道比较有意思的算法题给你这么个数列...看出规律了吗 这个数列是由下列数列串合而成：11212312341234512345612345671......现在问题是给定1&=i&=要求此数列的第i位头脑风暴时间！！！------解决方案--------------------额，很简单啊：先来分析下这个序列，对于第K数列串，其值为：123……k，数字个数为k对于第k+1个数列串，其值为：123……k(k+1),数字个数为k+1前k个数列串总的数字个数为1+2+3+……+K = (1+k)*k/2第k+1个数列串总的数字个数为(k+2)*(k+1)/2因为第i个数必定在否一个数列串中，所以对于i，可以找到合适的k使得(1+k)*k/2 &= i &(k+2)*(k+1)/2如果i = (1+k)*k/2,则i为第k个数列串的最后一个数，即 第i位 = k。否则 i 在第 k+1 的数列串中，令m = i - (1+k)*k/2，则 第i位 = m。例如：当i = 11，则k = 4，m = 11 - 10 = 1，则 第i位为 1。至于求解合适的k，使得(1+k)*k/2 &= i &(k+2)*(k+1)/2，可以用解方程的方法，这样效率还是挺高的。
------解决方案--------------------楼上的办法很好……【程序】C/C++ code
#include &stdio.h&
#include &math.h&
void fun(int n){
i=(int)sqrt(2*n)-1;
if((1+i)*i/2&=n&&(2+i)*(i+1)/2&=n)
printf(&%d&,n-(1+i)*i/2);
int main(){
for(i=1;i&=200;i++) fun(i);
printf(&\n&);
12345678910
12345678910
12345678910 上一篇：下一篇：文章评论相关解决方案 12345678910 Copyright & &&版权所有数字推理与语言表达_百度文库
赠送免券下载特权
10W篇文档免费专享
部分付费文档8折起
每天抽奖多种福利
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
数字推理与语言表达
阅读已结束，下载本文需要
想免费下载更多文档？
定制HR最喜欢的简历
下载文档到电脑，同时保存到云知识，更方便管理
加入VIP
还剩5页未读，
定制HR最喜欢的简历
你可能喜欢2011省行测数量关系_百度文库
赠送免券下载特权
10W篇文档免费专享
部分付费文档8折起
每天抽奖多种福利
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
2011省行测数量关系
阅读已结束，下载本文需要
想免费下载更多文档？
定制HR最喜欢的简历
下载文档到电脑，同时保存到云知识，更方便管理
加入VIP
还剩62页未读，
定制HR最喜欢的简历
你可能喜欢Android 面试之编程算法题 - 简书
Android 面试之编程算法题
，转载请注明出处：
本文收集整理了 Android 面试中会遇到的编程算法题。
推荐几个做编程题目的网站：
下列题目来源：
— 该处题目应该也是来源于剑指 Offer，不过每题都有详细思路和解法，值得一看。
二维数组中查找
在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
根据题意画了个简单的图，首先我们要确定查找开始的位置，因为它是二维的数组，它的下标变化是两个方向的，根据四个边界点来分析。
Ａ：向下　增　，向右　增
Ｂ：向左　减　，向下　增
Ｃ：向上　减　，向右　增
Ｄ：向左　减　，向上　减
可以看出从B 或Ｃ点开始查找刚好可以构建一个二叉查找树。
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。
先确定二维数组的行数和列数，把 查找值 与 二叉查找树的根节点（Ｂ或者　Ｃ）开始比较，如果相等返回true，小于查找左子树，大于就查找右子树。如果遍历超过数组边界，就返回 false。
以C为根节点查找
public class Solution {
public boolean Find(int [][] array,int target) {
int i = array.length -1;
int m = array[0].length -1;
int j = 0;
while(i&=0 && j&=m){
if(target == array[i][j]){
}else if(target &array[i][j]){
以B为根节点查找
public class Solution {
public boolean Find(int [][] array,int target) {
int i = array.length -1;
int j = array[0].length -1;
int n = 0;
while(j&=0 && n&=i){
if(target == array[n][j]){
}else if(target &array[n][j]){
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
解法一　　运行时间：29m 　占用内存：629k
public int
NumberOf1(int n) {
String s=Integer.toBinaryString(n);
char[] c=s.toCharArray();
for(int i=0;i&c.i++){
if(c[i]=='1'){
public static String toBinaryString(int i)
以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
①先把整数转换成二进制字符串
②把字符串转换成字符数组
③遍历该数组，判断每位是否为1，为1 计数加1。
④遍历完成返回1的个数
运行时间：30ms
占用内存：629k
public class Solution {
public int
NumberOf1(int n) {
int count =0;
while(n!=0){
n = n&(n-1);
如果一个整数不为0，那么这个整数至少有一位是1。如果我们把这个整数减1，那么原来处在整数最右边的1就会变为0，原来在1后面的所有的0都会变成1(如果最右边的1后面还有0的话)。其余所有位将不会受到影响。
举个例子：
①二进制数　　1100
② 减１后，得　1011
对比①和③你会发现，把一个整数减去1，再和原整数做与运算，会把该整数最右边一个1变成0.那么一个整数的二进制有多少个1，就可以进行多少次这样的操作。
定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。
import java.util.S
public class Solution {
Stack&Integer& stack = new Stack&Integer&();
Stack&Integer& min = new Stack&Integer&();
public void push(int node) {
stack.push(node);
if(min.isEmpty()){
min.push(node);
if (node &= min.peek()) {
min.push(node);
public void pop() {
if (stack.peek() == min.peek()) {
min.pop();
stack.pop();
public int top() {
return stack.peek();
public int min() {
return min.peek();
请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
str 是StringBuffer的对象
返回替换后的字符串的String对象
首先要对输入参数进行判空和越界判断（任何算法题都要注意）。
解法一 （运行时间：36ms
占用内存：688k）
public class Solution {
public String replaceSpace(StringBuffer str) {
if(str==null){
StringBuffer sb = new StringBuffer();
char [] strChar = str.toString().toCharArray();
for(int i=0;i&strChar.i++){
if(strChar[i]==' '){
sb.append("%20");
sb.append(strChar[i]);
return sb.toString();
把传入的StringBuffer 对象 str 转换成字符串 再转换成字符数组,申请一个新的StringBuffer 对象 sb来存最后的结果，遍历整个字符数组，如果当前字符为空格则把　＂％２０＂加入到sb中，否则直接追加当前字符，最后把sb转换成字符串返回。
解法二 （运行时间：34ms
占用内存：503k）
public class Solution {
public String replaceSpace(StringBuffer str) {
if(str == null){
for(int i =0;i&str.length();i++){
char c = str.charAt(i);
if(c==' '){
str.replace(i,i+1,"%20");
return str.toString();
public StringBuffer replace(int start, int end, String str)
使用给定 String 中的字符替换此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end - 1 处的字符，如果不存在这种字符，则一直到序列尾部。先将子字符串中的字符移除，然后将指定的 String 插入 start。（如果需要，序列将延长以适应指定的字符串。）参数：start - 起始索引（包含）。end - 结束索引（不包含）。str - 将替换原有内容的字符串。返回：此对象。
源码（可以看出它调用的是父类的方法）
public synchronized StringBuffer More ...replace(int start, int end, String str){
toStringCache =
super.replace(start, end, str);
父类AbstractStringBuilder
public AbstractStringBuilder More ...replace(int start, int end, String str) {
if (start & 0)
throw new StringIndexOutOfBoundsException(start);
if (start & count)
throw new StringIndexOutOfBoundsException("start & length()");
if (start & end)
throw new StringIndexOutOfBoundsException("start & end");
if (end & count)
int len = str.length();
int newCount = count + len - (end - start);
ensureCapacityInternal(newCount);
System.arraycopy(value, end, value, start + len, count - end);
str.getChars(value, start);
count = newC
可以看出StringBuffer类 提供了 插入的函数，值得注意的是 StringBuilder 也是继承于AbstractStringBuilder这个抽象类的。所以它也有这个方法，但是String并没有。
解法三（不推荐，运行时间：38ms
占用内存：654k）
public class Solution {
public String replaceSpace(StringBuffer str) {
return str.toString().replaceAll("\\s", "%20");
输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。 结果请按字母顺序输出。
输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。
顺序输出字符串的所有排列
这是一个字符串全排列的问题，把全部序列存在TreeSet中默认可得到字典顺序。
　　　　基于TreeMap实现的SortedSet，可以对Set集合中的元素进行排序，排序后按升序排列元素（缺省是按照自然排序），非线程安全。
固定一个字符串之后，之后再将问题变小，只需求出后面子串的排列个数就可以得出结果，然后依次将后面的字符串与前面的交换，再递归子串的排列结果，最后当所有字符都固定结束递归。
下面这张图很清楚的给出了递归的过程：
解法　运行时间：131ms　占用内存：1477k
import java.util.*;
public class Solution {
//用于最后返回结果
ArrayList&String& list
= new ArrayList&&();
//遍历的时候来存储序列实现排序
TreeSet&String& set = new TreeSet&&();
public ArrayList&String& Permutation(String str) {
if(str==null || str.length()==0)
Permutation(str.toCharArray(),0);
//容器转换，TreeSet中的元素已经是按照字母顺序排序，所以这里做了排序
list.addAll(set);
public void Permutation(char[] s,int index){
if(s==null ||s.length==0 || index&0 || index&s.length-1)
if(index==s.length-1){//递归固定到最后一个位置，把该串加入集合
// set不能添加重复元素，所以这里的add()解决了有重复字符的问题
set.add(new String(s));
}else{//固定前index+1个字符，递归后面所有可能的子串
for(int i =i&s.i++){
swap(s,index,i);//交换一次形成一个子串
Permutation(s,index+1);
swap(s,i,index);//复原使下次循环产生下一个子串
public void swap(char[] s,int i,int j){
char temp = s[i];
s[i] = s[j];
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。
思路一：数组排序后，如果符合条件的数存在，则一定是数组中间那个数。（比如：1，2，2，2，3；或2，2，2，3，4；或2，3，4，4，4等等）
这种方法虽然容易理解，但由于涉及到快排sort，其时间复杂度为O(NlogN)并非最优；
参考代码如下：
class Solution {
int MoreThanHalfNum_Solution(vector&int& numbers)
// 因为用到了sort，时间复杂度O(NlogN)，并非最优
if(numbers.empty()) return 0;
sort(numbers.begin(),numbers.end()); // 排序，取数组中间那个数
int middle = numbers[numbers.size()/2];
int count=0; // 出现次数
for(int i=0;i&numbers.size();++i)
if(numbers[i]==middle) ++
return (count&numbers.size()/2) ? middle :
思路二：如果有符合条件的数字，则它出现的次数比其他所有数字出现的次数和还要多。
在遍历数组时保存两个值：一是数组中一个数字，一是次数。遍历下一个数字时，若它与之前保存的数字相同，则次数加1，否则次数减1；若次数为0，则保存下一个数字，并将次数置为1。遍历结束后，所保存的数字即为所求。然后再判断它是否符合条件即可。
参考代码如下：
class Solution {
int MoreThanHalfNum_Solution(vector&int& numbers)
if(numbers.empty()) return 0;
// 遍历每个元素，并记录次数；若与前一个元素相同，则次数加1，否则次数减1
int result = numbers[0];
int times = 1; // 次数
for(int i=1;i&numbers.size();++i)
if(times == 0)
// 更新result的值为当前元素，并置次数为1
result = numbers[i];
times = 1;
else if(numbers[i] == result)
++ // 相同则加1
-- // 不同则减1
// 判断result是否符合条件，即出现次数大于数组长度的一半
times = 0;
for(int i=0;i&numbers.size();++i)
if(numbers[i] == result) ++
return (times & numbers.size()/2) ? result : 0;
斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。
斐波那契数列的第n项。
什么是斐波那契数列？
斐波那契数列（Fibonacci sequence），又称黄金分割数列
在数学上，斐波纳契数列以如下被以递归的方法定义：F（0）=0，F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2，n∈N*）
指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……
看到这个的第一想法就是用递归，当ｎ＜２时返回ｎ，ｎ＞＝２时返回ｆ(n-1)+f(n-2), 于是就来试一下...
public class Solution {
public int Fibonacci(int n) {
return Fibonacci(n-1)+Fibonacci(n-2);
运行超时:您的程序未能在规定时间内运行结束，请检查是否循环有错或算法复杂度过大。
为什么呢？
因为重复计算，比如：
ｆ(4) = ｆ(3) + ｆ(2);
　 = ｆ(2) + ｆ(1) + ｆ(1) + ｆ(0);
　 = ｆ(1) + ｆ(0) + ｆ(1) + ｆ(1) + ｆ(0);
求ｆ(4)就要计算三次ｆ(1)和两次ｆ(0)，显然这是不行的。
解法 (动态规划)
运行时间：27ms
占用内存：629k
public class Solution {
public int Fibonacci(int n) {
int i = 0, j = 1;
for(;n&0;n--){
public class Solution {
public int Fibonacci(int n) {
int a=1,b=1,c=0;
}else if(n==1||n==2){
for (int i=3;i&=n;i++){
根据n的大小，从f(0)=i 和 f(1)=j 从头开始遍历整个序列
有f(n)=f(n-1)+f(n-2)
（n≥2，n∈N*）
j+=i, 使j成为新的f(n-1)i = j-i ，使i成为f(n-2)
完成后，返回 f(n-2)
注意：java中
while(n--)
会报编译错误：
required: booleanfound: int
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法
该题答案和上题一样，其实就是斐波那契数列
设n阶的跳数为f(n)
当n=1时，f(1) = 1
当n=2时，分为最后一步 跳2阶和跳1阶 两种情况，有f(2)=f(0)+f(1)=1+1=2
当n=3时，分为最后一步 跳3阶、跳2阶和跳1阶 三种情况，有f(3)=f(0)+f(1)+f(2)=1+1+2=4
f(n) = f(n-1)+f(n-2)+...+f(1) + f(0)成立同时有　f(n-1)＝f(n-2)+...+f(1) + f(0)　成立，可得出f(n)=2f(n-1)
很明显可以得出递推公式：
　　　　(n=0 ) f(n) =
(n=1 )　　　　 | 2*f(n-1)　　(n&=2)
解法一 　运行时间：35ms
　 占用内存：654k
public class Solution {
public int JumpFloorII(int target) {
if(target&=1)
return 2*JumpFloorII(target-1);
　运行时间：34ms　
占用内存：654k
public class Solution {
public int JumpFloorII(int target) {
　　 if(target&=1)
return 1&&(target-1);
换一种思路想一下：一共有ｎ个台阶，最后一个台阶是一定要跳上去的，其他的　ｎ－１个可跳可不跳，一共有多少总情况？
２（ｎ－１）
这里用移位实现乘法，时间上要快一些！
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减序列的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
import java.util.ArrayL
public class Solution {
public int minNumberInRotateArray(int [] array) {
if(array.length==0){
for(int i =0;i&array.length-2;i++){
if(array[i+1] & array[i]){
return array[i+1];
return array[0];
import java.util.ArrayL
public class Solution {
public int minNumberInRotateArray(int [] array) {
int low = 0 ; int high = array.length - 1;
while(low & high){
int mid = low + (high - low) / 2;
if(array[mid] & array[high]){
low = mid + 1;
}else if(array[mid] == array[high]){
high = high - 1;
return array[low];
我们可以用 2 * 1 的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2 * 1的小矩形无重叠地覆盖一个2 * n的大矩形，总共有多少种方法？
一个大矩形
覆盖的方法数
设 被n个2*1的小矩形无重叠地覆盖的方法总数为 f(n)
当n=1时，明显f(1)=1;
当n=2时，只能两个都横着或两个都竖着放，有f(2)=2;
当小矩形个数为n，来覆盖这个2*n的大矩形。第一步只有两种放法：
①竖着放，那么剩下的摆放总数为 f(n-1)
②横着放，那么剩下的摆放总数为 f(n-２)。因为它下面的那块也跟随着它的摆放而确定（必须是一个横着放的小矩形）。
很容易看出满足斐波那契数列。
斐波那契数列（Fibonacci sequence），又称黄金分割数列
在数学上，斐波纳契数列以如下被以递归的方法定义：F（0）=0，F（1）=1，F（n）=F(n-1)+F(n-2)（n≥2，n∈N*）
指的是这样一个数列：0、1、1、2、3、5、8、13、21、34、……
可以得出递推公式：
| 1 　　　　(n=0 ) f(n) = 　 | 1 　　　　 (n=1 ) 　　　　 | f(ｎ-1)＋f(n-2)　　(n&=2)
解法一 （递归）
　运行时间：924ms 　占用内存：654k
public class Solution {
public int RectCover(int target) {
if(target&=1) return 1;
return RectCover(target-1)+RectCover(target-2);
递归效率不高，重复计算多，比如：
ｆ(4) = ｆ(3) + ｆ(2);
　 = ｆ(2) + ｆ(1) + ｆ(1) + ｆ(0);
　 = ｆ(1) + ｆ(0) + ｆ(1) + ｆ(1) + ｆ(0);
求ｆ(4)就要计算三次ｆ(1)和两次ｆ(0)，显然这是不行的。
解法二（动态规划）　　运行时间：29ms　占用内存：629k
public class Solution {
public int RectCover(int target) {
if(target&=1) return 1;
int i =1;//f(0)
int j =1;//f(1)
for(;target&=2;target--){
显然这个快很多，n&=2时，根据 f(n)=f(ｎ-1)＋f(n-2)进行依次计算，最后得出 f（target）并返回。
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
解法二　运行时间：27ms 　占用内存：503k
public class Solution {
public void reOrderArray(int [] array) {
if(array.length==0 || array==null){
for(int i=0;i&array.length-1;i++){
for(int j=0;j&array.length-i-1;j++){
if(array[j]%2==0 && array[j+1]%2==1){
int temp = array[j];
array[j] = array[j+1];
array[j+1] =
类似于冒泡排序，以为用到array[j+1]数组不要越界。
有一个容器类 ArrayList，保存整数类型的元素，现在要求编写一个帮助类，类内提供一个帮助函数，帮助函数的功能是删除 容器中&10的元素。
LeetCode上股票利益最大化问题
剑指offer上第一次只出现一次的字符
反转字符串
字符串中出现最多的字符。
实现stack 的pop和push接口 要求：
1.用基本的数组实现
2.考虑范型
3.考虑下同步问题
4.考虑扩容问题
单例模式——写一个Singleton出来
七种方式实现Singleton模式
public class Test {
* 单例模式，懒汉式，线程安全
public static class Singleton {
private final static Singleton INSTANCE = new Singleton();
private Singleton() {
public static Singleton getInstance() {
return INSTANCE;
* 单例模式，懒汉式，线程不安全
public static class Singleton2 {
private static Singleton2 instance =
private Singleton2() {
public static Singleton2 getInstance() {
if (instance == null) {
instance = new Singleton2();
* 单例模式，饿汉式，线程安全，多线程环境下效率不高
public static class Singleton3 {
private static Singleton3 instance =
private Singleton3() {
public static synchronized Singleton3 getInstance() {
if (instance == null) {
instance = new Singleton3();
* 单例模式，懒汉式，变种，线程安全
public static class Singleton4 {
private static Singleton4 instance =
instance = new Singleton4();
private Singleton4() {
public static Singleton4 getInstance() {
* 单例模式，使用静态内部类，线程安全（推荐）
public static class Singleton5 {
private final static class SingletonHolder {
private static final Singleton5 INSTANCE = new Singleton5();
private static Singleton5 getInstance() {
return SingletonHolder.INSTANCE;
* 静态内部类，使用枚举方式，线程安全（推荐）
public enum Singleton6 {
public void whateverMethod() {
* 静态内部类，使用双重校验锁，线程安全（推荐）
public static class Singleton7 {
private volatile static Singleton7 instance =
private Singleton7() {
public static Singleton7 getInstance() {
if (instance == null) {
synchronized (Singleton7.class) {
if (instance == null) {
instance = new Singleton7();
二叉树遍历
重建二叉树
输入二叉树的前序遍历和中序遍历的结果,重建出该二叉树。假设前序遍历和中序遍历结果中都不包含重复的数字,例如输入的前序遍历序列 {1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}重建出如图所示的二叉 树。
解题思路：
前序遍历第一个结点是父结点，中序遍历如果遍历到父结点，那么父结点前面的结点是左子树的结点，后边的结点的右子树的结点，这样我们可以找到左、右子树的前序遍历和中序遍历，我们可以用同样的方法去构建左右子树，可以用递归完成。
public class BinaryTreeNode {
public BinaryTreeNode leftN
public BinaryTreeNode rightN
public class Solution {
public static BinaryTreeNode constructCore(int[] preorder, int[] inorder) throws Exception {
if (preorder == null || inorder == null) {
if (preorder.length != inorder.length) {
throw new Exception("长度不一样，非法的输入");
BinaryTreeNode root = new BinaryTreeNode();
for (int i = 0; i & inorder. i++) {
if (inorder[i] == preorder[0]) {
root.value = inorder[i];
System.out.println(root.value);
root.leftNode = constructCore(Arrays.copyOfRange(preorder, 1, i + 1),
Arrays.copyOfRange(inorder, 0, i));
root.rightNode = constructCore(Arrays.copyOfRange(preorder, i + 1, preorder.length),
Arrays.copyOfRange(inorder, i + 1, inorder.length));
数值的整数次方
实现函数double Power(double base,int exponent)，求base的exponent次方，不得使用库函数，同时不需要考虑大数问题。
看到了很多人会这样写：
public static double powerWithExponent(double base,int exponent){
double result = 1.0;
for(int i = 1; i &= i++){
result = result *
输入的指数(exponent)小于1即是零和负数时怎么办？
当指数为负数的时候，可以先对指数求绝对值，然后算出次方的结果之后再取倒数，当底数(base)是零且指数是负数的时候，如果不做特殊处理，就会出现对0求倒数从而导致程序运行出错。最后，由于0的0次方在数学上是没有意义的，因此无论是输出0还是1都是可以接受的。
public double power(double base, int exponent) throws Exception {
double result = 0.0;
if (equal(base, 0.0) && exponent & 0) {
throw new Exception("0的负数次幂无意义");
if (equal(exponent, 0)) {
return 1.0;
if (exponent & 0) {
result = powerWithExponent(1.0 / base, -exponent);
result = powerWithExponent(base, exponent);
private double powerWithExponent(double base, int exponent) {
double result = 1.0;
for (int i = 1; i &= i++) {
result = result *
// 判断两个double型数据，计算机有误差
private boolean equal(double num1, double num2) {
if ((num1 - num2 & -0.0000001) && (num1 - num2 & 0.0000001)) {
一个细节，再判断底数base是不是等于0时，不能直接写base==0，这是因为在计算机内表示小数时(包括float和double型小数)都有误差。判断两个数是否相等，只能判断 它们之间的绝对值是不是在一个很小的范围内。如果两个数相差很小，就可以认为它们相等。
还有更快的方法。
如果我们的目标是求出一个数字的32次方，如果我们已经知道了它的16次方，那么只要在16次方的基础上再平方一次就好了，依此类推，我们求32次方只需要做5次乘法。
我们可以利用如下公式：
private double powerWithExponent2(double base,int exponent){
if(exponent == 0){
if(exponent == 1){
double result = powerWithExponent2(base, exponent && 1);
if((exponent&0x1) == 1){
我们用右移运算代替除2，用位与运算符代替了求余运算符（%)来判断一个数是奇数还是偶数。位运算的效率比乘除法及求余运算的效率要高很多。
扑克牌的顺子
从扑克牌中随机抽 5 张牌,判断是不是顺子,即这 5 张牌是不是连续的。 2-10 为数字本身,A 为 1,J 为 11,Q 为 12,K 为 13,而大小王可以看成任意的 数字。
解题思路：我们可以把5张牌看成是由5个数字组成的俄数组。大小王是特殊的数字，我们可以把它们都定义为0，这样就可以和其他的牌区分开来。
首先把数组排序，再统计数组中0的个数，最后统计排序之后的数组中相邻数字之间的空缺总数。如果空缺的总数小于或者等于0的个数，那么这个数组就是连续的，反之则不连续。如果数组中的非0数字重复出现，则该数组是不连续的。换成扑克牌的描述方式就是如果一幅牌里含有对子，则不可能是顺子。
详细代码：
import java.util.A
public class Solution {
public boolean isContinuous(int[] number){
if(number == null){
Arrays.sort(number);
int numberZero = 0;
int numberGap = 0;
//计算数组中0的个数
for(int i = 0;i & number.length&&number[i] == 0; i++){
numberZero++;
//统计数组中的间隔数目
int small = numberZ
int big = small + 1;
while(big&number.length){
//两个数相等，有对子，不可能是顺子
if(number[small] == number[big]){
numberGap+= number[big] - number[small] - 1;
return (numberGap&numberZero)?false:
圆圈中最后剩下的数字
0,1,...,n-1这n个数字排成一个圆圈，从数字0开始每次从这个圆圈里删除第m个数字。求这个圆圈里剩下的最后一个数字。
可以创建一个总共有n个结点的环形链表，然后每次在这个链表中删除第m个结点。我们发现使用环形链表里重复遍历很多遍。重复遍历当然对时间效率有负面的影响。这种方法每删除一个数字需要m步运算，总共有n个数字，因此总的时间复杂度为O(mn)。同时这种思路还需要一个辅助的链表来模拟圆圈，其空间复杂度O(n）。接下来我们试着找到每次被删除的数字有哪些规律，希望能够找到更加高效的算法。
首先我们定义一个关于n和m的方程f(n,m)，表示每次在n个数字0，1，。。。n-1中每次删除第m个数字最后剩下的数字。
在这n个数字中，第一个被删除的数字是（m-1)%n.为了简单起见，我们把（m-1)%n记为k，那么删除k之后剩下的n-1个数字为0，1，。。。。k-1，k+1,.....n-1。并且下一次删除从数字k+1,......n-1,0,1,....k-1。该序列最后剩下的数字也应该是关于n和m的函数。由于这个序列的规律和前面最初的序列不一样（最初的序列是从0开始的连续序列），因此该函数不同于前面的函数，即为f'(n-1,m)。最初序列最后剩下的数字f(n,m)一定是删除一个数字之后的序列最后剩下的数字，即f(n,m)=f'(n-1,m).
接下来我么把剩下的这n-1个数字的序列k+1,....n-1，0，1，,,,,,,k-1做一个映射，映射的结果是形成一个从0到n-2的序列
---------&
---------&
---------&
我们把映射定义为p，则p(x) = (x-k-1)%n。它表示如果映射前的数字是x,那么映射后的数字是（x-k-1)%n.该映射的逆映射是p-1(x)= (x+k+1)%n.
由于映射之后的序列和最初的序列具有同样的形式，即都是从0开始的连续序列，因此仍然可以用函数f来表示，记为f(n-1,m).根据我们的映射规则，映射之前的序列中最后剩下的数字f'(n-1,m) = p-1[(n-1,m)] = [f(n-1,m)+k+1]%n ,把k= (m-1)%n代入f(n,m) = f'(n-1,m) =[f(n-1,m)+m]%n.
经过上面的复杂的分析，我们终于找到一个递归的公示。要得到n个数字的序列中最后剩下的数字，只需要得到n-1个数字的序列和最后剩下的数字，并以此类推。当n-1时，也就是序列中开始只有一个数字0，那么很显然最后剩下的数字就是0.我们把这种关系表示为：
代码如下：
public static int lastRemaining(int n, int m){
if(n & 1 || m & 1){
return -1;
int last = 0;
for(int i = 2; i &= i++){
last = (last + m) %
Given an array of integers, find two numbers such that they add up to a specific target number.
The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.
You may assume that each input would have exactly one solution.
Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2
题目大意：
给定一个整数数组，找到2个数字，这样他们就可以添加到一个特定的目标号。功能twosum应该返回两个数字，他们总计达目标数，其中index1必须小于index2。请注意，你的答案返回（包括指数和指数）不为零的基础。你可以假设每个输入都有一个解决方案。
输入数字numbers= { 2，7，11，15 }，目标= 9输出：index1 = 1，index2= 2
解题思路：
可以申请额外空间来存储目标数减去从头遍历的数，记为key，如果hashMap中存在该key，就可以返回两个索引了。
import java.util.HashM
public class Solution {
public int[] twoSum(int[] numbers, int target) {
HashMap&Integer, Integer& map = new HashMap&&();
for(int i = 0; i & numbers. i++){
if(map.get(numbers[i]) != null){
int[] result = {map.get(numbers[i]) + 1, i+1};
map.put(target - numbers[i], i);
int[] result = {};
设计一个有getMin功能的栈
实现一个特殊的栈，在实现栈的基本功能的基础上，在实现返回栈中最小元素的操作。
pop、push、getMin操作的时间复杂度都是O(1)
设计的栈类型可以使用现成的栈结构
package chapter01_
import java.util.S
* 实现一个特殊的栈，在实现栈的基本功能的基础上，在实现返回栈中最小元素的操作。 要求： 1. pop、push、getMin操作的时间复杂度都是O(1)
* 2. 设计的栈类型可以使用现成的栈结构
* @author dream
public class Problem01_GetMinStack {
public static class MyStack1 {
* 两个栈，其中stacMin负责将最小值放在栈顶，stackData通过获取stackMin的peek()函数来获取到栈中的最小值
private Stack&Integer& stackD
private Stack&Integer& stackM
* 在构造函数里面初始化两个栈
public MyStack1() {
stackData = new Stack&Integer&();
stackMin = new Stack&Integer&();
* 该函数是stackData弹出栈顶数据，如果弹出的数据恰好等于stackMin的数据，那么stackMin也弹出
public Integer pop() {
Integer num = (Integer) stackData.pop();
if (num == getmin()) {
return (Integer) stackMin.pop();
* 该函数是先判断stackMin是否为空，如果为空，就push新的数据，如果这个数小于stackMin中的栈顶元素，那么stackMin需要push新的数，不管怎么样
* stackData都需要push新的数据
* @param value
public void push(Integer value) {
if (stackMin.isEmpty()) {
stackMin.push(value);
else if (value & getmin()) {
stackMin.push(value);
stackData.push(value);
* 该函数是当stackMin为空的话第一次也得push到stackMin的栈中，返回stackMin的栈顶元素
public Integer getmin() {
if (stackMin == null) {
throw new RuntimeException("stackMin is empty");
return (Integer) stackMin.peek();
public static void main(String[] args) throws Exception {
* 要注意要将MyStack1声明成静态的，静态内部类不持有外部类的引用
MyStack1 stack1 = new MyStack1();
stack1.push(3);
System.out.println(stack1.getmin());
stack1.push(4);
System.out.println(stack1.getmin());
stack1.push(1);
System.out.println(stack1.getmin());
System.out.println(stack1.pop());
System.out.println(stack1.getmin());
System.out.println("=============");
由两个栈组成的队列
编写一个类，用两个栈实现队列，支持队列的基本操作(add、poll、peek)。
* 编写一个类，用两个栈实现队列，支持队列的基本操作(add、poll、peek)。
* @author dream
public class Problem02_TwoStacksImplementQueue {
public static class myQueue{
Stack&Integer& stack1;
Stack&Integer& stack2;
public myQueue() {
stack1 = new Stack&Integer&();
stack2 = new Stack&Integer&();
* add只负责往stack1里面添加数据
* @param newNum
public void add(Integer newNum){
stack1.push(newNum);
* 这里要注意两点：
* 1.stack1要一次性压入stack2
* 2.stack2不为空，stack1绝不能向stack2压入数据
public Integer poll(){
if(stack1.isEmpty() && stack2.isEmpty()){
throw new RuntimeException("Queue is Empty");
}else if(stack2.isEmpty()){
while (!stack1.isEmpty()) {
stack2.push(stack1.pop());
return stack2.pop();
public Integer peek(){
if(stack1.isEmpty() && stack2.isEmpty()){
throw new RuntimeException("Queue is Empty");
}else if(stack2.isEmpty()){
while (!stack1.isEmpty()) {
stack2.push(stack1.pop());
return stack2.peek();
public static void main(String[] args) {
myQueue mQueue = new myQueue();
mQueue.add(1);
mQueue.add(2);
mQueue.add(3);
System.out.println(mQueue.peek());
System.out.println(mQueue.poll());
System.out.println(mQueue.peek());
System.out.println(mQueue.poll());
System.out.println(mQueue.peek());
System.out.println(mQueue.poll());
如何仅用递归函数和栈操作逆序一个栈
一个栈一次压入了1、2、3、4、5，那么从栈顶到栈底分别为5、4、3、2、1.将这个栈转置后，从栈顶到栈底为1、2、3、4、5，也就是实现栈中元素的逆序，但是只能用递归函数来实现，不能用其他数据结构。
* 一个栈一次压入了1、2、3、4、5，那么从栈顶到栈底分别为5、4、3、2、1.将这个栈转置后，
* 从栈顶到栈底为1、2、3、4、5，
* 也就是实现栈中元素的逆序，但是只能用递归函数来实现，不能用其他数据结构。
* @author dream
public class Problem03_ReverseStackUsingRecursive {
public static void reverse(Stack&Integer& stack) {
if (stack.isEmpty()) {
int i = getAndRemoveLastElement(stack);
reverse(stack);
stack.push(i);
* 这个函数就是删除栈底元素并返回这个元素
* @param stack
public static int getAndRemoveLastElement(Stack&Integer& stack) {
int result = stack.pop();
if (stack.isEmpty()) {
int last = getAndRemoveLastElement(stack);
stack.push(result);
public static void main(String[] args) {
Stack&Integer& test = new Stack&Integer&();
test.push(1);
test.push(2);
test.push(3);
test.push(4);
test.push(5);
reverse(test);
while (!test.isEmpty()) {
System.out.println(test.pop());
个人博客：http://eddy.wiki/
1.把二元查找树转变成排序的双向链表 题目： 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。 要求不能创建任何新的结点，只调整指针的指向。 10 / \ 6 14 / \ / \ 4 8 12 16 转换成双向链表 4=6=8=10=12=14=16。 首先我...
第5章 引用类型(返回首页) 本章内容 使用对象 创建并操作数组 理解基本的JavaScript类型 使用基本类型和基本包装类型 用类型的值（对象）是引用类型的-个实例。在ECMAScript中，引用类型是--种数据结构， 1 I用于将数据和功能组织在一起。它也常被称为类，...
百战程序员_ Java1573题 QQ群：034603 掌握80%年薪20万掌握50%年薪10万 全程项目穿插, 从易到难，含17个项目视频和资料持续更新，请关注www.itbaizhan.com 国内最牛七星级团队马士兵、高淇等11位十年开发经验专...
美食不分国界， 各国之间的美食也可以互相模仿学习，但是美食的历史地域文化不同却很难在另一个国家做出原汁原味出来。这样中国小吃就被日本吃货们盯上了，日本一位大厨模仿了咱们中国的做法，但是他却怎么都学不来，一天只能做出一道。日本的饮食习惯比较西化，早餐不仅吃传统的米饭，也吃三明...
燈光的運用 魔幻神秘 璀璨奪目 柔美炫麗 建築的建設 鋼筋水泥 肌肉結實 粗獷原始
域名、空间，程序三大网站重要组成部分，本人多年从事参与建网站行业工作，很多新手问得关于域名，虚拟主机，建站方式的何去何从，互联网上都没有系统的说明，所以我就自己整理了一些。 花了本人近4小时整理出来的系列教程列表 域名注册：http://www.yinxi.net/cust...
大部分python使用者, 还停留在Python2.x, 毕竟稳定性还是比较重要, 相关的扩展也是更丰富, 但Python3.x毕竟出来这么多年了, 所以还是有必要去尝试一下, mac或linux环境下, 使用python3.x安装扩展一般是不会出现什么问题的, 但是在wi...
换作4年前，你谈奥运，很多女性同志都是不怎么感兴趣的，不是因为没有什么爱国情怀，而是对于活了二十多年的女性同志们来说，对于运动天生不怎么感冒的她们，2000年的悉尼奥运会的时候她们只有几岁的样子，根本不懂奥运会。2004年雅典奥运会的时候，在某些偏爱运动的家长耳濡目染下开始...}