Question

所以现在我正在尝试编写一个函数，该函数将删除未排序数组中的最大值。

当前代码如下：

    @Override
public void remove() throws QueueUnderflowException {
    if (isEmpty()) {
        throw new QueueUnderflowException();
    } else {
        int priority = 0;
        for (int i = 1; i < tailIndex; i++) {
            while (i > 0 && ((PriorityItem<T>) storage[i - 1]).getPriority() < priority)
            storage[i] = storage[i + 1];
            i = i - 1;
        }
        /*int max = array.get(0);

        for (int i = 1; i < array.length; i++) {
        if (array.get(i) > max) {
        max = array.get(i);
        }*/
    }
        tailIndex = tailIndex - 1;
    }

我在此尝试：

int priority = 0;
    for (int i = 1; i < tailIndex; i++) {
        while (i > 0 && ((PriorityItem<T>) storage[i - 1]).getPriority() < priority)
        storage[i] = storage[i + 1];
        i = i - 1;

程序不会打扰，但仍会删除数组中的第一项而不是最高编号。我的大学讲师为我提供了此代码，以提供不同的解决方案，但不幸的是，此代码在这里不起作用。

此解决方案是否可以进行足够的修改？还是我应该尝试其他解决方案？

谢谢。

Answer 1

第1步
找到最高的索引。

int[] array;
int highIndex = 0;
for (int i = 1; i < highIndex.size(); i++)
    if (array[highIndex] < array[highIndex])
        highIndex = i;

第2步
使用new int[array.size() - 1]

创建新数组

第3步
将数组的所有值移到新数组中（最高的数组除外）。

我的提示：如果可能，请使用List。它降低了您的复杂性。

Answer 2

您可以找到largest Number，它是index，然后将每个数字复制到其先前的数字。之后，您有两个选择：

每次迭代数组时，请添加Length - 1。
或者复制前一个数组，并且不要在其中包含删除的数字。

工作代码：

import java.util.Arrays;

public class stackLargest
{
    public static void main(String[] args)
    {
        int[] unsortedArray = {1,54,21,63,85,0,14,78,65,21,47,96,54,52};
        int largestNumber = unsortedArray[0];
        int removeIndex = 0;
        // getting the largest number and its index
        for(int i =0; i<unsortedArray.length;i++)
        {
            if(unsortedArray[i] > largestNumber)
            {
                largestNumber = unsortedArray[i];
                removeIndex = i;
            }
        }

        //removing the largest number
        for(int i = removeIndex; i < unsortedArray.length -1; i++)
            unsortedArray[i] = unsortedArray[i + 1];

        // now you have two options either you can iterate one less than the array's size
        // as we have deleted one element
        // or you can copy the array to a new array and dont have to add " length - 1" when iterating through the array
        // I am doing both at once, what you lke you can do
        int[] removedArray = new int[unsortedArray.length-1];
        for(int i =0; i<unsortedArray.length-1;i++)
        {
            System.out.printf(unsortedArray[i] + " ");
            removedArray[i] = unsortedArray[i];
        }
    }
}

注意：：尽可能使用List，它不仅可以降低复杂性，而且还提供了非常丰富的方法，可以为您带来很大的帮助。

Answer 3

可以将问题中的代码片段更新为以下代码，同时保持相同的数据结构（即队列），并且此更新的代码包含3个步骤-查找最大元素的索引，移动元素以覆盖最大元素并最终设置将tailIndex减少一，即减小队列的大小。

    @Override
public void remove() throws QueueUnderflowException {
    if (isEmpty()) {
        throw new QueueUnderflowException();
    } else {
        int priority = 0;
        int largeIndex = 0;
        for (int i = 0; i < tailIndex; i++) {
          if (((PriorityItem<T>) storage[i]).getPriority() > priority) {
            priority = ((PriorityItem<T>) storage[i]).getPriority();
            largeIndex = i ;
          }
        }

        for(int i = largeIndex; i < (tailIndex - 1) ; i++)
          storage[i] = storage[i + 1];
    }
    tailIndex = tailIndex - 1;
  }

希望有帮助。

如何删除未排序数组中具有最高值的项目？

3 个答案: