java数组元素排序_Java数组的排序算法

在Java中，实现数组的排序算法有很多，如冒泡排序法、选择排序法、直接插入法和快速排序法、归并排序等。下面介绍几种排序算法的具体 实现。

本文引用文献：Java必须知道的300个问题。

1.冒泡排序法

1.1 基本思想：

比较待排序的数据元素中的相邻元素：如果前面的元素大于后面的元素，那么将两个元素交换位置；否则不变。即：永远保持大的元素值在待排序元素中的最后面位置。这样，数组元素就像气泡一样从底部上升到顶部。

1.2 过程实例：

每一轮，排序数组的长度减1次(每一轮结束后，最大元素都是最后一个元素。因此下轮比较过程中最后一次比较不用进行。)

1.3 代码实现

public static voidmain(String[] args) {//初始化数组

int[] array = {63,4,24,1,3,13};//排序

for (int i = 1; i < array.length; i++) {for (int j = 0; j < array.length - i; j++) {if(array[j] > array[j+1]){int temp =array[j];

array[j]= array[j+1];

array[j+1] =temp;

}

}

}//输出结果

System.out.println(Arrays.toString(array));

}

2. 选择排序法

2.1 基本思想

每一轮从待排序的数据元素中选出最小(最大)的一个元素，将该元素(通过与相邻元素交换的方式)移到待排序的数据元素的最前面(最后面)，直到全部待排序的数据元素排完。

2.2 过程实例

2.3 代码实现

//初始化数组

int[] array = {63,4,24,1,3,13};//排序

int len =array.length;//控制轮数

for (int i = 1; i < len; i++) {int max = array[0];int index = 0;//查找最大值

for (int j = 1; j < len - (i - 1); j++) {if(max

max=array[j];

index=j;

}

}//互换位置

int temp =array[index];

array[index]= array[len -i];

array[len- i] =temp;

}//输出

System.out.println(Arrays.toString(array));

3. 直接插入排序法

3.1 基本思想

1. 将n个有序元素放在数组中 --> 2.确认要插入元素的位置 --> 3.将数组中的要插入元素的位置后面的元素向后移一个位置  --> 4.将要出如的元素插到合适的位置上 --> 5.重复2. 3. 4.直到所有元素均插入到数组中。

3.2 过程实例

3.3 代码实现

//初始化数组

int[] array = {20,40,90,30,80,70,50};//排序

intj;for (int i = 1; i < array.length; i++) {int temp =array[i];for (j = i - 1; j > 0 && array[j] > temp; j--) {

array[j+1] =array[j];

}

array[j+1] =temp;

}//输出

System.out.println(Arrays.toString(array));

4. 快速排序法

4.1 基本思想

通过一趟排序将要排序的数据分割成独立的两部分(通常选取中数作为分割线)，其中一部分的所有数据都比另一部分的所有数据要小，然后再按此方法对这两部分数据进行快速排序，整个过程可以通过递归进行。

4.2 过程实例

4.3 代码实现

public static voidmain(String[] args) {//初始化数组

int[] array = {49,38,65,97,76,13,27,49};//排序

quickSort(array, 0, array.length - 1);//输出

System.out.println(Arrays.toString(array));

}private static void quickSort(int[] array, int lowIndex, inthighIndex) {int lo =lowIndex;int hi =highIndex;intmid;if(highIndex >lowIndex){

mid= array[(lowIndex + highIndex) / 2];while(lo <=hi){while((lo < highIndex) && (array[lo]

}while(hi > lowIndex && array[hi] >mid){--hi;

}if(lo <=hi){

swap(array,lo,hi);++lo;--hi;

}

}if(lowIndex

quickSort(array, lowIndex, hi);

}if(lo

quickSort(array, lo, highIndex);

}

}

}private static void swap(int[] array, int lo, inthi) {int temp =array[lo];

array[lo]=array[hi];

array[hi]=temp;

}

4.4 算法评价

快速排序是通用排序算法的传统选择。

5. 归并排序

5.1 基本思想

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

5.2 过程实例

将序列拆分成子序列(每个子序列中有两个元素)，将每个子序列进行排序(如：第一轮)；然后将拆分后的子序列进行两两合并，如果有落单的子序列，合并入上一组(如：第二轮)。重复合并的逻辑，一直到最后只剩下一个数组(该数组以实现排序)，结束。

5.3 代码实现

packagecom.BlueStarWei.test;public classTest2 {public static voidmain(String[] args) {int[] a = new int[]{43, 35, 62, 13, 24, 57,88,91,4,6,34};

mergeSort(a,0, 1);for (int i = 0; i < a.length; ++i) {

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

}

}/*** 　*　

* 　*　二路归并

* 　*　原理：将两个有序表合并和一个有序表

* 　*　

* 　*

* 　*@parama

* 　*@paramlow

* 　*　第一个有序表的起始下标

* 　*@paramlow2

* 　*　第二个有序表的起始下标

* 　*@paramhight2

* 　*　第二个有序表的结束小标

* 　**/

private static void merge(int[] a, int low, int low2, inthight2) {//1.分配空间存放比较后的元素

int[] tmp = new int[hight2 - low + 1];int i = low, j = low2, k = 0;//2.将较小的元素存入tmp

while (i < low2 && j <=hight2) {if (a[i] <=a[j]) {

tmp[k]=a[i];

k++;

i++;

}else{

tmp[k]=a[j];

j++;

k++;

}

}//3.将进行排序的元素中最大的元素存入tmp

while (i

tmp[k]=a[i];

i++;

k++;

}while (j <=hight2) {

tmp[k]=a[j];

j++;

k++;

}//4.将排好顺序的元素存入a(替代原有元素)

System.arraycopy(tmp, 0, a, low, tmp.length);

}/*** 　*

* 　*@parama

* 　*@paramlow

* 第一个有序表的起始下标

* 　*@parammergeLen

* 　*　 每一次进行合并的数组长度*/

public static void mergeSort(int[] a, int low, intmergeLen) {int size =a.length;int mid = size / (mergeLen << 1);//判断进行分割后的数组数量是否是奇数个

int c = size & ((mergeLen << 1) - 1);//-------归并到只剩一个有序集合的时候结束算法-------// if (mid == 0)return;//------进行一趟归并排序-------// for (int i = 0; i < mid; ++i) {

low= i * 2 *mergeLen;

merge(a, low, low+ mergeLen, (mergeLen << 1) + low - 1);

}//-------将剩下的数和倒数一个有序集合归并-------// if (c != 0)

merge(a, size- c - 2 * mergeLen, size - c, size - 1);for (int i = 0; i < a.length; ++i) {

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

}

System.out.println();//-------递归执行下一趟归并排序------// mergeSort(a, 0, 2 *mergeLen);

}

}

5.4 算法评价

归并排序的一个主要的优点是：稳定，即不需要交换相同的元素。

因此多应用于以下场景：假设有一张按照姓名排序的员工列表。现在要按工资排序。使用归并排序可以在按照工资排序的时候保留按名字排列的顺序(即：排序的结果是，先按工资排序，工资相同的按照姓名排序。)