八种排序算法（内部排序）

Posted 2020-08-09 aston

　　八种排序算法很长时间没有使用了，今天做一个总结，方便以后自己用的时候参考。

　　这八种排序算法都是内部算法，这八种排序算法分别是：

　　1. 插入排序
　　　　1）直接插入排序
　　　　2）希尔排序
　　2.选择排序
　　　　1）简单选择排序
　　　　2）堆排序
　　3.交换排序
　　　　1）冒泡排序
　　　　2）快速排序
　　4.归并排序
　　5.基数排序

一、直接插入排序

　　将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。在实际操作中，先将序列的第一个记录看成是一个有序的子序列，然后从第二个、第三个、……记录逐个进行插入，直至整个序列有序为止。

　　插入排序算法Java实现：

　　public class DirectInsertionSort {
　　　　/**
　　　　* 直接插入排序
　　　　* @param args
　　　　*/
　　　　public static void main(String[] args) {
　　　　　　int[] arrayInt = {17,56,80,17,12,9,100,64,42,37,64,82,123,974,314,548};
　　　　　　int length = arrayInt.length;
　　　　　　
　　　　　　for( int i=1; i<length; i++){
　　　　　　　　for( int j=i; j>0; j--){
　　　　　　　　　　if( arrayInt[j] <= arrayInt[j-1]){
　　　　　　　　　　　　int k = arrayInt[j];
　　　　　　　　　　　　arrayInt[j] = arrayInt[j-1];
　　　　　　　　　　　　arrayInt[j-1] = k;
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}

　　　　　　for( int i=0; i<length; i++){
　　　　　　　　System.out.println( arrayInt[i]);
　　　　　　}
　　　　}

　　}

二、希尔排序

　　先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，带整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

　　希尔排序Java实现：

　　public class ShellSort {
　　　　/**
　　　　* 希尔排序
　　　　* @param args
　　　　*/
　　　　public static void main(String[] args) {
　　　　　　int[] arrayInt = {17,56,80,17,12,9,100,64,42,37,64,82,123,974,314,548};
　　　　　　int length = arrayInt.length;
　　　　　　System.out.println( "length="+length);

　　　　　　shellSort( arrayInt);

　　　　　　for( int i=0; i<length; i++){
　　　　　　　　System.out.println( "arrayInt[" + i + "]=" + arrayInt[i]);
　　　　　　}

　　　　}

　　　　public static void shellSort( int[] arrayInt){
　　　　　　int j = 0;
　　　　　　int temp = 0;
　　　　　　for ( int increment=arrayInt.length/2; increment>0; increment/=2){
　　　　　　　　for ( int i=increment; i<arrayInt.length; i++){
　　　　　　　　　　temp = arrayInt[i];
　　　　　　　　　　for ( j=i; j>=increment; j-=increment){
　　　　　　　　　　　　if( temp > arrayInt[j-increment]){
　　　　　　　　　　　　　　arrayInt[j] = arrayInt[j - increment];
　　　　　　　　　　　　}else{
　　　　　　　　　　　　　　break;
　　　　　　　　　　　　}
　　　　　　　　　　}
　　　　　　　　　　arrayInt[j] = temp;
　　　　　　　　}
　　　　　　}
　　　　}

　　}

三、简单选择排序

　　在待排序的一组数中，选出最小（大）的一个数与第一个位置的数交换；然后在剩下的数当中再找最小（大）的与第二个位置的数交换，以此类推，直到第n-1个元素和第n个元素比较为止。

　　简单选择排序Java实现：

　　public class SimpleSelectionSort {
　　　　/**
　　　　* 简单选择排序
　　　　* @param args
　　　　*/
　　　　public static void main(String[] args) {
　　　　　　int[] arrayInt = {17,56,80,17,12,9,100,64,42,37,64,82,123,974,314,548};
　　　　　　int length = arrayInt.length;

　　　　　　for( int i=0; i<length; i++){
　　　　　　　　for( int j=i+1; j<length; j++){
　　　　　　　　　　if( arrayInt[i] > arrayInt[j]){
　　　　　　　　　　　　int k = arrayInt[i];
　　　　　　　　　　　　arrayInt[i] = arrayInt[j];
　　　　　　　　　　　　arrayInt[j] = k;
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}
　　　　　　
　　　　　　for( int i=0; i<length; i++){
　　　　　　　　System.out.println( arrayInt[i]);
　　　　　　}
　　　　}

　　}

四、堆排序

　　一种树形选择排序，是对直接选择排序的有效改进。

　　堆排序Java实现：

 

五、冒泡排序

　　对待排序的一组数，自上而下对相邻的两个数依次进行比较和调整，让较大（小）的数往下沉，较小（大）的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

　　冒泡排序Java实现：

　　public class BubbleSort {
　　　　/**
　　　　* 冒泡排序
　　　　* @param args
　　　　*/
　　　　public static void main(String[] args) {
　　　　　　int[] arrayInt = {17,56,80,17,12,9,100,64,42,37,64,82,123,974,314,548};
　　　　　　int length = arrayInt.length;
　　　　　　
　　　　　　for( int i=0; i<length-1; i++){
　　　　　　　　for( int j=0; j<length-i-1; j++){
　　　　　　　　　　if( arrayInt[j] > arrayInt[j+1]){
　　　　　　　　　　　　int k = arrayInt[j];
　　　　　　　　　　　　arrayInt[j] = arrayInt[j+1];
　　　　　　　　　　　　arrayInt[j+1] = k;
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}
　　　　　　
　　　　　　for( int i=0; i<length; i++){
　　　　　　　　System.out.println( arrayInt[i]);
　　　　　　}
　　　　}

　　}

六、快速排序

　　通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

　　快速排序Java实现：

　　public class QuickSort {
　　　　/**
　　　　* 快速排序
　　　　* @param args
　　　　*/
　　　　public static void main(String[] args) {
　　　　　　int[] arrayInt = {17,56,80,17,12,9,100,64,42,37,64,82,123,974,314,548};
　　　　　　int start = 0;
　　　　　　int end = arrayInt.length-1;
　　　　　　
　　　　　　quickSort( arrayInt, start, end);
　　　　　　
　　　　}

　　　　public static void quickSort( int[] arrayInt, int start, int end){
　　　　　　if( start >= end){
　　　　　　　　return;
　　　　　　}
　　　　　　
　　　　　　int i = start;
　　　　　　int j = end;
　　　　　　int value = arrayInt[start];
　　　　　　boolean flag = true;
　　　　　　
　　　　　　while( i != j){
　　　　　　　　if( flag){
　　　　　　　　　　if( value > arrayInt[j]){
　　　　　　　　　　　　int k = arrayInt[i];
　　　　　　　　　　　　arrayInt[i] = arrayInt[j];
　　　　　　　　　　　　arrayInt[j] = k;
　　　　　　　　　　　　i++;
　　　　　　　　　　　　flag = false;
　　　　　　　　　　}else{
　　　　　　　　　　　　j--;
　　　　　　　　　　}
　　　　　　　　}else{
　　　　　　　　　　if( value < arrayInt[i]){
　　　　　　　　　　　　int k = arrayInt[i];
　　　　　　　　　　　　arrayInt[i] = arrayInt[j];
　　　　　　　　　　　　arrayInt[j] = k;
　　　　　　　　　　　　j--;
　　　　　　　　　　　　flag = true;
　　　　　　　　　　}else{
　　　　　　　　　　　　i++;
　　　　　　　　　　}
　　　　　　　　}
　　　　　　}
　　　　　　
　　　　　　for( int m=0; m<arrayInt.length; m++){
　　　　　　　　System.out.print(arrayInt[m] + " ");
　　　　　　}
　　　　　　System.out.println();
　　　　　　
　　　　　　quickSort( arrayInt, start, j-1);
　　　　　　quickSort( arrayInt, i+1, end);
　　　　}
　　　　
　　}

七、归并排序

　　建立在归并操作上的一种有效的排序算法，该算法是采用“分治法”的一个非常典型的应用。

　　归并排序Java实现：

　　public class MergeSort {
　　　　/**
　　　　* 归并排序
　　　　* @param args
　　　　*/
　　　　public static void main(String[] args) {
　　　　　　int[] arrayInt = {17,56,80,17,12,9,100,64,42,37,64,82,123,974,314,548};
　　　　　　int start = 0;
　　　　　　int end = arrayInt.length-1;
　　　　　　
　　　　　　mergeSort( arrayInt, start, end);
　　　　　　
　　　　　　for( int i=0; i<arrayInt.length; i++){
　　　　　　　　System.out.print( arrayInt[i]+" ");
　　　　　　}
　　　　}

　　　　public static int[] mergeSort( int[] arrayInt, int start, int end){
　　　　　　int middle = ( start+end)/2;
　　　　　　
　　　　　　if( start < end){
　　　　　　　　mergeSort( arrayInt, start, middle);
　　　　　　　　mergeSort( arrayInt, middle+1, end);
　　　　　　　　sort( arrayInt, start, middle, end);
　　　　　　}
　　　　　　
　　　　　　return arrayInt;
　　　　}
　　　　
　　　　public static void sort( int[] arrayInt, int start, int middle, int end){
　　　　　　int[] arrayTemp = new int[ end-start+1];
　　　　　　int i = start;
　　　　　　int j = middle +1;
　　　　　　int k = 0;
　　　　　　
　　　　　　while( i <= middle && j <= end){
　　　　　　　　if( arrayInt[i] < arrayInt[j]){
　　　　　　　　　　arrayTemp[k] = arrayInt[i];
　　　　　　　　　　k++;
　　　　　　　　　　i++;
　　　　　　　　}else{
　　　　　　　　　　arrayTemp[k] = arrayInt[j];
　　　　　　　　　　k++;
　　　　　　　　　　j++;
　　　　　　　　}
　　　　　　}
　　　　　　
　　　　　　while( i<=middle){
　　　　　　　　arrayTemp[k] = arrayInt[i];
　　　　　　　　k++;
　　　　　　　　i++;
　　　　　　}
　　　　　　
　　　　　　while( j <= end){
　　　　　　　　arrayTemp[k] = arrayInt[j];
　　　　　　　　k++;
　　　　　　　　j++;
　　　　　　}
　　　　　　
　　　　　　for( int m=0; m<arrayTemp.length; m++){
　　　　　　　　arrayInt[m+start] = arrayTemp[m];
　　　　　　}
　　　　}

　　}

八、基数排序

　　属于“分配式排序”，又称“桶子法”。它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用。基数排序法是属于稳定性的排序。

　　基数排序Java排序：