C++博客-A Za, A Za, Fighting...-随笔分类-M_面试题集锦

数对之差的最大值

simplyzhao — Tue, 26 Jul 2011 05:25:00 GMT

题目:

题目：在数组中，数字减去它右边的数字得到一个数对之差。求所有数对之差的最大值。例如在数组{2, 4, 1, 16, 7, 5, 11, 9}中，数对之差的最大值是11，是16减去5的结果。

对于分治算法，实现的不好，参考原作者的思路，对于左半部分最大值、右半部分最小值都是可以在递归里求出的，参考：

http://zhedahht.blog.163.com/blog/static/2541117420116135376632/

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<limits.h>
#define MAX(a, b) ((a)>(b) ? (a) : (b))
#define MIN(a, b) ((a)<(b) ? (a) : (b))
/*
* 题目:
* 在数组中，数字减去它右边的数字得到一个数对之差。求所有数对之差的最大值
* 例如:
* 在数组{2, 4, 1, 16, 7, 5, 11, 9}中，数对之差的最大值是11，是16减去5的结果
*/

int
naive_solution(int *array, int len) //O(n^2)
{
    int i, j, ret = INT_MIN;
    for(i=0; i<len; ++i)
        for(j=i+1; j<len; ++j)
            ret = MAX(ret, array[i]-array[j]);

    return ret;
}

int
divide_and_conquer_solution(int *array, int begin, int end) //O(nlogn)
{
    if(begin >= end)
        return INT_MIN;
    int i, ret, left_ret, right_ret, left_max, right_min, mid;
    mid = begin + ((end-begin)>>1);
    left_ret = divide_and_conquer_solution(array, begin, mid);
    right_ret = divide_and_conquer_solution(array, mid+1, end);
    left_max = array[begin];
    for(i=begin+1; i<=mid; ++i)
        left_max = MAX(left_max, array[i]);
    right_min = array[end];
    for(i=end-1; i>mid; --i)
        right_min = MIN(right_min, array[i]);

    ret = MAX(left_ret, right_ret);
    ret = MAX(ret, left_max-right_min);
    return ret;
}

int
dynamic_programming_solution(int *array, int len) //O(n)
{
    int i, cur_ret, cur_min;
    cur_ret = array[len-2] - array[len-1];
    cur_min = MIN(array[len-2], array[len-1]);

    for(i=len-3; i>=0; --i) {
        cur_ret = MAX(cur_ret, array[i]-cur_min);
        cur_min = MIN(cur_min, array[i]);
    }

    return cur_ret;
}

int
main(int argc, char **argv)
{
    int i, num, *data = NULL;
    scanf("%d", &num);
    assert(num>=2);
    data = (int *)malloc(sizeof(int) * num);
    assert(data != NULL);
    for(i=0; i<num; i++)
        scanf("%d", data+i);

    printf("naive_solution result: %d\n", naive_solution(data, num));
    printf("divide_and_conquer_solution result: %d\n", divide_and_conquer_solution(data, 0, num-1));
    printf("dynamic_programming_solution result: %d\n", dynamic_programming_solution(data, num));

    free(data);
    return 0;
}

simplyzhao 2011-07-26 13:25 发表评论

根据(1,5)随机数生成器，生成(1,7)之内的随机数

simplyzhao — Tue, 19 Jul 2011 11:57:00 GMT

问题:

Given a random number generator which can generate the number in range (1,5) uniformly. How can you use it to build a random number generator which can generate the number in range (1,7) uniformly?

(给定一个随机数生成器，这个生成器能均匀生成1到5(1,5)的随机数，如何使用这个生成器生成均匀分布的1到7(1,7)的数?)

解法一:
拒绝采样定理
简单的说, 把 1-5 的随机数发生器用两次, 拼成一个5进制的数, 就是1-25. 将这 1-25 平均分配的25种情况映射到7种情况上, 问题就解决了. 因为21是7的倍数, 我们可以每三个映射到一个, 即1-3 映射到1, …, 19-21 映射到7. 可见, 这些情况之间的概率是一样的. 那么, 要是拼成的数字正好是 22-25 这四个呢? 有两种方法, 第一种是丢弃这个数字, 从头再来, 直到拼成的数字在1-21之间. 因为这个是个概率算法, 不能保证每次都能落在1-21, 所以采样的密度不高. 还有一种方法, 是说, 假如落到了 22-25, 那这次的采样结果就用上次的. 可以证明, 这看上去两个互相矛盾的算法, 结果都能均等的得到等概率的分布. (前者叫做 Reject Sampling, 后者叫做 Metropolis Algorithm, 都是数学物理模拟里面常用的方法)

解法二:
二进制
1-2映射到0，3跳过，4-5映射到1
生成三位的二进制即可

simplyzhao 2011-07-19 19:57 发表评论

从n个items中随机选择m个的问题

simplyzhao — Mon, 18 Jul 2011 01:32:00 GMT

问题来源: 编程珠玑

解法一:
遍历这n个items，巧妙地利用概率来筛选

void
generate_random_m_from_n(int n, int m)
{
    int i, remaining, select = m;
    srand(time(NULL));
    for(i=0; i<n; i++) {
        remaining = n - i;
        if(rand()%remaining < select) {
            printf("%d\t", i);
            --select;
        }
    }
    printf("\n");
}

解法二:
shuffle，即随机洗牌程序，然后选择前m个items即可
代码参考: http://blog.fuqcool.com/2011/04/17/algorithm-shuffle.html

洗牌算法的一种实现

作者：fuqcool 发布时间：2011-04-17 23:16:02 分类： algorithms

最近自己在做一个小的程序，需要把一个集合里面的元素全部随机地打散。自己想了一个方法，复杂度是n，觉得不太快。后来参照了一下python关于shuffle的算法，发现我的方法跟它的是一样的，连python的代码都这么写，可能已经没有办法再快了吧！

下面就来介绍洗牌算法，用C语言描述。

算法的前提是有一个产生随机数的函数

// Generates a random integer between beg and end.
int GetRandomNumber(int beg, int end);

还有一个交换函数。

// Swap a and b.
void Swap(int a, int b);

上面两个函数我就不写出实现了，因为这篇文章的重点在于算法的讨论。

假设我们有一堆扑克牌，怎么才能把这副牌完全打乱呢？计算机当然不能像人手那样洗牌。但是它可以产生随机数，随机地从一副牌中抽出一张牌是可以的。既然这样那就好办了，我们不停地从牌堆中随机抽取一张扑克牌，然后把这些牌堆起来，直到原来的牌堆只剩下一张牌的时候为止。这样不就完成了洗牌的动作了吗。

下面是C代码：

int Shuffle(int[] a, int len)
{
    for (int i = len - 1; i > 0; i--)
    {
        // Select an element from index 0 to i randomly;
        int index = GetRandomNumber(0, i);
        // exchange a[i] with a[index]
        Swap(a[index], a[i]);
    }
}

顺便也贴出python的random单元关于shuffle的实现：

def shuffle(self, x, random=None, int=int):
    """x, random=random.random -> shuffle list x in place; return None.

    Optional arg random is a 0-argument function returning a random
    float in [0.0, 1.0); by default, the standard random.random.
    """

    if random is None:
        random = self.random
    for i in reversed(xrange(1, len(x))):
        # pick an element in x[:i+1] with which to exchange x[i]
        j = int(random() * (i+1))
        x[i], x[j] = x[j], x[i]

simplyzhao 2011-07-18 09:32 发表评论

Google面试题

simplyzhao — Thu, 14 Jul 2011 02:13:00 GMT

来源:
http://coolshell.cn/articles/3345.html

Software Engineer

Why are manhole covers round? （陈皓：为什么下水井盖是圆的？这是有N种答案的，上Wiki看看吧）
What is the difference between a mutex and a semaphore? Which one would you use to protect access to an increment operation?
A man pushed his car to a hotel and lost his fortune. What happened? （陈皓：脑筋急转弯？他在玩大富翁游戏？！！）
Explain the significance of “dead beef”.（陈皓：要是你看到的是16进制 DEAD BEEF，你会觉得这是什么？IPv6的地址？）
Write a C program which measures the the speed of a context switch on a UNIX/Linux system.
Given a function which produces a random integer in the range 1 to 5, write a function which produces a random integer in the range 1 to 7.（陈皓：上StackOverflow看看吧，经典的问题）
Describe the algorithm for a depth-first graph traversal.
Design a class library for writing card games. （陈皓：用一系列的类来设计一个扑克游戏，设计题）
You need to check that your friend, Bob, has your correct phone number, but you cannot ask him directly. You must write a the question on a card which and give it to Eve who will take the card to Bob and return the answer to you. What must you write on the card, besides the question, to ensure Bob can encode the message so that Eve cannot read your phone number?（陈皓：协议+数字加密，我试想了一个，纸条上可以这样写，“Bob，请把我的手机号以MD5算法加密后的字符串，比对下面的字符串——XXXXXX，它们是一样的吗？”）
How are cookies passed in the HTTP protocol?
Design the SQL database tables for a car rental database.
Write a regular expression which matches a email address. （陈皓：上StackOverflow查相当的问题吧。）
Write a function f(a, b) which takes two character string arguments and returns a string containing only the characters found in both strings in the order of a. Write a version which is order N-squared and one which is order N.（陈皓：算法题，不难，不说了。一个O(n^2)和一个O(n)的算法复杂度）
You are given a the source to a application which is crashing when run. After running it 10 times in a debugger, you find it never crashes in the same place. The application is single threaded, and uses only the C standard library. What programming errors could be causing this crash? How would you test each one? （陈皓：和随机数有关系？或是时间？）
Explain how congestion control works in the TCP protocol.
In Java, what is the difference between final, finally, and finalize?
What is multithreaded programming? What is a deadlock?
Write a function (with helper functions if needed) called to Excel that takes an excel column value (A,B,C,D…AA,AB,AC,… AAA..) and returns a corresponding integer value (A=1,B=2,… AA=26..).
You have a stream of infinite queries (ie: real time Google search queries that people are entering). Describe how you would go about finding a good estimate of 1000 samples from this never ending set of data and then write code for it.
Tree search algorithms. Write BFS and DFS code, explain run time and space requirements. Modify the code to handle trees with weighted edges and loops with BFS and DFS, make the code print out path to goal state.
You are given a list of numbers. When you reach the end of the list you will come back to the beginning of the list (a circular list). Write the most efficient algorithm to find the minimum # in this list. Find any given # in the list. The numbers in the list are always increasing but you don’t know where the circular list begins, ie: 38, 40, 55, 89, 6, 13, 20, 23, 36. （陈皓：循环排序数组的二分查找问题）
Describe the data structure that is used to manage memory. (stack)
What’s the difference between local and global variables?
If you have 1 million integers, how would you sort them efficiently? (modify a specific sorting algorithm to solve this)
In Java, what is the difference between static, final, and const. (if you don’t know Java they will ask something similar for C or C++).
Talk about your class projects or work projects (pick something easy)… then describe how you could make them more efficient (in terms of algorithms).
Suppose you have an NxN matrix of positive and negative integers. Write some code that finds the sub-matrix with the maximum sum of its elements.（陈皓：以前见过一维数组的这个问题，现在是二维的。感觉应该是把二维的第一行的最大和的区间算出来，然后再在这个基础之上进行二维的分析。思路应该是这个，不过具体的算法还需要想一想）
Write some code to reverse a string.
Implement division (without using the divide operator, obviously).（陈皓：想一想手算除法的过程。）
Write some code to find all permutations of the letters in a particular string.
What method would you use to look up a word in a dictionary? （陈皓：使用排序，哈希，树等算法和数据结构）
Imagine you have a closet full of shirts. It’s very hard to find a shirt. So what can you do to organize your shirts for easy retrieval?
You have eight balls all of the same size. 7 of them weigh the same, and one of them weighs slightly more. How can you fine the ball that is heavier by using a balance and only two weighings?
What is the C-language command for opening a connection with a foreign host over the internet?
Design and describe a system/application that will most efficiently produce a report of the top 1 million Google search requests. These are the particulars: 1) You are given 12 servers to work with. They are all dual-processor machines with 4Gb of RAM, 4x400GB hard drives and networked together.(Basically, nothing more than high-end PC’s) 2) The log data has already been cleaned for you. It consists of 100 Billion log lines, broken down into 12 320 GB files of 40-byte search terms per line. 3) You can use only custom written applications or available free open-source software.
There is an array A[N] of N numbers. You have to compose an array Output[N] such that Output[i] will be equal to multiplication of all the elements of A[N] except A[i]. For example Output[0] will be multiplication of A[1] to A[N-1] and Output[1] will be multiplication of A[0] and from A[2] to A[N-1]. Solve it without division operator and in O(n).（陈皓：注意其不能使用除法。算法思路是这样的，把output[i]=a[i]左边的乘积 x a[i]右边的乘积，所以，我们可以分两个循环，第一次先把A[i]左边的乘积放在Output[i]中，第二次把A[i]右边的乘积算出来。我们先看第一次的循环，使用迭代累积的方式，代码如下：for(r=1; i=0; i
There is a linked list of numbers of length N. N is very large and you don’t know N. You have to write a function that will return k random numbers from the list. Numbers should be completely random. Hint: 1. Use random function rand() (returns a number between 0 and 1) and irand() (return either 0 or 1) 2. It should be done in O(n).（陈皓：本题其实不难。在遍历链表的同时一边生成随机数，一边记录最大的K个随机数和其链接地址。）
Find or determine non existence of a number in a sorted list of N numbers where the numbers range over M, M>> N and N large enough to span multiple disks. Algorithm to beat O(log n) bonus points for constant time algorithm.（陈皓：使用bitmap，如果一个长整形有64位，那么我们可以使用M/64个bitmap）
You are given a game of Tic Tac Toe. You have to write a function in which you pass the whole game and name of a player. The function will return whether the player has won the game or not. First you to decide which data structure you will use for the game. You need to tell the algorithm first and then need to write the code. Note: Some position may be blank in the game। So your data structure should consider this condition also.
You are given an array [a1 To an] and we have to construct another array [b1 To bn] where bi = a1*a2*…*an/ai. you are allowed to use only constant space and the time complexity is O(n). No divisions are allowed.（陈皓：前面说过了）
How do you put a Binary Search Tree in an array in a efficient manner. Hint :: If the node is stored at the ith position and its children are at 2i and 2i+1(I mean level order wise)Its not the most efficient way.（陈皓：按顺序遍历树）
How do you find out the fifth maximum element in an Binary Search Tree in efficient manner. Note: You should not use use any extra space. i.e sorting Binary Search Tree and storing the results in an array and listing out the fifth element.
Given a Data Structure having first n integers and next n chars. A = i1 i2 i3 … iN c1 c2 c3 … cN.Write an in-place algorithm to rearrange the elements of the array ass A = i1 c1 i2 c2 … in cn（陈皓：这个算法其实就是从中间开始交换元素，代码：for(i=n-1; i>1; i++) { for(j=i; j<2*n-i; j+=2) { swap(a[j], a[j+1]); } }，不好意思写在同一行上了。）
Given two sequences of items, find the items whose absolute number increases or decreases the most when comparing one sequence with the other by reading the sequence only once.
Given That One of the strings is very very long , and the other one could be of various sizes. Windowing will result in O(N+M) solution but could it be better? May be NlogM or even better?
How many lines can be drawn in a 2D plane such that they are equidistant from 3 non-collinear points?
Let’s say you have to construct Google maps from scratch and guide a person standing on Gateway of India (Mumbai) to India Gate(Delhi). How do you do the same?
Given that you have one string of length N and M small strings of length L. How do you efficiently find the occurrence of each small string in the larger one?
Given a binary tree, programmatically you need to prove it is a binary search tree.
You are given a small sorted list of numbers, and a very very long sorted list of numbers – so long that it had to be put on a disk in different blocks. How would you find those short list numbers in the bigger one?
Suppose you have given N companies, and we want to eventually merge them into one big company. How many ways are theres to merge?
Given a file of 4 billion 32-bit integers, how to find one that appears at least twice? （陈皓：我能想到的是拆分成若干个小数组，排序，然后一点点归并起来）
Write a program for displaying the ten most frequent words in a file such that your program should be efficient in all complexity measures.（陈皓：你可能需要看看这篇文章Finding Frequent Items in Data Streams）
Design a stack. We want to push, pop, and also, retrieve the minimum element in constant time.
Given a set of coin denominators, find the minimum number of coins to give a certain amount of change.（陈皓：你应该查看一下这篇文章：Coin Change Problem）
Given an array, i) find the longest continuous increasing subsequence. ii) find the longest increasing subsequence.（陈皓：这个题不难，O(n)算法是边遍历边记录当前最大的连续的长度。）
Suppose we have N companies, and we want to eventually merge them into one big company. How many ways are there to merge?
Write a function to find the middle node of a single link list. （陈皓：我能想到的算法是——设置两个指针p1和p2，每一次，p1走两步，p2走一步，这样，当p1走到最后时，p2就在中间）
Given two binary trees, write a compare function to check if they are equal or not. Being equal means that they have the same value and same structure.（陈皓：这个很简单，使用递归算法。）
Implement put/get methods of a fixed size cache with LRU replacement algorithm.
You are given with three sorted arrays ( in ascending order), you are required to find a triplet ( one element from each array) such that distance is minimum. Distance is defined like this : If a[i], b[j] and c[k] are three elements then distance=max(abs(a[i]-b[j]),abs(a[i]-c[k]),abs(b[j]-c[k]))” Please give a solution in O(n) time complexity（陈皓：三个指针，a, b, c分别指向三个数组头，假设：a[0]b[0]，计算 abs(a[i-1] – c[0])，把结果保存在min中。现在情况变成找 a[i], b[0],c[0]，重复上述过程，如果有一个新的值比min要小，那就取代现有的min。）
How does C++ deal with constructors and deconstructors of a class and its child class?
Write a function that flips the bits inside a byte (either in C++ or Java). Write an algorithm that take a list of n words, and an integer m, and retrieves the mth most frequent word in that list.
What’s 2 to the power of 64?
Given that you have one string of length N and M small strings of length L. How do you efficiently find the occurrence of each small string in the larger one? （陈皓：我能想到的是——把那M个小字串排个序，然后遍历大字串，并在那M个字串中以二分取中的方式查找。）
How do you find out the fifth maximum element in an Binary Search Tree in efficient manner.
Suppose we have N companies, and we want to eventually merge them into one big company. How many ways are there to merge?
There is linked list of millions of node and you do not know the length of it. Write a function which will return a random number from the list.
You need to check that your friend, Bob, has your correct phone number, but you cannot ask him directly. You must write a the question on a card which and give it to Eve who will take the card to Bob and return the answer to you. What must you write on the card, besides the question, to ensure Bob can encode the message so that Eve cannot read your phone number?
How long it would take to sort 1 trillion numbers? Come up with a good estimate.
Order the functions in order of their asymptotic performance: 1) 2^n 2) n^100 3) n! 4) n^n
There are some data represented by(x,y,z). Now we want to find the Kth least data. We say (x1, y1, z1) > (x2, y2, z2) when value(x1, y1, z1) > value(x2, y2, z2) where value(x,y,z) = (2^x)*(3^y)*(5^z). Now we can not get it by calculating value(x,y,z) or through other indirect calculations as lg(value(x,y,z)). How to solve it?
How many degrees are there in the angle between the hour and minute hands of a clock when the time is a quarter past three?
Given an array whose elements are sorted, return the index of a the first occurrence of a specific integer. Do this in sub-linear time. I.e. do not just go through each element searching for that element.
Given two linked lists, return the intersection of the two lists: i.e. return a list containing only the elements that occur in both of the input lists. （陈皓：把第一个链表存入hash表，然后遍历第二个链表。不知道还没有更好的方法。）
What’s the difference between a hashtable and a hashmap?
If a person dials a sequence of numbers on the telephone, what possible words/strings can be formed from the letters associated with those numbers?（陈皓：这个问题和美国的电话有关系，大家可以试着想一下我们发短信的手机，按数字键出字母，一个组合的数学问题。）
How would you reverse the image on an n by n matrix where each pixel is represented by a bit?
Create a fast cached storage mechanism that, given a limitation on the amount of cache memory, will ensure that only the least recently used items are discarded when the cache memory is reached when inserting a new item. It supports 2 functions: String get(T t) and void put(String k, T t).
Create a cost model that allows Google to make purchasing decisions on to compare the cost of purchasing more RAM memory for their servers vs. buying more disk space.
Design an algorithm to play a game of Frogger and then code the solution. The object of the game is to direct a frog to avoid cars while crossing a busy road. You may represent a road lane via an array. Generalize the solution for an N-lane road.
What sort would you use if you had a large data set on disk and a small amount of ram to work with?
What sort would you use if you required tight max time bounds and wanted highly regular performance.
How would you store 1 million phone numbers?（陈皓：试想电话是有区段的，可以把区段统一保存，Flyweight设计模式）
Design a 2D dungeon crawling game. It must allow for various items in the maze – walls, objects, and computer-controlled characters. (The focus was on the class structures, and how to optimize the experience for the user as s/he travels through the dungeon.)
What is the size of the C structure below on a 32-bit system? On a 64-bit? （陈皓：注意编译器的对齐）

struct foo {

char a;

char* b;

};

simplyzhao 2011-07-14 10:13 发表评论

扑克牌的顺子

simplyzhao — Tue, 12 Jul 2011 12:33:00 GMT

题目来源:
http://zhedahht.blog.163.com/blog/static/25411174200951262930831/

题目：从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。2-10为数字本身，A为1，J为11，Q为12，K为13，而大小王可以看成任意数字。

思路一:
我们需要把扑克牌的背景抽象成计算机语言。不难想象，我们可以把5张牌看成由5个数字组成的数组。大小王是特殊的数字，我们不妨把它们都当成0，这样和其他扑克牌代表的数字就不重复了。

接下来我们来分析怎样判断5个数字是不是连续的。最直观的是，我们把数组排序。但值得注意的是，由于0可以当成任意数字，我们可以用0去补满数组中的空缺。也就是排序之后的数组不是连续的，即相邻的两个数字相隔若干个数字，但如果我们有足够的0可以补满这两个数字的空缺，这个数组实际上还是连续的。举个例子，数组排序之后为{0，1，3，4，5}。在1和3之间空缺了一个2，刚好我们有一个0，也就是我们可以它当成2去填补这个空缺。

于是我们需要做三件事情：把数组排序，统计数组中0的个数，统计排序之后的数组相邻数字之间的空缺总数。如果空缺的总数小于或者等于0的个数，那么这个数组就是连续的；反之则不连续。最后，我们还需要注意的是，如果数组中的非0数字重复出现，则该数组不是连续的。换成扑克牌的描述方式，就是如果一副牌里含有对子，则不可能是顺子。

更好的思路二:
1）确认5张牌中除了0，其余数字没有重复的（可以用表统计的方法）;
2) 满足这样的逻辑：（max，min分别代表5张牌中的除0以外的最大值最小值）
       如果没有0，则max-min=4，则为顺子，否则不是
       如果有一个0，则max-min=4或者3，则为顺子，否则不是
       如果有两个0，则max-min=4或者3或者2，则为顺子，否则不是

最大值和最小值在1）中就可以获得，这样就不用排序了

simplyzhao 2011-07-12 20:33 发表评论

C++基础题

simplyzhao — Wed, 22 Jun 2011 11:41:00 GMT

题目来源:
http://zhedahht.blog.163.com/blog/static/25411174201102642136998/

题目（六）：运行下列C++代码，输出什么？

struct Point3D

{

int x;

int y;

int z;

};

int _tmain(int argc, _TCHAR* argv[])

{

Point3D* pPoint = NULL;

int offset = (int)(&(pPoint)->z);

printf("%d", offset);

return 0;

}

答案：输出8。由于在pPoint->z的前面加上了取地址符号，运行到此时的时候，会在pPoint的指针地址上加z在类型Point3D中的偏移量8。由于pPoint的地址是0，因此最终offset的值是8。

&(pPoint->z)的语意是求pPoint中变量z的地址（pPoint的地址0加z的偏移量8），并不需要访问pPoint指向的内存。只要不访问非法的内存，程序就不会出错。

题目（七）：运行下列C++代码，输出什么？

class A

{

public:

A()

{

Print();

}

virtual void Print()

{

printf("A is constructed.\n");

}

};

class B: public A

{

public:

B()

{

Print();

}

virtual void Print()

{

printf("B is constructed.\n");

}

};

int _tmain(int argc, _TCHAR* argv[])

{

A* pA = new B();

delete pA;

return 0;

}

答案：先后打印出两行:A is constructed. B is constructed. 调用B的构造函数时，先会调用B的基类及A的构造函数。然后在A的构造函数里调用Print。由于此时实例的类型B的部分还没有构造好，本质上它只是A的一个实例，他的虚函数表指针指向的是类型A的虚函数表。因此此时调用的Print是A::Print，而不是B::Print。接着调用类型B的构造函数，并调用Print。此时已经开始构造B，因此此时调用的Print是B::Print。

同样是调用虚拟函数Print，我们发现在类型A的构造函数中，调用的是A::Print，在B的构造函数中，调用的是B::Print。因此虚函数在构造函数中，已经失去了虚函数的动态绑定特性。

simplyzhao 2011-06-22 19:41 发表评论

顺时针打印矩阵

simplyzhao — Fri, 17 Jun 2011 12:00:00 GMT

题目来源:
http://zhedahht.blog.163.com/blog/static/254111742010111112236313/

模拟法

#include<stdio.h>
#define MAX_LEN 101

void
print_circle(int (*mtrx)[MAX_LEN], int leftup_x, int leftup_y, int rightdown_x, int rightdown_y)
{
    int i, j;
    if(leftup_x == rightdown_x) {
        for(j=leftup_y; j<=rightdown_y; j++)
            printf("%d\t", mtrx[leftup_x][j]);
        return;
    }
    if(leftup_y == rightdown_y) {
        for(i=leftup_x; i<=rightdown_x; i++)
            printf("%d\t", mtrx[i][leftup_y]);
        return;
    }

    for(i=leftup_y; i<rightdown_y; i++)
        printf("%d\t", mtrx[leftup_x][i]);
    for(j=leftup_x; j<rightdown_x; j++)
        printf("%d\t", mtrx[j][rightdown_y]);
    for(i=rightdown_y; i>leftup_y; i--)
        printf("%d\t", mtrx[rightdown_x][i]);
    for(j=rightdown_x; j>leftup_x; j--)
        printf("%d\t", mtrx[j][leftup_y]);
}

void
solve(int (*mtrx)[MAX_LEN], int width, int length)
{
    int lu_x, lu_y, rd_x, rd_y;
    lu_x = lu_y = 0;
    rd_x = width-1;
    rd_y = length-1;
    while(1) {
        if(lu_x>rd_x || lu_y>rd_y)
            break;
        print_circle(mtrx, lu_x, lu_y, rd_x, rd_y);
        ++lu_x;
        ++lu_y;
        --rd_x;
        --rd_y;
    }
}

int
main(int argc, char **argv)
{
    int i, j, length, width, matrix[MAX_LEN][MAX_LEN];
    scanf("%d %d", &width, &length);
    for(i=0; i<width; i++)
        for(j=0; j<length; j++)
            scanf("%d", matrix[i]+j);

    solve(matrix, width, length);
    return 0;
}

simplyzhao 2011-06-17 20:00 发表评论

不用＋、－、×、÷数字运算符做加法

simplyzhao — Fri, 17 Jun 2011 09:30:00 GMT

题目来源:
http://zhedahht.blog.163.com/blog/static/254111742011125100605/

题目：写一个函数，求两个整数的之和，要求在函数体内不得使用＋、－、×、÷。

分析：这又是一道考察发散思维的很有意思的题目。当我们习以为常的东西被限制使用的时候，如何突破常规去思考，就是解决这个问题的关键所在。

看到的这个题目，我的第一反应是傻眼了，四则运算都不能用，那还能用什么啊？可是问题总是要解决的，只能打开思路去思考各种可能性。首先我们可以分析人们是如何做十进制的加法的，比如是如何得出5+17=22这个结果的。实际上，我们可以分成三步的：第一步只做各位相加不进位，此时相加的结果是12（个位数5和7相加不要进位是2，十位数0和1相加结果是1）；第二步做进位，5+7中有进位，进位的值是10；第三步把前面两个结果加起来，12+10的结果是22，刚好5+17=22。

前面我们就在想，求两数之和四则运算都不能用，那还能用什么啊？对呀，还能用什么呢？对数字做运算，除了四则运算之外，也就只剩下位运算了。位运算是针对二进制的，我们也就以二进制再来分析一下前面的三步走策略对二进制是不是也管用。

5的二进制是101，17的二进制10001。还是试着把计算分成三步：第一步各位相加但不计进位，得到的结果是10100（最后一位两个数都是1，相加的结果是二进制的10。这一步不计进位，因此结果仍然是0）；第二步记下进位。在这个例子中只在最后一位相加时产生一个进位，结果是二进制的10；第三步把前两步的结果相加，得到的结果是10110，正好是22。由此可见三步走的策略对二进制也是管用的。

接下来我们试着把二进制上的加法用位运算来替代。第一步不考虑进位，对每一位相加。0加0与 1加1的结果都0，0加1与1加0的结果都是1。我们可以注意到，这和异或的结果是一样的。对异或而言，0和0、1和1异或的结果是0，而0和1、1和0的异或结果是1。接着考虑第二步进位，对0加0、0加1、1加0而言，都不会产生进位，只有1加1时，会向前产生一个进位。此时我们可以想象成是两个数先做位与运算，然后再向左移动一位。只有两个数都是1的时候，位与得到的结果是1，其余都是0。第三步把前两个步骤的结果相加。如果我们定义一个函数AddWithoutArithmetic，第三步就相当于输入前两步骤的结果来递归调用自己。

#include<stdio.h>

int
tricky_add(int arg1, int arg2)
{
    int a, b;
    a = arg1 ^ arg2; /* this is the result of arg1+arg2 without carry */
    b = arg1 & arg2;
    b <<= 1;

    if(b == 0)
        return a;
    else
        return tricky_add(a, b);
}

int
main(int argc, char **argv)
{
    int x, y;
    while(scanf("%d %d", &x, &y) != EOF) {
        printf("%d\n", tricky_add(x, y));
    }

    return 0;
}

simplyzhao 2011-06-17 17:30 发表评论

和为n连续正数序列

simplyzhao — Thu, 16 Jun 2011 11:33:00 GMT

题目来源:
http://zhedahht.blog.163.com/blog/static/25411174200732711051101/

题目：输入一个正数n，输出所有和为n连续正数序列。

例如输入15，由于1+2+3+4+5=4+5+6=7+8=15，所以输出3个连续序列1-5、4-6和7-8。

分析：这是网易的一道面试题。

这道题和本面试题系列的第10题有些类似。我们用两个数small和big分别表示序列的最小值和最大值。首先把small初始化为1，big初始化为2。如果从small到big的序列的和大于n的话，我们向右移动small，相当于从序列中去掉较小的数字。如果从small到big的序列的和小于n的话，我们向右移动big，相当于向序列中添加big的下一个数字。一直到small等于(1+n)/2，因为序列至少要有两个数字。

基于这个思路，我们可以写出如下代码：

void PrintContinuousSequence(int small, int big);

/////////////////////////////////////////////////////////////////////////
// Find continuous sequence, whose sum is n
/////////////////////////////////////////////////////////////////////////
void FindContinuousSequence(int n)
{
      if(n < 3)
            return;

      int small = 1;
      int big = 2;
      int middle = (1 + n) / 2;
      int sum = small + big;

      while(small < middle)
      {
            // we are lucky and find the sequence
            if(sum == n)
                  PrintContinuousSequence(small, big);

            // if the current sum is greater than n,
            // move small forward
            while(sum > n)
            {
                  sum -= small;
                  small ++;

                  // we are lucky and find the sequence
                  if(sum == n)
                        PrintContinuousSequence(small, big);
            }

            // move big forward
            big ++;
            sum += big;
      }
}

/////////////////////////////////////////////////////////////////////////
// Print continuous sequence between small and big
/////////////////////////////////////////////////////////////////////////
void PrintContinuousSequence(int small, int big)
{
      for(int i = small; i <= big; ++ i)
            printf("%d ", i);

      printf("\n");
}

simplyzhao 2011-06-16 19:33 发表评论

跳台阶问题

simplyzhao — Sun, 12 Jun 2011 10:19:00 GMT

题目来源:
http://zhedahht.blog.163.com/blog/static/25411174200731844235261/

题目：一个台阶总共有n级，如果一次可以跳1级，也可以跳2级。求总共有多少总跳法，并分析算法的时间复杂度。

分析：这道题最近经常出现，包括MicroStrategy等比较重视算法的公司都曾先后选用过个这道题作为面试题或者笔试题。

首先我们考虑最简单的情况。如果只有1级台阶，那显然只有一种跳法。如果有2级台阶，那就有两种跳的方法了：一种是分两次跳，每次跳1级；另外一种就是一次跳2级。

现在我们再来讨论一般情况。我们把n级台阶时的跳法看成是n的函数，记为f(n)。当n>2时，第一次跳的时候就有两种不同的选择：一是第一次只跳1级，此时跳法数目等于后面剩下的n-1级台阶的跳法数目，即为f(n-1)；另外一种选择是第一次跳2级，此时跳法数目等于后面剩下的n-2级台阶的跳法数目，即为f(n-2)。因此n级台阶时的不同跳法的总数f(n)=f(n-1)+(f-2)。

我们把上面的分析用一个公式总结如下：

        /  1                         n=1
f(n)=      2                          n=2
        \  f(n-1)+(f-2)               n>2

分析到这里，相信很多人都能看出这就是我们熟悉的Fibonacci序列。

simplyzhao 2011-06-12 18:19 发表评论

反转链表循环与递归

simplyzhao — Sun, 12 Jun 2011 08:15:00 GMT

题目来源：
http://zhedahht.blog.163.com/blog/static/2541117420073471124487/

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

struct Node {
    char value;
    struct Node *next;
};

struct Node *
list_reverse(struct Node *head)
{
    struct Node *tmp, *cur, *pre = NULL;
    cur = head;
    while(cur) {
        tmp = cur->next;
        cur->next = pre;
        pre = cur;
        cur = tmp;
    }
    return pre;
}

struct Node *
list_reverse_recursive(struct Node *head)
{
    struct Node *rv;
    if(head && head->next) {
        rv = list_reverse_recursive(head->next);
        head->next->next = head;
        head->next = NULL;
        return rv;
    } else
        return head;
}

void
test_print(struct Node *head)
{
    while(head) {
        printf("%c\t", head->value);
        head = head->next;
    }
    printf("\n");
}

int
main(int argc, char **argv)
{
    struct Node d = {'d', NULL};
    struct Node c = {'c', &d};
    struct Node b = {'b', &c};
    struct Node a = {'a', &b};

    test_print(&a);

    struct Node *rev_first = list_reverse(&a);

    test_print(rev_first);

    struct Node *rev_second = list_reverse_recursive(rev_first);

    test_print(rev_second);

    return 0;
}

simplyzhao 2011-06-12 16:15 发表评论

把字符串转换成整数

simplyzhao — Fri, 10 Jun 2011 11:46:00 GMT

题目来源:
http://blog.163.com/prevBlogPerma.do?host=zhedahht&srl=25411174200731139971&mode=prev

#include<stdio.h>
#include<stdlib.h>

#include<string.h>
#include<limits.h>
/*
* #define INT_MAX 2147483647 　　
* #define INT_MIN (-INT_MAX-1)
*/

enum Status {
    Success,
    Fail
};
enum Status ret;
int negative;

int
Str2Int(const char *input)
{
    long long num = 0;
    negative = 0;
    ret = Fail;
    if(input == NULL)
        return num;

    const char *ptr = input;
    if(*ptr=='+' || *ptr=='-') {
        if(*ptr == '-')
            negative = 1;
        ++ptr;
    }
    while(*ptr) {
        if(!(*ptr>='0' && *ptr<='9'))
            return num;

        if((!negative && num>INT_MAX) || (negative && (-num)<INT_MIN))
            return num;

        num = num*10 + (*ptr-'0');
        ++ptr;
    }
    ret = Success;
    return num;
}

#define MAX_LEN 101

int
main(int argc, char **argv)
{
    int result;
    char value[MAX_LEN];
    while(scanf("%s", value) != EOF) {
        result = Str2Int(value);
        if(ret == Success)
            printf("%d\n", negative ? (-result) : result);
        else
            printf("Invalid\n");
    }

    return 0;
}

simplyzhao 2011-06-10 19:46 发表评论

带随机指针的链表复制

simplyzhao — Thu, 09 Jun 2011 03:35:00 GMT

题目来源：
http://zhedahht.blog.163.com/blog/static/254111742010819104710337/

题目：有一个复杂链表，其结点除了有一个m_pNext指针指向下一个结点外，还有一个m_pSibling指向链表中的任一结点或者NULL。其结点的C++定义如下：

struct ComplexNode

{

int m_nValue;

ComplexNode* m_pNext;

ComplexNode* m_pSibling;

};

代码：

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

struct Node {
    char value;

    struct Node *next;
    struct Node *random;
};

void test_print(struct Node *);

struct Node *
list_copy_with_random_pointer(struct Node *head)
{
    struct Node *tmp, *ptr, *ret;

    ptr = head;
    while(ptr != NULL) {
        tmp = (struct Node *)malloc(sizeof(struct Node));
        tmp->value = (ptr->value)-32; /* from lowercase to uppercase, just for testing */
        tmp->next = ptr->next;
        tmp->random = NULL;

        ptr->next = tmp;

        ptr = ptr->next->next;
    }

    ptr = head;
    while(ptr != NULL) {
        ptr->next->random = ptr->random==NULL ? NULL : ptr->random->next;

        ptr = ptr->next->next;
    }

    ptr = head;
    ret = (head==NULL ? NULL : (head->next));
    while(ptr != NULL) {
        tmp = ptr->next;
        ptr->next = ptr->next->next;
        tmp->next = ptr->next==NULL ? NULL : ptr->next->next;

        ptr = ptr->next;
    }

    return ret;
}

void
test_print(struct Node *head)
{
    while(head != NULL) {
        printf("%c: [%c, %c]\n", head->value, head->next==NULL?'-':head->next->value, head->random==NULL?'-':head->random->value);

        head = head->next;
    }
}

int
main(int argc, char **argv)
{
    struct Node d = {'d', NULL, NULL};
    struct Node c = {'c', &d, NULL};
    struct Node b = {'b', &c, NULL};
    struct Node a = {'a', &b, NULL};
    a.random = &c;
    d.random = &b;

    test_print(&a);

    struct Node *copy = list_copy_with_random_pointer(&a);

    printf("\n\n");
    test_print(&a);
    printf("\n\n");
    test_print(copy);

    return 0;
}

simplyzhao 2011-06-09 11:35 发表评论

求二元查找树的镜像

simplyzhao — Wed, 01 Jun 2011 11:58:00 GMT

题目来源： http://blog.163.com/prevBlogPerma.do?host=zhedahht&srl=2541117420072159363370&mode=prev

题目：输入一颗二元查找树，将该树转换为它的镜像，即在转换后的二元查找树中，左子树的结点都大于右子树的结点。用递归和循环两种方法完成树的镜像转换。

例如输入：

     8
    / \
6      10
/\       /\
5 7    9   11

输出：

      8
    / \
10    6
/\      /\
11  9 7 5

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

struct Node {
    int value;
    struct Node *left;
    struct Node *right;
};

void
bst_preorder(struct Node *root)
{
    if(root == NULL)
        return;

    printf("%d\t", root->value);
    bst_preorder(root->left);
    bst_preorder(root->right);
}

void
bst_mirror_recursive(struct Node *root) /* easy */
{
    if(root == NULL)
        return;

    struct Node *ptr = root->left;
    root->left = root->right;
    root->right = ptr;

    bst_mirror_recursive(root->left);
    bst_mirror_recursive(root->right);
}

/* STACK : naive */
#define STACK_SIZE 101
struct Stack {
    void *data[STACK_SIZE];
    int top;
};

void
stack_pop(struct Stack *stack)
{
    if((stack->top) >= 0)
        --(stack->top);
}

void *
stack_top(struct Stack *stack)
{
    if((stack->top) >= 0)
        return stack->data[stack->top];

    return NULL;
}

void
stack_push(struct Stack *stack, void *entity)
{
    stack->data[++(stack->top)] = entity;
}

int
stack_isempty(struct Stack *stack)
{
    return (stack->top) < 0;
}

void
bst_mirror_nonrecursive(struct Node *root, struct Stack *aux_stack) /* stack used : good method */
{
    stack_push(aux_stack, root);
    while(!stack_isempty(aux_stack)) {
        struct Node *node = (struct Node *)stack_top(aux_stack);

        struct Node *ptr = node->left;
        node->left = node->right;
        node->right = ptr;

        stack_pop(aux_stack);
        if(node->left)
            stack_push(aux_stack, node->left);
        if(node->right)
            stack_push(aux_stack, node->right);
    }
}

int
main(int argc, char **argv)
{
    struct Node a = {5, NULL, NULL};
    struct Node b = {7, NULL, NULL};
    struct Node c = {9, NULL, NULL};
    struct Node d = {11, NULL, NULL};
    struct Node e = {6, &a, &b};
    struct Node f = {10, &c, &d};
    struct Node g = {8, &e, &f};

    bst_preorder(&g);
    printf("\n");
    bst_mirror_recursive(&g);
    bst_preorder(&g);
    printf("\n");

    bst_mirror_recursive(&g);
    bst_preorder(&g);
    printf("\n");
    struct Stack aux = {{0}, -1};
    bst_mirror_nonrecursive(&g, &aux);
    bst_preorder(&g);
    printf("\n");

    return 0;
}

simplyzhao 2011-06-01 19:58 发表评论

判断二叉树是不是平衡的

simplyzhao — Tue, 31 May 2011 08:58:00 GMT

题目来源: http://zhedahht.blog.163.com/blog/static/25411174201142733927831/

题目：输入一棵二叉树的根结点，判断该树是不是平衡二叉树。如果某二叉树中任意结点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX(a, b) ((a)>(b) ? (a) : (b))
#define ABS(x) ((x)>=0 ? (x) : ((x)*(-1)))

struct Node {
    void *data;
    struct Node *left, *right;
};

int
depth(struct Node *root)
{
    if(root == NULL)
        return 0;

    int ldepth = depth(root->left);
    int rdepth = depth(root->right);

    return MAX(ldepth, rdepth) + 1;
}

int
btree_isbalanced_naive(struct Node *root) /* return 1 if balanced, or return 0 */
{
    if(root == NULL)
        return 1;

    int ldepth = depth(root->left);
    int rdepth = depth(root->right);
    int diff = ldepth - rdepth;
    if(ABS(diff) > 1)
        return 0;

    return (btree_isbalanced_naive(root->left) && btree_isbalanced_naive(root->right));
}

int
btree_isbalanced(struct Node *root, int *depth)
{
    if(root == NULL) {
        *depth = 0;
        return 1;
    }

    int ldepth, rdepth, diff;
    if(!btree_isbalanced(root->left, &ldepth) || !btree_isbalanced(root->right, &rdepth))
        return 0;

    *depth = MAX(ldepth, rdepth) + 1;
    diff = ldepth - rdepth;
    return (ABS(diff)<=1 ? 1 : 0);
}

int
main(int argc, char **argv)
{
    struct Node a = {NULL, NULL, NULL};
    struct Node b = {NULL, NULL, NULL};
    struct Node c = {NULL, NULL ,NULL};
    struct Node d = {NULL, &b, NULL};
    struct Node e = {NULL, &a, &d};
    struct Node f = {NULL, NULL, NULL};
    struct Node g = {NULL, &e, &f};

    int ret1 = btree_isbalanced_naive(&g);
    printf("%s\n", ret1 ? "YES" : "NO");

    int dpth = 0;
    int ret2 = btree_isbalanced(&g, &dpth);
    printf("%s : %d\n", ret2 ? "YES" : "NO", dpth);
    return 0;
}

simplyzhao 2011-05-31 16:58 发表评论

设计包含min函数的栈

simplyzhao — Wed, 25 May 2011 07:49:00 GMT

题目出处: http://zhedahht.blog.163.com/blog/static/25411174200712895228171/

题目：定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。要求函数min、push以及pop的时间复杂度都是O(1)。

#include "StackWithMin.h"
#include<cstdio>
#include<cstdlib>
#include<cstring>

const int StackWithMin::MAX_SIZE ;

StackWithMin::StackWithMin() :
    top_index(-1), min_index(-1)
{
    printf("StackWithMin Constructor\n");
}

StackWithMin::~StackWithMin()
{
    printf("StackWithMin Destructor\n");
}

int
StackWithMin::top() const
{
    if(top_index == -1) {
        printf("top() failed: Stack Empty\n");
        return -1;
    }

    return stack[top_index];
}

int
StackWithMin::get_min() const
{
    if(min_index == -1) {
        printf("get_min() failed: Stack Empty\n");
        return -1;
    }

    return stack[min_index];
}

void
StackWithMin::push(int value)
{
    if(top_index == -1) { /* stack empty */
        stack[++top_index] = value;
        min_index = top_index;
        return;
    }
    stack[++top_index] = value;
    if(value < stack[min_index]) {
        index[top_index] = min_index;
        min_index = top_index;
    }
}

int
StackWithMin::pop()
{
    if(top_index == -1) {
        printf("pop() failed: Stack Empty\n");
        return -1;
    }
    int ret = stack[top_index];
    if(min_index == top_index)
        min_index = index[top_index];
    --top_index;
    return ret;
}

class StackWithMin
{
    public:
        StackWithMin();
        ~StackWithMin();
        int get_min() const;
        int top() const;
        void push(int value);
        int pop();
    private:
        static const int MAX_SIZE = 101;
        int top_index, min_index;
        int stack[MAX_SIZE];
        int index[MAX_SIZE];
};

simplyzhao 2011-05-25 15:49 发表评论

把二元查找树转变成排序的双向链表

simplyzhao — Mon, 23 May 2011 01:09:00 GMT

题目出处: http://zhedahht.blog.163.com/

题目：输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。要求不能创建任何新的结点，只调整指针的指向。

　　比如将二元查找树
                                            10
                                          /    \
                                        6       14
                                      / \     /　 \
                                   　4     8 12 　 16
转换成双向链表

4=6=8=10=12=14=16。

思路：递归，在一时找不到递归的灵感的时候，多考虑考虑递归的参数，有时更重要的是考虑递归的返回值
每处理一个节点，首先获取左子树和右子树所返回的链表，然后拼接

代码：

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

/* Problem: Convert a binary search tree into a sorted linkedlist */
/* When it comes to Tree-Structure, recursion is always the most common solution.
   When designing recursion solution, should consider:
       1. the parameters
       2(important). the return object
*/

struct Node {
    int value;
    struct Node *left;
    struct Node *right;
};

struct Node *
BTree2List(struct Node *root)
{
    if(root == NULL)
        return NULL;
    struct Node *ret = NULL;

    /* Convert the left tree into a sorted linkedlist */
    struct Node *l_linkedlist = BTree2List(root->left);
    ret = l_linkedlist==NULL ? root : l_linkedlist;

    /* Convert the right tree into a sorted linkedlist */
    struct Node *r_linkedlist = BTree2List(root->right);
    while(l_linkedlist && l_linkedlist->right)
        l_linkedlist = l_linkedlist->right;

    /* Combine */
    if(l_linkedlist)
        l_linkedlist->right = root;
    root->left = l_linkedlist;
    root->right = r_linkedlist;
    if(r_linkedlist)
        r_linkedlist->left = root;

    return ret;
}

int main(int argc, char** argv)
{
    struct Node a = {4, NULL, NULL};
    struct Node b = {8, NULL, NULL};
    struct Node c = {12, NULL, NULL};
    struct Node d = {16, NULL, NULL};
    struct Node e = {6, NULL, &b};
    struct Node f = {14, &c, NULL};
    struct Node g = {10, &e, &f};

    struct Node *ret = BTree2List(&g);
    while(ret && ret->right) {
        ret = ret->right;
    }

    while(ret) {
        printf("%d\n", ret->value);
        ret = ret->left;
    }

    return 0;
}

simplyzhao 2011-05-23 09:09 发表评论