排序算法的简单实现(冒泡和快排)

Posted weixuqin

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了排序算法的简单实现(冒泡和快排)相关的知识,希望对你有一定的参考价值。

排序算法

冒泡排序

原理:把相邻的元素两两比较,根据大小来交换元素的位置。

原始的冒泡排序是稳定排序。由于该排序的每一轮要遍历所以元素,轮转的次数和元素数量相当,所以时间复杂度是 O(N^2)。

java代码表达如下:

import java.util.Arrays;

public class BubbleSort{
    private static void sort(int array[]){
        int tmp = 0;
        for (int i = 0; i < array.length; i++){
            for (int j = 0; j < array.length - i - 1;j++) {
                if (array[j] > array[j+1]) {
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
        }
    }

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

(使用双循环来进行排序。外部循环控制所有的回合,内部循环代表每一轮的冒泡处理,先进行元素比较,再进行元素交换。)

冒泡优化(一)

判断出数列已经有序,并且做出标记,剩下的几轮排序就可以不必执行,提早结束工作。

代码如下:

import java.util.Arrays;

public class BubbleSort{
    private static void sort(int arrray[]){
        int tmp = 0;
        for (int i = 0; i < arrray.length; i++) {
            //有序标记,每一轮的初始是true
            boolean isSorted = true;
            for (int j = 0; j < arrray.length - i - 1; j++ ) {
                if(arrray[j] > arrray[j+1]) {
                    tmp = arrray[j];
                    arrray[j] = arrray[j+1];
                    arrray[j+1] = tmp;

                    //有元素交换,所以不是有序,标记变为false
                    isSorted = false;
                }
            }
            if(isSorted){
                break;
            }
        }
    }

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

利用布尔变量 isSorted作为标记。如果在本轮排序中,元素有交换,则说明数列无序;如果没有元素交换,说明数列已然有序,直接跳出大循环。

冒泡优化(二)

如果元素排序前面无序,后面无序,我们可以设定排序边界,这样当遍历到有序数组时,跳出循环,结束程序。

思路:我们在每一轮排序的最后,记录下最后一次元素交换的位置,那个位置也就是无序数列的边界,再往后就是有序区了。

代码如下:

import java.util.Arrays;

public class BubbleSort {
    private static void sort(int array[]) {
        int tmp = 0;
        // 记录最后一次交换的位置
        int lastExchangeIndex = 0;
        // 无序数列的边界,每次比较只需要比到这里为止
        int sortBorder = array.length - 1;
        for (int i = 0; i < array.length; i++) {
            // 有序标记,每一轮的初始是true
            boolean isSorted = true;
            for (int j = 0; j < sortBorder; j++) {
                if (array[j] > array[j+1]) {
                    tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    // 有元素交换,所以不是有序,标记为false
                    isSorted = false;
                    // 把无序数列的边界更新为最后一次交换元素的位置
                    lastExchangeIndex = j;
                }
            }

            sortBorder = lastExchangeIndex;
            if (isSorted) {
                break;
            }
        }
    }

    public static void main(String[] args) {
        int[] array = new int[]{3,4,2,1,5,6,7,8};
        sort(array);
        System.out.println(Arrays.toString(array));
    }
}

sortBorder 就是无序数列的边界。每一轮排序过程中,sortBorder 之后的元素就完全不需要比较了,肯定是有序的。

快速排序

快速排序跟冒泡排序一样,都属于交换类排序,通过采用不断的比较和移动元素来实现排序。

快速排序利用了 ”分治法“ 的思想, 通过设置基准数 key ,将比基准数大的数从前面移动到后面,比基准数小的数从后面移动到前面,将数组分为两部分,其中以 key 为中心, key 左边的数比 key 小,key 右边的数比 key 大,然后对这两部分分别重复这个排序的过程,直到整个有序。

由于采取 ”分治法“ ,我们可以很容易的得出快速排序的平均时间复杂度为:O(nlogn)

快速排序的简单实现:

import java.util.Arrays;

public class QuickSort {
    private static void quickSort(int[] a, int low, int high) {
        //1.找到递归算法的出口
        if (low > high) {
            return;
        }
        //2. 存
        int i = low;
        int j = high;
        //3. key
        int key = a[low];
        //4,完成一趟排序
        while(i < j) {
            //4.1 从右往左找到第一个小于key的数
            while(i<j && a[j] > key){
                j--;
            }
            //4.2 从左往右找到第一个大于key的数
            while (i<j && a[i] <= key) { 
                i++;
            }
            //4.3 交换
            if(i < j){
                int p = a[i];
                a[i] = a[j];
                a[j] = p;
            }
        }
        //4.4 调整key的位置
        int p = a[i];
        a[i] = a[low];
        a[low] = p;
        //5. 对key左边的数快排
        quickSort(a, low, i - 1);
        //6. 对key右边的数快排
        quickSort(a, i + 1, high);
    }

    public static void quickSort(int[] a){
        if (a.length>0) {
            quickSort(a, 0, a.length - 1);
        }
    }

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

}

以上是关于排序算法的简单实现(冒泡和快排)的主要内容,如果未能解决你的问题,请参考以下文章

阿里电话面试

四中基本排序算法几Java实现(冒泡选择插入快排)

七大排序算法(插排,希尔,选择排序,堆排,冒泡,快排,归并)--图文详解

其它排序:简单选择桶排序

Java排序算法分析与实现:快排冒泡排序选择排序插入排序归并排序

PHP排序函数sort底层实现分析