常见排序的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.数据的存储结构: 一对一的:线性表:顺序表(比如:数组).链表.栈(先进后 ...
随机推荐
- wamp选择语言
桌面右下角 右击绿色小图标 点击language选择chinese
- 用户 'sa' 登录失败。该用户与可信 SQL Server 连接无关联'。错误代码：18452 解决办法
原文:https://blog.csdn.net/wuxianwei/article/details/6330270 SQLSERVER 2005采用'SQLSERVER身份验证'去登录, 出错的原因 ...
- AC3 channel coupling
1.overview 如果使用channel coupling, encoder端计算所有channel的transform coefficients的平均值,将平均值压缩到coupling chan ...
- 【Python】【爬虫】爬取酷狗TOP500
好啦好啦,那我们来拉开我们的爬虫之旅吧~~~ 这一只小爬虫是爬取酷狗TOP500的,使用的爬取手法简单粗暴,目的是帮大家初步窥探爬虫长啥样,后期会慢慢变得健壮起来的. 环境配置 在此之前需要下载一个谷 ...
- C语言随笔4：指针数组、数组指针
数组: 1:数组名为地址,表达方法: Int A[10]; A;//数组名表示首地址 &A;//数组名加取地址符,仍然表示首地址 &A[0];//第0个元素的地址,即首地址 数组名是指 ...
- 断点调试，issubclass和ininstance的使用
一等公民 只要可以把一个东西赋值给一个变量,这个东西就叫一等公民 断点调试 在想要加断点的地方用鼠标点击一下,你会看到一个红色圆圈 变红的地方,程序执行到,就会暂停 断电应该加载报错之前 绿色箭头表示 ...
- 关于mybatis中多参数传值
如果前台单独传递多个参数,并且未进行封装,在mybatis的sql映射文件中需要以下标的形式表示传递的参数,从0开始 即:where name=#{0} and password =#{1}:0表示第 ...
- dbGet net trace instant pin
proc rn { net_name } {puts " "puts "Net name : $net_name : "set name_rule [dbget ...
- pysftp-tools
import pysftp import paramiko import os import unittest import json import warnings warnings.filterw ...
- 公告 & 留言板 & 随想录
欢迎dalao在评论区留言 \(Q \omega Q\) 公告部分: 博客文章的更新一般被放在周末 当然还是可能会咕 自从改了博客的主题之后,文章中的引用好像都会显示出一堆乱码. 由于之前写过的博文不 ...