8大内部排序算法学习笔记--(2)快速排序 Java实现

1. 起泡排序

1. 思路：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

2. java实现：

int[] arr  = { 49, 38, 65, 97, 76, 13, 27, 49, 55, 4 };
private static int[] bubbleSort(int[] arr) {
        // TODO Auto-generated method stub
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
        return arr;
    }

2. 快速排序

1. 思路：快速排序是对起泡排序的一种改进，基本思想是，选择一个基准元素，通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录比基准元素小，一部分比基准元素大，然后分别对这两部分记录继续进行排序，以达到整个序列有序。

2. 实例
   

3. java实现（递归实现）

// 快速排序
    private static void quickSort(int[] b) {
        // TODO Auto-generated method stub
        if (b.length > 0) {
            _quickSort(b, 0, b.length - 1);
        }
    }

    private static void quickSort_(int[] b, int low, int high) {
        // TODO Auto-generated method stub
        if (low < high) {
            int middle = getMiddle(b, low, high);
            quickSort_(b, low, middle - 1);
            quickSort_(b, middle + 1, high);
        }
    }

    private static int getMiddle(int[] data, int low, int high) {
        // TODO Auto-generated method stub
        int tmp = data[low];
        while (low < high) {
            while (low < high && data[high] >= tmp) {
                high--;
            }
            data[low] = data[high];
            while (low < high && data[low] <= tmp) {
                low++;
            }
            data[high] = data[low];
        }
        data[low] = tmp;
        System.out.println(Arrays.toString(data));
        return low;
    }