算法练习必看

1.一球从100米高度自由落下，每次落地反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？

public static void main(String[] args) {
    double s=0;
    double t=100;

    for(int i=1;i<=10;i++){
        s+=t;
        t=t/2;
    }
    System.out.println(s);
    System.out.println(t);
}

2.输入一个整数，求该整数的二进制表达中有多少个1。例如输入10，由于其二进制表示为1010，有两个1，因此输出2

public static int  howManyOne(int num) { 
int i = 0;
while(num != 0){
    i= ((num>>=1) & 1) == 1? i+1:i;
   }
   return i;
}

&= 按位与赋值
|=  按位或赋值
^= 按位非赋值
>>= 右移赋值
>>>= 无符号右移赋值

<表达式1>?<表达式2>:<表达式3>; "?"运算符的含义是: 先求表达式1的值, 如果为真, 则执行表达式2，并返回表达式2的结果 ; 如果表达式1的值为假, 则执行表达式3 ，并返回表达式3的结果

3.两个有序数组的合并成一个

// 两个有序数组的合并函数
public static int[] MergeList(int a[], int b[]) {
   int result[];
   if (checkSort(a) && checkSort(b)) { // 检查传入的数组是否是有序的
       result = new int[a.length + b.length];
       int i = 0, j = 0, k = 0; // i:用于标示a数组 j：用来标示b数组 k：用来标示传入的数组

  while (i < a.length && j < b.length)
       if (a[i] <= b[j]) {
           result[k++] = a[i++];
       } else {
          result[k++] = b[j++];
   }

/* 后面连个while循环是用来保证两个数组比较完之后剩下的一个数组里的元素能顺利传入 */
while (i < a.length)
     result[k++] = a[i++];
while (j < b.length)
     result[k++] = b[j++];

  return result;
} else {
  System.out.print("非有序数组，不可排序！");
  return null;
  }
}
// 检查数组是否是顺序存储的
public static boolean checkSort(int a[]) {
boolean change = true; // 这个标志位是一种优化程序的方法，看看我写的冒泡排序优化就会明白了
for (int i = 0; i < a.length - 1 && change; i++) {
for (int j = i + 1; j < a.length; j++)
if (a[j - 1] > a[j])
  return false;
else
  change = false;
  }
  return true;
}
// 打印函数
public static void print(int b[]) {
   for (int i = 0; i < b.length; i++) {
       System.out.print(b[i] + (i % 10 == 9 ? "\n" : "\t"));
    }
}

public static void main(String args[]) {
int a[] = { 1, 2, 2, 3, 5, 6, 7, 7 };
int b[] = { 1, 2, 4, 5, 8, 8, 9, 10, 11, 12, 12, 13, 14 };
int c[] = MergeList(a, b);
  if (c != null)
     print(c);
  else
     System.out.println("");
 }

4.两个栈实现一个队列

栈（stack）在计算机科学中是限定仅在表尾进行插入或删除操作的线形表。 
栈是一种数据结构，它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）
队列：也是一种运算受限的线性表。它只允许在标的一端进行插入，而在另一端进行删除。

http://weidaohang.org/wangluo/h/index.php?q=aHR0cDovL2Jsb2cuY3Nkbi5uZXQvc2hlZXBtdS9hcnRpY2xlL2RldGFpbHMvMzg0MjgyMDU=

http://emuch.net/fanwen/450/61716.html

http://www.cnblogs.com/wanghui9072229/archive/2011/11/22/2259391.html

5.java泛型

http://javaee.h.baike.com/article-307334.html

http://lichaozhangobj.iteye.com/blog/476911

http://peiquan.blog.51cto.com/7518552/1302898

6.排序汇总

public static void bubbleSort() {// 冒泡排序
   int a[] = { 49, 38, 65, 97, 76, 13, 49, 78, 5, 4, 62, 53, 51 };
   int temp = 0;
   for (int i = 0; i < a.length - 1; i++) {
       for (int j = 0; j < a.length - 1 - i; j++) {
          if (a[j] > a[j + 1]) {
             temp = a[j];
             a[j] = a[j + 1];
             a[j + 1] = temp;
         }
     }
}

   for (int i = 0; i < a.length; i++)
        System.out.println(a[i]);
  }

public static int[] insertSort(int[] args) {// 插入排序算法
for (int i = 1; i < args.length; i++) {
for (int j = i; j > 0; j--) {
if (args[j] < args[j - 1]) {
int temp = args[j - 1];
args[j - 1] = args[j];
args[j] = temp;
} else
break;
}
}
return args;
}

public static int[] selectSort(int[] args) {// 选择排序算法
for (int i = 0; i < args.length - 1; i++) {
int min = i;
for (int j = i + 1; j < args.length; j++) {
if (args[min] > args[j]) {
min = j;
}
}
if (min != i) {
int temp = args[i];
args[i] = args[min];
args[min] = temp;
}
}
return args;
}

public static void main(String[] args) {
//冒泡排序
bubbleSort();

// 插入排序
int[] a = { 38, 65, 97, 76, 13, 49, 5, 62, 53, 51 };
int[] b = insertSort(a);
System.out.println(b);

// 快速排序
int[] c = { 5, 4, 2, 4, 9, 1 };
Arrays.sort(c); // 进行排序
for (int i : a) {
System.out.print(i);
}

// 选择排序
int[] d = { 49, 38, 65, 97, 76, 13, 5, 4, 62, 53, 51 };
int[] e = selectSort(d);
System.out.println(e[0]);
System.out.println(e[1]);
System.out.println(e[2]);
System.out.println(e[3]);
System.out.println(e[4]);
System.out.println(e[5]);
}

7.链表中的倒数第m个元素（链表）

http://www.cnblogs.com/xilifeng/archive/2012/10/06/2713185.html

http://www.it165.net/pro/html/201403/10922.html

http://wangyu.iteye.com/blog/190743

http://www.oschina.net/code/snippet_992559_21721

http://m.blog.csdn.net/blog/yujie_v/6856698

8.输入一个正整数 X，以2*X,4*X,8*X的方式递增，当大于10000时，再倒叙输出已经输出的整数。比如 X= 2468，输出结果为：2468，4936，9872，19744，19744，9872，4936，2468

public static void main(String[] args) {  
        func(2468);  
    }  
    private static void func(int x) {  
        if(x >= 10000){  
            System.out.println(x);  
            System.out.println(x);  
            return;  
        }  else if(x<10000){  
            System.out.println(x);  
            func(x<<1);  
            System.out.println(x);  
        }  
    }  

9.已知两个字符串由不同的字母组成，一长一短，长的为A，短的为B。若所有在B中出现的字符都在A中出现，则返回true，否则返回false。假设短的长度为m，长的长度为n，要求算法的时间复杂度不能大于O（m+n）

http://www.cnblogs.com/skylar/p/3657319.html

10.最快方法判断所有String2的字母在String1里是否存在，如：string2="abx",string1="abcdef",ab在string1中，x不在

      String string1 = "abx";
      String string2 = "abcdef";
       for (char b : string1.toCharArray()) {
            if (!string2.contains(b + "")){
                System.out.println(b);
            }
        }

11.Andriod如何处理UI与耗时操作的通信，有哪些方式及各自的优缺点。

handler机制是，在主线程中创建handler对象，
当执行耗时操作时，新建一个线程，在这个线程中执行耗时操作，通过调用handler的sendMessage，post等方法，更新ui界面；
AsyncTask本质上是一个线程池，所有的异步任务都会在这个线程池中的工作线程中执行，当需要操作ui界面时，会和工作线程通过handler传递消息。

handler机制的优点：  结构清晰，功能明确，但是代码过多；
asyncTask：简单，快捷，但是可能会新开大量线程，消耗系统资源，造成FC，

12.一个大小为n的数组，里面的数都属于范围[0, n-1]，有不确定的重复元素，找到至少一个重复元素，要求O(1)空间和O(n)时

http://blog.csdn.net/sunnyyoona/article/details/43883519

http://www.2cto.com/kf/201203/123393.html

算法复杂度分为时间复杂度和空间复杂度。其作用： 时间复杂度是度量算法执行的时间长短；而空间复杂度是度量算法所需存储空间的大小
时间复杂度
1.时间频度
　　一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
2.计算方法
　　1. 一般情况下，算法的基本操作重复执行的次数是模块n的某一个函数f（n），因此，算法的时间复杂度记做：T（n）=O（f（n）） 　　分析：随着模块n的增大，算法执行的时间的增长率和f（n）的增长率成正比，所以f（n）越小，算法的时间复杂度越低，算法的效率越高。 　　2. 在计算时间复杂度的时候，先找出算法的基本操作，然后根据相应的各语句确定它的执行次数，再找出T（n）的同数量级（它的同数量级有以下：1，Log2n ，n ，nLog2n ，n的平方，n的三次方，2的n次方，n！），找出后，f（n）=该数量级，若T(n)/f(n)求极限可得到一常数c，则时间复杂度T（n）=O（f（n）） 　　例：算法： 　　for（i=1;i<=n;++i） 　　{ 　　for(j=1;j<=n;++j) 　　{ 　　c[ i ][ j ]=0; //该步骤属于基本操作 执行次数：n的平方 次 　　for(k=1;k<=n;++k) 　　c[ i ][ j ]+=a[ i ][ k ]*b[ k ][ j ]; //该步骤属于基本操作 执行次数：n的三次方 次 　　} 　　} 　　则有 T（n）= n的平方+n的三次方，根据上面括号里的同数量级，我们可以确定 n的三次方 为T（n）的同数量级 　　则有f（n）= n的三次方，然后根据T（n）/f（n）求极限可得到常数c 　　则该算法的 时间复杂度：T（n）=O（n的三次方）
空间复杂度
与时间复杂度类似，空间复杂度是指算法在计算机内执行时所需存储空间的度量。记作: S(n)=O(f(n)) 我们一般所讨论的是除正常占用内存开销外的辅助存储单元规模。

13.Java实现 找出数组中出现次数超过数组长度一半的元素

http://blog.csdn.net/anialy/article/details/8075310

14.1、2、2、3、4、5这六个数字，用java写一个main函数，打印出所有不同的排列，如：512234、412345等，要求："4"不能在第三位，"3"与"5"不能相连

public class MathTest {
private static String[] mustExistNumber = new String[] { "1", "2", "2",
"3", "4", "5" };
private static boolean isValidNumber(String str) {
// 检查是否包含12345这五个数，不包含返回false
for (String number : mustExistNumber) {
if (str.indexOf(number) < 0)
return false;
}
// 检查是否有两个2，只有一个返回false
if (str.lastIndexOf("2") == str.indexOf("2")) {
return false;
}
// 检查4在不在第三位，是返回false
if (str.charAt(2) == '4') {
return false;
}
// 检查是否存在35在一起，有返回false
if (str.indexOf("35") >= 0 || str.indexOf("53") >= 0) {
return false;
}
return true;
}

public static void main(String[] args) {
for (int i = 122345; i < 543221; i++) {
if (isValidNumber(String.valueOf(i))) {
System.out.println(i);
}
}
}
}

15.数组相关算法

https://github.com/zhanhongtao/blog/issues/49#issuecomment-28761995  //数组相关算法

http://www.open-open.com/bbs/view/1320502624734   //各种算法

16.df