常用排序算法代码兑现

回顾

五天过去了,8个主要排序算法的思想和原理图解都已经推送完了,在这些推送中,我们详细分析讨论了

  • 各种排序算法的时间、空间复杂度;
  • 算法的稳定性;
  • 算法的优化改进
  • 算法的应用场景

如果您想了解或者进一步熟悉下这些算法原理,请参考之前五天的推送:

冒泡排序到快速排序做的那些优化

直接选择排序到堆排序做的那些改进

直接插入排序到希尔排序做的那些改进

归并排序算法的过程图解

不基于比较的基数排序原理图解

兑现代码

当我们详细研究了这些常用排序算法的基本实现原理之后,是时候写出这些排序算法的源代码了,也许这些代码在网上有更高效的实现,不过下面写的这些都是和之前说的算法原理和图都解密切相关,一 一对应的,主要是方便大家的理解。测试了几遍,有错误大家指出来吧。

使用了 Java 语言 和 C# 语言实现了这些算法,下面一 一列出。

几个算法中使用的一个交换函数,源码如下,

 //swap element at i to at j
    private static void swap(int[] array, int i,int j){
       int tmp = array[i];
       array[i] = array[j];
       array[j] = tmp;
    }

以下7种排序算法都实现了序列的非降序排列,函数参数代表的含义一般统一定义为:

  • array: 待排序的数组,类型为一维整形数组
  • n:元素个数
  • i:一般为外层循环索引,或表示排序区或未排序的开始或结束索引
  • j :一般为内层循环索引,或表示未排序区或排序的结束或开始索引
  • lo:数组计算区间的开始索引
  • hi:数组计算区间的结束索引
  • d :分组长度
  • k:分组索引

1 冒泡排序

    //bubble sort
     public static void bubbleSort(int[] array, int n){
        int i = 0;// loop
        int j = 0; // element index
        while(i < n) {
           for(j=0; j<n-i-1; j++){
              if( array[j] > array[j+1] ){ //swap condition
                 swap( array, j, j +1 );
               }
           }
           i++;
        }
     }

2 快速排序

快速排序是很巧妙的实现算法,它选取一个轴点,每轮计算时,凡是轴点的移动都会空出一个位置,这个位置就是被调整后的关键码所代替,经过这种调整后,一轮下来轴点前的关键码都小于轴点,后的都大于。

注意
里层的两个while遍历条件,最后碰头的位置,就是这轮轴点的位置,记得给这个填上轴点值。

 //quick sort
    public static void quickSort(int[] array, int lo, int hi){
        if(lo>hi) return;
        int pivot = array[lo]; 
        int i = lo;
        int j = hi;
        while( i<j ){
            //get smaller after pivot 
            //warning: while condition, here and next while
            //at least one item is >=
            while(i < j && array[j] >= pivot){
                j--;
            }
            array[i] = array[j]; //so at j an element is void
            //get bigger before pivot
            while(i < j && array[i] < pivot){
                i++;
            }
            array[j] = array[i]; // at i an element is to fill at j
        }
        //here, i bumps into j
        array[i] = pivot;
        //here, before index i smaller than pivot, after bigger than pivot
        // lo~i quick sort
        quickSort(array, lo, i-1);  
        // i+1~hi quick sort
        quickSort(array, i+1, hi); 
     }

3 直接选择排序

直接选择排序就是把每轮找出的最小值放到排序区的最后,代码实现简单。

  //direct select sort
    public static void selectSort(int[] array, int n){
        int i=0; //sorted last element
        int j=0; //unsorted first element
        while(i<n){
            int min=array[i];
            int index = i;
            for(j=i+1; j<n;j++){
                if(array[j]<min){
                    min = array[j];
                    index = j;
                }
            }
            swap(array,i,index);
            i++;
        }
    }

4 堆排序

注意大根堆顶与未排序区的最后一个元素不断交换,直至未排序区的个数为0,整个序列完成排序。

堆排序算法比较容易出错的点:

  1. 构建堆函数,左右子节点可能都有,也可能只含有左节点,咖啡色标记的代码
  2. 堆排序函数,while遍历时,buildHeap参数中元素个数每次减1,始终从位置0(堆顶)开始调整。
    //heap sort
        public static void heapSort(int[] array, int n){    
            for (int i = n / 2 - 1; i >= 0; i--)
                buildHeap(array, n, i);
            int len = n - 1;
            while (len > 0) {           
                swap(array, 0, len);
                buildHeap(array, len, 0);
                len--;
            }
        }
        private static void buildHeap(int[] array, int n, int i){
            for (; left(i) < n; i = left(i)) {
                int bigger =
                    right(i) < n ? max(array, left(i), right(i)) : left(i);
                if (array[bigger] > array[i]) //swap
                    swap(array, bigger, i);
                else break;
            }
        }

    private static int left(int i){
        return 2*i+1;
    }
    private static int right(int i){
        return 2*i+2;
    }
    private static int max(int[] array, int i, int j){
        return array[i]>array[j]? i:j;
    }

5 直接插入排序

插入排序算法,需要注意在移动排序区的元素时,会覆盖未排序区的第一个元素,所以需要先用另一个变量标记出来。

  // insert sort
    public static void insertSort(int[] array, int n){
       int i = 1; //unsorted first index
       while (i < n) {
        int j = i - 1; //sorted last index
        int insert = array[i]; //warning: label array[i]
        while (j > 0 && insert < array[j]){                
            array[j + 1] = array[j];
            j--;
         }               
        array[j + 1] = insert; //j+1 is insert pos
        i++;
       }
    }

6 希尔排序

希尔排序的精华是在插入排序的思想下多了一层分组逻辑,如下所示,d为分组长度,k为分组索引。内层逻辑实际上为插入排序的逻辑。

 //shell Sort
     public static void shellSort(int[] array, int n, int group){
        if (group > n) return;
        int d = n / group; //d: number for each group
        while (d > 0){
           for (int i = 0; i < d; i++){
                 int j = i; // number index
                 int k = 1; //distance index
                 while (j < n){
                        int insert = array[j]; //label unsorted first
                        j -= d; //sorted last index
                        while (j > 0 && insert < array[j]){
                            array[j + d] = array[j];
                            j -= d;
                        }
                   array[j + d] = insert; //insert pos: j+d
                   j = i + (++k) * d; //next number index
                }
           }
          d /= 2;
        }
     }   

7 归并排序

二分后再归并是这个算法的精华所在,需要注意的是,递归排序的前半部分和后半部分各自的起始终止索引,以及归并时要分别指出array被分隔的两半部分的起始,终止位置,当然划分的前提是lo < hi,这也是递归返回的条件。

 //merge sort
public static void mergeSort(int[] array, int n){
            var sorted = new int[n];
            mergeSort(array,sorted,0,n-1);
  }

 private static void mergeSort(int[] array, int[] sorted, int lo, int hi){
            if (lo < hi){
                int mid = lo + (hi - lo) / 2;
                mergeSort(array, sorted,lo, mid);
                mergeSort(array, sorted, mid + 1, hi);
                merge(array, sorted, lo, mid, hi);
            }
   }
        //beg: part1 beginning index
        //mid: part1 end index
        //mid+1: part2 beginning index
        //end: part2 end index
   private static void merge(int[] array, int[] sorted, int beg, int mid, int end){
            int i = beg; //part1 index
            int j = mid + 1; //part2 index
            int k = 0; //merged index
            while (i <= mid && j <= end)
                sorted[k++] = 
                    array[i] <= array[j] ? array[i++] : array[j++];                
            while (i <= mid)
                sorted[k++] = array[i++];
            while (j <= end)
                sorted[k++] = array[j++];
            for (i = 0; i < k; i++)
                array[beg + i] = sorted[i]; 
     }

总结

对以上算法不清晰的地方请直接参考以下推送:

冒泡排序到快速排序做的那些优化

直接选择排序到堆排序做的那些改进

直接插入排序到希尔排序做的那些改进

归并排序算法的过程图解

不基于比较的基数排序原理图解

请记住:每天一小步,日积月累一大步!

欢迎关注《算法channel》公众号

主要推送关于对算法的思考以及应用的消息。培养思维能力,注重过程本身,注重背后的原理,刨根问底。本着严谨和准确的态度,目标是撰写实用和启发性的文章,欢迎您的关注。

这里写图片描述

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值