整理了一下常用的排序算法,算法过程和示意图不详细讲,百度很多,只列代码,如有错误,还望大家指出。

1.冒泡排序

public static void bubbleSort(int[] a){
for(int i=a.length-1;i>0;i--){
for(int j=0;j<i;j++){
if(a[j]>a[j+1]){
int tmp=a[j];
a[j]=a[j+1];
a[j+1]=tmp;
}
}
}
}

,冒泡排序的时间复杂度为O(n^2),是稳定的算法

2.快速排序

public static void quickSort(int[] a,int l,int r){
if(l<r){
int i,j,x;
i=l;
j=r;
x=a[i];
while(i<j){
while(i<j&&a[j]>x)
j--;
if(i<j)
a[i++]=a[j];
while(i<j&&a[i]<x)
i++;
if(i<j)
a[j--]=a[i];
}
a[i]=x;
quickSort(a,l,i-1);
quickSort(a,i+1,r);
}
}

快速排序的时间复杂度O(N*logN),不稳定算法

3.插入排序

public static void insertSort(int[] a){
int i,j,k;
for(i=1;i<a,length;i++){
for(j=i-1;j>=0;j--){
if(a[j]<a[i])
break;
}
if(j!=i-1){
int tmp=a[i];
for(k=i-1;k>j;k--)
a[k+1]=a[k];
a[k+1]=tmp;
}
}
}

插入排序的时间复杂度O(N^2),稳定的算法

4.希尔排序

public static void shellSort(int[] a){
for(int gap=a.length/2;gap>0;gap/=2){
for(int i=0;i<gap;i++){
for(int j=i+gap;j<a.length;j+=gap){
if(a[j]<a[j-gap]){
int tmp=a[j];
int k=j-gap;
while(k>=0&&a[k]>tmp){
a[k+gap]=a[k];
k-=gap;
}
a[k+gap]=tmp;
}
}
}
}
}

希尔排序的时间复杂度与gap有关,当增量为1时,蜕化成插入排序,此时的复杂度为O(N^2),而Hibbard增量的希尔排序的时间复杂度为O(N^3/2),不稳定算法

5.选择排序

public static void selectSort(int[] a){
int i,j,min;
for(i=0;i<a.length;i++){
min=i;
for(j=i+1;j<a.length;j++){
if(a[j]<a[min])
min=j;
}
if(min!=i){
int tmp=a[i];
a[i]=a[min];
a[min]=tmp;
}
}
}

选择排序的时间复杂度为O(N^2),稳定的算法

6.堆排序

//最大堆的向下调整算法
publi static void maxHeapDown(int[] a,int start,int end){
int c=start;
int l=2*c+1;
int tmp=a[c];
for(;l<=end;c=l,l=2*l+1){
if(l<end&&a[l]<a[l+1])
l++;
if(tmp>a[l])
break;
else{
a[c]=a[l];
a[l]=tmp;
}
}
}
//堆排从小到大
public static void heapSortAsc(int[] a,int n){
int i,tmp;
for(i=n/2-1;i>=0;i--)
maxHeapDown(a,i,n-1);
for(i=n-1;i>0;i--){
tmp=a[0];
a[0]=a[i];
a[i]=tmp;
maxHeapDown(a,0,i-1);
}
} //最小堆的向下调整算法
public static void minHeapDown(int[] a,int start,int end){
int c=start;
int l=2*c+1;
int tmp=a[c];
for(;i<=end;c=1,l=2*l+1){
if(l<end&&a[l]<a[l+1])
l++;
if(tmp<=a[l])
break;
else{
a[c]=a[l];
a[l]=tmp;
}
}
} //堆排序从大到小 public static void heapSortDesc(int[] a,int n){
int i,tmp;
for(i=n/2-1;i>=0;i--)
minHeapDown(a,0,n-1);
for(i=n-1;i>0;i--){
tmp=a[0];
a[0]=a[i];
a[i]=tmp;
minHeapDown(a,0,i-1);
}
}

堆排序的时间复杂度O(N*logN),不稳定算法

7.归并排序

public static void merge(int[] a,int start,int mid,int end){
int[] tm=new int[end-start+1];
int i=start;
int j=mid+1;
int k=0;
while(i<=mid&&j<=end){
if(a[i]<a[j])
tmp[k++]=a[i++];
elss
tmp[k++]=a[j++];
}
while(i<=mid)
tmp[k++]=a[i++];
while(j<=end)
tmp[k++]=a[j++];
for(i=0;i<k;i++)
a[start+i]=tmp[i]'
tmp=null;
}
//归并排序(由上往下) public static void mergeSortUp2Down(int[] a,int start,int end){
if(a==null||start>=end)
return;
int mid=start+(end-start)/2;
mergeSortUp2Down(a,start,mid);
mergeSortUp2Down(a,min+1,end);
merge(a,start,mid,end);
} //归并排序(从下往上)
public atatic void mergeDown2Up(int[] a){
if(a==null)
return;
for(int n=1;n<a.length;n*=2)
mergeGroup(a,a.length,n);
} public static void mergeGroups(int[] a,int len,int gap){
int i;
int twolen=2*gap;
for(i=0;i+2*gap-1<len;i+=(2*gap))
merge(a,i,i+gap-1,i+2*gap-1);
if(i+gap-1<len-1)
merge(a,i,i+gap-1,len-1);
}

归并排序的时间复杂度为O(N*logN),稳定的算法

8.桶排序

public static void bucketSort(int[] a,int max){
int[] buckets;
if(a==null||max<1)
return;
buckets=new int[max];
for(int i=0;i<a.length;i++){
buckets[a[i]]++;
}
for(int i=0,j=0;i<max;i++){
while((buckets[i]--)>0){
a[j++]=i;
}
}
buckets=null;
}

转自:http://wangkuiwu.github.io

感谢wangkuiwu大神

排序算法合集(Java)的更多相关文章

  1. 排序算法合集(C++实现)

    摘要 排序操作在程序设计中是非常基础和常见的,也是算法的基础部分,我对几种常见的比较排序算法进行了整理. 暴力排序(violence sort) 思想:遍历数组,每次遍历都在未排序的部分找到最小元素的 ...

  2. 常见算法合集[java源码+持续更新中...]

    一.引子 本文搜集从各种资源上搜集高频面试算法,慢慢填充...每个算法都亲测可运行,原理有注释.Talk is cheap,show me the code! 走你~ 二.常见算法 2.1 判断单向链 ...

  3. 排序算法合集 python

    直接选择.插入排序 直接选择排序和直接插入排序类似,都将数据分为有序区和无序区,所不同的是直接播放排序是将无序区的第一个元素直接插入到有序区以形成一个更大的有序区,而直接选择排序是从无序区选一个最小的 ...

  4. 排序算法总结(基于Java实现)

    前言 下面会讲到一些简单的排序算法(均基于java实现),并给出实现和效率分析. 使用的基类如下: 注意:抽象函数应为public的,我就不改代码了 public abstract class Sor ...

  5. 常见排序算法题(java版)

    常见排序算法题(java版) //插入排序:   package org.rut.util.algorithm.support;   import org.rut.util.algorithm.Sor ...

  6. 八大排序算法总结与java实现(转)

    八大排序算法总结与Java实现 原文链接: 八大排序算法总结与java实现 - iTimeTraveler 概述 直接插入排序 希尔排序 简单选择排序 堆排序 冒泡排序 快速排序 归并排序 基数排序 ...

  7. 第二章:排序算法 及其他 Java代码实现

    目录 第二章:排序算法 及其他 Java代码实现 插入排序 归并排序 选择排序算法 冒泡排序 查找算法 习题 2.3.7 第二章:排序算法 及其他 Java代码实现 --算法导论(Introducti ...

  8. 动画展现十大经典排序算法(附Java代码)

    0.算法概述 0.1 算法分类 十种常见排序算法可以分为两大类: 比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此也称为非线性时间比较类排序. 非比较类排序: ...

  9. 排序算法代码实现-Java

    前言 为了准备面试,从2月开始将排序算法认认真真得刷了一遍,通过看书看视频,实践打代码,还有一部分的leetcode题,自己感觉也有点进步,将笔记记录总结发出来. 冒泡排序 该排序就是一种像泡泡浮到水 ...

随机推荐

  1. Java面向对象_适配器模式

    概念:将一个类的接口转换成客户希望的另外一个接口.适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作 public class Practice14 { public static v ...

  2. Zookeeper问题汇总

    1. 遗留问题 a). zookeeper集群如何保证请求的均匀分布? 2. ZK概念澄清 2.1 ZK节点类型 CreateMode.PERSISTENT //持久节点,该节点客户端断开后不会删除 ...

  3. SVN的搭建(权限配置篇)

    如要转载,请注明出处! 两个问题: 如何维护多个目录或者仓库 目录权限如何设置 ============================================================ ...

  4. js之BOM和DOM

      今天我们来学习js中的一些基础的操作. 一.BOM对象 BOM(浏览器对象模型),可以对浏览器窗口进行访问和操作.使用 BOM,开发者可以移动窗口.改变状态栏中的文本以及执行其他与页面内容不直接相 ...

  5. 学习笔记:MDN的JavaScript

    JavaScript 第一步 什么是JavaScript? 每次当你浏览网页时不只是显示静态信息—— 显示即时更新的内容, 或者交互式的地图,或 2D/3D 图形动画,又或者自动播放视频等,你可以确信 ...

  6. 学习笔记:MDN的HTML

    一.        HTML介绍: HTML —— 用于定义一个网页的结构的基本技术. 元素(Element):开始标记,加结束标记,加内容,等于元素. 两种重要的元素类别,块级元素和内联元素: 块级 ...

  7. HTTP响应报文与工作原理详解(转)

    超文本传输协议(Hypertext Transfer Protocol,简称HTTP)是应用层协议.HTTP 是一种请求/响应式的协议,即一个客户端与服务器建立连接后,向服务器发送一个请求;服务器接到 ...

  8. cms-静态化组件

    1.要让我们的网站性能更好,那么有的东西是需要做静态化的.做静态化步骤: 1.1在web.xml中配置监听器 1.2.创建一个bean用来实现静态化 web.xml <?xml version= ...

  9. Redis单机数据库

    单机数据库 ·Redis服务器的所有数据库都保存在redisServer.db数组中,而数据库的数量则由redisServer.dbnum属性保存. ·客户端通过修改目标数据库指针,让它指向redis ...

  10. 部署git服务器(Windows Server 2008)

    原来的这个项目是一个人开发的,没有做版本管理,我接手后准备搭建git版本管理服务端,方便离线开发和做版本管理: 一台云主机,操作系统:Windows Server 2008,64位: java已经安装 ...