/**
*
* @author yuzhiping
* @version 1.0
* 功能说明:计算机领域经典的算法
*
*/
public class sortAlgorithm<T extends Comparable<T>> { //交换索引i和索引j的值
private void swap(T [] data ,int i,int j){
T tmp;
tmp=data[i];
data[i]=data[j];
data[j]=tmp;
} //-----堆排序 时间复杂度O(nlogn)----- public void heapSort(T [] data){
int arrayLength=data.length;
//循环件堆
for(int i=0;i<arrayLength-1;i++){
// 建堆
builMaxdHeap(data, arrayLength - 1 - i);
// 交换堆顶和最后一个元素
swap(data, 0, arrayLength - 1 - i); }
} // 对data数组从0到lastIndex建大顶堆
private void builMaxdHeap(T[] data, int lastIndex) {
// 从lastIndex处节点(最后一个节点)的父节点开始
for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
// k保存当前正在判断的节点
int k = i;
// 如果当前k节点的子节点存在
while (k * 2 + 1 <= lastIndex) {
// k节点的左子节点的索引
int biggerIndex = 2 * k + 1;
// 如果biggerIndex小于lastIndex,即biggerIndex + 1
// 代表的k节点的右子节点存在
if (biggerIndex < lastIndex) {
// 如果右子节点的值较大
if (data[biggerIndex].compareTo(data[biggerIndex + 1]) < 0) {
// biggerIndex总是记录较大子节点的索引
biggerIndex++;
}
}
// 如果k节点的值小于其较大子节点的值
if (data[k].compareTo(data[biggerIndex]) < 0) {
// 交换它们
swap(data, k, biggerIndex);
// 将biggerIndex赋给k,开始while循环的下一次循环,
// 重新保证k节点的值大于其左、右子节点的值。
k = biggerIndex;
} else {
break;
}
}
}
} //-----冒泡排序法 时间复杂度O(n^2)-----
public void bubbleSort(T[] data){
int i,j;
for(i=0;i<data.length-1;i++){
for(j=0;j<data.length-i-1;j++){
if(data[j].compareTo(data[j+1]) > 0){
swap(data,j+1,j);
}
}
}
} //-----选择排序法 时间复杂度O(n^2)-----
public void selectSort(T[] data){
int i,j; for(i=0;i<data.length-1;i++){
for(j=i+1;j<data.length;j++){
if (data[i].compareTo(data[j]) > 0){
swap(data,i,j);
}
}
}
} //-----快速排序法 时间复杂度为O(log2n)-----
public void quickSort(T[] data){
subQuickSort(data,0,data.length-1);
} private void subQuickSort(T[] data,int start,int end){
if( start < end ){
//以第一个元素作为分界值
T base = data[start];
//i从左边开始搜索大于分界值元素的索引
int i = start;
//j从右边开始搜索小于分界值元素的索引
int j = end + 1;
while(true){
//左边跳过比base小的元素
while(i < end && data[++i].compareTo(base) <= 0);
//右边跳过比base大的元素
while(j > start && data[--j].compareTo(base) >= 0); if(j > i){
swap(data,i,j);
}else{
break;
}
}
//将分界值还原
swap(data,start,j); //递归左边序列
subQuickSort(data,start,j-1);
//递归右边序列
subQuickSort(data,j+1,end);
}
} //-----插入排序法 时间复杂度O(n^2)-----
public void insertSort(T[] data){
int arrayLength = data.length; for(int i=1;i<arrayLength;i++){
//当整体后移时保证data[i]的值不会丢失
T tmp = data[i];
//i索引处的值已经比前面所有值都大,表明已经有序,无需插入
//i-1处索引之前的数值已经有序,i-1处索引处元素的值也是最大值
if(data[i].compareTo(data[i-1]) < 0){
int j = i-1;
//整体后移一个
while(j>=0 && data[j].compareTo(tmp) > 0){
data[j+1] = data[j];
j--;
}
data[j+1] = tmp;
}
}
} //-----折半插入排序法 时间复杂度-----
public void binaryInsertSort(T[] data) {
int arrayLength = data.length; for (int i = 1; i < arrayLength; i++) {
if (data[i - 1].compareTo(data[i]) > 0) {
// 缓存i处的元素值
T tmp = data[i]; // 记录搜索范围的左边界
int low = 0;
// 记录搜索范围的右边界
int high = i - 1; while (high >= low) {
// 记录中间位置
int mid = (high + low) / 2;
// 比较中间位置数据和i处数据大小,以缩小搜索范围 if (tmp.compareTo(data[mid]) > 0) {
low = mid + 1;
} else {
high = mid - 1;
}
}
// 将low~i处数据整体向后移动1位
for (int j = i; j > low; j--) {
data[j] = data[j - 1];
}
data[low] = tmp; }
}
} //-----希尔排序法 时间复杂度O(nlogn)O(n^2)具体看h的值-----
public void shellSort(T[] data){
int arrayLength = data.length;
//h保存可变增量 int h = 1;
while(h<=arrayLength/3){
h = h * 3 + 1;
} while(h > 0){
//System.out.println(Arrays.toString( data )+"h="+h); for(int i=h;i<arrayLength;i++){
//当整体后移时,保证data[i]的值不丢失
T tmp = data[i];
//i索引处的值已经比前面所有的值大
//(i-1索引之前的值已经有序的,i-1索引处元素的值就是最大值)
if(data[i].compareTo(data[i-h]) < 0){
int j = i-h;
//整体后移一格
while(j>=0 && data[j].compareTo(tmp) > 0){
data[j+h] = data[j];
j-=h;
} //最后将tmp值插入合适的位置
data[j+h] = tmp;
}
}
h = (h-1)/3;
} } //-----归并排序法 时间复杂度为O(nlog2n)-----
public void mergeSort(T[] data){
subMergeSort(data,0,data.length-1);
} private void subMergeSort(T[] data,int left,int right){
if(right > left){
//找出中间索引
//System.out.println( Arrays.toString(data) );
int center = (left + right)/2;
//对左边数组进行递归
subMergeSort(data,left,center);
//对右边数组进行递归
subMergeSort(data,center+1,right);
//合并
merge(data,left,center,right);
}
} @SuppressWarnings("unchecked")
private void merge(T[] data, int left, int center, int right) {
Object[] tmpArr = new Object[data.length];
int mid = center + 1;
// third记录中间处索引
int third = left;
int tmp = left; while (left <= center && mid <= right) {
// 从两个数组中取出最小的放入中间数组
if (data[left].compareTo(data[mid]) <= 0) {
tmpArr[third++] = data[left++];
} else {
tmpArr[third++] = data[mid++];
}
} // 剩余部分依次放入中间数组
while (mid <= right) {
tmpArr[third++] = data[mid++];
}
while (left <= center) {
tmpArr[third++] = data[left++];
} // 将中间数组的内容复制拷回原数组
// (原left~right范围内德内容被复制回原数组)
while (tmp <= right) {
data[tmp] = (T) tmpArr[tmp++];
}
} public static void main(String[] args) {
// TODO Auto-generated method stub } }

经典的排序算法java实现版的更多相关文章

  1. 排序算法 Java实现版

    8种排序之间的关系: 1. 直接插入排序 (1)基本思想: 在要排序的一组数中,假设前面(n-1)[n>=2] 个数已经是排好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数也是排好顺序 ...

  2. 常见排序算法(JS版)

    常见排序算法(JS版)包括: 内置排序,冒泡排序,选择排序,插入排序,希尔排序,快速排序(递归 & 堆栈),归并排序,堆排序,以及分析每种排序算法的执行时间. index.html <! ...

  3. 十大经典排序算法总结——JavaScrip版

    首先,对于评述算法优劣术语的说明: 稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面:即排序后2个相等键值的顺序和排序之前它们的顺序相同 不稳定:如果a原本在b的前面,而a=b,排序之后a ...

  4. 十大经典排序算法的JS版

    前言 个人博客:Damonare的个人博客 如遇到问题或有更好的优化方法,可以: 提issue给我 或是pull requests 我都会看到并处理,欢迎Star. 这世界上总存在着那么一些看似相似但 ...

  5. 排序算法Java版,以及各自的复杂度,以及由堆排序产生的top K问题

    常用的排序算法包括: 冒泡排序:每次在无序队列里将相邻两个数依次进行比较,将小数调换到前面, 逐次比较,直至将最大的数移到最后.最将剩下的N-1个数继续比较,将次大数移至倒数第二.依此规律,直至比较结 ...

  6. [转]Java学习---7大经典的排序算法总结实现

    [原文]https://www.toutiao.com/i6591634652274885128/ 常见排序算法总结与实现 本文使用Java实现这几种排序. 以下是对排序算法总体的介绍. 冒泡排序 比 ...

  7. Java 实现的各种经典的排序算法小Demo

    由于有上机作业,所以就对数据结构中常用的各种排序算法都写了个Demo,有如下几个: 直接插入排序 折半插入排序 希尔排序 冒泡排序 快速排序 选择排序 桶排序 Demo下载地址 下面谈一谈我对这几个排 ...

  8. 八大排序算法Java实现

    本文对常见的排序算法进行了总结. 常见排序算法如下: 直接插入排序 希尔排序 简单选择排序 堆排序 冒泡排序 快速排序 归并排序 基数排序 它们都属于内部排序,也就是只考虑数据量较小仅需要使用内存的排 ...

  9. 排序算法(Java实现)

    这几天一直在看严蔚敏老师的那本<数据结构>那本书.之前第一次学懵懵逼逼,当再次看的时候,发觉写的是非常详细,非常的好. 那就把相关的排序算法用我熟悉的Java语言记录下来了.以下排序算法是 ...

随机推荐

  1. Android JSON

    转自:http://www.open-open.com/lib/view/open1326376799874.html JSON的定义: 一 种轻量级的数据交换格式,具有良好的可读和便于快速编写的特性 ...

  2. hybird app(混合式app开发)cordova ionic 创建相应平台的app

    hybird app(混合式app开发) 之ionic 框架平台 guide cordova 创建相应平台的app 1. npm install -g cordova //全局安装cordova-cl ...

  3. snmp 默认团体名检测利用

    [root@izj6c2n1nth4tg8emd8h58z tmp]# lsb_release LSB Version:    :core-4.1-amd64:core-4.1-noarch[root ...

  4. 文件夹操作-DirectoryInfo类

    DirectoryInfo类是一个密封类,它可以用来创建.移动.枚举目录和子目录.DirectoryInfo类包括4个属性,可以用来获取目录的名称.父目录等. DirectoryInfo类的属性表 属 ...

  5. hdu 2112(字典树+最短路)

    HDU Today Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total ...

  6. react 如何处理页面加载时无法将获取缓存信息存入全局变量中

    最近在做一个权限功能时,发现在读取用户公司ID进行列表查询 时,无法钭读取到缓存中的数据存入页面全局变量中进行加载查询 将问题代码整理出来 将信息存入缓存: let menuList = Helper ...

  7. 新疆大学ACM-ICPC程序设计竞赛五月月赛(同步赛)F 猴子排序的期望【Java/高精度/组合数学+概率论】

    链接:https://www.nowcoder.com/acm/contest/116/F 来源:牛客网 题目描述 我们知道有一种神奇的排序方法叫做猴子排序,就是把待排序的数字写在卡片上,然后让猴子把 ...

  8. HDU 6113 度度熊的01世界【DFS/Flood Fill】

    度度熊的01世界 Accepts: 967 Submissions: 3064 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 32768/3 ...

  9. Codeforces Beta Round #91 (Div. 2 Only) A. Lucky Division【暴力/判断是不是幸运数字4,7的倍数】

    A. Lucky Division time limit per test 2 seconds memory limit per test 256 megabytes input standard i ...

  10. sqlite3特殊的字符转义

    sqlite3数据库在搜索的时候,一些特殊的字符需要进行转义, 具体的转义如下:      /   ->    //     '   ->    ''     [   ->    / ...