2018春实习·美团一面

比较简单并且常规的两道算法题：

1.青蛙跳台阶问题

一只青蛙一次可以跳上 1 级台阶，也可以跳上2 级。求该青蛙跳上一个n 级的台阶总共有多少种跳法。

解：

即斐波那契数列

（用的别人的图）

方法一：递归

效率太低，时间复杂度为O(2^n)

int Kinds(int n)
{
if(n == 1) return 1;
else if(n == 2) return 2;
else return Kinds(n-1) + Kinds(n-2);
}

方法二：非递归

把之前算过的数据存储起来，时间复杂度O（n）

int Kinds(int n)
{
int n0 = 1, n1 = 2;

if(n == 1) return n0;
else if(n == 2) return n1;
else 
{
n = n-2;
while(n--)
{
n1 = n0 + n1;
n0 = n1 - n0;
}
}
return n1;
}

2.用快速排序的方法得到数组第K大的数

快速排序的时间复杂度为O(nlogn)

此处摘自https://www.cnblogs.com/GODYCA/archive/2013/01/02/2842297.html

和我在面试时写的基本一样，但源代码有几个问题，我进行了修改

1）Sort函数中的if语句应改为while

2）QuickSort_K_MAX中与k比较的语句应改为与k-1比较，因为数组中是下标大小

3）在main函数中调用QuickSort_K_MAX函数时传递的最后一个参数应该就是k，而不是len-k

以下为修改后代码，已验证

#include <stdio.h>
#define length(array) sizeof(array)/sizeof(array[0])
#define true 1
#define false 0


int Sort(int *a, int low, int high)
{
    int pivot = a[low]; //这里每次的枢纽元素都取了待排数组的第一个元素，记住是a[low],而不是a[0]
    while(low < high)  //时间复杂度是O(n),n是数组长度
    {
        while(a[high] >= pivot && low < high) high --;
        a[low] = a[high];
        while(a[low] <= pivot && low <high) low ++;
        a[high] = a[low];
    }
    a[low] = pivot;
    return low;
}


int QuickSort_K_MAX(int *a, int low, int high, int k)
{
    if(low >= high)
        return a[low];
    else
    {
        int mid = Sort(a,low,high); //划分子递归数组
        if(mid > k-1)
            QuickSort_K_MAX(a,low,mid-1,k); //左递归
        else if(mid < k-1)
            QuickSort_K_MAX(a,mid+1,high,k); //右递归，一旦右递归mid+1=high，将退化成冒泡，递归深度将变成n，n为数组长度
        else
            return a[mid];
    }
}


int main()
{
    int a[10] = {10,7,8,6,3,1,5,2,4,9};
    int k =8;
    int len = length(a);
    printf("%d",QuickSort_K_MAX(a,0,len-1,k));
    return 0;
}