剑指offer

//思路：从左下角/右上角开始遍历，每走一步就可以剔除一行或者一列。
//复杂度：O(m+n)
    public boolean Find(int target, int [][] array) {
         int rowCount = array.length;
         int colCount = array[0].length;
         int i,j;
         for(i=rowCount-1,j=0;i>=0&&j<colCount;)
         {
             if(target == array[i][j]) return true;
             if(target < array[i][j]){
                 i--;
                 continue;
             }
             if(target > array[i][j]){
                 j++;
                 continue;
             }
         }
         return false;
    }

/*问题1：替换字符串，是在原来的字符串上做替换，还是新开辟一个字符串做替换！
问题2：在当前字符串替换，怎么替换才更有效率（不考虑java里现有的replace方法）
从前往后替换，后面的字符要不断往后移动，要多次移动，所以效率低下
从后往前，先计算需要多少空间，然后从后往前移动，则每个字符只为移动一次，这样效率更高一点。*/
public class Solution {
    public String replaceSpace(StringBuffer str) {
        int spacenum=0;
    	for(int i=0;i<str.length();i++)
            if(str.charAt(i)==' ') spacenum++;
        int indexHold=str.length()-1; 
        int newlength=str.length()+spacenum*2;
        int indexNew = newlength -1;
        str.setLength(newlength);
        for(;indexHold>=0;indexHold--){
            if(str.charAt(indexHold)==' '){
                str.setCharAt(indexNew--,'0');
                str.setCharAt(indexNew--,'2');
                str.setCharAt(indexNew--,'%');
            }
            else str.setCharAt(indexNew--,str.charAt(indexHold));
        }
        return str.toString();
    }
}

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.*;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        Stack<Integer> result = new Stack<Integer>();
        ArrayList<Integer> list = new ArrayList<Integer>();
        while(listNode!=null) {
            result.push(listNode.val);
            listNode=listNode.next;
        }
        int value=0;
        while(!result.isEmpty()){
            value=result.pop();
            list.add(value);
        }
        return list;
    }
}

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {    
    public TreeNode reConstructBinaryTree(int [] pre,int [] in){        
        TreeNode root=reConstructBinaryTree(pre,0,pre.length-1,in,0,in.length-1);        
        return root;    
    }    //前序遍历{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}
    //先左后右，按照前序遍历的顺序
    private TreeNode reConstructBinaryTree(int [] pre,int startPre,int endPre,
                                           int [] in, int startIn, int endIn){                 
        if(startPre>endPre||startIn>endIn)            
            return null;        
        TreeNode root=new TreeNode(pre[startPre]);                 
        for(int i=startIn;i<=endIn;i++)            
            if(in[i]==pre[startPre]){//前序遍历是以子树根节点顺序进行的                
                root.left=reConstructBinaryTree(pre,startPre+1,startPre+i-startIn,
                                                in,startIn,i-1);//左子树                
                root.right=reConstructBinaryTree(pre,startPre+i-startIn+1,endPre,
                                                 in,i+1,endIn);//右子树                      
                break;            
            }                         
        return root;    
    }
}

import java.util.Stack;

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    //stack1实现入队列，stack2实现出队列
    public void push(int node) {
        stack1.push(node);
    }
    
    public int pop() {
        if(stack1.isEmpty()&&stack2.isEmpty())
            throw new RuntimeException("Queue is empty!");
        if(stack2.isEmpty())
            while(!stack1.isEmpty()){
                stack2.push(stack1.pop());
            }
        return stack2.pop();
    }
}

public int minNumberInRotateArray(int [] array) {
        if(array.length==0) return 0;
        int low=0,high=array.length-1,mid=0;
        while(array[low]>=array[high]){//不满足这个说明是从小到大顺序，根本没变
            if(high-low==1){
                mid=high;
                break;
            }
            mid = low + (high - low) / 2;
            if(array[mid]>=array[low]) low=mid;
            else  high=mid;
        }
        return array[mid];
    }

public int Fibonacci(int n) {
        if(n==0) return 0;
        if(n==1||n==2) return 1;
        return Fibonacci(n-1)+Fibonacci(n-2);
    }
public int Fibonacci(int n) {//动态规划
        int f = 0, g = 1;        
        while(n-->0){            
            g += f;//前一项            
            f = g - f;//前二项        
        }        
        return f;
    }

public int JumpFloor(int target) {
        int f = 1, g = 1;        
        while(target-->0){            
            g += f;            
            f = g - f;        
        }        
        return f;//主要注意返回的是前面一阶而不是现在阶的数目
    }

public int JumpFloorII(int target) {
        if(target<=0) return 0;
        if(target==1) return 1;
        int a=1,b=1;
        while(target-->0){
            a=b;
            b*=2;
        }//经过变化，b是当前跳法，a是前一阶跳法
        return a;//平台不算台阶
    }　　

public int RectCover(int target) {
        if(target<=0) return 0;
        if(target==1) return 1;
        if(target==2) return 2;
        return RectCover(target-1)+RectCover(target-2);//横着竖着
    }

/*
分析一下代码：这段小小的代码，很是巧妙。
如果一个整数不为0，那么这个整数至少有一位是1。如果我们把这个整数减1，那么原来处在整数最右边的1就会变为0，
原来在1后面的所有的0都会变成1(如果最右边的1后面还有0的话)。其余所有位将不会受到影响。
举个例子：一个二进制数1100，从右边数起第三位是处于最右边的一个1。
减去1后，第三位变成0，它后面的两位0变成了1，而前面的1保持不变，因此得到的结果是1011.
我们发现减1的结果是把最右边的一个1开始的所有位都取反了。这个时候如果我们再把原来的整数和减去1之后的结果做与运算，
从原来整数最右边一个1那一位开始所有位都会变成0。如1100&1011=1000.
也就是说，把一个整数减去1，再和原整数做与运算，会把该整数最右边一个1变成0.
那么一个整数的二进制有多少个1，就可以进行多少次这样的操作。
*/
public class Solution {
    public int NumberOf1(int n) {
        int count=0;
        while(n!=0){
            n=n & (n-1);
            count++;
        }
        return count;
    }
}

public double Power(double base, int exponent) {
        if(base==0) return 0;
        if(base==1) return 1;
        if(exponent==0) return 1;
        if(exponent==1) return base;
        double temp = base;
        if(exponent>0){
            for(;exponent>1;exponent--){
                base = base * temp;
            }
        }
        else {
            for(;exponent<=0;exponent++){
                base = base / temp;
            }
        }
        return base;
  }//注意幂次是负数的情况

public void reOrderArray(int [] array) {
        if (array != null){            
            int[] even = new int[array.length];            
            int indexOdd = 0;            
            int indexEven = 0;            
            for (int num : array){                
                if ((num & 1) == 1){                    
                    array[indexOdd++] = num;                
                } else{                    
                    even[indexEven++] = num;                
                }            
            }             
            for (int i = 0; i < indexEven; i++){                
                array[indexOdd + i] = even[i];            
            }    
        }
    }

public ListNode FindKthToTail(ListNode head,int k) {//需要空间少
        ListNode pre=null,p=null;                
        p=head;        pre=head;        //两个指针都指向头结点        
        int a=k;        //记录k        
        int count=0;        //记录节点的个数
        //p指针先跑，并且记录节点数，当p指针跑了k-1个节点后，pre指针开始跑，        
        //当p指针跑到最后时，pre所指指针就是倒数第k个节点        
        while(p!=null){            
            p=p.next;            
            count++;            
            if(k<1){                
                pre=pre.next;            
            }            
            k--;        
        }        //如果节点个数小于所求的倒数第k个节点，则返回空        
        if(count<a) return null;        
        return pre;
    }

public ListNode ReverseList(ListNode head) {
        if(head==null) return null;
        ListNode pre = null, next = null;
        while(head!=null){
            next=head.next;//防止丢失下个节点
            head.next=pre;
            pre=head;
            head=next;
        }
        return pre;
    }