面试问题1：给一个无序数组，找到其中位数。

问题描述：给一个无序数组，找到其中位数,并说出该算法的时间复杂度以及空间复杂度。

　　解题方法一：

　　　中位数：当数组元素个数为奇数n时，中位数=a[n/2]。当元素个数为偶数时，中位数=( a[n / 2] + a[ ( n + 1 ) / 2 ])

　按照这个中位数定义来求解。利用快速排序对数组进行排序，时间复杂度为O(nlogn) 空间复杂度为S(1); 之后的找到中位数所用时间复杂度为O(1) 空间复杂度为O(1)

　　解题方法二：

　　　　在了解方法二之前我们先来了解一下快速排序。对于快排算法，其中主元的选择对于数组的划分起到很大的影响，从而对于运行时间产生很大的影响。当主元不能很好地分割数组，即主元将数组分成一个子数组中有一个记录，而另一个子组组有 n -1 个记录时，下一次的子数组只比原来数组小 1，这是快速排序的最差的情况。如果这种情况发生在每次划分过程中，那么快速排序就退化成了冒泡排序，其时间复杂度为O(n²)。老师曾经举过一个例子：甲、乙两同学去比较各自排序算法的好坏，他们可以互相阅读对方的原代码，然后互相给对方提供无序数组，最后比较那个运行比较快。乙同学看到甲同学的快排的代码，乙同学针对甲同学的代码专门写了所谓的无序数组（并非无序数组，只是甲同学的代码在解决这个无序数组的排序中会退化成冒泡排序）。然而甲同学看到乙同学的快排代码之后就老老实实的给了无序数组。为什么甲同学没有去找针对于乙同学的那个能够导致退化的无序数组呢？原因就是乙同学的快排主元的选择是随机化的。

随机化排序代码：

#include<stdio.h>
#include<stdlib.h>
int partition(int *a,int p,int r);
int random_partition(int *a,int p,int r);
int random_select(int *a,int p,int r,int i);
int main()
{

system("pasue");
return 0;
}
int partition(int *a,int p,int r)
{
    int x=a[r],t;
    int i=p-1,j;
    for(j=p;j<=r-1;j++)
    {
        if(a[j]<=x)//如果要降序排列，则改为if(a[j]>=x)
        {
            i++;
            t=a[i];
            a[i]=a[j];
            a[j]=t;
        }
    }
    t=a[i+1];
    a[i+1]=a[r];
    a[r]=t;
    return i+1;
}
int random_partition(int *a,int p,int r)
{
    int t,i;
    i=p+(int)((r-p+1)*rand()/(RAND_MAX+1.0));//利用随机数随机选择用于分割的元素，注意范围
    t=a[i];
    a[i]=a[r];
    a[r]=t;
    return partition(a,p,r);
}
int random_select(int *a,int p,int r,int i)//找出a[p]——a[r]之间第i小的元素
{
    int q;
    if(p==r)
        return a[p];
    q=random_partition(a,p,r);
    int k=q-p+1;
    if(i==k)
        return a[q];
    else if(i<k)
        return random_select(a,p,q-1,i);
    else
        return random_select(a,q+1,r,i-k);
}

线性时间选择算法：
含义：是解决选择问题的分治算法
与快速排序不同的是：快排递归处理划分的两边，而线性选择只对其中
的一个部分进行处理
时间复杂度:O(n)
实现：需要用到随机划分函数
主要的过程好似：A[p...r]通过随机划分函数得到枢轴q
根据划分的两个区间A[p...q-1],A[q],A[q+1...r]
然后判断<=A[q]的元素数量k=q-p+1 与 需要寻找的第i小的关系
如果 k == i,直接返回A[q]
如果 k > i，说明第i小的元素只可能在区间A[p...q-1]中
如果 k < i ,说明第i小的元素在区间A[q+1...r]中 ，并且问题转化为在A[q+1...r]中寻找第i-k小的元素

参考代码：

#include <iostream>
#include <stdlib.h>
#include <stdlib.h>

using namespace std;

//返回iMin~iMax中的任意数字
int myrandom(int iMin,int iMax)
{
    // 3~6,6-3=3 ，
    int iResult = rand() % (iMax - iMin + 1) + iMin;
    return iResult;
}

void swap(int* pArr , int p , int q)
{
    int iTemp = pArr[p];
    pArr[p] = pArr[q];
    pArr[q] = iTemp;
}

int randomPartition(int* pArr,int iLow ,int iHigh)
{
    int iRand = myrandom(iLow , iHigh);
    swap(pArr , iRand , iLow);
    int iPivot = pArr[iLow];
    //下面就是快排的枢轴划分
    while(iLow < iHigh)
    {
        while(iLow < iHigh && pArr[iHigh] >= iPivot)
        {
            iHigh--;
        }
        pArr[iLow] = pArr[iHigh];
        while(iLow < iHigh && pArr[iLow] <= iPivot)
        {
            iLow++;
        }
        pArr[iHigh] = pArr[iLow];
    }
    pArr[iLow] = iPivot;
    return iLow;
}

int randomizedSelect(int* pArr,int p ,int r,int i)
{
    if(p == r)
    {
        return pArr[p];
    }
    int q = randomPartition(pArr, p ,r);
    int k = q - p + 1;
    if(i == k)
    {
        return pArr[q];
    }
    //在低区间
    else if(i < k)
    {
        int iResult = randomizedSelect(pArr, p , q-1 ,i);
        return iResult;
    }
    else
    {
        int iResult = randomizedSelect(pArr , q + 1 , r , i - k);
        return iResult;
    }
}

void process()
{
    int n,u;
    while(cin >> n >> u)
    {
        int* pArr = new int[n];
        for(int i = 0; i < n ; i++)
        {
            cin >> pArr[i];
        }
        int iResult = randomizedSelect(pArr, 0 , n -1 , u);
        cout << iResult << endl;
        delete[] pArr;
    }
}

int main(int argc,char* argv[])
{
    process();
    getchar();
    return 0;
}