返回k个最小元素的java

从数组

int[]a

，我想找到并返回一个k.length的数组，该数组包含排序的k个最小元素

数组a的内容不能有任何更改。在制作了一个k.length的帮助数组之后，我从a复制了k个first值，然后对其进行排序

在此之后，如果数组a中有任何元素小于帮助数组中的元素，我将其放置在正确的位置，最后一个元素消失，依此类推

方法：

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

可能的投入：

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

输出：

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

[1, 2, 3]

另一项输入：

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

输出：

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

[1, 2, 3]

到目前为止我所拥有的。它不起作用，效率太低：

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;
}

公共静态int[]kMinst（int[]a，intk）{
if（k<1 | | k>a.长度）{
抛出新的非法辩论例外（“k har ikke riktig verdi！”）；
}
int[]绿色=新的int[k]；
for（int i=0；i0；j--）{
if（a[i]j；l--）{
a[l]=a[l-1]；
}
a[j]=温度；
}
}
}
返青；
}

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

您可以对数组排序，并从中获取前k个元素

    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;
}

公共静态int[]kMinst（int[]a，intk）{
if（k<1 | | k>a.长度）{
抛出新的IllegalArgumentException（“k需要大于1且小于数组长度”）；
}
int help[]=新的int[a.length]；
int res[]=新的int[k]；
for（int i=0；i

---

希望有帮助：）

我想下面的代码可以满足您的需要

公营索塔雷酒店{

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]);
    }

}
}

public int[]排序（int[]a，int[]b）{
int c[]=新int[b]；
内部温度=0；
for（int i=1；i如果（a[i]，我将使用
集
丢弃重复项，并使其成为
树集
，因此它自己进行所有排序

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]);
}

公共静态整数[]kSmallest（整数[]a，int k）{
//使用树集使t保持最小。
TreeSet kSmallest=新树集（）；
//将所有阵列折叠到集合中。
for（整数x:a）{
//把它加进去。
k最小。添加（x）；
//修剪到k。
如果（kSmallest.size（）>k）{
迭代器last=kSmallest.degendingIterator（）；
//选择最大的。
last.next（）；
//移除它。
最后，删除（）；
}
}
//做出我的结果。
返回ksmalest.toArray（新整数[0]）；
}
下面是一个在包含唯一元素的数组中查找第k个最小元素的实现。如果您希望允许重复，可以使用java.util.Set来消除重复。
该算法基于随机快速选择算法，最坏情况为n阶，输出原始数组中K个最小元素的无序序列

首先，它找到第k个最小元素的索引，并对列表[k]进行部分无序排序。因此，最终结果将包含k个数字，这些数字在数组中较小，第k个最小元素位于最右侧

 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;
    }
}

公共类QuickSelect{
公共静态void main（字符串[]args）{
最终整数[]列表=新整数[]{1,2,11,16,34,3,4,42,5,6,28,7,8,9,10}；
QuickSelect qs=新的QuickSelect（）；
最终整数k=10；
最终int-kthMinIndex=qs.findkthmimimimum（列表，k-1）；
System.out.println（“[”）；
对于（int i=0；i list.length | k<1）{
抛出新的IllegalArgumentException（“坏论点”）；
}
最终整数左=0；
final int right=list.length-1；
final int pivot=（int）Math.floor（（double）left+（Math.random（）*（double）（right-left））；
最终int结果=findkthmimimum（列表、左、右、k、轴）；
返回结果；
}
私有整数findkthmimimum（最终整数[]列表、左整数、右整数、最终整数k、整数透视）{
int partitionElement=分区（列表、左、右、轴）；
while（左！=右）{
if（partitionElement==k）
打破
else if（partitionElement>k）{
右=分区元素-1；
pivot=（int）Math.floor（（double）left+（Math.random（）*（double）（right-left））；
}else if（partitionElement
我会用英语写这篇文章，但如果你想用挪威语解释，我也可以。我不会给你写任何代码存根，因为这是一个家庭作业，b