选择排序java

㈠ java中有哪几种常用的排序方法

最主要的是冒泡排序、选择排序、插入排序以及快速排序

1、冒泡排序

冒泡排序是一个比较简单的排序方法。在待排序的数列基本有序的情况下排序速度较快。若要排序的数有n个，则需要n-1轮排序，第j轮排序中，从第一个数开始，相邻两数比较，若不符合所要求的顺序，则交换两者的位置；直到第n+1-j个数为止，第一个数与第二个数比较，第二个数与第三个数比较，......，第n-j个与第n+1-j个比较，共比较n-1次。此时第n+1-j个位置上的数已经按要求排好，所以不参加以后的比较和交换操作。

例如：第一轮排序：第一个数与第二个数进行比较，若不符合要求的顺序，则交换两者的位置，否则继续进行二个数与第三个数比较......。直到完成第n-1个数与第n个数的比较。此时第n个位置上的数已经按要求排好，它不参与以后的比较和交换操作；第二轮排序：第一个数与第二个数进行比较，......直到完成第n-2个数与第n-1个数的比较；......第n-1轮排序：第一个数与第二个数进行比较，若符合所要求的顺序，则结束冒泡法排序；若不符合要求的顺序，则交换两者的位置，然后结束冒泡法排序。

共n-1轮排序处理，第j轮进行n-j次比较和至多n-j次交换。

从以上排序过程可以看出，较大的数像气泡一样向上冒，而较小的数往下沉，故称冒泡法。

public void bubbleSort(int a[])

{

int n = a.length;

for(int i=0;i<n-1;i++)

{

for(int j=0;j<n-i-1;j++)

{

if(a[j] > a[j+1])

{

int temp = a[j];

a[j] = a[j + 1];

a[j + 1] = temp;

}

}

}

}

2、选择排序

选择法的原理是先将第一个数与后面的每一个数依次比较,不断将将小的赋给第一个数,从而找出最小的,然后第二个数与后面的每一个数依次比较,从而找出第二小的,然后第三个数与后面的每一个数依次比较,从而找出第三小的.....直到找到最后一个数。

public void sort(int x[])

{

int n=x.length;

int k,t;

for(int i=0;i<n-1;i++)

{

k=i;

for(int j=i+1;j=n;j++)

{

if(x[j]>x[k])k=j;

if(k!=i)

{

t=x[i];

x[i]=x[k];

x[k]=t;

}

}

}

}


3、插入排序

插入排序的原理是对数组中的第i个元素，认为它前面的i-1个已经排序好，然后将它插入到前面的i-1个元素中。插入排序对少量元素的排序较为有效.

public void sort(int obj[])

{

for(int j=1;j<obj.length;j++)

{

int key=obj[j];

int i=j-1;

while(i>=0&&obj[i]>key)

{

obj[i+1]=obj[i];

i--;

}

obj[i+1]=key;

}

}

4、快速排序

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一次排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此大道整个数据变成有序序列。

public void quickSort(int obj[],int low,int high)

{

int i=low;

int j=high;

int keyValue=obj[i];

while(i<j)

{

int temp=0;

while(i<j&&obj[j]>=keyValue)

{

j=j-1;

}

temp=obj[j];

obj[j]=obj[i];

obj[i]=temp;

while(i<j&&obj[i]<=keyValue)

{

i=i+1;

}

temp=obj[j];

obj[j]=ojb[i];

obj[i]=temp;

}

obj[i]=keyValue;

if(low<i-1)

{

quickSort(obj,low,i-1);

}

if(high>i+1)

{

quickSort(obj,i+1,high);

}

}

㈡ java关于选择排序的问题，我写的是升序排列，结果降序了。。。

static class Case2{//选择排序 第一次找到最小的数字放到A[0]的位置，第二次是次小的放到a【1】。。。
static String select(int [] array){
for(int i=0;i<array.length;i++){//进行数组长度次选择，因为每个都要选择
for(int j=0;j<array.length;j++){//选出该次最小的那个数字，放在A【i】
if(array[j]>array[i]){
int temp=array[j];
array[j]=array[i];
array[i]=temp;
}
}
}
return Arrays.toString(array);
}

㈢ java怎么实现排序

Java实现几种常见排序方法

日常操作中常见的排序方法有：冒泡排序、快速排序、选择排序、插入排序、希尔排序，甚至还有基数排序、鸡尾酒排序、桶排序、鸽巢排序、归并排序等。
以下常见算法的定义
1. 插入排序：插入排序基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入排序的基本思想是：每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。
2. 选择排序：选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。
3. 冒泡排序：冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。
4. 快速排序：快速排序（Quicksort）是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
5. 归并排序：归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
6. 希尔排序：希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
https://www.cnblogs.com/wangmingshun/p/5635292.html

㈣ JAVA选择排序算法方法

下面是我自己定的一个int数组排序的工具，希望对你有帮助。

package net.ftng.util.Order;

public class IntArrayOrder {

/**
* @param args
*/
public static void main(String[] args) {
int[] a = { 12, 6, 14, 7, 18, 9 };

System.out.print("noOrderByAnything====>:");
for (int t : a) {
System.out.print(t + " ");
}

System.out.println();

System.out.print("orderByAscend====>:");
int[] temp = lightOrderByAscend(a);
for (int t : temp) {
System.out.print(t + " ");
}

System.out.println();

System.out.print("orderByDescend====>:");
temp = lightOrderByDescend(a);
for (int t : temp) {
System.out.print(t + " ");
}

}

static public int[] lightOrderByAscend(int[] args) {
try {
int temp;
int[] tempargs = args.clone();
int argsLength = tempargs.length;

for (int i = 0; i < argsLength; i++) {
for (int j = i + 1; j < argsLength; j++) {
if (tempargs[i] < tempargs[j]) {
temp = tempargs[i];
tempargs[i] = tempargs[j];
tempargs[j] = temp;
}
}
}
return tempargs;

} catch (Exception e) {
return null;
}

}

static public int[] deepOrderByAscend(int[] args) {
try {
int temp;
int argsLength = args.length;

for (int i = 0; i < argsLength; i++) {
for (int j = i + 1; j < argsLength; j++) {
if (args[i] < args[j]) {
temp = args[i];
args[i] = args[j];
args[j] = temp;
}
}
}
return args;

} catch (Exception e) {
return null;
}

}

static public int[] lightOrderByDescend(int[] args) {
try {
int temp;
int[] tempargs = args.clone();
int argsLength = tempargs.length;

for (int i = 0; i < argsLength; i++) {
for (int j = i + 1; j < argsLength; j++) {
if (tempargs[i] > tempargs[j]) {
temp = tempargs[i];
tempargs[i] = tempargs[j];
tempargs[j] = temp;
}
}
}
return tempargs;

} catch (Exception e) {
return null;
}

}

static public int[] deepOrderByDescend(int[] args) {
try {
int temp;
int argsLength = args.length;

for (int i = 0; i < argsLength; i++) {
for (int j = i + 1; j < argsLength; j++) {
if (args[i] > args[j]) {
temp = args[i];
args[i] = args[j];
args[j] = temp;
}
}
}
return args;

} catch (Exception e) {
return null;
}

}
}

㈤ 用java写个选择排序

import java.util.Random;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Sort {
public static void quickSort(int a[],int p,int r)
{
if(p<r)
{
int q=Partition(a,p,r);
quickSort(a,p,q-1);
quickSort(a,q+1,r);
}
}
public static int Partition(int a[],int p,int r)
{
int i=p+1;
int j=r;
int x = a[p];
//将<x的元素交换到左边区域
//将>x的元素交换到右边区域
while(true)
{
while(a[i]<x)
{
i=i+1;
}
while(a[j]>x)
{
j=j-1;
}
if(i>=j)
break;
int temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
a[p]=a[j];
a[j]=x;
return j;
}

public static void InsertionSort(int arr[],int start,int end)
{
for(int p=start;p<=end;p++)
{
int temp = arr[p];
int pt = p-1;
while(pt>=1&&arr[pt]>temp)
{
arr[pt+1] = arr[pt];
pt = pt-1;
}
arr[pt+1] = temp;
}
}

public static void HeapSort(int arr[],int node_number)
{
for(int parents= node_number/2;parents>=1;parents--)
{
int k = parents;
int v = arr[k];
boolean heap = false;
while(!heap&&2*k<=node_number)
{
int j = 2*k;
if(j<node_number)
{
if(arr[j]<arr[j+1])
j = j + 1;
}
if(v>=arr[j])
heap = true;
else
{
arr[k] = arr[j];
k = j;
continue;
}
}
arr[k] = v;
}
}

public static void HeapOut(int arr[]) //将构造的堆取出根节点，送往临时数组
{
int sorted_arr[] = new int [100];
int p = 99;
int node_number = 100;

while(node_number>0&&p>=0)
{
sorted_arr[p] = arr[1];
arr[1] = arr[node_number]; //将最后一个元素赋给根节点
node_number = node_number - 1; //节点数减1
p = p-1;
HeapSort(arr,node_number); //反复构造堆
}
for(int i=1;i<100;i++)
{
arr[i] = sorted_arr[i-1];
}

}

public static void welcome() //欢迎界面
{
System.out.println("~~~~~~~~Sort the array~~~~~~~~~");
System.out.println(" Please choose :");
System.out.println(" 1.Quick Sort.");
System.out.println(" 2.Insertion Sort.");
System.out.println(" 3.Heap Sort.");
}

public static void makearr(int arr[]) //随机数生成器
{
long seed = 9;
Random rnums = new Random(seed);
for(int j=0;j<101;j++)
{
arr[j] = rnums.nextInt(1000);
}
}

public static void main(String[] args)
{
int arr[] = new int [101];
welcome(); //欢迎界面
boolean cnti = true; //用户选择是否尝试另一种排序方法
boolean sorted = false; //用户是否选择了三种排序中的一种并顺利排序
char choice; //键盘输入
while(cnti==true)
{
makearr(arr);
try{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
choice = (char)in.read();
switch(choice)
{
case '1':
quickSort(arr, 1, 100);
sorted = true;
break;
case '2':
InsertionSort(arr,1,100);
sorted = true;
break;
case '3':
HeapSort(arr,100);
HeapOut(arr);
sorted = true;
break;
default:
System.out.println("Please input your choice in 1,2,3");
break;
}
}
catch(IOException e)
{}
if(sorted==true) //如果选择正确，输出排序结果
{
for(int i=1;i<100;i++)
{
System.out.print(arr[i]);
System.out.print(' ');
}
System.out.println();
}
System.out.println("Continue trying? [Y/N]");
char choice1 = 0;
try{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
choice1 = (char)in.read();
}
catch(IOException e) {}
if(choice1=='Y'||choice1=='y')
{
welcome();
cnti = true;
sorted = false;
continue;
}
else
cnti = false;
//}
}
}
}

㈥ java 选择排序法

你好，很小的错误，看下注释的地方

public class Outfile {
public static void main(String[] args) {
int a[] = { 20, 29, 21, 45, 68, 15, 3, 5 };
for (int i = 0; i < a.length - 1; i++) {
int min = i;
for (int j = i + 1; j < a.length; j++) {
if (a[j] < a[min]) {
min = j;
}
}
if (min != i) {//这一段从上面内层的for拿了出来
int b = a[min];
a[min] = a[i];
a[i] = b;
}
}
for (int c = 0; c < a.length; c++) {
System.out.println(a[c]);
}
}
}

运行结果：
3
5
15
20
21
29
45
68

㈦ java的选择排序问题。

public class select{
public static void main(String[] args){
int[] arr={2,345,111,1,34,5};
int temp=0;
int min=0;
for(int i=0;i<arr.length-1;i++){ //修改第1处，可选
min=i;

for(int j=i+1;j<arr.length;j++){
if(arr[min]>arr[j]) //修改第2处，必选
min=j;
}
if( min != i) { //修改第3处，可选
temp=arr[min];
arr[min]=arr[i];
arr[i]=temp;
}
}
System.out.println("排序后的数组为:");
for (int i=0;i<arr.length;i++){

System.out.print(arr[i]+" ");
}
}
}

㈧ java里的选择排序问题

首先,图1是标准的选择排序算法(经过优化的)。
其次，图3也是选择排序算法,但它算不上标准，是因为它没有经过优化的(比如它在交换时没有if判断是否找到了最小值,假设序列是有序的情况更会体现这种性能上的差异,是冗余的写法)，
最后,为什么图2会得不到正确的结果呢？是因为min始终都是外部for里假设的最小值,即使在内部找到比它更小的你也没有保存到它，言外之意就是说你拿到minIndex是错的。

㈨ Java：运用选择排序法，将十个数存入数组a中，通过输入对话框任意输入十个数，从大到小排列

importjava.util.Scanner;

publicclassTest{
	publicstaticvoidmain(String[]args){
		Scannerscanner=newScanner(System.in);
		int[]a=newint[10];
		intcount=0;
		while(count<10){
			System.out.print("输入第【"+(count+1)+"】个数：");
			a[count]=scanner.nextInt();
			count++;
		}
		System.out.print("
排序之前：");
		for(inti=0;i<a.length;i++){
			System.out.print(a[i]+"");
		}
		//选择排序
		for(inti=0;i<a.length-1;i++){
			intmin=i;
			for(intj=i+1;j<a.length;j++){
				if(a[min]<a[j]){
					min=j;
				}
			}
			if(min!=i){
				inttemp=a[i];
				a[i]=a[min];
				a[min]=temp;
			}
		}
		System.out.print("
排序之后：");
		for(inti=0;i<a.length;i++){
			System.out.print(a[i]+"");
		}
	}
}