java经典排序算法

本文对当前主流排序算法原理和具体java实现，主要包括冒泡排序，插入排序，选择排序，希尔排序，堆排序，快速排序，归并排序进行讲解。算法功能基本测试通过，读者若有更好的算法实现请留评论里面，感激不尽。

一、冒泡排序（BubbleSortDemo），冒泡排序基本原理：打个简单的比方就如同我们烧开水时的气泡，大的气泡一个一个的往上冒，即冒泡排序的每一轮排序都选出最大的数拍在最后或者最前。冒泡排序的时间复杂度为O（n2）。

//parm score为输入排序数组，return排序后数组

public static int[] BubbleSortDemo(int [] score) {

    for (int i = 0; i < score.length -1; i++){    
             for(int j = 0 ;j < score.length - i - 1; j++){    
                 if(score[j] >score[j + 1]){    
                     int temp = score[j];
                     score[j] = score[j + 1];
                     score[j + 1] = temp;
               }
              } 
}
return score;  

}

二、选择排序（selectionSort），选择排序的基本原理：用白话讲就是首先从一组数中选出一个最小的数或者最大的数，然后将这个最小的数或者最大的数与此轮排序第一个数进行交换。选择排序的时间复杂度为O（n*n）。

public static int[] selectionSort(int[] score){
        for(int i = 0; i < score.length-1; ++i){
            int k = i;
            for(int j = i; j < score.length; ++j){
                if(score[k] > score[j]){
                    k = j;
                }
            }
            if(k != i){
                int temp = score[i];
                score[i] = score[k];
                score[k] = temp;
            }
        }
        return score;
}

三、插入排序 （insertSort），插入排序的基本原理：用白话讲就是像我们打扑克牌，把从1到K的牌排好序，我们一般采用的方法时取出俩张牌排好大小，然后取第三张牌，插入这俩种中合适的位置，然后在取第四张牌插入，前三张已经排好序的位置，直到所有的牌都排好为止。用比较正式的话来讲就是把n个待排序的元素看成一个有序表和一个无序表，开始有序表只包含一个元素，无序表中包含n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。

  public static int[] insertSort(int score[])
    {
        for(int i=1;i<score.length;i++)
        {
            int insertVal = score[i];
            // insertValue准备和前一个数比较
            int index=i-1;
              
            while(index>=0&&insertVal<score[index])
            {
                //  将把arr[index]向后移动
            score[index+1]=score[index];
                // 让index向前移动一位
                index--;
            }
              
            // 将insertValue插入到适当位置
            score[index+1]=insertVal;
        }
        return score;
    }

四、希尔排序（shellSort），在研究希尔排序之前一定要好好熟悉插入排序，有助于理解。希尔排序的基本原理：用白话来说，希尔排序实际上就是插入排序的一种改进算法，首先对数据进行分组，然后对分组的数据插入排序，最后对所有数据插入排序。本例中分割间隔长度为  DataLength = DataLength / 2; 对半分。最好的时间复杂度为与分割增量有很大的关系。

   public static int []  ShellSort(int[] score) {  
        int i, j, k; // 循环计数变量  
        int Temp; // 暂存变量  
        boolean Change; // 数据是否改变  
        int DataLength; // 分割集合的间隔长度  
        int Pointer; // 进行处理的位置  
        int Index=score.length;
        DataLength = (int) Index / 2; // 初始集合间隔长度  
        while (DataLength != 0) // 数列仍可进行分割  
        {  
          // 对各个集合进行处理  
          for (j = DataLength; j < Index; j++) {  
            Change = false;  
            Temp = score[j]; // 暂存Data[j]的值,待交换值时用  
            Pointer = j - DataLength; // 计算进行处理的位置  
            // 进行集合内数值的比较与交换值  
            while (Temp < score[Pointer] && Pointer >= 0 && Pointer <= Index) {  
            score[Pointer + DataLength] = score[Pointer];  
              // 计算下一个欲进行处理的位置  
              Pointer = Pointer - DataLength;  
              Change = true;  
              if (Pointer < 0 || Pointer > Index)  
                break;  
            }  
            // 与最后的数值交换  
            score[Pointer + DataLength] = Temp;  
          }  
          DataLength = DataLength / 2; // 计算下次分割的间隔长度  
        } 
        return score;
      } 

五、快速排序（Quik Sort），快速排序基本原理：快速排序实际上就是采用递归分组方法，选出一个排序数中的数作为参考节点，小于参考节点的数放在左边，大于节点的数放在右边。采用递归一直到整个左右排序都执行完。

 public static void swap1(int a[], int i, int j) {              // 通过临时变量,交换数据
        int tmp = a[i]; 
        a[i] = a[j]; 
        a[j] = tmp; 
      }                                                                  // 第一次交换分析
      public static void quicksort(int a[], int low, int high) {   // 假设传入low=0; high=a.length-1;
        if (low < high) {                                          // 条件判断
         int pivot, p_pos, i;                                    // 声明变量
            p_pos = low;                                         // p_pos指向low,即位索引为0位置 ;
            pivot = a[p_pos];                                   // 将0位置上的数值赋给pivot;
            for (i = low + 1; i <= high; i++) {             // 循环次数, i=1;
             if (a[i]<pivot) {                                      // 1位置的数与0位置数作比较: a[1]>a[0]
               p_pos++;                                           // 2位与1位比较,3位与2位比较......
               swap(a, p_pos, i);                              // 传参并调用swap      
              } 
            } 
          swap1(a, low, p_pos);                              // 将p_pos设为high再次调用swap
          quicksort(a, low, p_pos - 1);                  // 递归调用,排序左半区
          quicksort(a, p_pos + 1, high);                // 递归调用,排序右半区
        } 
      } 
    六、堆排序（Heap Sort），堆排序基本原理：堆排序采用二叉树的基本原理进行排序，java中可用数组表示二叉树。堆排序过程主要有俩部，第一部就是构建堆；第二部就是讲堆根节点与尾节点交换。

 public static int[] heapSort(int[] data){
        
        int arrayLength=data.length;
        //循环建堆
        for(int i=0;i<arrayLength-1;i++){
            //建堆
            buildMaxHeap(data,arrayLength-1-i);
            //交换堆顶和最后一个元素
            swap(data,0,arrayLength-1-i);
         
        }
        return data;
    }


    private static void swap(int[] data, int i, int j) {
        // TODO Auto-generated method stub
    int tmp=data[i];
        data[i]=data[j];
        data[j]=tmp;
    }
    //对data数组从0到lastIndex建大顶堆
    private static void buildMaxHeap(int[] data, int lastIndex) {
        // TODO Auto-generated method stub
        //从lastIndex处节点（最后一个节点）的父节点开始
        for(int i=(lastIndex-1)/2;i>=0;i--){
            //k保存正在判断的节点
            int k=i;
            //如果当前k节点的子节点存在
            while(k*2+1<=lastIndex){
                //k节点的左子节点的索引
                int biggerIndex=2*k+1;
                //如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在
                if(biggerIndex<lastIndex){
                    //若果右子节点的值较大
                    if(data[biggerIndex]<data[biggerIndex+1]){
                        //biggerIndex总是记录较大子节点的索引
                        biggerIndex++;
                    }
                }
                //如果k节点的值小于其较大的子节点的值
                if(data[k]<data[biggerIndex]){
                    //交换他们
                    swap(data,k,biggerIndex);
                    //将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值
                    k=biggerIndex;
                }else{
                    break;
                }
            }
        }
    }
    七、归并排序（Merge Sort），归并排序基本原来：归并排序采用递归算法，分治策略等方法排序。基本流程为分割，在子分割，子合并，大合并。整个流程就是分割和合并，采用递归算法实现。

   public static void mergeSort(int[] data) {  
          sort(data, 0, data.length - 1);  
      }  
    
      public static void sort(int[] data, int left, int right) {  
          if (left >= right)  
              return;  
          // 找出中间索引  
          int center = (left + right) / 2;  
          // 对左边数组进行递归  
          sort(data, left, center);  
          // 对右边数组进行递归  
          sort(data, center + 1, right);  
          // 合并  
          merge(data, left, center, right);  
           
      }  
      public static void merge(int[] data, int left, int center, int right) {  
          // 临时数组  
          int[] tmpArr = new int[data.length];  
          // 右数组第一个元素索引  
          int mid = center + 1;  
          // third 记录临时数组的索引  
          int third = left;  
          // 缓存左数组第一个元素的索引  
          int tmp = left;  
          while (left <= center && mid <= right) {  
              // 从两个数组中取出最小的放入临时数组  
              if (data[left] <= data[mid]) {  
                  tmpArr[third++] = data[left++];  
              } else {  
                  tmpArr[third++] = data[mid++];  
              }  
          }  
          // 剩余部分依次放入临时数组（实际上两个while只会执行其中一个）  
          while (mid <= right) {  
              tmpArr[third++] = data[mid++];  
          }  
          while (left <= center) {  
              tmpArr[third++] = data[left++];  
          }  
          // 将临时数组中的内容拷贝回原数组中  
          // （原left-right范围的内容被复制回原数组）  
          while (tmp <= right) {  
              data[tmp] = tmpArr[tmp++];  
          }  
      }  
    八、基数排序，基数排序的基本原理：基数排序就是从对数字的个位，十位，百位等待，进行装桶。具体过程先将个位装桶，然后组合，在讲十位装桶，然后组合，以此类推，知道组合完了，排序也就完了。

   //基于计数排序的基数排序算法  
      private static void radixSort(int[] array,int radix, int distance) {  
          //array为待排序数组  
          //radix，代表基数  
          //代表排序元素的位数  
            
          int length = array.length;  
          int[] temp = new int[length];//用于暂存元素  
          int[] count = new int[radix];//用于计数排序  
          int divide = 1;  
            
          for (int i = 0; i < distance; i++) {  
                
              System.arraycopy(array, 0,temp, 0, length);  
              Arrays.fill(count, 0);  
                
              for (int j = 0; j < length; j++) {  
                  int tempKey = (temp[j]/divide)%radix;  
                  count[tempKey]++;  
              }  
                
              for (int j = 1; j < radix; j++) {  
                  count [j] = count[j] + count[j-1];  
              }  
                
              //个人觉的运用计数排序实现计数排序的重点在下面这个方法              
              for (int j = length - 1; j >= 0; j--) {  
                  int tempKey = (temp[j]/divide)%radix;  
                  count[tempKey]--;  
                  array[count[tempKey]] = temp[j];  
              }  
                
              divide = divide * radix;                  
                
          }  
                    
      }