码迷,mamicode.com
首页 > 编程语言 > 详细

九大排序算法Java实现

时间:2017-02-26 18:47:11      阅读:302      评论:0      收藏:0      [点我收藏+]

标签:堆排   包括   有序   改进   public   break   数据结构与算法   目标   停止   

之前学习数据结构与算法时花了三天时间整理九大排序算法,并采用Java语言来实现,今天第一次写博客,刚好可以把这些东西从总结的文档中拿出来与大家分享一下,同时作为自己以后的备忘录。   

1.排序算法时间复杂度、稳定性分类:

技术分享

技术分享

2.排序算法问题描述与实现

2.1冒泡排序(交换排序-稳定)

【问题描述】对于一个int数组,请编写一个冒泡排序算法,对数组元素排序。 
问题分析:冒泡排序,顾名思义,从前往后遍历,每次遍历在末尾固定一个最大值。

易错点:每次内层循环结束都会在末尾确定一个元素的位置,因此内层循环的判断条件要减去外层的循环次数i

public int[] BobbleSort(int[] array){ 

         for(int i=0;i<array.length-1;i++){  

            for(int j=0;j<array.length-1-i;j++){  //内层循环,注意array.length-1-i,一定要-i

                swap(array,j,j+1);//交换数据元素的方法

            }

         }

         return array;

      }

      public void swap(int[] array,int i,int j){//交换数据元素的方法

         if(array[i]>array[j]){

            int temp=array[i];

             array[i]=array[j];

             array[j]=temp;

         }

      }

冒泡排序的改进:加一个布尔型的flag,当某一趟冒泡排序没有元素交换时,则冒泡结束,元素已经有序,可以有效的减少冒泡次数。

 

2.2 选择排序(不稳定)

【问题描述】对于一个int数组,请编写一个选择排序算法,对数组元素排序。  
问题分析:选择排序,从前往后遍历,每次遍历从头开始依次选择最小的来排序。

注意点:

【初始升序】:交换0次,时间复杂度为o(n); 【初始降序】:交换n-1次,时间复杂度为o(n^2)。

【特点】:交换移动数据次数少,比较次数多。

   public int[] choose(int[] array){

      for(int i=0;i<array.length-1;i++){

         int min=i;

         for (int j = i+1; j < array.length; j++) {

            if(array[min]>array[j])

                min=j;

         }

         if(i!=min){

            swap(array,i,min);

         }

      }

      return array;

   }

  public void swap(int[] array,int i,int j){

      if(array[i]>array[j]){

         int temp=array[i];

          array[i]=array[j];

          array[j]=temp;

      }

   }

 

2.3 直接插入排序(稳定的 )

【问题描述】对于一个int数组,请编写一个插入排序算法,对数组元素排序。  
问题分析:插入排序,从前往后遍历,每次遍历确定一个元素的位置,下一个元素从后往前依次与排序好的元素比较,类似于摸扑克牌。

注意点:假定n是数组的长度,首先假设第一个元素被放置在正确的位置上,这样仅需从1-n-1范围内对剩余元素进行排序。对于每次遍历,从0-i-1范围内21.的元素已经被排好序,每次遍历的任务是:通过扫描前面已排序的子列表,将位置i处的元素定位到从0到i的子列表之内的正确的位置上。将arr[i]复制为一个名为target的临时元素。向下扫描列表,比较这个目标值target与arr[i-1]、arr[i-2]的大小,依次类推。这个比较过程在小于或等于目标值的第一个元素(arr[j])处停止,或者在列表开始处停止(j=0)。在arr[i]小于前面任何已排序元素时,后一个条件(j=0)为真,因此,这个元素会占用新排序子列表的第一个位置。在扫描期间,大于目标值target的每个元素都会向右滑动一个位置(arr[j]=arr[j-1])。一旦确定了正确位置j,目标值target(即原始的arr[i])就会被复制到这个位置。与选择排序不同的是,插入排序将数据向右滑动,并且不会执行交换。

   public int[] insert1(int[] array){

      for(int i=1;i<array.length;i++){

         int j=i;

         int temp=array[i];

         while(j>0&&array[j-1]>temp){

            array[j]=array[j-1];//元素右移

            j--;

         }

         array[j]=temp;

      }

      return array;

   }

 

2.4 希尔排序(2for循环+最后一个while,不稳定

问题描述:对于一个int数组,请编写一个希尔排序算法,对数组元素排序。  
问题分析:希尔排序是改进的插入排序,算法先将要排序的一组数按某个增量d(n/2,n为要排序数的个数)分成若干组,每组中记录的下标相差d.对每组中全部元素进行直接插入排序,然后再用一个较小的增量(d/2)对它进行分组,在每组中再进行直接插入排序。当增量减到1时,进行直接插入排序后,排序完成。希尔排序法(缩小增量法) 属于插入类排序,是将整个无序列分割成若干小的子序列分别进行插入排序的方法。

  • public int[] hillInsert(int[] array){
  •     for (int d = array.length>>1; d>=1; d=d>>1) {
  •        for(int i=d;i<array.length;i++){
  •           int j=i;
  •           int temp=array[i];
  •           while(j>=d&&array[j-d]>temp){
  •              array[j]=array[j-d];
  •              j-=d;
  •           }
  •           array[j]=temp;
  •        }
  •     }
  •     return array;
  • }

2.5.堆排序(不稳定)

 问题描述:对于一个int数组,请编写一个堆排序算法,对数组元素排序。  
问题分析:
堆数据结构是一种数组对象,它可以被视为一科完全二叉树结构(完全二叉树是由满二叉树而引出来的。对于深度为K的,有n个结点的二叉树,当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树)。它的特点是父节点的值大于(小于)两个子节点的值(分别称为大顶堆和小顶堆)。它常用于管理算法执行过程中的信息,应用场景包括堆排序优先队列等。

完全二叉树性质:如果i>1,则双亲是结点[i/2]。也就是说下标i与2i和2i+1是双亲子女关系。 当排序对象为数组时,下标从0开始,所以下标 i 与下标 2i+1和2i+2是双亲子女关系。

算法思路:

  • 堆排序:(大根堆)
  • ①将存放在array[0,...,n-1]中的n个元素建成初始堆;
  • ②将堆顶元素与堆底元素进行交换,则序列的最大值即已放到正确的位置;
  • ③但此时堆被破坏,将堆顶元素向下调整使其继续保持大根堆的性质,再重复第②③步,直到堆中仅剩下一个元素为止。
  • 堆排序算法的性能分析:
  • 空间复杂度:o(1);
  • 时间复杂度:建堆:o(n),每次调整o(log n),故最好、最坏、平均情况下:o(n*logn);
  • 稳定性:不稳定
  • public static int[] heapMax(int[] array){  //建立大根堆
  •     for(int i=(array.length-2)/2;i>=0;i--){
  •        buildHeap(array,i,array.length);
  •     }
  •     return array;
  • }
  • private static void buildHeap(int[] array, int k, int length) {  //建堆方法
  •     // TODO Auto-generated method stub
  •     int temp=array[k];
  •     for(int i=2*k+1;i<length-1;i=2*i+1){
  •        if(array[i]<array[i+1]){
  •           i++;
  •        }
  •        if(temp>=array[i])
  •           break;
  •        else{
  •           array[k]=array[i];
  •           k=i;
  •        }
  •     } 
  •        array[k]=temp;
  • }
  • public static int[] heapSortArray(int[] array){ //进行堆排序
  •      array=heapMax(array);  
  •     for (int i =array.length-1; i >0; i--) {
  •        int temp=array[0];   
  •        array[0]=array[i];
  •        array[i]=temp;
  •        buildHeap(array,0,i);
  •     }
  •     return array;
  • }

 

2.6 归并排序(稳定)

问题描述:对于一个int数组,请编写一个归并排序算法,对数组元素排序。 
问题分析:归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。首先考虑下如何将将二个有序数列合并。这个非常简单,只要从比较二个数列的第一个数,谁小就先取谁,取了后就在对应数列中删除这个数。然后再进行比较,如果有数列为空,那直接将另一个数列的数据依次取出即可。可以看出合并有序数列的效率是比较高的,可以达到O(n)。

解决了上面的合并有序数列问题,再来看归并排序,其的基本思路就是将数组分成二组A,B,如果这二组组内的数据都是有序的,那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了?

可以将A,B组各自再分成二组。依次类推,当分出来的小组只有一个数据时,可以认为这个小组组内已经达到了有序,然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列,再合并数列就完成了归并排序。

   public int[] mergeSort(int[] A, int n) {

          //归并排序,递归做法,分而治之

           mSort(A,0,n-1);

           return A;

       }

 

       private void mSort(int[] A,int left,int right){

    //分而治之,递归常用的思想,跳出递归的条件

    if(left>=right){

        return;

    }

    //中点

    int mid = (left+right)/2;

    //有点类似后序遍历!

    mSort(A,left,mid);

    mSort(A,mid+1,right);

    merge(A,left,mid,right);

}

//将左右俩组的按序子序列排列成按序序列

private void merge(int[] A,int left,int mid,int rightEnd){

    //充当tem数组的下标

    int record = left;

    //最后复制数组时使用

    int record2 = left;

    //右子序列的开始下标

    int m =mid+1;

    int[] tem = new int[A.length];

    //只要left>mid或是m>rightEnd,就跳出循环

    while(left<=mid&&m<=rightEnd){

        if(A[left]<=A[m]){

            tem[record++]=A[left++];

        }else{

            tem[record++]=A[m++];

        }

    }

    while(left<=mid){

        tem[record++]=A[left++];

    }

    while(m<=rightEnd){

        tem[record++]=A[m++];

    }

    //复制数组

    for( ;record2<=rightEnd;record2++){

        A[record2] = tem[record2];

    }

}

 

2.7 快速排序算法(不稳定)

问题描述:对于一个int数组,请编写一个快速排序算法,对数组元素排序。 
问题分析:快速排序(Quicksort)是对冒泡排序的一种改进,使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub-lists)。

从数列中挑出一个元素,称为”枢轴”(pivot)。重新排序数列,所有元素比枢轴值小的摆放在基准前面,所有元素比枢轴值大的摆在枢轴的后面(相同的数可以到任一边)。

在这个分区结束之后,该枢轴就处于数列的中间位置。这个称为分区(partition)操作。递归地(recursive)把小于枢轴值元素的子数列和大于枢轴值元素的子数列排序。

  • public static final void quickSort(int[] array, intstart, intend) {
  •        // i相当于助手1的位置,j相当于助手2的位置
  •        int i = start, j = end;
  •        int pivot = array[i]; // 取第1个元素为基准元素
  •        int emptyIndex = i; // 表示空位的位置索引,默认为被取出的基准元素的位置
  •        // 如果需要排序的元素个数不止1个,就进入快速排序(只要i和j不同,就表明至少有2个数组元素需要排序)
  •        while (i < j) {
  •          // 助手2开始从右向左一个个地查找小于基准元素的元素
  •          while (i < j && pivot <= array[j])
  •            j--;
  •          if (i < j) {
  •            // 如果助手2在遇到助手1之前就找到了对应的元素,就将该元素给助手1的"空位",j成了空位
  •            array[emptyIndex] = array[emptyIndex = j];
  •          }
  •           
  •          // 助手1开始从左向右一个个地查找大于基准元素的元素
  •          while (i < j && array[i] <= pivot)
  •            i++;
  •          if (i < j) {
  •            // 如果助手1在遇到助手2之前就找到了对应的元素,就将该元素给助手2的"空位",i成了空位
  •            array[emptyIndex] = array[emptyIndex = i];
  •          }
  •        }   
  •        // 助手1和助手2相遇后会停止循环,将最初取出的基准值给最后的空位
  •        array[emptyIndex] = pivot;
  •         
  •        // =====本轮快速排序完成=====
  •        // 如果分割点i左侧有2个以上的元素,递归调用继续对其进行快速排序
  •        if (i - start > 1) {
  •          quickSort(array, 0, i - 1);
  •        }
  •        // 如果分割点j右侧有2个以上的元素,递归调用继续对其进行快速排序
  •        if (end - j > 1) {
  •          quickSort(array, j + 1, end);
  •        }
  •      }

 

算法优化:选取基准轴点时采用三数取中法:

public class Quick {

   public void sort(int[] array){

      int start=0;

      int end=array.length-1;

      quickSort(array,start,end);

   }

   public void quickSort(int[] array, int start, int end) {

      // TODO Auto-generated method stub

      int i=start;

      int j=end;

      int emptyIndex=start;

      int pivot=middle3(array,start,end);

      while(i<j){

         while(i<j&&array[j]>=pivot){

            j--;

         }

         if(i<j)

            array[emptyIndex]=array[emptyIndex=j];

         while(i<j&&array[i]<=pivot){

            i++;

         }

         if(i<j)

            array[emptyIndex]=array[emptyIndex=i];

      }

      array[emptyIndex]=pivot;

     

      if(i-start>1)

         quickSort(array,start,i-1);

      if(end-j>1)

         quickSort(array,j+1,end);

   }

 

2.8 计数排序算法(稳定,也是桶排序)

问题描述:对于一个int数组,请编写一个计数排序算法,对数组元素排序。 
问题分析:

1. 提前必须是已知待排序的关键字为整型且范围已知。 
2. 时间复杂度为O(n+k),n指的是桶的个数,k指的是待排序数组的长度,不是基于比较的排序算法,因此效率非常之高。 
3. 稳定性好,这个是计数排序非常重要的特性,可以用在后面介绍的基数排序中。 
4. 但需要一些辅助数组,如C[0..k],因此待排序的关键字范围0~k不宜过大。

    public int[] countingSort(int[] A, int n) {

        if(A==null ||n<2){

            return A;

        }

        //找出桶的范围,即通过要排序的数组的最大最小值来确定桶范围

        int min=A[0];

        int max=A[0];

        for(int i=0;i<n;i++){

            min=Math.min(A[i],min);

            max=Math.max(A[i],max);

        }

        //确定桶数组,桶的下标即为需排序数组的值,桶的值为序排序数同一组值出现的次数

        int[] arr = new int[max-min+1];

        //往桶里分配元素

        for(int i=0;i<n;i++){

            arr[A[i]-min]++;

        }

        //从桶中取出元素

        int index=0;

        for(int i=0;i<arr.length;i++){

            while(arr[i]-->0){

                A[index++]=i+min;

            }

        }

        return A;

    }

}

 

2.9 基数排序算法(稳定)

问题描述:对于一个int数组,请编写一个基数排序算法,对数组元素排序。 
问题分析:

基数排序(Radix sort)是一种非比较型整数排序算法,其原理是将整数按位数切割成不同的数字,然后按每个位数分别比较。由于整数也可以表达字符串(比如名字或日期)和特定格式的浮点数,所以基数排序也不是只能使用于整数。将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零。然后,从最低位开始,依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

键字范围0~k不宜过大。

public void sort(int[] array){

      int max=0;

      int d=0;// 位数

      for (int i = 0; i < array.length; i++) {

         max=Math.max(max, array[i]);

      }

      while(max>0){

         max/=10;

         d++;

      }

      int t=0;

      int m=1;

      int n=1;

      int[][] temp=new int[10][array.length];

      int[] order=new int[10];

      while(m<=d){

         for (int i = 0; i < array.length; i++) {

                int k=((array[i]/n)%10);

                temp[k][order[k]++]=array[i];

            }

        

         for (int i = 0; i < 10; i++) {

            if(order[i]!=0){

                for (int j = 0; j <order[i]; j++) {

                   array[t++]=temp[i][j];

                }

                order[i]=0;

            }

         }

         t=0;

         n=n*10;

         m++;

      }

   }

 

九大排序算法Java实现

标签:堆排   包括   有序   改进   public   break   数据结构与算法   目标   停止   

原文地址:http://www.cnblogs.com/jetHu/p/6445060.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!