常见排序的Java实现
插入排序
1、原理：在有序数组中从后向前扫描找到要插入元素的位置，将元素插入进去。
2、步骤：插入元素和依次和前一个元素进行比较，若比前一个元素小就交换位置，否则结束循环。
3、代码：
package ecut.sort; import java.util.ArrayList;
import java.util.List;
import java.util.Scanner; import edu.princeton.cs.algs4.StdOut;
/**
*
* 插入排序是将数组中无序数中依次和有序数进行比较，直到插入到正确的位置。
* 需要n-1趟完成排序，比较次数最坏是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次,最好是n-1次比较。
* 交换次数最坏是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次,最好是0次交换。时间复杂度是O(n^2)。
*/
public class InsertionSort { private static Scanner sc;
@SuppressWarnings("rawtypes")
public static void sort(Comparable[] a) {
int N = a.length;
for (int i = 1; i < N; i++) {
for (int j = i - 1; j >= 0 && less(a[j + 1], a[j]); j--) {
exch(a, j + 1, j);
}
}
} @SuppressWarnings({ "rawtypes", "unchecked" })
public static boolean less(Comparable v, Comparable w) {
// v.compareTo(w):v<w 返回负整数 v=w 返回0 v>w 返回正整数
return v.compareTo(w) < 0;
} @SuppressWarnings("rawtypes")
public static void exch(Comparable[] a, int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
} @SuppressWarnings("rawtypes")
public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
StdOut.print(a[i] + " ");
}
StdOut.println();
} @SuppressWarnings("rawtypes")
public static boolean isSorted(Comparable[] a) {
for (int i = 1; i < a.length; i++) {
if (less(a[i], a[i - 1])) {
return false;
}
}
return true;
} public static void main(String[] args) {
sc = new Scanner(System.in);
String[] a = null;
List<String> list = new ArrayList<String>();
while(sc.hasNextLine()){
list.add(sc.nextLine());
}
a=list.toArray(new String[0]);
sort(a);
assert isSorted(a);
show(a); }
}
排序方法等价于：
@SuppressWarnings("rawtypes")
public static void sort(Comparable[] a) {
int N = a.length;
for (int i = 1; i < N; i++) {
//用k记录当前的位置
int k = i;
for (int j = i - 1; j >= 0; j--) {
if (less(a[k], a[j])) {
exch(a, k, j);//k=i,j=i-1 ===> k=j+1
//交换后要让k重新指向插入元素的位置
k--;
}else{
break;
}
}
}
}
插入排序是将数组中无序数中依次和有序数进行比较，直到插入到正确的位置。需要n-1趟完成排序，比较次数最坏是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次，最好是n-1次比较。交换次数最坏是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次，最好是0次交换。时间复杂度是O(n^2)。
选择排序
1、原理：依次从数组中选出最小的放入到对应位置。
2、步骤：找出数组中的最小值，和对应位置的元素进行交换，最小的和a[0]交换，其次小的和a[1]交换，以此类推。
3、代码：
package ecut.sort; import java.util.ArrayList;
import java.util.List;
import java.util.Scanner; import edu.princeton.cs.algs4.StdOut;
/**
*
* 选择排序是依次选择数组中无序数中最小的和对应的数交换位置，最小的数和a[0]交换，第二小的和a[1]交换，以此类推。
* 需要n-1趟完成排序，比较次数是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次，n-1次交换，时间复杂度是O(n^2)
*
*/
public class SelectionSort { private static Scanner sc; @SuppressWarnings("rawtypes")
public static void sort(Comparable[] a) {
int N = a.length;
for (int i = 0; i < N - 1; i++) {
int min = i;
for (int j = i + 1; j < N; j++) {
if (less(a[j], a[min])) {
min = j;
}
}
exch(a, i, min);
}
} @SuppressWarnings({ "rawtypes", "unchecked" })
public static boolean less(Comparable v, Comparable w) {
// v.compareTo(w):v<w 返回负整数 v=w 返回0 v>w 返回正整数
return v.compareTo(w) < 0;
} @SuppressWarnings("rawtypes")
public static void exch(Comparable[] a, int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
} @SuppressWarnings("rawtypes")
public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
StdOut.print(a[i] + " ");
}
StdOut.println();
} @SuppressWarnings("rawtypes")
public static boolean isSorted(Comparable[] a) {
for (int i = 1; i < a.length; i++) {
if (less(a[i], a[i - 1])) {
return false;
}
}
return true;
} public static void main(String[] args) {
sc = new Scanner(System.in);
String[] a = null;
List<String> list = new ArrayList<String>();
while(sc.hasNextLine()){
list.add(sc.nextLine());
}
a=list.toArray(new String[0]);
sort(a);
assert isSorted(a);
show(a); }
}
需要n-1趟完成排序，比较次数是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次，n-1次交换，时间复杂度是O(n^2)
归并排序
1、原理：将两个有序数组合并成一个新的有序数组。
2、步骤：对数组进行折半，分别对两边数组进行归并排序，先讲需要排序的数组拷贝到一个新数组中，然后比较mid+1和low所对应的值，将较小的数放入到拷贝数组中，以此类推。
3、代码：
package ecut.sort; import java.util.ArrayList;
import java.util.List;
import java.util.Scanner; import edu.princeton.cs.algs4.StdOut;
/**
*
* 归并排序是将两个有序的数组合并到一个数组中。
* 数组长度为n的数组，比较次数所形成的二叉树有n层，总节点数是N=2^n-1，n=lgN+1 ~ lgN,比较次数最坏是n*2^n次即NlgN,最好是1/2 NlgN次比较。
* 时间复杂度是O(n log n)
*/
public class MergeSort { private static Scanner sc; @SuppressWarnings("rawtypes")
private static Comparable[] aux; @SuppressWarnings("rawtypes")
public static void sort(Comparable[] a) {
aux = new Comparable[a.length];
sort(a,0,a.length-1);
} @SuppressWarnings("rawtypes")
public static void sort(Comparable[] a,int lo,int hi){
if(hi<=lo) return;
int mid =lo+ (hi-lo)/2;
sort(a,lo,mid);
sort(a,mid+1,hi);
merge(a,lo,mid,hi);
} @SuppressWarnings("rawtypes")
public static void merge(Comparable[] a,int lo, int mid,int hi){
int i=lo;
int j=mid+1;
for(int k=lo;k<=hi;k++){
aux[k]=a[k];
}
for (int k = lo; k <= hi; k++) {
if (i > mid)
a[k] = aux[j++];
else if(j>hi)
a[k] = aux[i++];
else if(less(aux[j],aux[i]))
a[k]=aux[j++];
else
a[k]=aux[i++]; }
} @SuppressWarnings({ "rawtypes", "unchecked" })
public static boolean less(Comparable v, Comparable w) {
// v.compareTo(w):v<w 返回负整数 v=w 返回0 v>w 返回正整数
return v.compareTo(w) < 0;
} @SuppressWarnings("rawtypes")
public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
StdOut.print(a[i] + " ");
}
StdOut.println();
} @SuppressWarnings("rawtypes")
public static boolean isSorted(Comparable[] a) {
for (int i = 1; i < a.length; i++) {
if (less(a[i], a[i - 1])) {
return false;
}
}
return true;
} public static void main(String[] args) {
sc = new Scanner(System.in);
String[] a = null;
List<String> list = new ArrayList<String>();
while(sc.hasNextLine()){
list.add(sc.nextLine());
}
a=list.toArray(new String[0]);
sort(a);
assert isSorted(a);
show(a); }
}
归并排序是将两个有序的数组合并到一个数组中。数组长度为n的数组，比较次数所形成的二叉树有n层，总节点数是N=2^n-1，n=lgN+1 ~ lgN,比较次数最坏是n*2^n次即NlgN,最好是1/2 NlgN次比较。 时间复杂度是O(n log n)。
冒泡排序
1、原理：依次比较相邻两个数的大小，最大的i数沉到zu
2、步骤：每趟排序中依次比较相邻两个数的大小，a[0]和a[1]比较，a[1]和a[2]比较，以此类推，直至结束，然后重复执行，直到所有的书有序。
3、代码：
package ecut.sort; import java.util.ArrayList;
import java.util.List;
import java.util.Scanner; import edu.princeton.cs.algs4.StdOut;
/**
*
* 冒泡排序是将数组依次比较相邻的两个数，将小数放在前面，大数放在后面。
* 需要n-1趟完成排序，比较次数最坏是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次,时间复杂度是O(n^2)。
*/
public class BubbleSort { private static Scanner sc; @SuppressWarnings("rawtypes")
public static void sort(Comparable[] a) {
for(int i=0; i<a.length-1;i++){
for(int j=0; j<a.length-i-1;j++){
if(less(a[j+1],a[j])){
exch(a,j+1,j);
}
}
}
} @SuppressWarnings({ "rawtypes", "unchecked" })
public static boolean less(Comparable v, Comparable w) {
// v.compareTo(w):v<w 返回负整数 v=w 返回0 v>w 返回正整数
return v.compareTo(w) < 0;
} @SuppressWarnings("rawtypes")
public static void exch(Comparable[] a, int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
} @SuppressWarnings("rawtypes")
public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
StdOut.print(a[i] + " ");
}
StdOut.println();
} @SuppressWarnings("rawtypes")
public static boolean isSorted(Comparable[] a) {
for (int i = 1; i < a.length; i++) {
if (less(a[i], a[i - 1])) {
return false;
}
}
return true;
} public static void main(String[] args) {
sc = new Scanner(System.in);
String[] a = null;
List<String> list = new ArrayList<String>();
while(sc.hasNextLine()){
list.add(sc.nextLine());
}
a=list.toArray(new String[0]);
sort(a);
assert isSorted(a);
show(a); }
}
冒泡排序是将数组依次比较相邻的两个数，将小数放在前面，大数放在后面。需要n-1趟完成排序，比较次数最坏是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次，时间复杂度是O(n^2)。
快速排序
1、原理：找到一个目标元素，把比目标元素小的数放在目标元素的左侧，比目标元素大的数放在目标元素的右侧。
2、步骤：将 i 赋值为需要排序元素的初始位置，将 j 指向数组的末尾位置+1，然后让 i 依次后移，j 依次前移，若 j 所指向位置的元素比目标元素小就退出while循环，若 i 所指向位置的元素比目标元素大就退出while循环，然后交换两个元素。分别对数组的左半边和右半边都进行排序。
3、代码：
package ecut.sort; import java.util.ArrayList;
import java.util.List;
import java.util.Scanner; import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;
/**
*
* 快速排序是将数组切分使左侧小于a[j],右侧大于a[j]。
* 时间复杂度是O(n log n)
*
*/
public class QuickSort { private static Scanner sc; @SuppressWarnings("rawtypes")
public static void sort(Comparable[] a) {
StdRandom.shuffle(a);//清楚对输入的依赖
sort(a,0,a.length-1);
} @SuppressWarnings("rawtypes")
public static void sort(Comparable[] a,int lo,int hi){
if(hi<=lo) return;
int j=partition(a,lo,hi);
sort(a,lo,j-1);
sort(a,j+1,hi); } @SuppressWarnings("rawtypes")
public static int partition(Comparable[] a,int lo,int hi){
Comparable v = a[0];
int i = lo;
int j = hi+1;
while(true){
while(less(a[++i],v)){
if(i==hi){
break;
}
}
while(less(v,a[--j])){
if(j==lo){
break;
}
}
if(i>=j){
break;
}
exch(a,i,j);
}
exch(a,lo,j);
return j; } @SuppressWarnings("rawtypes")
public static void exch(Comparable[] a, int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
} @SuppressWarnings({ "rawtypes", "unchecked" })
public static boolean less(Comparable v, Comparable w) {
// v.compareTo(w):v<w 返回负整数 v=w 返回0 v>w 返回正整数
return v.compareTo(w) < 0;
} @SuppressWarnings("rawtypes")
public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
StdOut.print(a[i] + " ");
}
StdOut.println();
} @SuppressWarnings("rawtypes")
public static boolean isSorted(Comparable[] a) {
for (int i = 1; i < a.length; i++) {
if (less(a[i], a[i - 1])) {
return false;
}
}
return true;
} public static void main(String[] args) {
sc = new Scanner(System.in);
String[] a = null;
List<String> list = new ArrayList<String>();
while(sc.hasNextLine()){
list.add(sc.nextLine());
}
a=list.toArray(new String[0]);
sort(a);
assert isSorted(a);
show(a); }
}
快速排序的时间复杂度是O(n log n)。
转载请于明显处标明出处
https://www.cnblogs.com/AmyZheng/p/9502759.html
推荐博客链接
https://www.cnblogs.com/onepixel/articles/7674659.html
常见排序的Java实现的更多相关文章
- 常见排序的JAVA实现和性能测试
五种常见的排序算法实现 算法描述 1.插入排序 从第一个元素开始,该元素可以认为已经被排序 取出下一个元素,在已经排序的元素序列中从后向前扫描 如果该元素(已排序)大于新元素,将该元素移到下一位置 重 ...
- 常见排序算法JAVA实现
1.冒泡排序,时间复杂度:最好:T(n) = O(n) ,情况:T(n) = O(n2) ,平均:T(n) = O(n2) public int[] bubbleSort(int[] nums) { ...
- 常见排序算法 - Java实现
1.冒泡排序 每次比较相邻的两个元素大小,调整顺序.从头到尾执行一轮(i),最大数值的元素就排到最后.每次从头到尾执行一轮,都会排好一个元素(length - i - 1).这就是说一个包含 n 个元 ...
- 常见排序算法(附java代码)
常见排序算法与java实现 一.选择排序(SelectSort) 基本原理:对于给定的一组记录,经过第一轮比较后得到最小的记录,然后将该记录与第一个记录的位置进行交换:接着对不包括第一个记录以外的其他 ...
- Java常见排序算法之Shell排序
在学习算法的过程中,我们难免会接触很多和排序相关的算法.总而言之,对于任何编程人员来说,基本的排序算法是必须要掌握的. 从今天开始,我们将要进行基本的排序算法的讲解.Are you ready?Let ...
- 常见排序算法总结 -- java实现
常见排序算法总结 -- java实现 排序算法可以分为两大类: 非线性时间比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此称为非线性时间比较类排序. 线性时间 ...
- Java基础-数组常见排序方式
Java基础-数组常见排序方式 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 数据的排序一般都是生序排序,即元素从小到大排列.常见的有两种排序方式:选择排序和冒泡排序.选择排序的特 ...
- 几种常见排序算法之Java实现（插入排序、希尔排序、冒泡排序、快速排序、选择排序、归并排序）
排序(Sorting) 是计算机程序设计中的一种重要操作,它的功能是将一个数据元素(或记录)的任意序列,重新排列成一个关键字有序的序列. 稳定度(稳定性)一个排序算法是稳定的,就是当有两个相等记录的关 ...
- 数组其他部分及java常见排序
数据结构的基本概述: 数据结构是讲什么,其实大概就分为两点: 1.数据与数据之间的逻辑关系:集合.一对一.一对多.多对多 2.数据的存储结构: 一对一的:线性表:顺序表(比如:数组).链表.栈(先进后 ...
随机推荐
- 题解【CJOJ1070/UVA】嵌套矩形
P1070 - [Uva]嵌套矩形 Description 有 n 个矩形,每个矩形可以用两个整数 a, b 描述,表示它的长和宽.矩形 X(a, b) 可以嵌套在矩形 Y(c, d) 中当且仅当 a ...
- SpringMVC-时间类型转换
在上一篇SpringMVC的提交表单中,我们使用的日期为String型,可以将日期转换为Date型,然后使用initBinder函数进行显示,具体代码如下: (1)首先更改User.java的birt ...
- D. Easy Problem dp(有衔接关系的dp(类似于分类讨论) )
D. Easy Problem dp(有衔接关系的dp(类似于分类讨论) ) 题意 给出一个串 给出删除每一个字符的代价问使得串里面没有hard的子序列需要付出的最小代价(子序列不连续也行) 思路 要 ...
- pocketsphinx实现连续大词汇量语音识别
之前有个项目需求是要在客户内网实现一个连续大词汇语音识别功能,由于客户的内网是独立的,不能访问互联网,所以我只能到开源社区去找找碰碰运气了.后来在网上找到了cmusphinx(地址:http://cm ...
- 【做题笔记】CF1311A、B、C
或许以后会有D. A 题目大意:给定两个整数 \(a,b\) ,每次可以进行一下任意一个操作: \(a\) 加上任意一个正奇数 \(b\) 减去任意一个正偶数 问是否可以通过若干次操作把 \(a\) ...
- Bootstrap入门（1）简介
作者:赵盼盼 出处:https://www.cnblogs.com/zhaopanpan/ Bootstrap是Twitter开源的基于HTML.CSS.JavaScript的前端框架. 它是为实现快 ...
- ios 下 select和option 无法隐藏指定元素
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...
- AS常用快捷键
Alt+回车 导入包,自动修正 Ctrl+N 查找类 Ctrl+Shift+N 查找文件 Ctrl+Alt+L 格式化代码 Ctrl+Alt+O 优化导入的类和包 Alt+Insert 生成代码(如g ...
- VMware 搭建linux虚拟机环境
1.任务管理器-服务 确认VMware服务是否启动 2.VMware生成网关地址 编辑--虚拟网络编辑器 VMnet8 NAT设置子网IP,子网掩码,网关 3.windows网络--更改适配器设置-- ...
- Nexus坑人系列-license格式问题
这种情况一般出现在RMA或者新设备使用的时候.这些时候一般需要安装license,在安装完license的时候,例如我们去配置一些三层特性,例如feature eigrp等,可能会出现设备拒绝了你的命 ...