查找数组中的第四大和第四小数字

Question

我尝试了以下方法来查找第二大和最小的数字，并且它可以工作：

class Test

{

static void main()throws IOException

{
    Scanner sc = new Scanner(System.in);
    System.out.println("Enter");
    int a[] = {45,79,2,5,74,4,19,56,2,888};
    int small= a[0];
    int big=a[0];
    int s=0,b=0;
    for(int i=0;i<10;i++)
    {
        if(small>a[i])
        {
            small=a[i];
        }
        if(big<a[i])
        {
            big=a[i];
        }
    }

    int small2=a[0],big2=a[0];

    for(int i=0;i<10;i++)
    {
        if(small2>a[i]&&a[i]!=small)
        {
            small2=a[i];
        }
        if(big2<a[i]&&a[i]!=big)
        {
            big2=a[i];
        }
    }
    System.out.println("second biggest = "+big2);
    System.out.println("second smallest = "+small2);
}
}

现在我想找到第四大和最低的。 在这种情况下，我可能需要使用4个循环。 但是我想用更短，更聪明的方式做到这一点。 有人可以帮忙吗？

Answer 1

以下是一些解决方案：

1. 如果您不希望对整个输入进行排序，则可以放置一个保持排序的临时集合（或使用已经一直排序的集合）。

   例如，如果输入为“ 1,2,3,4,5,6,7,8,9，... 1000”，而您希望获得第m个最大数字，则将创建一个临时集合大小m，以及您经过的每个数字，都决定它是否应该在临时数组内。 您应该始终对临时集合进行排序（或仅使用已经进行了排序的临时集合），然后将新项放入其中，同时删除最小的项，以防其大小超过m。

   就内存而言，您使用的收集项（m）的大小较小，并且您不修改输入数组。

   就操作数（复杂度）而言，与对数组进行排序-O（nlogn）大致相同，因为对于放入temp数组中的每个项目，集合都需要将其放在哪里，并且需要logn（例如使用二进制搜索）。

   顺便说一句，此解决方案与获得最大/最小数目相同，只是您不需要对临时集合中的项目进行排序，因为它的大小为1。

2. 如果您不关心内存，但是只是不想更改输入，则可以复制数组并对其进行排序...

3. 有一个更好的算法可以在线性时间内工作，类似于您获得中值的方法（链接在这里 ）。 这是一个显示效果更好的链接。

Answer 2

您可以使用通用方式。使用Arrays.sort(array);对数组进行Arrays.sort(array); 然后您可以使用索引访问它。

Answer 3

我认为最简单的方法是订购Array（是Log（n））。

如果您不想更改原始数组，则可以先进行克隆（int b [] = Arrays.copyOf（a，a.length）;）。

如果您想要数组中的位置而不是值，请告诉我，我将找到另一个解决方案。

告诉我这是否有帮助：

    public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);
    System.out.println("Enter");
    int a[] = { 45, 79, 2, 5, 74, 4, 19, 56, 2, 888 };

    Arrays.sort(a);
    System.out.print("ordered array: ");
    for(int i:a){
        System.out.print(i+", ");
    }
    System.out.println();
    System.out.println("the 4th smallest : " + a[3]);
    System.out.println("the 4th biggest: " + a[(a.length - 4)]);

}

Answer 4

对常规数组排序为O（nlogn），然后可以按索引选择元素。

您还可以使用具有O（n）最坏情况时间复杂度的Select算法 。 该算法获取一个数组和一些k，然后返回第k个大元素。 我相信您可以找到它的实现。

Answer 5

public class FourthLargest {

    static int a[] = {45, 79, 2, 5, 74, 4, 19, 56, 2, 888};

    public static void main(String[] args) {
        Arrays.sort(a);
        System.out.println("The fourth smallest number = " + a[3]);
        System.out.println("The fourth largest number = " + a[a.length-4]);
    }
}

Answer 6

为了找到未排序数组的第i个元素，有一个非常简单的基于quicksort（quickselect）的随机算法，其平均时间为O（n），而一个相当复杂的非随机算法则为O（n）最坏情况。

您需要的所有内容都在这些PowerPoint幻灯片中 。 只是为了提取O（n）最坏情况算法的基本算法：

Select（A，n，i）：将输入分为大小为5的⌈n/5⌉组。

/* Partition on median-of-medians */
medians = array of each group’s median.
pivot = Select(medians, ⌈n/5⌉, ⌈n/10⌉)
Left Array L and Right Array G = partition(A, pivot)

/* Find ith element in L, pivot, or G */
k = |L| + 1
If i = k, return pivot
If i < k, return Select(L, k-1, i)
If i > k, return Select(G, n-k, i-k)

在Cormen等人的《算法介绍》一书中，它也做了非常详细的介绍。

对于最小的元素，您可以简单地检查每个元素，这将花费O（n）时间。