选择排序
假设数组为int[] a = { 49, 38, 65, 97, 76, 13, 27 }，数组元素个数为7个。
第1轮比较：先是a[0]与a[1]比较，大于则先交换，再比较a[0]和a[2]…最后是a[0]与a[6]比较。总共比较6次。(此时a[0]已是数组中的最小值)
第2轮比较：先是a[1]与a[2]比较，大于则先交换，再比较a[1]和a[3]…最后是a[1]与a[6]比较。总共比较5次。
第3轮比较：先是a[2]与a[3]比较，大于则先交换，再比较a[2]和a[4]…最后是a[2]与a[6]比较。总共比较4次。
第4轮比较：先是a[3]与a[4]比较，大于则先交换，再比较a[3]和a[5]…最后是a[3]与a[6]比较。总共比较3次。
第5轮比较：先是a[4]与a[5]比较，大于则先交换，再比较a[4]和a[6]。总共比较2次。
第6轮比较：只用a[5]与a[6]比较，大于则先交换。总共比较1次。
public class ThroughArrays {
public static void main(String[] args) {
int[] a = { 49, 38, 65, 97, 76, 13, 27 };
int[] b = selectSort(a);
for (int i=0 ; i<b.length ; i++)
System.out.println(b[i]);
}
public static int[] selectSort(int[] arr) {
// 外层for循环控制比较的是第几轮
for (int i = 0; i < arr.length - 1; i++) {
// 内层for循环控制每轮比较的次数，arr[j]是右侧待比元素
for (int j = i + 1; j < arr.length; j++) {
// 判断左是否大于右
if (arr[i] > arr[j]) {
// 交换数据
int temp;
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
return arr;
}
}
输出结果：
13
27
38
49
65
76
97
冒泡排序
原理：依次比较相邻的两个数，将小数放在前面，大数放在后面。
首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复第一趟步骤，直至全部排序完成。第一次交换完成后，最后一个数为最大数，不再参与比较。
import java.util.Arrays;
public class BubbleSort {
public static void BubbleSort(int[] arr) {
int temp;//定义一个临时变量
for(int i=0;i<arr.length-1;i++){//冒泡趟数
for(intj=0;j<arr.length-i-1;j++){
if(arr[j+1]<arr[j]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
public static void main(String[] args) {
int arr[] = new int[]{1,6,2,2,5};
BubbleSort.BubbleSort(arr);
system.out.println(Arrays.toString(arr));
}
}
自然升序排序
自然排序：java.lang.Comparable
Comparable 接口中只提供了一个方法： compareTo(Object obj) ，该方法的返回值是 int 。如果返回值为正数，则表示当前对象(调用该方法的对象)比 obj 对象“大”；反之“小”；如果为零的话，则表示两对象相等。
import java.util.Arrays;
public class mysort{
public static void main(String [ ] args){
int [ ] a = { 1 , 12 , 35 ,5 ,2 ,9};
Arrays.sort(a);
System.out.println(Arrays.toString(a) );
}
}
自然降序排序
Java中sort实现降序排序
利用Collections的reverseOrder方法：Copyimport java.util.Arrays;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
Integer[] arr = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
Arrays.sort(arr, Collections.reverseOrder());
for (Integer x : arr) {
System.out.print(x + " ");
}
System.out.println();
}
}
利用Comparator接口复写compare方法：Copyimport java.util.Arrays;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
//注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）,而要使用它们对应的类
Integer[] arr = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
//定义一个自定义类MyComparator的对象
Comparator cmp = new MyComparator();
Arrays.sort(arr, cmp);
for (int x : arr) {
System.out.print(x + " ");
}
}
}
//实现Comparator接口
class MyComparator implements Comparator<Integer> {
@Override //作用是检查下面的方法名是不是父类中所有的，也起到注释的作用
public int compare(Integer a, Integer b) {
return a > b ? -1 : 1;
}
}
数组倒置
方法一：使用集合个工具类： Collections.reverse(ArrayList) 将数组进行反转
import java.util.ArrayList;import java.util.Collections;
public class Main {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("A");
arrayList.add("B");
arrayList.add("C");
arrayList.add("D");
arrayList.add("E");
System.out.println("反转前排序: " + arrayList);
Collections.reverse(arrayList);
System.out.println("反转后排序: " + arrayList);
}
}
方法二：使用集合ArrayList实现反转：
方法三：直接使用数组实现反转，即，反转后数组的第一个元素等于源数组的最后一个元素：
方法二和方法三的实现代码如下：
package javatest2;
import java.util.ArrayList;
public class JavaTest2 {
public static void main(String[] args) {
String[] Array = { "a", "b", "c", "d", "e" };
reverseArray1(Array);// 使用集合ArrayList实现反转
for (int j = 0; j < Array.length; j++) {
System.out.print(Array[j] + " ");
}
System.out.print("\n");
String[] temp = reverseArray2(Array);// 直接使用数组实现反转
for (int j = 0; j < temp.length; j++) {
System.out.print(Array[j] + " ");
}
}
/*
* 函数：reverseArray1和reverseArray2
* 功能：实现 数组翻转
* 例如：{'a','b','c','d'}变成{'d','c','b','a'}
*/
private static void reverseArray1(String[] Array) {
ArrayList<String> array_list = new ArrayList<String>();
for (int i = 0; i < Array.length; i++) {
array_list.add(Array[Array.length - i - 1]);
}
Array = array_list.toArray(Array);
}
private static String[] reverseArray2(String[] Array) {
String[] new_array = new String[Array.length];
for (int i = 0; i < Array.length; i++) {
// 反转后数组的第一个元素等于源数组的最后一个元素：
new_array[i] = Array[Array.length - i - 1];
}
return new_array;
}
}
随机排序
方法一：Collections.shuffle(list)方法
引用Collectons类中的。Collections.shuffle(list)方法
Collectons类用于操作集合类，如list，set。提供的所有方法都是静态的。
Collectons类的几个常用方法：
Collections.sort(list);
// 顺序排列 （对集合进行排序,默认按照升序排序，列表中所有元素必须实现Comparable接口）
Collections.shuffle(list);
// 对集合中元素进行随机排序
Collections.reverse(list);
// 倒序排列 （反转）
排序实例：
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class demo {
public static void main(String[] args) {
String[] chars = new String[] { "a", "b", "c", "d", "e", "f", "g", "h",
"i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t",
"u", "v", "w", "x", "y", "z",};
List<String> list = Arrays.asList(chars);//数组转化为list
System.out.println("List容器中排列顺序：" + list);
//打乱List容器的元素排列顺序
Collections.shuffle(list);
System.out.println("Shuffle方法调用后顺序：" + list);
//再次打乱List容器的元素排列顺序
Collections.shuffle(list);
System.out.println("Shuffle方法调用后顺序：" + list);
}
}
输出结果：
List容器中排列顺序：[a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z]
Shuffle方法调用后顺序：[p, t, f, c, h, r, y, a, e, k, m, d, w, i, g, o, u, z, n, b, s, v, x, l, j, q]
Shuffle方法调用后顺序：[f, j, n, c, q, a, k, y, g, h, e, l, o, x, r, b, i, s, u, z, m, d, t, w, p, v]
方法二：Java random() 方法
random() 方法用于返回一个随机数，随机数范围为 0.0 =< Math.random < 1.0。
实例：
public class RandomSortTest {
private int[]arr = {1,2,3,4,5,6,7,8};
private static final int SIZE = 8;
Random random = new Random();
@Test
//重新排列
public void sort(){
printArr();
for(int i=0;i<SIZE;i++){
int p = random.nextInt(i+1);
System.out.println("i==="+i+"p==="+p);
int tmp = arr[i];
arr[i] = arr[p];
arr[p] = tmp;
}
printArr();
//1 2 4 8 5 3 7 6
//4 1 8 7 2 6 5 3
//1 8 2 3 5 4 6 7
//5 7 8 3 4 2 6 1
}
@Test
//打印
public void printArr(){
for(int i=0;i<SIZE;i++){
System.out.print(arr[i]+" ");
}
}
}
参考引用：
扫一扫
1080
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
