剑指Offer——好未来视频面知识点储备+面后总结

情景介绍

时间:2016.10.12 13：00-
地点:宿舍
事件:好未来视频面

知识点储备

数据结构

单链表反转

public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
    private static ListNode ReverseList(ListNode head) {
        if (head == null)
            return null;
        ListNode reversedHead = null;
        ListNode current = head;
        ListNode pNext = null;
        ListNode pre = null;
        while (current != null) {
            pNext = current.next;
            current.next = pre;
            if (pNext == null)          // 确定反转后的头结点
                reversedHead = current;
            pre = current;
            current = pNext;
        }
        return reversedHead;
    }

合并两个排序的链表

    /**
     *
     * @param ListNode
     *              链表1
     * @param ListNode
     *              链表2
     * @return ListNode
     *              合并后的链表
     */
    private static ListNode Merge(ListNode list1,ListNode list2) {

        // 其中之一为空或均为空
        if(list1 == null || list2 == null){
            return list1 == null?(list2 == null?list1:list2):list1;
        }else{
            ListNode headNode = null;
            if(list1.val < list2.val){
                headNode = list1;
                headNode.next = Merge(list1.next, list2);
            }else{
                headNode = list2;
                headNode.next = Merge(list1, list2.next);
            }
            return headNode;
        }
    }

求两个链表的第一个公共节点问题

private static ListNode FindFirstCommonNode2(ListNode pHead1, ListNode pHead2) {
        // 第一步首先是特殊输入测试，即为空或长度为0的情况，切记！
        if(pHead1 == null || pHead2 == null){
            return null;
        }
        int len1 = getLength(pHead1);
        int len2 = getLength(pHead2);
        int difLen = 0;
        // pHeadTmp1指向较长链表
        ListNode pHeadLong = pHead1;
        // pHeadTmp2指向较短链表
        ListNode pHeadShort = pHead2;
        if(len1 > len2){
            difLen = len1 - len2;
        }else{
            pHeadLong = pHead2;
            pHeadShort = pHead1;
            difLen = len2 - len1;
        }
        // 1.先让长的链表走difLen步
        for(int i = 0; i < difLen; i++){
            pHeadLong = pHeadLong.next;
        }
        // 2.对齐后，两个链表同时走
        while(pHeadLong != null && pHeadShort != null && pHeadLong != pHeadShort){
            pHeadLong = pHeadLong.next;
            pHeadShort = pHeadShort.next;
        }
        return pHeadLong;
    }

    private static int getLength(ListNode pHead){
        int len = 0;
        while(pHead != null){
            len++;
            pHead = pHead.next;
        }
        return len;
    }

多线程

实现生产者、消费者

package cn.edu.ujn.producer_customer;

// 公共资源类
class PublicResource {

    private static final int MAX_RESOURCE_NUMBER = 10;
    private int number = 0;    

    /**
     * 增加公共资源
     */
    public synchronized void increace() {
        while (number > MAX_RESOURCE_NUMBER) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 添加资源
        number++;
        System.out.println(number);
        // 进行通知
        notify();
    }    

    /**
     * 减少公共资源
     */
    public synchronized void decreace() {
        while (number == 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number--;
        System.out.println(number);
        notify();
    }
}

// 生产者线程，负责生产公共资源
class ProducerThread implements Runnable {
    private PublicResource resource;    

    public ProducerThread(PublicResource resource) {
        this.resource = resource;
    }    

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep((long) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.increace();
        }
    }
}    

// 消费者线程，负责消费公共资源
class ConsumerThread implements Runnable {
    private PublicResource resource;    

    public ConsumerThread(PublicResource resource) {
        this.resource = resource;
    }    

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep((long) (Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.decreace();
        }
    }
}    

public class ProducerConsumerTest {
    public static void main(String[] args) {
        PublicResource resource = new PublicResource();
        new Thread(new ProducerThread(resource)).start();
        new Thread(new ConsumerThread(resource)).start();
        new Thread(new ProducerThread(resource)).start();
        new Thread(new ConsumerThread(resource)).start();
        new Thread(new ProducerThread(resource)).start();
        new Thread(new ConsumerThread(resource)).start();
    }
}

多线程发短信

设计模式

排序

查找

存储

算法

克鲁斯卡尔算法

J2EE

面后总结

1.数据库索引(聚集索引、组合、主键、普通、唯一)
2.select * from db_name where name=’demo’order by age group by age;执行顺序。
3.提高数据库查询效率的措施。
4.基本数据类型 int、long、short、float、double、char、boolean、byte
5.float与double的区别:精度不同。
6.冒泡排序、快速排序；

数据库这一块自己是完败！自己只是用了mysql，但是对于里面的概念自己真的表示无能为力！其中数据库索引这一块，其实在项目开发中，自己也没有使用到。惭愧无比！但是简历中明明写了熟悉SQL语句、存储过程和函数(从第二道问题中就完全推翻了自己。)。不能使之成为自己的鸡肋！

Mysql语法顺序，即当sql中存在下面的关键字时，它们要保持这样的顺序：

select[distinct]、from、join（如left join）、on、where、group by、having、union、order by、limit

Mysql执行顺序，即在执行时sql按照下面的顺序进行执行：

from、on、join、where、group by、having、select、distinct、 union、order by

group by要和聚合函数一起使用，例如:

select a.Customer,sum(a.OrderPrice) from orders a where a.Customer=’Bush’ or a.Customer = ‘Adams’ group by a.Customer
数据库+Java是自己找工作的双翼。

通过面试，还可以发现的问题就是自己的简历中项目过少，导致面试官关于项目的面试中，所问的问题不会太多(这是面试官反映的)。但是，自己感觉也只有“立马送药”这个项目可以拿得出手，其他的项目只可说是练习项目，例如“鲜花礼品网”、“CTCs监测系统”、“竞彩APP”。

另外，如果视频面的话，最好戴耳麦，否则会很尴尬的。自己当时就没有戴耳麦，结果说话时音调稍不均匀，就会带来很大的噪声与回音，严重影响了面试质量。第一次视频面，姑且作为教训。

最后可以问面试官问题，最恰当的问题莫过于“请评价一下我此次的视频面，还欠缺哪方面的知识储备，面试结果何时可以给出”。

最后，自己给自己的面试评分为55。