常用的排序算法解析

• 概述

对某些数据进行排序是程序员不得不面对的一些需求，排序算法也是面试过程中老生常谈的一些问题，下面来总结一下常用到的一些排序算法，常用到的排序算法包括：冒泡排序，选择排序，插入排序，希尔排序，快速排序。

• 冒泡排序

冒泡排序是指在排序时从最开始或者从最末尾开始，依次比较相邻两个数据项，遵循更大(小)往前(后)移动的规矩，从而依次将最值放到了开始或者末尾处，循环下来，最终完成排序功能。

效率分析    比较次数：C*O(n²)    (C为常数，n为数据项数量)

                  交换次数：C*O(n²)

代码示例：

    int[] a = new int[10];
    int length = a.length;
                
    /**
     * 冒泡排序，大的往后移动   比较n*n次，交换n*n次
     */
    public void bubblesort() {
        for (int out = length - 1; out > 1; out--) {
            for (int in = 0; in < out; in++) {
                if (a[in] > a[in + 1]) {
                    swap(in, in + 1);
                }
            }
        }
    }



    private void swap(int in, int i) {
        int temp = a[in];
        a[in] = a[i];
        a[i] = temp;
    }

 

• 选择排序

选择排序是从左边第一位开始，往右边移动，记录住最大值或者最小值，然后再和左边第一位的数据交换，完成第一项数据的交换移动，然后从左边第二位数据开始，依此完成数据的交换移动，就完成了排序功能。

效率分析    比较次数：C*O(n²)    (C为常数，n为数据项数量)

                  交换次数：C*O(n)

示例代码：

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

 /**
     * 选择排序，选出最小值然后再放到前面，比较n*n，交换n次
     */
    public void selectSort() {
        int min;
        for (int out = 0; out < length - 1; out++) {
            min = out;
            for (int in = out + 1; in < length; in++) {
                if (a[in] < a[min]) {
                    min = in;
                }
            }
            if (min != out)
                swap(min, out);
        }
    }


   private void swap(int in, int i) {
        int temp = a[in];
        a[in] = a[i];
        a[i] = temp;
    }

 

• 插入排序

插入排序是指从左往右或者是从右往左依此局部排序，在某一刻存在局部有序，它的效率比冒泡排序和选择排序要高一些，如果是在大部分已经顺序的数据中，插入排序的效率会更高。

效率分析    比较次数：C*O(n²)    (C为常数，n为数据项数量)

                  交换次数：C*O(n)

示例代码：

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

    /**
     * 插入排序
     */
    public void insertSort() {
        int in, out;

        for (out = 1; out < length; out++) {
            in = out;
            int temp = a[out];
            while (in > 0 && a[in - 1] >= temp) {
                a[in] = a[in - 1];
                in--;
            }
            a[in] = temp;
        }
    }

    private void swap(int in, int i) {
        int temp = a[in];
        a[in] = a[i];
        a[i] = temp;
    }

• 希尔排序

在插入排序中，通过依次局部排序，如果数据项很多并且后面有一些极大或者极小值，将会存在很多的数据交换，从而降低效率，而希尔排序就是为了解决这些麻烦，希尔排序以更大的增量来进行插入排序，并依次减小增量，最后以1来进行插入排序，这样就可以避免数据量很大时，插入排序因为太多的数据交换所造成的效率低的问题。增量的常用最佳选择是3h+1，并且最后一定要以1进行插入排序才完成了排序效果。

示例代码：

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

/**
     * 希尔排序
     * <p>
     * 以h为增量的插入排序，h=h*3+1,h递减，最后h为1时即为普通插入排序
     * <p>
     * 效率比冒泡，选择，插入排序更高，更快
     */
    public void shellSort() {
        int in, out, temp;
        int h = 1;
        while (h <= length / 3) {
            h = h * 3 + 1;
        }
        while (h > 0) {
            for (out = h; out < length; out++) {
                temp = a[out];
                in = out;
                while (in > h - 1 && a[in - h] >= temp) {
                    a[in] = a[in - h];
                    in -= h;
                }
                a[in] = temp;
            }
            h = (h - 1) / 3;
        }
    }

• 快速排序

快速排序，顾名思义是一种速度很快的排序算法，它的效率比起冒泡排序，选择排序，插入排序和希尔排序都要高，速度都更快一些，快速排序指的是 在数组中选择一个枢纽(可以选择左中右位置的一个中间值)，然后按照枢纽将数组分成左右两边，枢纽放在中间，再对左右两边的数组分成两份分别完成之前的操作，此中用到递归的思想，这样就可以很快的完成排序，在数据项小于3项时可以直接通过交换数据完成排序，不必在分。

示例代码：

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

     public void quickSort() {
        int left = 0;
        int right = length - 1;
        quickSortAction(left, right);
      }

    private void quickSortAction(int left, int right) {
        if (right - left <= 2) {
            //3项或者以下的数据直接交换
            changeData(left, right);
        } else {
			//找到枢纽
            int median = medianOf3(left, right);
			//根据选出的枢纽，把大于等于枢纽的数据放到枢纽的右边，小于枢纽的数据放在枢纽的
            //左边，然后选出分割线的位置，进行下次的划分排序
            int partition = partitonInt(left, right, median);
            quickSortAction(left, partition - 1);
            quickSortAction(partition + 1, right);
        }
    }
	
	//找到左中右三个数据的中间项作为枢纽，并将枢纽放到右边的倒数第二位
	private int medianOf3(int left, int right) {
        int center = (right + left) / 2;
        if (a[left] < a[right]) {
            swap(left, right);
        }
        if (a[center] < a[right]) {
            swap(left, right);
        }
        if (a[left] < a[center]) {
            swap(left, right);
        }
        swap(center, right - 1);
        return a[right - 1];
    }

	//从左边开始，遇到大于等于中间项的数据停下来，然后从右边开始，遇到小于中间项的停下来，交换
    //两个数的位置
	//...依次下去，左后leftptr以左的数据都是小于枢纽的，右边的数据都是大于或者等于枢纽的，
    //把枢纽移到leftptr位//置,并把左边界返回，作为下次两边数据的界限
    private int partitonInt(int left, int right, int median) {
        int leftPtr = left;
        int rightPtr = right - 1;
        while (true) {
            while (a[++leftPtr] < median) ;
            while (a[--rightPtr] > median) ;
            if (leftPtr >= rightPtr) {
                break;
            } else {
                swap(leftPtr, rightPtr);
            }
        }
        swap(leftPtr, right - 1);

        return leftPtr;
    }

    

    private void changeData(int left, int right) {
        int size = right - left;
        if (size <= 0) {
            return;
        } else if (size == 1) {
            if (a[left] < a[right]) {
                swap(left, right);
            }
        } else if (size == 2) {
            if (a[left] < a[right]) {
                swap(left, right);
            }
            if (a[left + 1] < a[right]) {
                swap(left, right);
            }
            if (a[left] < a[left + 1]) {
                swap(left, right);
            }
        }
    }

    private void swap(int in, int i) {
        int temp = a[in];
        a[in] = a[i];
        a[i] = temp;
    }