剑指offer1-7题

/**

• 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
  思路：
  选定一个维度(行或列)先找到需要查找的元素所在的行(列)，再从该行(列)找到该元素的该元素具体的列(行)位置。复杂度O(n)。

优化：因为数列是递增有序的，可以进行二分查找进行优化，但是本题可以不进行二分也可以过。因为大家有兴趣可以去查一查编程语言数组可以开多大。然后单个查找在这个范围内即使不优化也不会超时。有兴趣的可以自己写一写二分！复杂度O(logn)
*/

public class Shuzuchazhao {


       public boolean Find(int target,int [][] array){
           if (array.length==0||array[0].length==0)
               return false;
           for (int i=array.length-1;i>=0;i--){
               if (array[i][0]>target){
                   continue;
               }
               for (int j=0;j<array[0].length;j++){
                    if (array[i][j] == target){
                        return true;
                    }
               }
           }
           return false;
       }
}

/**

• 请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
• 字符串遍历重构即可。遇到为 的字符直接在新的字符添加一个%20即可。当然，在java中直接使用replaceAll即可。复杂度O(n);
• ps: replaceall效率较低，建议使用StringBuider之类完成
• 大致就是 有讨论是在原字符串上进行移动还是新建字符串的问题。当然新建字符串会更简单些，但是如果遇到要求在原字符串基础上进行移动的，因为String的底层实现是数组，那就要首先遍历一次知道有多少空格，然后扩充空间。至于遍历完空格的移动方式：从后往前移动的方式更好，因为最终移动的位置是相同的，但是从前往后每次遇到空格都会拖家带口后面一串都要跟着移动。(好比国旗下讲话排队往后挫，要挫很多次整体慢慢腾腾移动)，而从后往前插就相当于很明确一个个明确移动到哪。
• 虽然两者最终已经总距离一样的，但是从前往后每个单词要经过(1-n)次才能移动到最后，而从后往前每个单词只1次就移动到目标位置！
  */

public class Tihuankongge {
       /** public static String replaceSpace(StringBuffer str){
            String team = str.toString();
            return team.replaceAll(" ","%20");
        }
        **/
        public static String  replaceSpace(StringBuffer str){
            StringBuffer str2=new StringBuffer();
             char demo=' ';
             for (int i=0;i<str.length();i++){
                 demo=str.charAt(i);
                 if (demo == ' '){
                     str2.append("%20");
                 }
                 else {
                     str2.append(demo);
                 }
             }
             return str2.toString();
        }
}

/**

• 输入一个链表，按链表从尾到头的顺序返回一个ArrayList。
• 思路：
• 题目给我们一个链表让我们返回一个序列数字。而这个序列要求我们将链表从后向前的顺序返回。当然，这样的话处理方法就比较多了。比如先从前往后存到一个数组中，然后数组再从后往前往List中塞。
• 当然Arraylist本身也是一个线性表(顺序表)，可以进行头插。将链表每次向后遍历的数插在首位，最后返回即可。
  */

public class Linkedlist {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {

        ArrayList<Integer>list=new ArrayList<Integer>();
        while (listNode!=null) {
            list.add(0, listNode.val);
            listNode=listNode.next;
        }
        return list;

    }
}

/**

• 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
• 我们都知道一个中序序列带着一个前序或者后序序列都能确定一棵完整的二叉树。首先分析这种问题。二叉树的问题大部分有可重复性，经常会使用递归。所以大部分人应该能够想到使用递归，但是可能不清楚该怎么递归。其实递归的使用不需要你考虑全篇，需要你谨慎完整的考虑其中一个过程。现在我们看看前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，的构造过程！

• 对于前序，我们知道从根还是，所以可以确定第一个是根。然而中序是左中右。我们找到根的位置，那么我们就可以确定这个根的左侧是左侧，根的右侧是二叉树的右侧。
  

• 然而很重要的一点是：在中序左侧右侧的在前序序列中的：根左右。虽然具体排序可能不同，但是左区域、右区域(区域元素总数量)也是连续的，所以我们这样可以确定唯一一个根，然后前序有左右两个区域，中序有左右两个区域，这样递归的构造子树，知道完成二叉排序树。
  

• 所以，如果用代码实现的话，比较麻烦的就是要考虑数组的区间问题，要记录进行复原的两数组的左右区间。
  

*/

public class Binarytree {

      public TreeNode reConstructBinaryTree(int [] pre, int [] in){
            TreeNode node=new TreeNode(in[0]);
            int preleft=0,preright=pre.length-1;
            int inleft=0,inright=pre.length-1;
            return creat(pre,in,preleft,preright,inleft,inright);
      }
      private TreeNode creat(int[] pre,int[] in,int preleft,int preright,int inleft,int inright){
            if (preleft>preright||inleft>inright) return null;
            TreeNode node=new TreeNode(pre[preleft]);
            int mid=0;
            for (int i=inleft;i<=inright;i++){
                  if (pre[preleft]==in[i]){
                        mid=i;
                  }
            }
            node.left=creat(pre,in,preleft+1,preleft+(mid-inleft),inleft,mid-1);
            node.right=creat(pre,in,preleft+(mid-inleft)+1,preright,mid+1,inright);
            return node;
      }
}

/**

• 用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型
• 首先要了解队列，队列是一种先进先出(排队)的结构，而栈是一种后进先出的结构。
• 要求完成push和pop两种操作。push就是加入队尾(tail)类似enqueue，而pop是返回并抛出队头(front)类似dequeue。我们假设stack1是用作返回，而stack2用作中转。可以先看看下面的图。假设7、3、5、6在队列中，待加入8（push8）.
  */

public class Stack {

    java.util.Stack<Integer> stack1=new java.util.Stack<>();
    java.util.Stack<Integer> stack2=new java.util.Stack<>();

    public void push(int node){
        while (!stack1.isEmpty()){
            stack2.push(stack1.pop());
        }
        stack2.push(node);
        while (!stack2.isEmpty()){
            stack1.push(stack2.pop());
        }
        stack2.clear();
    }
    public int pop(){
        return stack1.pop();
    }
}

/**

• 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
• 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
• 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
• NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
• 思路：
• 就是要求我们在这么一组序列中找到最小的一个数字，非递减的旋转，也就是这么一串有两段非递减的连续串串。找到第二个非递减的串串头就是结果。
• 然而，我们只需第一次查找到最小即可结束。不会超时还是因为数组大小有限制。无法提供更大量输入数据。复杂度为O(n)；

*/

public class Xuanzhuanshuzu {
        public int minNumberInRotateArray(int[] array){
            if (array.length==0)return 0;
            int min=array[0];
            for (int i=0;i<array.length;i++){
                if (array[i]<min){
                    min=array[i];
                    break;
                }
            }
            return min;
        }

        int minNumberInRotateArray(vector<int> rotateArray){
            if (rotateArray.empty()){
                return 0;

                int low=0;
                int high=rotateArray.size()-1;
                int mid=0;

                while (low<high){
                    if (rotateArray[low] < rotateArray[high])
                        return rotateArray[low];
                    mid=low+(high-low)/2;
                    if (rotateArray[mid] > rotateArray[low])
                        low=mid+1;
                    else if (rotateArray[mid] < rotateArray[high])
                        high=mid;
                    else low++;
                }
                return rotateArray[low];
            }
        }
}

/**

• 大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。
• n<=39
  */

public class Feibona {

    public int Fibonacci(int n){
        if (n==1||n==0){
            return n;
        }else{
            return Fibonacci(n-1+Fibonacci(n-2));
        }
    }
    public int Fibonacci2(int n){
        int Fibo[]=new int[40];
        Fibo[0]=0;
        Fibo[1]=1;
        for (int i=2;i<=n;i++){
            Fibo[i]=Fibo[i-1]+Fibo[i-2];
        }
        return Fibo[n];
    }
}

标签：遍历,return,int,前序,offer1,数组,public
来源： https://blog.csdn.net/u011676417/article/details/104678852