排序算法及性能-数据结构-java



package com.xjp.common_algorithm;

import java.util.ArrayList;
import java.util.List;

//******************************算法*****************************
/**
 * 分类： 1） 插入排序（直接插入排序、希尔排序）
 *    直接插入排序基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，
 *         现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。
 *    希尔排序基本思想：算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，
 *        每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小
 *        的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。
 *    2）交换排序（冒泡排序、快速排序）
 *    冒泡排序基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对
 *      相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。
 *               快速排序基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，
 *        将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其
 *        排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
 *    3）选择排序（直接选择排序、堆排序）
 *    直接选择排序基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；
 *      然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
 *                堆排序基本思想：具有n个元素的序列（h1,h2,...,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)时称之为堆。
 *       堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。
 *     4）归并排序
 *         归并排序基本思想：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。
 *       然后再把有序子序列合并为整体有序序列。
 *      5）分配排序（基数排序）
 *       基数排序基本思想：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。
 *        这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。
 *    不稳定：快速排序，希尔排序，堆排序。
 *    %%由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，
 *         相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以shell排序是不稳定的。
 *    %%希尔算法在最坏的情况下和平均情况下执行效率相差不是很多。
 *    %%专家们提倡，几乎任何排序工作在开始时都可以用希尔排序，若在实际使用中证明它不够快，再改成快速排序这样更高级的排序算法.
 *              本质上讲，希尔排序算法是直接插入排序算法的一种改进，减少了其复制的次数，速度要快很多。
 */
public class AllSort {
 public static void main(String[] args) {
  double a[]={11, 9, 8, 7, 5, 6, 4};  
  AllSort allsort=new AllSort();  
  allsort.insertSort(a);   //直接插入排序
  //allsort.shellSort(a);    //希尔排序  
  //allsort.bubbleSort(a);   //冒泡排序
  //allsort.quickSort(a);    //快速排序
  //allsort.selectSort(a);   //直接选择排序
  //allsort.heapSort(a);     //堆排序
  //allsort.mergingSort(a);  //归并排序
  //allsort.radixSort(a);    //基数排序
  //System.out.println(Math.ceil(1/2.0)+"  haha");
  for(int i=0;i<a.length;i++){
   System.out.println(a[i]);
  }
 }

 //1直接插入排序(说白了，就是不断地交换两个数的位置)
 public void insertSort(double a[]){
  double temp=0;
  for(int i=1;i<a.length;i++){
   int j=i-1;
   temp=a[i];//用第i个数，去与前面(i-1)个数比较
   for(;j>=0&&a[j]>temp;j--){
    a[j+1]=a[j];//将大于第i数的值整体后移一个单位    
   }
   a[j+1]=temp;//把第i个数交给第j个数
  }  
 }
 //2希尔排序（最小增量排序）
 public void shellSort(double a[]){
  double len=a.length;
  double temp=0;
  while(true){ //增量d减少到1时，停止
   len=Math.ceil(len/2.0); // len/2错误，应该是len/2.0
   int d=(int)len;//增量
   for(int k=0;k<d;k++){//分组，分为d组
    for(int i=k+d;i<a.length;i+=d){//直接插入排序,i=k+d表示是第k组的第2,3...个数
     int j=i-d;//j是在第i个数前面     
     temp=a[i];//i=k+d表示是第k组的第i个数,与前面i-1个数比较
     for(;j>=0&&a[j]>temp;j-=d){
      a[j+d]=a[j];//将大于第i数的值整体后移一个单位
     }
     a[j+d]=temp;
    }
   }
   if(d==1){
    break;
   }
  }
 }
 //3冒泡排序
 public void bubbleSort(double a[]){
  double temp=0;
  for(int i=0;i<a.length-1;i++){
   for(int j=0;j<a.length-1-i;j++){
    if(a[j]<a[j+1]){
     temp=a[j];
     a[j]=a[j+1];
     a[j+1]=temp;
    }
   }
  }
 }
 //4快速排序
 public void quickSort(double a[]){
  if(a.length>0){
   partSort(a,0,a.length-1);
  }
 }
 int getMiddle(double list[],int low,int high){
  double tmp =list[low]; //数组的第一个作为中轴
  while (low < high){
   while (low < high&& list[high] >= tmp) {
    high--;
   }
   list[low] =list[high]; //比中轴小的记录移到低端
   while (low < high&& list[low] <= tmp){
    low++;
   }
   list[high] =list[low]; //比中轴大的记录移到高端
  }
  list[low] = tmp; //中轴记录到尾
  return low; //返回中轴的位置
 }
 void partSort(double list[],int low,int high){
  if (low < high){
   int middle =getMiddle(list, low, high); //将list数组进行一分为二
   partSort(list, low, middle - 1); //对低字表进行递归排序
   partSort(list,middle + 1, high); //对高字表进行递归排序
  }
 }
 //5直接选择排序
 public void selectSort(double a[]){
  int position=0;
  for(int i=0;i<a.length;i++){
   int j=i+1;
   position=i;
   double temp=a[i];
   for(;j<a.length;j++){
    if(a[j]<temp){
     temp=a[j];
     position=j;
    }
   }
   a[position]=a[i];
   a[i]=temp;
  }
 }
 //6堆排序
 public void heapSort(double[] a){
  int arrayLength=a.length;
  for(int i=0;i<arrayLength-1;i++){ //循环建堆
   buildMaxHeap(a,arrayLength-1-i);
   swap(a,0,arrayLength-1-i);
  }
 }
 private void swap(double[] data,int i,int j){
  double temp=data[i];
  data[i]=data[j];
  data[j]=temp;
 }
 private void buildMaxHeap(double[] data,int lastIndex){
  //从lastIndex处节点（最后一个节点）的父节点开始
  for(int i=(lastIndex-1)/2;i>=0;i--){
   int k=i; //k保存正在判断的节点
   while(k*2+1<=lastIndex){ //如果当前k节点的子节点存在
    int biggerIndex=2*k+1; //k节点的左子节点的索引
    if(biggerIndex<lastIndex){ //如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在
     if(data[biggerIndex]<data[biggerIndex+1]){ //如果右子节点的值较大
      biggerIndex++; //biggerIndex总是记录较大子节点的索引
     }
    }
    if(data[k]<data[biggerIndex]){ //如果k节点的值小于较大的子节点的值
     swap(data,k,biggerIndex); //交换他们
     k=biggerIndex; //将biggerIndex赋予k，开始while下一次循环，重新保证k节点的值大于其左右字节点的值
    }else{
     break;
    }
   }
  }
 }
 //7归并排序
 public void mergingSort(double[] a){
  msort(a,0,a.length-1);
 }
 private void msort(double[] data,int left,int right){
  if(left<right){
   int center=(left+right)/2; //找出中间索引
   msort(data,left,center); //对左边数组进行递归
   msort(data,center+1,right); //对右边数组进行递归
   merge(data,left,center,right); //合并
  }
 }
 private void merge(double[] data,int left,int center,int right){
  double[] tempArr=new double[data.length];
  int mid=center+1;
  int third=left; //记录中间数组的索引
  int temp=left;
  while(left<=center&&mid<=right){
   if(data[left]<=data[mid]){ //从两个数组中取出最小的放入中间数组
    tempArr[third++]=data[left++];
   }else{
    tempArr[third++]=data[mid++];
   }
  }
  //剩余部分依次放入中间数组
  while(mid<=right){
   tempArr[third++]=data[mid++];
  }
  while(left<=center){
   tempArr[third++]=data[left++];
  }
  while(temp<=right){ //将中间数组中的内容复制回原数组
   data[temp]=tempArr[temp++];
  }
 }
 //8基数排序(正整数)
 public void radixSort(double[] a){
  rsort(a);
 }
 private void rsort(double[] array){
  //首先确定排序的趟数
  double max=array[0];
  for(int i=1;i<array.length;i++){
   if(array[i]>max){
    max=array[i];
   }
  }
  int time=0;
  while(max>0){ //判断位数
   max/=10;
   time++;
  }
  //建立10个队列
  List<ArrayList> queue=new ArrayList<ArrayList>();
  for(int i=0;i<10;i++){
   ArrayList<Double>queue1=new ArrayList<Double>();
   queue.add(queue1);
  }
  for(int i=0;i<time;i++){ //进行time次分配和收集
   for(int j=0;j<array.length;j++){ //分配数组元素
    //得到数字的第time+1位数
    int x=(int) (array[j]%(int)Math.pow(10,i+1)/(int)Math.pow(10, i));
    ArrayList<Double>queue2=queue.get(x);
    queue2.add(array[j]);
    queue.set(x, queue2);
   }
   int count=0; //元素计数器
   //收集队列元素
   for(int k=0;k<10;k++){
    while(queue.get(k).size()>0){
     ArrayList<Double>queue3=queue.get(k);
     array[count]=queue3.get(0);
     queue3.remove(0);
     count++;
    }
   }
  }
 }
};