java返回最小的k个元素

Question

From an array int[] a , I want to find and return an array with k.length containing the k smallest elements sorted.

There cant be any changing of the content of array a. After making a helping array of k.length I copy the k first values from a, then sorting it.

After this if there is any elements in array a that is smaller than the ones in the help ing array I put it in the right position and the last element disappear and so on.

Method:

public static int[] kMinst(int[] a, int k)

Possible Input:

int[] a = {1,2,3,4,5,6,7,8,9,10}
kMinst(a, a.length);

Output:

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

Another input:

int[] b = {4,3,2,1}
kMinst(b, 3);

Output:

[1, 2, 3]

What I have so far. And it's not working and is too inefficient:

public static int[] kMinst(int[] a, int k) {

    if (k < 1 || k > a.length) {
        throw new IllegalArgumentException("k har ikke riktig verdi!");
    }

    int[] verdier = new int[k];

    for (int i = 0; i < verdier.length; i++) {
        verdier[i] = a[i];
    }
    sortering(verdier);

    for (int i = verdier.length; i < a.length; i++) {
        for (int j = verdier.length - 1; j > 0; j --) {
            if (a[i] < a[j]) {
                int temp = a[j];
                for (int l = verdier.length - 1; l > j; l--) {
                    a[l] = a[l - 1];
                }
                a[j] = temp;
            }
        }
    }

    return verdier;
}

Answer 1

您可以从原始数据构建一个堆，该堆将为O（nlogn），然后从该堆中获取k个元素，在最坏的情况下，该元素也将为O（nlogn）。

Answer 2

You can sort the array, and get the first k elements from it.

    public static int[] kMinst(int[] a, int k){
    if (k < 1 || k > a.length) {
        throw new IllegalArgumentException("k need to be greater than 1 and lesser than the length of the array");
    }
    int help[] = new int[a.length];
    int res[] = new int[k];
    for(int i = 0; i < a.length; i++) help[i] = a[i]; // copy the a array, not to change it
    Arrays.sort(help);
    for(int i = 0; i < k; i++) res[i] = help[i]; // get the first k elements from the sorted array
    return res;
}

Hope it helps :)

Answer 3

I guess the below code serves ur purpose,

public class SortArray {

public int[] sort(int[] a,int b) {
    int c[]=new int[b];
    int temp=0;
 for (int i = 1; i < a.length; i++) {

for (int j = 0; j < i; j++) {
    if(a[i] <=a[j]){
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;      
    }
  }
}
 for (int i = 0; i < b; i++) {
  c[i]=a[i];    
      }
return c;
}


public static void main(String[] args) {
    int a[]={7,2,4,5,3,7};
    SortArray sort=new SortArray();
    int[] c=sort.sort(a,3);
    for (int i = 0; i < c.length; i++) {
        System.out.println(c[i]);
    }

}
}

Answer 4

I'd use a Set to discard duplicates and make it a TreeSet so it does all of the sorting itself.

public static Integer[] kSmallest(Integer[] a, int k) {
    // Use a TreeSet to keep tbhe smallest.
    TreeSet<Integer> kSmallest = new TreeSet<Integer>();
    // Fold all the array into the set.
    for (Integer x : a) {
        // Add it in.
        kSmallest.add(x);
        // Trim to k.
        if (kSmallest.size() > k) {
            Iterator<Integer> last = kSmallest.descendingIterator();
            // Select the biggest.
            last.next();
            // Remove it.
            last.remove();
        }
    }
    // Make my result.
    return kSmallest.toArray(new Integer[0]);
}

Answer 5

Here is an implementation which finds K th minimum element in an array containing unique elements. If you want to allow duplicates, you can use java.util.Set to eliminate duplicates. It is based on randomized Quick Select algorithm and has worst case in order of n . It outputs unordered sequence of K number of smallest elements from the original array.

First it finds index of Kth smallest elemnt as well as does partial unordered sorting with respect to list[k]. Therefore, at the end result would contain K numbers which are smaller in the array with the Kth smallest element at the right most position.

 public class QuickSelect {

    public static void main (String[] args) {
        final int[] list = new int[]{1,2,11,16,34,3,4,42,5,6,28,7,8,9,10};
        QuickSelect qs = new QuickSelect();
        final int k = 10;
        final int kthMinIndex = qs.findKthMinimum (list, k - 1);
        System.out.println("[");
        for (int i = 0; i <= kthMinIndex; i++)
            System.out.print(list[i] + " ");
        System.out.print("]");

    }

    public int findKthMinimum (final int[] list, final int k) {
        if (k > list.length || k < 1) {
            throw new IllegalArgumentException("Bad arguments.");
        }
        final int left = 0;
        final int right = list.length - 1;
        final int pivot = (int)Math.floor((double)left +  (Math.random() * (double)(right - left)));
        final int result = findKthMinimum (list, left, right, k , pivot);
        return result;
    }

    private int findKthMinimum (final int[] list, int left, int right, final int k, int pivot) {
        int partitionElement = partition (list, left, right, pivot);
        while (left != right) {
            if (partitionElement == k)
                break;
            else if (partitionElement > k) {
                right = partitionElement - 1;
                pivot = (int)Math.floor((double)left +  (Math.random() * (double)(right - left)));
            } else if (partitionElement < k) {
                left = partitionElement + 1;
                pivot = (int)Math.floor((double)left +  (Math.random() * (double)(right - left)));
            }
            partitionElement = partition (list, left, right, pivot);
        }
        return list[partitionElement];
    }

    private int partition (final int[] list, int left, int right, int pivot) {
        final int pivotElement = list[pivot];
        swap (list, pivot, right);
        int lastStoredIndex = left;
        for (int i = left; i < right; i++) {
            if (list[i] < pivotElement) {
                swap (list, i, lastStoredIndex++);
            }
        }
        swap (list, lastStoredIndex, right);
        return lastStoredIndex;
    }

    private void swap (final int[] list, final int first, final int second) {
        final int temp = list[first];
        list[first] = list[second];
        list[second] = temp;
    }
}

Answer 6

I will write this in english, but if you would like an explanation in norwegian, I can do that as well. I will not write you any code stub, since this is a homework, but try to imagine what you need to get done first: I guess the array a is unsorted, or atleast sorted but in reverse ways as shown in your text? a cannot be changed. k, of k length, is supposed to contain the k amount of lowest valued numbers in a. k must be sorted.

First and foremost, how do you solve problem number 1? What I would do (This is more inefficient in the beginning, but you wouldn't have to write as much code): Go through array a, starting by saving the first integer in index 0 in k. Let i++ work it's magic, and then call upon a method where you send in the entire array k, and the new integer. Make it check (with compareTo()-method) whether or not the new int is lower than the integer in every index in k, moving the other numbers one index ahead all the way (remember to check for null-values, orelse: NPE). Return this new array. This will allow you to save the k lowest numbers, sort them and not change a. I think it would solve your entire problem?