选择排序java（java怎么实现排序）

本文目录

• java怎么实现排序
• java直接选择排序
• java选择排序法
• java里的选择排序问题
• JAVA选择排序算法方法
• java里,几种排序方法各有什么优缺点
• java 选择排序法
• java的选择排序问题

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直接选择排序

我写的自己对吧，第二个循环的开始结束位置问题

java选择排序法

原理：每次都找到当次最大的数，按大小顺序依次放入数组相应位置
比如：第一次先找到最大的数并记下其位置，如果其不在数组第一位，
则将其与第一位交换，使最大数置于第一位
第二次再循环查找第二大的数并记下其位置，如果其不在数组第二位，
则将其与第二位交换，使最大数置于第二位
依次类推.........................................
第i次再循环查找第i大的数并记下其位置，如果其不在数组第 i位，
则将其与第 i位交换，使最大数置于第 i位

java里的选择排序问题

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

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里,几种排序方法各有什么优缺点

一、冒泡排序

已知一组无序数据a、a、……a[n]，需将其按升序排列。首先比较 a与a的值，若a大于a则交换两者的值，否则不变。再比较a与a的值，若a大于a则交换两者的值，否则不变。再比较a与a，以此类推，最后比较a[n-1]与a[n]的值。这样处理一轮后，a[n]的值一定是这组数据中最大的。再对 a~a[n-1]以相同方法处理一轮，则a[n-1]的值一定是a~a[n-1]中最大的。再对a~a[n-2]以相同方法处理一轮，以此类推。共处理n-1轮后a、a、……a[n]就以升序排列了。

优点：稳定；

缺点：慢，每次只能移动相邻两个数据。

二、选择排序

冒泡排序的改进版。

每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

选择排序是不稳定的排序方法。

n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：

①初始状态：无序区为R[1..n]，有序区为空。

②第1趟排序

在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

……

③第i趟排序

第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(1≤i≤n- 1)。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

优点：移动数据的次数已知（n-1次）；

缺点：比较次数多。

三、插入排序

已知一组升序排列数据a、a、……a[n]，一组无序数据b、 b、……b[m]，需将二者合并成一个升序数列。首先比较b与a的值，若b大于a，则跳过，比较b与a的值，若b仍然大于a，则继续跳过，直到b小于a数组中某一数据a[x]，则将a[x]~a[n]分别向后移动一位，将b插入到原来 a[x]的位置这就完成了b的插入。b~b[m]用相同方法插入。（若无数组a，可将b当作n=1的数组a）

优点：稳定，快；

缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。

三、缩小增量排序

由希尔在1959年提出，又称希尔排序(shell排序)。

已知一组无序数据a、a、……a[n]，需将其按升序排列。发现当n不大时，插入排序的效果很好。首先取一增量d(d《n)，将a、a[1+d]、a[1+2d]……列为第一组，a、a[2+d]、 a[2+2d]……列为第二组……，a[d]、a[2d]、a[3d]……列为最后一组以次类推，在各组内用插入排序，然后取d’《d，重复上述操作，直到d=1。

优点：快，数据移动少；

缺点：不稳定，d的取值是多少，应取多少个不同的值，都无法确切知道，只能凭经验来取。

四、快速排序

快速排序是目前已知的最快的排序方法。

已知一组无序数据a、a、……a[n]，需将其按升序排列。首先任取数据 a[x]作为基准。比较a[x]与其它数据并排序，使a[x]排在数据的第k位，并且使a~a[k-1]中的每一个数据《a[x]，a[k+1]~a[n]中的每一个数据》a[x]，然后采用分治的策略分别对a~a[k-1]和a[k+1]~a[n] 两组数据进行快速排序。

优点：极快，数据移动少；

缺点：不稳定。

五、箱排序

已知一组无序正整数数据a、a、……a[n]，需将其按升序排列。首先定义一个数组x[m],且m》=a、a、……a[n]，接着循环n次，每次x[a]++.

优点：快，效率达到O(1)

缺点：数据范围必须为正整数并且比较小

六、归并排序

归并排序是多次将两个或两个以上的有序表合并成一个新的有序表。最简单的归并是直接将两个有序的子表合并成一个有序的表。

归并排序是稳定的排序.即相等的元素的顺序不会改变.如输入记录 1(1) 3(2) 2(3) 2(4) 5(5) (括号中是记录的关键字)时输出的 1(1) 2(3) 2(4) 3(2) 5(5) 中的2 和 2 是按输入的顺序.这对要排序数据包含多个信息而要按其中的某一个信息排序,要求其它信息尽量按输入的顺序排列时很重要.这也是它比快速排序优势的地方.

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