由于有上机作业,所以就对数据结构中常用的各种排序算法都写了个Demo,有如下几个:

  • 直接插入排序
  • 折半插入排序
  • 希尔排序
  • 冒泡排序
  • 快速排序
  • 选择排序
  • 桶排序

    Demo下载地址

下面谈一谈我对这几个排序算法的理解:

插入类算法

对于直接插入排序:(按从小到大的顺序)

核心原理:

若数组中只有一个元素,那么这就已经是有序的了;若数组中元素个数为两个,我们只需要对他们进行比较一次,要么交换顺序,要么不交换顺序就可以实现数组的内容的有序化;但是当数组内的元素的个数为N个呢?又该如何?这就催化了这个直接插入排序算法,其核心就是利用了有序化数组的方式,认为再插入一个新的元素之前都是有序的,只需要从后往前进行查找(找到一个小于待插入数据的位置,记为position,然后把这个数据之后的元素全部向后迁移一个,再把待插入数据插入到position+1的位置即可。(小伙伴们可以想象一下为什么是position+1,因为position位置上的数据小于我们的待插入的数据啊,所以要插在Position的下一个位置上!)

public static void DirectoryInsert(int []array,int length){
        int p,i;
        for(p=1;p<length;p++){
            int temp=array[p];
            i=p-1;
            while(i>=0&&array[i]>temp){
                array[i+1]=array[i];
                i--;
            }
            array[i+1]=temp;
        }
    }

关于折半插入排序算法:

核心原理:

折半插入的核心原理仍然是基于有序表的插入算法,找到位置后,仍然采用插入的方式进行数据添加。但是较之于直接插入有很大的提升,那就是在查找插入位置上的优化,速度上稍微有了一定的提升,虽然在乱序的数据上有良好的效果,但是时间复杂度仍然很大O(n^2)。是稳定的算法。

下面是代码的实现:

private static void Half(int[] array, int length) {
        //p stands for the times of the sort
        int left,right,mid,p;
        for(p=1;p<length;p++){
            int temp=array[p];
            left=0;right=p-1;
            while(left<=right){
                mid=(left+right)/2;
                if(array[mid]>temp){
                    right=mid-1;
                }else{
                    left=mid+1;
                }
            }
            for(int i=p-1;i>=left;i--){
                array[i+1]=array[i];
            }
            array[left]=temp;
        }
    }

对于希尔排序:

核心原理:

希尔排序核心仍然是基于插入方式的,以逐步减小“步长”,采用“分治”的思想对每一个子序列进行排序。最终实现对整个序列的排序。

特点:希尔排序是不稳定的排序算法,会导致数据原始相对位置的改变。如果以步长为2计算,其时间复杂度可达到O(n^2),若数据足够长,步长也足够大那么时间复杂度将接近与O(n),但是一般认为其为O(n^1.3)。

代码实现:

private static void Shell(int[] array, int length) {
        // TODO Auto-generated method stub
        int d=length/2;
        while(d>=1){
            for(int k=0;k<d;k++){
                //to every sub,carry the direcly insert
                for(int i=k+d;i<length;i+=d){
                    int temp=array[i];
                    int j=i-d;
                    while(j>=k&&array[j]>temp){
                        array[j+d]=array[j];
                        j-=d;
                    }
                    array[j+d]=temp;
                }
            }
            d=d/2;
        }
    }

交换类排序算法


对于冒泡排序:

核心原理:

冒泡排序是我们接触比较早的一个排序算法,其原理就是对数据两两进行比较大小,并对符合要求的数据进行交换。循环n-1次,便可以对n 个数据实现排序。

特点:

时间复杂度O(n^2),由于数据发生交换时并没有发生原始位置的变化,所以冒泡排序算法是稳定的排序算法。

代码实现:

private static void Bubble(int[] array, int length) {
        // TODO Auto-generated method stub
        for(int i=0;i<length;i++){
            //expeclally the end case is "length-i"
            for(int j=1;j<length-i;j++){
                if(array[j-1]>array[j]){
                    int temp=array[j];
                    array[j]=array[j-1];
                    array[j-1]=temp;
                }
            }
        }
    }

对于冒泡排序,这里还有一个改进版的冒泡,是针对于特殊情况下的排序的处理,比如一个已经有序的序列如果再进行正常的冒泡的话,就会浪费时间,所以,如果一个序列已经是有序的,那么就应该跳出这个序列的冒泡,从而在一定程度上减少了时间的浪费。

代码实现:

private static void BubbleBetter(int[] array, int length) {
        // TODO Auto-generated method stub
        boolean flag=false;
        for(int i=0;i<length;i++){
            //expeclally the end case is "length-i"
            for(int j=1;j<length-i;j++){
                flag=false;
                if(array[j-1]>array[j]){
                    int temp=array[j];
                    array[j]=array[j-1];
                    array[j-1]=temp;
                    flag=true;
                }
            }
            if(flag){
                return;
            }
        }
    }

快速排序算法:

核心原理:

快速排序的原理是找到轴值pivot(这里有两种方式,从代码中可以清晰地看到,但最终结果都是一样的,那就是找到这个分割点,再递归的进行排序。

特征:

时间复杂度为O(nlogn,已2为底);

代码如下:

private static void Fast(int[] array, int left, int right) {
        // TODO Auto-generated method stub
        if (left < right) {
            int p = Partition1(array, left, right);
            Fast(array, left, p - 1);
            Fast(array, p + 1, right);
        }
//      if (left < right) {
//          int p = Partition2(array, left, right);
//          Fast(array, left, p - 1);
//          Fast(array, p + 1, right);
//      }
    }

    private static int Partition1(int[] array, int left, int right) {
        int pivot = array[left];
        while (left < right) {
            while (left < right && array[right] >= pivot) {
                right--;
            }
            array[left] = array[right];
            while (left < right && array[left] <= pivot) {
                left++;
            }
            array[right] = array[left];
        }
        array[left] = pivot;
        return left;
    }

    private static int Partition2(int[] array, int start, int end) {
        int pivot = array[start];
        int left = start, right = end;
        while (left <= right) {
            while (left <= right && array[left] <= pivot) {
                left++;
            }
            while (left <= right && array[right] >= pivot) {
                right--;
            }
            if (left < right) {
                Swap(array[right], array[left]);
                left++;
                right--;
            }
        }
        Swap(array[start], array[right]);
        return right;

    }

选择类排序算法


对于选择排序:

核心原理:

两轮循环,第一轮是选择的次数的记录,第二轮是目标查找。所谓目标查找,就是找到一个符合要求的值,记录其位置,然后在第一轮的循环中进行判断,将符合条件者进行交换,如此可实现排序的功能。

特征:

时间复杂度O(n^2),交换n-1次,比较了n^2次。是不稳定的排序算法。

代码:

private static void Select(int[] array, int length) {
        // TODO Auto-generated method stub
        for(int i=1;i<length;i++){
            int k=i-1;
            for(int j=i;j<length;j++){
                if(array[j]<array[k]){
                    k=j;
                }
            }
            if(k!=i-1){
                int temp=array[i-1];
                array[i-1]=array[k];
                array[k]=temp;
            }
        }
    }

归并类排序算法


对于归并排序:

核心原理:

若一个序列只有一个元素,则它是有序的,归并排序不执行任何操作。否则归并排序将执行下面的递归步骤:

1)先把序列划分为长度基本相等的子序列

2)对每个子序列归并并排序

3)把排好序的子序列合并为最终的结果。

特征:

时间复杂度O(nlogn),是不依赖于数据原始顺序的不稳定的排序算法。

代码如下:

private static void MergeFunction(int[] array,int start, int end) {
        // TODO Auto-generated method stub
        if(start<end){
            int mid=(start+end)/2;
            MergeFunction(array, start, mid);
            MergeFunction(array, mid+1, end);
            Merge(array,start,mid,end);
        }
    }

    private static void Merge(int[] array, int start, int mid, int end) {
        // TODO Auto-generated method stub
        int len1=mid-start+1,len2=end-mid;
        int i,j,k;
        //声明数组,分别保存子串信息
        int[] left=new int[len1];
        int[] right=new int[len2];
        for(i=0;i<len1;i++){//执行数据复制
            left[i]=array[i+start];
        }
        for(i=0;i<len2;i++){//执行数据复制
            right[i]=array[i+mid+1];
        }
        i=0;j=0;
        //执行合并操作
        for(k=start;k<end;k++){
            if(i==len1||j==len2){
                break;
            }
            if(left[i]<right[j]){
                array[k]=left[i++];
            }else{
                array[k]=right[j++];
            }
        }

        //若array[start,mid]还有待归并数据,则放到array后面
        while(i<len1){
            array[k++]=left[i++];
        }

        //对array[mid+1,end]见得数据执行同样的操作
        while(j<len2){
            array[k++]=left[j++];
        }
        //释放内存操作
        left=null;
        right=null;

    }

总结:

排序算法多种多样,在不同的情况下选择合适的排序算法能让你事半功倍。

Java 实现的各种经典的排序算法小Demo的更多相关文章

  1. [转]Java学习---7大经典的排序算法总结实现

    [原文]https://www.toutiao.com/i6591634652274885128/ 常见排序算法总结与实现 本文使用Java实现这几种排序. 以下是对排序算法总体的介绍. 冒泡排序 比 ...

  2. 深度实战玩转算法, Java语言7个经典应用诠释算法精髓

    深度实战玩转算法,以Java语言主讲,通过7款经典好玩游戏,真正将算法用于实际开发,由算法大牛ACM亚洲区奖牌获得者liuyubobobo主讲,看得见的算法,带领你进入一个不一样的算法世界,本套课程共 ...

  3. 我们一起来排序——使用Java语言优雅地实现常用排序算法

    破阵子·春景 燕子来时新社,梨花落后清明. 池上碧苔三四点,叶底黄鹂一两声.日长飞絮轻. 巧笑同桌伙伴,上学径里逢迎. 疑怪昨宵春梦好,元是今朝Offer拿.笑从双脸生. 排序算法--最基础的算法,互 ...

  4. java讲讲几种常见的排序算法(二)

    java讲讲几种常见的排序算法(二) 目录 java讲讲几种常见的排序算法(一) java讲讲几种常见的排序算法(二) 堆排序 思路:构建一个小顶堆,小顶堆就是棵二叉树,他的左右孩子均大于他的根节点( ...

  5. java讲讲几种常见的排序算法

    java讲讲几种常见的排序算法(一) 目录 java讲讲几种常见的排序算法(一) java讲讲几种常见的排序算法(二) 以数组array={6,3,20,8,15,1}为例 冒泡排序 思路:从第0个到 ...

  6. Java中常用的6种排序算法详细分解

    排序算法很多地方都会用到,近期又重新看了一遍算法,并自己简单地实现了一遍,特此记录下来,为以后复习留点材料. 废话不多说,下面逐一看看经典的排序算法: 1. 选择排序 选择排序的基本思想是遍历数组的过 ...

  7. Java面试宝典系列之基础排序算法

    本文就是介绍一些常见的排序算法.排序是一个非常常见的应用场景,很多时候,我们需要根据自己需要排序的数据类型,来自定义排序算法,但是,在这里,我们只介绍这些基础排序算法,包括:插入排序.选择排序.冒泡排 ...

  8. 用 Java 实现的八种常用排序算法

    八种排序算法可以按照如图分类 交换排序 所谓交换,就是序列中任意两个元素进行比较,根据比较结果来交换各自在序列中的位置,以此达到排序的目的. 1. 冒泡排序 冒泡排序是一种简单的交换排序算法,以升序排 ...

  9. JAVA学习笔记(4)—— 排序算法

    排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作.排序算法,就是如何使得记录按照要求排列的方法. 排序算法大体可分为两种: 一种是比较排序,时间复杂度O(nlogn) ...

随机推荐

  1. vue 移动端公众号采坑经验

    自己用vue做微信公众号项目有一段时间了,遇到各种奇葩的问题,下面细数那些坑: 第一坑:微信分享导致安卓手机无法调起相册和无法调起微信充值 解决方案: setTimeout(_ => { wx. ...

  2. Ubuntu安装与配置KVM

    事前检查 查看一下linux是32位还是64位 file /bin/ls 确认一下 CPU支持硬件虚拟化(不支持也没关系,可以继续) egrep -o '(vmx|svm)' /proc/cpuinf ...

  3. 聚沙成塔-linux 常用命令

    批量更改文件后缀名 find . -depth -name "*.scss" -exec sh -c 'mv "$1" "${1%.scss}.les ...

  4. J2EE进阶(十七)Hibernate中常用的HQL查询方法(getHibernateTemplate())

    J2EE进阶(十七)Hibernate中常用的HQL查询方法(getHibernateTemplate())   当我们使用Hibernate进行数据的CRUD操作时,利用模版进行操作不失为一种方法. ...

  5. springMVC源码分析--SimpleServletHandlerAdapter(二)

    上一篇博客springMVC源码分析--HandlerAdapter(一)中我们主要介绍了一下HandlerAdapter接口相关的内容,实现类及其在DispatcherServlet中执行的顺序,接 ...

  6. 用Python最原始的函数模拟eval函数的浮点数运算功能(2)

    这应该是我编程以来完成的难度最大的一个函数了.因为可能存在的情况非常多,需要设计合理的参数来控制解析流程.经验概要: 1.大胆假设一些子功能能够实现,看能否建立整个框架.如果在假设的基础上都无法建立, ...

  7. 详解EBS接口开发之应收款处理

    参考实例参考:杜春阳 R12应收模块收款API研究 (一)应收款常用标准表简介 1.1   常用标准表 如下表中列出了与应收款处理相关的表和说明: 表名 说明 其他信息 AR_BATCHES_ALL ...

  8. activiti源码编译

    个小时,大家安装的时候一定要耐心. 最终编译之后的效果部分如下图所示: 因为我这里有些xml文件没有去除验证,所以有红色的警告,不过也不影响使用. 下面看一下下载之后文件的变化如下图所示: 我们导入主 ...

  9. Swift中不用桥接文件和.h头文件直接和C代码交互的方法

    我们知道一般情况下Swit要想调用obj-c,c或c++代码必须通过obj-c以及桥接文件才可以办到,但是对于某些简单的代码,我们可以跳过桥接文件和.h头文件,直接和C代码交互呢! 我们再Projec ...

  10. 前端面试题-----js和jquery的区别是什么?

    最近我有一个朋友问我js和jquery的区别是什么,于是我打算写一篇文章说下到底有什么区别. 首先你要知道: 1.js是网页的脚本语言,记住哈,js是语言! 2.jquery是用js语言写出来的一个框 ...