【数据结构】—— Java实现快速排序、归并排序

一、排序的概念及稳定性

- 概念： 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。

- 稳定性： 简单来说就是在一组还未排序的数据中，两个关键字具有相同属性（相当于两个数字相等，即5 = 5）再经过排序后两个关键字的顺序不变，如以下示例。

二、快速排序

1.基本思想

快速排序： 通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

2.代码实现

public class QuickSort {
    public void sort (int[] array) {
        int left = 0;
        int right = array.length - 1;
        sort(array,left,right);
    }

    private void sort(int[] array, int left, int right) {
        if (left >= right) {
            return ;
        }
        int pivotKey = array[left];
        int low = left;
        int high = right;
        while (low < high) {
            while (low < high && array[high] >= pivotKey) {
                high--;
            }
            while (low < high && array[low] <= pivotKey) {
                low++;
            }
            swap(array,low,high);
        }
        swap(array,left,low);

        sort(array,left,low - 1);

        sort(array,low + 1,right);
    }

    private void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}


import java.util.Arrays;

public class QuickSortTest {
    public static void main(String[] args) {
        QuickSort quickSort = new QuickSort();
        int[] array = {23, 5, 21, 28, 52, 30, 31, 18, 6, 8, 3, 21};
        quickSort.sort(array);
        System.out.println(Arrays.toString(array));
    }
}

三、归并排序

1.基本思想

归并排序 归并排序也是分治算法的一个运用，它就是利用分治的思想是实现排序的方法。首先先把数组分成n个记录，这个过程是“分”的过程，然后再把这n个记录合并成有序的序列，这个过程是“治”的过程。

2.代码实现

public class Merge {
    public void sort (int[] array) {
        int left = 0;
        int right = array.length - 1;

        sort(array,left,right);
    }

    private void sort(int[] array, int left, int right) {
        if (left >= right) {
            return ;
        }

        int mid = left + (right - left) / 2;
        sort(array,left,mid);
        sort(array,mid + 1,right);

        merging(array,left,right,mid);

    }

    private void merging(int[] array, int start, int end, int mid) {
        if (start >= end) {
            return ;
        }

        int p1 = start;
        int p2 = mid + 1;
        int index = 0;
        int[] assist = new int[end - start + 1];

        while (p1 <= mid && p2 <= end) {
            if (array[p1] < array[p2]) {
                assist[index++] = array[p1++];
            } else {
                assist[index++] = array[p2++];
            }
        }

        while (p1 <= mid) {
            assist[index++] = array[p1++];
        }
        while (p2 <= end) {
            assist[index++] = array[p2++];
        }

        System.arraycopy(assist, 0, array, start, assist.length);
    }
}


import java.util.Arrays;

public class MergeTest {
    public static void main(String[] args) {
        Merge merge = new Merge();
        int[] array = {23, 5, 21, 28, 52, 30, 31, 18, 6, 8, 3, 21};
        merge.sort(array);
        System.out.println(Arrays.toString(array));
    }
}