剑指Offer第三章面试题（Java版）

面试11：数值的整数次方

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

public class Solution {
    static boolean flag_invalidinput = false;

    public double Power(double base, int exponent) {
        double result = 0.0;
        //判断是否输入有效
        if(equals(base, 0.0)&&exponent<0){
            flag_invalidinput = true;
            return 0.0;
        }

        int absexponent = exponent;
        //判断指数是正数还是负数
        if(exponent<0)
            absexponent = -exponent;

        result = powerUnsignedNum(base, absexponent);
        //如果是负数求倒数。
        if (exponent<0) {
            result = 1.0/result;
        }

        return result;
    }


    public double powerUnsignedNum(double base, int absexponent){

        double result = 0.0;
        if(absexponent==0)
            return 1;
        if(absexponent==1)
            return base;
        result = powerUnsignedNum(base, absexponent>>1);
        result = result*result;

        if((absexponent&0x1)==1){
            result *= base;
        }
        return result;
    }


    public boolean equals(double num1,double num2){
        return (num1-num2<0.0000001)&&(num1-num2>-0.0000001)?true:false;
    }
}

注：

使用位运算符的效率比乘除法及求余运算效率高很多。

面试题12：打印1到最大的n位数

public void  printToMaxOfNDigits(int n) {
        //小于等于0，直接退出
        if(n<=0){
            return;
        }

        char[] chs = new char[n];
        for (int i = 0; i < 10; i++) {
            chs[0] = (char) (i +'0');
            printToMaxOfNDigits(chs,n,0);       
        }
    }


    public void printToMaxOfNDigits(char[] chs,int length,int index){

        if(index == length-1){
            printNumber(chs);
            return;
        }

        for (int i = 0; i < 10; i++) {
            chs[index+1] = (char) (i+'0');//chs[1]='0'
            printToMaxOfNDigits(chs,length,index+1);
        }   
    }

    //打印数字
    public void printNumber(char[] number){
        boolean isBegin = true;//假设开始为0
        for (int i = 0; i < number.length; i++) {
            if (isBegin&&number[i]!='0') {
                isBegin = false;//设置开始不为0
            }

            if(!isBegin){
                System.out.print(number[i]);
            }
        }
        System.out.print("-");
    }

面试题13：在O(1)的时间删除链表结点

public class Demo13 {
    //需要确保删除的元素在链表中
    public void DeleteNode(Node head,Node deleteNode){

        //要删除的节点不为空
        if(deleteNode.next!=null){
            Node tempNode = deleteNode.next;
            deleteNode.value = tempNode.value;
            deleteNode.next = tempNode.next;

            tempNode.next = null;

        }else if(head==deleteNode){//这里有个隐含条件了，deleteNode.next=null
            head.next=null;//链表只有一个节点，删除头结点（也是尾节点）

        }else {//链表有多个节点，删除的尾节点
            Node temp = head;
            while(temp.next!=deleteNode){
                temp = temp.next;
            }
            temp.next = null;
            deleteNode = null;
        }   
    }
    class Node{
        Node next;
        int value;
    }
}

注：本来删除一个链表节点我们需要知道该节点的头一个节点这就需要O（n）的时间，题目要求我们要在O（1）的时间内完成。因此我们只能找到该节点的下一个节点，将值覆盖该节点，然后删除下一个节点。这题存在一个缺陷就是我们必须要确保该节点存在于该链表中。

面试题14：调整数组顺序使奇数位于偶数前面

public class Solution {
    public static void reOrderArray(int [] array) {
        int low=0;
        int high = array.length-1;

        while(high>low){
            //如果是偶数，继续循环
            /*while((high>low)&&(array[high]&0x1)==0){
                high--;
            }*/
            while((high>low)&&isOdd(array[high])){
                high--;
            }

            //如果是奇数，继续循环
            /*while((high>low)&&(array[low]&0x1)==1){//加上判断条件high>low，可以节约一定步骤
                low++;
            }*/
            while((high>low)&&!isOdd(array[low])){
                low++;
            }

            if(high>low){
                int temp = array[low];
                array[low] = array[high];
                array[high] = temp;
            }
        }

    }

    public static boolean isOdd(int num){
        return (num&0x1)==0?true:false;
    }

    public static boolean isPlus(int num){
        return num>=0?true:false;
    }
}

附加：

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

public class Solution {
    public void reOrderArray(int [] array) {
        int len = array.length;

        for (int i = 0; i < len; i++) {
            if((array[i]&0x1)==0){//判断是否是偶数
                int j=i;
                int temp = array[j];
                while(j<array.length-1){
                    array[j] = array[j+1];
                    j++;
                }
                array[j]=temp;
                len--;//表名后面已经有一个偶数了   

                //i=-1;//交换之后，控制i每次从第一个开始比较
                i--;//相对于i=-1更优
            }
        }
    }
}

面试题15：链表中倒数第k个结点

输入一个链表，输出该链表中倒数第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||k==0) {
            return null;
        }

        ListNode firstNode = head;
        ListNode secordNode = head;
        for (int i = 0; i < k-1; i++) {
            if(secordNode.next!=null){
                secordNode = secordNode.next;
            }else {
                return null;
            }

        }

        while(secordNode.next!=null){
            firstNode = firstNode.next;
            secordNode = secordNode.next;
        }

        return firstNode;
    }
}

面试题16：反转链表

输入一个链表，反转链表后，输出链表的所有元素。

非递归版

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

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution
{
    public ListNode ReverseList(ListNode head) {
        ListNode newHead=null;
        ListNode first=null;
        ListNode second=head;
        ListNode three=null;

        if(second==null){
            return second;
        }

        while(second!=null){
            three = second.next;
            if(three==null)
                newHead = second;

            second.next = first;

            first = second;
            second = three;

        }
        return newHead;
    }
}

递归版

public class Demo16 {
    public class ListNode {
        int val;
        ListNode next = null;

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

    public  ListNode reverse(ListNode head) {   
        if (null == head || null == head.next) {   
            return head; 
        }
        ListNode reversedHead = reverse(head.next);

        head.next.next = head;   
        head.next = null;
        return reversedHead;   
    }   
    /**
     * 测试
     */
    public static void main(String[] args) { 
        Demo16 demo16 = new Demo16();
        ListNode node1 = demo16.new ListNode(1);
        ListNode node2 = demo16.new ListNode(2);
        ListNode node3 = demo16.new ListNode(3);
        ListNode node4 = demo16.new ListNode(4);
        ListNode node5 = demo16.new ListNode(5);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;

        ListNode reListNode = demo16.reverse(node1);

        ListNode tempListNode = reListNode;
        while (tempListNode!=null) {
            System.out.println(tempListNode.val);
            tempListNode = tempListNode.next;
        }

    }
}

面试题17：合并两个排序的链表

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

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

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        //解决鲁棒性问题
        if(list1 == null)
            return list2;
        if(list2 == null)
            return list1;

        ListNode mergeList = null;
        if(list1.val>list2.val){
            mergeList = list2;
            mergeList.next = Merge(list1, list2.next);
        }else {
            mergeList = list1;
            mergeList.next = Merge(list1.next, list2);
        }

        return mergeList;
    }
}

面试题18：树的子结构

输入两颗二叉树A，B，判断B是不是A的子结构。

/**
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) {
        boolean result = false;

        if(root1 != null && root2 !=null){
            if(root1.val == root2.val){
                result = DoesTree1HavaTree2(root1, root2);
            }

            //遍历左子树
            if(!result){
                result = HasSubtree(root1.left,root2);
            }

            //遍历右子树
            if(!result){
                result = HasSubtree(root1.right,root2);
            }
        }
        return result;
    }

    public boolean DoesTree1HavaTree2(TreeNode root1,TreeNode root2){
        //为什么要判断是否为null？ 因为该函数还会进行递归。
        if (root2==null) {
            return true;
        }
        if(root1==null){
            return false;
        }
        if (root1.val != root2.val) {
            return false;
        }
        return DoesTree1HavaTree2(root1.left,root2.left)
             &&DoesTree1HavaTree2(root1.right,root2.right);
    }
}