排序算法可以分为如图所示8种。只有数据非常大时(超过10亿)才用外部排序。
一. 冒泡排序(每遍历一次,两两进行比较,将较大或较小的数放在后面(交换位置))
package com.bzw.sort;
import java.util.Arrays;
public class BubbleSort {
public static void main(String[] args) {
int[] array = {5,4,3,2,1};
boolean flag = false;
int count = 0;
for (int i=0;i<array.length-1;i++){
for (int j=0;j<array.length-1-i;j++){ //每遍历一次相当于选出当前数组中的最大值
if (array[j] > array[j+1]){
flag = true;
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
count++;
}
if (!flag){ //在一次遍历中一次都没有进行交换,说明排序已经完成,不必再往后循环了
break;
} else {
flag = false;
}
}
System.out.println(Arrays.toString(array));
System.out.println("遍历次数" + count);
}
}
二. 简单选择排序(先假设第一个数就是最大值或最小值,然后遍历找到真的最小值,交换位置)
package com.bzw.sort;
import java.util.Arrays;
public class ChooseSort {
public static void main(String[] args) {
int[] array = {4,3,-2,6,5};
for (int i=0;i<array.length-1;i++){
for (int j=i;j<array.length;j++){
if (array[j] < array[i]){
int temp = array[j];
array[j] = array[i];
array[i] = temp;
}
}
}
System.out.println(Arrays.toString(array));
}
}
三. 直接插入排序(从头开始遍历,每遍历到一个数与前面的数进行比较,当有一个数比这个数小时,就插在这个数后面。)
package com.bzw.sort;
import java.util.Arrays;
public class InsertSort {
public static void main(String[] args) {
int[] array = {2, 1, 5, -3, 4, 2, -5, 9};
// 自己写的代码,没有老师写的通俗易懂
// for (int i=0;i<array.length;i++){
// for (int j=0;j<i+1;j++){
// if (array[i] < array[j]){
// int temp = array[i];
// int k = i;
// while ( j != k ){
// array[k] = array[k-1];
// k--;
// }
// array[j] = temp;
// }
// }
// }
// System.out.println(Arrays.toString(array));
// }
// 老师代码
for (int i = 0; i < array.length; i++) {
int insertVal = array[i];
int insertIndex = i - 1;
while (insertIndex >= 0 && insertVal < array[insertIndex]) {
array[insertIndex + 1] = array[insertIndex];
insertIndex--;
}
//insertIndex + 1 即为要插入的位置
array[insertIndex + 1] = insertVal;
}
System.out.println(Arrays.toString(array));
}
}
四. 希尔排序(可以看成是直接插入排序的优化,直接插入排序有一个弊端,就是当一个较小的数在靠后的位置时,要遍历的次数较多。希尔排序可以解决这个问题。它的思想是将数组分成若干份(array.length/2),然后对每一份再用直接插入法排序,直到最后只剩一组。)
package com.bzw.sort;
import java.util.Arrays;
public class ShellSort {
public static void main(String[] args) {
int[] array = {-3,4,2,1,3};
shellSort(array);
System.out.println(Arrays.toString(array));
}
// 自己尝试写,没写出来
// public static void shellSort(int[] array,int n){
// int[] temp1 = new int[array.length];
// int[] temp2 = new int[array.length];
// while (n != 1){
// for (int j=0;j<n;j++){
// for (int i=j;i<array.length;i=n + i){
// temp1[i] = array[i];
// insertSort(temp1,n);
// array[i] = temp1[i];
// }
// }
// n = n/2;
// shellSort(array,n);
// }
//
//
//
// }
//
// public static void insertSort(int[] array,int n){
// for (int i=0;i<array.length;i=i+n){
// int insertVal = array[i];
// int insertIndex = i - n; //插入数的前一个下标
//
// while (insertIndex >= 0 && insertVal < array[insertIndex]){
// array[insertIndex + n] = array[insertIndex];
// insertIndex = i - n;
// }
//
// array[insertIndex + n] = insertVal;
// }
// }
public static void shellSort(int[] array){
for (int grap = array.length/2;grap > 0;grap /= 2){ //grap 指步长,即分组的长度
for (int i = grap;i < array.length;i++){
// 因为后面代码要对i值进行修改,所以把当前的i值和数组值存到一个变量中
int temp = array[i];
int j = i;
if (temp < array[j - grap] ){
while (j - grap >= 0 && temp < array[j - grap]){
array[j] = array[j - grap];
j = j - grap; //每次减少一个步长,确保在同一个组内移动
}
array[j] = temp;
}
}
}
}
}
五. 快速排序(可以看成是冒泡排序的优化。它的思想是先选择一个数,然后将比这个数大的放在一边,比这个数小的放在一边,然后用递归实现排序。因为用的是递归,快排还是比较快的。)
package com.bzw.sort;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
public class QuickSort {
public static void main(String[] args) {
// int[] array = {4,3,-1,78,45,0,3,10};
int[] array = new int[80000000];
for (int i=0;i<array.length;i++){
array[i] = (int)Math.random()*80000000;
}
Date datal = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String datelStr = simpleDateFormat.format(datal);
System.out.println("排序前的时间"+datelStr);
quickSort(array,0,array.length-1);
Date data2 = new Date();
String datelStr2 = simpleDateFormat.format(data2);
System.out.println("排序后的时间"+datelStr2);
// System.out.println(Arrays.toString(array));
}
public static void quickSort(int[] array,int left,int right){
int l = left;
int r = right;
int pivot = array[(left + right) / 2];
int temp = 0;
while (l < r ){
while (array[l] < pivot){
l ++;
}
while (array[r] > pivot){
r --;
}
if (l >= r){
break;
}
temp = array[l];
array[l] = array[r];
array[r] = temp;
if (array[r] == pivot){ //交换完如果发现 array[r] == pivot,要将左下标手动向后移一位,
l ++; // 不然 l 就不会动了,造成死循环(可以举个相等的例子,画图理解)
}
if (array[l] == pivot){ //右下标同理
r --;
}
}
// 当 l == r 必须l++,r-- 否则出现栈溢出
// 当l == r时,如果不手动l++,r--的话,l和r的值将不在发生变化(因为没有其他代码使其变化),那么递归的条件将不会发生改变,
// 递归函数不停的压栈,最终导致栈溢出
if (l == r){
l ++;
r --;
}
if (left < r){
quickSort(array,left,r);
}
if (l < right){
quickSort(array,l,right);
}
}
}
六. 归并排序(采用分治策略,将一个数组分解成一个个的数,再进行合并,最终完成排序。合并的思路:将左面的一组和右面的一组进行比较,将较小的或较大的数放到一个临时数组中,最后将这个临时数组再复制原数组。)
package com.bzw.sort;
import java.util.Arrays;
public class MergerSort {
public static void main(String[] args) {
int[] array = {6,29,17,9,3,11,-3,0,4};
int[] temp = new int[array.length];
mergerSort(array,0,array.length-1,temp);
System.out.println(Arrays.toString(array));
}
//分解 + 合并
public static void mergerSort(int[] array,int left,int right,int[] temp){
if (left < right){
int mid = (left + right) / 2;
//向左递归分解
mergerSort(array,left,mid,temp);
//向右递归分解
mergerSort(array,mid+1,right,temp);
//合并
merger(array,left,right,mid,temp);
}
}
//合并
public static void merger(int[] array ,int left,int right,int mid,int[] temp ){
int l = left;
int j = mid + 1;
int t = 0;
while (l <= mid && j <= right){
if (array[l] <= array[j]){
temp[t] = array[l];
t++;
l++;
}else {
temp[t] = array[j];
t++;
j++;
}
}
while (l <= mid){
temp[t] = array[l];
t++;
l++;
}
while (j <= right){
temp[t] = array[j];
t++;
j++;
}
//把temp中的值复制到array中,这里的tempLeft表明复制到array哪个位置。
t = 0;
int tempLeft = left;
while (tempLeft <= right){
array[tempLeft] = temp[t];
tempLeft++;
t++;
}
}
}
七. 基数排序(桶排序的扩展,它的思想很简单,把一组数先按个位数字的大小排序,再按十位数字的大小排序,然后百位,千位.........。所以需要10个桶(一位数组)分别表示0-9 十个数,而且也不能确定每个桶中有多少的数,只能按最坏的情况算,即每个桶的大小都是和原数组大小一样。这样有时候就会造成空间的浪费,基数排序就是空间换时间的经典算法。)
package com.bzw.sort;
import java.util.Arrays;
public class RadixSort {
public static void main(String[] args) {
int[] array = {3,35,3,0,9,7};
radixSort(array);
System.out.println(Arrays.toString(array));
}
public static void radixSort(int[] array){
//用一个二维数组表示桶和桶中的数据,比如bucket[1][2] = 31 表示编号为1的桶在第二个位置有个数是31
int[][] bucket = new int[10][array.length];
//表示桶中有多少个数,比如bucketElement[4] = 3 表示编号为4这个桶中有3个数据(有一个数组来存储,便于后面将值取出赋给array)
int[] bucketElement = new int[10];
int max = array[0];
for (int i = 0;i < array.length;i++){
if (array[i] > max){
max = array[i];
}
}
int length = (max + "").length();//最大值的位数
// System.out.println(length);
for (int j = 0,n = 1;j < length;j++,n = n * 10){
for (int i = 0;i < array.length;i++){
int data = array[i] / n % 10;
bucket[data][bucketElement[data]] = array[i];
bucketElement[data]++;
}
int index = 0;
for (int k = 0;k <bucketElement.length;k++){
if (bucketElement[k] != 0){
for (int l = 0;l <bucketElement[k];l++){
array[index++] = bucket[k][l];
}
}
bucketElement[k] = 0;
}
System.out.println("第" + (j + 1) +"轮后" + Arrays.toString(array));
}
}
}
八. 总结
稳定表示,如果两个相同的数,在排序过后,原来在前面的那个数仍然在前面。不稳定就不确定了。
In-place表示没有额外占用空间,Out-place表示有额外占用空间。
当数的规模较大的时候(超过2^10),用基数排序较快。