数组排序的实现
数组排序方法的实现
JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。 快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。 冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。 选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。 插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。
<1>利用Arrays带有的排序方法快速排序
import java.util.Arrays;
public class Test2{
public static void main(String[] args){
int[] a={5,4,2,4,9,1};
Arrays.sort(a); //进行排序
for(int i: a){
System.out.print(i);
}
}
}<2>冒泡排序算法
public static int[] bubbleSort(int[] args){//冒泡排序算法
for(int i=0;i<args.length-1;i++){
for(int j=i+1;j<args.length;j++){
if (args[i]>args[j]){
int temp=args[i];
args[i]=args[j];
args[j]=temp;
}
}
}
return args;
}<3>选择排序算法
public static int[] selectSort(int[] args){//选择排序算法
for (int i=0;i<args.length-1 ;i++ ){
int min=i;
for (int j=i+1;j<args.length ;j++ ){
if (args[min]>args[j]){
min=j;
}
}
if (min!=i){
int temp=args[i];
args[i]=args[min];
args[min]=temp;
}
}
return args;
}<4>插入排序算法
public static int[] insertSort(int[] args){//插入排序算法
for(int i=1;i<args.length;i++){
for(int j=i;j>0;j--){
if (args[j]<args[j-1]){
int temp=args[j-1];
args[j-1]=args[j];
args[j]=temp;
}else break;
}
}
return args;
}1.自然升序排序
package peng;
import java.util.Arrays;
public class Testexample {
public static void main(String[] args) {
int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
Arrays.sort(a);
for(int arr:a) {
System.out.print(arr + " ");
}
}
}2.自然降序排序
利用Collections.reverseOrder()方法：倒叙排列，数组倒置。
package peng;
import java.util.Arrays;
import java.util.Collections;
public class Testexample {
public static void main(String[] args) {
int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
Arrays.sort(a,Collections.reverseOrder());
for(int arr:a) {
System.out.print(arr + " ");
}
}
}自定义排序方法
实现Comparator接口的复写compare()方法。自定义排序方法:
package peng;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
public class Testexample {
public static void main(String[] args) {
/*注意，要想改变默认的排列顺序，不能使用基本类型（int,double, char）
而要使用它们对应的类*/
Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
//定义一个自定义类MyComparator的对象
Comparator cmp = new MyComparator();
Arrays.sort(a,cmp);
for(int arr:a) {
System.out.print(arr + " ");
}
}
}
//实现Comparator接口
class MyComparator implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
/*如果o1小于o2，我们就返回正值，如果o1大于o2我们就返回负值，
这样颠倒一下，就可以实现降序排序了,反之即可自定义升序排序了*/
return o2-o1;
}
}3：数组倒置
【方法一】使用集合个工具类： 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);
}
}以上代码运行输出结果为：
反转前排序: [A, B, C, D, E]
反转后排序: [E, D, C, B, A]【方法二】使用集合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;
}
}4：随机排序
1：Java List容器内元素的顺序重新随机排序、洗牌排序
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class ListShuffle {
public static void main(String[] args) {
//假设，list容器中装了一副扑克牌的元素
String[] strArray = new String[] { "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3", "2" };
List<String> list = Arrays.asList(strArray);
System.out.println("List容器中扑克牌元素的排列顺序：" + list);
//打乱List容器的元素排列顺序
Collections.shuffle(list);
System.out.println("Shuffle（洗牌、打乱）后List容器中元素的排列顺序：" + list);
//再次打乱List容器的元素排列顺序
Collections.shuffle(list);
System.out.println("再次Shuffle（洗牌、打乱）后List容器中元素的排列顺序：" + list);
//再次打乱List容器的元素排列顺序
Collections.shuffle(list);
System.out.println("再次Shuffle（洗牌、打乱）后List容器中元素的排列顺序：" + list);
}
}执行结果：
List容器中扑克牌元素的排列顺序：[A, K, Q, J, 10, 9, 8, 7, 6, 5, 4, 3, 2]
Shuffle（洗牌、打乱）后List容器中元素的排列顺序：[K, 10, 4, 3, 8, 7, A, J, 9, 6, Q, 5, 2]
再次Shuffle（洗牌、打乱）后List容器中元素的排列顺序：[10, 5, A, K, J, 4, 2, 3, 6, 7, 8, Q, 9]
再次Shuffle（洗牌、打乱）后List容器中元素的排列顺序：[5, 9, 10, 8, A, J, 7, K, 6, Q, 4, 3, 2]2：数字数组随机生产
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]+" ");
}
}
}本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2019-03-31 ，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
腾讯云开发者
