排序相关面试题总结

1. 旋转数组中的最小元素如{3，4，5，1，2}，就是{1，2，3，4，5}左旋两个得到，因为数组可以分为两个递增的部分，左边大于右边，用二分法的思想，中间元素如5大于2，说明5在左边部分，最小元素在右半部分，缩小区间到{5, 1, 2}之间。时间复杂度为O(logN).
   注：如果左边元素与右边元素中间元素相同，需要另外处理。如{1，1，1，0，1}和{1，0，1，1，1}都是旋转数组，无法用二分法判断。

int  _Min(int *arr, int left, int right)
{
    if (NULL == arr || left < 0 || right < 0 || left > right)
        throw new exception("参数错误");
    for (int i = left+1; i <= right; ++i)
    {
        if (arr[left] > arr[i])
            arr[left] = arr[i];
    }
    return arr[left];
}

int Min(int *arr, int sz)
{
    if (NULL == arr || sz < 0)
        throw new exception("参数错误");
    int left = 0;
    int right = sz - 1;
    int mid = 0;
    while (arr[left] >=  arr[right])
    {
         mid = left + ((right - left) >> 1);
        if (right - left == 1)
        {
            arr[mid] = arr[right];
            break;
        }

        if (arr[left] == arr[right] &&
            arr[left] == arr[mid])
        {
            return _Min(arr, left, right);
        }
        else if (arr[mid] >= arr[right])
        {
            left = mid;
        }
        else
        {
            right = mid;
        }
    }
    return arr[mid];
}

2.数组中出现超过一半的数字
数组中超过一半的数字排序后一定位于数组的中间位置。但是全部排序耗费时间。
快速排序可以将数组分为两部分，左半部分小于等于关键值，右半部份大于等于关键值，当关键值恰好位于中间位置时，它就是要找的元素。
注：这种方法会改变数组的顺序

int partition(int *arr, int left, int right)
{
    int slow = left - 1;
    for (int fast = left; fast < right; ++fast)
    {
        if (arr[fast] < arr[right])
        {
            slow++;
            if (slow != fast)
                swap(arr[slow], arr[fast]);
        }
    }
    ++slow;
    swap(arr[slow], arr[right]);

    return slow;
}

bool invalied = false;

bool check(int *arr, int sz, int ret)
{
    int count = 0;
    for (int i = 0; i < sz; ++i)
    {
        if (arr[i] == ret)
            count++;
    }
    if (2 * count > sz)
    {
        invalied = true;
        return ret;
    }
    else return 0;
}

int MoreThanHalf(int *arr, int sz)
{
    if (NULL == arr || sz < 1)
        return 0;
    int index = partition(arr, 0, sz - 1);
    int left = 0;
    int right = sz - 1;
    int mid = (sz >> 1);
    while (index != mid)
    {
        if (index > mid)
            index = partition(arr, left, index - 1);
        else
            index = partition(arr, index + 1, right);
    }

    int ret =check (arr,sz,arr[mid]);
    return ret;

}

如果不希期忘改变顺序，可以用计数的方法，ret与下一次数相同加一，小于0更新ret。超过一半最后一定会留下。

int MoreThanHalf_2(int *arr, int sz)
{
    invalied = false;
    if (NULL == arr || sz < 1)
        return 0;
    int result = arr[0];
    int times = 1;
    for (int i = 1; i < sz; ++i)
    {
        if (times == 0)
        {
            result = arr[i];
            times = 1;
        }
        else if (arr[i] == result)
            times ++ ;
        else 
            times--;
    }
    result = check(arr, sz, result);
    return result;
}

3.数组最小的K个数
方法与上一题相同，快速排序可以将数据分为两部分，小于关键值，大于关键值得，如果关键值下标恰好是K，前面的K个数就是要找的数。
注：会改变数据的顺序

void SmallKnum(int *arr, int sz, int K)
{
    if (NULL == arr || sz < K)
        return;
    int left = 0;
    int right = sz - 1;
    int index = partition_(arr, left, right);
    while (index != K)
    {
        if (index < K)
        {
            left = index + 1;
            index = partition_(arr, left, right);
        }
        else
        {
            right = index - 1;
            index = partition_(arr, left, right);
        }
    }

    for (int i = 0; i < index; ++i)
        cout << arr[i] << " ";
    cout << endl;
}

用multiset（底层红黑树，可以报存相同的元素）/大堆， 保存K个最小值，有值小于multiset中的最大值时，更新。
这里用multiset实现：

typedef multiset<int, greater>  Set;
typedef multiset<int, greater>::iterator Setit;

void SmallKnum_(int *arr, int sz, int K)
{
    if (NULL == arr || sz < 1 || sz < K)
        return;
    Set myset;
    Setit it = myset.begin();
    for (int i = 0; i < sz; ++i)
    {

        if (myset.size() < K)
        {
            myset.insert(arr[i]);
        }
        else
        {
            Setit it  = myset.begin();
            if (arr[i] < *myset.begin())
            {
                myset.erase(it);
                myset.insert(arr[i]);
            }
        }
    }

    for (it = myset.begin() ; it != myset.end(); ++it)
        cout << *it << " ";
    cout << endl;

}

4.数组中的逆序对
用归并排序，先将数组分到最小，排序合并。

int _InverseMerge(int *arr, int *copy, int left, int right)
{
    if (left == right)
        return 0;
    int mid = (left + ((right - left) >> 1));   
    int leftPairs = _InverseMerge(arr, copy, left, mid);
    int rightPairs = _InverseMerge(arr, copy, mid+1, right);
    int end = right;
    int i = mid;
    int j = right;
    int Pairs = 0;
    while (left <= i && mid + 1 <= j)
    {
        if (arr[i] > arr[j])
        {
            Pairs += (j - mid);
            copy[right--] = arr[i];
            i--;
        }
        else
        {
            copy[right--] = arr[j];
            j--;
        }
    }
    if (left <= i) 
    {
        copy[right--] = arr[i--];
    }
    if (mid + 1 <= j)  
    {
        copy[right--] = arr[j--];
    }

    for (; left <= end; ++left)
    {
        arr[left] = copy[left];
    }
    return Pairs + leftPairs + rightPairs;
}

int InversePairs(int arr[], int sz)
{
    if (NULL == arr || sz < 2)
        return 0;

    int *copy = new int[sz];
    return _InverseMerge(arr, copy, 0, sz-1);
    delete[]copy;
}

5.数字在排序数组中出现的次数
排序好的数组可以用二分法，因为是重复数字，先找第一次出现的位置，找到K，如果K左边的数字相同，继续往左边找，直到下标为0或者左边元素不相同为止，同方法找到最后一次出现的位置。两个相减就是出现的次数。

int GetFirstK(int *arr, int sz, int K)
{
    if (NULL == arr || sz < 1)
        return -1;
    int left = 0;
    int right = sz - 1;
    while (left <= right)
    {
        int mid = left + ((right - left) >> 1);
        if (arr[mid] > K)
        {
            right = mid - 1;
        }
        else if (arr[mid] < K)
        {
            left = mid + 1;
        }
        else
        {
            if (mid == 0)
                return mid;
            else if (arr[mid - 1] != K)
                return mid;
            else
                right = mid - 1;
        }
    }

    return -1;
}

int GetLastK(int *arr, int sz, int K)
{
    if (NULL == arr || sz < 1)
        return -1;
    int left = 0;
    int right = sz - 1;
    while (left <= right)
    {
        int mid = left + ((right - left) >> 1);
        if (arr[mid] > K)
        {
            right = mid - 1;
        }
        else if (arr[mid] < K)
        {
            left = mid + 1;
        }
        else
        {
            if (mid == sz-1)
                return mid;
            else if (arr[mid + 1] != K)
                return mid;
            else
                left = mid + 1;
        }
    }

    return -1;
}

int HasMoreK(int *arr, int sz, int K)
{
    int lastK = GetLastK(arr, sz, K);
    int firstK = GetFirstK(arr, sz, K);
    if (lastK == -1 || firstK == -1)
        return 0;
    return lastK - firstK + 1;
}

6.扑克牌是否为顺子，大王可以看做任意牌
把扑克牌用数字替代，A为1，JQK为，11，12，13，大王看作0，先对数据排序，统计0的个数，在统计相差（两张牌之间差几个）的个数，看是否能用0抵消。

int partition_2(int *arr, int left, int right)
{
    int slow = left - 1;
    for (int i = left; i < right; ++i)
    {
        if (arr[i] < arr[right])
        {
            slow++;
            if (slow != i)
                swap(arr[i], arr[slow]);
        }
    }
    ++slow;
    swap(arr[slow], arr[right]);
    return slow;
}

void qSort(int *arr, int left, int right)
{
    if (left < right)
    {
        int index = partition_2(arr, left, right);
        qSort(arr, left, index - 1);
        qSort(arr, index + 1, right);
    }
}

//把大王看作0
bool IsContinue(int *arr, int sz)
{
    if (NULL == arr || sz < 1)
        return false;

    qSort(arr,0,sz-1);
    //0的数目
    int zeronums = 0;
    for (int i = 0; i < sz; ++i)
    {
        if (0 == arr[i])
            zeronums++;
        else
            break;
    }
    //第一个不为0的下标
    int small = zeronums;
    int big = small + 1;

    int difference = 0;
    while (big < sz) 
    {
        //如果相等一定不为顺子
        if (arr[big] == arr[small])
            return false;
        //计算相邻卡片多余的差
        difference += (arr[big] - arr[small] - 1);
        small++;
        big++;
    }
    //多余的差是否能用0填充
    return (difference  <= zeronums );
}

7.n个数，数的范围是0~n-1。求任意一个重复出现的数。
由于数的大小在0~n-1之间，所以可以用arr[n] = n的顺序排序，如{2, 3, 1, 0, 2, 5, 3}，从第一个数开始，下标为0，值为2，不匹配，把2交换到下标为2的位置.
{1, 3, 2, 0, 2, 5, 3},不匹配，把1交换到下标为1的位置
{3, 1, 2, 0, 2, 5, 3},不匹配，把3交换到下标为3的位置
{0, 1, 2, 3, 2, 5, 3}匹配，下标为1，2，3也匹配，跳过
下标为4的值是2，交换，发现与下标为2的值相同，则找到相同元素返回。
这种方法每次查找都会把一个元素归位，所以最坏是O(n)。

bool repeatnum(int *arr, int sz)
{
    if (NULL == arr || sz < 2)
        return false;

    for (int i = 0; i < sz;++i)
    {
        while (arr[i] != i)  //不等于下标交换位置
        {
            //待交换位置上的元素与当前元素相同，找到重复元素
            if (arr[i] == arr[arr[i]])  
            {
                cout << arr[i] << endl;
                return true;
            }
            swap(arr[i], arr[arr[i]]); //移动元素位置
        }
    }
    return false;  //没找到重复元素
}