Java中常用排序算法及示例-冒泡排序、希尔排序、选择排序、插入排序、合并排序、基数排序、快速排序、堆积树排序
场景
Java中需要对数据进行排序处理，常用的排序算法以及示例进行归纳整理。
注：
博客：
https://blog.csdn.net/badao_liumang_qizhi
实现
1、冒泡排序
冒泡排序法又称为交换排序法，原理是从第一个元素开始，比较相邻元素的大小，若大小顺序有误，
则对调后再进行下一个元素的比较。如此扫描一次之后就可以确保最后一个元素位于正确的顺序，
接着逐步进行第二次扫描，直到所有元素的排序为止。n个算法必须执行n-1次扫描。
示例代码:
public class MaoPao {
static int data[] = {7,3,8,4,2,6};
public static void showData(){
int i;
for (i =0;i<6;i++){
System.out.print(data[i]+" ");
}
}
public static void bubble(){
int i,j,tmp;
//扫描次数
for(i=5;i>0;i--){
//比较、交换次数
for(j=0;jdata[j+1]){
//data[j]和data[j+1]交换
tmp = data[j];
data[j] = data[j+1];
data[j+1] = tmp;
}
}
//将各次扫描后的结果打印输出
System.out.print("第"+(6-i)+"次排序后:");
showData();
System.out.println();
}
}
public static void main(String[] args) {
System.out.print("原始数据为:");
showData();
System.out.println();
bubble();
System.out.print("排序后的结果:");
showData();
System.out.println();
}
//原始数据为:7 3 8 4 2 6
//第1次排序后:3 7 4 2 6 8
//第2次排序后:3 4 2 6 7 8
//第3次排序后:3 2 4 6 7 8
//第4次排序后:2 3 4 6 7 8
//第5次排序后:2 3 4 6 7 8
//排序后的结果:2 3 4 6 7 8
} 2、冒泡排序优化-添加岗哨
n个算法必须执行n-1次扫描。传统冒泡排序法有个缺点，就是不管数据是否已经排序完成都会固定执行n(n-1)/2次。
可使用岗哨的概念改进冒泡排序，提高执行的效率。
优化算法:
public class MaoPaoYouHua {
static int data[] = {6,5,3,7,8,9};
public static void showData(){
int i;
for (i =0;i<6;i++){
System.out.print(data[i]+" ");
}
}
public static void bubble(){
int i,j,tmp,flag;
//扫描次数
for(i=5;i>0;i--){
flag=0;
//比较、交换次数
for(j=0;jdata[j+1]){
//data[j]和data[j+1]交换
tmp = data[j];
data[j] = data[j+1];
data[j+1] = tmp;
//如果执行过交换，则flag不为0
flag++;
}
}
if(flag == 0){
break;
}
//将各次扫描后的结果打印输出
System.out.print("第"+(6-i)+"次排序后:");
showData();
System.out.println();
}
}
public static void main(String[] args) {
System.out.print("原始数据为:");
showData();
System.out.println();
bubble();
System.out.print("排序后的结果:");
showData();
System.out.println();
}
//原始数据为:6 5 3 7 8 9
//第1次排序后:5 3 6 7 8 9
//第2次排序后:3 5 6 7 8 9
//排序后的结果:3 5 6 7 8 9
} 3、插入排序
插入排序法是将数组中的元素逐一与已排序好的数据进行比较，先将前两个元素排序，再将第三个元素插入到适当的位置，重复次步骤。
示例代码:
public class ChaRu {
static int data[] = {7,3,8,4,2,6};
public static void showData(){
int i;
for (i =0;i<6;i++){
System.out.print(data[i]+" ");
}
}
public static void insert(){
int i,j,tmp;
for(i=1;i<6;i++){
tmp = data[i];
j=i-1;
//如果第二个元素小于第一个元素
while (j>=0 && tmp4、快速排序
快速排序法又称为分割交换排序法，是目前公认的最佳排序法，也是使用分而治之的的方式，会先在数据中找到一个虚拟的中间值，并按照此中间值
将所有打算排序的数据分成两部分。其中小于中间值的数据放在左边，而大于中间值的数据放在右边，再以同样的方式分别处理左右两边的数据，直到排序完成
示意过程
(5,2,7,3,9,10,8,6,1,4)
以4为基准进行分解
(2,3,1)(4)(5,7,9,10,8,6)
再以每组最右边的值为基准进行分解
(1)(2,3)(4)(5)(6)(7,9,10,8)
(1)(2)(3)(4)(5)(6)(7)(8)(9,10)
(1)(2)(3)(4)(5)(6)(7)(8)(9)(10)
示例代码:
public class KuaiSu {
public static void main(String[] args){
Integer[] arr = {5,2,7,3,9,10,8,6,1,4};
quickSort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
//排序方法-假设从小到大排序
public static void quickSort(Integer[] arr,int low,int high){
if(low < high){
int part=partition(arr,low,high);
//递归调用
quickSort(arr,low,part-1);
quickSort(arr,part+1,high);
}
}
//划分方法
private static int partition(Integer[] arr,int low,int high){
//使用 r[low]作为枢轴元素
int pivot = arr[low];
//从两端交替向内扫描
while(low < high){
while(low= pivot) {high--;}
//将比 pivot 小的元素移向低端
arr[low] = arr[high];
while(low 5、选择排序
选择排序法，就是反复从未排序的数列中取出最小的元素，加入到另一个数列中，
最后的结果即为已经排序的数列。若从大到小排序，则将最大值放入第一个位置;若从小到大排序，
则将最大值放在最后一个位置。
示例代码:
public class XuanZe {
static int data[] = {7,3,8,4,2,6};
public static void showData(){
int i;
for (i =0;i<6;i++){
System.out.print(data[i]+" ");
}
}
public static void select(){
int smallest,temp,j,index;
//扫描次数
for(int i=0;i<5;i++){
smallest = data[i];
index = i;
//由i+1比较起，比较5次
for(j=i+1;j<6;j++){
//比较第i个和第j个
if(smallest>data[j]){
smallest = data[j];
index=j;
}
}
//将最小的与当前data[i]互换
temp =data[index];
data[index]=data[i];
data[i]=temp;
//将各次扫描后的结果打印输出
System.out.print("第"+(i+1)+"次排序后:");
showData();
System.out.println();
}
}
public static void main(String[] args) {
System.out.print("原始数据为:");
showData();
System.out.println();
select();
System.out.print("排序后的结果:");
showData();
System.out.println();
}
//原始数据为:7 3 8 4 2 6
//第1次排序后:2 3 8 4 7 6
//第2次排序后:2 3 8 4 7 6
//第3次排序后:2 3 4 8 7 6
//第4次排序后:2 3 4 6 7 8
//第5次排序后:2 3 4 6 7 8
//排序后的结果:2 3 4 6 7 8
}6、基数排序
基数排序并不需要元素之间的比较操作，而是属于一种分配模式排序方式
基数排序法的方向可分为最高位优先和最低位优先两种，以最低位优先为例。
将三位数的整数数据加以排序(按个位数、十位数、百位数来进行排序)
75,3,18,46,21,16,188,256
把每个整数按个位数字放到列表中
个位数字 0 1 2 3 4 5 6 7 8 9
21 3 75 16,46,256 18,188
合并后 21 3 75 16 46 256 18 188
按十位数字 0 1 2 3 4 5 6 7 8 9
3 16,18 21 46 256 75 188
合并后 3 16 18 21 46 256 75 188
按百位数字 0 1 2 3 4 5 6 7 8 9
3,16,18,21,46,75 188 256
最后合并即完成排序 3 16 18 21 46 75 188 256
示例代码
public class JiShu {
static int data[] = {75,3,18,46,21,16,188,256};
static int size = 8;
public static void showData(){
int i;
for (i =0;i7、希尔排序
希尔排序法
当原始记录的键值大部门已经排好序的情况下插入排序法会非常有效，因为不需要执行太多的数据搬移操作。
希尔排序法就是将数据区分成特定间隔的几个小区块，以插入排序法排完区块内的数据后再渐渐减少间隔的操作。
以数列(59,95,36,45,12,4,58,25)从小到大的排序过程来说明希尔排序法的演算过程
1、首先将所有数据划分成4份，分别是
(59,12)(95,4)(36,58)(45,25)
2、再分别进行插入排序
(12,59)(4,95)(36,58)(25,45)
3、接着缩小间隔为2份
(12,4,36,25)(59,95,58,45)
4、再进行插入排序
(4,12,25,36)(45,58,59,95)
5、再缩小间隔为1份对每一个元素进行排序
(4,12,25,36,45,58,59,95)
所以这种情况适合大部分数据都已经排序的情况
示例代码:
public class XiEr {
static int data[] = {59,95,36,45,12,4,58,25};
static int size=8;
public static void showData(){
int i;
for (i =0;i=0 && tmp 8、合并排序
合并排序法是针对已经排序好的两个或两个以上的数列，通过合并的方式将其组合成一个大的且已经排好序的数列。
(4,2,6,3,5,1,9,7)
(2,4)(3,6)(1,5)(7,9)
(2,3,4,6)(1,5,7,9)
(1,2,3,4,5,6,7,9)
示例代码
public class HeBing {
public static void main(String[] args) {
int[] arr1 = {4,2,6,3,5,1,9,7};
System.out.println(Arrays.toString(arr1));
mergeSort(arr1,0,arr1.length-1);
System.out.println(Arrays.toString(arr1));
}
public static void mergeSort(int[] arr,int l,int r) {
if (l9、堆积树排序
堆积树排序是选择排序法的改进版，可以减少再选择排序法中的比较次数，进而减少排序时间。
堆积树是一种特殊的二叉树，可分为最大堆积树和最小堆积树两种。
最大堆积树:它是一颗完全二叉树。所有节点的值都大于或等于它左右子节点的值。树根是堆积树中最大的。
最小堆积树:它是一颗完全二叉树。所有节点的值都小于或等于它左右子节点的值。树根是堆积树中最小的。
堆积树排序的基本思想：
（1）将待排序的序列构造成一个大顶堆；
（2）此时，整个序列最大的值就是堆顶的根节点；
（3）将其与末尾元素进行交换，此时末尾就成了最大值；
（4）然后将剩余的 n-1 个元素重新构造称为一个堆，这样会得到 n 个元素的次大（小）值；
（5）如此反复执行就能得到一个有序序列。
示例代码:
public class DuiJiShu {
public static void main(String args[]) throws IOException
{
int i,size,data[]={0,5,6,4,8,3,2,7,1}; //原始数组内容
size=9;
System.out.print("原始数组：");
for(i=1;i0;i--) //建立堆积树节点
DuiJiShu.ad_heap(data,i,size-1);
System.out.print("\n堆积内容：");
for(i=1;i0;i--) //堆积排序
{
tmp=data[i+1]; //头尾节点交换
data[i+1]=data[1];
data[1]=tmp;
DuiJiShu.ad_heap(data,1,i); //处理剩余节点
System.out.print("\n处理过程：");
for(j=1;j=data[j]) //若树根较大，结束比较过程
post=1;
else
{
data[j/2]=data[j]; //若树根较小，则继续比较
j=2*j;
}
}
data[j/2]=tmp; //指定树根为父节点
}
}