排序算法汇总

（从小到大排序）

1.冒泡排序

　　冒泡排序类似于小鱼吐泡泡，大的泡泡往上走。每一趟排序都将当前排序范围中最大的元素放到最右侧的位置。

　　对 4 5 6 3 2 1 进行冒泡排序：

　　第一趟：4 5 3 2 1 6

　　第二趟：4 3 2 1 5 6

　　第三趟：3 2 1 4 5 6

　　第四趟：2 1 3 4 5 6

　　第五趟：1 2 3 4 5 6

　　相关代码如下：

import java.util.*;
class test  
{
    public static void main (String[] args) throws java.lang.Exception
    {
        //实现冒泡算法
        int[] array = {1,7,5,6,8,9,2,3,0};
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
        bubbleSort(array);
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
        
    }
    public static void bubbleSort(int[] array){
        int len = array.length;
        
        for(int i=0;i<len;i++){
            boolean flag = false;
            for(int j=1;j<len-i;j++){
                if(array[j]<array[j-1]){
                    int temp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = temp;
                    flag = true;
                }
                
            }
            if(flag == false)
                return;
        }
    }
}

　　时间复杂度为O(n²)。

　　当相邻的两个元素相等的时候，是不用进行交换的，所以冒泡排序是稳定的排序算法！

2.选择排序

　　选择排序是从待排序的元素中选择最大/最小的，将其放在最合适的位置。

　　待排序序列：38,12,92,12,52,66,39,99

　　第一次选择排序结果：12,38,92,12,52,66,39,99

　　第二次选择排序结果：12,12,92,38,52,66,39,99

　　第三次选择排序结果：12,12,38,92,52,66,39,99　　

　　第四次选择排序结果：12,12,38,39,52,66,92,99　

　　第五次选择排序结果：12,12,38,39,52,66,92,99

　　第六次选择排序结果：12,12,38,39,52,66,92,99

　　第七次选择排序结果：12,12,38,39,52,66,92,99

具体代码为：

import java.util.*;
class test  
{
    public static void main (String[] args) throws java.lang.Exception
    {
        //实现选择排序
        int[] array = {1,7,5,6,8,9,2,3,0};
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
        
        selectSort(array);
        
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
        
    }
    public static void selectSort(int[] array){
       int len = array.length;
       for(int i=0;i<len-1;i++){
           int min = array[i];
           int index = i;
           
           for(int j=i+1;j<len;j++){
               if(array[j]<min){
                    min = array[j];
                    index = j;
               }
           
           }
           if(min!=array[i]){
               int temp = array[index];
               array[index] = array[i];
               array[i] = temp;
           }
           
       }
    }
}

　　时间复杂度为O(n²)，由于选择之后可能会交换两个相同元素的前后位置，所以是不稳定的排序。

3.插入排序

　　把未排序的元素从后往前插入到已经排好序的序列中。　适用于处理数据量比较少或者序列部分有序的情况。

适用处理数据量比较少或者部分有序的数据
本文由 帅地玩编程(www.iamshuaidi.com) 辛苦整理，可以拿去当作本地笔记，但请勿抄袭发布在自家网站或者博客引流，否则必追究(原文来自：https://www.iamshuaidi.com/535.html)

import java.util.*;
class test  
{
    public static void main (String[] args) throws java.lang.Exception
    {
        //实现插入排序
        int[] array = {1,7,5,6,8,9,2,3,0};
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
        
        insertSort(array);
        
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
        
    }
    
    public static void insertSort(int[] array){
       int len = array.length;
       for(int i=1;i<len;i++){
           int insert = array[i];
          int j=i-1;
           for(;j>=0 && insert<array[j];j--){
               array[j+1] = array[j];
           }
           array[j + 1] = insert;
       }
    }
}

　　时间复杂度为O(n²)，从后往前插入的过程中，相等的话不需要移动，所以是稳定的排序算法。

4.希尔排序

　　希尔排序是插入排序的改进版，将元素以每k个为一组先进行分组，然后对这一组的数据实行插入排序，这样大的元素就靠后了，小的元素就靠前了。初始时k=n/2，分为两组，插入排序完成之后再将k除以2，直到k为1为止。

　　具体代码如下：

import java.util.*;
class test  
{
    public static void main (String[] args) throws java.lang.Exception
    {
        //实现希尔排序
        int[] array = {1,7,5,6,8,9,2,3,0};
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
        
        shellSort(array);
        
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
        
    }
    
    public static void shellSort(int[] array){
       int n = array.length;
       for(int gap=n/2;gap>0;gap/=2){
           for(int i=gap;i<n;i++){
               insert(array,gap,i);
           }
       }
    }
    public static void insert(int[] array,int gap,int i){
        int inserted = array[i];
        int j ;
        for(j=i-gap;j>=0&&array[j]>inserted;j-=gap){
            array[j+gap] = array[j];
        }
        array[j+gap] = inserted;
    }
}

　　时间复杂度为O(n^1.3)，因为希尔排序是跳跃性插入，所以可能会破坏两个相同元素的前后位置，是不稳定的排序算法。

5.快速排序

　　先选取一个基准元素，基准元素左侧的都小于基准，基准右侧的都大于基准元素。每一趟排序都能够确定一个基准元素的位置，然后再对基准左右两侧的元素分别递归进行快排。

　　具体代码如下：

import java.util.*;
class test  
{
    public static void main (String[] args) throws java.lang.Exception
    {
        //实现快速排序
        int[] array = {1,7,5,6,8,9,2,3,0};
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
        
        quickSort(array,0,array.length-1);
        
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
        
    }
    
    public static void quickSort(int[] array,int left,int right){
        if(left>=right)
            return;
        
       int start = left;
       int end = right;
       int temp = array[left];
       while(left<right){
           while(left<right&&array[right]>=temp){
               right--;
           }
           array[left] = array[right];
           while(left<right&&array[left]<temp){
               left++;
           }
           array[right] = array[left];
       }
       array[left] = temp;
       quickSort(array,start,left-1);
       quickSort(array,left+1,end);
    }
}

　　平均时间复杂度为O(nlogn),最坏时间复杂度是O(n²)，不稳定。

6.归并排序

　　归并排序就是用的一个“分而治之”的思想，分----并

　　具体代码如下：

import java.util.*;
class test  
{
    public static void main (String[] args) throws java.lang.Exception
    {
        //实现归并排序
        int[] array = {1,7,5,6,8,9,2,3,0};
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
        int[] temp = new int[array.length];
        
        mergeSort(array,temp, 0,array.length-1);
        
        for(int i=0;i<array.length;i++){
            System.out.print(array[i]+" ");
        }
        System.out.println();
        
    }
    
    public static void mergeSort(int[] array, int[] temp,int left,int right){
        if(left<right){
            int center = (left+right)/2;
            mergeSort(array,temp,left,center);
            mergeSort(array,temp,center+1,right);
            merge(array,temp,left,center,right);
        }
    }
    public static void merge(int[] array,int[] temp,int left,int center,int right){
        int i=left,j=center+1;
        for(int k=left;k<=right;k++){
            if(i>center)
                temp[k] = array[j++];
            else if(j>right)
                temp[k] = array[i++];
            else if(array[i]<array[j])
                temp[k] = array[i++];
            else
                temp[k] = array[j++];
        }
        for(int k=left;k<=right;k++){
            array[k] = temp[k];
        }
    }
}

　　时间复杂度为O(nlogn)，是稳定的排序算法。