修改数组的最大元素而不更改其位置？

Question

I'm trying to figure out how to modify the n greatest elements of an array without modifying their position. For example, suppose I have an array of ints {5, 2, 3, 4, 8, 9, 1, 3}; I want to add 1 to the two greatest elements, making the array {5, 2, 3, 4, 9, 10, 1, 3} .

All of the methods I can think of to go about doing this end up feeling clunky and unintuitive when I try to implement them, signaling to me that I'm not thinking about it correctly. For example, I could use a TreeMap with the values of the array as keys and their indices as values to find the greatest values, modify them, and then throw them back into the array, but then I would have have to implement my own Comparator to sort the TreeMap in reverse order(unless there's an easier way I'm not aware of?). I was also considering copying the contents of the array into a list, iterating through n times, each time finding the greatest element and its index, putting the modified greatest element back into the array at that index, removing the element from the list, and repeat, but that feels sloppy and inefficient to me.

Any suggestions as to how to approach this type of problem?

Answer 1

The simplest thing would be to scan your array, and store the indices of the n highest values. Increment the values of those elements.

This is going to be O(n) performance, and I don't think any fancier methods can beat that.

edit to add: you can sort the array in place in O(n) at best, in which case you can get the n highest values very quickly, but the requirement is to not change position of the elements, so you'd have to start with a copy of the array if you wanted to do that (or preserve ordering information so you could put everything back afterward).

Answer 2

You might be over engineering the solution to this problem: scan the array, from beginning to end, and mark the two largest elements. Return to the two greatest elements and add 1 to it. The solution shouldn't be longer than 10 lines.

Answer 3

1. Loop over the array and keep track of the indices and values of the two largest items

   a. Initialize the tracker with -1 for an index and MIN_INT for a value or the first two values of the array

   b. At each step of the loop compare the current value against the two tracker values and update if necessary

2. Increment the two items

Any algorithm you choose should be O(n) for this. Sorting and n passes are way overkill.

Answer 4

使用此处和此处的技术（可以在线性时间内完成）找到第n个最大元素（称为K），然后遍历数组修改所有> = K的元素。

Answer 5

i would do something like this

int[] indices = new int[2];
int[] maximas = new int[] { 0, 0 };
int[] data = new int[] { 3, 4, 5, 1, 9 };
for (int i = 0; i < 5; ++i)
{
    if (data[i] > maximas[1])
    {
            maximas[0] = maximas[1];
            maximas[1] = data[i];
            indices[0] = indices[1];
            indices[1] = i;
    } 
    else if (data[i] > maximas[0])
    {
            maximas[0] = data[i];
            indices[0] = i;
    }
} 

didn't test it, but I think it should work :)

Answer 6

I have tought a bit about this but I cannot achieve more than worstcase:

O( n + (mn) * n ) : (m > n)

best case:

O(m) : (m <= n)

where m = number of values, n = number of greatest value to search

This is the implementation in C#, but you can easily adapt to java:

        int n = 3;
        List<int> values = new List<int> {1,1,1,8,7,6,5};
        List<int> greatestIndexes = new List<int>();

        for (int i = 0; i < values.Count; i++) {
            if (greatestIndexes.Count < n)
            {
                greatestIndexes.Add(i);
            }
            else {
                int minIndex = -1, minValue = int.MaxValue;
                for (int j = 0; j < n; j++)
                {
                    if (values[greatestIndexes[j]] < values[i]) {

                        if (minValue > values[greatestIndexes[j]])
                        {
                            minValue = values[greatestIndexes[j]];
                            minIndex = j;
                        }
                    }
                }
                if (minIndex != -1)
                {
                    greatestIndexes.RemoveAt(minIndex);
                    greatestIndexes.Add(i);
                }
            }
        }

        foreach (var i in greatestIndexes) {
            Console.WriteLine(values[i]);
        }

Output:

8
7
6