12年7月1日某搜索面试题

1. 如何用虚函数实现多态

class A
{
public:
    virtual void print()
    {
        cout<<"THIS IS A"<<endl;
    }
};
class B:public A
{
public:
    void print()
    {
        cout<<"THIS IS B"<<endl;
    }
};
int main()
{
    A a;
    B b;
    A* p1 = &a;
    A* p2 = &b;
    p1->print();
    p2->print();
    return 0;
}

2. 给定一个升序单链表和一个降序单链表，将两个链表合并成升序单链表

  思路： 首先将降序的单链表进行逆置，逆置算法的复杂度是O(n); 逆置之后，就变成两个升序单链表的合并，复杂度也是O(n).

  代码：这里说一下需要考虑边界问题（判断链表是否为空），代码中没有写。

Node* fanxu(Node* p)         //对单链表逆置
{
    Node *r,*q;
    q = NULL;                 //q用来保存后缀 初始为NULL
    r = NULL;                 //r用来保存前缀 初始为NULL
    while (p != NULL)         
    {
        q = p->next;          //q设为后缀
        p->next = r;          //将p的后指针指向前缀 逆置
        r = p;                //
        p = q;                // r p后移
    }
    return r;
}

Node* comb(Node *h1,Node *h2)
{
    Node* temp = NULL;            //保存返回的头指针
    Node* head = NULL;            //记录当前指针
    if (h1->val < h2->val)        //选取起始点作为合并后头指针
    {
        head = h1;
        h1 = h1->next;
    }
    else
    {
        head = h2;
        h2 = h2->next;
    }
    temp = head;                   //保存头指针位置
    while (h1 != NULL &&h2 != NULL) //当两个链表都不为空
    {
        if (h1->val < h2->val)     //将较小的插入
        {
            head->next = h1;
            h1 = h1->next;
        }
        else
        {
            head->next = h2;
            h2 = h2->next;
        }
        head = head->next;
    }
    if (h1 != NULL)          //若h1不为空 h2为空
    {
        head->next = h1;      
    }
    else                      //若h2不为空 h1为空
    {
        head->next = h2;
    }
    return temp;
}

3. 给定一个数组{...a_i,...,a_j...},求max（a_i-a_j）,其中i<j. 并且要求得相应max（a_i-a_j）中的a_i与a_j。

  思路：遍历一边的算法是：第一遍，标记出每个a_i之后的min(aj); 遍历a_i-min(aj)的差值，找出最大者。 O(n)时间复杂度

  代码：

    const int num = 6;                            //数组数目
    int arr[num];
    for (int i = 0 ; i < num;++i)
    {
        arr[i] = rand()%20;
        cout<<arr[i]<<' ';
    }
    cout<<endl;
    int minn[num - 1];                             //保存排在每个数之后的最小的数的下标
    minn[num - 2] = num - 1;                       //倒数第二个数之后的最小数只能是最后一个数
    int pos = num - 2;                                           //最大差值对应大数的下标
    int maxx = arr[num - 2] - arr[num - 1];                //最大差值 
    for (int i = num - 3;i >= 0;--i)               //从倒数第三个数开始
    {
        minn[i] = arr[i + 1]>arr[minn[i + 1]]?minn[i + 1]:i + 1;  //找到排在其之后的最小数的下标
        if (arr[i] - arr[minn[i]] > maxx)                       //当前数减去其对应最小数差值更大
        {
            maxx = arr[i] - arr[minn[i]];                       //替换
            pos = i;
        }
    }
    cout<<"MAX = "<<arr[pos]<<" - "<<arr[minn[pos]]<<" = "<<maxx<<endl;