排序算法进阶--排序算法优化

排序算法进阶

        上篇文章中我们主要介绍了经典的八大排序算法，从算法思想，动图演示，代码实现，复杂度及稳定性分析等角度进行学习。还没阅读的童鞋可以点这里进行浏览。

        求知若渴的你肯定不会满足于入门的内容，今天，小编在上一篇的基础上，对多种排序算法进行优化，让我们一起来康康吧~~

01冒泡排序

1. 优化一

• 优化思路：优化外层循环，我们知道，冒泡排序的每一轮都会对未排序部分进行一次遍历，如果在某次循环中没有交换操作，就说明数组已经有序，不用继续排序。

• 实现代码

  public static int[] bubbleSort(int[] array) {
        if (array.length == 0)
            return array;
        for (int i = 0; i < array.length; i++){
            boolean isSwap = false;//标记是否已经有序
            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;
                    isSwap = true;
                }
            if(!isSwap)
                break;
        }
        return array;
    }

2. 优化二

• 优化思路：优化内层循环，记住上一次发生交换的位置pos，则有序区扩展为[pos, len-1]，下一趟排序只需遍历[0, pos-1]即可。

• 实现代码

public static int[] bubbleSort(int[] array) {
    if (array.length == 0)
        return array;
    int pos = 0;//标记最后一次交换的位置
    int k = array.length-1;
    for (int i = 0; i < array.length; i++){
        boolean isSwap = false;
        for (int j = 0; j < k; j++)
            if (array[j + 1] < array[j]) {
                int temp = array[j + 1];
                array[j + 1] = array[j];
                array[j] = temp;
                isSwap = true;
                pos = j;
            }
            k=pos;
            if(!isSwap)
                break;
    }
    return array; 
}    1570932802569

3. 优化三

• 优化思路：双向冒泡排序（鸡尾酒排序），先从前往后，再从后往前去比较序列中的元素大小，每一次排序分别能确定未排序序列的最大最小值并放在相应位置。

• 实现代码

public void cocktail_sort(int[] a){
    int left = 0, right = a.length-1;
    int temp;
    while(left<right){
//找到当前排序元素里最大的那个，放在右侧
        for(int i=left;i<right;i++){ 
            if(a[i]>a[i+1]){
                temp = a[i];
                a[i] = a[i+1] ;
                a[i+1] = temp;
            }
        }
        right--;
//找到当前排序元素里最小的那个，放在左侧
        for(int j=right;j>left;j--){
            if(a[j-1]>a[j]){
                temp = a[j];
                a[i] = a[j+1] ;
                a[j+1] = temp;}
        }
        left++;
    }
}

   当然，你也可以结合上述的优化算法实现：优化外层循环+优化内层循环+双向冒泡排序。

02选择排序

 

1. 优化一

• 优化思路：折半插入排序，由于我们是要在有序的序列中找到一个位置插入元素，所以可以用二分查找的方法来代替顺序查找，不过这种方法虽然减少了插入过程的比较次数，时间复杂度仍为O(n^2)。

• 实现代码

  public static int[]  selectSort(int[] array) {
      if (array.length == 0)
          return array;
      int left = 0;
      int right = array.length-1;
      int min = left;//最小值下标
      int max = right;//最大值下标
      while(left<=right){
          min = left;
          max = right;
          for(int i=left; i<=right; i++){
              if(array[i]<array[min]){
                  min = i;
              }
              if(array[i]>array[max])
                  max = i;
          }
          swap(array[left],array[min]);
          if(left==max)
              max = min;
          swap(array[right],array[max]);
          ++left;
          --right;
      }
      return array;
  }

 

03插入排序

 

1. 优化一

• 优化思路：每一次查找最大值的时候，也可以同时查找最小值，然后分别放在相应的位置。

• 实现代码

  public static int[] BinsertSort(int[] a){
      int left, right, m, num;
      for(int i=1;i<a.length;i++){
          num = a[i];
          left = 0;
          right = i-1;
  //二分查找
          while(left<=right){
              m = (left+right)/2;
              if(num<a[m])
                  right = m-1;
  else
                  left = m+1;
          }
          for(int j=i-1;j>=right+1;--j)
              a[j+1]=a[j];
          a[right+1]=num;
      }
      return a;
  }

 

04快速排序

1. 优化一

• 优化思路：优化基准值选取：采用固定基准的方法来对数组进行划分时，如果数组元素基本有序，容易产生最坏时间复杂度O(n^2)；所以可以采用随机基准值确定；但是如果数组值是随机的，采用固定基准可能比随机的要快；故可考虑三数取中：选取待排序数组的开头中间和结尾，通过比较，选取中间值作为基准；

• 实现代码

  public static void swap(int[] arr,int left,int right)
  {
      int temp;
      temp=arr[left];
      arr[left]=arr[right];
      arr[right]=temp;
  }
  public static int partition(int[] arr,int left,int right)
  {
      int m=left+(right-left)/2;//找到中间的数字的下标
      if(arr[left]>arr[right])//最左大于最右的时候，交换左右
      {
          swap(arr,left,right);
      }
      if(arr[m]>arr[right])//如果中间的>right ,交换
      {
          swap(arr,m,right);
      }
      if(arr[m]>arr[left])//如果中间的>left，交换
      {
          swap(arr,m,right);
      }
      int temp=arr[left];//基准
      while(left<right)//知道left和right重合的时候，才找到合适的位置
      {     //从后向前找到比小的数字
          while(left<right  &&  arr[right]>=temp)
          {
              right--;
          }
          arr[left]=arr[right];//当right的值小于temp的值的时候执行
          while(left<right  && arr[left] <= temp)//从前往后找到比基准大的数字
          {
              left++;
          }
          arr[right]=arr[left];//当left的值大于temp的时候执行
      }
      arr[left]=temp;//此时的left和right在同一个位置，此时为合适的位置，把temp的值给left
      return left;//此时返回的值是temp合适的位置，即小于它的在它的左边，大于它的在它的右边
  }
  public static int[] Quicksort(int array[], int left, int right) {
      if(left < right){
          int pos = partition(array, left, right);
          Quicksort(array, left, pos - 1);
          Quicksort(array, pos + 1, right);
      }
      return array;
  }

2. 优化二

• 优化思路：序列长度达到一定大小时，使用插入排序：当快排达到一定深度后，划分的区间很小，使用快排效率不高，可以使用插入排序；

• 实现代码

  public static void quickSort(int[] arr,int left,int right)
  {
      int length=right-left;
      if(length>max_len )
      {
          int pivot=partition(arr,left,right);
          quickSort(arr,left,pivot-1);
          quickSort(arr,pivot+1,right);
      }
  else
      {
          BinsertSort(arr);
      }
  }

3. 优化三

• 优化思路：尾递归优化，快排的递归出现在函数的尾部，且它的返回值不作为表达式的一部分，即递归回溯后不需要做任何操作，编译器检测到尾递归时，他就覆盖当前的活动记录而不是在栈中去创建一个新的，节省了大量栈空间；

4. 优化四

• 优化思路：聚集元素，在一次分割结束后，将与本次基准相等的元素聚集在一起，再分割时，不再对聚集过的元素进行分割（可以在划分过程中，将与本次基准相等元素放入数组两端，划分结束后再将这些元素一道基准值周围）；

• 代码实现

  //找基准
  public static int partion(int[] array,int low,int high){//一次快排
      int tmp=array[low];
      while(low < high){
  //从后找
          while(low < high && array[high] >= tmp){
              --high;
          }
          if(low >= high){
              break;
          }else{
              array[low] = array[high];
          }
  //从前找
          while(low < high && array[low] <= tmp){
              ++low;
          }
          if(low >= high){
              break;
          }else{
              array[high] =array[low];
          }
      }
      array[low] = tmp;
      return low;
  }
  //将相同元素聚集在一起
  public static int[] focusNum(int[] array,int start,int end,int par){
      int tmp = 0;
  //查找范围
      int left=par-1;
      int right=par+1;
  //交换的指引变量
      int parLeft=par-1;
      int parRight=par+1;
  //左边找
      for(int i = left;i >= start;i--){
          if(array[i] == array[par]){//遍历过程中，有与par相同的元素时
              if(i != parLeft){//若i 和parLeft相同，将两下标所对应的元素交换
                  tmp = array[i];
                  array[i] = array[parLeft];
                  array[parLeft] = tmp;
                  parLeft--;
              }else{
                  parLeft--;
              }
          }
      }
  //右边找
      for(int j = right;j <= end;j++){//遍历过程中，有与par相同的元素时
          if(array[j] == array[par]){//若i 和parRight相同，将两下标所对应的元素交换
              if(j != parRight){
                  tmp = array[j];
                  array[j] = array[parRight];
                  array[parRight] = tmp;
                  parRight++;
              }else{
                  parRight++;
              }
          }
      }
      int[] focus={parLeft,parRight};
      return focus;
  }
  //基准左右进行递归排序
  public static void Quick(int[] array,int start,int end){
      int par = partion(array,start,end);
      int[] brray = focusNum(array,start,end,par);//相同元素聚集在一起后，新的left和right
      int left = brray[0];
      int right = brray[1];
      if(par > start+1){
          Quick(array,start,left);
      }
      if(par < end-1){
          Quick(array,right,end);
      }
  }

5. 优化五

• 优化思路：采用多线程，因为子问题是独立的。   

                                                                                                                                                 欢迎补充，指错，提建议，感谢阅读，感谢支持！

 

关注我 获取更多知识长按扫码关注你点的每个赞，我都认真当成了喜欢