選擇排序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]+"");
		}
	}
}