关闭

程序员面试金典(一)

标签: 面试
415人阅读 评论(0) 收藏 举报
分类:

1.算法题的五种解法

方法一:举例法

举例法简单来讲就是数学中的归纳推理和演绎推理,根据特征找到通解,最常见的是在数列运算过程中,大家熟知的斐波那契数列,1+....+100,等等,都可以使用举例法解答。

方法二:模式匹配法

模式匹配法是指将现有问题与相似问题作类比,看看能否通过修改相关问题的解法来解决新问题。

方法三:简化推广法

采用简化推广法,具体做法对于问题可以分步进行处理。首先,我们会修改某个约束条件,比如数据类型或数据量,从而简化这个问题。接着,转而处理这个问题的简化版本。最后,一旦找到解决简化版问题的算法,我们就可以基于这个问题进行推广,并调整最终的解决方案,找到最优解。

方法四:简单构造法

对于某些问题,简单构造法非常高效。使用简单构造法,我们会从最基本的情况(比如n=1)来解决问题,还是拿斐波那契数列来举例子,最后可以发现,这是一个递归方法可以解决的问题。所以,简单构造法最后往往会演变成递归法。

方法五:数据结构头脑风暴法

数据结构头脑风暴法过程往往会相对来说较复杂。运用数据结构中的链表,数组,二叉树,堆来解决问题,根据具体情况选择最优解。

2.数组与字符串

2.1散列表

散列表是一种将键(key)映射为值(value)从而实现快速查找的数据结构。散列表包含一个底层数组和一个散列函数(hash function)。插入一个对象及对应的键时,散列函数会将键映射为数组的一个索引。这个对象就回储存到数组中该索引的位置。

public HashMap<Integer, Student> buildMap(Student[] students){
        HashMap<Integer, Student> map = new HashMap<>();
        for (student s : students) {
            map.put(s.getId(),s);
        }
        return map;
    }

2.2 ArrayList(动态数组)

ArrayList,即动态数组,是一种按需调整大小的数组,数据访问时间为O(1)。一种典型的实现是在数组存满时扩容,每次扩容时O(n),均摊下来还是O(1)。

public ArrayList<String> merges(String[] words,String[] more){
        ArrayList<String> sentence = new ArrayList<>();
        for (String w : words) {
            sentence.add(w);
        }
        for (String m : more) {
            sentence.add(m);
        }
        return sentence;
}

2.3 StringBuffer

在Java编程中把一组字符串拼接起来,可以使用String str = "hello" + "字符";但是这样操作相当于每次都创建一个string对象的字符串,运行效率低下而且还特别占用内存,为了简化这种状况可以使用StringBuffer

public String mergeStr(String[] string){
        StringBuffer sb = new StringBuffer();
        for (String str : string) {
            sb.append(str);
        }
        return sb.toString();
}

3.链表

链表问题往往涉及递归操作,非常依赖概念。

3.1创建链表

以下代码为创建一个基本的单向链表。

class Node{
    Node next = null;
    int data;

    public Node(int d){
        data = d;
    }
    void appendToTail(int d){
        Node end = new Node(d);
        Node n = this;
        while(n.next != null){
            n = n.next;
        }
        n.next = end;
    }
}

3.2删除单向链表中的节点

删除单向链表,给定一个节点n,我们先找到它的前趋节点prev,并将prev.next设置为n.next。如果是双向链表,还要更新n.next,将n.next.prev置为n.prev.

  • 注意:(1)检查空指针;(2)必要时更新表头(head)或表尾(tail)指针。
    Node deleteNode(Node head,int d){
        Node n = head;
        if (n.data == d) {
            return head.next;//表头指向下一个节点
        }
        while(n.next ! = null){
            if (n.next.data == d) {
                n.next = n.next.next;
                return head; //表头不变
            }
            n = n.next;
        }
        return head;
    }

3.3“快行指针”技巧

在处理链表问题时,“快行指针”(runner,或者称为第二个指针)是一种很常见的技巧,“快行指针”指的是同时用两个指针来迭代访问链表,只不过其中一个比另一个超前一些。“快”指针往往先行几步,或与“慢”指针相差固定的步数。

3.4递归问题

许多链表问题都要用到递归。当然,还需注意递归算法至少要占用O(n)空间,其中n为递归调用层数。

4.栈和队列

4.1实现一个栈

栈采用后进先出(LIFO)顺序。实际上,栈和链表本质上是一样的,用户只能看到栈顶元素。

class Stacks{
    Node top;
    Object pop(){
        if (top != null) {
            Object item = top.data;
            top = top.next;
            return item;
        }
        return null;
    }
    void push(Object item){
        Node t = new Node(item);
        t.next = top;
        top = t;
    }
    Object peek(){
        return top.data;
    }
}

以下是一个具体栈的实例:

public class Stacks {
    static String[] months = {"Jan","Feb","Mar","Apr","May",
            "June","Aug","Sep","Oct","Nov","Dec"};

    public static void main(String[] args) {
        Stack stack = new Stack();
        //进栈,先进元素压入栈底,最后的元素在栈顶
        for (int i = 0; i < months.length; i++) {
            stack.push(months[i]+"");
        }
        System.out.println("stk = " + stack);

        stack.addElement("************");
        System.out.println("element 5 = " + stack.elementAt(5));
        System.out.println("popping elements: ");
        //出栈后进先出,栈顶元素最先被输出
        while (!stack.empty()) {
            System.out.println(stack.pop());
        }
    }
}

4.2实现一个队列

队列采用先进先出(FIFO)顺序。队列也可以用链表实现,新增元素追加至表尾。

class Queue{
    Node first,last;
    void enqueue(Object item){
        if (first == null) {
            last = new Node(item);
            first = last;
        }else{
            last.next = new Node(item);
            last = last.next;
        }
    }
    Object dequeue(){
        if (first != null) {
            Object item = first.data;
            first = first.next;
            return item;
        }
    }
}

5.树和图

5.1需要注意的潜在问题

  • 二叉树与二叉查找树
    二叉查找树一般会有附加条件:对于任意节点,左子节点小于或等于当前节点,后者又小于所有右子节点。
  • 平衡与不平衡
    树的平衡有多重方法,平衡一棵树只意味着子树的深度差不会超过一定值,并不表示左子树和右子树的深度完全相同。
  • 完满和完整(Full and Complete)
    完满和完整树的所有叶节点都在树的底部,所有非叶节点都有两个子节点。完满和完整树必须满足2n1个节点。

5.2二叉树遍历

二叉树遍历一般分为中序、后序和前序遍历。

5.3树的平衡:红黑树和平衡二叉树

5.4单词查找树(trie)

trie树是n层树的一种变体,其中每个节点存储有字符。整棵树的每条路径自上而下表示一个单词。

5.5图的遍历

  • 深度优先搜索(DFS)
    在DFS中,先访问节点r,然后循环访问r的每个相邻节点。在访问r的相邻节点n时,会在访问r的其他相邻节点之前先访问n的所有相邻节点。前序和树遍历的其他形式都是一种DFS,区别是对图实现该算法时,必须先检查该节点是否已访问。否则,可能会死循环。
    实现DFS伪代码:
void search(Node root){
    if(root == null) return;
    visit(root);
    root.visited = true;
    foreach(Node n in root.adjacent){
        if(n.visited == false) search(n);
    }
}
  • 广度优先搜索(BFS)
    在搜索r的“孙子节点”之前先访问节点r的所有相邻节点。一般用队列实现的迭代方案最有效。
    实现BFS伪代码:
void search(Node root){
    Queue queue = new Queue();
    root.visited = true;
    visit(root);
    queue.enqueue(root);//加至队列尾部

    while(!queue.isEmpty()){
        Node r = queue.dequeue();//从队列头部移除
        foreach(Node n in r.adjacent){
            if(n.visited ==false){
            visit(n);
            n.visited = true;
            queue.enqueue(n);
            }
        }
    }
}
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:53913次
    • 积分:1006
    • 等级:
    • 排名:千里之外
    • 原创:46篇
    • 转载:8篇
    • 译文:0篇
    • 评论:4条
    最新评论