第一題

/**在一個二維陣列中，每一行都按照從左到右遞增的順序排序，每一列都按照從上到下遞增的順序排序。
 * 請完成一個函式，輸入這樣的一個二維陣列和一個整數，判斷陣列中是否含有該整數。
 * Created by gentl on 2017/9/18.
 */

public class T1_cankao {
    /*兩種思路
    一種是：
    把每一行看成有序遞增的陣列，
    利用二分查詢，
    通過遍歷每一行得到答案，
    時間複雜度是nlogn*/
    public class Solution {
        public boolean Find(int [][] array,int target) {

            for(int i=0;i<array.length;i++){
                int low=0;
                int high=array[i].length-1;
                while(low<=high){
                    int mid=(low+high)/2;
                    if(target>array[i][mid])
                        low=mid+1;
                    else if(target<array[i][mid])
                        high=mid-1;
                    else
                        return true;
                }
            }
            return false;

        }
    }

   /* 另外一種思路是：
    利用二維陣列由上到下，由左到右遞增的規律，
    那麼選取右上角或者左下角的元素a[row][col]與target進行比較，
    當target小於元素a[row][col]時，那麼target必定在元素a所在行的左邊,
    即col--；
    當target大於元素a[row][col]時，那麼target必定在元素a所在列的下邊,
    即row++；*/
    public class Solution2 {
        public boolean Find(int [][] array,int target) {
            int row=0;
            int col=array[0].length-1;
            while(row<=array.length-1&&col>=0){
                if(target==array[row][col])
                    return true;
                else if(target>array[row][col])
                    row++;
                else
                    col--;
            }
            return false;

        }
    }
    //
    public class Solution3 {
        public boolean Find(int [][] array,int target) {
            int len = array.length-1;
            int i = 0;
            while((len >= 0)&& (i < array[0].length)){
                if(array[len][i] > target){
                    len--;
                }else if(array[len][i] < target){
                    i++;
                }else{
                    return true;
                }
            }
            return false;
        }
    }
}
 

第二題

/**
 * Created by gentl on 2017/9/18.
 * 請實現一個函式，將一個字串中的空格替換成“%20”。
 * 例如，當字串為We Are Happy.
 * 則經過替換之後的字串為We%20Are%20Happy。
 */
public class T2 {
    public String replaceSpace(StringBuffer str) {
        for (int i=0;i<str.length();i++){
            if(str.charAt(i)==' '){
                str.deleteCharAt(i);
                str.insert(i,"%20");
            }
        }
        return str.toString();
    }
}
 

第三題

import java.util.ArrayList;
import java.util.Stack;

/**
 * Created by gentl on 2017/9/18.
 * 輸入一個連結串列，從尾到頭列印連結串列每個節點的值。
 */
class ListNode {
    int val;
    ListNode next = null;
    ListNode(int val) {
        this.val = val;
    }
}

public class T3 {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> al=new ArrayList<>();
        Stack<Integer> st=new Stack<>();
        while (!listNode.equals(null)){
            //System.out.print(listNode.val+" ");
            st.push(listNode.val);
            //al.add(listNode.val);
            listNode=listNode.next;
        }
        while(!st.isEmpty()){
            al.add(st.peek());
            st.pop();
        }
        return al;
    }
}
 

第四題

/**
 * Created by gentl on 2017/9/18.
 */
/*
*輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建出該二叉樹。
* 假設輸入的前序遍歷和中序遍歷的結果中都不含重複的數字。
* 例如輸入前序遍歷序列{1,2,4,7,3,5,6,8}和中序遍歷序列{4,7,2,1,5,3,8,6}，
* 則重建二叉樹並返回。
*/

//Definition for binary tree
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

public class T4 {

 public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
     TreeNode root=reConstruct(pre,0,pre.length-1,in,0,in.length-1);
     return root;
 }

    public TreeNode reConstruct(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=reConstruct(pre,startPre+1,startPre+i-startIn,in,startIn,i-1);
                root.right=reConstruct(pre,startPre+i-startIn+1,endPre,in,i+1,endIn);
            }
        }
        return root;
    }
}

import java.util.Stack;

/**
 * Created by gentl on 2017/9/18.
 * 用兩個棧來實現一個佇列，完成佇列的Push和Pop操作。
 * 佇列中的元素為int型別。
 */
public class T5 {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();

    public void push(int node) {
        stack1.push(node);
    }

    public int pop() {

        if(stack2.empty()){
            while(!stack1.empty()){
                stack2.push(stack1.pop());
            }
        }
        if (!stack2.empty()){
            return stack2.pop();
        }else return -1;
    }
}

/**
 * Created by gentl on 2017/9/18.
 * 把一個數組最開始的若干個元素搬到陣列的末尾，我們稱之為陣列的旋轉。
 * 輸入一個非遞減排序的陣列的一個旋轉，輸出旋轉陣列的最小元素。
 * 例如陣列{3,4,5,1,2}為{1,2,3,4,5}的一個旋轉，該陣列的最小值為1。
 * NOTE：給出的所有元素都大於0，若陣列大小為0，請返回0。
 */

 public static int minNumberInRotateArray(int[] array) {
        if (array.length == 0)
            return 0;
        int left = 0;
        int right = array.length - 1;
        int middle = -1;
        while (array[left]>=array[right]) {
            if(right-left==1){
                middle = right;
                break;
            }
            middle = left + (right - left) / 2;
            if (array[middle] >= array[left]) {
                left = middle;
            }
            if (array[middle] <= array[right]) {
                right = middle;
            }
        }
        return array[middle];
    }