java实现七种经典排序算法

简单算法：冒泡，简单选择，直接插入

改进算法：希尔，堆，归并，快速

直接插入排序：将一个记录插入到已经拍好的有序列表中，从而得到一个新的、记录数增加1的有序表。

冒泡排序：两两比较，反序交换。每趟将最大（小）的浮到最上面或沉到最底下。

简单选择排序：通过关键字之间的比较，每次将剩余的记录中选择最小的与指定位置交换。

希尔排序：跳跃的插入排序，选择某个增量，对间隔增量的子序列进行排序，随着增量递减，逐步完成所有值的排序。

堆排序：将待排序序列构建成一个大顶堆，此时整个序列最大值就是根节点。将它和末尾元素交换，随后将剩余的n-1个元素重新构造成一个堆，以此类推。

归并排序：拆分，随后重组。

快速排序：通过一趟排序将待排记录分成独立的两部分，一部分都小于另一部分，随后对两部分分别进行再次排序，以达到整体有序。

（所有代码均可独立运行成功）

冒泡排序：

import java.util.Arrays;/*** 冒泡排序算法* 两两比较相邻记录的关键字，如果反序则交换，直到没有反序记录为止* @author 诸葛浪**/
public class BubbleSortDemo {public static void bubbleSort0(int[] arr) {//初级版本冒泡算法 每一个关键字都和后面每一个关键字相比较for(int i =0;i<arr.length-1;i++) for(int j =i+1; j<arr.length;j++)if(arr[i] > arr[j])swap(arr, i, j);}public static void bubbleSort(int[] arr) {//从后往前 两两比较 每一轮把最小的转移到i的位置for(int i=0;i<arr.length;i++)for(int j = arr.length-1;j>i;j--)//for(int j=0 ; j<arr.length-1-i ; j++) 从前往后也可以 每一趟把最大的放最后    if(arr[j-1] > arr[j])swap(arr, j-1, j);}public static void bubbleSort2(int[] arr) {//改进版 如果一趟下来没有交换 说明有序 之后就不必循环判断了boolean flag = true;//用以记录是否发生交换for(int i = 0;i<arr.length&&flag;i++) {flag = false;for(int j = arr.length - 1;j>i;j--) {if(arr[j-1] > arr[j]) {       swap(arr, j-1, j);flag = true;}}}}public static void main(String[] args) {int[] arrTest = {9,1,5,8,3,7,4,6,2};System.out.println("before: " +  Arrays.toString(arrTest));bubbleSort2(arrTest);System.out.println("after: " + Arrays.toString(arrTest));}public static void swap(int[] arr , int i, int j) {//交换数组两元素int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}
}

直接插入排序：

import java.util.Arrays;/*** 插入排序算法* 基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个记录数+1的有序表* @author 诸葛浪**/
public class InsertSortDemo {public static void insertSort(int[] arr) {//设置一个辅助空间arr[0]for(int i =2;i<arr.length;i++  ) {if(arr[i] < arr[i-1]) {       //需要将arr[i]插入有序子表arr[0] = arr[i];//设置哨兵int j;for(j = i-1;arr[j] > arr[0];j--)arr[j+1] = arr[j];//记录后移arr[j+1] = arr[0];//插入到正确位置}}}public static void main(String[] args) {int[] arrTest = {0,1,5,8,3,7,4,6,2};System.out.println("before: " + Arrays.toString(arrTest));insertSort(arrTest);System.out.println("after: " + Arrays.toString(arrTest));}}

简单选择排序

import java.util.Arrays;/*** 简单选择排序* 基本思想是每一趟在n-i个记录中选择最小的作为第i个记录（从0开始）* * @author 诸葛浪**/
public class SelectSortDemo {public static void selectSort(int[] arr) {//选择排序 每一趟找到最小的放到i的位置for(int i=0;i<arr.length;i++) {int min = i;//将当前下标定义为最小值下标for(int j = i+1; j<arr.length;j++)  {if(arr[min] > arr[j]    )//如果有小于当前最小值的关键字min = j;    //将此下标赋值给min}if(i != min)//有更改 则交换swap(arr, i, min);}}public static void main(String[] args) {int[] arrTest = {9,1,5,8,3,7,4,6,2};System.out.println("before: " +    Arrays.toString(arrTest));selectSort(arrTest);System.out.println("after: " + Arrays.toString(arrTest));}public static void swap(int[] arr , int i, int j) {//交换数组两元素int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}
}

希尔排序：

import java.util.Arrays;/*** 希尔排序 又叫增量递减排序* 将相距某个”增量“的记录组成一个子序列* 保证在子序列内分别进行直接插入排序后得到的结果是基本有序的* 直接插入排序的升级版* @author 诸葛浪**/
public class ShellSortDemo {public static void shellSort(int[] arr) {//增量递减的插入排序int increment = arr.length;do {increment = increment / 3 + 1;for(int i = increment + 1 ; i < arr.length; i++) {if(arr[i] < arr[i - increment]) {//对间隔增量的位置进行比较arr[0] = arr[i];//暂存在0int j;for(j = i - increment; j> 0 && arr[0] < arr[j]; j -= increment)arr[j+increment] = arr[j];//记录后移 查找插入位置arr[j+increment] = arr[0];            }}}while(increment > 1);}public static void main(String[] args) {int[] arrTest = {0,1,5,8,3,7,4,6,2};System.out.println("before: " + Arrays.toString(arrTest));shellSort(arrTest);System.out.println("after: " + Arrays.toString(arrTest));}
}

堆排序：


import java.util.Arrays;/*** 堆排序 利用完全二叉树的结构* 对于完全二叉树来说，层序遍历之后如果i>1 则i/2(向上取整3.5->3)为其双亲节点* 而双亲节点均大于或小于子节点* 根节点最大称大顶堆 否则小顶堆* 通过不断移除根节点（与末尾结点交换）并重新组织成堆* 从而得到有序序列* 简单选择排序的升级版* @author 诸葛浪**/
public class HeapSortDemo {public static void heapSort(int[] arr) {for(int i = (arr.length-1)/2; i>0;i--) heapAdjust(arr, i, arr.length-1);for(int i = (arr.length-1);i>1;i--) {swap(arr, 1, i);heapAdjust(arr, 1, i-1);}}public static void heapAdjust(int[] arr, int s, int m) {//将s到m调整为大顶堆int temp = arr[s];for(int j = s*2;j<=m;j*=2) {//左孩子节点2*s 右孩子2*s+1if(j < m && arr[j] < arr[j+1])//左孩子小于右孩子 j指向右孩子++j;if(temp >= arr[j])//根节点大于右孩子 满足大顶堆特性 跳出循环break;arr[s] = arr[j];//否则将大节点赋值给根节点s = j;//根节点向下指向孩子节点}arr[s]  = temp;}public static void swap(int[] arr , int first, int next) {//交换数组两元素int temp = arr[first];arr[first] = arr[next];arr[next] = temp;}public static void main(String[] args) {int[] arrTest = {0,50,10,90,30,70,40,80,60,20};System.out.println("before: " +  Arrays.toString(arrTest));heapSort(arrTest);System.out.println("after: " + Arrays.toString(arrTest));}
}

归并排序：

import java.util.Arrays;/*** 归并排序算法* 假设初始序列含有n个记录 则可以看成是n个有序的子序列 每个子序列长度为1* 然后两两归并 得到n/2（向上取整）个长度为2或1的有序子序列 两两归并 如此重复 * 直到得到长度为n的有序序列为止 称为2路归并* 一种拆分到最小 并从最小合并成最大的思路* 拆分之后的归并实际上是选择排序的一种* @author 诸葛浪**/
public class MergeSortDemo {public static void mergeSort(int[] arr ) {mSort(arr, arr, 0, arr.length-1);}public static void mSort(int[] SR,int[] TR1,int s, int t ) {int m;int[] TR2 = new int[SR.length + 1];if(s == t)//递归返回条件 拆分至最小了TR1[s] = SR[s];else {m = (s+t)/2; //将SR[s..t]分成s到m和m+1到tmSort(SR, TR2, s, m); //递归地将SR[s...m]归并为有序的TR2[s..m]mSort(SR, TR2, m+1, t); //同上merge(TR2,TR1,s,m,t);//TR2归并到TR1中}}public static void merge(int[] SR,int[] TR,int i, int m ,int n ) {//将有序的SR[i..m]和SR[m+1...n]归并为有序的TR[i...n]int j,k,l;for(j = m+1,k=i;i<=m&&j<=n;k++) {//两半里面挨个挑 将SR中记录由小到大并入TRif(SR[i] < SR[j])//比较符号反过来就是从大到小的排序TR[k] = SR[i++];elseTR[k] = SR[j++];}//剩下哪个全都归入TR数组if(i <= m)for(l = 0;l<=m-i;l++)TR[k+l] = SR[i+l];if(j <= n)for(l = 0;l<=n-j;l++)TR[k+l] = SR[j+l];}public static void main(String[] args) {int[] arrTest = {50,10,90,30,70,40,80,60,20};System.out.println("before: " +    Arrays.toString(arrTest));mergeSort(arrTest);System.out.println("after: " + Arrays.toString(arrTest));}
}

快速排序：


import java.util.Arrays;/*** 快速排序算法* 属于交换排序 * 基本思想是通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分小* 则可以分别对这两个部分继续进行排序 以达到整个序列有序的目的* * @author 诸葛浪**/
public class QuickSortDemo {public static void quickSort(int[] arr) {qSort(arr, 0, arr.length-1);}/*对arr中的子序列arr[low...high]做快速排序*/public static void qSort(int[] arr, int low,int high) {int pivot;//枢轴变量if(low < high) {//将arr[]一分为二 算出枢轴值pivot//pivot = partition(arr, low ,high);pivot = partition1(arr, low, high);qSort(arr, low, pivot-1);//对低子表进行递归排序qSort(arr, pivot+1, high);//对高子表进行递归排序}}/*交换arr中字表的记录 使枢轴记录到位 并返回其所在位置，此时在它之前均不大于他 之后均不小于他*/public static int partition(int[] arr, int low, int high) {int pivotKey = arr[low];//用子表的第一个记录作为枢轴值while(low < high) {//low和high双指针不断向中间靠拢，枢轴值也在不断移动 性能依赖枢轴值在序列中的分布//另一个版本中也可以不移动枢轴值 最后赋值皆可while(low < high && arr[high] >= pivotKey)high--;swap(arr, low, high);while(low < high && arr[low] <= pivotKey)low++;swap(arr, low, high);}return low;}public static int partition1(int[] arr, int low, int high) {int pivotKey ;//用子表三数取中法 作为枢轴值int m = low +(high - low) /2;//找到序列中间位置if(arr[low] > arr[high])swap(arr, low, high);if(arr[m] > arr[high])swap(arr, high, m);if(arr[m] > arr[low])swap(arr, m, low);pivotKey = arr[low];//此时枢轴值选择为左中右三个数中位数值while(low < high) {//可以不移动枢轴值 最后赋值皆可while(low < high && arr[high] >= pivotKey)high--;arr[low] = arr[high]; //改为直接赋值while(low < high && arr[low] <= pivotKey)low++;arr[high] = arr[low];}arr[low] = pivotKey;return low;}public static void swap(int[] arr , int i, int j) {//交换数组两元素int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}public static void main(String[] args) {int[] arrTest = {50,10,90,30,70,40,80,60,20};System.out.println("before: " + Arrays.toString(arrTest));quickSort(arrTest);System.out.println("after: " + Arrays.toString(arrTest));}}

快排和归并的示意图：

再加一个啊哈磊的图

java实现七种经典排序算法相关推荐

3分钟快速实现：9种经典排序算法的可视化
作者 | 爱笑的眼睛来源 | 恋习Python(ID:sldata2017) 最近在某网站上看到一个视频,是关于排序算法的可视化的,看着挺有意思的,也特别喜感. ▼ 6分钟演示15种排序算法不知道 ...
3min利用Python实现9种经典排序算法可视化!（附源代码）
来源:恋习Python 本文附视频,建议收藏. 本文为你分享实现9种经典排序算法可视化的方法,3分钟即可实现. [导读]近在某网站上看到一个视频,是关于排序算法的可视化的,看着挺有意思的,也特别喜感 ...
[转载] java实现四种常用排序算法
参考链接: 用Java排序四种常用排序算法 ##注:从小到大排 ##冒泡排序## 特点:效率低,实现简单思想:每一趟将待排序序列中最大元素移到最后,剩下的为新的待排序序列,重复上述步骤直到排完所有 ...
Jerry 2017年的五一小长假：8种经典排序算法的ABAP实现
2017年4月29日~5月1日,国际劳动节, 三天的小长假. 在国内,小长假往往是这样的: 然而我当时在戏称为"德村"(德国农村)的Walldorf出差并且住在Wiesloch, ...
八种经典排序算法总结
前言算法和数据结构是一个程序员的内功,所以经常在一些笔试中都会要求手写一些简单的排序算法,以此考验面试者的编程水平.下面我就简单介绍八种常见的排序算法,一起学习一下. 一.冒泡排序思路: 比较相邻 ...
排序八种经典排序算法
排序(Sorting) 是计算机程序设计中的一种重要操作,它的功能是将一个数据元素(或记录)的任意序列,重新排列成一个关键字有序的序列. 我整理了以前自己所写的一些排序算法结合网上的一些资料,共介绍8 ...
剖析八种经典排序算法
排序(Sorting) 是计算机程序设计中的一种重要操作,它的功能是将一个数据元素(或记录)的任意序列,重新排列成一个关键字有序的序列. 我整理了以前自己所写的一些排序算法结合网上的一些资料,共介绍8 ...
我用 Python 3分钟实现9种经典排序算法的可视化
导读:最近在某网站上看到一个视频,是关于排序算法的可视化的,看着挺有意思的,也特别喜感. 不知道作者是怎么做的,但是突然很想自己实现一遍,而且用python实现特别快,花了一天的时间,完成了这个项目. ...
快速修改数组的某个值_我用Python，3分钟快速实现，9种经典排序算法的可视化...
最近在某网站上看到一个视频,是关于排序算法的可视化的,看着挺有意思的,也特别喜感. ▼ 6分钟演示15种排序算法 https://v.qq.com/x/page/t0396emm8oy.html 不知 ...
Java代码来实现-经典排序算法
Java基础算法这里只写了冒泡排序.选择排序.插入排序,后续还会更新. 1.原理冒泡排序: 每次比较从第个数据开始,数据两两比较,如果左边数据比右数据大,则交换左右数据.继续比较.一次比较 ...