剑指offer面试题 java解答26-30

面试题26:复杂链表的复制

import java.util.HashMap;
public class Test26{
    private class Node<T>{
        T valueT=null;
        Node next=null;
        Node sibling=null;
        public Node(T valueT) {
            this.valueT = valueT;
        }
    }
    private Node head=null;
    public Node getHeadNode(){
        return head;
    }
    public <T> Node insertTail(T value){
        Node nextNode=null;
        if (head==null) {
            head=new Node(value);
            return head;
        }else {
            nextNode=head;
            while (nextNode.next!=null) 
            {
                nextNode=nextNode.next;
            }
            nextNode.next=new Node(value);
            return nextNode.next;
        }
    }
    private Node ReconnectNodes(Node head) {
        Node nowNode=head;
        Node cloneNodeHead=null;
        Node cloneNode=null;
        if (head!=null) {
            cloneNodeHead=nowNode.next;
            cloneNode=cloneNodeHead;
            nowNode=cloneNodeHead.next;
            while (nowNode!=null) {
                cloneNode.next=nowNode.next;
                cloneNode=nowNode.next;
                nowNode=cloneNode.next;
            }
        }
        return cloneNodeHead;
    }
    private void ConnectSiblingNodes(Node head) {
        if (head!=null) {
            Node nowNode=head;
            while (nowNode!=null) {
                Node nowCloneNode=nowNode.next;
                if (nowNode.sibling!=null) {
                    nowCloneNode.sibling=nowNode.sibling.next;
                }
                nowNode=nowCloneNode.next;
            }
        }       
    }
    private void CloneNodes(Node head) {
        if (head!=null) {
            Node nowNode=head;
            while (nowNode.next!=null) {
                Node cloneNode=new Node(nowNode.valueT);
                Node nextNode=nowNode.next;
                nowNode.next=cloneNode;
                cloneNode.next=nextNode;
                nowNode=nextNode;
            }
            Node cloneNode=new Node(nowNode.valueT);
            nowNode.next=cloneNode;
        }
    }
    public Node Clone(Node head){
        CloneNodes(head);
        ConnectSiblingNodes(head);
        return ReconnectNodes(head);
    }
    public static void main(String[] args) {
        HashMap<Character, Object> map=new HashMap<Character, Object>();
        Object[] a={'A','B','C','D','E'};
        Test26 t=new Test26();
        for (int i = 0; i < a.length; i++) {
            Node node=t.insertTail(a[i]);
            map.put((Character) a[i], node);
        }
        ((Node)(map.get('A'))).sibling=((Node)(map.get('C')));
        ((Node)(map.get('B'))).sibling=((Node)(map.get('E')));
        ((Node)(map.get('D'))).sibling=((Node)(map.get('B')));
        Node cloneHead=t.Clone(t.getHeadNode());
        if (cloneHead!=null) 
        {
            while (cloneHead!=null) 
            {
                System.out.print(cloneHead.valueT);
                if (cloneHead.sibling!=null) 
                {
                    System.out.println(cloneHead.sibling.valueT);
                }else {
                    System.out.println();
                }
                cloneHead=cloneHead.next;
            }           
        }
    }
}

面试题27:二叉搜索树与双向链表

public class Test27{
    private class Node<T> {
        public T value;
        public Node<T> lChild;
        public Node<T> rChild;
        public Node(T value) {
            this.value = value;
        }
    }
    public Node root=null;
    private int pos = 0;
    public <T> void creatBiTree(T[] value){
        pos=0;
        root=creatBiTree(root, value);
    }
    // 以node为根节点，创建一棵树，返回此根节点
    private <T> Node 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 Node Convert(Node root){
        Node lastNode=null;
        Node tailNode=ConvertNode(root, lastNode);
        Node head=tailNode;
        while (head.lChild!=null) {
            head=head.lChild;
        }
        return head;
    }
    private Node ConvertNode(Node nowNode,Node lastNode){
        if (nowNode==null)
        {
            return null;
        }
        if (nowNode.lChild!=null)
        {
            lastNode=ConvertNode(nowNode.lChild, lastNode);
        }
        nowNode.lChild=lastNode;
        if (lastNode!=null)
        {
            lastNode.rChild=nowNode;
        }
        lastNode=nowNode;
        if (nowNode.rChild!=null) {
            lastNode=ConvertNode(nowNode.rChild, lastNode);
        }
        return lastNode;
    }
    public static void main(String[] args) {
        Object[] a = { 10, 6, 4, null, null, 8, null, null, 14, 12, null, null, 16, null, null };
        Test27 t = new Test27();
        t.creatBiTree(a);
        Node head=t.Convert(t.root);
        while (head!=null) {
            System.out.println(head.value);
            head=head.rChild;
        }
    }
}

面试题28:字符串的排列

public class Test28 {
    public void Permutation(String str){
        permutation(str, 0);
    }
    //第i个字符和后面的全排列交换
    private static void permutation(String s, int i) {  
        char[] str=s.toCharArray();
        if (i>s.length()) {
            return ;
        }else if (i==s.length()) {
            System.out.println(String.valueOf(str));
        }else {
            for (int j = i; j < str.length; j++) {
                char tmp=str[j];
                str[j]=str[i];
                str[i]=tmp;
                permutation(String.valueOf(str), i+1);
            }
        }
    }
    public static void main(String[] args) {
        Test28 t=new Test28();
        String str="abcd";
        t.Permutation(str);
    }
}

面试题29:数组中出现次数超过一半的数字

public class Test29 {
    public int MoreThanHalfNum(int[] numbers) throws Exception{
        if (numbers==null) {
            throw new Exception("invalid input");
        }
        int number=numbers[0];
        int times=1;
        for (int i = 1; i < numbers.length; i++) {
            if (numbers[i]!=number) {
                if (--times==0) {
                    number=numbers[i];
                    times=1;
                }
            }else {
                times++;
            }
        }
        int sum=0;
        for (int i = 0; i < numbers.length; i++) 
        {
            if (numbers[i]==number) 
            {
                sum++;
            }
        }
        if (sum>numbers.length/2) {
            return number;
        }else {
            throw new Exception("without");
        }       
    }
    public static void main(String[] args) throws Exception {
        int[] numbers={1,2,3,2,2,2,5,4,2};
        Test29 t=new Test29();
        int number=t.MoreThanHalfNum(numbers);
        System.out.println(number);
    }
}

面试题30:最小的K个数

public class Test30 {
    private static int leftChild(int i)
    {
        return 2*i+1;
    }
    //下滤实现大顶堆
    public static <T extends Comparable<? super T>> void percolateDownSort(T[] a,int i,int n)
    {
        int child;
        T tmp;
        for (tmp=a[i];leftChild(i)<n;i=child) 
        {
            child=leftChild(i);
            if (child<n-1&&a[child].compareTo(a[child+1])<0)
            {
                child++;
            }
            if (tmp.compareTo(a[child])<0) 
            {
                a[i]=a[child];
            }else {
                break;
            }
        }
        a[i]=tmp;
    }
    public static <T extends Comparable<? super T>> T returnMax(T[] a)
    {
        int length=a.length;
        percolateDownSort(a, 0, length);
        return a[0];
    }
    public Integer[] getLeastNumbers(int k,Integer[] a) throws Exception{
        if (a==null||k<0||k>a.length) {
            throw new Exception("invalid input");
        }
        Integer[] result=new Integer[k];
        System.arraycopy(a, 0, result, 0, k);
        if (a.length<k) 
        {
            return result;
        }else {
            for (int i = k; i < a.length; i++) 
            {
                Integer max=returnMax(result);
                if (max>a[i]) 
                {
                    result[0]=a[i];
                }
            }
        }
        return result;
    }
    public static void main(String[] args) throws Exception {
        Integer[] a={4,6,1,2,8,3,0,9,7,5};
        Test30 t=new Test30();
        Integer[] result=t.getLeastNumbers(4, a);
        for (int i = 0; i < result.length; i++) {
            System.out.println(result[i]);
        }
    }
}