2021-06-04

排序算法小结

最近学习了一些经典的排序算法，再加上之前学习的3个排序算法，现总结如下。

到现在我一共学习了8种排序算法：冒泡排序，选择排序，插入排序，希尔排序，快速排序，归并排序，堆排序，基数排序，计数排序。

其中前三个是之前学习的3个基础的排序算法，后面5个是最近学习的进阶的排序算法。

---

1.冒泡排序(bubble sort)

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

            for (int j = 0; j < a.length - 1 - i; j++) {

                if(a[j+1]<a[j]){
                    swap(a,j+1,j);
                }
            }
        }

---

2.选择排序（election sort）

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

            for (int j = i + 1; j < a.length; j++) {

                if(a[j]<a[i]){
                    swap(a,j,i);
                }
            }
        }

---

3.插入排序（inserting sort）

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

            for (int j = 0; j < i; j++) {

                if(a[i]<a[j]){
                    swap(a,i,j);
                }
            }
        }

---

4.希尔排序（shell sort）

        for (int h = a.length/2; h > 0; h=h/2) {

            for (int i = h; i < a.length; i++) {

                for (int j = i; j > h-1 ; j-=h) {
                   if(a[j]<a[j-h]){
                       swap(a,j,j-h);
                   }
                }
            }
        }

---

5.快速排序（quick sort）

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {

        int[] a = {12,56,15,6,84,6,986,6,56,6};

        quickSort(a,0,a.length-1);

        System.out.println(Arrays.toString(a));
    }

    private static void quickSort(int[] a, int start, int end) {

        if(start<end){

            int index = getIndex(a,start,end);
            quickSort(a,start,index-1);
            quickSort(a,index+1,end);
        }
    }

    private static int getIndex(int[] a, int start, int end) {

        int i = start;
        int j = end;
        int x = a[start];

        while(i<j){
            while(i<j&&a[j]>x){
                j--;
            }
            if(i<j){
                a[i] = a[j];
                i++;
            }

            while(i<j&&a[i]<x){
                i++;
            }
            if(i<j){
                a[j] = a[i];
                j--;
            }
        }

        a[i] = x;
        return i;

    }

}

---

6.归并排序（mergeSort）

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {

        int[] a = {12,56,15,6,84,6,986,6,56,6};

        mergerSort(a,0,a.length-1);

        System.out.println(Arrays.toString(a));
    }

    private static void mergerSort(int[] a, int start, int end) {

        int mid = (start+end)/2;
        if(start<end){

            mergerSort(a,start,mid);
            mergerSort(a,mid+1,end);
            sort(a,start,end);
        }
    }

    private static void sort(int[] a, int start, int end) {

        int i = start;
        int mid = (start+end)/2;
        int j = mid+1;
        int[] temp = new int[end-start+1];
        int index = 0;

        while(i<=mid&&j<=end){
            if(a[i]<a[j]){
                temp[index++] = a[i];
                i++;
            }else{
                temp[index++] = a[j];
                j++;
            }
        }

        while(i<=mid){
            temp[index++] = a[i++];
        }
        while(j<=end){
            temp[index++] = a[j++];
        }

        for (int h = 0;  h< temp.length; h++) {

            a[start+h] = temp[h];
        }
    }

}

---

7.堆排序（heapSort）

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {

        int[] a = {11,13,546,89,9,165,46,89,46,46,13,646,88};

        int startIndex = (a.length-1)/2;
        for (int i = startIndex; i >= 0; i--) {

            toMaxHeap(a,a.length,i);
        }

        for (int i = a.length-1; i > 0; i--) {

            int temp = a[0];
            a[0] = a[i];
            a[i] = temp;
            toMaxHeap(a,i,0);
        }

        System.out.println(Arrays.toString(a));
    }

    private static void toMaxHeap(int[] a, int size, int index) {

        int i = 2*index+1;
        int j = 2*index+2;
        int maxIndex = index;

        if(i<size&&a[maxIndex]<a[i]){
            maxIndex = i;
        }
        if(j<size&&a[maxIndex]<a[j]){
            maxIndex = j;
        }

        if(maxIndex!=index){

            int temp = a[index];
            a[index] = a[maxIndex];
            a[maxIndex] = temp;
            toMaxHeap(a,size,maxIndex);
        }
    }
}

---

8.基数排序（radixSort）

下面是两种不同的实现方法

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {

        int[] a = {12,56,15,6,84,6,986,6,56,6};

        radixSort(a);

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

    }

    private static void radixSort(int[] a) {

        int max = getMax(a);
        int digit = String.valueOf(max).length();

        int[] counts = new int[10];
        int[] b = new int[a.length];

        for (int i = 1; i <= max; i*=10) {

            for (int j = 0; j < a.length; j++) {

                counts[(a[j]/i)%10]++;
            }

            for (int j = 1; j < counts.length; j++) {

                counts[j] = counts[j]+counts[j-1];
            }

            for(int j = a.length-1; j>=0; j--){

                b[--counts[(a[j]/i)%10]] = a[j];

            }

            for (int j = 0; j < counts.length; j++) {

                counts[j] = 0;
            }
            
            for (int j = 0; j < a.length; j++) {

                a[j] = b[j];
            }
        }

    }

    private static int getMax(int[] a) {

        int max = a[0];

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

            if(a[i]>max){
                max = a[i];
            }
        }

        return max;
    }

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {

        int[] a = {12,56,15,6,84,6,986,6,56,6};

        radixSort(a);

        System.out.println(Arrays.toString(a));
    }

    private static void radixSort(int[] a) {

        int[][] radix = new int[10][a.length];
        int[] counts = new int[10];
        int max = getMax(a);
        int digit = String.valueOf(max).length();

        for (int i = 0,n = 1; i < digit; i++,n*=10) {

            for (int j = 0; j < a.length; j++) {

                int num = a[j]/n%10;
                radix[num][counts[num]++] = a[j];
            }

            int index = 0;
            for (int k = 0; k < counts.length; k++) {

               if(counts[k]!=0){
                   for (int h = 0; h < counts[k]; h++) {

                       a[index++] = radix[k][h];
                   }
                   counts[k] = 0;
               }
            }
        }

    }

    private static int getMax(int[] a) {

        int max = a[0];
        for (int i = 1; i < a.length; i++) {

            if(a[i]>max){
                max = a[i];
            }
        }
        return max;
    }

}

---

9.计数排序（countingSort)

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {

        int[] a = {12,56,15,6,84,6,986,6,56,6};

        a = countingSort(a);

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

    }

    private static int[] countingSort(int[] a) {

        int max = getMax(a);
        int min = getMin(a);
        int[] counts = new int[max-min+1];

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

            counts[a[i]-min]++;
        }

        for (int i = 1; i < counts.length; i++) {

            counts[i] = counts[i]+counts[i-1];
        }

        int[] b = new int[a.length];

        for(int i = a.length-1; i>=0; i--){

            b[--counts[a[i]-min]] = a[i];
        }

       return b;
    }

    private static int getMin(int[] a) {

        int min = a[0];
        for (int i = 1; i < a.length; i++) {

            if(a[i]<min){
                min = a[i];
            }
        }

        return min;
    }

    private static int getMax(int[] a) {

        int max = a[0];
        for (int i = 1; i < a.length; i++) {

            if(a[i]>max){
                max = a[i];
            }
        }
        return max;
    }

}