有序序列中的i个最大数（算法导论思考题9-1）

有序序列中的i个最大数

（算法导论思考题9-1）
a
时间复杂度O(nlgn+i)

//总共时间复杂度O(nlgn+i)
vector<int> i_largest_number_in_ordered_sequence_a(int *array,int length,int i){
    vector<int>result;
    //时间复杂度O(nlgn)
    quick_sort_by_median_contains_equal_elements(array,0,length-1);
    //时间复杂度i
    while (i>0)
    {
        result.push_back(array[length-i]);
        i--;
    }
    return result;
}

b 时间复杂度O(n+ilgn)

//时间复杂度O(n+ilgn)
vector<int> i_largest_number_in_ordered_sequence_b(int *array,int length,int i){
    vector<int>result;
    //时间复杂度O(n)
    build_heap(array,length);
    int heap_size = length;
    //时间复杂度O(ilgn)
    while (i-->0)
    {
        //O(lgn)
        result.push_back(extra_max(array,heap_size));
    }
    return result;
}

c 时间复杂度O(n+ilgi)

//时间复杂度O(n+ilgi)
vector<int> i_largest_number_in_ordered_sequence_c(int *array,int length,int i)
{
    vector<int> result;
    //时间复杂度O(n)
    int key = select(array,0,length - 1,length - i + 1);
    //时间复杂度O(n)
    int position = partition(array,0,length - 1,key);
    //时间复杂度O(ilgi)
    quick_sort_by_median_contains_equal_elements(array,position,length - 1 );
    //时间复杂度O(i)
    for(int j = position;j < length;j++)
    {
        result.push_back(array[j]);
    }
    return result;
}

综上比较 c是最佳渐进最坏情况运行时间最优的算法。
辅助函数 extra_max

int extra_max(int *array,int& heap_size)
{
    int max = array[0];
    array[0] = array[heap_size-1];
    heap_size -- ;
    max_heapify(array,heap_size,0);
    return max;
}

辅助函数 max_heapify
链接地址
辅助函数
quick_sort_by_median_contains_equal_elements
地址链接
select和partition
链接地址