这里总结下各种排序算法的java实现

冒泡排序

public class BubbleSort {

publicstaticint[] bubbleSort(int[] array) {
if(array == null) {
returnnull;
} for(inti = 0; i < array.length; i++) {
for(intj = i + 1; j < array.length; j++) {
if(array[i] > array[j]) {
array[i] = array[i] + array[j];
array[j] = array[i] - array[j];
array[i] = array[i] - array[j];
}
}
} returnarray;
}

}

插入排序

public class InsertSort {

publicstaticint[] insertSort(int[] array) {
if(array == null) {
returnnull;
} for(inti = 1; i < array.length; i++) {
for(intj = i; (j > 0) && (array[j] < array[j - 1]); j--) {
SortUtils.swap(array, j, j - 1);
}
} returnarray;
}

}

选择排序

public class SelectionSort {

publicstaticint[] selectionSort(int[] array) {
if(array == null) {
returnnull;
} for(inti = 0; i < array.length; i++) {
intlowIndex = i;
for(intj = array.length - 1; j > i; j--) {
if(array[j] < array[lowIndex]) {
lowIndex = j;
}
} SortUtils.swap(array, i, lowIndex);
} returnarray;
}

}

?

Shell排序

public class ShellSort {

publicstaticint[] shellSort(int[] array) {
if(array == null) {
returnnull;
} for(inti = array.length / 2; i > 2; i /= 2) {
for(intj = 0; j < i; j++) {
insertSort(array, j, i);
}
} insertSort(array,0,1); returnarray;
} privatestaticvoidinsertSort(int[] array, intstart,intinc) {
for(inti = start + inc; i < array.length; i += inc) {
for(intj = i; (j >= inc) && (array[j] < array[j - inc]); j -= inc) {
SortUtils.swap(array, j, j - inc);
}
}
}

}

?

快速排序

public class QKSort {

publicstaticint[] quickSort(int[] array) {
if(array != null) {
returnquickSort(array,0, array.length - 1);
} returnnull;
} privatestaticint[] quickSort(int[] array, intbeg,intend) {
if(beg >= end || array == null) {
returnnull;
} intp = partition(array, beg, end);
quickSort(array, beg, p - 1);
quickSort(array, p + 1, end); returnarray;
} /**
* 找到分界点
* @param array
* @param beg
* @param end
* @return
*/
privatestaticintpartition(int[] array, intbeg,intend) {
intlast = array[end];
inti = beg - 1; for(intj = beg; j <= end - 1; j++) {
if(array[j] <= last) {
i++;
if(i != j) {
array[i] = array[i] ^ array[j];
array[j] = array[i] ^ array[j];
array[i] = array[i] ^ array[j];
}
}
} if((i + 1) != end) {
array[i + 1] = array[i + 1] ^ array[end];
array[end] = array[i + 1] ^ array[end];
array[i + 1] = array[i + 1] ^ array[end];
} returni + 1;
}

}

堆排序

public class HeapSort {

publicstaticint[] heapSort(int[] array) {
if(array == null) {
returnnull;
}
MaxHeap h = newMaxHeap();
h.init(array); for(inti = 0; i < array.length; i++) {
h.remove();
} System.arraycopy(h.queue,1, array, 0, array.length); returnarray;
} privatestaticclassMaxHeap { voidinit(int[] data) {
this.queue = newint[data.length + 1];
for(inti = 0; i < data.length; i++) {
queue[++size] = data[i];
fixUp(size);
}
} privateintsize = 0; privateint[] queue; publicintget() {
returnqueue[1];
} publicvoidremove() {
SortUtils.swap(queue,1, size--);
fixDown(1);
} // fixdown
privatevoidfixDown(intk) {
intj;
while((j = k << 1) <= size) {
if(j < size && queue[j] < queue[j + 1]) {
j++;
} // 不用交换
if(queue[k] > queue[j]) {
break;
} SortUtils.swap(queue, j, k);
k = j;
}
} privatevoidfixUp(intk) {
while(k > 1) {
intj = k >> 1;
if(queue[j] > queue[k]) {
break;
} SortUtils.swap(queue, j, k);
k = j;
}
} }

}

归并排序

public class MergeSort {

publicstaticint[] mergeSort(int[] array) {
if(array == null) {
returnnull;
} int[] temp = newint[array.length];
returnmergeSort(array, temp, 0, array.length - 1);
} privatestaticint[] mergeSort(int[] array, int[] temp, intl,intr) {
intmid = (l + r) / 2;
if(l == r) {
returnnull;
}
mergeSort(array, temp, l, mid);
mergeSort(array, temp, mid + 1, r);
for(inti = l; i <= r; i++) {
temp[i] = array[i];
}
inti1 = l;
inti2 = mid + 1;
for(intcur = l; cur <= r; cur++) {
if(i1 == mid + 1) {
array[cur] = temp[i2++];
}elseif(i2 > r) {
array[cur] = temp[i1++];
}elseif(temp[i1] < temp[i2]) {
array[cur] = temp[i1++];
}else{
array[cur] = temp[i2++];
}
} returnarray;
}

}

归并排序(改进)

public class MergeSortImproved {

privatestaticfinalint THRESHOLD = 10; 

publicstaticint[] mergeSort(int[] array) {
if(array == null) {
returnnull;
} int[] temp = newint[array.length];
returnmergeSort(array, temp, 0, array.length - 1);
} privatestaticint[] mergeSort(int[] array, int[] temp, intl,intr) {
inti, j, k;
intmid = (l + r) / 2;
if(l == r) {
returnnull;
} if((mid - l) >= THRESHOLD) {
mergeSort(array, temp, l, mid);
}else{
insertSort(array, l, mid - l + 1);
} if((r - mid) > THRESHOLD) {
mergeSort(array, temp, mid + 1, r);
}else{
insertSort(array, mid + 1, r - mid);
} for(i = l; i <= mid; i++) {
temp[i] = array[i];
}
for(j = 1; j <= r - mid; j++) {
temp[r - j + 1] = array[j + mid];
}
inta = temp[l];
intb = temp[r];
for(i = l, j = r, k = l; k <= r; k++) {
if(a < b) {
array[k] = temp[i++];
a = temp[i];
}else{
array[k] = temp[j--];
b = temp[j];
}
} returnarray;
} privatestaticvoidinsertSort(int[] array, intstart,intlen) {
for(inti = start + 1; i < start + len; i++) {
for(intj = i; (j > start) && array[j] < array[j - 1]; j--) {
SortUtils.swap(array, j, j - 1);
}
}
}

}

Java基础学习总结(28)——Java对各种排序算法的实现的更多相关文章

  1. java基础学习03(java基础程序设计)

    java基础程序设计 一.完成的目标 1. 掌握java中的数据类型划分 2. 8种基本数据类型的使用及数据类型转换 3. 位运算.运算符.表达式 4. 判断.循环语句的使用 5. break和con ...

  2. java基础学习总结一(java语言发展历史、jdk的下载安装以及配置环境变量)

    最近一段时间计划复习一下java基础知识,使用的视频课程是尚学堂高淇老师的,上课过程中的心得体会直接总结一下,方便以后复习. 一:计算机语言的发展 1:机器语言,最原始的语言,主要有“01”构成,最早 ...

  3. Java基础学习笔记一 Java介绍

    java语言概述 Java是sun公司开发的一门编程语言,目前被Oracle公司收购,编程语言就是用来编写软件的. Java的应用 开发QQ.迅雷程序(桌面应用软件) 淘宝.京东(互联网应用软件) 安 ...

  4. JAVA基础学习——1.0 Java概述

    Java语言 SUN公司  1995年推出的高级编程语言 ■  主要应用方向 Web开发和Android开发 ■  主要特点 平台无关性:能运行于不同的平台上    安全性:去掉了指针操作,内存由操作 ...

  5. Java基础学习笔记十 Java基础语法之final、static、匿名对象、内部类

    final关键字 继承的出现提高了代码的复用性,并方便开发.但随之也有问题,有些类在描述完之后,不想被继承,或者有些类中的部分方法功能是固定的,不想让子类重写.可是当子类继承了这些特殊类之后,就可以对 ...

  6. Java基础学习总结(50)——Java事务处理总结

    一.什么是Java事务 通常的观念认为,事务仅与数据库相关. 事务必须服从ISO/IEC所制定的ACID原则.ACID是原子性(atomicity).一致性(consistency).隔离性(isol ...

  7. Java基础学习笔记七 Java基础语法之继承和抽象类

    继承 继承的概念 在现实生活中,继承一般指的是子女继承父辈的财产.在程序中,继承描述的是事物之间的所属关系,通过继承可以使多种事物之间形成一种关系体系. 例如公司中的研发部员工和维护部员工都属于员工, ...

  8. Java基础学习笔记八 Java基础语法之接口和多态

    接口 接口概念 接口是功能的集合,同样可看做是一种数据类型,是比抽象类更为抽象的”类”.接口只描述所应该具备的方法,并没有具体实现,具体的实现由接口的实现类(相当于接口的子类)来完成.这样将功能的定义 ...

  9. Java基础学习笔记二 Java基础语法

    注释 注释用来解释和说明程序的文字,注释是不会被执行的. 单行注释 //这是一条单行注释 public int i; 多行注释 /* 这是 * 一段注释, * 它跨越了多个行 */ public vo ...

  10. Java基础学习笔记三 Java基础语法

    Scanner类 Scanner类属于引用数据类型,先了解下引用数据类型. 引用数据类型的使用 与定义基本数据类型变量不同,引用数据类型的变量定义及赋值有一个相对固定的步骤或格式. 数据类型 变量名 ...

随机推荐

  1. 【Oracle】使用bbed恢复delete的数据

    表中的数据被delete之后并不会真正删除数据,而是打了一个删除标记,仅仅要还没有被覆盖就能够恢复回来. 实验步骤例如以下: SYS@ORCL>create table bbed_test(x  ...

  2. hdu 5375 - Gray code(dp) 解题报告

    Gray code Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total ...

  3. C# 插入排序 冒泡排序 选择排序 高速排序 堆排序 归并排序 基数排序 希尔排序

    C# 插入排序 冒泡排序 选择排序 高速排序 堆排序 归并排序 基数排序 希尔排序 以下列出了数据结构与算法的八种基本排序:插入排序 冒泡排序 选择排序 高速排序 堆排序 归并排序 基数排序 希尔排序 ...

  4. android图像处理(3) 底片效果

    这篇将讲到图片特效处理的底片效果.跟前面一样是对像素点进行处理,算法是通用的. 算法原理:将当前像素点的RGB值分别与255之差后的值作为当前点的RGB值. 例: ABC 求B点的底片效果: B.r ...

  5. 小白算法之路-非确定性多项式(non-deterministic polynomial,缩写NP)

    前端小白的算法之路   时隔多日终于解决了埋在心头的一道难题,霎时云开雾散,今天把一路而来碰到的疑惑和心得都记录下来,也算是开启了自己探索算法的大门. 问题背景 曾经有一个年少轻狂的职场小白,在前端圈 ...

  6. HDU 2564 饭卡

    饭卡 Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submissi ...

  7. CMDB学习之二数据采集

    首先也要调用插件的方式,来写采集数据插件,在src目录下创建一个插件 plugins ,然后在plugins下创建disk.py ,memory.py, network.py等等 src plugin ...

  8. 阅读笔记—EL表达式

    表达式语言(EL) 表达式语言是一种在JSP页面中使用的数据访问语言,通过它可以很方便地在JSP页面中访问应用程序数据. 使用EL访问数据 表达式语言的使用形式:              ${exp ...

  9. [Angular & Unit Testing] Automatic change detection

    When you testing Component rendering, you often needs to call: fixture.detectChanges(); For example: ...

  10. ios学习之block初探

    1. block概念 block是ios4.0+和Mac osX 10.6以后引进的对C语言的拓展,用来实现匿名函数的特性.所谓匿名函数,也称闭包函数.即同意创建一个暂时的没有指定名称的函数. 最经经 ...