JAVA排序算法

JAVA排序算法

快速排序

public class QuickSort {
    public int partition(int[] a, int low, int high){
        int i = low;
        int j = high + 1;
        int v = a[low];
        while (true){
            while (a[++i] <= v) if (i == high) break;
            while (a[--j] >= v) if (j == low) break;
            if (i >= j) break;
            exch(a, i, j);
        }
        exch(a, low, j);
        return j;
    }

    private void exch(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }

    public void quickSort(int[] a, int low, int high){
        if (low < high){
            int j = partition(a, low, high);
            quickSort(a, low, j - 1);
            quickSort(a, j + 1, high);
        }
    }

    public static void main(String[] args) {
        QuickSort quickSort = new QuickSort();
        int[] a = {1, 1, 2, 3, 4, 5, 6};
        quickSort.quickSort(a, 0, a.length - 1);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

}

归并排序

public class MergeSort {



    public void mergeSort(int[] a, int low, int high){
        if (low < high){
            int middle = (low + high) / 2;
            mergeSort(a, low, middle);
            mergeSort(a, middle + 1, high);
            merge(a, low, middle, high);
        }
    }

    private void merge(int[] a, int low, int middle, int high) {
        int[] temp = new int[a.length];
        int p1 = low, p2 = middle + 1, k = low;
        while (p1 <= middle && p2 <= high){
            if (a[p1] < a[p2]) temp[k++] = a[p1++];
            else temp[k++] = a[p2++];
        }
        while (p1 <= middle) temp[k++] = a[p1++];
        while (p2 <= high) temp[k++] = a[p2++];

        for (int i = low; i <= high; i++) {
            a[i] = temp[i];
        }
    }



    public static void main(String[] args) {
        MergeSort mergeSort = new MergeSort();
        int[] a = {1, 5, 9, 4, 3, 6, 7};
        mergeSort.mergeSort(a, 0, a.length - 1);
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }
}

插入排序

public void insertSort(int[] a){
    for (int i = 0; i < a.length; i++) {
        int tmp = a[i];
        int j = i - 1;
        for (; j >= 0; j--) {
            if (a[j] > tmp){
                a[j + 1] = a[j];
            } else {
                break;
            }
        }
        a[j + 1] = tmp;
    }
}

冒泡排序

public void bubbleSort(int[] a){
    for (int i = 0; i < a.length; i++) {
        
        boolean flag = false;
        for (int j = 0; j < a.length - 1 - i; j++) {
            if (a[j] > a[j + 1]){
                int tmp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = tmp;
                flag = true;
            }
        }
        if (!flag) break;
    }
}

选择排序

public void selectSort(int[] a){
    for (int i = 0; i < a.length; i++) {
        int min = i;
        for (int j = i + 1; j < a.length; j++) {
            if (a[j] < a[min])
                min = j;
        }
        int tmp = a[i];
        a[i] = a[min];
        a[min] = tmp;
    }
}

堆排序

import java.util.Arrays;

/**
 * Created by Administrator on 2019/9/23.
 */
public class HeapSort {

    public void HeapSort(int[] a){
        for (int i = a.length / 2 - 1; i >= 0; i--) {
            adjustHeap(a, i, a.length);
        }

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

    private void swap(int[] a, int i, int i1) {
        int tmp = a[i];
        a[i] = a[i1];
        a[i1] = tmp;
    }

    private void adjustHeap(int[] a, int i, int length) {
        int tmp = a[i];
        for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {
            if (k + 1 < length && a[k + 1] > a[k])
                k++;
            if (a[k] > tmp){
                a[i] = a[k];
                i = k;
            } else {
                break;
            }
        }
        a[i] = tmp;
    }

    public static void main(String[] args) {
        HeapSort heapSort = new HeapSort();
        int[] a = {1, 7, 2, 9, 5, 3};
        heapSort.HeapSort(a);
        System.out.println(Arrays.toString(a));
    }
}

希尔排序

将整个无序序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序时，再对全体元素进行一次直接插入排序。

public void shellSort(int[] a){
    int n=a.length;
    int i,j,k,gap;
    for(gap=n/2;gap>0;gap/=2){
        for(i=0;i<gap;i++){
            for(j=i+gap;j<n;j+=gap){
                int temp = a[j];
                for(k=j-gap;k>=0 && a[k]>temp;k-=gap){
                    a[k+gap]=a[k];
                }
                a[k+gap]=temp;
            }
        }
    }
}

各排序算法性能比较