剑指Offer【11-20】Java实现

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

public class Solution {
    public int NumberOf1(int n) {
        int num = 0;
        int[] arr = new int[32];
        if(n > 0){
            arr = getT(n);

        }
        else if(n < 0){
            arr = getC(n);
        }
        else{
            return 0;
        }
        for(int i=0; i<arr.length; i++){
            if(arr[i] == 1){
                num++;
            }
        }
        return num;
    }
    public int[] getT(int n){
        int[] arr = new int[32];
        if(n == 0){
            return arr;
        }
        int m = n>0?n:-n;
        int cur = arr.length-1;
        while(m!=0){
            int x = m%2;
            arr[cur] = x;
            m = m/2;
            cur--;
        }
        if(n < 0){
            arr[0] = 1;
        }
        else{
            arr[0] = 0;
        }
        return arr;
    }
    public int[] getR(int n){
        int[] arr = new int[32];
        arr = getT(n);
        for(int i=arr.length-1; i>0; i--){
            if(arr[i] == 0){
                arr[i] = 1;
            }
            else{
                arr[i] = 0;
            }
        }
        return arr;
    }
    public int[] getC(int n){
        int[] arr = new int[32];
        arr = getR(n);

        boolean flag = false;
        for(int i=arr.length-1; i>0; i--){
            if(arr[i] == 0){
                arr[i] = 1;
                break;
            }
            else if(arr[i] == 1 && flag == false){
                arr[i] = 0;
            }
        }

        return arr;
    }
}

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

public class Solution {
    public double Power(double base, int exponent) {
        double tmp = base;
        if(exponent == 0){
            return 1;
        }
        if(exponent > 0){
            for(int i=1; i<exponent; i++){
                tmp = tmp*base;
            }
        }
        else if(exponent < 0){
            exponent = -exponent;
            for(int i=1; i<exponent; i++){
                tmp = tmp*base;
            }
            tmp = 1.0/tmp;
        }
        return tmp;
  }
}

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

public class Solution {
    public void reOrderArray(int [] array) {
        int[] arr = new int[array.length];
        int j = 0;
        for(int i=0; i<array.length; i++){
            if(isJ(array[i])){
                arr[j] = array[i];
                j++;
            }
        }
        for(int i=0,k=j;i<array.length;i++){
            if(!isJ(array[i])){
                arr[k] = array[i];
                k++;
            }
        }
        for(int i=0; i<array.length; i++) {
            array[i] = arr[i];
        }
    }
    public boolean isJ(int a){
        if(a%2 == 0){
            return false;
        }
        return true;
    }
}

14、输入一个链表，输出该链表中倒数第k个结点。

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
        if(head == null){
            return null;
        }
        ListNode p1 = head;
        ListNode p2 = head;
        int num = k;
        while(num>0 && p1!=null){
            num--;
            p1 = p1.next;
        }
        if(num>0){
            return null;
        }
        //System.out.print(p1.val);
        while(p1 != null){
            p2 = p2.next;
            p1 = p1.next;
        }
        return p2;
    }
}

15、输入一个链表，反转链表后，输出新链表的表头。

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        if(head == null){
            return null;
        }
        if(head.next == null){
            return head;
        }
        ListNode pre = head;
        ListNode cur = head.next;
        pre.next = null;
        while(cur!=null){
            ListNode tmp;
            tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
        return pre;
    }
}

16、输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        ListNode node = null;
        ListNode head = null;
        if(list1==null){
            return list2;
        }
        if(list2==null){
            return list1;
        }
        if(list1.val<list2.val){
            head = list1;
            node = head;
            list1 = list1.next;
        }
        else{
            head = list2;
            node = head;
            list2 = list2.next;
        }
        while(list1!=null && list2!=null){
            //ListNode nodeNext = null;
            if(list1.val<list2.val){

                node.next = list1;

                //node.next = nodeNext;
                node = node.next;
                list1 = list1.next;
            }
            else{
                node.next = list2;

                //node.next = nodeNext;
                node = node.next;
                list2 = list2.next;
            }
        }
        if(list1!=null){
            node.next = list1;
        }
        if(list2!=null){
            node.next = list2;
        }
        return head;
    }
}

17、输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {
        if(root1 == null){
            return false;
        }
        if(root2 == null){
            return false;
        }
        if(root1 == root2){
            return true;
        }
        boolean flag = false;
        flag = match(root1,root2);
        if(flag){
            return true;
        }
        else{
            return HasSubtree(root1.left,root2)||HasSubtree(root1.right,root2);
        }   
    }
    public boolean match(TreeNode node1,TreeNode node2){
        if(node2 == null){
            return true;
        }
        if(node1 == null){
            return false;
        }
        if(node1.val == node2.val){
            return match(node1.left,node2.left)&&match(node1.right,node2.right);
        }
        return false;
    }
}

18、操作给定的二叉树，将其变换为源二叉树的镜像。
输入描述:
二叉树的镜像定义：源二叉树
8
/ \
6 10
/ \ / \
5 7 9 11
镜像二叉树
8
/ \
10 6
/ \ / \
11 9 7 5

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public void Mirror(TreeNode root) {
        if(root == null){
            return;
        }
        TreeNode left = root.left;
        TreeNode right = root.right;
        if(left==null&&right==null){
            return;
        }
        root.left = right;
        root.right = left;
        if(root.left!=null){
            Mirror(root.left);
        }
        if(root.right!=null){
            Mirror(root.right);
        }
    }
}

19、输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
           ArrayList<Integer> arr = new ArrayList<Integer>();
           if(matrix == null){
               return arr;
           }
           boolean flag = true;
           while(flag){
               for(int i=0; i<matrix[0].length; i++){
                   arr.add(matrix[0][i]);
               }
               //System.out.println(arr.toString());
               matrix = delFirstRow(matrix);
               if(matrix.length == 0){
                   break;
               }
               matrix = rotate(matrix);  
           }
           //System.out.println(arr.toString());
           return arr;
    }
    public int[][] delFirstRow(int[][] matrix){
        int[][] arr = new int[matrix.length-1][matrix[0].length];
        for(int i=1,k=0; i<matrix.length; i++,k++){
            for(int j=0; j<matrix[i].length; j++){
                arr[k][j] = matrix[i][j];
            }
        }
        /*for(int i=0; i<arr.length; i++){
            for(int j=0; j<arr[i].length; j++){
                System.out.print(arr[i][j] + " ");
            }
        }*/
        return arr;
    }
    /**
     * 旋转数组
     * 1 2 3     3 6
     * 4 5 6     2 5
     *           1 4
     * @param matrix
     * @return
     */
    public int[][] rotate(int[][] matrix){
        int[][] arr = new int[matrix[0].length][matrix.length];
        for(int j=matrix[0].length-1,k=0; j>=0; j--,k++){
            for(int i=0; i<matrix.length; i++){
                arr[k][i] = matrix[i][j];
            }
        }
        /*for(int i=0; i<arr.length; i++){
            for(int j=0; j<arr[i].length; j++){
                System.out.print(arr[i][j] + " ");
            }
        }*/
        return arr;
    }
}

20、定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

import java.util.Stack;

public class Solution {


    Stack<Integer> stack = new Stack<Integer>();
    int min = 0;
    Stack<Integer> stack2 = new Stack<Integer>();
    public void push(int node) {
        if(stack.isEmpty()){
            min = node;
            stack.push(node);
            return;
        }
        stack.push(node);
        while(!stack.isEmpty()){
            int tmp = stack.peek();
            min = min<tmp?min:tmp;
            stack2.push(stack.pop());
        }
        while(!stack2.isEmpty()){
            stack.push(stack2.pop());
        }
    }

    public void pop() {
        if(stack.isEmpty()){
            return;
        }
        stack.pop();
        min = stack.peek();
        while(!stack.isEmpty()){
            int tmp = stack.peek();
            min = min<tmp?min:tmp;
            stack2.push(stack.pop());
        }
        while(!stack2.isEmpty()){
            stack.push(stack2.pop());
        }

    }

    public int top() {
        return stack.peek();
    }

    public int min() {
        return min;
    }
}