【算法导论 第9章 中位数和顺序统计学】

 第9章 中位数和顺序统计学

1. 第i个顺序统计量是该集合中第i小的元素。 最小值是第1个顺序统计量(i=1)最大值是第n个顺序统计量(i=n)

2. 中位数是它所在集合的“中点元素”，n为奇数时为（n+1）/2，n为偶数时有两个。
3. 找最大最小值的算法，一般人可能以为需要2（n-1）次比较，实际上只需要最多3⌊n/2⌋次比较，使用的技巧是： 将一对元素比较，然后把较大者于max比较，较小者与min比较，因此每两个元素需要比较3次。

如何设定当前最小值和最大值取决于n是偶数还是奇数。如果n为奇数，就将最小值和最大值都设置为第一个元素，然后成对的处理余下元素。如果n是偶数，就对前两个元素做一次比较，已决定最大值和最小值的初值。然后如同n是奇数一样，成对处理余下元素。 

比较次数， n为奇数：3⌊n/2⌋       n为偶数：3（n - 2）/ 2 + 1 = 3n/2 - 2

#include <stdio.h>
#include<stdlib.h>
#include<time.h>

int count = 0;
int compare(int a, int b)
{
count++;
return a-b;
}

#define MAX(a, b) compare(a,b) > 0 ? (a) : (b)
#define MIN(a, b) compare(a,b) > 0 ? (b) : (a)

int main()
{
int i, min, max;
int N;
srand((int)time(0));
while (1)
{
N = rand() %10;
if (N > 2)
break;
}

printf("N:%d\n", N);

int *A = (int*)malloc(N);
for (i = 0; i < N; i++)
{
A[i] = rand() % 15;
printf("%d ",A[i]);
}

printf("\n");

if (N&1)
{
min = max = A[0];
i = 1;
}
else
{
i = 2;
if (compare(A[0], A[1]) < 0)
{
min = A[0];
max = A[1];
}
else
{
min = A[1];
max = A[0];
}
}

for (; i+1 < N; i += 2)
{
if (compare(A[i], A[i+1]) < 0)
{
min = MIN(A[i], min);
max = MAX(A[i+1], max);
}
else
{
min = MIN(A[i+1], min);
max = MAX(A[i], max);
}
}

printf("count:%d, max:%d, min:%d\n", count, max, min);
}

4.以期望线性时间选择顺序统计量的方法是以快速排序为模型。如同在快速排序中一样，此算法的思想也是对输入数组进行递归划分。但和快速排序不同的是，快速排序会递归处理划分的两边，而randomized-select只处理划分的一边。并由此将期望的运行时间由O(nlgn)下降到了O(n)。 这就是顺序统计量算法能够如此高效的核心原因所在！

//////////////////////////////////////////////////////////////////////////
/// @file nth_element.cpp
/// @brief 中位数和顺序统计学
/// @details COPYRIGHT NOTICE
/// Copyright (c) 2011
/// All rights reserved.\n
/// 在O(n)的时间内寻找一个数组中的第i个顺序统计量\n
/// 第i个顺序统计量的定义为：该集合中第i小的元素\n
/// 以期望线性时间选择顺序统计量的方法是以快速排序为模型。如同在快速排序中一样，此算法的思想也是
/// 对输入数组进行递归划分。但和快速排序不同的是，快速排序会递归处理划分的两边，而randomized-select
/// 只处理划分的一边。并由此将期望的运行时间由O(nlgn)下降到了O(n)。
///
//////////////////////////////////////////////////////////////////////////

#include <time.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <iterator>
using namespace std;

namespace ita
{
namespace
{

/// 寻找v数组的子集[begin_index, end_index]中的第i个元素顺序统计量，0 <= i < end_index-begin_index
int _NthElement( vector<int> &v, int const begin_index, int const end_index, int const n )
{
//这个判断纯粹只是一个加速return的技巧，没有这个判断算法也是正确的！
if ( begin_index == end_index )
{
return v[begin_index];
}

//随机取样
int swap_index = rand() % ( end_index - begin_index + 1 ) + begin_index;
swap( v[swap_index], v[end_index] );

//根据最后一个主元进行分割成两部分
int i = begin_index;
for ( int j = begin_index; j < end_index; ++j )
{
if ( v[j] < v[end_index] )
{
swap( v[i++], v[j] );
}
}
swap( v[i], v[end_index] );

//主元是本区间的第k个元素顺序统计量，0<=k<size
int k = i - begin_index;

if ( n == k )
{
//找到了
return v[i];
}
if ( n < k )
{
//在左区间继续找
return _NthElement( v, begin_index, i - 1, n );
}
else
{
//在右区间继续找：由于主元是第k个元素顺序统计量(0<=k<size)，所以小于等于主元的元素有k+1个（包括主元），因此寻找右区间的第n-(k+1)个顺序统计量
return _NthElement( v, i + 1, end_index, n - k - 1 );
}
}

}

/// @brief 寻找v数组中的第i个顺序统计量，0<=i<size
///
/// 以快速排序为模型。如同在快速排序中一样，此算法的思想也是
/// 对输入数组进行递归划分。但和快速排序不同的是，快速排序会递归处理划分的两边，而randomized-select
/// 只处理划分的一边。并由此将期望的运行时间由O(nlgn)下降到了O(n)。
/// @param v 要进行查找操作的集合
/// @param i 查找集合中的第i个顺序统计量
/// @return 集合中的第i个顺序统计量
/// @see int _NthElement(vector<int> &v, int const begin_index, int const end_index, int const n)
int NthElement( vector<int> &v, int const i )
{
return _NthElement( v, 0, v.size() - 1, i );
}

/// 中位数和顺序统计学
int testNthElement()
{
vector<int> v;
srand((int)time(0));
for ( int i = 0; i < 10; ++i )
{
v.push_back( ( rand() % 1000 ) );
}
copy( v.begin(), v.end(), ostream_iterator<int>( cout, " " ) );
cout << endl;

for ( int i = 0; i < 10; ++i )
{
cout << i << "th element is:" << NthElement( v, i ) << endl;
}

return 0;
}
}
using namespace ita;
int main()
{
testNthElement();
}