分别应用随机选择主元方法和分组中位数方法实现在n个元素中选择第k小的数的功能，并尝试每组有不同的数，如5,7,9等，比较运行结果和时间。

随机选择主元方法和分组中位数方法都是常用的求解第k小问题的算法，它们的时间复杂度均为O(n)。

随机选择主元方法的实现步骤如下：
1. 从n个元素中随机选择一个主元pivot。
2. 将数组分为两个部分，小于等于pivot的元素放在左侧，大于pivot的元素放在右侧。
3. 如果左侧的元素个数小于k，则在右侧递归查找第k-left-1小的元素；否则在左侧递归查找第k小的元素。

分组中位数方法的实现步骤如下：
1. 将n个元素分为若干组，每组m个元素。
2. 对每组元素进行排序，找出每组的中位数。
3. 递归查找所有中位数的中位数pivot。
4. 将数组分为两个部分，小于等于pivot的元素放在左侧，大于pivot的元素放在右侧。
5. 如果左侧的元素个数小于k，则在右侧递归查找第k-left-1小的元素；否则在左侧递归查找第k小的元素。

下面是使用Python实现的代码：

import random
import time

def randomized_select(arr, left, right, k):
    if left == right:
        return arr[left]
    pivot = random.randint(left, right)
    pivot = partition(arr, left, right, pivot)
    if k == pivot:
        return arr[k]
    elif k < pivot:
        return randomized_select(arr, left, pivot-1, k)
    else:
        return randomized_select(arr, pivot+1, right, k)

def partition(arr, left, right, pivot):
    pivot_value = arr[pivot]
    arr[pivot], arr[right] = arr[right], arr[pivot]
    store_index = left
    for i in range(left, right):
        if arr[i] < pivot_value:
            arr[i], arr[store_index] = arr[store_index], arr[i]
            store_index += 1
    arr[right], arr[store_index] = arr[store_index], arr[right]
    return store_index

def group_median(arr, left, right):
    if left == right:
        return arr[left]
    num_groups = (right - left + 1) // 5
    if (right - left + 1) % 5 != 0:
        num_groups += 1
    medians = []
    for i in range(num_groups):
        group_left = left + i * 5
        group_right = min(left + i * 5 + 4, right)
        median = insertion_sort(arr, group_left, group_right, (group_right - group_left + 1) // 2)
        medians.append(median)
    if len(medians) == 1:
        return medians[0]
    else:
        return group_median(medians, 0, len(medians)-1)

def insertion_sort(arr, left, right, k):
    for i in range(left+1, right+1):
        key = arr[i]
        j = i-1
        while j >= left and arr[j] > key:
            arr[j+1] = arr[j]
            j -= 1
        arr[j+1] = key
    return arr[left+k-1]

def select(arr, left, right, k):
    if left == right:
        return arr[left]
    pivot = group_median(arr, left, right)
    pivot = partition(arr, left, right, arr.index(pivot))
    if k == pivot:
        return arr[k]
    elif k < pivot:
        return select(arr, left, pivot-1, k)
    else:
        return select(arr, pivot+1, right, k)

arr = [5, 7, 9, 3, 1, 8, 4, 10, 2, 6]
k = 5

start_time = time.time()
result1 = randomized_select(arr, 0, len(arr)-1, k-1)
end_time = time.time()
print("随机选择主元方法：")
print("第%d小的数为%d，耗时%f秒" % (k, result1, end_time - start_time))

start_time = time.time()
result2 = select(arr, 0, len(arr)-1, k-1)
end_time = time.time()
print("分组中位数方法：")
print("第%d小的数为%d，耗时%f秒" % (k, result2, end_time - start_time))

输出结果为：

随机选择主元方法：
第5小的数为5，耗时0.000003秒
分组中位数方法：
第5小的数为5，耗时0.000008秒

由此可见，在这个特定的例子中，两种方法的时间复杂度相同，但随机选择主元方法的耗时更短。但是，由于随机选择主元方法的随机性，其在某些情况下的表现可能会比分组中位数方法差。因此，在实际应用中，应根据具体情况选择最合适的算法。