编程面试中排名前10的算法

以下是在编程面试中排名前10的算法相关的概念,我会通过一些简单的例子来阐述这些概念。由于完全掌握这些概念需要更多的努力,因此这份列表只是作为一个介绍。本文将从Java的角度看问题,包含下面的这些概念:

1. 字符串

如果IDE没有代码自动补全功能,所以你应该记住下面的这些方法。

toCharArray() // 获得字符串对应的char数组
Arrays.sort() // 数组排序
Arrays.toString(char[] a) // 数组转成字符串
charAt(int x) // 获得某个索引处的字符
length() // 字符串长度
length // 数组大小

2. 链表

在Java中,链表的实现非常简单,每个节点Node都有一个值val和指向下个节点的链接next。

class Node {
    int val;
    Node next;
    Node(int x) {
       val = x;
       next = null;
    }
}

链表两个著名的应用是栈Stack和队列Queue。

栈:

class Stack{
 
    Node top; 
 
    public Node peek(){//查看堆栈顶部的对象,但不从堆栈中移除它。
 
        if(top != null){
 
            return top;
 
        }
 
        return null;
 
    }
 
    public Node pop(){//移除堆栈顶部的对象,并作为此函数的值返回该对象。
 
        if(top == null){
 
            return null;
 
        }else{
 
            Node temp = new Node(top.val);
 
            top = top.next;
 
            return temp;
 
        }
 
    }
 
    public void push(Node n){//把项压入堆栈顶部。
 
        if(n != null){
 
            n.next = top;
 
            top = n;
 
        }
 
    }
 
}

队列:

class Queue{
 
    Node first, last;
 
    public void enqueue(Node n){
 
        if(first == null){
 
            first = n;
 
            last = first;
 
        }else{
 
            last.next = n;
 
            last = n;
 
        }
 
    }
 
    public Node dequeue(){
 
        if(first == null){
 
            return null;
 
        }else{
 
            Node temp = new Node(first.val);
 
            first = first.next;
 
            return temp;
 
        }
 
    }
 
}

3.

这里的树通常是指二叉树,每个节点都包含一个左孩子节点和右孩子节点,像下面这样:

class TreeNode{
 
    int value;
 
    TreeNode left;
 
    TreeNode right;
 
}

下面是与树相关的一些概念:

平衡 vs. 非平衡:平衡二叉树中,每个节点的左右子树的深度相差至多为1(1或0)。

满二叉树(Full Binary Tree):除叶子节点以为的每个节点都有两个孩子。

完美二叉树(Perfect Binary Tree):是具有下列性质的满二叉树:所有的叶子节点都有相同的深度或处在同一层次,且每个父节点都必须有两个孩子。

完全二叉树(Complete Binary Tree):二叉树中,可能除了最后一个,每一层都被完全填满,且所有节点都必须尽可能想左靠。

译者注:完美二叉树也隐约称为完全二叉树。完美二叉树的一个例子是一个人在给定深度的祖先图,因为每个人都一定有两个生父母。完全二叉树可以看成是可以有若干额外向左靠的叶子节点的完美二叉树。疑问:完美二叉树和满二叉树的区别?(参考:http://xlinux.nist.gov/dads/HTML/perfectBinaryTree.html)

4. 图

图相关的问题主要集中在深度优先搜索(depth first search)和广度优先搜索(breath first search)。

下面是一个简单的图广度优先搜索的实现。

1) 定义GraphNode

class GraphNode{ 
 
    int val;
 
    GraphNode next;
 
    GraphNode[] neighbors;
 
    boolean visited;
 
    GraphNode(int x) {
 
        val = x;
 
    }
 
    GraphNode(int x, GraphNode[] n){
 
        val = x;
 
        neighbors = n;
 
    }
 
    public String toString(){
 
        return "value: "+ this.val; 
 
    }
 
}

2) 定义一个队列Queue

class Queue{
 
    GraphNode first, last;
 
    public void enqueue(GraphNode n){
 
        if(first == null){
 
            first = n;
 
            last = first;
 
        }else{
 
            last.next = n;
 
            last = n;
 
        }
 
    }
 
    public GraphNode dequeue(){
 
        if(first == null){
 
            return null;
 
        }else{
 
            GraphNode temp = new GraphNode(first.val, first.neighbors);
 
            first = first.next;
 
            return temp;
 
        }
 
    }
 
}

3) 用队列Queue实现广度优先搜索

public class GraphTest {
 
  public static void main(String[] args) {
 
        GraphNode n1 = new GraphNode(1); 
 
        GraphNode n2 = new GraphNode(2); 
 
        GraphNode n3 = new GraphNode(3); 
 
        GraphNode n4 = new GraphNode(4); 
 
        GraphNode n5 = new GraphNode(5); 
 
        n1.neighbors = new GraphNode[]{n2,n3,n5};
 
        n2.neighbors = new GraphNode[]{n1,n4};
 
        n3.neighbors = new GraphNode[]{n1,n4,n5};
 
        n4.neighbors = new GraphNode[]{n2,n3,n5};
 
        n5.neighbors = new GraphNode[]{n1,n3,n4};
 
        breathFirstSearch(n1, 5);
 
    }
 
    public static void breathFirstSearch(GraphNode root, int x){
 
        if(root.val == x)
 
            System.out.println("find in root");
 
        Queue queue = new Queue();
 
        root.visited = true;
 
        queue.enqueue(root);
 
        while(queue.first != null){
 
            GraphNode c = (GraphNode) queue.dequeue();
 
            for(GraphNode n: c.neighbors){
 
                if(!n.visited){
 
                    System.out.print(n + " ");
 
                    n.visited = true;
 
                    if(n.val == x)
 
                        System.out.println("Find "+n);
 
                    queue.enqueue(n);
 
                }
 
            }
 
        }
 
    }
 
}

5. 排序

下面是不同排序算法的时间复杂度,你可以去wiki看一下这些算法的基本思想。

另外,这里有一些实现/演示:: Counting sortMergesortQuicksortInsertionSort

《视觉直观感受 7 种常用的排序算法》

《视频: 6分钟演示15种排序算法》

6. 递归 vs. 迭代

对程序员来说,递归应该是一个与生俱来的思想(a built-in thought),可以通过一个简单的例子来说明。

问题:有n步台阶,一次只能上1步或2步,共有多少种走法。

步骤1:找到走完前n步台阶和前n-1步台阶之间的关系。

为了走完n步台阶,只有两种方法:从n-1步台阶爬1步走到或从n-2步台阶处爬2步走到。如果f(n)是爬到第n步台阶的方法数,那么f(n) = f(n-1) + f(n-2)。

步骤2: 确保开始条件是正确的。

f(0) = 0;

f(1) = 1;

public static int f(int n){
 
    if(n <= 2) return n;
 
    int x = f(n-1) + f(n-2);
 
    return x;
 
}

递归方法的时间复杂度是n的指数级,因为有很多冗余的计算,如下:

f(5)

f(4) + f(3)

f(3) + f(2) + f(2) + f(1)

f(2) + f(1) + f(1) + f(0) + f(1) + f(0) + f(1)

f(1) + f(0) + f(1) + f(1) + f(0) + f(1) + f(0) + f(1)

直接的想法是将递归转换为迭代:

public static int f(int n) {
 
    if (n <= 2){
 
        return n;
 
    }
 
    int first = 1, second = 2;
 
    int third = 0;
 
    for (int i = 3; i <= n; i++) {
 
        third = first + second;
 
        first = second;
 
        second = third;
 
    }
 
    return third;
 
}

对这个例子而言,迭代花费的时间更少,你可能也想看看Recursion vs Iteration。

7. 动态规划

动态规划是解决下面这些性质类问题的技术:

①.一个问题可以通过更小子问题的解决方法来解决(译者注:即问题的最优解包含了其子问题的最优解,也就是最优子结构性质)。

②.有些子问题的解可能需要计算多次(译者注:也就是子问题重叠性质)。

③.子问题的解存储在一张表格里,这样每个子问题只用计算一次。

④.需要额外的空间以节省时间。

爬台阶问题完全符合上面的四条性质,因此可以用动态规划法来解决。

public static int[] A = new int[100];
 
public static int f3(int n) {
 
    if (n <= 2)
 
        A[n]= n;
 
    if(A[n] > 0)
 
        return A[n];
 
    else
 
        A[n] = f3(n-1) + f3(n-2);//store results so only calculate once!
 
    return A[n];
 
}

8. 位操作

位操作符:

获得给定数字n的第i位:(i从0计数并从右边开始)

public static boolean getBit(int num, int i){
 
    int result = num & (1<<i);
 
    if(result == 0){
 
        return false;
 
    }else{
 
        return true;
 
    }

例如,获得数字10的第2位:

i=1, n=10

1<<1= 10

1010&10=10

10 is not 0, so return true;

9. 概率问题

解决概率相关的问题通常需要很好的规划了解问题(formatting the problem),这里刚好有一个这类问题的简单例子:

一个房间里有50个人,那么至少有两个人生日相同的概率是多少?(忽略闰年的事实,也就是一年365天)

计算某些事情的概率很多时候都可以转换成先计算其相对面。在这个例子里,我们可以计算所有人生日都互不相同的概率,也就是:365/365 * 364/365 * 363/365 * … * (365-49)/365,这样至少两个人生日相同的概率就是1 – 这个值。

public static double caculateProbability(int n){
 
    double x = 1; 
 
    for(int i=0; i<n; i++){
 
        x *=  (365.0-i)/365.0;
 
    }
 
    double pro = Math.round((1-x) * 100);
 
    return pro/100;

calculateProbability(50) = 0.97

10. 排列组合

组合和排列的区别在于次序是否关键。

参考/推荐资料:

1. Binary tree

2. Introduction to Dynamic Programming

3. UTSA Dynamic Programming slides

4. Birthday paradox

5. Cracking the Coding Interview: 150 Programming Interview Questions and Solutions, Gayle Laakmann McDowell

文章源自: http://blog.jobbole.com/52144/

时间: 07-17

编程面试中排名前10的算法的相关文章

编程面试过程中常见的10大算法(转)

以下是在编程面试中排名前10的算法相关的概念,我会通过一些简单的例子来阐述这些概念.由于完全掌握这些概念需要更多的努力,因此这份列表只是作为一个介绍.本文将从Java的角度看问题,包含下面的这些概念: 1. 字符串 如果IDE没有代码自动补全功能,所以你应该记住下面的这些方法. toCharArray() // 获得字符串对应的char数组 Arrays.sort() // 数组排序 Arrays.toString(char[] a) // 数组转成字符串 charAt(int x) // 获得

数据结构笔记01:编程面试过程中常见的10大算法(java)

以下是在编程面试中排名前10的算法相关的概念,我会通过一些简单的例子来阐述这些概念.由于完全掌握这些概念需要更多的努力,因此这份列表只是作为一个介绍.本文将从Java的角度看问题,包含下面的这些概念: 1. 字符串 如果IDE没有代码自动补全功能,所以你应该记住下面的这些方法. toCharArray() // 获得字符串对应的char数组 Arrays.sort() // 数组排序 Arrays.toString(char[] a) // 数组转成字符串 charAt(int x) // 获得

如何在 Kaggle 首战中进入前 10%

转载一篇文章 如何在 Kaggle 首战中进入前 10% Posted on 2016-04-29   |   In Data Science  | Introduction 本文采用署名 - 非商业性使用 - 禁止演绎 3.0 中国大陆许可协议进行许可.著作权由章凌豪所有. Kaggle 是目前最大的 Data Scientist 聚集地.很多公司会拿出自家的数据并提供奖金,在 Kaggle 上组织数据竞赛.我最近完成了第一次比赛,在 2125 个参赛队伍中排名第 98 位(~ 5%).因为是

统计电影票房排名前10的电影并存入另一个文件

今天看到一个笔试题,是这样的:给定一个文件(m.dat),里面保存了各个电影票房统计,格式如下: <2012>                                索尼                $769.7 <哈利波特与死亡圣器(上)>              华纳兄弟            $952.0 <星球大战>                            二十世纪福克斯      $775.4 <怪物史莱克4>      

搞定编程大赛必知哪10个算法?

再没有比算法更让人头疼的东西了吧! 前两天参加了一个编程大赛http://www.ijiami.cn/newsInfo?id=519&v=2,有感于算法,所以整理了这篇关于编程竞赛的10个算法. 动态规划(DP)似乎占据了大部分的编程竞赛题目,乃至三分之一.当然,DP也不是一个学一次就Ok的单一算法. 这还取决于你是否把数据结构与算法放在同一个等级中考虑.如果你想要在编程竞赛中一展风采的话,当然,有些数据结构是你应该熟悉的.其中最重要的有范围树(Range Tree,也被称为线段树或区间树)和树

代码面试最常用的10大算法

摘要:面试也是一门学问,在面试之前做好充分的准备则是成功的必须条件,而程序员在代码面试时,常会遇到编写算法的相关问题,比如排序.二叉树遍历等等. 在程序员的职业生涯中,算法亦算是一门基础课程,尤其是在面试的时候,很多公司都会让程序员编写一些算法实例,例如快速排序.二叉树查找等等. 本文总结了程序员在代码面试中最常遇到的10大算法类型,想要真正了解这些算法的原理,还需程序员们花些功夫. 1.String/Array/Matrix 在Java中,String是一个包含char数组和其它字段.方法的类

【算法】代码面试最常用的10大算法

http://www.csdn.net/article/2014-04-10/2819237-Top-10-Algorithms-for-Coding-Interview 在程序员的职业生涯中,算法亦算是一门基础课程,尤其是在面试的时候,很多公司都会让程序员编写一些算法实例,例如快速排序.二叉树查找等等. 本文总结了程序员在代码面试中最常遇到的10大算法类型,想要真正了解这些算法的原理,还需程序员们花些功夫. 1.String/Array/Matrix 在Java中,String是一个包含cha

2014年市场需求排名前10的编程语言 - 生命的延续是 BI

开篇介绍 2014年就快收尾了,Team 内部每人都会准备一些 Tech Talk 的内容,技术方面的,咨询方面的都可以.我就准备了一些有关 BI 排名,BI 报表排名,包括各种技术编程语言等相关排名的信息.摘选一部分有关编程技术相关的拿出来分享给大家看一下,或许对大家年终写写总结,内部技术分享时有所帮助. 以社交与工作需求相关角度出发的 2014 TOP 10 排名 来自 Slideshare 上的一个分享 - http://fr.slideshare.net/lyndadotcom/top-

卷积神经网络 cnnff.m程序 中的前向传播算法 数据 分步解析

最近在学习卷积神经网络,哎,真的是一头雾水!最后决定从阅读CNN程序下手! 程序来源于GitHub的DeepLearnToolbox 由于确实缺乏理论基础,所以,先从程序的数据流入手,虽然对高手来讲,这样有点太小儿科了,但觉得对于个人理解CNN网络的结构和数据流走向有较大帮助! 下面,将要分析CNN的前向传播算法cnnff.m 本程序所用的神经网络的结构如下图的结构体net所示 结构体net 包含5层 每层的结构 这五层的结构如下: 每层的结构分别如下: 为了方便自己理解,下面,分别对每一层的输