微软、谷歌、百度等公司经典面试100题[第1-60题]——自己的实现[转]

原文链接：http://blog.csdn.net/v_JULY_v/archive/2011/03/09/6234496.aspx

1、有一个整数数组，请求出两两之差绝对值最小的值,
记住，只要得出最小值即可，不需要求出是哪两个数

 

#include <iostream>
#include <cassert>
#include <ctime>
#include <iterator>
using namespace std;
/************************************************************************/
/* 函数功能：有一个整数数组，请求出两两之差绝对值最小的值
    思路：两个for循环，记录每次的最小值,复杂度为o(N)
*/
/************************************************************************/
int GetMinDiff(int arr[], int length)
{
    assert(length >=2 );
    int min = abs(arr[1] - arr[0]);
    for (int i=0; i<length-1; i++)
    {
        for (int j=i+1; j<length; j++)
        {
            if(abs(arr[j] - arr[i]) < min)
                min = abs(arr[j] - arr[i]);
        }
    }
    return min;
}
/************************************************************************/
/* 方法2：先对数组排序（快速排序）,然后求两两差值的最小值，复杂度为O(lgN + N)* /
/************************************************************************/
int cmp(const void *a, const void *b)
{
    return *(int *)a - *(int *)b;
}
int GetMinDiff2(int arr[], int length)
{
    qsort(arr, 10, sizeof(arr[0]), cmp);
    assert(length >= 2);
    int min = abs(arr[1] - arr[0]);
    for (int i=3; i<length; i++)
    {
        if (abs(arr[i] - arr[i-1]) < min)
            min = abs(arr[i] - arr[i-1]);
    }
    return min;
}
int main()
{
    int arr[10];
    srand((unsigned int)time(NULL));
    for(int i=0; i<10; i++)
        arr[i] = rand()%100;
    copy(arr, arr+10, ostream_iterator<int>(cout, " "));
    cout<<endl;
    int minDiff = GetMinDiff(arr, 10);
    cout<<minDiff<<endl;
    minDiff = GetMinDiff(arr, 10);
    cout<<minDiff<<endl;
}

 

 

2、写一个函数，检查字符是否是整数，如果是，返回其整数值。
（或者：怎样只用4行代码编写出一个从字符串到长整形的函数）

http://blog.csdn.net/cadcisdhht/archive/2011/02/21/6197041.aspx

 

 

3、给出一个函数来输出一个字符串的所有排列。

 

#include <iostream>
#include <cassert>
#include <ctime>
#include <iterator>
using namespace std;
void swap(char *str, int i, int j)
{
    char temp = str[i];
    str[i] = str[j];
    str[j] = temp;
}
/************************************************************************/
/* 函数功能：递归求全排列                                               */
/************************************************************************/
void GetQuanPaiLie(char *str, int current, int length)
{
    if(current == length-1)
        cout<<str<<endl;
    else
    {
        for (int i=current; i<length; i++)
        {
            swap(str, current, i);
            GetQuanPaiLie(str, current+1, length);
            swap(str, current, i);
        }
    }
}
int main()
{
    char str[] = "abc";
    GetQuanPaiLie(str, 0, 3);
}

 

 

 

4、请编写实现malloc()内存分配函数功能一样的代码。 
给出一个函数来复制两个字符串A和B。字符串A的后几个字节和字符串B的前几个字节重叠。

http://lklkdawei.blog.163.com/blog/static/32574109200881445518891/

不会做！

 

 

5、怎样编写一个程序，把一个有序整数数组放到二叉树中？

6、怎样从顶部开始逐层打印二叉树结点数据？请编程。  

两题的答案下面代码！

 

#include <iostream>
#include <deque>
using namespace std;
struct TNode
{
    int element;
    TNode* left;
    TNode* right;
    TNode(int ele = 0, TNode* l = NULL, TNode* t= NULL)
        :element(ele), left(l), right(t){}
};
/************************************************************************/
/*函数功能：将一个有序整数数组放到二叉树中                              */
/************************************************************************/
TNode* ConvertArrayToBinaryTree(int arr[], int current, int legth)
{
    TNode *root = NULL;
    if (current < legth)
    {
        root = new TNode(arr[current]);
        if(2*current + 1 < legth)
            root->left = ConvertArrayToBinaryTree(arr, 2*current + 1, legth);
        if(2*current + 2 < legth)
            root->right = ConvertArrayToBinaryTree(arr, 2*current + 2, legth);
    }
    return root;
}
/************************************************************************/
/* 函数功能：从顶部开始逐层打印二叉树结点数据（借助队列实现）           */
/************************************************************************/
void levelOutPut(TNode* root)
{
    if(root == NULL)
        return;
    deque<TNode*> d;
    d.push_back(root);
    while(!d.empty())
    {
        cout<<d.front()->element<<" ";
        if(d.front()->left != NULL)
            d.push_back(d.front()->left);
        if (d.front()->right != NULL)
            d.push_back(d.front()->right);
        d.pop_front();
    }
}
int main()
{
    int arr[10];
    for (int i=0; i<10; i++)
        arr[i] = i+1;

    TNode *root = ConvertArrayToBinaryTree(arr, 0, sizeof(arr)/sizeof(arr[0]));
    cout<<"层次输出二叉树:"<<endl;
    levelOutPut(root);
    cout<<endl;
}

 

 

 

7、怎样把一个链表掉个顺序（也就是反序，注意链表的边界条件并考虑空链表）？

 

#include <iostream>
#include <deque>
using namespace std;
struct Node
{
    int element;
    Node* pNext;
    Node(int ele, Node *next = NULL)
    {
        element = ele;
        pNext = next;
    }
};
/************************************************************************/
/* 函数功能：构建单链表                                                 */
/************************************************************************/
 Node* BuildList(int arr[], int length)
 {
    Node* head = NULL; //头结点
    if(length > 0)
    {
        head = new Node(arr[0]);
        Node* curr = head;
        Node* newNode = NULL; //新创建的节点
        for (int i=1; i<length; i++)
        {
            newNode = new Node(arr[i]);
            curr->pNext = newNode;
            curr = newNode;
        }
    }
    return head;
 }
 //函数功能：输出单链表
 void PrintList(Node* head)
 {
     Node *temp  = head;
     while (temp != NULL)
     {
         cout<<temp->element<<" ";
         temp = temp->pNext;
     }
     cout<<endl;
 }
 //函数功能：反转单链表
 Node* ReverseList(Node* head)
 {
    if((head == NULL) || (head->pNext == NULL)) //0个或1个结点
        return head;

    Node* p = NULL;
    Node* tempHead = head;
    while (tempHead->pNext != NULL)
    {
        p = tempHead->pNext;
        tempHead->pNext = p->pNext;
        p->pNext = head;
        head = p;
    }
    return head;
 }
int main()
{
    int arr[10];
    for(int i=0; i<10; i++)
        arr[i] = i + 1;
    Node *head = BuildList(arr, 10);
    cout<<"反转前："<<endl;
    PrintList(head);
    cout<<"反转前："<<endl;
    head = ReverseList(head);
    PrintList(head);
}

 

 

 

8、请编写能直接实现int atoi(const char * pstr)函数功能的代码。

 

#include <iostream>
#include <cassert>
using namespace std;
int Myatoi(const char *pstr)
{
    assert(pstr != NULL); //判断不为空

    const char *temp = pstr;
    while (*temp == ' ') // 去除开头的空字符
        temp++;
    int result = 0;
    int flag = 1; // 正负值标志位
    if(*temp == '-') //若为负数
    {
        flag = -1;
        temp++;
    }
    while (*temp != '/0')
    {
        result = result * 10 + (*temp - '0');
        temp++;
    }
    return result * flag;
}
int main()
{
    const char* str1 = "1234";
    const char* str2 = "-567";
    const char* str3 = "  455";
    const char* str4 = "  -45677";
    cout<<Myatoi(str1)<<endl;
    cout<<Myatoi(str2)<<endl;
    cout<<Myatoi(str3)<<endl;
    cout<<Myatoi(str4)<<endl;
}

 

 

 

9、编程实现两个正整数的除法
编程实现两个正整数的除法，当然不能用除法操作符。
// return x/y.
int div(const int x, const int y) 
{
  ....
}

 

#include <iostream>
using namespace std;
/************************************************************************/
/* 函数功能：编程实现两个正整数的除法，当然不能用除法操作符             ×/
/************************************************************************/
int Mydiv(const int x, const int y)
{
    int result = 0;
    int temp = x;
    while (temp >= y)
    {
        result++;
        temp = temp - y;
    }
    return result;
}
int main()
{
    cout<<Mydiv(20, 4)<<endl;
    cout<<Mydiv(20, 7)<<endl;
}

 

 

 

 

10、在排序数组中，找出给定数字的出现次数
比如 [1, 2, 2, 2, 3] 中2的出现次数是3次。

 

#include <iostream>
using namespace std;
/************************************************************************/
/* 函数功能：在排序数组中，找出给定数字的出现次数
   比如 [1, 2, 2, 2, 3] 中2的出现次数是3次。
   陷阱：一个看到题，首先想到的方法是进行遍历统计，这样时间复杂度为O(N),
   但是题目明确说明是“排序数组”，所以使用二分查找的方法分别找出给定数字
   的开始和结束位置，最坏情况下时间复杂度为O(logn)。×/
/************************************************************************/
//函数功能：返回最后一个等于x的位置
int getUpper(int arr[], int length, int x)
{
    int low = 0;
    int high = length - 1;
    int mid = 0;
    while (low <= high)
    {
         mid = (low + high) / 2;
        if(arr[mid] <= x) //向后查找
            low = mid + 1;
        else
            high = mid - 1;
    }
    return high;
}
//函数功能：返回第一个等于x的位置
int getLower(int arr[], int length, int x)
{
    int low = 0;
    int high = length - 1;
    int mid = 0;
    while (low <= high)
    {
        mid = (low + high) / 2;
        if(arr[mid] >= x) //向前查找
            high = mid - 1;
        else
            low = mid + 1;
    }
    return low;
}
//函数功能：返回x的次数
int GetTimes(int arr[], int length, int x)
{
    int low = getLower(arr, length,  x);
    int high = getUpper(arr, length, x);
    return (high - low + 1);
}
int main()
{
    int arr[] = {1, 2, 2, 2, 3};
    cout<<GetTimes(arr, sizeof(arr)/sizeof(arr[0]), 2)<<endl;;
}

 

 

 

 

11、平面上N个点，每两个点都确定一条直线，
求出斜率最大的那条直线所通过的两个点（斜率不存在的情况不考虑）。时间效率越高越好。

不会！

 

 

12、一个整数数列，元素取值可能是0~65535中的任意一个数，相同数值不会重复出现。0是例外，可以反复出现。
请设计一个算法，当你从该数列中随意选取5个数值，判断这5个数值是否连续相邻。
注意：
- 5个数值允许是乱序的。比如： 8 7 5 0 6
- 0可以通配任意数值。比如：8 7 5 0 6 中的0可以通配成9或者4
- 0可以多次出现。
- 复杂度如果是O(n2)则不得分。

 

/************************************************************************/
/* 算法思想：
    1、找到非零最大值a，找到非零最小值b O（1）
    2，计算s=a-b O（1）
    3, s>4 则不连续相邻， s<=4 连续相邻 O（1）
    代价为O（1）                                                        */
/************************************************************************/

 

 

 

 

13、设计一个算法，找出二叉树上任意两个结点的最近共同父结点。
复杂度如果是O(n2)则不得分。

 

#include "stdafx.h"
#include <iostream>
#include <vector>
#include <deque>
#include <iterator>
using namespace std;
struct TNode
{
    int element;
    TNode* left;
    TNode* right;
    TNode(int ele = 0, TNode* l = NULL, TNode* t= NULL)
        :element(ele), left(l), right(t){}
};
/************************************************************************/
/*函数功能：将一个有序整数数组放到二叉树中                              */
/************************************************************************/
TNode* ConvertArrayToBinaryTree(int arr[], int current, int legth)
{
    TNode *root = NULL;
    if (current < legth)
    {
        root = new TNode(arr[current]);
        if(2*current + 1 < legth)
            root->left = ConvertArrayToBinaryTree(arr, 2*current + 1, legth);
        if(2*current + 2 < legth)
            root->right = ConvertArrayToBinaryTree(arr, 2*current + 2, legth);
    }
    return root;
}
/************************************************************************/
/*函数功能：输出根节点到给定节点pNode的路径                             */
/************************************************************************/
void PrintPath(TNode* root, vector<int> vec, TNode *pNode)
{
    if(root == NULL)
        return;
    TNode* temp = root;
    vec.push_back(temp->element);
    if(temp == pNode)
    {
        for(size_t i = 0; i < vec.size(); ++i)
            cout<<vec.at(i)<<" ";
        cout<<endl;
        return;
    }
    else
    {
        PrintPath(root->left, vec, pNode);
        PrintPath(root->right, vec, pNode);
    }
}
/************************************************************************/
/*函数功能：获取根节点到给定节点pNode的路径                             */
/************************************************************************/
void GetPath(TNode* root, vector<int> vec, TNode *pNode, vector<int>& path)
{
    if(root == NULL)
        return;
    TNode* temp = root;
    vec.push_back(temp->element);
    if(temp == pNode)
    {
        for (size_t i = 0; i < vec.size(); ++i)
            path.push_back(vec.at(i));
        return;
    }
    else
    {
        GetPath(root->left, vec, pNode, path);
        GetPath(root->right, vec, pNode, path);
    }
}
/************************************************************************/
/* 函数功能：出二叉树上任意两个结点的最近共同父结点                     */
/************************************************************************/
int GetCommonParentNode(TNode* root, TNode *node1, TNode* node2)
{
    vector<int> path1, path2, path;
    GetPath(root, path, node1, path1);
    GetPath(root, path, node2, path2);
    //找第一个不相同的节点
    size_t index1 = 0;
    size_t index2 = 0;
    while ((index2 < path2.size()) && (index1 < path1.size()))
    {
        if(path1.at(index1) != path2.at(index2))
            break;
        index2++;
        index1++;
    }
    return path1[index1 - 1];
}
int main()
{
    int arr[10];
    for (int i=0; i<10; i++)
        arr[i] = i+1;
    TNode *root = ConvertArrayToBinaryTree(arr, 0, sizeof(arr)/sizeof(arr[0]));

    TNode *pNode = root->left->left->right;
    vector<int> vec;
    PrintPath(root, vec, pNode);
    TNode *node1 = root->left->left->left;
    TNode *node2 = root->left->right;
    int res = GetCommonParentNode(root, node1, node2);
    cout<<res<<endl;
}

 

 

 

14、一棵排序二叉树，令 f=(最大值+最小值)/2，
设计一个算法，找出距离f值最近、大于f值的结点。
复杂度如果是O(n2)则不得分。

 

 

15、一个整数数列，元素取值可能是1~N（N是一个较大的正整数）中的任意一个数，相同数值不会重复出现。
设计一个算法，找出数列中符合条件的数对的个数，满足数对中两数的和等于N+1。
复杂度最好是O(n)，如果是O(n2)则不得分.

 

#include <iostream>
#include <cstdlib>
using namespace std;
/*
先排序，复杂度O（nlgn），然后用两个指示器（front和back）分别指向第一个和最后一个元素，
如果A[front]+A[back]>N+1，则back--；
如果A[front]+A[back]=N+1，则计数器加1，back--，同时front++；
如果A[front]+A[back] <N+1，则front++；
重复上述步骤，O（n）时间找到所有数对，总体复杂度为O（nlgn）
*/
//比较函数
int cmp(const void *a, const void *b)
{
    return *(int *)a - *(int *)b;
}
int GetCount(int arr[], int length)
{
    qsort(arr, length, sizeof(int), cmp);
    int count = 0;
    int low = 0;
    int high = length - 1;
    int N = arr[high];
    while(low <= high)
    {
        if(arr[low] + arr[high] < N+1)
            low++;
        else if (arr[low] + arr[high] > N+1)
            high--;
        else
        {
            count++;
            cout<<arr[low]<<" "<<arr[high]<<endl;
            low++;
            high--;
        }
    }
    return count;
}
int main()
{
    int arr[] = {4, 5, 7, 8, 9, 1, 10, 13, 16};
    int length = sizeof(arr) / sizeof(arr[0]);
    int num = GetCount(arr, length);
    cout<<"个数为: "<<num<<endl;
}

 

 

 

---

---

谷歌八道面试题

16、正整数序列Q中的每个元素都至少能被正整数a和b中的一个整除，现给定a和b，需要计算出Q中的前几项，例如，当a=3，b=5，N=6时，序列为3，5，6，9，10，12
(1)、设计一个函数void generate（int a,int b,int N ,int * Q）计算Q的前几项
(2)、设计测试数据来验证函数程序在各种输入下的正确性。

 

#include <iostream>
#include <iterator>
#include <cassert>
using namespace std;
void generate(int a, int b, int N, int * Q)
{
    int num = 0; //计数
    int index = 1;
    while (num < N)
    {
        if ((index%a == 0) || ( index%b == 0)) //若index满足条件。放到数组Q
        {
            Q[num++] = index;
        }
        index++;
    }
}
int main()
{
    int N = 6;
    int *arr = new int[N];
    generate(3, 5, 6, arr);

    copy(arr, arr+N, ostream_iterator<int>(cout, " "));
    cout<<endl;
}

 

 

 

 

17、有一个由大小写组成的字符串，现在需要对他进行修改，将其中的所有小写字母排在答谢字母的前面（大写或小写字母之间不要求保持原来次序），如有可能尽量选择时间和空间效率高的算法 c语言函数原型void proc（char *str） 也可以采用你自己熟悉的语言

 

#include <iostream>
#include <iterator>
#include <cassert>
using namespace std;
void proc(char *str)
{
    assert(str != NULL);
    int length = strlen(str);
    char *begin = str;
    char *end = str + length - 1;
    while(begin < end)
    {
        while (islower(*begin))
            begin++;
        while (isupper(*end))
            end--;
        char temp = *begin;
        *begin = *end;
        *end = temp;
        begin++;
        end--;
    }
}
int main()
{
    char str[] = "aDsfGGrr";
    proc(str);
    cout<<str<<endl;
}

 

 

 

18、如何随机选取1000个关键字
给定一个数据流，其中包含无穷尽的搜索关键字（比如，人们在谷歌搜索时不断输入的关键字）。如何才能从这个无穷尽的流中随机的选取1000个关键字？

      定义长度为1000的数组。
　　对于数据流中的前1000个关键字，显然都要放到数组中。
　　对于数据流中的的第n(n>1000)个关键字，我们知道这个关键字被随机选中的概率为 1000/n。所以我们以 1000/n 的概率用这个关键       字去替换数组中的随机一个。这样就可以保证所有关键字都以 1000/n的概率被选中。
　　对于后面的关键字都进行这样的处理，这样我们就可以保证数组中总是保存着1000个随机关键字。

 

19、判断一个自然数是否是某个数的平方
说明：当然不能使用开方运算。

假设待判断的数字是 N。

方法1：
遍历从1到N的数字，求取平方并和N进行比较。
如果平方小于N，则继续遍历；如果等于N，则成功退出；如果大于N，则失败退出。
复杂度为O(n^0.5)。

方法2：
使用二分查找法，对1到N之间的数字进行判断。
复杂度为O(log n)。

方法3：
由于
(n+1)^2 
=n^2 + 2n + 1，
= ...
= 1 + (2*1 + 1) + (2*2 + 1) + ... + (2*n + 1)
注意到这些项构成了等差数列（每项之间相差2）。
所以我们可以比较 N-1， N - 1 - 3， N - 1 - 3 - 5 ... 和0的关系。
如果大于0，则继续减；如果等于0，则成功退出；如果小于 0，则失败退出。
复杂度为O(n^0.5)。不过方法3中利用加减法替换掉了方法1中的乘法，所以速度会更快些。

 

21、1024! 末尾有多少个0？

 

末尾0的个数取决于乘法中因子2和5的个数。显然乘法中因子2的个数大于5的个数，所以我们只需统计因子5的个数。
是5的倍数的数有： 1024 / 5 = 204个
是25的倍数的数有：1024 / 25 = 40个
是125的倍数的数有：1024 / 125 = 8个
是625的倍数的数有：1024 / 625 = 1个
所以1024! 中总共有204+40+8+1=253个因子5。
也就是说1024! 末尾有253个0。 

 

 

23、Google2009华南地区笔试题
给定一个集合A=[0,1,3,8](该集合中的元素都是在0，9之间的数字，但未必全部包含)，
指定任意一个正整数K，请用A中的元素组成一个大于K的最小正整数。

比如，A=[1,0] K=21 那么输出结构应该为100。

 

 

这个问题,应该逼近法
数组 数组biaozhi[0..9] biaozhi[i]=true 则表示i包含在集合中,0<=i<=9;
从整数k的高位往底位判断
  设k当前位的数值为i,
  if biaozhi[i]=true
  {
  进行下一位判断;
  }
  else //biaozhi[i]=false
  {
  当集合中有比i大的值记为m,则 把k的当前位用m代替,从k位下一位往个位用集合中最小值填充
  当集合中没有比i大的值,则从k的上1位回溯
  }  

 

 

// Google.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <iostream>
#include <set>
#include <stack>
#include <list>
using namespace std;
int GetMinK(set<int> inputSet, int K)
{
    //求整数K的位数，并将每一位存储到stack中
    int n = 0;
    stack<int> s;
    while (K != 0)
    {
        n++;
        s.push(K%10);
        K /= 10;
    }
    list<int> result;
    for (int i=0; i<n; i++)
    {
        while (!s.empty() && inputSet.find(s.top()) != inputSet.end()) //集合中存在整数第i位(高位为第0位)的元素值
        {
            result.push_back(s.top());
            s.pop();
        }
        if (s.empty() == true) //若各位都在集合inputSet中
        {
            set<int>::iterator iter;
            while (!result.empty())
            {
                iter = inputSet.upper_bound(result.back());
                while (!result.empty() && iter == inputSet.end())
                {
                    result.pop_back();
                    iter = inputSet.upper_bound(result.back());
                }
                if(!result.empty())
                {
                    result.pop_back();
                    result.push_back(*iter);
                    for (int j= result.size(); j<n; j++)
                        result.push_back(*inputSet.begin());
                    break;
                }
                if(result.empty())
                {
                    iter = inputSet.upper_bound(0);
                    result.push_back(*iter);
                    for(int j=0; j<n; j++)
                        result.push_back(*inputSet.begin());
                    break;
                }
            }
        }
        else
        {
            if (inputSet.find(s.top()) == inputSet.end()) //集合中不存在整数第i位(高位为第0位)的元素值
            {
                set<int>::iterator iter = inputSet.lower_bound(s.top());
                if (iter != inputSet.end()) //集合中存在比整数第i位(高位为第0位)大的元素值
                {
                    result.push_back(*iter);
                    for (int j=i+1; j<n; j++)
                        result.push_back(*inputSet.begin());
                    break;
                }
                if (iter == inputSet.end()) //集合中不存在比整数第i位(高位为第0位)大的元素值
                {
                    if(result.empty() == true) //若第一位不存在集合中
                    {
                        iter = inputSet.upper_bound(0);
                        result.push_back(*iter);
                        for(int j=0; j<n; j++)
                            result.push_back(*inputSet.begin());
                        break;
                    }
                    else
                    {
                        while(!result.empty()) //进行回退
                        {
                            iter  = inputSet.upper_bound(result.back());
                            if(iter == inputSet.end())
                            {
                                result.pop_back(); i--;
                            }
                            else
                            {
                                result.pop_back();
                                result.push_back(*iter);
                                for (int j=i+1; j<n; j++)
                                    result.push_back(*inputSet.begin());
                                break;
                            }
                        }
                        break;
                    }
                }
            }
        }
    }
    if (s.empty() == true)
    {
    }
    int res = 0;
    while (!result.empty())
    {
        res = res * 10 + result.front();
        result.pop_front();
    }
    return res;
}
int _tmain(int argc, _TCHAR* argv[])
{
    set<int> s;
    s.insert(1);
    s.insert(0);
    int res = GetMinK(s, 21);
    cout<<res<<endl;
    return 0;
}

 

 

 

 

 

 

26、有一根27厘米的细木杆，在第3厘米、7厘米、11厘米、17厘米、23厘米这五个位置上各有一只蚂蚁。
木杆很细，不能同时通过一只蚂蚁。开始时，蚂蚁的头朝左还是朝右是任意的，它们只会朝前走或调头，但不会后退。
当任意两只蚂蚁碰头时，两只蚂蚁会同时调头朝反方向走。假设蚂蚁们每秒钟可以走一厘米的距离。

编写程序，求所有蚂蚁都离开木杆的最小时间和最大时间。

 

 

 

解析：可以采用鬼魂算法，鬼魂的意思就是“传递能量”，“穿透”。

首先判断最靠近中间点的蚂蚁，用程序很好判断，就是11厘米处的蚂蚁，其实这个蚂蚁，最快的时间就是最小时间。

其次判断最靠外面的蚂蚁，用程序很好判断，就是3厘米处的蚂蚁，其实这个蚂蚁，最慢的时间就是最大时间。

其他蚂蚁无视就可以了。

答案：最大时间是27-3=24，最小时间是11-0=11。

 

 

---

---

---

雅虎三道面试题

34、编程实现：把十进制数(long型)分别以二进制和十六进制形式输出，不能使用printf系列

 

#include "stdafx.h"
#include <iostream>
using namespace std;
/************************************************************************/
/* 函数功能：把十进制数(long型)分别以二进制                             */
/************************************************************************/
void LongTo2(long n)
{
    if(0 == n)
        return;
    else
    {
        LongTo2(n/2);
        cout<<n%2;
    }
}
/************************************************************************/
/* 函数功能：把十进制数(long型)分别以16进制                             */
/************************************************************************/
const char arr[16] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                      'A', 'B', 'C', 'D', 'E', 'F'};
void LongTo16(long n)
{
    if(0 == n)
        return;
    else
    {
        LongTo16(n/16);
        cout<<arr[n%16];
    }
}
int main()
{
    LongTo2(56);
    cout<<endl;
    LongTo16(256);
    cout<<endl;
}

 

 

 

35、编程实现：找出两个字符串中最大公共子字符串,如"abccade","dgcadde"的最大子串为"cad"

 

#include "stdafx.h"
#include <iostream>
using namespace std;
/************************************************************************/
/* 函数功能：找出两个字符串中最大公共子字符串,如"abccade","dgcadde"的最大
             子串为"cad"*/
/************************************************************************/
void GetMaxCommonSubString(const char *str1, const char *str2, char* &subString)
{
    int length1 = strlen(str1);
    int length2 = strlen(str2);
    int max = 0; //存储最大值
    int start = 0;//最大公共字串在str1中开始的位置
    for (int i=0; i<length1; i++)
    {
        for (int j=0; j<length2; j++)
        {
            int temp1 = i; //每次查找的开始位置
            int temp2 = j;
            int number = 0; //统计个数
            while ((str1[temp1] == str2[temp2]) && (temp2 < length2) && (temp1 < length1)) //开始找公共字串
            {
                number++;
                temp1++;
                temp2++;
            }
            if (number > max) //判断是否是最大的
            {
                max = number;
                start = i;
            }
        }
    }
    strncpy(subString, str1 + start, max); //拷贝到subString中
}
int main()
{
    const char* str1 = "abccade";
    const char* str2 = "dgcadde";
    int length = (strlen(str1) <= strlen(str2) ? strlen(str1) : strlen(str2));
    char *str = new char[length];
    memset(str, '/0', length+1);
    GetMaxCommonSubString(str1, str2, str);
    cout<<str<<endl;
}

 

 

 

 

38、顺时针打印矩阵
题目：输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
例如：如果输入如下矩阵：

1              2              3              4
5              6              7              8
9              10             11             12
13             14             15             16
则依次打印出数字1, 2, 3, 4, 8, 12, 16, 15, 14, 13, 9, 5, 6, 7, 11, 10。

分析：包括Autodesk、EMC在内的多家公司在面试或者笔试里采用过这道题。

 

#include <iostream>
using namespace std;
/************************************************************************/
/*函数功能：顺时针打印矩阵，m表示矩阵的行，n表示矩阵的列                */
/************************************************************************/
void PrintMatrix(int **matrix, int m, int n)
{
    int numbers = m * n;
    int num = 0;
    for (int i=0; i<=m/2; i++)
    {
        for (int j=i; j<n-i; j++, num++)
            printf("%d ", matrix[i][j]); //打印上边的行

        for (int k=i+1; k<m-i-1; k++, num++)
        {
            if(num >= numbers)
                break;
            printf("%d ", matrix[k][n-i-1]); //打印右边的列
        }
        for (int j=n-i-1; j>=i; j--, num++)
        {
            if(num >= numbers)
                break;
            printf("%d ", matrix[m-i-1][j]); //打印下边的行
        }
        for(int k= m-i-2; k>i; k--, num++)
        {
            if(num > numbers)
                break;
            printf("%d ", matrix[k][i]); //打印左边的行
        }
    }
    printf("/n");
}
int main()
{
    int **matrix;
    const int M = 5;
    const int N = 4;
    matrix = new int*[M];
    for (int i=0; i<M; i++)
        matrix[i] = new int[N];
    int k = 1;
    for(int i=0; i<M; i++)
        for(int j=0; j<N; j++)
            matrix[i][j] = k++;

    PrintMatrix(matrix, M, N);
}

 

 

 

 

39、对称子字符串的最大长度
题目：输入一个字符串，输出该字符串中对称的子字符串的最大长度。
比如输入字符串“google”，由于该字符串里最长的对称子字符串是“goog”，因此输出4。

分析：可能很多人都写过判断一个字符串是不是对称的函数，这个题目可以看成是该函数的加强版。

 

 

 

 

#include <iostream>
#include <cassert>
using namespace std;
/************************************************************************/
/* 函数功能：判断low和high之间的字符串是否是对称的                      */
/************************************************************************/
bool isDuiChen(const char* low, const char* high)
{
    while (low < high)
    {
        if (*low == *high)
        {
            low++;
            high--;
        }
        else
            return false;
    }
    return true;
}
/************************************************************************/
/* 函数功能：求字符串str中对称字符串的最大长度,result存放该字串         */
/************************************************************************/
int getMaxLength(const char* str, char* result)
{
    assert(str != NULL);
    int len = strlen(str);
    int max = 0;
    int start = 0;
    for (int i=0; i<len-1; i++)
    {
        for (int j= i+1; j<len; j++)
        {
            if (isDuiChen(str+i, str+j))
            {
                if((j - i + 1) > max)
                {
                    max = j - i + 1;
                    start = i;
                }
            }
        }
    }
    strncpy(result, str + start, max);
    return max;
}
int main()
{
    const char *str = "googleyanggnay";
    int len = strlen(str);
    char *result = new char[len + 1];
    memset(result, '/0', len + 1);
    int max = getMaxLength(str, result);
    printf("最大的对称字串为：%s, 长度为: %d/n", result, max);
}

 

 

 

40、用1、2、2、3、4、5这六个数字，写一个main函数，打印出所有不同的排列，
如：512234、412345等，要求："4"不能在第三位，"3"与"5"不能相连.

 

#include <iostream>
using namespace std;
char result[7] = {'/0'};
void PrintSpecialPaiLie(char *str, int curPos, int n)
{
    if (curPos == n)
    {
        if ((str[3] != '4') && (strstr(str, "35") == NULL)) //对输出进行过滤
            printf("%s/n", str);
    }
    else
    {
        for (int i = curPos; i<n; i++)
        {
            swap(str[0], str[i]);
            PrintSpecialPaiLie(str, curPos + 1, n);
            swap(str[0], str[i]);
        }
    }
}
int main()
{
    char str[] = "122345";
    int N = sizeof(str) / sizeof(char) - 1; //减1是因为str中含有字符'/0';
    PrintSpecialPaiLie(str, 0, N);
}

 

 

 

 

48、找出数组中唯一的重复元素

1-1000放在含有1001个元素的数组中，只有唯一的一个元素值重复，其它均只出现一次．
每个数组元素只能访问一次，设计一个算法，将它找出来；不用辅助存储空间，
能否设计一个算法实现？

 

#include <iostream>
using namespace std;
/*
    算法思想：统计数组的全部元素之和sum，然后根据等差数列求出1到upperBound这些
    数字的和n，然后重复的数字为sum-n。
*/
int findDuplicateElement(int arr[], int upperBound)
{
    int sum = 0;
    for(int i = 0; i < upperBound + 1 ; i++)
        sum += arr[i];
    return sum - (1 + upperBound) * upperBound / 2;
}
int main()
{
    const int NUMBERS = 1001;
    int arr[NUMBERS];

    for(int i = 0; i < NUMBERS; ++i)
        arr[i] = i + 1;

    arr[NUMBERS - 1] = 520;  //设定重复元素

    int result = findDuplicateElement(arr, NUMBERS - 1);
    cout<<"重复元素为: "<<result<<endl;

}

 

 

 

50、一道SPSS笔试题求解

题目：输入四个点的坐标，求证四个点是不是一个矩形
关键点：
1.相邻两边斜率之积等于-1，
2.矩形边与坐标系平行的情况下，斜率无穷大不能用积判断。
3.输入四点可能不按顺序，需要对四点排序。

 

// ww.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <iostream>
#include <algorithm>
using namespace std;
//向量的类
struct Vector
{
    int x;
    int y;
    Vector(){}
    Vector(int _x, int _y)
    {
        x = _x; y = _y;
    }
    bool operator* (const Vector& other) //定义两个向量相乘
    {
        if((x * other.x + y * other.y) == 0)
            return true;
        return false;
    }
};
//点的类
struct Point
{
    int x;
    int y;
    Point(){}
    Point(int _x, int _y)
    {
        x = _x; y = _y;
    }
    Vector operator- (const Point& other) //定义两个点相减
    {
        return Vector(other.x - x, other.y - y);
    }
};
bool cmp(const Point& lv, const Point& rv)
{
    return ((lv.x < rv.x) || (lv.x == rv.x && lv.y < rv.y));
}
//判断四个点是否构成矩形
bool IsRectangle(Point arr[4])
{
    sort(arr, arr + 4, cmp);
    Vector v01 = arr[1] - arr[0];
    Vector v03 = arr[2] - arr[0];
    if(v03 * v01 == false)
        return false;
    Vector v21 = arr[0] - arr[1];
    Vector v23 = arr[3] - arr[1];
    if(v21 * v23 == false)
        return false;
    Vector v32 = arr[0] - arr[2];
    Vector v34 = arr[3] - arr[2];
    if(v32 * v34 == false)
        return false;
    Vector v41 = arr[1] - arr[3];
    Vector v43 = arr[2] - arr[3];
    if (v41 * v43 == false)
        return false;

    return true;
}
int _tmain(int argc, _TCHAR* argv[])
{
    Point arr[4] = {Point(1, 0), Point(0, 6), Point(-1, 0), Point(0, -1)};
    if (IsRectangle(arr))
        cout<<"是矩形"<<endl;
    else
        cout<<"不是矩形"<<endl;
    return 0;
}

 

 

 

 

取值为【1，n-1】含n个元素的整数数组至少存在一个重复数，O（n）时间内找出其中任意一个重复数

 

// ww.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <iostream>
#include <algorithm>
using namespace std;
/*
取值为【1，n-1】含n个元素的整数数组至少存在一个重复数，O（n）时间内找出其中任意一个重复数
*/
/*
思路分析：
1、如果数组中有且仅有一个重复数，可以简单的通过S(A)=(n-1)*n/2得到重复数，其中S(A)表示对数组A求和
2、仿链表中找环的思路解决至少含一个重复数的问题
*/
int GetRepeatNumber(int arr[], int n)
{
    int x = 0, y = 0;
    do
    {
        x = arr[arr[x]];
        y = arr[y];
    } while (x != y);
    return arr[x];
}
int main()
{
    int arr[10] = {1, 4, 3, 5, 4, 5, 5, 4, 8, 9};
    cout<<"重复的数字为："<<GetRepeatNumber(arr, 10)<<endl;
}