4/26腾讯笔试复盘

1、完成队列的PUSH，POP，TOP，SIZE，CLEAR操作。只有POP，TOP，SIZE有输出操作，其中POP只有在没有元素时输出-1，其他情况不输出；TOP在没有元素时输出-1

    输入： 2                    次数n
               4                    每次m个操作，且每次队列置空
               PUSH 1          第i次操作
               PUSH 2
               PUSH 3
               TOP
               5
               SIZE
               PUSH 2
               TOP
               POP
               TOP
    输出： 1
               0
               2
              -1

import java.util.*;

public class Main{

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = Integer.parseInt(sc.nextLine());
        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            int m = Integer.parseInt(sc.nextLine());
            queue.clear();
            for (int j = 0; j < m; j++) {
                String[] ss = sc.nextLine().split(" ");
                if(ss[0].equals("POP")){
                    if(queue.isEmpty()){
                        System.out.println(-1);
                    }
                }
                else if(ss[0].equals("TOP")){
                    System.out.println(queue.isEmpty()?-1:queue.peek());
                }
                else if(ss[0].equals("SIZE")){
                    System.out.println(queue.size());
                }
                else if(ss[0].equals("PUSH")){
                    queue.offer(Integer.valueOf(ss[1]));
                }
                else if(ss[0].equals("CLEAR")){
                    queue.clear();
                }
            }
        }
    }
}

 

2、寻找两个点集中最近的对

    经典的分治算求平面中的最近点对的变形，唯一的区别是需要记录点是属于哪个阵营中。
    先将平面中的点按x坐标值排序，找到中间点mid，递归的在左右两侧找距离最小的点对距离min，再按照y坐标值排序，在中间点mid左右不超过min的点，对于每个点只需与它之后的六个点进行比较，找到中间区域的最小值tempmin，与min相比较得到min的最终值
    时间复杂度为O(nlogn)，空间复杂度O(n)

import java.util.*;

public class Main{
    static class Node{
        double x,y;
        int f;
    }
    public static double cal(Node x,Node y){
        if(x.f == y.f){
            return Double.MAX_VALUE;
        }
        return Math.sqrt((x.x-y.x)*(x.x-y.x)+(x.y-y.y)*(x.y-y.y));
    }
    public static double mergeSort(Node[] nodes,int left,int right){
        double min = Double.MAX_VALUE;
        if(right-left <= 0){
            return min;
        }
        if(right-left == 1){
            return cal(nodes[left],nodes[right]);
        }
        int mid = left+(right-left)/2;
        double mina = mergeSort(nodes,left,mid);
        double minb = mergeSort(nodes,mid+1,right);
        min = mina > minb ? minb : mina;
        merge(nodes,left,mid,right);
        Node[] temps = new Node[right-left+1];
        int num = 0;
        for (int i = left; i <= right; i++) {
            if(Math.abs(nodes[i].x-nodes[mid].x) <= min){
                temps[num++] = nodes[i];
            }
        }
        double tempmin;
        for (int i = 0; i < num; i++) {
            for (int j = i+1; j < num && j < i+7; j++) {
                tempmin = cal(nodes[i],nodes[j]);
                if(tempmin < min){
                    min = tempmin;
                }
            }
        }
        return min;
    }
    public static void merge(Node[] nodes,int left,int mid,int right){
        Node[] temp = new Node[right-left+1];
        int j = left;
        int k = mid+1;
        int t = 0;
        while(j <= mid && k <= right){
            if(nodes[j].y < nodes[k].y){
                temp[t++] = nodes[j++];
            }
            else{
                temp[t++] = nodes[k++];
            }
        }
        while(j <= mid){
            temp[t++] = nodes[j++];
        }
        while(k <= right){
            temp[t++] = nodes[k++];
        }
        t = 0;
        while(left <= right){
            nodes[left++] = temp[t++];
        }
    }
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = Integer.parseInt(sc.nextLine());
        String[] ss = new String[2];
        for (int i = 0; i < n; i++) {
            int m = Integer.parseInt(sc.nextLine());
            Node[] nodes = new Node[2*m];
            for (int j = 0; j < m; j++) {
                ss = sc.nextLine().split(" ");
                Node node = new Node();
                node.x = Double.valueOf(ss[0]);
                node.y = Double.valueOf(ss[1]);
                node.f = 0;
                nodes[j] = node;
            }
            for (int j = m; j < 2*m; j++) {
                ss = sc.nextLine().split(" ");
                Node node = new Node();
                node.x = Double.valueOf(ss[0]);
                node.y = Double.valueOf(ss[1]);
                node.f = 1;
                nodes[j] = node;
            }
            Arrays.sort(nodes,(v1,v2)-> (int) (v1.x-v2.x));
            System.out.println(String.format("%.3f",mergeSort(nodes,0,2*m-1)));
        }
    }
}

 

4、两个栈实现队列

（1）用两个栈模拟队列，一个栈模拟入队列，一个栈模拟出队列；push()的时间复杂度为O(1)，pop()的摊分时间复杂度为O(1)，这是最巧妙的一种方法
（2）若存在不合法情况比如队列为空时进行pop()、peek()操作时，要进行判空；定义一个全局变量size，只有size != 0时，才进行pop()、peek（）操作
（3）peek()操作的巧妙方法在于，在push()时，记录front值；如果stack2不为空，就return stack2.pop()，否则的话return front
（4）四个操作的时间复杂度都为O(1)

import java.util.*;

public class Main{
    Stack<Integer> stack1;
    Stack<Integer> stack2;
    int size = 0;
    int front = 0;

    public Main() {
        stack1 = new Stack<>();
        stack2 = new Stack<>();
    }

    public void push(int x) {
        if(stack1.empty()){
            front = x;
        }
        stack1.push(x);
        size++;
    }

    public int pop() {
        if(size == 0){
            return -1;
        }
        if(stack2.empty()){
            while(!stack1.empty()){
                stack2.push(stack1.pop());
            }
        }
        size--;
        return stack2.pop();
    }

    public int peek() {
        if(!stack2.empty()){
            return stack2.peek();
        }
        return front;
    }

    public boolean empty() {
        return size==0?true:false;
    }
}

5、一棵无限深的的满二叉树，求x的k层祖先

  输入 ： 4              次数n
             10 1          结点值  层数i
             10 2
             10 3
             10 4
  输出： 1               第i层祖先
             2
             5
            -1
（1）具有n个结点的完全二叉树，树的高度为log(n)+1，其中log(n)为向下取整；Java中向上取整的API是Math.ceil(double a)，向下取整的API是Math.floor(double a)，此题可直接用Math.getExponent()+1获得树的高度，因为Math.getExponent()是无偏指数且向下取整
（2）x的k层祖先可由x/2获得，循环的次数为x所在层数减去k

import java.util.*;

public class Main{

    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n = Integer.parseInt(sc.nextLine());
        for (int j = 0; j < n; j++) {
            String[] ss = sc.nextLine().split(" ");
            int p = Integer.valueOf(ss[0]);
            int q = Integer.valueOf(ss[1]);
            if((Math.getExponent(p)+1) > q){
                int sum = Math.getExponent(p)+1-q;
                while(sum > 0){
                    p = p/2;
                    sum--;
                }
                System.out.println(p);
            }
            else{
                System.out.println(-1);
            }
        }
    }
}