剑指offer的前16题-java版

public class Solution {

    /*//第一题
    在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。
    请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
     */
    public boolean Find(int target, int[][] array) {
        int n = array.length;//代表数组有n行
        int m = array[0].length;//代表数组有m列

        for (int i = 0; i < n && i < m; i++) {
            if (target == array[i][i]) {
                return true;
            } else if (target > array[i][i]) {
                continue;
            } else {
                //比较array[i-1][i]和array[i][i-1]
                for (int j = 0; j < i; j++) {
                    if (target == array[j][i] || target == array[i][j]) {
                        return true;
                    }
                }
            }
        }
        if (n > m) {
            for (int k = m; k < n; k++) {
                for (int j = 0; j < m; j++) {
                    if (target == array[k][j]) {
                        return true;
                    }
                }
            }
        } else if (n < m) {
            for (int k = 0; k < n; k++) {
                for (int j = n; j < m; j++) {
                    if (target == array[k][j]) {
                        return true;
                    }
                }
            }
        } else {
            return false;
        }
        return false;
    }

    //第二题
    /*
    请实现一个函数，将一个字符串中的空格替换成“%20”。
    例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
     */
    public String replaceSpace(StringBuffer str) {

        String[] strs = str.toString().split("");
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < strs.length; i++) {
            if (strs[i].equals(" ")) {
                sb.append("%20");
            } else {
                sb.append(strs[i]);
            }
        }
        return sb.toString();
    }

    //第三题
    /*
    输入一个链表，从尾到头打印链表每个节点的值。
     */
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> ai = new ArrayList<>();
        while (listNode != null) {
            ai.add(listNode.val);
            listNode = listNode.next;
        }
        ArrayList<Integer> aii = new ArrayList<>();
        for (int i = ai.size() - 1; i >= 0; i--) {
            aii.add(ai.get(i));
        }
        return aii;
    }

    //第四题
    /*
    输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
    例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，
    则重建二叉树并返回。
    针对根的存放顺序来决定
    先序遍历：中左右
    中序遍历：左中右
    后续遍历：左右中
     */

    public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
        if (pre.length == 0 || in.length == 0)
            return null;
        TreeNode node = new TreeNode(pre[0]);
        for (int i = 0; i < pre.length; i++) {
            if (pre[0] == in[i]) {
                //Arrays.copyOfRange  表示数组复制，左闭右开
                node.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i + 1), Arrays.copyOfRange(in, 0, i));
                node.right = reConstructBinaryTree(Arrays.copyOfRange(pre, i + 1, pre.length), Arrays.copyOfRange(in, i + 1, in.length));
                break;
            }
        }
        return node;
    }

    //第五题
// 用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();

    public void push(int node) {
        stack1.push(node);//实现队列的push操作

    }

    public int pop() {
        int result;
        if (stack2.empty()) {
            while (!stack1.empty()) {
                stack2.push(stack1.pop());
            }
            result = stack2.pop();
        } else {
            result = stack2.pop();
        }
        return result;
    }

    //第六题，把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
    // 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
    public int minNumberInRotateArray(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = i + 1; j < array.length; j++) {
                if (array[j] < array[i]) {
                    int temp = array[j];
                    array[j] = array[i];
                    array[i] = temp;
                }
            }
        }
        return array[0];

    }

    //第七题：大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项。n<=39
    public int Fibonacci(int n) {
        int[] F = new int[n + 1];
        if (n == 0) {
            return 0;
        }
        F[0] = 0;
        F[1] = 1;
        for (int i = 2; i < F.length; i++) {
            F[i] = F[i - 1] + F[i - 2];
        }
        return F[n];
    }

    //第8题：一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
    //1  1
    // 2  2
    // 3  3
    // 4  5
    // 5  8
    // 6  13
    public int JumpFloor(int target) {
        if (target == 0) {
            return 0;
        }
        if (target == 1) {
            return 1;
        }
        if (target == 2) {
            return 2;
        }
        int[] array = new int[target + 1];
        array[0] = 0;
        array[1] = 1;
        array[2] = 2;
        array[3] = 3;
        for (int i = 4; i < array.length; i++) {
            int x1 = array[i - 2] - array[i - 3];
            int x2 = array[i - 1] - array[i - 2];
            array[i] = array[i - 1] + x1 + x2;//等于上一个值加上斐波那契数列
        }
        return array[target];
    }

    //第九题：一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
    public int JumpFloorII(int target) {
        if (target == 0) {
            return 0;
        }
        if (target == 1) {
            return 1;
        }
        if (target == 2) {
            return 2;
        }
        int[] array = new int[target + 1];
        array[0] = 0;
        array[1] = 1;
        array[2] = 2;
        array[3] = 4;
        for (int i = 4; i < array.length; i++) {
            array[i] = array[i - 1] + (int) Math.pow(2, i - 2); //等于上一个值加上2的i-2次方
        }
        return array[target];

    }

    //第10题：我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
    //实际上是解一个斐波那契数列的修改版，需要通过分析可得
    public int RectCover(int target) {
        int[] F = new int[target + 1];
        if (target == 0) {
            return 0;
        }
        if (target == 1) {
            return 1;
        }
        F[0] = 0;
        F[1] = 1;
        F[2] = 2;
        for (int i = 3; i < F.length; i++) {
            F[i] = F[i - 1] + F[i - 2];
        }
        return F[target];
    }

    //第11题：输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
    //解题思路：将10进制转换为二进制
    //补码=反+1;
    //此处可以用到：补码+原码=int型的2的32次方，因为int型占4个字节，一个字节8位，也就是占32位，故补码加原码的和为2的32次方
    public int NumberOf1(int n) {
        StringBuilder sb = new StringBuilder();
        long nn = 0;
        //求正数的原码
        if (n < 0) {//针对负数，求其原码的补码，其补码=原码的反码+1
            nn = (long) Math.pow(2, 32) + n;
        } else {
            nn = n;
        }
        while (nn > 0) {
            if (nn % 2 == 1) {
                nn = nn / 2;
                sb.append(1);
            } else {
                nn = nn / 2;
                sb.append(0);
            }
        }
        int num = 0;
        String[] ss = sb.toString().split("");
        StringBuilder sb1 = new StringBuilder();
        for (int i = ss.length - 1; i >= 0; i--) {
            sb1.append(ss[i]);
            if (ss[i].equals("1")) {
                num++;
            }
        }
        return num;
    }

    //第12题：给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。
    public double Power(double base, int exponent) {
        double ss = Math.pow(base, exponent);
        return ss;
    }

    //第13题：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，
    // 所有的偶数位于位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。
    public void reOrderArray(int[] array) {
        int[] flag = new int[array.length];
        for (int i = 0; i < array.length; i++) {
            if (array[i] % 2 == 0) {//表示偶数
                flag[i] = 1;
            } else {//表示基数
                flag[i] = 0;
            }
        }
        int[] array_new = new int[array.length];
        int k = 0;
        for (int i = 0; i < array.length; i++) {
            if (flag[i] == 0) {
                array_new[k] = array[i];
                k++;
            }
        }
        for (int i = 0; i < array.length; i++) {
            if (flag[i] == 1) {

                array_new[k] = array[i];
                k++;
            }
        }
        for (int i = 0; i < array_new.length; i++) {
            array[i] = array_new[i];
        }
    }

    //第14题：输入一个链表，输出该链表中倒数第k个结点。
    public ListNode FindKthToTail(ListNode head, int k) {
        if (head == null) {
            return null;
        }
        int sum = 1;
        ListNode l = head;
        while (head.next != null) {
            head = head.next;
            sum = sum + 1;
        }//得到最后一个节点，跳出循环时，head属于最后一个节点,sum表示有多少个节点
        if (sum < k) {
            return null;
        }
        for (int i = 1; i < sum - k + 1; i++) {  //循环到第sum-k个节点，我们需要返回的是sum-k+1个节点，故执行下列语句可以得到
            l = l.next;
        }
        return l;
    }

    //第15题：输入一个链表，反转链表后，输出链表的所有元素。
    public ListNode ReverseList(ListNode head) {
        if (head == null) {
            return null;
        }
        ListNode ln = head;
        int sum = 1;
        while (head.next != null) {
            head = head.next;
            sum++;
        }//得到链表的最后一个节点
        int[] sb = new int[sum];
        //将节点中的值存储在一个数组中
        for (int i = 0; i < sum; i++) {
            sb[i] = ln.val;
            ln = ln.next;
        }
        //将数组中的值逆向赋值给一个新的链表
        ListNode no = new ListNode(sb[sb.length - 1]);
        if (sb.length == 1) {
            return no;
        }
        ListNode sk = no;//当后文no的节点被赋予值的时候，sk节点的后文也被赋予值，只不过指向的是首节点
        for (int i = sb.length - 2; i >= 0; i--) {
            no.next = new ListNode(sb[i]);
            no = no.next;
        }
        no.next = null;//此处no指向的是尾节点
        return sk;
    }

    //第16题：输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。
    public ListNode Merge(ListNode list1, ListNode list2) {
        ListNode head;
        if (list1 == null) {
            return list2;
        }
        if (list2 == null) {
            return list1;
        }
        if (list1.val < list2.val) {
            head = list1;
            head.next = Merge(list1.next, list2);
        } else {
            head = list2;
            head.next = Merge(list1, list2.next);
        }
        return head;
    }
  
    public static void main(String[] args) {
        ListNode no  = new ListNode(1);
        ListNode p = no;
       for (int i =2;i<12;i++){
           System.out.println(p.val);
           ListNode next = new ListNode(i);
           p.next = next;
           p = p.next;

       }


    }
}


class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}

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

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