用java查找最小k个元素

Ⅰ 找出第k个最小数

！修改成从键盘输入的了，输入数字的时候要每次输入一个数后敲一下回车，因为用的是readLine方法

呵呵，我上学期算法设计与分析的实验
使用的是快速排序算法，不需要对原数列进行排序便可求出第k个元素

实验6 快速排序算法求第K个元素
 问题描述
利用快速排序的方法，在不将所有数据排序的情况下找出数据中第K小元素。
 设计思想
利用快速排序的方法，将数列A[i..j]分成A[i..p],A[p+1..j]2部分，并使的A[i..p]中的每个元素的键值都不大于A[p+1..j]中的每个元素的键值，这样如果k<=p,则第K个元素一定在数组A[i..p]中，如果k>p,则第K个元素一定在数组A[p+1..j]，此时，第K个元素在A[p+1..j]中为第k-q个元素(其中q为A[i..p]数组中元素的个数)。依次递归下去便可以找到第K个元素。
 时间复杂度
设T(n)为在长度为n的数组中选择一个元素的时间，则可以得到递归式
T(n)≤(1/n)T(max(1,n-1))+ +O(n)
由此可得T(n) ≤Cn.
所以时间复杂度为O(n)
 实验源程序
import java.util.Random;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.IOException;
public class FindK
{
int[] arr;//存放数列
int size;//数列的容量
FindK(int size)
{//在数列arr中查找第k个元素
this.size=size;
//Random ran=new Random();
arr=new int[size];
System.out.println("请输入"+size+"个数字:");
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
String temp = "1";
for(int i=0;i<size;i++)
{//从键盘上读入数列，数字之间以回车分隔
try
{
temp=bf.readLine();
}
catch(IOException ioe){}
try
{
arr[i]=Integer.parseInt(temp);
}
catch(NumberFormatException nfe)
{
System.out.println("你的输入不合法");
}
}
}
int quickSort(int p,int r,int k)
{//进行快速排序
int q;
int m;
int temp;
if(p==r) return(arr[p]);
q=partition(p,r,arr[p]);
temp=q-p+1;
if(k<=temp){m=quickSort(p,q,k); return m;}
else {m=quickSort(q+1,r,k-temp); return m;}
}
int partition(int p,int r,int keyword)
{//进行划分
int i,j;
int temp;
i=p;
j=r;
while(true)
{
for(;arr[j]>keyword;j--){}
for(;arr[i]<keyword;i++){}
if(i<j){temp=arr[i];arr[i]=arr[j];arr[j]=temp;}
else return(j);
}
}
void display()
{
String str="";
for(int i=0;i<size;i++)
{
str+=str.format("%8d",arr[i]);
}
System.out.println(str);
}
public static void main(String args[])
{
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
String sSize = "1";
int iSize = 1;
while(true)
{
System.out.println("请输入数列的容量:");
try
{
sSize = bf.readLine();//从键盘读入数列容量
}catch(IOException ioe){}
try
{
iSize = Integer.parseInt(sSize);
}catch(NumberFormatException nfe)
{
System.out.println("你的输入不合法");
continue;//进入下次循环
}
break;
}

FindK fk=new FindK(iSize);
int k=1;
long t;
fk.display();
String sn = "1";
while(true)
{
System.out.println("你要查找第几个元素？");
try
{
sn=bf.readLine();
}
catch(IOException ioe){}
try
{
k=Integer.parseInt(sn);
}
catch(NumberFormatException nfe)
{
System.out.println("你的输入不合法");
continue;
}
if(k<1||k>fk.size)
{//输入不合法
System.out.println("你的输入不合法");
continue;
}
break;//输入合法则结束循环
}

t=System.currentTimeMillis();
int result = fk.quickSort(0,fk.size-1,k);
t=System.currentTimeMillis()-t;
System.out.println("第"+k+"小元素是 ： "+result);
System.out.println("查找时间为 ： "+t+"ms");
}
}

Ⅱ 编写一个JAVA应用程序 找出几个整数中最小的一个

import java.util.Scanner;

public class Test {
public static void main(String[] args)
{
Scanner scanner = new Scanner(System.in);
//从键盘输入数字个数
System.out.println("请输入数字的个数");
int count = scanner.nextInt();

int[] numberArray = new int[count];
//构造数组
for(int i = 0; i < count; i++){
System.out.println("请输入第 " + (i + 1) + " 个数字");
int number = scanner.nextInt();
numberArray[i] = number;

}
//查找最小指
int minNumberIndex = 0;
int minNumber = numberArray[minNumberIndex];
for(int i = 0; i < numberArray.length; i++){
if(numberArray[i] < minNumber){
minNumberIndex = i;
minNumber = numberArray[i];
}
}

System.out.println("最小的数是第 " + (minNumberIndex + 1) + " 次输入的数字，数值是 " + minNumber);
}

}

Ⅲ java编写程序，找出一维数组中元素的最大值和最小值。

java编写程序，找出一维数组中元素的最大值和最小值：

方法：

importjava.util.*;
publicclassMain{
publicstaticvoidmain(Stringargs[]){
inta1[]=newint[]{5,3,6,8,10,56};
Arrays.sort(a1);
System.out.println("最大值："+a1[a1.length-1]);
System.out.println("最小值："+a1[0]);
}
}

方法2：

publicclassa{
publicstaticvoidmain(Stringargs[]){
inta[]={84,40,16,3,10,49,28,76,94,70};
intn;
intmin=a[0];
inti;
intmax=a[0];
for(n=0;n<=9;n++){
if(max<a[n])
max=a[n];
}
for(i=0;i<=9;i++){
if(min>a)
min=a;
}
System.out.print("max="+max);
System.out.print("min="+min);
}
}

Ⅳ java中如何找出一串时间序列中的最大，最小值

java.lang.String.compareTo(String)
public int compareTo(String anotherString)按字典顺序比较两个字符串。该比较基于字符串中各个字符的 Unicode 值。将此 String 对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此 String 对象在参数字符串之前，则比较结果为一个负整数。如果按字典顺序此 String 对象位于参数字符串之后，则比较结果为一个正整数。如果这两个字符串相等，则结果为 0；compareTo 只有在方法 equals(Object) 返回 true 时才返回 0。
这是字典排序的定义。如果这两个字符串不同，则要么它们在某个索引处具有不同的字符，该索引对二者均为有效索引，要么它们的长度不同，或者同时具备上述两种情况。如果它们在一个或多个索引位置上具有不同的字符，假设 k 是这类索引的最小值；则按照 < 运算符确定的那个字符串在位置 k 上具有较小的值，其字典顺序在其他字符串之前。这种情况下，compareTo 返回这两个字符串在位置 k 处的两个不同的 char 值，即值：

this.charAt(k)-anotherString.charAt(k)
如果它们没有不同的索引位置，则较短字符串在字典顺序上位于较长字符串的前面。这种情况下，compareTo 返回这两个字符串长度的不同，即值：
this.length()-anotherString.length()

指定者：
接口 Comparable<String> 中的 compareTo
参数：
anotherString - 要比较的 String。
返回：
如果参数字符串等于此字符串，则返回 0 值；如果按字典顺序此字符串小于字符串参数，则返回一个小于 0 的值；如果按字典顺序此字符串大于字符串参数，则返回一个大于 0 的值。

解决了比较大小的问题，最大值和最小值一个循环搞出来主可以了。

Ⅳ java用快速排序法查找最小的k个元素

quicksort完毕之后，截走前k个元素即可，调用Arrays.sort方法(内部使用的是优化过的quicksort)

Ⅵ java用分治法查找数组元素的最大值和最小值,求大神帮我看看这段代码错在哪

分治那个方法基本都错了：

importjava.util.*;
publicclassMaxmin{
	publicintmax＝0;
	publicintmin＝Integer.MAX_VALUE;
	publicintMin(inta,intb){
		if(a<=b)
			returna;
		else
			returnb;
	}
	publicintMax(inta,intb){
		if(a>=b)
			returna;
		else
			returnb;
	}
	
	publicvoidmin_max(inta[]){
		if(a.length==1){
			max=Max(max,a[0]);
			min=Min(min,a[0]);
		}else{
			intm[]=newint[a.length/2];
			intn[]=newint[a.length-a.length/2];
			System.array(a,0,m,0,m.length);
			System.array(a,m.length,n,0,n.length);
			min_max(m);
			min_max(n);
		}
	}
	publicstaticvoidmain(String[]args){
		Maxminobject=newMaxmin();
		int[]array=newint[100];
		for(inti=0;i<array.length;i++)
		{
			array[i]=(int)(Math.random()*100+1);
			System.out.print(array[i]+"");
		}
		object.min_max(array);
		System.out.println("最大值是："+object.max);
		System.out.println("最小值是："+object.min);
	}
}

Ⅶ 用JAVA语言编译：数组中包含n个整数，从其中找出k个最小的数，写出你能想到的最快的方法！！！

最快k*O(n)~O(n)，将前K个数放入一个k的数组中，按序放，对K+1到N的数，依次如果比K数组总的小，将K中最大的取出，放入最小的数，一直维持K个，最后就是最小的K个。

import java.util.Arrays;

/**先给数值里的值进行从小到大排序，取从0到k-1索引的数组值

* @创建一个数组,包含11个元素，求5个最小的数

* @author Administrator

public class ArrayTest {

public static void main(String[] args) {

//最小元素的个数

int k=5;

//创建一个数组,

int[] arr = {1,3,45,33,67,12,88,11,46,32,89};

//操作数组的工具Arrays,sort()方法自动排序，由小到大

Arrays.sort(arr);

for(int i=0;i<k;i++){

System.out.println(arr[i]);

}

(7)用java查找最小k个元素扩展阅读：

此处数组是程序中声明的变量数组。它们不同于控件数组，控件数组是在设计时通过设置控件的 Index 属性规定的。变量数组总是连续的；与控件数组不同的是，不能从一个数组的中部加载或卸载数组元素。

一个数组中的所有元素具有相同的数据类型（在C、C++、Java、pascal中都这样。但也并非所有涉及数组的地方都这样，比如在Visual Foxpro中的数组就并没这样的要求）。当然，当数据类型为 Variant 时，各个元素能够包含不同种类的数据（对象、字符串、数值等等）。可以声明任何基本数据类型的数组，包括用户自定义类型和对象变量。