排序算法

1冒泡排序：
        是一种简单的排序算法，它重复地走访待排序的数组，一次比较两个相邻的元素，若两者顺序的错了就交换过来

        
        1.1 算法描述

·     比较相邻的元素。如果第一个比第二个大，就交换它们两个；

·     对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；

·     针对所有的元素重复以上的步骤，除了最后一个；

·     重复步骤1~3，直到排序完成。

1.2 动图演示

 

1.3 代码实现

   public static int[] bubbleSort(int[] array) {
      if (array.length == 0)
          return array;
      //
      for (int i = 0; i < array.length; i++)
      //
          for (int j = 0; j < array.length - 1 - i; j++)
              if (array[j + 1] < array[j]) {
                  int temp = array[j + 1];
                  array[j + 1] = array[j];
                  array[j] = temp;
              }
      return array;
  }

1.4 算法分析
最佳情况：T(n) = O(n)   最差情况：T(n) = O(n2)   平均情况：T(n) = O(n2)

2、选择排序（Selection Sort）
                                                                                        表现最稳定的排序算法之一，无论什么数据进去，它的时间复杂度都为O（n2）

工作原理：

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.1 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

初始状态：无序区为R[1..n]，有序区为空；
第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
n-1趟结束，数组有序化了。
2.2 动图演示

2.3 代码实现

 public static int[] selectionSort(int[] array) {
                if(array.length==0) {
                        return array;
                }
                //选定一次循环后比较出的最值存放的位置
                for (int i = 0; i < array.length; i++) {
                        int temp=array[i];
                        //一次循环后比较出最值，并存放到选定的位置上
                        for (int j = i+1; j < array.length; j++) {
                                if(array[i]>array[j]) {
                                        Swap.swap(array, i, j);
                                }
                        }
                }

                return array;

        }

2.4 算法分析
最佳情况：T(n) = O(n2)  最差情况：T(n) = O(n2)  平均情况：T(n) = O(n2)

3、快速排序（Quick Sort）

基本思想：
                                                                                                在待排的数组中选择一个基准值key(比如A[0]),通过一轮排序将数组A分成两部分，其中以key为中心，
                                                                                                key的左边都比key值小，key的右边都比key值大，然后对这两部分分别重复这个过程，直到整个数组有序。

3.1 算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

从数列中挑出一个元素，称为 “基准”（pivot）；
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
3.2 动图演示

/**
        * 在待排的数组中选择一个基准值key(比如A[0]),通过一轮排序将数组A分成两部分，其中以key为中心，
        *        key的左边都比key值小，key的右边都比key值大，然后对这两部分分别重复这个过程，直到整个数组有序。
        * @param array                待排数组
        * @param leftIndex    待排数组中的起始索引
        * @param rightIndex  待排数组中的末尾索引
        * @return
        */
        public static int[] quickSort(int[] array,int leftIndex,int rightIndex) {

//                1、找到递归算法的出口
                if( leftIndex > rightIndex) {
                        return array;
                }

//                2、存储当前待排数组的起始索引和末尾索引
                int left=leftIndex;
                int right=rightIndex;

//                3、在待排数组中随机选定一个基准值key
                int key=array[leftIndex]; 
                if(left<=right) {

//                        4、完成一轮排序以key为中心将数组分成两部分
                        while(left<right) {
//                                4.1、从右往左，找到第一个比key值小的元素
                                while(left<right && array[right]>=key) { 
                                        right--;    //若元素比key值大，则指针往左移，一直循环，直到找到比key值小的元素
                                }
//                                4.2、从左往右，找到第一个比key值大的元素
                                while(left<right && array[left]<=key) { 
                                        left++;    //若元素比key值小，则指针往右移，一直循环，直到找到比key值大的元素
                                }
//                                4.3、当找到两个分别比key值大、小的元素时，则交换位置
                                Swap.swap(array, left, right); 
                        }
//                        4.4、while循环跳出来时，即left=right，也就是基准值key所排列的位置
                        Swap.swap(array, left/right, leftIndex);

//                        5、对这两部分用递归重复操作上述步骤
                        quickSort(array,leftIndex,left-1);  //对key左边部分操作
                        quickSort(array,right+1,rightIndex);  //对key右边部分操作
                }

                return array;
        }

3.4 算法分析

最佳情况：T(n) = O(nlogn)   最差情况：T(n) = O(n2)   平均情况：T(n) = O(nlogn)