算法导论学习笔记05——求一个数列中第N大的数字

        本篇文章根据快速排序的分治思想在排序的情况下求解一个数列中第N大的数字。关于快速排序的原理和实现算法导论学习笔记04——快速排序。

        快速排序中介绍了一种PARTITION()函数，它将原数组A[r]使用一个主元x（A[]的某个成员）换分成大于x和小于x的两部分。PARTITION()执行后，主元x被交换到A[r]的k位置，并满足A[0 ~ k-1]都小于A[k]，A[k+1 ~ r]都大于A[k]。

        此时如果：

            ① k == N，则主元x就是第N大的数字，结束递归

            ② k < N，则第N大的数在A[0 ~ k-1]区间，递归执行PARTITION(A, 0, k)

            ③ k > N，则第N大的数在A[k+1 ~ r]区间，递归执行PARTITION(A, k + 1, r)

C代码如下：

         get_number() 用于处理输入参数。PARITITON() 的返回值就是求解结果。

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

/*
     PARTITION(A, p, r)
       x = A[r]
       i = p - 1
       for j = p to r - 1
           if A[j] <= x
               i = i + 1
               exchange A[i] with A[j]
       exchange A[i + 1] with A[r]
       return i + 1
 */

#define exchange(p1, p2) \
        do { \
                int tmp; \
                tmp = *p2; \
                *p2 = *p1; \
                *p1 = tmp; \
        } while(0)

int partition(int A[], int p, int r)
{
        int x, i, j;

        x = A[r];
        i = p - 1;
        for (j = p; j < r; j++) {
                if (A[j] <= x) {
                        i++;
                        exchange(&A[i], &A[j]);
                }
        }
        exchange(&A[i + 1], &A[r]);
        return i + 1;
}
/* RANDOMIZED-SELECT(A, p, r, i)
 *     if p == r
 *         return A[p]
 *     q = PARTITION(A, p, r)
 *     k = q - p + 1
 *     if k == i
 *         return A[q]
 *     else if i < k
 *         return RANDOMIZED-SELECT(A, p, q - 1, i)
 *     else
 *         return RANDOMIZED-SELECT(A, q + 1, r, i - k)
 * */

int randomized_select(int A[], int p, int r, int i)
{
        int q, k;

        if (p == r) {
                return A[p];
        }
        q = partition(A, p, r);
        k = q - p + 1;
        if (k == i) {
                return A[q];
        } else if (i < k) {
                return randomized_select(A, p, q - 1, i);
        } else {
                return randomized_select(A, q + 1, r, i - k);
        }
}

int get_number(int num, int **arr, char *argv[])
{
        int i;

        *arr = (int *)malloc(sizeof(int) * num);
        if (NULL == *arr) {
                printf("Error: malloc failed\n");
                return -1;
        }
        for (i = 0; i < num; i ++) {
                (*arr)[i] = atoi(argv[i + 1]);
        }
        return 0;
}

int main(int argc, char *argv[])
{
        int num, len, *arr;
        int res;

        num = argc - 1;
        len = num - 1;
        if (get_number(num, &arr, argv)) {
                return -1;
        }
        res = randomized_select(&arr[1], 0, len - 1, arr[0]);
        printf("%d\n", res);
        free(arr);
        return 0;
}

 

下面提供python脚本进行测试：

        求一个数列中第N大的数字。生成一个数列，对其进行排序，从排序后的数列中选出第N大的数字。

import os
import random

def do_test(func_str, arg, res):
    cmd = func_str + " " + arg
    ret = os.popen(cmd).read().strip()
    if res != ret:
        print "Error case\n" + "case: " + arg
        print "res:  " + ret
        return -1
    return 0

MAX = 2147483647
MIN = -2147483648
# test 10000 times
TIMES = 10000
# we will input 'number_len', which is between 1 and MAX_NUMBER, numbers into the sort program
MAX_NUMBER = 10000

if __name__ == '__main__':
    func = "./randomized_select"
    for i in range(TIMES):
        number_len = random.randint(1, MAX_NUMBER)
        positition = random.randint(1, number_len)
        # get input number array
        number = [random.randint(MIN, MAX) for i in range(number_len)]
        # get sorted input number array
        number_s = sorted(number)
        # exchange number to string, as input srting
        arg1 = str(positition) + ' '
        arg2 = ' '.join(str(n) for n in number)
        arg = arg1 + arg2
        # exchange sorted number to string, as result
        res = str(number_s[positition - 1])
        # do test
        ret = do_test(func, arg, res)
        if ret == -1:
            print(number_s)
            break
    if ret != -1:
        print "test success"