几种常见排序算法的Java实现及时间复杂度

常见的的几种排序方式的Java实现

在我们的学习中，在很多的环境里，我们都要进行排序，这里来介绍几种常见的排序方式的Java实现
排序方法主要分为两种排序
- 稳定排序：基数排序、冒泡排序、直接插入排序、折半插入排序、归并排序
- 不稳定排序：快速排序、希尔排序、堆排序、直接选择排序

由于篇幅有限这里就只说说基数排序、冒泡排序、直接插入排序、快速排序以下的用Java来实现各种排序方法
1.冒泡排序 对于冒泡排序，相信对每个人人都很熟悉，这个是每个学习编程的人都会学习的排序方法
具体的原理就是未排好，自上而下的比较，小的数就往上冒，大的数就往下沉，按理来说冒泡排序总共的次数最多为n(n-1)/2

package com.dxh.sort;

import java.util.ArrayList;
import java.util.Scanner;

public class BubbleSort {
    public static void bubbleSort(int [] array){
        int tem = 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]){
                    tem = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tem;
                }
            }
        }

    }

    public static void main(String [] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();//数组的长度
        int [] array = new int [n];
        for(int i = 0;i<n;i++){
            array[i] = in.nextInt();
        }
        bubbleSort(array);
        ArrayList<Integer> list = new ArrayList<>();
        for(int e:array){
            list.add(e);
        }
        System.out.println(list);
    }

}

2.基数排序 运用二维数组来分别比较每一位，个位、十位、百位…
输入10个整数的数组

package com.dxh.sort;

import java.util.ArrayList;
import java.util.Scanner;

public class RadixSort {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int d = in.nextInt();//d为最大数的位数1,10,100。。。
        int [] array =new int [10];
        for(int i = 0;i<10;i++){
            array[i] = in.nextInt();
        }
        radixSort(d,array);
//      for(int e:array){
//          System.out.println(e);
//      }
        //为了输出好看，用了一个ArrayList数组
        ArrayList<Integer> list = new ArrayList<>();
        for(int e:array){
            list.add(e);
        }
        System.out.println(list);


    }

    //d为位数，
    private static void radixSort(int d,int[] array){
        int n=1;//代表位数对应的数：1,10,100...
        int k=0;//保存每一位排序后的结果用于下一位的排序输入
        int[][] bucket=new int[10][array.length];//排序桶用于保存每次排序后的结果，这一位上排序结果相同的数字放在同一个桶里
        int[] num=new int[array.length];//用于保存每个桶里有多少个数字 ,最多为输入数组长度
        while(n<=d)
        {
            for(int e:array) //将数组array里的每个数字放在相应的桶里
            {
                int digit=(e/n)%10;
                bucket[digit][num[digit]]=e;
                num[digit]++;
            }
            for(int i=0;i<array.length;i++)//将前一个循环生成的桶里的数据覆盖到原数组中用于保存这一位的排序结果
            {
                if(num[i]!=0)//这个桶里有数据，从上到下遍历这个桶并将数据保存到原数组中
                {
                    for(int j=0;j<num[i];j++)
                    {
                        array[k]=bucket[i][j];
                        k++;
                    }
                }
                num[i]=0;//将桶里计数器置0，用于下一次位排序
            }
            n*=10;
            k=0;//将k置0，用于下一轮保存位排序结果
        }

    }


}

3.直接插入排序
直接插入排序就是我们假设前面的数为有序数列，然后有序数列与无序数列的每个数比较，我们可以从右向左比较
当 array[i]<=array[j]=

package com.dxh.sort;

import java.util.ArrayList;
import java.util.Scanner;

public class DirectInsertSort {
    public static void directInsertSort(int [] array){
        int tem = 0;
        for(int i = 1;i<array.length;i++){
            int j = i-1;
            tem = array[i];
            for(;j>=0&&array[j]>tem;j--){
                array[j+1] =array[j];//将大于array[i]的数整体后移一单位
            }
            array[j+1] = tem;
        }
    }
    public static void main(String [] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();//数组长度
        int array []  =new int [n];
        for(int i = 0;i<n;i++){
            array[i] = in.nextInt();
        }
        directInsertSort(array);
//      for(int i = 0;i<array.length;i++){
//          System.out.println(array[i]);
//      }
        ArrayList<Integer> list = new ArrayList<>();
        for(int e:array){
            list.add(e);
        }
        System.out.println(list);

    }

}

4.快速排序
快速排序可以以第一个数作为一个旗帜k,在前后分别设置i和j两个标识，然后从右向左遍历，直到找到一个小于k的值，交换这两个值
在从左向右遍历，一直到i=j就结束，这样就完成了一轮排序，然后采用递归的方法，直到i>=j就完成了快速排序

package com.dxh.sort;

import java.util.ArrayList;
import java.util.Scanner;

public class RapidSort {
    public static void rapidSort(int [] array,int n){
        if(array == null||n<1){
            System.out.println("Error");
            return;
        }
        rapidSort(array,0, n-1);
    }
    public static void rapidSort(int [] array,int start,int end){

        if(start>end){
            return;
        }
        int i = start;
        int j = end;
        int k = array[i];
        boolean flag = true;
        while(i!=j){
            if(flag){
                if(k>array[j]){
                    swap(array,i,j);
                    flag = false;
                }else{
                    j--;
                }
            }else{
                if(k<array[i]){
                    swap(array,i,j);
                    flag = true;
                }else{
                    i++;
                }
            }
        }
        //递归
        rapidSort(array, start, j-1);
        rapidSort(array, i+1, end);


    }
    /*
     * 交换两个元素的位置
     */
    public static void swap(int [] array,int i,int j){
        int tem = 0;
        tem = array[i];
        array[i] = array[j];
        array[j] = tem;

    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int [] array = new int [n];
        for(int i = 0;i<n;i++){
            array[i] = in.nextInt();
        }
        rapidSort(array, n);
        ArrayList<Integer> list = new ArrayList<>();
        for(int e:array){
            list.add(e);
        }
        System.out.println(list);
    }

}