算法面试题

近期面试，下面这些是经常被问到的数据结构算法的内容，虽然一般工作中用的不多，但随着系统开发扩展下去，服务器并发量上来了或者服务器中数据扭转过多，性能瓶颈也越来越明显，设计适当的数据结构的优势就显现出来了。下面几道是非常基础的题目，想了解算法，祥看《算法导论(第三版)》

 

1.冒泡

void BubbleSort(int arr[],int count)
{
    int temp=0;
    bool swapped=false;
    for(int i=1;i<count;i++)
    {
        swapped=false;
        for(int j=count-1;j>=i;j--)
        {
            if(arr[j-1]>arr[j])
            {
                temp=arr[j-1];
                arr[j-1]=arr[j];
                arr[j]=temp;

            }
            swapped=true;
        }

        if(!swapped)//本趟排序未发生交换，提前终止算法
            return;
    }
}

2.二分查找

int BinSearch(int *arr, int n , int key)
{
    int low = 0;
    int high = n-1;
    int mid;              
    if(arr[low] == key)
    {
        return 0;
    }

    while(low <= high)
    { 
        mid = low + ((high - low)/2);
        if(arr[mid] == key)
        {
            return mid;
        }

        if(arr[mid] > key)
            high = mid - 1; 
        else
            low = mid + 1;
    }
    return -1;
}

3.堆排序

 

4.快排

#include <stdio.h>
int a[100] = { 1, 2, 8, 7, 9, 5, 6, 4, 3, 66, 77, 33, 22, 11 };
 
/* 输出数组前n各元素*/
void prt(int n) {
    int i;
    for (i = 0; i < n; i++) {
        printf("%d\t", a[i]);
    }
    printf("\n");
}
 
/* 数据交换*/
void swap(int *a, int *b)
{
    int tmp;
    tmp = *a; *a = *b; *b = tmp;
}
 
void quick_sort(int a[], int left, int right)
{
    int i = left + 1, j = right;
    int  key = a[left];
 
    if (left >= right) return;
 
    /* 从i++和j--两个方向搜索不满足条件的值并交换 *
     * 条件为：i++方向小于key，j--方向大于key      */
    while (1) {
       while (a[j] > key) j--;
       while (a[i] < key&&i<j) i++;
       if(i >= j) break;
       swap(&a[i],&a[j]);
       if(a[i]==key)j--;
       else  i++;
    }
 
    /* 关键数据放到‘中间’*/
    swap(&a[left],&a[j]);
 
    if(left  < i - 1)   quick_sort(a, left, i - 1);
    if(j + 1 < right)  quick_sort(a, j + 1 , right);
 
}
 
int main(void) {
 
    /* 排序与输出*/
    quick_sort(a, 0, 13);
    prt(14);
 
    return 0;
}

 

5.编程判断两个链表是否相交

深信服面试的时候被问到这题，出自编程之美。

给出两个单向链表的头指针（如图所示），比如 h1、h2，判断这两个链表是否相交。这里为了简化问题，我们假设两个链表均不带环。

图链表相交示意图

问题分析：

1.如果相交，两个链表从第一个相交节点至尾节点都会相同；

2.如果相交，两个链表的尾节点相同

【解法】

先遍历第一个链表，记住最后一个节点。然后遍历第二个链表，到最后一个节点时和第一个链表的最后一个节点做比较，如果相同，则相交，否则，不相交。这样我们就得到了一个时间复杂度，它为 O((Length(h1) + Length(h2))，而且只用了一个额外的指针来存储最后一个节点。

7.扩展一点，上题只需要判断是否相交，那如何找出第一个相交节点呢？

答：

延续上题的思路，两个链表h1和h2相交，两个链表的长度分别为Length1和Length2，第一个相交节点离h1的距离为firstnode1，该节点离h2的距离为firstnode2，那么Length1 - firstnode1 == Length2 - firstnode2。假设Length1> Length2，那么遍历寻找节点时，长链表h1应该比短链表h2早出发Length1- Length2。

代码如下：

// 判断两个链表是否相交，并返回第一个相交节点

const ListNode* FirstCommonNode(const ListNode* listhead1, const ListNode* listhead2)
{
    if(listhead1 == NULL || listhead2 == NULL) 
        return NULL;

    int Length1 = 1,Length2 = 1;
    const ListNode* curhead1 = listhead1, *curB = listhead2;

    while(curhead1->next)
    {
        ++Length1; 
        curhead1 = curhead1->next;
    }

    while(curB->next)
    {
        ++Length2; 
        curB = curB->next;
    }

    if(curhead1 != curB) 
        return NULL;

    curhead1 = listhead1;
    curB = listhead2;
    if(Length1 > Length2)
    {
        for(int i = 0; i < Length1 - Length2; ++i)
            curhead1 = curhead1->next;
    }
    else
    {
        for(int i = 0; i< Length2 - Length1; ++i)
            curB = curB->next;
    }
    while(curhead1 && curhead1 != curB)
    {
        curhead1 = curhead1->next;
        curB = curB->next;
    }
    return curhead1;
}

8.判断单链表是否有环？

答：

设置两个指针(fast, slow)，初始值都指向头，slow每次前进一步，fast每次前进二步，如果链表存在环，则fast必定先进入环，而slow后进入环，两个指针必定相遇。(当然，fast先行头到尾部为NULL，则为无环链表)程序如下：

bool IsExitsLoop(slist *head)

{

    slist *slow = head, *fast = head;

    while ( fast && fast->next ) 

    {

        slow = slow->next;

        fast = fast->next->next;

        if ( slow == fast ) break;

    }

    return !(fast == NULL || fast->next == NULL);

}

当fast若与slow相遇时，slow肯定没有走遍历完链表，而fast已经在环内循环了n圈(1<=n)。假设slow走了s步，则fast走了2s步（fast步数还等于s 加上在环上多转的n圈），设环长为r，则：

2s = s + nr

s= nr

9.单链表反转

struct ListNode
{
    int nKey;
    ListNode* pNext;
};

void ReverseLink(ListNode *&pHead)
{
    if (NULL == pHead)
    {
        return;
    }
    ListNode *pNode = pHead;
    ListNode *Prev = NULL;
    ListNode *pNext = NULL;
    while (NULL != pNode)
    {
        pNext = pNode->pNext;
        if (NULL == pNext)
        {
            pHead = pNode;s
        }
        pNode->pNext = Prev;
        Prev = pNode;
        pNode = pNext;
    }
}

 

10.前序遍历二叉树，不递归和递归的实现

前序遍历：根节点->左子树->右子树

中序遍历：左子树->根节点->右子树

后序遍历：左子树->右子树->根节点

前序遍历的递归代码：

void preorder(bintree t)
{
    if(t)
    {
        printf("%c ",t->data);
        preorder(t->lchild);
        preorder(t->rchild);
    }
}

前序遍历的非递归代码：

#define SIZE 100
typedef struct seqstack{
    bintree data[SIZE];
    int tag[SIZE];   //为后续遍历准备的
    int top;     //top为数组的下标
}seqstack;

void push(seqstack *s,bintree t){

    if(s->top == SIZE){
        printf("the stack is full\n");
    }else{
        s->top++;
        s->data[s->top]=t;
    }
}

bintree pop(seqstack *s){
    if(s->top == -1){
        return NULL;
    }else{
        s->top--;
        return s->data[s->top+1];
    }
}

void preorder_dev(bintree t){
    seqstack s;
    s.top = -1;    
    if(!t){
        printf("the tree is empty\n");
    }else{
        while(t || s.top != -1){
            while(t){   
                printf("%c ",t->data);
                push(&s,t);
                t= t->lchild;
            }
            t=pop(&s);
            t=t->rchild;
        }
    }
}

11.一个类，实现栈的功能，具有push和pop操作？

答：

内核中定义了程序栈的空间大小，当然编译器也可以设置栈空间，也就是说栈是有大小限制的，那么我们在类中声明一个数组8K来实现这个栈， 然后成员变量数组进行操作push和pop，代码量也不大，这在腾讯视频的面试中出现过。

12.vector/list/map等的实现

答：

(1)vector是一个线性顺序结构。相当于数组,但其大小可以不预先指定,并且自动扩展。它可以像数组一样被操作,由于它的特性我们完全可以将vector看作动态数组。初始的空间大小可以预先指定也可以由vector 默认指定,这个大小即 capacity ()函数的返回值。当存储的数据超过分配的空间时vector 会重新分配 一块内存块,但这样的分配是很耗时的,在重新分配空间时它会做这样的动作。

优缺点：vector随机访问非常方便，想数组一样通过下标访问；当数据量大时候，插入和删除时性能低劣。

(2)list采用链表实现，链表的结构再熟悉不过，插入和删除非常方便。

(3)map采用红黑树实现，红黑树是一种自平衡二叉查找树，时间复杂度是O(logn)。

红黑树本身是二叉搜索树，同时它应该始终满足五个性质：

1.红黑树每个节点颜色非红即黑；

2.根节点颜色必须为黑色；

3.每个叶节点(指的NULL指针节点)颜色均为黑；

4.不可以出现相邻的两个红色节点；

5.对于每个节点，其左右子树中的黑色节点个数必须相等；

一棵正常的红黑树如下图(引自wiki)：

13.解决哈希冲突的方法

开放定址法

溢出区法

拉链法

http://zh.wikipedia.org/wiki/排序算法