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

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

    Demo下载地址

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

插入类算法

对于直接插入排序：（按从小到大的顺序）

核心原理：

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

  1. public static void DirectoryInsert(int []array,int length){
  2.         int p,i;
  3.         for(p=1;p<length;p++){
  4.             int temp=array[p];
  5.             i=p-1;
  6.             while(i>=0&&array[i]>temp){
  7.                 array[i+1]=array[i];
  8.                 i--;
  9.             }
  10.             array[i+1]=temp;
  11.         }
  12.     }

关于折半插入排序算法：

核心原理：

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

下面是代码的实现：

  1. private static void Half(int[] array, int length) {
  2.         //p stands for the times of the sort
  3.         int left,right,mid,p;
  4.         for(p=1;p<length;p++){
  5.             int temp=array[p];
  6.             left=0;right=p-1;
  7.             while(left<=right){
  8.                 mid=(left+right)/2;
  9.                 if(array[mid]>temp){
  10.                     right=mid-1;
  11.                 }else{
  12.                     left=mid+1;
  13.                 }
  14.             }
  15.             for(int i=p-1;i>=left;i--){
  16.                 array[i+1]=array[i];
  17.             }
  18.             array[left]=temp;
  19.         }
  20.     }

对于希尔排序：

核心原理：

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

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

代码实现：

  1. private static void Shell(int[] array, int length) {
  2.         // TODO Auto-generated method stub
  3.         int d=length/2;
  4.         while(d>=1){
  5.             for(int k=0;k<d;k++){
  6.                 //to every sub,carry the direcly insert
  7.                 for(int i=k+d;i<length;i+=d){
  8.                     int temp=array[i];
  9.                     int j=i-d;
  10.                     while(j>=k&&array[j]>temp){
  11.                         array[j+d]=array[j];
  12.                         j-=d;
  13.                     }
  14.                     array[j+d]=temp;
  15.                 }
  16.             }
  17.             d=d/2;
  18.         }
  19.     }

交换类排序算法

对于冒泡排序：

核心原理：

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

特点：

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

代码实现：

  1. private static void Bubble(int[] array, int length) {
  2.         // TODO Auto-generated method stub
  3.         for(int i=0;i<length;i++){
  4.             //expeclally the end case is "length-i"
  5.             for(int j=1;j<length-i;j++){
  6.                 if(array[j-1]>array[j]){
  7.                     int temp=array[j];
  8.                     array[j]=array[j-1];
  9.                     array[j-1]=temp;
  10.                 }
  11.             }
  12.         }
  13.     }

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

代码实现：

  1. private static void BubbleBetter(int[] array, int length) {
  2.         // TODO Auto-generated method stub
  3.         boolean flag=false;
  4.         for(int i=0;i<length;i++){
  5.             //expeclally the end case is "length-i"
  6.             for(int j=1;j<length-i;j++){
  7.                 flag=false;
  8.                 if(array[j-1]>array[j]){
  9.                     int temp=array[j];
  10.                     array[j]=array[j-1];
  11.                     array[j-1]=temp;
  12.                     flag=true;
  13.                 }
  14.             }
  15.             if(flag){
  16.                 return;
  17.             }
  18.         }
  19.     }

快速排序算法：

核心原理：

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

特征：

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

代码如下：

  1. private static void Fast(int[] array, int left, int right) {
  2.         // TODO Auto-generated method stub
  3.         if (left < right) {
  4.             int p = Partition1(array, left, right);
  5.             Fast(array, left, p - 1);
  6.             Fast(array, p + 1, right);
  7.         }
  8. //      if (left < right) {
  9. //          int p = Partition2(array, left, right);
  10. //          Fast(array, left, p - 1);
  11. //          Fast(array, p + 1, right);
  12. //      }
  13.     }
  15.     private static int Partition1(int[] array, int left, int right) {
  16.         int pivot = array[left];
  17.         while (left < right) {
  18.             while (left < right && array[right] >= pivot) {
  19.                 right--;
  20.             }
  21.             array[left] = array[right];
  22.             while (left < right && array[left] <= pivot) {
  23.                 left++;
  24.             }
  25.             array[right] = array[left];
  26.         }
  27.         array[left] = pivot;
  28.         return left;
  29.     }
  31.     private static int Partition2(int[] array, int start, int end) {
  32.         int pivot = array[start];
  33.         int left = start, right = end;
  34.         while (left <= right) {
  35.             while (left <= right && array[left] <= pivot) {
  36.                 left++;
  37.             }
  38.             while (left <= right && array[right] >= pivot) {
  39.                 right--;
  40.             }
  41.             if (left < right) {
  42.                 Swap(array[right], array[left]);
  43.                 left++;
  44.                 right--;
  45.             }
  46.         }
  47.         Swap(array[start], array[right]);
  48.         return right;
  50.     }

选择类排序算法

对于选择排序：

核心原理：

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

特征：

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

代码：

  1. private static void Select(int[] array, int length) {
  2.         // TODO Auto-generated method stub
  3.         for(int i=1;i<length;i++){
  4.             int k=i-1;
  5.             for(int j=i;j<length;j++){
  6.                 if(array[j]<array[k]){
  7.                     k=j;
  8.                 }
  9.             }
  10.             if(k!=i-1){
  11.                 int temp=array[i-1];
  12.                 array[i-1]=array[k];
  13.                 array[k]=temp;
  14.             }
  15.         }
  16.     }

归并类排序算法

对于归并排序：

核心原理：

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

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

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

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

特征：

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

代码如下：

  1. private static void MergeFunction(int[] array,int start, int end) {
  2.         // TODO Auto-generated method stub
  3.         if(start<end){
  4.             int mid=(start+end)/2;
  5.             MergeFunction(array, start, mid);
  6.             MergeFunction(array, mid+1, end);
  7.             Merge(array,start,mid,end);
  8.         }
  9.     }
  11.     private static void Merge(int[] array, int start, int mid, int end) {
  12.         // TODO Auto-generated method stub
  13.         int len1=mid-start+1,len2=end-mid;
  14.         int i,j,k;
  15.         //声明数组，分别保存子串信息
  16.         int[] left=new int[len1];
  17.         int[] right=new int[len2];
  18.         for(i=0;i<len1;i++){//执行数据复制
  19.             left[i]=array[i+start];
  20.         }
  21.         for(i=0;i<len2;i++){//执行数据复制
  22.             right[i]=array[i+mid+1];
  23.         }
  24.         i=0;j=0;
  25.         //执行合并操作
  26.         for(k=start;k<end;k++){
  27.             if(i==len1||j==len2){
  28.                 break;
  29.             }
  30.             if(left[i]<right[j]){
  31.                 array[k]=left[i++];
  32.             }else{
  33.                 array[k]=right[j++];
  34.             }
  35.         }
  37.         //若array[start,mid]还有待归并数据，则放到array后面
  38.         while(i<len1){
  39.             array[k++]=left[i++];
  40.         }
  42.         //对array[mid+1,end]见得数据执行同样的操作
  43.         while(j<len2){
  44.             array[k++]=left[j++];
  45.         }
  46.         //释放内存操作
  47.         left=null;
  48.         right=null;
  50.     }

总结：

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

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. 实现一个ordeeddict

    class MyOrderdict(): def __init__(self, mydict): self._cur = 0 self._mykeys = [] self._myvalues = [] ...

  2. Redis设置Key的过期时间 – EXPIRE命令

    EXPIRE key seconds 为给定 key 设置生存时间,当 key 过期时(生存时间为 0 ),它会被自动删除. 操作key对生存时间的影响 生存时间可以通过使用 DEL 命令来删除整个 ...

  3. web领域的实时推送技术-WebSocket

    WebSocket protocol 是HTML5一种新的协议.它实现了浏览器与服务器全双工通信(full-duplex),即是所谓的及时推送技术. 在此之前,很多网站为了实现及时推送技术通常采用的是 ...

  4. 关于html+ashx开发中几个问题的解决方法的感想和总结

    1.针对上篇文章中的服务端处理不敢苟同.仍然坚持使用反射,建立BaseHandler.ashx并在默认process方法中写上反射方法以及权限验证方法.针对具体的情况返回对应的值.服务端其他handl ...

  5. python学习之路基础篇(第五篇)

    前四天课程回顾 1.python简介 2.python基本数据类型 类: int:整型 | str:字符串 | list:列表 |tuple:元组 |dict:字典 | set:集合 对象: li = ...

  6. PyCharm 2018.1破解过程

    一.下载 首先从官网下载 官网,如果开了酸酸乳的话无法下载,官网会自动断开连接.所以下载时请关闭酸酸乳 二.安装 选择安装路径 选择64位,创建关联.py文件 安装完后运行Pycharm 选择不导入开 ...

  7. Linux设置文件读写权限

    设置文件夹的读写权限: sudo chmod -R 777 /data 权限码描述 sudo chmod 600 ××× (只有所有者有读和写的权限)sudo chmod 644 ××× (所有者有读 ...

  8. PHP MySQL 插入数据

    PHP MySQL 插入数据 使用 MySQLi 和 PDO 向 MySQL 插入数据 在创建完数据库和表后,我们可以向表中添加数据. 以下为一些语法规则: PHP 中 SQL 查询语句必须使用引号 ...

  9. JavaScript 对象JavaScript 对象

    JavaScript 中的所有事物都是对象:字符串.数值.数组.函数... 此外,JavaScript 允许自定义对象. 所有事物都是对象 JavaScript 提供多个内建对象,比如 String. ...

  10. Throughtput收集器

    介绍 JVM里面的Throughtput收集器是一款关注吞吐量的垃圾收集器.该收集器是唯一一个实现了UseAdaptiveSizePolicy策略的收集器,允许用户通过指定最大暂停时间和垃圾收集时间占 ...