Java实现7种常见的排序算法
数据结构中的内部排序:不需要访问外存便能完成,是一个逐步扩大记录的有序序列长度的过程。
可以分为5类:
1.插入排序:直接插入排序,稳定排序,时间复杂度为O(n^2)非递减有序,设置r[0]为哨兵进行n-1趟。
shell排序,不稳定的排序,时间复杂度为O(n^1.3)非递减有序,设置r[0]为哨兵。
2.选择排序:直接选择排序,稳定排序,时间复杂度为O(n^2)非递减有序。
堆排序,不稳定排序,时间复杂度为O(nlogn)非递减有序。
3.交换排序:冒泡排序,稳定排序,时间复杂度为O(n^2)非递减有序。进行n-1趟排序。
快速排序,不稳定排序,时间复杂度为O(nlogn),进行一趟排序确定一个数字的位置,左边的数比它小右边的数比它大。如果左右两边都有元素再分别对他们进行一次快排。
4.归并排序:前后两两合并开始(2,3),(5,6),(7,8),(9,10),然后两俩个合并进行排序。
5.分配排序:基数排序(一个关键字,多个关键字)(稳定排序)。
import java.util.Random; public class Sort { public Sort() {
// TODO Auto-generated constructor stub
} // 冒泡排序,该排序总共要进行n-1趟,每一趟的比较次数递减
public void bubbleSort(int[] a) {
if (a == null) {
return;
}
int len = a.length;
for (int i = 0; i < a.length - 1; i++)
for (int j = 0; j < len - i - 1; j++) {
if (a[j] > a[j + 1])
swrap(a, j, j + 1);
} } // 直接插入排序,该排序首先要设置一个哨兵,因为在排序的时候向前比较的过程中不会越界,a<a,不可能成立。
public void insertSort(int[] a) {
if (a == null) {
return;
}
int len = a.length;
int[] b = new int[len + 1];
System.arraycopy(a, 0, b, 1, len);
for (int i = 2; i <= len; i++) {
b[0] = b[i];
for (int j = i - 1; j > 0; j--) {
if (b[j] > b[0]) {
b[j + 1] = b[j];// 元素后移一位
b[j] = b[0];
}
}
}
System.arraycopy(b, 1, a, 0, len);
} // shell排序,该排序是插入排序的一种,只是,间隔不再是1而是d
public void shellSort(int[] a) {
if (a == null)
return;
int len = a.length;
int[] b = new int[len + 1];
System.arraycopy(a, 0, b, 1, len);
for (int d = len / 2; d >= 1; d /= 2) {
for (int i = d + 1; i <= len; i++) {
b[0] = b[i];
for (int j = i - d; j > 0; j -= d) {
if (b[j] > b[0]) {
b[j + d] = b[j];
b[j] = b[0];
}
}
}
}
System.arraycopy(b, 1, a, 0, len);
} // 选择排序,选出最小的值查到整个排好序的数组中,只要进行n-1次选择就OK
public void selectSort(int[] a) {
if (a == null)
return;
int len = a.length;
for (int i = 0; i < len - 1; i++) {
int min = i;// 初始化最小元素的下标。
for (int j = i + 1; j < len; j++) {
if (a[j] < a[min]) {
min = j;// 选出最小元素的下标。
}
swrap(a, i, min); }
}
} // 快速排序一次排序的结果,index左边的值小于它,右边的值大于它
public int parition(int[] a, int start, int end) {
Random rand = new Random();
int index = start + rand.nextInt(end - start);
swrap(a, index, end);
int small = start - 1;
for (index = start; index < end; index++) {
if (a[index] < a[end]) {
small++;
if (small != index) {
swrap(a, small, index);
}
}
}
small++;
swrap(a, small, end);
return small;
} // 快速排序,通过快速排序一趟的排序来确定index值,然后递归排序。
public void quickSort(int[] a, int start, int end) {
if (a == null || start < 0 || end > a.length || start == end)
return;
int index = parition(a, start, end);
if (index > start)
quickSort(a, start, index - 1);
if (index < end)
quickSort(a, index + 1, end);
} // 堆排序,首先要构建堆,我们以大根堆为例,就是大根堆的左右子节点都比本身要小
public void heapSort(int[] a) {
if (null != a) {
int end = a.length - 1;
for (int i = (end - 1) / 2; i >= 0; i--)
adjustHead(a, i, end);
for (int i = end; i >= 0; i--) {
swrap(a, 0, i);
adjustHead(a, 0, i - 1);
}
}
} public void adjustHead(int[] a, int start, int end) {
if (a == null || start < 0 || end > a.length || start == end)
return;
int temp = a[start];
for (int i = 2 * start + 1; i <= end; i = i * 2 + 1) {
if (i < end && a[i] < a[i + 1])
i++;
if ((a[i] > temp)) {
a[start] = a[i];
start = i;
} else
break;
}
a[start] = temp;
} private void swrap(int[] a, int j, int i) {
// TODO Auto-generated method stub
int temp = a[j];
a[j] = a[i];
a[i] = temp;
} private void print(int[] a) {
for (int temp : a)
System.out.print(temp + " ");
System.out.println();
}
//归并排序,首先将数组分成n个小片,然后两两归并。需要借助一个O(n)的空间。
//时间复杂度为O(nlogn)
public void mergeSort(int[] a){
if(a==null)
return;
int[] b=new int[a.length];
System.arraycopy(a, 0, b, 0, a.length);
mergeSortCore(a,b,0,a.length-1);
System.arraycopy(b, 0, a, 0, a.length); }
//归并排序的核心
public void mergeSortCore(int[] a, int[] b, int start, int end) {
if(a==null||b==null){
return;
}
if(start==end){
b[start]=a[start];
return;
}
int len=(end-start)/2;
mergeSortCore(b,a,start,start+len);
mergeSortCore(b,a,start+len+1,end);
//用来表示前半段的最后一个下标
int i=start+len;
//用来表示后半段的最后一个下标
int j=end;
int index=end;
while(i>=start&&j>=start+len+1){
if(a[i]>a[j])
b[index--]=a[i--];
else
b[index--]=a[j--]; }
for(;i>=start;i--)
b[index--]=a[i];
for(;j>=start+len+1;j--)
b[index--]=a[j]; } public static void main(String[] args) {
int[] a = { 3, 5, 7, 2, 1, 8, 4 };
Sort s = new Sort();
s.bubbleSort(a);
s.print(a);
s.insertSort(a);
s.print(a);
s.shellSort(a);
s.print(a);
s.selectSort(a);
s.print(a);
s.quickSort(a, 0, a.length - 1);
s.print(a);
s.heapSort(a);
s.print(a);
} }
Java实现7种常见的排序算法的更多相关文章
- java讲讲几种常见的排序算法(二)
java讲讲几种常见的排序算法(二) 目录 java讲讲几种常见的排序算法(一) java讲讲几种常见的排序算法(二) 堆排序 思路:构建一个小顶堆,小顶堆就是棵二叉树,他的左右孩子均大于他的根节点( ...
- java讲讲几种常见的排序算法
java讲讲几种常见的排序算法(一) 目录 java讲讲几种常见的排序算法(一) java讲讲几种常见的排序算法(二) 以数组array={6,3,20,8,15,1}为例 冒泡排序 思路:从第0个到 ...
- 用Java实现几种常见的排序算法
用Java语言实现的各种排序,包括插入排序.冒泡排序.选择排序.Shell排序.快速排序.归并排序.堆排序.SortUtil等. 插入排序: package org.rut.util.algorith ...
- java几种常见的排序算法总结
/*************几种常见的排序算法总结***************************/ package paixu; public class PaiXu { final int ...
- 七种常见经典排序算法总结(C++实现)
排序算法是非常常见也非常基础的算法,以至于大部分情况下它们都被集成到了语言的辅助库中.排序算法虽然已经可以很方便的使用,但是理解排序算法可以帮助我们找到解题的方向. 1. 冒泡排序 (Bubble S ...
- python3实现几种常见的排序算法
python3实现几种常见的排序算法 冒泡排序 冒泡排序是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来.走访数列的工作是重复地进行直到没有再需要 ...
- Java中8种常见的排序方法
排序方法的演示1)插入排序(直接插入排序.希尔排序)2)交换排序(冒泡排序.快速排序)3)选择排序(直接选择排序.堆排序)4)归并排序5)分配排序(基数排序)所需辅助空间最多:归并排序所需辅助空间最少 ...
- Python全栈开发之5、几种常见的排序算法以及collections模块提供的数据结构
转载请注明出处http://www.cnblogs.com/Wxtrkbc/p/5492298.html 在面试中,经常会遇到一些考排序算法的题,在这里,我就简单了列举了几种最常见的排序算法供大家学习 ...
- 用php实现四种常见的排序算法
几种常见的排序 排序是一个程序员的基本功,对于初级phper,更是可以通过排序算法来锻炼自己的思维能力. 所谓排序,就是对一组数据,按照某个顺序排列的过程.下面就总结四种常用的php排序算法,分别是冒 ...
随机推荐
- sql统计上周销售量的起止时间
开始日期: >select DATEADD(Day, 1 - DATEPART(Weekday,CONVERT(varchar(10), GETDATE() - 7, 120)), CONVER ...
- Servlet+MyBatis项目转Spring Cloud微服务,多数据源配置修改建议
一.项目需求 在开发过程中,由于技术的不断迭代,为了提高开发效率,需要对原有项目的架构做出相应的调整. 二.存在的问题 为了不影响项目进度,架构调整初期只是把项目做了简单的maven管理,引入spri ...
- kali 源设置sources.list
由于阿里源有些问题,可能我设置的问题,所以就去掉了,163的很快 # deb cdrom:[Debian GNU/Linux 2016.1 _Kali-rolling_ - Official Snap ...
- 使用MyCat分表分库原理分析
Mycat可以实现 读写分离 分表分库 主从复制是MySQL自带的哈~ 关于分片取模算法: 根据id进行取模 根据数据库集群的数量(或者说是表数量,mycat里面一个表对应一个库) 使用MyCat ...
- NumPy数组创建例程
NumPy - 数组创建例程 新的ndarray对象可以通过任何下列数组创建例程或使用低级ndarray构造函数构造. numpy.empty 它创建指定形状和dtype的未初始化数组. 它使用以下构 ...
- CNI:容器网络接口
CNI 简介 不管是 docker 还是 kubernetes,在网络方面目前都没有一个完美的.终极的.普适性的解决方案,不同的用户和企业因为各种原因会使用不同的网络方案.目前存在网络方案 flann ...
- html笔记(1)
hgroup 代替div figure figcaption 独立流内容 替代 dl mark 替代 span
- mysql应该看的blog
一个比较系统的学习mysql的网站:http://www.runoob.com/mysql/mysql-data-types.html
- python学习笔记(excel+unittest)
准备先利用之前整理的python自带的unittest框架 整合excel 实现接口自动化测试功能 先看看excel表格设置: 下来是对excel获取的代码: #!/usr/bin/env pytho ...
- javascrip函数简单介绍
JavaScript 函数定义JavaScript 使用关键字 function 定义函数.函数可以通过声明定义,也可以是一个表达式.函数声明在之前的教程中,你已经了解了函数声明的语法 :functi ...