剑指offer——优化时间和空间效率（第五章）

面试题29：数组中出线次数超过一半的数字

    数组中有一个数字出线的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。

思路1：

   对于有序的数组，出线次数超过一半的数字肯定会出现在数组中间的位置。

    对数组进行排列，然后直接输出排列后数组中间位置的数字

    注意：排序算法的使用——快速排序！

思路2：

    这个数字出线的次数比其他所有数字出线的次数和要多。

    遍历数组，保存两个值，一个数组中的一个数字，一个是次数。

    次数：初始为1。

    数字：初始为第一个值。

    当下一个数字与其前一个数字相同，则次数+1；否则次数-1；

    当次数为0时，下一个数字为保存数字。

    这样，最后保存的数字一定为所求数字~（它的次数大于其它所有数字的和）。

#include <iostream>
using namespace std;
void QuickSort(int* arr,int left,int right);
int Partition(int* arr,int left,int right);
int MoreThanHalfNum1(int* arr,int len);
int MoreThanHalfNum2(int* arr,int len);
void Change(int &a,int &b)
{
    int temp=a;
    a=b;
    b=temp;
}
int main()
{
    const int mSize=20;
    int a[mSize]={1,2,3,2,2,2,5,4,2};
    int len=9;
//    for(int i=0;i<len;i++)
//        cout<<a[i]<<" ";
    cout<<MoreThanHalfNum2(a,len);
    return 0;
}
int MoreThanHalfNum1(int* arr,int len)
{
    if(!arr||len<=0)
        return 0;
    QuickSort(arr,0,len-1);
    int mid=(len-1)/2;
    return arr[mid];
}
void QuickSort(int* arr,int left,int right)
{
    int index;
    if(left<right)
    {
           index=Partition(arr,left,right);
           QuickSort(arr,left,index-1);
           QuickSort(arr,index+1,right);
    }
}
int Partition(int* arr,int left,int right)
{
    int i=left-1;
    for(int j=left;j<right;j++)
    {
        if(arr[j]<=arr[right])
        {
            i++;
            Change(arr[i],arr[j]);
        }
    }
    Change(arr[i+1],arr[right]);
    return i+1;
}
int MoreThanHalfNum2(int* arr,int len)
{
    if(!arr||len<=0)
        return 0;
    int result=arr[0];
    int time=1;
    for(int i=1;i<len;i++)
    {
        if(time==0)
        {
            result=arr[i];
            time=1;
        }
        else if(arr[i]==result)
            time++;
        else time--;
    }
    return result;
}

 

面试题30：最小的k个数

    输入n个整数，找出其中最小的k个数。例如输入4、5、1、6、2、7、3、8这8个数字，则最小的4和数是1、2、3、4

思路1：

    排序，选择前k个数，时间复杂度为O(nlogn)，面试官可能不满意

    并且该方案改变了原来数组的结构（当然这不是问题）。

思路2：

    与29道思路二类似：

    遍历一边数组即可：定位arr[k]，遍历数组，所有比arr[k]小的数放在arr[k]左边，比它大的数放在其右边。这不类似于快速排序里面那个Partition嘛~

    具体实现：（基于Partition）

    我们知道，Partition得到的是一个值，小于这个值的都在其左边，大于这个值的都在其右边。

    而我们的目标是：小于arr[k-1]的都在其左边，而大于arr[k-1]的都在其右边，因此arr[0]-arr[k-1]就是所求的k个数

    这样的话，问题就简单了，只要Partition的返回值为k-1就行了。

    因此：如果Partition的返回值<k-1，则在其右侧继续进行Partition；而Partition的返回值>k-1，则在其左侧继续Partition

#include <iostream>
using namespace std;
void Change(int &a,int &b)
{
    int temp;
    temp=a;
    a=b;
    b=temp;
}
/// 方案1：先排序，直接找出排序后的前k个
void GetLeastNumbers1(int* arr,int len,int k);
int Partition(int* arr,int left,int right);
void QuickSort(int* arr,int left,int right);

///方案2：基于Partition的方法
void GetLeastNumbers2(int* arr,int len,int k);


int main()
{
    int arr[]={4,5,1,6,2,7,3,8};
    int k=4;
    int len=sizeof(arr)/sizeof(arr[0]);
//    GetLeastNumbers1(arr,len,k);
    GetLeastNumbers2(arr,len,k);
    return 0;
}

///1:
int Partition(int* arr,int left,int right)
{
    int i=left-1;
    for(int j=left;j<right;j++)
    {
        if(arr[j]<=arr[right])
        {
            i++;
            Change(arr[i],arr[j]);
        }
    }
    Change(arr[i+1],arr[right]);
    return i+1;
}
void QuickSort(int* arr,int left,int right)
{
    if(!arr||left>right) return;
    if(left<right)
    {
        int index=Partition(arr,left,right);
        QuickSort(arr,left,index-1);
        QuickSort(arr,index+1,right);
    }
}
void GetLeastNumbers1(int* arr,int len,int k)
{
    if(!arr||len<0||len<k) return;
    QuickSort(arr,0,len-1);
    for(int i=0;i<k;i++)
        cout<<arr[i]<<" ";
}

///2:
void GetLeastNumbers2(int* arr,int len,int k)
{
    if(!arr||len<0||len<k) return;
    int left=0,right=len-1;
    int index=Partition(arr,left,right);
    while(index!=k-1)
    {
        if(index<k-1)
        {
            left=index+1;
            index=Partition(arr,left,right);
        }
        else
        {
            right=index-1;
            index=Partition(arr,left,right);
        }
    }
    for(int i=0;i<k;i++)
        cout<<arr[i]<<" ";
}

 

///3:
void GetLeastNumbers3(vector<int> arr,int k)
{
    vector<int>::iterator iter1=arr.begin();
    multiset<int,greater<int> > leastNumbers;
    multiset<int,greater<int> >::iterator iter2;
    for(;iter1!=arr.end();iter1++)
    {
        if((leastNumbers.size())<k)
            leastNumbers.insert(*iter1);
        else
        {
            multiset<int,greater<int> >::iterator temp=leastNumbers.begin();
            if(*iter1<*(leastNumbers.begin()))
            {
                leastNumbers.erase(temp);//删除顶端元素，最大堆中顶端元素就是最大的元素
                leastNumbers.insert(*iter1);
            }
        }
    }
    for(iter2=leastNumbers.begin();iter2!=leastNumbers.end();iter2++)
        cout<<*iter2<<" ";
    cout<<endl;
}