下面是我面试问到题目的总结

题目

1.spark计算任务划分，宽窄依赖，小文件处理
2.partition过多如何处理
3.java为什么使用iterator
4.多线程和多进程
5.hive结构图
6.hbase结构图
7.zookeeper
8.垃圾回收算法（7个，8个）

1.机器学习偏差，方差
2.算法选取数据量
3.最近做了什么算法

1.spark shuffle节点丢失，如何恢复
2.共享内存，存在竞争，如何处理（乐观锁）
3.jvm动态替换掉加载好的类
4.推荐系统协同过滤相关（倒排，近似近邻查找）
5.L1,L2正则

1.L1，L2正则
2.逻辑回归与决策树的差异
3.什么是集成学习
4.map比较慢是为什么
5.spark任务有问题怎么定位
6.hadoop跑的比较慢的原因
7.hive原理
8.hbase原理，与hive的差异
9.hive存储格式

1.spark分区算子
2.java锁（静态锁，对象锁）
3.线程池相关
4.垃圾回收（root，七种垃圾回收算法）

1.acid（原子性，一致性，隔离性，持久性）
2.后序遍历二叉树
3.n个拍好序的数组全排（堆排）
4.两个拍好序的数组求交集（一个循环，一个二分查找）

1.spark sql ，rdd df的差异
2.hbase为什么比mysql写的快
3.rowkey如何设计

1.kafka原理特性
2.多线程，锁
3.dubbo框架原理
4.抽奖系统设计
5.spark任务优化

1.tf-idf为什么取log
2.lr可以用来做什么
3.决策树和lr对比
4.java生产者和消费者

最大公共前缀

题目

Write a function to find the longest common prefix string amongst an array of strings.

If there is no common prefix, return an empty string “”.

解析重点

1.大概思路，先找出字符串数组，第一个和第二个字符串公共前缀，然后拿这个公共前缀和第三个字符串比较找出公共部分，依此类推

java代码

1
2
3
4
5
6
7
8
9
10
11
12

class Solution {
   public String longestCommonPrefix(String[] strs) {
        if(strs == null || strs.length == 0) return "";        
        String prefix = strs[0];        
            for(int i = 1; i < strs.length; i++) {
                while(strs[i].indexOf(prefix) != 0 && prefix.length() > 0) {
                    prefix = prefix.substring(0, prefix.length() - 1);
                }                
            }
        return prefix;
    }
}

两个链表的交集

题目

Write a program to find the node at which the intersection of two singly linked lists begins.

For example, the following two linked lists:

A: a1 → a2
↘
c1 → c2 → c3
↗
B: b1 → b2 → b3

begin to intersect at node c1.

Notes:

If the two linked lists have no intersection at all, return null.
The linked lists must retain their original structure after the function returns.
You may assume there are no cycles anywhere in the entire linked structure.
Your code should preferably run in O(n) time and use only O(1) memory.

解析重点

1.我们注意到两个链表如果有交集，那么相交之后的的node都是相交的，因此，我们只需要找出相交的node即可
2.如果两个链表长度相同，我们只需要一起迭代即可，但是两个链表长度不同呢，怎么办？可以用A+B=B+A的形式，
即两个链表一起迭代，a迭代完后迭代b，同时b迭代完后a，第二轮就可以知道相交的点了。

java代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
   public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    //boundary check
    if(headA == null || headB == null) return null;
    
    ListNode a = headA;
    ListNode b = headB;
    
    //if a & b have different len, then we will stop the loop after second iteration
    while( a != b){
    	//for the end of first iteration, we just reset the pointer to the head of another linkedlist
        a = a == null? headB : a.next;
        b = b == null? headA : b.next;    
    }
    
    return a;
}
}

循环链表

题目

Given a linked list, determine if it has a cycle in it.

Follow up:
Can you solve it without using extra space?

解析重点

1.一开始只想到了hash table 的解决方案
2.后面参考官方，使用了双指针的方式，一个快指针，一个慢指针，如果是环形快指针一定可以追上慢指针

java代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/**
  * Definition for singly-linked list.
  * class ListNode {
  *     int val;
  *     ListNode next;
  *     ListNode(int x) {
  *         val = x;
  *         next = null;
  *     }
  * }
  */
public class Solution {
  public boolean hasCycle(ListNode head) {
    if (head == null || head.next == null) {
      return false;
    }
    ListNode slow = head;
    ListNode fast = head.next;
    while (slow != fast) {
      if (fast == null || fast.next == null) {
        return false;
      }
      slow = slow.next;
      fast = fast.next.next;
    }
    return true;
  }
}

有效的括号

题目

Given a string containing just the characters ‘(‘, ‘)’, ‘{‘, ‘}’, ‘[‘ and ‘]’, determine if the input string is valid.

An input string is valid if:

Open brackets must be closed by the same type of brackets.
Open brackets must be closed in the correct order.

Note that an empty string is also considered valid.

Example 1:

Input: “()”
Output: true

Example 2:

Input: “()[]{}”
Output: true

Example 3:

Input: “(]”
Output: false

Example 4:

Input: “([)]”
Output: false

Example 5:

Input: “{[]}”
Output: true

解析重点

1.这道题最重要是找出括号之间的规律，当有左括号的时候不用管，出现右括号的时候要检查左边是否有对应的括号，
有的话将其消除掉，不断重复这个过程。但是，这需要我们从内到外处理数据，我们可以借助栈来处理这种情况。
2.循环处理表达式的每个括号，当遇到左括号时，我们将其推入栈。
3.当遇到右括号时，弹出栈顶元素，看是否匹配，如果无法消除，则表达式无效，如果匹配，则消除这对数据。
4.如果最后站内任有元素，表达式无效。

java代码

具体java代码参考官方

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

class Solution {

  // Hash table that takes care of the mappings.
  private HashMap<Character, Character> mappings;

  // Initialize hash map with mappings. This simply makes the code easier to read.
  public Solution() {
    this.mappings = new HashMap<Character, Character>();
    this.mappings.put(')', '(');
    this.mappings.put('}', '{');
    this.mappings.put(']', '[');
  }

  public boolean isValid(String s) {

    // Initialize a stack to be used in the algorithm.
    Stack<Character> stack = new Stack<Character>();

    for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i);

      // If the current character is a closing bracket.
      if (this.mappings.containsKey(c)) {

        // Get the top element of the stack. If the stack is empty, set a dummy value of '#'
        char topElement = stack.empty() ? '#' : stack.pop();

        // If the mapping for this bracket doesn't match the stack's top element, return false.
        if (topElement != this.mappings.get(c)) {
          return false;
        }
      } else {
        // If it was an opening bracket, push to the stack.
        stack.push(c);
      }
    }

    // If the stack still contains elements, then it is an invalid expression.
    return stack.isEmpty();
  }
}

最大和的子序列

题目

Given an integer array nums, find the contiguous subarray (containing at least one number) which has the largest sum and return its sum.

Example:

Input: [-2,1,-3,4,-1,2,1,-5,4],
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.

Follow up:

If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, which is more subtle.

解析重点

1.子序列的和图像是类似股票图的，有波峰波谷
2.那我们需要记录最高点（max），及当前值（sum），当前值小于0的时候，我们需要重新开始计算sum

scala代码

1
2
3
4
5
6
7
8
9
10
11

object Solution {
  def maxSubArray(nums: Array[Int]): Int = {
    var sum = Integer.MIN_VALUE
    var max = sum
    for(num <- nums){
      sum = if (sum<0) num else sum+num//计算当前和值，当sum小于0时重新计算
      max=Math.max(max,sum)//计算全局最大值
    }
    max
  }
}

下面是windows10专业版docker安装tensorflow流程

搭建步骤

1.windows10上docker安装
2.设置docker镜像代理
3.docker安装tensorflow
4.测试tensorflow
5.安装总结

1.windows10上安装docker

略略略

docker安装完后可以使用以下命令测试

1

$ docker run hello-world

命令正常运行得到想要的结果即安装正常

5.搭建问题总结

1.windows10安装docker最好升级到专业版，激活可以去淘宝买激活码
2.docker最好设置镜像代理，否则会很慢

下面是我搭建博客的一些总结

搭建步骤

1.安装git
2.设置git免密登陆
3.安装node.js
4.安装hexo
5.关联git和hexo
6.测试关联结果
7.搭建问题总结

1.git安装、测试

git安装完后可以使用以下命令测试

1

$ git --version

7.搭建问题总结

1.node.js安装后先执行npm install -g cnpm –registry=https://registry.npm.taobao.org ，安装阿里的镜像，以后都使用cnpm代替npm安装模块
2.hexo关联git的时候，配置_config.yml文件冒号后面记得留空格，否则会关联失败，并且不报错，很难找到问题

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1

$ hexo new "My New Post"

More info: Writing

Run server

1

$ hexo server

More info: Server

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment