java

排序算法大致有直接插入排序、折半插入排序、Shell排序、归并排序、直接选择排序、堆排序、冒泡排序、快速排序、桶式排序、基数排序等这些种，各个算法都有其优异性，大家不妨自己看看。下面贴上每个算法的简单讲解和实现：

        1.直接选择排序（DirectSelectSort）：其关键就是对n个数据要进行n-1趟比较，每趟比较的目的就是选择出本趟比较中最小的数据，并将选择出的数据放在本趟中的第一位。实现如下：     

  1. <span style="font-size:18px;">public class DirectSelectSort {  
  2.               
  3.     //排序方法  
  4.     public static void directSelectSort(int[] data){  
  5.         int minData = 0;  
  6.         int index = 0;  
  7.         //进行n-1趟比较  
  8.         for(int i=0; i<data.length-1; i++){  
  9.             minData = data[i];  
  10.             index = i;  
  11.             for(int j=i+1; j<data.length; j++){  
  12.                 if(minData > data[j]){  
  13.                     minData = data[j];  
  14.                     index = j;  
  15.                 }  
  16.             }  
  17.             //一趟比较完后，交换一次  
  18.             data[index] = data[i];  
  19.             data[i] = minData;  
  20.         }  
  21.     }  
  22.       
  23.     public static void main(String args[]){  
  24.         int data[] = {22,34,12,32,50,67,43,32};  
  25.         System.out.print("排序前：");  
  26.         for(int i=0; i<data.length; i++){  
  27.             System.out.print(data[i]+" ");  
  28.         }  
  29.         System.out.println();  
  30.         directSelectSort(data);  
  31.         System.out.print("排序后：");  
  32.         for(int i=0; i<data.length; i++){  
  33.             System.out.print(data[i]+" ");  
  34.         }  
  35.     }  
  36.   
  37. }</span>  

            2.堆排序（HeapSort）:先说下堆的概念，假设有n个数据元素的序列k0,k1,k2,k3,...,kn-1,当且仅当满足下列关系时，可以将这组数据称为小顶堆，即ki <= k2i+1且 ki<= k2i+2(其中i=0,2,4,...,(n-1)/2);或者，满足如下关系成为大顶堆，即ki >= k2i+1且 ki >= k2i+2(其中i=0,2,...,(n-1)/2)。如果将堆排成一棵完全二叉树，则小顶堆的特点是：树中所有节点的值都小于其左右节点的值，且根节点的值最小；而大顶堆相反。堆排序的关键在于：1.建堆（大顶堆或小顶堆）2.拿堆的根节点和最后一个节点交换。

  1. <span style="font-size:18px;">public class HeapSort{  
  2.       
  3.     public static void heapSort(int[] data){  
  4.         //循环建堆  
  5.         for(int i=0; i<data.length-1; i++){  
  6.             buildMaxHeap(data, data.length-1-i);  
  7.             //交换栈顶和最后一个元素  
  8.             swap(data, 0, data.length-1-i);  
  9.         }  
  10.     }  
  11.       
  12.     public static void buildMaxHeap(int[] data, int lastIndex){  
  13.         //从最后一个节点的父节点开始  
  14.         for(int i=(lastIndex-1)/2; i>=0; i--){  
  15.             //保存当前正在判断的节点  
  16.             int k = i;  
  17.             //如果当前k节点的子节点存在  
  18.             while(k*2+1 <= lastIndex){  
  19.                 int biggerIndex = 2*k+1;  
  20.                 if(biggerIndex < lastIndex){  
  21.                     if(data[biggerIndex] < data[biggerIndex+1]){  
  22.                         biggerIndex++;  
  23.                     }  
  24.                 }  
  25.                 if(data[k] < data[biggerIndex]){  
  26.                     //交换  
  27.                     swap(data, k, biggerIndex);  
  28.                     k = biggerIndex;  
  29.                 }else{  
  30.                     break;  
  31.                 }  
  32.             }  
  33.         }  
  34.     }  
  35.       
  36.     public static void swap(int[] data, int i, int j){  
  37.         int temp = data[i];  
  38.         data[i] = data[j];  
  39.         data[j] = temp;  
  40.     }  
  41.       
  42.     public static void main(String[] args){  
  43.         int data[] = {22,34,12,32,50,67,43,32};  
  44.         System.out.print("排序前：");  
  45.         for(int i=0; i<data.length; i++){  
  46.             System.out.print(data[i]+" ");  
  47.         }  
  48.         System.out.println();  
  49.         heapSort(data);  
  50.         System.out.print("排序后：");  
  51.         for(int i=0; i<data.length; i++){  
  52.             System.out.print(data[i]+" ");  
  53.         }  
  54.     }  
  55. }</span>  


          3. 冒泡排序（BubbleSort）:冒泡排序是最简单的排序算法之一，实现起来也比较简单，其原理就是进行n-1趟比较并交换，小数往上冒，大数往下沉，经过n-1趟之后形成了有序的数列。

  1. <span style="font-size:18px;">public class BubbleSort {  
  2.       
  3.     public static void bubbleSort(int[] data){  
  4.         for(int i=0; i<data.length-1; i++){  
  5.             for(int j=0; j<data.length-i-1; j++){  
  6.                 if(data[j] > data[j+1]){  
  7.                     int temp = data[j];  
  8.                     data[j] = data[j+1];  
  9.                     data[j+1] = temp;  
  10.                 }  
  11.             }  
  12.         }  
  13.     }  
  14.       
  15.     public static void main(String[] args){  
  16.         int data[] = {22,34,12,32,50,67,43,32};  
  17.         System.out.print("排序前：");  
  18.         for(int i=0; i<data.length; i++){  
  19.             System.out.print(data[i]+" ");  
  20.         }  
  21.         System.out.println();  
  22.         bubbleSort(data);  
  23.         System.out.print("排序后：");  
  24.         for(int i=0; i<data.length; i++){  
  25.             System.out.print(data[i]+" ");  
  26.         }  
  27.     }  
  28.   
  29. }  
  30. </span>  


            4.快速排序（QuickSort）: 快速排序死对 冒泡排序的一种改进，基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

  1. <span style="font-size:18px;">public class QuickSort {  
  2.   
  3.     public static void quickSort(int[] data, int start, int end){  
  4.   
  5.         if(start < end){  
  6.             //以第一个元素为分界值  
  7.             int middleNum = data[start];  
  8.             int i = start;  
  9.             int j = end + 1;  
  10.             while(true){  
  11.                 //找到大于分界值的元素的索引或者已经到了end处  
  12.                 while(i<end && data[++i] <= middleNum);  
  13.                 //找到小于分界值的元素的索引或者已经到了start处  
  14.                 while(j>start && data[--j] >= middleNum);  
  15.                 if(i < j){  
  16.                     //交换  
  17.                     int temp = data[i];  
  18.                     data[i] = data[j];  
  19.                     data[j] = temp;  
  20.                 }else{  
  21.                     break;  
  22.                 }  
  23.             }  
  24.             int temp = data[start];  
  25.             data[start] = data[j];  
  26.             data[j] = temp;  
  27.             //递归左子序列  
  28.             quickSort(data, start, j-1);  
  29.             //递归右子序列  
  30.             quickSort(data, j+1, end);  
  31.         }         
  32.     }  
  33.   
  34.     public static void main(String[] args){  
  35.         int data[] = {22,34,12,32,50,67,43,32};  
  36.         System.out.print("排序前：");  
  37.         for(int i=0; i<data.length; i++){  
  38.             System.out.print(data[i]+" ");  
  39.         }  
  40.         System.out.println();  
  41.         quickSort(data, 0, data.length-1);  
  42.         System.out.print("排序后：");  
  43.         for(int i=0; i<data.length; i++){  
  44.             System.out.print(data[i]+" ");  
  45.         }  
  46.     }  
  47.   
  48. }  
  49. </span>  

                5.直接插入排序（DirectInsertSort）:直接插入排序的思路很简单，就是依次将带排序的数据元素按其关键字排序的大小插入前面的有序序列。

      1. <span style="font-size:18px;">public class DirectInsertSort {  
      2.       
      3.     public static void directInsertSort(int[] data){  
      4.         for(int i=1; i<data.length; i++){  
      5.             for(int j=0; j<i; j++){  
      6.                 if(data[i] < data[j]){  
      7.                     //保存插入元素  
      8.                     int temp = 0;  
      9.                     temp = data[i];  
      10.                     //将要插入元素位置后的元素依次往后移  
      11.                     for(int m=i; m>j; m--){  
      12.                         data[m] = data[m-1];  
      13.                     }  
      14.                     //插入元素  
      15.                     data[j] = temp;  
      16.                 }  
      17.             }             
      18.         }  
      19.     }  
      20.       
      21.     public static void main(String[] args){  
      22.         int data[] = {22,34,12,32,50,67,43,32};  
      23.         System.out.print("排序前：");  
      24.         for(int i=0; i<data.length; i++){  
      25.             System.out.print(data[i]+" ");  
      26.         }  
      27.         System.out.println();  
      28.         directInsertSort(data);  
      29.         System.out.print("排序后：");  
      30.         for(int i=0; i<data.length; i++){  
      31.             System.out.print(data[i]+" ");  
      32.         }  
      33.     }  
      34.   
      35. }  
      36. </span>  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/BillLei/p/4890452.html