剑指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面试题 java解答1-5

面试题1:赋值运算符函数 Java中不能重载运算符(C++可以) String 类的“+”是通过StringBuidler的append追加实现的。 可以重写自定...
  • frasker
  • frasker
  • 2016年08月22日 16:19
  • 510

剑指Offer面试题9(java版)斐波那契数列

题目一:写一个函数,输入n,求斐波那契数列的第n项。斐波那契数列的定义如下: 1、效率很低效的解法,挑剔的面试官不会喜欢 很多C语言的教科书在讲述递归函数的时候,都户拿Fibonacci作为例子,...
  • jsqfengbao
  • jsqfengbao
  • 2015年07月29日 08:47
  • 1654

剑指offer题目及答案

剑指offer最近在牛客网上刷剑指offer的题目,现将题目和答案总结如下
  • panda_AJ
  • panda_AJ
  • 2017年04月06日 19:07
  • 2801

剑指offer面试题28:字符串的排列 Java实现

题目: 输入一个字符串,打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab,cba. 算法分析: 我们求...
  • gg543012991
  • gg543012991
  • 2016年09月14日 19:42
  • 622

剑指Offer,面试题4,替换空格,Java写法

题目:请实现一个函数,将一个字符串中的空格替换成“%20”。例如,当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。思路就是如果从左到右去插入的话,时间复杂...
  • u012162920
  • u012162920
  • 2016年08月15日 17:21
  • 251

剑指offer面试题46 求1+2+3…+n(java实现)

解题思路: 利用逻辑与的短路特性实现递归终止 public class Solution { public int Sum_Solution(int n) { int sum ...
  • u013398759
  • u013398759
  • 2017年07月14日 19:23
  • 212

剑指Offer 面试题19:正则表达式匹配 Java代码实现

题目:正则表达式匹配 请实现一个函数用来匹配包含'.'和'*'的正则表达式。字符'.'表示任意一个字符,而'*'表示它前面的字符可以出现任意次(包含0次) 主要思想就是字符的第...
  • hh_zheng
  • hh_zheng
  • 2017年11月20日 19:58
  • 85

剑指offer-面试题2 实现单例模式

我也不知道面试题1去哪儿了。。面试题2.实现单例模式1. 单例模式的定义  单例模式是一种常用的软件设计模式。通过单例模式可以保证系统中只有类的实例的唯一性。单例模式最初的定义出现于《设计模式》(艾迪...
  • pomony1
  • pomony1
  • 2017年03月20日 14:26
  • 581

【剑指Offer学习】【所有面试题汇总】

剑指Offer学习  剑指Offer这本书已经学习完了,从中也学习到了不少的东西,现在做一个总的目录,供自已和大家一起参考,学如逆水行舟,不进则退。只有不断地学习才能跟上时候,跟得上技术的潮流!目录第...
  • DERRANTCM
  • DERRANTCM
  • 2015年07月15日 07:26
  • 19862

剑指offer--面试题16:翻转链表--Java实现

题目描述: 定义一个函数,输入一个链表的头结点,反转该链表并输出反转后链表的头结点。解题思路: 为了反转列表,其实就是为了改变next指针,由指向后一个变为指向前一个。 这里为了避免链表断裂,要...
  • u012289407
  • u012289407
  • 2015年06月15日 21:36
  • 1059
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:剑指offer面试题 java解答61-65
举报原因:
原因补充:

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