详细总结各种排序算法(Java实现)

一、插入类排序

1.直接插入排序

思想:将第i个插入到前i-1个中的适当位置

时间复杂度:T(n) = O(n²)。

空间复杂度:S(n) = O(1)。

稳定性:稳定排序。

如果碰见一个和插入元素相等的,那么插入元素把想插入的元素放在相等元素的后面。

所以,相等元素的前后顺序没有改变,从原无序序列出去的顺序就是排好序后的顺序,所以插入排序是稳定

哨兵有两个作用:

① 进人查找(插入位置)循环之前,它保存了R[i]的副本,使不致于因记录后移而丢失R[i]的内容;

② 它的主要作用是:在查找循环中"监视"下标变量j是否越界。一旦越界(即j=0),因为R[0].可以和自己比较,循环判定条件不成立使得查找循环结束,从而避免了在该循环内的每一次均要检测j是否越界(即省略了循环判定条件"j>=1")

public void insertSort(int[] array){
  for(int i=1;i<array.length;i++)//第0位独自作为有序数列,从第1位开始向后遍历
  {
   if(array[i]<array[i-1])//0~i-1位为有序,若第i位小于i-1位,继续寻位并插入,否则认为0~i位也是有序的,忽略此次循环,相当于continue
   {
    int temp=array[i];//保存第i位的值
    int k = i - 1;
    for(int j=k;j>=0 && temp<array[j];j--)//从第i-1位向前遍历并移位,直至找到小于第i位值停止
    {
     array[j+1]=array[j];
     k--;
    }
    array[k+1]=temp;//插入第i位的值
   }
  }
}

2.折半插入排序

思想:将数据插入到已经排好序的序列中,通过不断与中间点比较大小来确定位置

时间复杂度:比较时的时间减为O(n㏒n),但是移动元素的时间耗费未变,所以总是得时间复杂度还是O(n²)。

空间复杂度:S(n) = O(1)。

稳定性:稳定排序。

3.希尔排序

思想:又称缩小增量排序法。把待排序序列分成若干较小的子序列,然后逐个使用直接插入排序法排序,最后再对一个较为有序的序列进行一次排序,主要是为了减少移动的次数,提高效率。原理应该就是从无序到渐渐有序,要比直接从无序到有序移动的次数会少一些。

时间复杂度:O(n的1.5次方)

空间复杂度:O(1)

稳定性:不稳定排序。{2,4,1,2},2和1一组4和2一组,进行希尔排序,第一个2和最后一个2会发生位置上的变化。

public static void main(String [] args)
{
 int[]a={49,38,65,97,76,13,27,49,78,34,12,64,1};
  System.out.println("排序之前:");
  for(int i=0;i<a.length;i++)
  {
   System.out.print(a[i]+" ");
  }
  //希尔排序
  int d=a.length;
   while(true)
   {
    d=d/2;
    for(int x=0;x<d;x++)
    {
     for(int i=x+d;i<a.length;i=i+d)
     {
      int temp=a[i];
      int j;
      for(j=i-d;j>=0&&a[j]>temp;j=j-d)
      {
       a[j+d]=a[j];
      }
      a[j+d]=temp;
     }
    }
    if(d==1)
    {
     break;
    }
   }
   System.out.println();
   System.out.println("排序之后:");
    for(int i=0;i<a.length;i++)
    {
     System.out.print(a[i]+" ");
    }
  }
}

二、交换类排序

1.冒泡排序

时间复杂度:T(n) = O(n²)。

空间复杂度:S(n) = O(1)。

稳定性:稳定排序。

public class BubbleSort
{
 public void sort(int[] a)
 {
  int temp = 0;
  for (int i = a.length - 1; i > 0; --i)
  {
   for (int j = 0; j < i; ++j)
   {
    if (a[j + 1] < a[j])
    {
     temp = a[j];
     a[j] = a[j + 1];
     a[j + 1] = temp;
    }
   }
  }
 }
}

2.快速排序

思想:对冒泡排序的改进,通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

时间复杂度:平均T(n) = O(n㏒n),最坏O(n²)。

空间复杂度:S(n) = O(㏒n)。

稳定性:不稳定排序

首先把数组的第一个数拿出来做为一个key,在前后分别设置一个i,j做为标识,然后拿这个key对这个数组从后面往前遍历,及j--,直到找到第一个小于这个key的那个数,然后交换这两个值,交换完成后,我们拿着这个key要从i往后遍历了,及i++;一直循环到i=j结束,当这里结束后,我们会发现大于这个key的值都会跑到这个key的后面

三、选择类排序

1.简单选择排序

时间复杂度:T(n) = O(n²)。

空间复杂度:S(n) = O(1)。

稳定性:不稳定排序

思路:

1)从待排序的序列中,找到关键字最小的元素

2)如果最小的元素不在第一位,就和第一个元素互换位置

3)从余下的N-1个元素中,找到关键字最小的元素,重复 1)、2)步

public class SelectionSort {
 public void selectionSort(int[] list) {
  // 需要遍历获得最小值的次数
  // 要注意一点,当要排序 N 个数,已经经过 N-1 次遍历后,已经是有序数列
  for (int i = 0; i < list.length - 1; i++) {
   int temp = 0;
   int index = i; // 用来保存最小值得索引
   // 寻找第i个小的数值
   for (int j = i + 1; j < list.length; j++) {
    if (list[index] > list[j]) {
     index = j;
    }
   }
   // 将找到的第i个小的数值放在第i个位置上
   temp = list[index];
   list[index] = list[i];
   list[i] = temp;
   System.out.format("第 %d 趟:\t", i + 1);
   printAll(list);
  }
 }
 // 打印完整序列
 public void printAll(int[] list) {
  for (int value : list) {
   System.out.print(value + "\t");
  }
  System.out.println();
 }
 public static void main(String[] args) {
  // 初始化一个随机序列
  final int MAX_SIZE = 10;
  int[] array = new int[MAX_SIZE];
  Random random = new Random();
  for (int i = 0; i < MAX_SIZE; i++) {
   array[i] = random.nextInt(MAX_SIZE);
  }
  // 调用排序方法
  SelectionSort selection = new SelectionSort();
  System.out.print("排序前:\t");
  selection.printAll(array);
  selection.selectionSort(array);
  System.out.print("排序后:\t");
  selection.printAll(array);
 }
}

2.树形选择排序

思想:为了减少比较次数,两两进行比较,得出的较小的值再两两比较,直至得出最小的输出,然后在原来位置上置为∞,再进行比较。直至所有都输出。

时间复杂度:T(n) = O(n㏒n)。

空间复杂度:较简单选择排序,增加了n-1个额外的存储空间存放中间比较结果,就是树形结构的所有根节点。S(n) = O(n)。

稳定性:稳定排序。

3.堆排序

【待】

四.、归并排序

归并排序:

思想:假设初始序列有n个记录,首先将这n个记录看成n个有序的子序列,每个子序列的长度为1,然后两两归并,得到n/2向上取整个长度为2(n为奇数时,最后一个序列的长度为1)的有序子序列

在此基础上,在对长度为2的有序子序列进行两两归并,得到若干个长度为4的有序子序列  

如此重复,直至得到一个长度为n的有序序列为止。

时间复杂度:T(n) = O(n㏒n)

空间复杂度:S(n) = O(n)

稳定性:稳定排序

public class MergeSort {

 public static void merge(int[] a, int low, int mid, int high) {
  int[] temp = new int[high - low + 1];
  int i = low;// 左指针
  int j = mid + 1;// 右指针
  int k = 0;
  // 把较小的数先移到新数组中
  while (i <= mid && j <= high) {
   if (a[i] < a[j]) {
    temp[k++] = a[i++];
   } else {
    temp[k++] = a[j++];
   }
  }
  // 把左边剩余的数移入数组
  while (i <= mid) {
   temp[k++] = a[i++];
  }
  // 把右边边剩余的数移入数组
  while (j <= high) {
   temp[k++] = a[j++];
  }
  // 把新数组中的数覆盖nums数组
  for (int k2 = 0; k2 < temp.length; k2++) {
   a[k2 + low] = temp[k2];
  }
 }

 public static void mergeSort(int[] a, int low, int high) {
  int mid = (low + high) / 2;
  if (low < high) {
   // 左边
   mergeSort(a, low, mid);
   // 右边
   mergeSort(a, mid + 1, high);
   // 左右归并
   merge(a, low, mid, high);
   System.out.println(Arrays.toString(a));
  }

 }

 public static void main(String[] args) {
  int a[] = { 51, 46, 20, 18, 65, 97, 82, 30, 77, 50 };
  mergeSort(a, 0, a.length - 1);
  System.out.println("排序结果:" + Arrays.toString(a));
 }
}

五、分配类排序

1.多关键字排序:

【待】

2.链式基数排序:

思想:先分配,再收集,就是先按照一个次关键字收集一下,然后进行收集(第一个排序),然后再换一个关键字把新序列分配一下,然后再收集起来,又完成一次排序,这样所有关键字分配收集完后,就完成了排序。

时间复杂度:T(n) = O( d ( n + rd ) )

空间复杂度:S(n) = O(rd)

稳定性:稳定排序

以上这篇详细总结各种排序算法(Java实现)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们。

时间: 2017-09-10

JAVA简单选择排序算法原理及实现

简单选择排序:(选出最小值,放在第一位,然后第一位向后推移,如此循环)第一位与后面每一个逐个比较,每次都使最小的置顶,第一位向后推进(即刚选定的第一位是最小值,不再参与比较,比较次数减1) 复杂度: 所需进行记录移动的操作次数较少 0--3(n-1) ,无论记录的初始排列如何,所需的关键字间的比较次数相同,均为n(n-1)/2,总的时间复杂度为O(n2):空间复杂度 O(1) 算法改进:每次对比,都是为了将最小的值放到第一位,所以可以一比到底,找出最小值,直接放到第一位,省去无意义的调换移动操作

十种JAVA排序算法实例

排序算法有很多,所以在特定情景中使用哪一种算法很重要.为了选择合适的算法,可以按照建议的顺序考虑以下标准: (1)执行时间 (2)存储空间 (3)编程工作  对于数据量较小的情形,(1)(2)差别不大,主要考虑(3):而对于数据量大的,(1)为首要. 一.冒泡(Bubble)排序 复制代码 代码如下: void BubbleSortArray() {       for(int i=1;i<n;i++)       {         for(int j=0;i<n-i;j++)       

三种简单排序算法(使用java实现)

一.冒泡排序 算法思想:遍历待排序的数组,每次遍历比较相邻的两个元素,如果他们的排列顺序错误就交换他们的位置,经过一趟排序后,最大的元素会浮置数组的末端.重复操 作,直到排序完成. 示例演示: 算法实现: for(int i=0;i<array.length-1;i++){//最多排序n-1次 for(int j=0;j<array.length-i-1;j++){//需要交换的次数 if(array[j]>array[j+1]){ int temp=array[j]; array[j]

Java排序算法总结之堆排序

本文实例讲述了Java排序算法总结之堆排序.分享给大家供大家参考.具体分析如下: 1991年计算机先驱奖获得者.斯坦福大学计算机科学系教授罗伯特·弗洛伊德(Robert W.Floyd)和威廉姆斯(J.Williams)在1964年共同发明了著名的堆排序算法( Heap Sort ).本文主要介绍堆排序用Java来实现. 堆积排序(Heapsort)是指利用堆积树(堆)这种资料结构所设计的一种排序算法,可以利用数组的特点快速定位指定索引的元素.堆排序是不稳定的排序方法,辅助空间为O(1), 最坏

java几种排序算法的实现及简单分析

本文实例讲述了java几种排序算法的实现及简单分析.分享给大家供大家参考.具体如下: package test; public class first { /*普通的插入排序*/ public void insertSort(int[] list) { int i, j; list[0] = -999; //相当于设置一个监视哨兵,不用判断是否越界, //但要求数组从第二个数开始即i=1开始存储 for (i = 1; i < list.length; i++) { j = i; while (

Java实现几种常见排序算法代码

稳定度(稳定性)一个排序算法是稳定的,就是当有两个相等记录的关键字R和S,且在原本的列表中R出现在S之前,在排序过的列表中R也将会是在S之前. 排序算法分类 常见的有插入(插入排序/希尔排序).交换(冒泡排序/快速排序).选择(选择排序).合并(归并排序)等. 一.插入排序 插入排序(Insertion Sort),它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入.插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),

JavaScript中几种常见排序算法小结

说明 写这个主要是为了锻炼自己,并无实际意义. 每个浏览器测试得出的数据会不一样.比如我用chrome 测试 一般快速排序都会最快,IE 则根据数组长度有可能希尔最快. 不要用太大数据去测试冒泡排序(浏览器崩溃了我不管) 如果有兴趣可以 下载测试页面 个人理解 冒泡排序:最简单,也最慢,貌似长度小于7最优 插入排序: 比冒泡快,比快速排序和希尔排序慢,较小数据有优势 快速排序:这是一个非常快的排序方式,V8的sort方法就使用快速排序和插入排序的结合 希尔排序:在非chrome下数组长度小于10

java实现的各种排序算法代码示例

折半插入排序 折半插入排序是对直接插入排序的简单改进.此处介绍的折半插入,其实就是通过不断地折半来快速确定第i个元素的 插入位置,这实际上是一种查找算法:折半查找.Java的Arrays类里的binarySearch()方法,就是折半查找的实现,用 于从指定数组中查找指定元素,前提是该数组已经处于有序状态.与直接插入排序的效果相同,只是更快了一些,因 为折半插入排序可以更快地确定第i个元素的插入位置 代码: package interview; /** * @author Administrat

浅谈Java中几种常见的比较器的实现方法

在Java中经常会涉及到对象数组的排序问题,那么就涉及到对象之间的比较问题. 通常对象之间的比较可以从两个方面去看: 第一个方面:对象的地址是否一样,也就是是否引用自同一个对象.这种方式可以直接使用"=="来完成. 第二个方面:以对象的某一个属性的角度去比较. 从最新的JDK8而言,有三种实现对象比较的方法: 一.覆写Object类的equals()方法: 二.继承Comparable接口,并实现compareTo()方法: 三.定义一个单独的对象比较器,继承自Comparator接口

Python八大常见排序算法定义、实现及时间消耗效率分析

本文实例讲述了Python八大常见排序算法定义.实现及时间消耗效率分析.分享给大家供大家参考,具体如下: 昨晚上开始总结了一下常见的几种排序算法,由于之前我已经写了好几篇排序的算法的相关博文了现在总结一下的话可以说是很方便的,这里的目的是为了更加完整详尽的总结一下这些排序算法,为了复习基础的东西,从冒泡排序.直接插入排序.选择排序.归并排序.希尔排序.桶排序.堆排序.快速排序入手来分析和实现,在最后也给出来了简单的时间统计,重在原理.算法基础,其他的次之,这些东西的熟练掌握不算是对之后的工作或者

PHP实现四种基础排序算法的运行时间比较(推荐)

许多人都说算法是程序的核心,算法的好坏决定了程序的质量.作为一个初级phper,虽然很少接触到算法方面的东西.但是对于基本的排序算法还是应该掌握的,它是程序开发的必备工具.下面通过本文给大家介绍PHP实现四种基础排序算法的运行时间比较,一起看下吧. 废话不多说了,直接给大家贴代码了. 具体代码如下所示: /** * php四种基础排序算法的运行时间比较 * @authors Jesse (jesse152@163.com) * @date 2016-08-11 07:12:14 */ //冒泡排

Javascript中的常见排序算法

具体代码及比较如下所示: 复制代码 代码如下: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  <html xmlns="http://www.w3.org/1999/xhtml" lang="gb2312">

Java HashMap两种简便排序方法解析

这篇文章主要介绍了Java HashMap两种简便排序方法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 HashMap的储存是没有顺序的,而是按照key的HashCode实现. key=手机品牌,value=价格,这里以这个例子实现按名称排序和按价格排序. Map phone=new HashMap(); phone.put("Apple",8899); phone.put("SAMSUNG",7000);

几种经典排序算法的JS实现方法

一.冒泡排序 function BubbleSort(array) { var length = array.length; for (var i = length - 1; i > 0; i--) { //用于缩小范围 for (var j = 0; j < i; j++) { //在范围内进行冒泡,在此范围内最大的一个将冒到最后面 if (array[j] > array[j+1]) { var temp = array[j]; array[j] = array[j+1]; arra