剑指offer66题（1-6）

第一题

/**在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。
 * 请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
 * 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];
    }