Top 10 Algorithms for Coding Interview

转载 2013年12月05日 15:31:57
The following are top 10 algorithms related concepts in coding interview. I will try to illustrate those concepts though some simple examples. As understanding those concepts requires much more efforts, this list only serves as an introduction. They are viewed from a Java perspective. The following concepts will be covered:

Linked List
Recursion vs. Iteration
Dynamic Programming
Bit Manipulation
Combinations and Permutations
1. String

Without code auto-completion of any IDE, the following methods should be remembered.

toCharyArray() //get char array of a String
Arrays.sort()  //sort an array
Arrays.toString(char[] a) //convert to string
charAt(int x) //get a char at the specific index
length() //string length
length //array size
Also in Java a String is not a char array. A String contains a char array and other fields and methods.

2. Linked List

The implementation of a linked list is pretty simple in Java. Each node has a value and a link to next node.

class Node {
int val;
Node next;
Node(int x) {
val = x;
next = null;
Two popular applications of linked list are stack and queue.


class Stack{
Node top; 
public Node peek(){
if(top != null){
return top;
return null;
public Node pop(){
if(top == null){
return null;
Node temp = new Node(top.val);
top =;
return temp;
public void push(Node n){
if(n != null){ = top;
top = n;

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

Tree here is normally binary tree. Each node contains a left node and right node like the following:

class TreeNode{
int value;
TreeNode left;
TreeNode right;
Here are some concepts related with trees:

Binary Search Tree: for all nodes, left children <= current node <= right children
Balanced vs. Unbalanced: In a balanced tree, the depth of the left and right subtrees of every node differ by 1 or less.
Full Binary Tree: every node other than the leaves has two children.
Perfect Binary Tree: a full binary tree in which all leaves are at the same depth or same level, and in which every parent has two children.
Complete Binary Tree: a binary tree in which every level, except possibly the last, is completely filled, and all nodes are as far left as possible
4. Graph

Graph related questions mainly focus on depth first search and breath first search.

Below is a simple implementation of a graph and breath first search.


1) Define a 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) Define a Queue

class Queue{
GraphNode first, last;
public void enqueue(GraphNode n){
if(first == null){
first = n;
last = first;
}else{ = n;
last = n;
public GraphNode dequeue(){
if(first == null){
return null;
GraphNode temp = new GraphNode(first.val, first.neighbors);
first =;
return temp;
3) Breath First Search uses a 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;
while(queue.first != null){
GraphNode c = (GraphNode) queue.dequeue();
for(GraphNode n: c.neighbors){
System.out.print(n + " ");
n.visited = true;
if(n.val == x)
System.out.println("Find "+n);

value: 2 value: 3 value: 5 Find value: 5
value: 4
5. Sorting

Time complexity of different sorting algorithms. You can go to wiki to see basic idea of them.

Algorithm Average Time Worst Time Space
Bubble sort n^2 n^2 1
Selection sort n^2 n^2 1
Counting Sort n+k n+k n+k
Insertion sort n^2 n^2
Quick sort n log(n) n^2
Merge sort n log(n) n log(n) depends
In addition, here are some implementations/demos: Counting sort, Mergesort, Quicksort, InsertionSort.

6. Recursion vs. Iteration

Recursion should be a built-in thought for programmers. It can be demonstrated by a simple example.

Question: there are n stairs, each time one can climb 1 or 2. How many different ways to climb the stairs.

Step 1: Finding the relationship before n and n-1.

To get n, there are only two ways, one 1-stair from n-1 or 2-stairs from n-2. If f(n) is the number of ways to climb to n, then f(n) = f(n-1) + f(n-2)

Step 2: Make sure the start condition is correct.

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;
The time complexity of the recursive method is exponential to n. There are a lot of redundant computations.

f(4) + f(3)
f(3) + f(2) + f(2) + f(1)
f(2) + f(1) + f(2) + f(2) + f(1)
It should be straightforward to convert the recursion to iteration.

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;
For this example, iteration takes less time. You may also want to check out Recursion vs Iteration.

7. Dynamic Programming

Dynamic programming is a technique for solving problems with the following properties:

An instance is solved using the solutions for smaller instances.
The solution for a smaller instance might be needed multiple times.
The solutions to smaller instances are stored in a table, so that each smaller instance is solved only once.
Additional space is used to save time.

The problem of climbing steps perfectly fit those 4 properties. Therefore, it can be solve by using dynamic programming.

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];
A[n] = f3(n-1) + f3(n-2);//store results so only calculate once!
return A[n];
8. Bit Manipulation

Bit operators:

OR (|) AND (&) XOR (^) Left Shift (<<) Right Shift (>>) Not (~)
1|0=1 1&0=0 1^0=1 0010<<2=1000 1100>>2=0011 ~1=0
Get bit i for a give number n. (i count from 0 and starts from right)

public static boolean getBit(int num, int i){
int result = num & (1<<i);
if(result == 0){
return false;
return true;
For example, get second bit of number 10.

i=1, n=10
1<<1= 10
10 is not 0, so return true;
9. Probability

Solving probability related questions normally requires formatting the problem well. Here is just a simple example of such kind of problems.

There are 50 people in a room, what’s the probability that two people have the same birthday? (Ignoring the fact of leap year, i.e., 365 day every year)

Very often calculating probability of something can be converted to calculate the opposite. In this example, we can calculate the probability that all people have unique birthdays. That is: 365/365 * 364/365 * 363/365 * … * 365-n/365 * … * 365-49/365. And the probability that at least two people have the same birthday would be 1 – this value.

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. Combinations and Permutations

The difference between combination and permutation is whether order matters.

Please leave your comment if you think any other problem should be here.

References/Recommmended Materials:
1. Binary tree
2. Introduction to Dynamic Programming
3. UTSA Dynamic Programming slides
4. Birthday paradox
5. Cracking the Coding Interview: 150 Programming InterviewQuestions and Solutions, Gayle Laakmann McDowell

经典算法题目:Cracking the coding interview 问题与解答

Cracking the coding interview--问题与解答 March 14, 2013 作者:Hawstein 出处:
  • wangbaochu
  • wangbaochu
  • 2016年10月31日 00:39
  • 1548

cracking the coding interview 中文版 (程序员面试金典)

转自:CTCI面试系列——谷歌面试官经典作品 | 快课网 谷歌面试官经典作品(CTCI)目录 1.1 判断一个字符串中的字符是否唯一 1.2 字符串翻转 1.3 去除字符串中重复字符 1.8 利用已知...
  • a327369238
  • a327369238
  • 2016年10月09日 20:16
  • 889

cracking the coding interview 中文版 (程序员面试金典)

 转自:CTCI面试系列——谷歌面试官经典作品 | 快课网 谷歌面试官经典作品(CTCI)目录 1.1 判断一个字符串中的字符是否唯一 1.2 字符串翻转 1.3 去除字符串中重复字符 ...
  • hnuzengchao
  • hnuzengchao
  • 2014年10月19日 11:32
  • 23595


本地(带图形环境):jvisualvm 线上(无图形环境):看总内存用top,看详细信息用jmap dump出来分析 Top nmon...
  • zheng0518
  • zheng0518
  • 2014年12月27日 22:51
  • 4581

数据挖掘:Top 10 Algorithms 序    一直想对top 10 algorithms in data mining 中的算法做一些分析介绍,也作为自己的一个回顾。但一直都没有...
  • Botaruibo
  • Botaruibo
  • 2013年01月04日 13:58
  • 1088

TOP 10 安全漏洞

TOP 10 安全漏洞 1 弱口令    弱的、易于猜中的和重新使用以前用过的口令都损害安全。测试账户拥有的口令强度弱且几乎没有监控。不要在系统或因特网站点重新使用...
  • ziliang871118
  • ziliang871118
  • 2015年05月09日 07:12
  • 599


一 概述 在终端中可以查看top命令的路径和所属软件包。 top程序对运行的系统提供一个动态的实时的监控。它能够显示系统的总体信息和一些正被Linux内核管理的任务。它所显示的系统...
  • leo115
  • leo115
  • 2013年02月04日 13:38
  • 18668

算法10—海量数据处理之top k算法

第一部分:Top K 算法详解 问题描述 百度面试题:     搜索引擎会通过日志文件把用户每次检索使用的所有检索串都记录下来,每个查询串的长度为1-255字节。     假设目前有一千万个记...
  • u012129558
  • u012129558
  • 2016年06月02日 16:27
  • 789


题目:如果有1000个分值,需要快速找到前10个是什么(并排序),怎么算更快 本人想到的是插入排序法:先将前10个排序作为初步结果(default_list),然后对剩余990个(rest_lis...
  • y68738580
  • y68738580
  • 2014年03月28日 21:41
  • 1665

【self-taught learning】学习论文以及代用代码

【self-taught learning】快速稀疏编码算法   Self-taught learning是Honglak Lee等开发的一个matlab框架,能够实现他们在论文Self-taug...
  • pirage
  • pirage
  • 2013年12月26日 16:40
  • 5800
您举报文章:Top 10 Algorithms for Coding Interview