剑指offer面试题 java解答61-65

原创 2016年08月31日 15:46:40

面试题61:按之字形顺序打印二叉树

import java.util.Stack;
public class Test61<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);
    }
    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 Print(Node root) {
        if (root==null) {
            return;
        }
        Stack<Node>[] levels=new Stack[2];
        levels[0]=new Stack<Node>();
        levels[1]=new Stack<Node>();
        int current=0;
        int next=1;
        levels[current].add(root);
        while (!levels[0].empty()||!levels[1].empty()) {
            Node pNode=levels[current].pop();
            System.out.print(pNode.value+" ");
            if (current==0) {
                if (pNode.lChild!=null) {
                    levels[next].push(pNode.lChild);
                }
                if (pNode.rChild!=null) {
                    levels[next].push(pNode.rChild);
                }
            }else {
                if (pNode.rChild!=null) {
                    levels[next].push(pNode.rChild);
                }
                if (pNode.lChild!=null) {
                    levels[next].push(pNode.lChild);
                }
            }
            if (levels[current].empty()) {
                System.out.println();
                current=1-current;
                next=1-next;
            }
        }
    }
    public static void main(String[] args) {
        Object[] a = { 1,2,4,8,null,null,9,null,null,5,10,null,null,11,null,null,3,6,12,null,null,13,null,null,7,14,null,null,15,null,null};
        Test61 t = new Test61();
        t.creatBiTree(a);
        t.Print(t.root);
    }
}

面试题62:序列化二叉树

public class Test62{
    private class Node {
        public char value;
        public Node lChild;
        public Node rChild;
        public Node(char value) {
            this.value = value;
        }
    }
    public Node root = null;
    private int pos = 0;

    public void creatBiTree(char[] value) {
        pos = 0;
        root = creatBiTree(root, value);
    }
    private Node creatBiTree(Node node, char[] value) {
        char t = value[pos];
        pos++;
        if (t == '$') {
            return null;
        } else {
            node = new Node(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.print(""+node.value);
                preOrderTraverse(node.lChild);
                preOrderTraverse(node.rChild);
            }
          }
    public static void main(String[] args) {
        char[] a = {'1','2','4','$','$','$','3','5','$','$','6','$','$',};
        Test62 t = new Test62();
        t.creatBiTree(a);
        t.preOrderTraverse(t.root);
    }
}

面试题63:二叉搜索树的第K个结点

public class Test63 {
    private class Node {
        public char value;
        public Node lChild;
        public Node rChild;
        public Node(char value) {
            this.value = value;
        }
    }
    public Node root = null;
    private int pos = 0;

    public void creatBiTree(char[] value) {
        pos = 0;
        root = creatBiTree(root, value);
    }
    private Node creatBiTree(Node node, char[] value) {
        char t = value[pos];
        pos++;
        if (t == '$') {
            return null;
        } else {
            node = new Node(t);
            node.lChild = creatBiTree(node.lChild, value);
            node.rChild = creatBiTree(node.rChild, value);
        }
        return node;
    }
    public Node KthNode(Node pRoot,int k){
        if (pRoot==null||k<=0) {
            return null;
        }
        //数组本身是一个对象,如果传递的是数组的引用,则对数组元素的后续修改可以在原始数组中反映出来
        //而传递基本类型int则不可以 只是传值引用
        int[] kth = {k};
        return KthNodeCore(pRoot,kth);
    }
      private Node KthNodeCore(Node pRoot, int[] k) {
        Node target=null;
        if (pRoot.lChild!=null) {
            target=KthNodeCore(pRoot.lChild, k);
        }
        if (target==null) {
            if (k[0]==1) {
                target=pRoot;
            }
            k[0]--;
        }
        if (target==null&&pRoot.rChild!=null) {
            target=KthNodeCore(pRoot.rChild, k);
        }
        return target;
    }
    public void preOrderTraverse(Node node){
            if (node!=null) {
                System.out.print(""+node.value);
                preOrderTraverse(node.lChild);
                preOrderTraverse(node.rChild);
            }
          }
    public static void main(String[] args) {
        char[] a = {'5','3','2','$','$','4','$','$','7','6','$','$','8','$','$',};
        Test63 t = new Test63();
        t.creatBiTree(a);
        System.out.println(t.KthNode(t.root,3));
    }
}

面试题64:数据流中的中位数

import java.util.Scanner;
public class Test64 {
    class MaxHeap{
        int size=0; 
        double maxNum;
        double[] a=null;
        private int leftChild(int i)
        {
            return 2*i+1;
        }
        public void percolateDownSortByMax(double[] a,int i,int n)
        {
            int child;
            double tmp;
            for (tmp=a[i];leftChild(i)<n;i=child) 
            {
                child=leftChild(i);
                if (child<n-1&&a[child]<a[child+1])
                {
                    child++;
                }
                if (tmp<a[child]) 
                {
                    a[i]=a[child];
                }else {
                    break;
                }
            }
            a[i]=tmp;
        }
        public double MaxHeapTop(double[] a)
        {
            for (int i = a.length/2-1; i >=0; i--) 
            {
                percolateDownSortByMax(a, i, a.length);
            }
            return a[0];
        }
        void pop_max(){
            size--;
            double[] tmp=new double[size];
            for (int i = 0; i < tmp.length; i++) {
                tmp[i]=a[i+1];
            }
            a=tmp;
            maxNum=MaxHeapTop(a);
        }
        void push_back(double num){
            size++;
            double[] tmp=new double[size];
            if (a==null) {
                tmp[0]=num;
                a=tmp;
            }else {
                for (int i = 0; i < a.length; i++) {
                    tmp[i]=a[i];
                }
                tmp[a.length]=num;
                a=tmp;
            }
            maxNum=MaxHeapTop(a);
        }
        double max(){
            return maxNum;
        }
        int size(){
            return size;
        }
    }
    class MinHeap{
        int size=0; 
        double minNum;
        double[] a=null;
        private int leftChild(int i)
        {
            return 2*i+1;
        }
        public void percolateDownSortByMin(double[] a,int i,int n)
        {
            int child;
            double tmp;
            for (tmp=a[i];leftChild(i)<n;i=child) 
            {
                child=leftChild(i);
                if (child<n-1&&a[child]>a[child+1])
                {
                    child++;
                }
                if (tmp>a[child])
                {
                    a[i]=a[child];
                }else {
                    break;
                }
            }
            a[i]=tmp;
        }

        public double MinHeapTop(double[] a)
        {
            for (int i = a.length/2-1; i >=0; i--) 
            {
                percolateDownSortByMin(a, i, a.length);
            }
            return a[0];
        }
        void pop_min(){
            size--;
            double[] tmp=new double[size];
            for (int i = 0; i < tmp.length; i++) {
                tmp[i]=a[i+1];
            }
            a=tmp;
            minNum=MinHeapTop(a);
        }
        void push_back(double num){
            size++;
            double[] tmp=new double[size];
            if (a==null) {
                tmp[0]=num;
                a=tmp;
            }else {
                for (int i = 0; i < a.length; i++) {
                    tmp[i]=a[i];
                }
                tmp[a.length]=num;
                a=tmp;
            }
            minNum=MinHeapTop(a);
        }
        double min(){
            return minNum;
        }
        int size(){
            return size;
        }
    }
    MaxHeap max=new MaxHeap();
    MinHeap min=new MinHeap();  
    public void Insert(double num){
        if (((min.size()+max.size())&1)==0) {
            if (max.size()>0&&num<max.max()) {
                max.push_back(num);
                num=max.max();
                max.pop_max();
            }
            min.push_back(num);
        }else {
            if (min.size()>0&&num>min.min()) {
                min.push_back(num);         
                num=min.min();
                min.pop_min();
            }
            max.push_back(num);
        }
    }
    public double GetMedian() throws Exception{
        int size=max.size()+min.size();
        if (size==0) {
            throw new Exception("No numbers are available");
        }
        double median;
        if ((size&1)==1) {
            median=min.min();
        }else {
            median=(max.max()+min.min())/(double)2;
        }
        return median;
    }
    public static void main(String[] args) throws Exception {
        Test64 t=new Test64();
        Scanner s=new Scanner(System.in);
        while (s.hasNext()) {
            t.Insert(s.nextDouble());
            System.out.println(t.GetMedian());
        }       
    }
}

面试题65:滑动窗口的最大值

import java.util.LinkedList;
import java.util.Queue;
import java.util.Vector;
public class Test65 {
    public static Vector<Integer> maxInWindows(int[] num,int size){
        Vector<Integer> maxInWindows=new Vector<Integer>();
        if (num.length>=size&&size>=1) {
            LinkedList<Integer> index=new LinkedList<Integer>();
            for (int i = 0; i < size; i++) {
                while (!index.isEmpty()&&num[i]>=num[index.getLast()]) {
                    index.removeLast();
                }
                index.add(i);
            }
            for (int i = size; i < num.length; i++) {
                maxInWindows.add(num[index.getFirst()]);
                while (!index.isEmpty()&&num[i]>=num[index.getLast()]) {
                    index.removeLast();
                }
                while (!index.isEmpty()&&index.getFirst()<=(i-size)) {
                    index.removeFirst();
                }
                index.add(i);
            }
            maxInWindows.add(num[index.getFirst()]);
        }
        return maxInWindows;
    }
    public static void main(String[] args) {
        int[] a={2,3,4,2,6,2,5,1};
        Vector<Integer> vector=Test65.maxInWindows(a,3);
        for (int i = 0; i < vector.size(); i++) {
            System.out.println(vector.elementAt(i));
        }
    }
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

剑指Offer面试题61:按之子型打印二叉树 Java实现

题目:按之字型打印二叉树           请实现一个函数按照之字形顺序打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右到左的顺序打印,即第一行按照从左到右的顺序打印,第二层按照从右...

剑指offer面试题61 按之字形顺序打印二叉树(java实现)

解题思路: 利用两个栈stack1和stack2,stack1暂存奇数层的节点,stack2暂存偶数层的节点。当stack1中节点即奇数层节点出栈时,存入一个当前层次的arraylist中,与此同时...

剑指Offer面试题65:滑动窗口的最大值 Java实现

题目:给定一个数组和滑动窗口的大小,请找出所有滑动窗口里的最大值。如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3,那么一共存在6个滑动窗口,他们的最大值分别为{4.4,6,6,6,5...

【剑指Offer学习】【面试题61:按之字形顺序打印二叉树】

题目:请实现一个函数按照之字形顺序打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右到左的顺序打印,即第一行按照从左到右的顺序打印,第二层按照从右到左顺序打印,第三行再按照从左到右的顺序打印,...

【剑指offer】面试题61:扑克牌中的顺子

题目LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张^_^)… 他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买...

剑指offer 面试题61 按之字形顺序打印二叉树

剑指offer 面试题61 按之字形顺序打印二叉树题目: 请实现一个函数按照之字型顺序打印二叉树,即第一行按照从左到右的顺序打印, 第二层按照从右到左的顺序打印,第三行再按照从左到右的顺序打印,其他行...

剑指offer-面试题61-按之字形顺序打印二叉树

二叉树节点结构定义: package case62_PrintTreeInZigzag; /** * 定义二叉树节点结构 * * @author WangSai * */ public ...

【剑指Offer】面试题61:按之字形顺序打印二叉树

整理自剑指Offer 一:题目描述 请实现一个函数按照之字形打印二叉树,即第一行按照从左到右的顺序打印,第二层按照从右至左的顺序打印,第三行按照从左到右的顺序打印,其他行以此类推。 ...

【剑指Offer学习】【面试题65:滑动窗口的最大值】

题目:给定一个数组和滑动窗口的大小,请找出所有滑动窗口里的最大值。举例说明例如,如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小,那么一共存在6个滑动窗口,它们的最大值分别为{4,4,6...

剑指Offer系列-面试题65:滑动窗口的最大值

题目:给定一个数组和滑动窗口的大小,找出所有滑动窗口里数值的最大值。例如,如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3,那么一共存在6个滑动窗口,他们的最大值分别为{4,4,6,6...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:剑指offer面试题 java解答61-65
举报原因:
原因补充:

(最多只允许输入30个字)