牛客网中剑指office的1234题

最新推荐文章于 2019-06-20 10:30:24 发布

qq_34173971

最新推荐文章于 2019-06-20 10:30:24 发布

阅读量200

点赞数

分类专栏： Java 文章标签： Java 笔试

Java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1.在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数

public class Solution {
    public boolean Find(int target, int [][] array) {
        int rows = array.length;
        int col = array[0].length;
        
        //最简单的查询方法
        /*for(int i = 0;i < rows;i++){
            for(int j = 0;j < col;j++){
                if(target == array[i][j]){
                    return true;
                }
            }
        }
        return false;*/
        
        //根据有序的特性进行查找
        /*从左下角开始查找，大于左下角删除一行，小于左下角删除一列*/
        /*int i,j = 0;
        for(i = rows - 1,j = 0;i >= 0 && j < col;){
            if(target == array[i][j]){
                return true;
            }
            else if(target > array[i][j]){
                j++;
                continue;
            }
            else if(target < array[i][j]){
                i--;
                continue;
            }
        }
        return false;*/
        
        /*从右上角开始查找，大于右上角删除一行，小于右上角的删除一列*/
        int i,j;
        for(i = 0,j = col - 1;j >= 0 && i < rows;){
            if(target == array[i][j]){
                return true;
            }
            else if(target > array[i][j]){
                i++;
                continue;
            }
            else if(target < array[i][j]){
                j--;
                continue;
            }
        }
        return false;
        }
}

2.请实现一个函数，将一个字符串中的空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

public class Solution {
    public String replaceSpace(StringBuffer str) {
        String str1=str.toString();
       //toString()返回该对象的字符串表示

        char[] charArray = str1.toCharArray();
       //toCharArray()将字符串转换为字符数组

        StringBuffer s= new StringBuffer();
        for (char c : charArray) {
            if(c==' ') {
            s.append("%20");    
            }else {
                s.append(c);
            }
        }
        String string = s.toString();
        return string;
       /*
        int index = str.indexOf(" ");
        while(index != -1){
            str.replace(index,index+1,"%20");
            index = str.indexOf(" ",index);
        }
        String result = str.toString();
        return result;*/
    }
}

3.输入一个链表,按链表值从尾到头的顺序返回一个ArrayList

public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        ArrayList<Integer> result = new ArrayList<Integer>();
        ListNode temp = listNode;
        while ( temp != null ) {
            list.add( temp.val );
            temp = temp.next;
        }
        for ( int i = list.size()-1; i>=0; i-- ) {
            result.add( list.get(i) );
        }
        return result;
    }
}

4.输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

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,i-startIn+startPre+1,endPre,in,i+1,endIn);
            }
                  
        return root;
    }
}

package checkArray;
 
import java.util.ArrayList;
 
public class CheckArray {
    /*输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。
     * 假设输入的前序遍历和中序遍历的结果中都不含重复的数字
     * 。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍
     * 历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。*/
    
    public static void main(String[] args) {
        //测试
        int[] pre= {1,2,4,7,3,5,6,8};
        int[] in= {4,7,2,1,5,3,8,6};
        TreeNode treeNode=reConstructBinaryTree(pre,in);
        System.out.println(treeNode.toString());
    }
 
     public static TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        
         TreeNode treeNode=new TreeNode(pre[0]);
         
         //获取根节点在中序遍历数组中是位置
         int RootIndex=0;
         for(int i=0;i<in.length;i++) {
             if(in[i]==pre[0]) {
                 RootIndex=i;
             }
         }
         
         //去掉根节点
         //int[] pre2=new int[pre.length-1];
         int[] preLeft=new int[RootIndex];
         int[] preRight=new int[pre.length-RootIndex-1];
         
         for(int i=0;i<RootIndex;i++) {
             preLeft[i]=pre[i+1];
         }
         for(int i=0;i<pre.length-RootIndex-1;i++) {
             preRight[i]=pre[RootIndex+1+i];
         }
    
        //将中序的遍历的结果分为两份，一份是左节点，一份是右节点
         int[] leftArray=new int[RootIndex];
         int[] rightArray=new int[in.length-RootIndex-1];
         ArrayList<Integer> leftList=new ArrayList<>();
         ArrayList<Integer> rightList=new ArrayList<>();
         
         for(int i=0;i<RootIndex;i++) {
             leftArray[i]=in[i];
             leftList.add(in[i]);
         }
         
         for(int i=0;i<in.length-RootIndex-1;i++) {
             rightArray[i]=in[RootIndex+i+1];
             rightList.add(in[RootIndex+i+1]);
         }
         
        
         if(in.length>0&pre.length>0) {
             if(preLeft.length>0) {
        treeNode.left=reConstructBinaryTree(preLeft,leftArray);
             }
             if(preRight.length>0) {
                 treeNode.right= reConstructBinaryTree(preRight,rightArray);
             }
         }
         
         return treeNode;    
      }    
}
 
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

/**
 * 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) {
    if(pre.length == 0){return null;}//当长度为0直接返回空树
    TreeNode root=new TreeNode(pre[0]);//pre[0]是根值
    int len=pre.length;
    //len=1 说明是只有根的树
    if(len==1){
        root.left=null;
        root.right=null;
        return root;
    }
    //找到中序根位置index
    int rootnode=root.val;
    int i;
    for(i=0;i<len;i++){
        if(rootnode==in[i])
            break;
    }
        
    /**
        按照根的搜索方式，建立子树的前序遍历和中序遍历，并进行递归调用
        */
        
    //创建左子树
    if(i>0){
        
        int[] pre_left=new int[i];
        int[] in_left=new int[i];
        for(int j=0;j<i;j++){
            pre_left[j]=pre[j+1];
        }
        for(int j=0;j<i;j++){
            in_left[j]=in[j];
        }
        root.left=reConstructBinaryTree(pre_left,in_left);
    }else{
        root.left=null;
    }
    //创建右子树
    if(len-i-1>0){
        int[] pre_right=new int[len-i-1];
        int[] in_right=new int[len-i-1];
        for(int j=i+1;j<len;j++){            //j=i+1,因为i为中序根节点位置，也为前序遍历左子树的最后一个节点的位置
            pre_right[j-i-1]=pre[j];
            in_right[j-i-1]=in[j];
        }
        root.right=reConstructBinaryTree(pre_right,in_right);
    }else{
        root.right=null;
    }
    return root;
    }
 
}