八大排序算法(Java，便于理解)

时间换空间排序算法

一.冒泡排序

java 复制代码

package SortDemo;

import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;

public class BubbleSort {
    //冒泡排序,相邻两个数两两比较
    private int[]a;

    public void swap(int i,int j){
        int temp=a[i];
         a[i]=a[j];
         a[j]=temp;
    }
    public void sort(int []arr){
        this.a=arr;
        int count=0;//统计程序运行次数
        //排序
        for (int i = 0; i <a.length-1; i++) {
            for (int j = 0; j <a.length-1-i; j++) {
                //从小到大排序
                if(a[j]>a[j+1]){
                    swap(j,j+1);
                }
                count++;
            }
        }
    }
    public void print(){
        System.out.println(Arrays.toString(a));
    }
    public static void main(String[] args) {
        int []a={1,9,3,6,8,4};

       BubbleSort  bubbleSort = new BubbleSort();
       bubbleSort.sort(a);
       bubbleSort.print();
    }
}

二.选择排序

java 复制代码

package SortDemo;

import java.util.Arrays;

public class SelectSort {
    private int[]a;

    public void swap(int i,int j){
        int temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }

    public void sort(int []arr){
        this.a=arr;

        //选择排序
        for (int i = 0; i <a.length; i++) {
            int min=arr[i];
            for (int j = i+1; j <a.length; j++) {
                if(arr[j]<min){
                    min=arr[j];
                    swap(i,j);
                }
            }
        }
    }
    public void print(){
        System.out.println(Arrays.toString(a));
    }
    public static void main(String[] args) {
        int []a={1,9,3,6,8,4};
       SelectSort selectSort = new SelectSort();
       selectSort.sort(a);
       selectSort.print();
    }
}

三.插入排序

java 复制代码

package SortDemo;

import java.util.Arrays;

public class InsertSort {
    private int[]a;

    public void swap(int i,int j){
        int temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
    public void sort(int []arr){
        this.a=arr;

        //排序
        for (int i = 1; i <a.length; i++) {
           int j=i;
           int tmp=a[i];//要插入的数据
           for (;j>0&&tmp<a[j-1];j--){
               a[j]=a[j-1];
           }
           a[j]=tmp;
        }
    }
    public void print(){
        System.out.println(Arrays.toString(a));
    }
    public static void main(String[] args) {
        int []a={1,9,3,6,8,4};
        InsertSort insertSort=new InsertSort();
         insertSort.sort(a);
         insertSort.print();
    }
}

四.希尔排序

java 复制代码

package SortDemo;

import java.util.Arrays;

public class XRSort {
    //希尔排序
    //先找到
    private int[]a;
    public void swap(int i,int j){
        int temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
    public void print(){
        System.out.println(Arrays.toString(a));
    }
    public void sort(int []arr) {
        this.a = arr;
        int gap=a.length/2;
        //排序
        while (gap>0){
            for (int i = gap; i < a.length; i++) {
                int j = i;
                int tmp = a[i];//默认第一个已经排好序
                for (; j >=gap && tmp < a[j - gap]; j-=gap) {
                    a[j] = a[j - gap];
                }
                a[j] = tmp;
            }
            gap/=2;
        }

    }

    public static void main(String[] args) {
        int []a={1,9,3,6,8,4};
         XRSort xrSort=new XRSort();
         xrSort.sort(a);
         xrSort.print();
    }
}

空间换时间排序算法

一.计数排序

java 复制代码

package SortDemo;

import java.util.Arrays;

public class CountStringSort {
    private int[] arr;

    public CountStringSort(int[] arr) {
        this.arr = arr;
    }

    //计数排序，先找到该数组最大的值作为一个新数组的索引
    public void sort(){

     int maxval=Arrays.stream(arr).max().getAsInt();

      //创建一个新数组统计每个索引对应的数字出现的个数
     int []s=new int[maxval+1];
     Arrays.fill(s,-1);//默认新建的数组的值为-1;

        for (int index : arr) {
            s[index]++;
        }

        //遍历新数组
        int count=0;
        for (int i = 0; i <s.length; i++) {
            while (s[i]>-1){
                arr[count++]=i;
                s[i]--;
            }
        }
    }

    public void print(){
        System.out.println(Arrays.toString(arr));
    }
    public static void main(String[] args) {
        int []a={1,9,3,6,8,4,3};
      CountStringSort countStringSort = new CountStringSort(a);
      countStringSort.sort();
      countStringSort.print();

    }
}

二.桶排序

java 复制代码

package SortDemo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class BucketSort {
    private int[]sum;
    //桶排序
    public void sort(int []arr){
        this.sum=arr;

        int n=10;//用来计算取要排序数组里的数在那个桶里面

        int size=0;//用来最后反向填充要排序数组索引

        //取要排序数组里最大数作为桶的个数
        int maxval= Arrays.stream(arr).max().getAsInt();

        //桶的个数
        List<Integer>bucket[]=new List[maxval];

        //初始化桶
        for (int i = 0; i <maxval; i++) {
            bucket[i]=new ArrayList<>();
        }

       //将数组数据归类桶
        for (int t : arr) {
           int  index=t/n;//第几个桶
           bucket[index].add(t);
        }

        //对桶里面的数据进行排序
        for (List<Integer> list : bucket) {
            list.sort((o1, o2) -> o1-o2);
        }

        //将每个桶中排好序的的数据依次反向填充到要排序的原数组中
        for (int i = 0; i <bucket.length; i++) {
            for (int j = 0; j <bucket[i].size(); j++) {
                arr[size++]=bucket[i].get(j);
            }
        }
        System.out.println(Arrays.toString(arr));
    }

    public static void main(String[] args) {
     new BucketSort().sort(new int[]{3,7,3,8,19,22,123,8,0});
    }
}

三.基数排序

java 复制代码

package SortDemo;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class RadixSort {
    private int[] a;

    //基数排序
    public void sort(int[] a) {
        this.a = a;
        final int SIZE = 10;//桶的个数

        int maxVal = Arrays.stream(a).max().getAsInt();//拿到数组最大数
        int len = (int) (Math.log10(maxVal) + 1);//拿到最大数的位数
        int divisor = 1;//

         //循环最大数位数次,分别对数组每位数字依次进行排序
        for (int i = 0; i < len; i++) {
            List<Integer>[] bukets = new List[SIZE];//桶
            //初始化桶
            for (int k = 0; k < SIZE; k++) {
                bukets[k] = new ArrayList<>();
            }


            for (int val : a) {
                int index = val / divisor % SIZE;
                bukets[index].add(val);
            }
            //对桶内数据排序
            for (List<Integer> list : bukets) {
                list.sort(Comparator.comparingInt(o -> o));
            }
            //放入数组中
            int pos = 0;
            for (List<Integer> list : bukets) {
                if (!list.isEmpty()) {
                    for (int tmp : list) {
                        a[pos++] = tmp;
                    }
                }
            }
            divisor *= 10;
        }
    }


    public void print() {
        System.out.println(Arrays.toString(a));
    }


    public static void main(String[] args) {
        RadixSort sort = new RadixSort();
        sort.sort(new int[]{128,3,7,8,19,22,123});
        sort.print();
    }
}