java编程题

最近有空会做一下这些编程题，再此做一个记录，并非是最优解。

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

/* 此二维数组可看成一个表格，里面数据是有序的 即左上角最小，右下角最大，因此从右上角开始对比，如果
 * 大于右上角，坐标下移，如果小于右上角则坐标左移继续对比，直至找到数据或者不能再移
 * */
public class Solution {
    public static boolean find(int target, int[][] array) {
        /*判断数组是否为空*/
        if (array == null || array.length <= 0 || array[0].length <= 0) {
            return false;
        }

        int rows = 0; // 获取数组行数
        int columns = array[0].length - 1; // 获取数组列数

        //判断是否小于最小数，大于最大数
        if (array[0][0] > target || array[array.length - 1][columns] < target) {
            return false;
        }
        //从左上角开始判断
        while (rows < array.length && columns >= 0) {
            System.out.println("array[" + rows + "][" + columns + "]");
            if (array[rows][columns] == target) {
                return true;
            } else if (array[rows][columns] > target) {
                columns--;
            } else {
                rows++;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        String str = "['1,2,3,4']";
        String newStr = str.replaceAll(",", "','");
        System.out.println(newStr);
    }
}

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

/*
 * 如果是自己写的替换方法，可以从后往前替换，从前往后替换可能会出现一些问题，由于是一个空格替换成三个字符，
 * 长度不一致会导致字符串长度出现变化，当字符下标后移时不是之前想要的字符
 * 
 * */
public class Solution2 {
    public static String replaceSpace(StringBuffer str) {
        /*暴力替换  从尾到头遍历替换*/
        int length = str.length();
        for (int i = length - 1; i >= 0; i--) {
            if (str.charAt(i) == 32) {
                str.replace(i, i + 1, "%20");
            }
        }
        return str.toString();
        /*
         *  第二种方式 直接使用已有方法
         *  return str.toString().replaceAll("\\s", "%20");
         * */

    }

    public static void main(String[] args) {
        StringBuffer str = new StringBuffer("We Are Happy");
        String res = replaceSpace(str);
        System.out.println(res);

    }
}

3、输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
import java.util.List;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list=new ArrayList();
        
        //获取正序list
        while(listNode!=null){
            list.add(listNode.val);
            listNode=listNode.next;
            
        }
        //将list倒序排序
        int size=list.size();
        Integer tem=null;
        for(int i=0;i<size-1-i;i++){
            tem = list.get(i);
            list.set(i,list.get(size-i-1));
            list.set(size-i-1,tem);
        }
        return list;
    }
}

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

/*
 * 前序遍历中的第一个肯定是根节点，根据根节点在中序遍历中可以将树分为左右两个子树中序遍历以及长度，
 * 根据长度在前序遍历中除去第一个元素，接下来就是左子树和右子树的前序遍历，
 * 接下来即可根据子树的前序遍历和中序遍历获取根节点和更小的子树
 * 以此递归
 * 
 * */
public class Solution4 {
    public static TreeNode reConstructBinaryTree(int[] pre, int[] in) {

        int size = pre.length;
        int i = 0;
        //如果遍历数组为空
        if (size == 0) {
            return null;
        }
        //根节点
        TreeNode tree = new TreeNode(pre[0]);

        //根据根节点和中序遍历找左右子节点
        for (; i < size; i++) {
            if (pre[0] == in[i]) {
                //右子树
                int[] newRightPre = new int[size - i - 1];
                int[] newRightIn = new int[size - i - 1];
                System.arraycopy(pre, i + 1, newRightPre, 0, size - i - 1);
                System.arraycopy(in, i + 1, newRightIn, 0, size - i - 1);
                //左子树
                int[] newLeftPre = new int[i];
                int[] newLeftIn = new int[i];
                System.arraycopy(pre, 1, newLeftPre, 0, i);
                System.arraycopy(in, 0, newLeftIn, 0, i);
                //递归
                tree.right = reConstructBinaryTree(newRightPre, newRightIn);
                tree.left = reConstructBinaryTree(newLeftPre, newLeftIn);
                break;
            }

        }
        return tree;
    }

    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 tree = reConstructBinaryTree(pre, in);
        System.out.println(tree.val);
    }
}

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode(int x) {
        val = x;
    }
}

5、用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

import java.util.Stack;

/*
 * 队列先进先出，栈后进先出，push为添加模拟进，pop为返回并删除一个数模拟出
 * 因此先将数压入栈1中，在将数据倒入到栈2中，数据顺序就会发生改变，先压入栈1的数就会在栈2的顶部
 * 当下次在添加数据时就现将栈2中的数据倒回栈1，添加后在倒入栈2完成一次push，进行删除操作就直接 
 * 将栈2顶部数据pop掉就达到了先进先出的目的
 * */
public class Solution5 {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();

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

    public int pop() {
        return stack2.pop();
    }
}

6、把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

/*
 * 非递减排序的数组，那么原数组是递增的或者每个元素相等，则第一个元素最小
 * 那么旋转后的数组可以分为两部分，例如{4,5,1,2,3}，4,5为前半部，1,2,3为后半部
 * 后半部分第一个元素1,就是最小元素，并且小于前一个元素，如果没有这样的数字
 * 我们可以认为这是一个所有值相等的数组，旋转后等于本身因此第一个元素是最小的。
 * 所以我们只需找到旋转数组中第一个小于前一位的元素，没有就是第一位元素即可
 * 
 * */

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        int length=array.length;
        if(length==0){
            return 0;
        }
        int i=0;
        for(;i<length-1;i++){
            if(array[i]>array[i+1]){
                return array[i+1];
            }
        }
        return array[i];
    }
}

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

/*
 * 斐波那契数列：1,1,2,3,5,8...(第一位第二位为1，从第三位开始等于前两位之和的数列)
 * 题目要求最多n为39，因此最多数组40位就可以了，我第一反应就是计算出来写死，代码也能通过就是自
 * 己算的太久并且显然不符合要考察的方向，因此还是老老实实写代码吧
 * 由题知：f(0)=0,f(1)=1,f(2)=1,f(n)=f(n-1)+f(n-2);(n>=3) 因此需要递归计算
 * */
public class Solution {
    public int Fibonacci(int n) {

 /*int[] array={0,1,1,2,3,5,8,13,21,34,
                55,89,144,233,377,610,987,1597,2584,4181,
                6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,
                832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986};
        return array[n];*/
        if(n==0){
            return 0;
        }else if(n==1){
            return 1;
        }else if(n==2){
            return 1;
        }else {
            return Fibonacci(n-1)+Fibonacci(n-2);
        }
    }
    
}

8、一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

/*
 * 对于本题,前提只有 一次 1阶或者2阶的跳法。
 * a.如果两种跳法，1阶或者2阶，那么假定第一次跳的是一阶，那么剩下的是n-1个台阶，跳法是f(n-1);
 * b.假定第一次跳的是2阶，那么剩下的是n-2个台阶，跳法是f(n-2)
 * c.由a\b假设可以得出总跳法为: f(n) = f(n-1) + f(n-2)
 * d.然后通过实际的情况可以得出：只有一阶的时候 f(1) = 1 ,只有两阶的时候可以有 f(2) = 2
 * e.可以发现最终得出的是一个斐波那契数列（可以参考上一题）：
 * */
public class Solution {
    public int JumpFloor(int n) {
        if(n==0){
            return 0;
        }else if(n==1){
            return 1;
        }else if(n==2){
            return 2;
        }else {
            return JumpFloor(n-1)+JumpFloor(n-2);
        }
    }
}

9、一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

/*
 * 此题我依旧使用了第八题的思路只不过变成了
 * f(1)=1,f(2)=2,f(n)=f(n-1)+f(n-2)+...+f(2)+f(1)+1,(n>=3);在此令f(0)=1则可以得到
 * f(0)=1,f(1)=1,f(2)=2,f(n)=f(n-1)+f(n-2)+...+f(2)+f(1)+f(0),(n>=3)
 * */
public class Solution {
    public int JumpFloorII(int n) {
        if(n==0){
            return 1;
        }else if(n==1){
            return 1;
        }else if(n==2){
            return 2;
        }else {
            int res=0;
            for(int i=1;i<=n;i++){
                res=res+JumpFloorII(n-i);
            }
            return res;
        }
    }
}

10、我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

/*
 * 这一题依旧是斐波那契数列和递归，思路参考第八题
 * */
public class Solution {
     public int RectCover(int n) {
        if (n == 0) {
            return 0;
        } else if (n == 1) {
            return 1;
        } else if (n == 2) {
            return 2;
        } else {
            int res = RectCover(n - 1) + RectCover(n - 2);
            return res;
        }
    }
}

11、输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

/* 
如果一个整数不为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){
            ++count;
            n = n & (n - 1);
        }
        return count;
    }
}

12、给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

/* 我直接用了Math.pow()这个方法，肯定有比这更优的答案*/
public class Solution {
    public double Power(double base, int exponent) {
        return Math.pow(base,exponent);
  }
}

13、输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

/*
    * 解题思路：
    * 建一个新数组，遍历旧数组，如果是奇数就从头开始放在新数组的前半部分，
    * 如果是偶数就从后往前放在新数组的最后。得到的新数组前半部分是相对位置不变的奇数后半部分为相对位置倒叙的偶数，
    * 比如旧数组为{1,2,3,4,5,6,7,8,9}，新数组为{1,3,5,7,9,8,6,4,2}。
    * 此时再将新数组的前半部分数放入旧数组的前半部分，新数组的后半部分倒叙放入旧数组的后半部
    * */
public class Solution {
    public void reOrderArray(int [] array) {
        int size = array.length;
        int[] newArray1 = new int[size];
        int flag1 = 0;
        int flag2 = size-1;
        for(int i=0;i<size;i++){
            if (array[i]%2==1){
                newArray1[flag1]=array[i];
                flag1++;
            }else {
                newArray1[flag2]=array[i];
                flag2--;
            }
        }
        for (int i=0;i<flag1;i++){
            array[i]=newArray1[i];
        }
        flag2 = size-1;
        for (int i=flag1;i<size;i++){
            array[i]=newArray1[flag2];
            flag2--;
        }
    }
}