java 全排序_Java排序算法全
Java排序算法代码
零、 排序基类
package com.yunche.sort;
/**
* @ClassName: BaseSort
* @Description:
* @author: yunche
* @date: 2018/12/12
*/
public class BaseSort {
public static boolean less(Comparable a, Comparable b) {
return a.compareTo(b) < 0;
}
public static void swap(Comparable[] a, int i, int j) {
Comparable temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
一、 选择排序
package com.yunche.sort;
import java.util.Arrays;
/**
* @ClassName: Selection
* @Description:
* @author: yunche
* @date: 2018/12/12
*/
public class Selection extends BaseSort {
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;
}
}
swap(a, i, min);
}
}
public static void main(String[] args) {
Comparable[] a = {1, 4, 6, 5, 2, 3, 9, 8, 7, 0};
sort(a);
System.out.println(Arrays.toString(a));
}
}
二、 插入排序
package com.yunche.sort;
import java.util.Arrays;
/**
* @ClassName: Insertion
* @Description:
* @author: yunche
* @date: 2018/12/12
*/
public class Insertion extends BaseSort {
public static void sort(Comparable[] a) {
int N = a.length;
for (int i = 0; i < N - 1; i++) {
for (int j = i + 1; j > 0 && less(a[j], a[j - 1]); j--) {
swap(a, j, j - 1);
}
}
}
public static void main(String[] args) {
Comparable[] a = {'S', 'O', 'R', 'T', 'E', 'X', 'A', 'M', 'P', 'L', 'E'};
sort(a);
System.out.println(Arrays.toString(a));
}
}
三、 希尔排序
package com.yunche.sort;
import java.util.Arrays;
/**
* @ClassName: Shell
* @Description:
* @author: yunche
* @date: 2018/12/12
*/
public class Shell extends BaseSort {
public static void sort(Comparable[] a) {
int N = a.length;
int h = 1;
while (h < N / 3) {
// h 1 4 12
h = 3 * h + 1;
}
while (h >= 1) {
for (int i = 0; i < N - h; i++) {
for (int j = i + h; j >= h && less(a[j], a[j - h]); j -= h) {
swap(a, j, j - h);
}
}
h /= 3;
}
}
public static void main(String[] args) {
Comparable[] cs = {'S', 'H', 'E', 'L', 'L', 'S', 'O', 'R', 'T', 'E', 'X', 'A', 'M', 'P', 'L', 'E'};
sort(cs);
System.out.println(Arrays.toString(cs));
}
}
四、 归并排序
1、 自顶向下
package com.yunche.sort;
import java.util.Arrays;
/**
* @ClassName: Up2DownMerge
* @Description:自顶向下
* @author: yunche
* @date: 2018/12/12
*/
public class Up2DownMerge extends BaseSort {
private static Comparable[] aux;
public static void sort(Comparable[] a) {
aux = new Comparable[a.length];
sort(a, 0, a.length - 1);
}
private static void sort(Comparable[] a, int lo, int hi) {
//递归边界
if (hi <= lo) {
return;
}
//优化：当hi - lo 小于一定值，可以使用插入排序来提高性能
int mid = (lo + hi) >> 1;
sort(a, lo, mid);
sort(a, mid + 1, hi);
//优化：if (a[mid] <= a[mid + 1]) return;对于有序数组来说算法变成了 O(n),对于乱序的话 比较本身也会耗费时间，
merge(a, lo, mid, hi);
}
private static void merge(Comparable[] a, int lo, int mid, int hi) {
int le = lo;
int ri = mid + 1;
for (int k = lo; k <= hi; k++) {
if (le > mid) {
aux[k] = a[ri++];
} else if (ri > hi) {
aux[k] = a[le++];
} else {
if (less(a[ri], a[le])) {
aux[k] = a[ri++];
} else {
aux[k] = a[le++];
}
}
}
//复制到原数组
for (int k = lo; k <= hi; k++) {
a[k] = aux[k];
}
}
public static void main(String[] args) {
Comparable[] cs = {'M', 'E', 'R', 'G', 'E', 'S', 'O', 'R', 'T', 'E', 'X', 'A', 'M', 'P', 'L', 'E'};
sort(cs);
System.out.println(Arrays.toString(cs));
}
}
2、 自底向上
package com.yunche.sort;
import java.util.Arrays;
/**
* @ClassName: Down2UpMerge
* @Description:
* @author: yunche
* @date: 2018/12/12
*/
public class Down2UpMerge extends BaseSort {
private static Comparable[] aux;
public static void sort(Comparable[] a) {
int N = a.length;
aux = new Comparable[N];
for (int sz = 1; sz < N; sz += sz) {
for (int lo = 0; lo < N - sz; lo += sz + sz) {
merge(a, lo, lo + sz - 1, Math.min(lo + sz + sz - 1, N - 1));
}
}
}
private static void merge(Comparable[] a, int lo, int mid, int hi) {
int le = lo;
int ri = mid + 1;
for (int k = lo; k <= hi; k++) {
if (le > mid) {
aux[k] = a[ri++];
} else if (ri > hi) {
aux[k] = a[le++];
} else {
if (less(a[ri], a[le])) {
aux[k] = a[ri++];
} else {
aux[k] = a[le++];
}
}
}
//复制到原数组
for (int k = lo; k <= hi; k++) {
a[k] = aux[k];
}
}
public static void main(String[] args) {
Comparable[] cs = {'M', 'E', 'R', 'G', 'E', 'S', 'O', 'R', 'T', 'E', 'X', 'A', 'M', 'P', 'L', 'E'};
sort(cs);
System.out.println(Arrays.toString(cs));
}
}
五、 快速排序
1、 基本版
package com.yunche.sort;
import java.util.Arrays;
/**
* @ClassName: Quick
* @Description: 快速排序基本版
* 缺点：含有大量重复元素时，时间复杂度近乎退化为O(N?)
* @author: yunche
* @date: 2018/12/15
*/
public class Quick extends BaseSort {
public static void sort(Comparable[] a) {
sort(a, 0, a.length - 1);
}
private static void sort(Comparable[] a, int lo, int hi) {
if (hi <= lo) {
return;
}
int p = partition(a, lo, hi);
sort(a, lo, p - 1);
sort(a, p + 1, hi);
}
private static int partition(Comparable[] a, int lo, int hi) {
//优化：随机化标定点，避免当数组近乎有序时，快速排序退化成O(N?)
swap(a, (int) (Math.random() * (hi - lo + 1) + lo), lo);
//切分时使得a[lo+1..j] < v; a[j+1..i-1] > v;
//指定j，i初始值使得上面两个集合初始化为空
// i为当前元素, j为当前小于v的最后一个元素
int j = lo;
Comparable v = a[lo];
for (int i = lo + 1; i <= hi; i++) {
if (less(a[i], v)) {
swap(a, i, ++j);
}
}
swap(a, lo, j);
return j;
}
public static void main(String[] args) {
Comparable[] cs = {1, 4, 5, 5, 9, 4, 7, 6, 0, 3, 2, 8};
sort(cs);
System.out.println(Arrays.toString(cs));
}
}
2、 双路切分版
package com.yunche.sort;
import java.util.Arrays;
/**
* @ClassName: Quick2Ways
* @Description: 快速排序双路切分(将整个数组，切分成小于v，和大于v两部分，再分别递归)
* @author: yunche
* @date: 2018/12/13
*/
public class Quick2Ways extends BaseSort {
public static void sort(Comparable[] a) {
sort(a, 0, a.length - 1);
}
private static void sort(Comparable[] a, int lo, int hi) {
//递归边界
if (hi <= lo) {
return;
}
int p = partition(a, lo, hi);
sort(a, lo, p - 1);
sort(a, p + 1, hi);
}
private static int partition(Comparable[] a, int lo, int hi) {
//优化：随机化标定点，避免当数组近乎有序时，快速排序退化成O(N?)
swap(a, (int) (Math.random() * (hi - lo + 1) + lo), lo);
//定义变量i，使得a[lo+1...i-1] < v
//定义变量j，使得a[j...hi] > v
int i = lo, j = hi + 1;
Comparable v = a[lo];
while (true) {
while (less(a[++i], v) && i != hi) {
}
while (less(v, a[--j]) && j != lo) {
}
if (i >= j) {
break;
}
swap(a, i, j);
}
swap(a, lo, j);
return j;
}
public static void main(String[] args) {
Comparable[] cs = {1, 0, 4, 5, 5, 9, 4, 7, 6, 3, 2, 1, 8};
sort(cs);
System.out.println(Arrays.toString(cs));
}
}
3、 三路切分版
package com.yunche.sort;
import java.util.Arrays;
/**
* @ClassName: Quick3Ways
* @Description: 快速排序三路切分(将整个数组 ， 切分成小于v ， 等于v和大于v三部分 ， 再分别递归)
* @author: yunche
* @date: 2018/12/16
*/
public class Quick3Ways extends BaseSort {
public static void sort(Comparable[] a) {
sort(a, 0, a.length - 1);
}
private static void sort(Comparable[] a, int lo, int hi) {
//递归边界
if (hi <= lo) {
return;
}
//优化：随机化标定点，避免当数组近乎有序时，快速排序退化成O(N?)
swap(a, (int) (Math.random() * (hi - lo + 1) + lo), lo);
//定义变量lt使得a[lo+1...lt] < v
//定义变量gt使得a[gt...hi] > v
int lt = lo, gt = hi + 1;
//定义变量i指向当前元素
int i = lo + 1;
Comparable v = a[lo];
while (i < gt) {
if (less(a[i], v)) {
swap(a, i, lt + 1);
lt++;
i++;
} else if (less(v, a[i])) {
swap(a, i, --gt);
} else {
i++;
}
}
swap(a, lo, lt);
sort(a, lo, lt - 1);
sort(a, gt, hi);
}
public static void main(String[] args) {
Comparable[] cs = {1, 0, 4, 5, 5, 9, 4, 7, 6, 3, 2, 1, 8};
sort(cs);
System.out.println(Arrays.toString(cs));
}
}
六、 堆排序
1、 shiftUp
2、 shiftDown
3、 heaplify
4、 MaxHeap
package com.yunche.datastructure;
/**
* @ClassName: MaxHeap
* @Description: 利用数组实现最大堆(完全二叉树)：任意节点的值不大于父节点
* @author: yunche
* @date: 2018/12/17
*/
public class MaxHeap {
/**
* 存储堆中元素
*/
private T[] data;
/**
* 堆中元素的个数
*/
private int count;
/**
* 堆中最大容量
*/
private int capacity;
/**
* 构造一个空堆，最多容纳capacity个元素
*
* @param capacity
*/
public MaxHeap(int capacity) {
this.capacity = capacity;
count = 0;
//数组从索引为1的位置开始存储元素
data = (T[]) new Comparable[capacity + 1];
}
/**
* 根据已有数组构建最大堆
* 时间复杂度为O(n)
*
* @param arr
*/
public MaxHeap(T[] arr) {
capacity = arr.length;
count = arr.length;
data = (T[]) new Comparable[capacity + 1];
for (int i = 1; i <= count; i++) {
data[i] = arr[i - 1];
}
int k = count >> 1;
while (k >= 1) {
shiftDown(k);
k--;
}
}
/**
* 返回堆中元素个数
*
* @return
*/
public int size() {
return count;
}
/**
* 返回堆中是否为空
*
* @return
*/
public boolean isEmpty() {
return count == 0;
}
/**
* 向最大堆中插入一个元素item
*
* @param item
*/
public void insert(T item) {
if (count == capacity) {
capacity = capacity << 1;
T[] tem = (T[]) new Comparable[capacity + 1];
for (int i = 1; i <= count; i++) {
tem[i] = data[i];
}
data = tem;
}
data[++count] = item;
shiftUp(count);
}
/**
* 从堆中取出最大元素，即堆顶元素
*
* @return 返回最大元素
*/
public T extractMax() {
if (count == 0) {
return null;
}
T ret = data[1];
data[1] = null;
swap(1, count--);
shiftDown(1);
return ret;
}
/**
* 将数组中索引为k的节点向上移动，直到符合最大堆的定义
*
* @param k 索引
*/
private void shiftUp(int k) {
while (k > 1 && less(data[k >> 1], data[k])) {
swap(k >> 1, k);
k >>= 1;
}
}
/**
* 将数组中索引为k的节点向下移动，直到符合最大堆的定义
*
* @param k
*/
private void shiftDown(int k) {
//边界：确保至少有一个孩子
while( 2*k <= count ){
// 在此轮循环中,data[k]和data[j]交换位置
int j = 2*k;
if(j+1 <= count && less(data[2 *k ], data[2 *k +1])) {
j ++;
}
// data[j] 是 data[2*k]和data[2*k+1]中的最大值
if(!less(data[k], data[j]) ) {
break;
}
swap(k, j);
k = j;
}
}
/**
* 交换堆中索引为i和j的两个元素
*
* @param i
* @param j
*/
private void swap(int i, int j) {
T t = data[i];
data[i] = data[j];
data[j] = t;
}
private boolean less(T t1, T t2) {
return t1.compareTo(t2) < 0;
}
/**
* 测试方法
*
* @param args
*/
public static void main(String[] args) {
MaxHeap maxHeap = new MaxHeap(10);
Integer[] a = {34, 12, 23, 90, 87, 16, 15 ,17, 32, 43};
/*****************测试shiftdown开始*********/
for (int i =0; i < a.length; i++) {
maxHeap.insert(a[i]);
}
// 取出来的顺序应该是按照从大到小的顺序取出来的
while (!maxHeap.isEmpty()) {
System.out.print(maxHeap.extractMax() + " ");
}
System.out.println();
/*****************测试shiftdown结束*********/
/**********测试heaplify开始*************/
MaxHeap heap2 = new MaxHeap(a);
// 取出来的顺序应该是按照从大到小的顺序取出来的
while (!heap2.isEmpty()) {
System.out.print(heap2.extractMax() + " ");
}
System.out.println();
/**********测试heaplify结束*************/
}
}
5、 原地堆排序
package com.yunche.sort;
import java.util.Arrays;
/**
* @ClassName: HeapSort
* @Description: 原地堆排序(堆中索引从0开始)--利用数组本身进行最大堆化，然后再将最大的元素放置
* 数组末尾，再将剩余的数组元素进行shiftdown操作维持最大堆，再继续取出最大的元素，
* 如此反复，直到最大堆中只剩下一个最小的元素
* @author: yunche
* @date: 2018/12/25
*/
public class HeapSort extends BaseSort {
private static void shiftDown(Comparable[] arr, int k, int count) {
//边界：确保至少有一个孩子
while (2 * k + 1 < count) {
// 在此轮循环中,arr[k]和 arr[j]交换位置
int j = 2 * k + 1;
if (j + 1 < count && less(arr[2 * k + 1], arr[2 * k + 2])) {
j++;
}
// arr[j] 是 arr[2*k + 1]和 arr[2*k+2]中的最大值
if (!less(arr[k], arr[j])) {
break;
}
swap(arr, k, j);
k = j;
}
}
public static void sort(Comparable[] arr) {
//heaplify
for (int i = (arr.length - 1 - 1) / 2; i >= 0; i--) {
shiftDown(arr, i, arr.length);
}
for (int i = arr.length - 1; i > 0; i--) {
swap(arr, 0, i);
shiftDown(arr, 0, i);
}
}
public static void main(String[] args) {
Integer[] a = {1, 7 ,32, 98, 23, 12, 87, 23, 63, 90, 52, 12, 34, 28};
sort(a);
System.out.println(Arrays.toString(a));
}
}
七、 总结
-
平均时间复杂度
原地排序
额外空间
稳定排序
插入排序
O(n^2)
√
O(1)
√
归并排序
O(nlogn)
×
O(n)
√
快速排序
O(nlogn)
√
O(logn)
×
堆排序
O(nlogn)
√
O(1)
×
八、 源代码下载(github)
java 全排序_Java排序算法全相关推荐
- java的排序_java排序
Bubble sort 冒泡排序 一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经 ...
- java基础排序_Java排序算法-Java入门|Java基础课程
1. 课程目标排序是任何语言都会使用到的功能之一,然成果排序的算法有很多,对空间的要求及其时间效率也不尽相同. 本文章以Java语言示例,通过对空间要求.时间效率要求,来对比各种排序算法的使用场景 2 ...
- java 比较算法_JAVA排序算法实现和比较：冒泡，桶，选择，快排，归并
一.冒泡排序: 实现思想: 重复地走访过要排序的元素列,一次比较两个相邻的元素,如果他们的顺序(如从大到小.首字母从A到Z)错误就把他们交换过来.走访元素的工作是重复地进行直到没有相邻元素需要交换,也 ...
- java 全角_java 全角半角字符转换的方法实例
这篇文章主要介绍了java 全角半角字符转换的方法,大家参考使用吧 如果搞明白了Java中全角字符和半角字符之间的关系 那他们之间的转换根本就不是个事. 可以通过下面的程序看看Java中所有字符以及对 ...
- java堆排序工具包_JAVA 排序工具类
提供了以下排序:冒泡排序 选择排序 插入排序 希尔排序 快速排序 归并排序 桶排序 堆排序 package com.xingej.algorithm.sort;import java.util.Arr ...
- java 正序排序_java排序之冒泡排序
性能优化冒泡排序 1.举个例子:int[] array = {2,4,9,7,6,5}; 第一轮2和4进行比较,2<4,位置不变.再4和9进行比较,4<9,位置不变.再9和7进行比较,9& ...
- java sort方法_Java排序方法sort用法详解
本文实例为大家分享了java对数组.集合的排序方法,供大家参考,具体内容如下 对数组的排序: //对数组排序 public void arraySort(){ int[] arr = {1,4,6,3 ...
- java 英文单词排序_java 排序单词
package mypackage; public class Test { public static void main(String[] args) { WindowDocument win=n ...
- java sort 插入排序_Java排序之InsertionSort插入排序的实例
插入排序 の implementation 插入排序就像打赌的时候,比如双扣.抽牌的时候,一次拿一张牌,这张牌和之前的牌一张张比较.选择把这张牌插入什么位置,排好顺序的位置后打牌更顺.要不然得一个一个 ...
最新文章
- 不要再封装各种Util工具类了，这个神级框架值得拥有！
- python 下载大文件
- nodejs 实现文件拷贝
- 刚刚，“国民”APP微信崩了！官方致歉：已经逐步恢复
- POJ 1830.开关问题（高斯消元）
- Qt与HTML/JavaScript网页端通信和调用
- python 替换array中的值_Python实现计数排序
- openstack学习之路-python运维（user）
- 软件测试的错误优先级,软件测试典型错误
- 模拟器游戏修改之教你如何修改gba rom里的程序!
- 木质机器人挂坠_设计癖 2014 大盘点：十大木质产品
- 火狐浏览器不弹出窗口_Firefox选项卡的Vista样式弹出窗口预览
- python绘制正态分布图像
- linux上mysql定时备份数据库数据_linux下如何实现mysql数据库每天自动备份定时备份...
- 呼叫中心客服人员的秘密生活：同理心永远不会让你遭殃
- t20171215a1BILL的账单
- html5图片并列排版,小编，图片与文字并排怎么排版呢？
- Flume部署安装详细图文步骤(单节点)
- #第一章 从数学拟合的角度看股市理论的预测环节－－一、恼人的数学题
- Hadoop面试题汇总-20221031
热门文章
- SpringCloud系列-Feign的基本应用
- easyui中checkbox全选全不选的时不处理最后一行的实现
- 你需要知道的基础算法知识——STL和基础数据结构（五）
- MIPS汇编实现冒泡排序法
- maven：Exception in thread main java.lang.UnsupportedClassVersionError: org/apache/maven/cli/MavenC
- java web怎么快速设计网页_Javaweb毕业设计快速开发指南（一）
- 计算机软件和理论学什么,武汉大学计算机软件与理论考研科目有哪些？
- 设计模式之-简单工厂模式
- JS原生父子页面操作
- Java操作Mongodb 保存/读取java对象到/从mongodb