剑指offer面试题 java解答16-20

面试题16:反转链表

public class Test16 {
    private class Node<T>{
        private T obj;      
        private Node<T> next = null;
        Node(T obj) {
            this.obj = obj;
        }
    }
    private Node first = null;
    public Node getHeadNode(){
        return first;
    }
    public <T> void insertFirst(T obj){  
        Node node = new Node(obj);  
        node.next = first;  
        first = node;  
    }
    public Node ReverseList(Node head)
    {
        if (head==null) 
        {
            return null; 
        }
        Node reverseHead=null;
        Node preNode=null;
        Node nowNode=head;
        Node nextNode;
        while (nowNode!=null) 
        {
            if (nowNode.next==null)
            {
                reverseHead=nowNode;
            }
            nextNode=nowNode.next;
            nowNode.next=preNode;
            preNode=nowNode;
            nowNode=nextNode;
        }
        return reverseHead;
    }
    public static void main(String[] args) {
        int[] a={6,5,4,3,2,1};
        Test16 t=new Test16();
        for (int i = 0; i < a.length; i++) 
        {
            t.insertFirst(a[i]);//头插法
        }
        //链表为1->2->3->4->5->6
        Node head=t.ReverseList(t.getHeadNode());
    }
}

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

public class Test17 {
    private class Node<T>{
        private T obj;      
        private Node<T> next = null;
        Node(T obj) {
            this.obj = obj;
        }
    }
    private Node firstOne = null;
    private Node firstTwo = null;
    public Node getHeadOne(){
        return firstOne;
    }
    public Node getHeadTwo(){
        return firstTwo;
    }
    public <T> void insertFirstOne(T obj){  
        Node node = new Node(obj);  
        node.next = firstOne;  
        firstOne = node;  
    }
    public <T> void insertFirstTwo(T obj){  
        Node node = new Node(obj);  
        node.next = firstTwo;  
        firstTwo = node;  
    }
    public  void showLinkList(Node head) throws Exception{
        if (head==null) {
            throw new Exception("null");
        }
        Node cur=head;
        while (cur!=null) 
        {
            System.out.println("\n"+cur.obj);
            cur=cur.next;
        }
    }
    public <T extends Comparable<? super T>> Node<T> Merge(Node<T> headOne,Node<T> headTwo){
        if (headOne==null) 
        {
            return headTwo;
        }
        if (headTwo==null)
        {   
            return headOne;
        }
        Node<T> mergeHead=null;
        if ((headOne.obj).compareTo(headTwo.obj)<0) 
        {
            mergeHead=headOne;
            mergeHead.next=Merge(headOne.next, headTwo);
        }else 
        {
            mergeHead=headTwo;
            mergeHead.next=Merge(headOne, headTwo.next);
        }
        return mergeHead;
    }
    public static void main(String[] args) throws Exception {
        int[] a={7,5,3,1};
        int[] b={8,6,4,2};
        Test17 t=new Test17();
        for (int i = 0; i < a.length; i++) 
        {
            t.insertFirstOne(a[i]);//头插法
        }
        //链表为1->3->5->7
        for (int i = 0; i < a.length; i++) 
        {
            t.insertFirstTwo(b[i]);//头插法
        }
        //链表为2->4->6->8
        Node mergeHead=t.Merge(t.getHeadOne(), t.getHeadTwo());
        t.showLinkList(mergeHead);
    }
}

面试题18:树的子结构

public class Test18<T> {
    private class Node<T> {
        public T value;
        public Node<T> lChild;
        public Node<T> rChild;
        public Node(T value) {
            this.value = value;
        }
    }
    public Node<T> treeOne;
    public Node<T> treeTwo;
    private int pos = 0;
    public Node<T> creatBiTreeOne(T[] value){
        pos=0;
        return treeOne=creatBiTree(treeOne, value);
    }
    public Node<T> creatBiTreeTwo(T[] value){
        pos=0;
        return treeTwo=creatBiTree(treeTwo, value);
    }
    // 以node为根节点，创建一棵树，返回此根节点
    private Node<T> creatBiTree(Node node, T[] value) {
        T t = value[pos];
        pos++;
        if (t == null) {
            return null;
        } else {
            node = new Node<T>(t);
            node.lChild = creatBiTree(node.lChild, value);
            node.rChild = creatBiTree(node.rChild, value);
        }
        return node;
    }
    public void preOrderTraverse(Node node) {
        if (node != null) {
            System.out.println("" + node.value);
            preOrderTraverse(node.lChild);
            preOrderTraverse(node.rChild);
        }
    }
    private <T extends Comparable<? super T>> boolean dosHaveSubtree(Node<T> tree1,Node<T> tree2){
        if (tree2==null) 
        {
            return true;
        }
        if (tree1==null) 
        {
            return false;
        }
        if (tree1.value.compareTo(tree2.value)!=0)
        {
            return false;
        }
        return dosHaveSubtree(tree1.lChild, tree2.lChild)&&dosHaveSubtree(tree1.rChild, tree2.rChild);
    }
    public <T extends Comparable<? super T>> boolean HasSubtree(Node<T> tree1,Node<T> tree2){
        boolean hasSubtree=false;
        if (tree1!=null&&tree2!=null) 
        {
            if (tree1.value.compareTo(tree2.value)==0)
            {
                hasSubtree=dosHaveSubtree(tree1,tree2);
            }
            if (!hasSubtree) 
            {
                hasSubtree=HasSubtree(tree1.lChild, tree2);
            }
            if (!hasSubtree) 
            {
                hasSubtree=HasSubtree(tree1.rChild, tree2);
            }
        }
        return hasSubtree;
    }
    public static void main(String[] args) {
        Object[] a = { 8, 8, 9, null, null, 2, 4, null, null, 7, null, null, 7,null, null };
        Object[] b = { 8, 9, null, null, 2, null, null};
        Test18 t = new Test18();
        t.creatBiTreeOne(a);
        t.creatBiTreeTwo(b);
        System.out.println(t.HasSubtree(t.treeOne, t.treeTwo));
    }
}

面试题19:二叉树的镜像

public class Test19<T>{
    private class Node<T> {
        public T value;
        public Node<T> lChild;
        public Node<T> rChild;
        public Node(T value) {
            this.value = value;
        }
    }
    public Node<T> root=null;
    private int pos = 0;
    public void creatBiTree(T[] value){
        pos=0;
        root=creatBiTree(root, value);
    }
    // 以node为根节点，创建一棵树，返回此根节点
    private Node<T> creatBiTree(Node node, T[] value) {
        T t = value[pos];
        pos++;
        if (t == null) {
            return null;
        } else {
            node = new Node<T>(t);
            node.lChild = creatBiTree(node.lChild, value);
            node.rChild = creatBiTree(node.rChild, value);
        }
        return node;
    }
    public void preOrderTraverse(Node node) {
        if (node != null) {
            System.out.println("" + node.value);
            preOrderTraverse(node.lChild);
            preOrderTraverse(node.rChild);
        }
    }
    public void MirrorRecursively(Node<T> root) {
        if (root!=null) 
        {
            Node<T> rNode=root.rChild;
            root.rChild=root.lChild;
            root.lChild=rNode;
            MirrorRecursively(root.lChild);
            MirrorRecursively(root.rChild);
        }       
    }
    public static void main(String[] args) {
        Object[] a = { 8, 6, 5, null, null, 7, null, null, 10, 9, null, null, 11, null, null };
        Test19 t = new Test19();
        t.creatBiTree(a);
        t.MirrorRecursively(t.root);
        t.preOrderTraverse(t.root);
    }
}

面试题20:顺时针打印矩阵

public class Test20 {
    public void PrintMatrixClockwisely(int[][] a){
        if (a==null)
        {
            return;
        }
        int rows=a.length;
        int columns=a[0].length;
        int start=0;
        while (rows>start*2&&columns>start*2) {
            PrintMatrixInCircle(a,rows,columns,start);
            start++;
        }
    }
    private void PrintMatrixInCircle(int[][] a, int rows, int columns, int start) {
        int endX=columns-start-1;
        int endY=rows-start-1;
        for (int i = start; i <=endX; i++)
        {
            int number=a[start][i];
            printNumber(number);
        }
        if (start<endY) 
        {
            for (int i = start+1; i <=endY; i++) 
            {
                int number=a[i][endX];
                printNumber(number);
            }
        }
        if (start<endX&&start<endY) 
        {
            for (int i = endX-1; i >=start; i--) {
                int number=a[endY][i];
                printNumber(number);
            }
        }
        if (start<endX&&start<endY-1) 
        {
            for (int i = endY-1; i >=start+1; i--)
            {
                int number=a[i][start];
                printNumber(number);
            }
        }

    }
    private void printNumber(int number) {
        System.out.print(number+",");
    }
    public static void main(String[] args) {
        int[][] a={
                {1,2,3,4},
                {5,6,7,8},
                {9,10,11,12},
                {13,14,15,16}
        };
        Test20 t=new Test20();
        t.PrintMatrixClockwisely(a);
    }
}