几种常见的排序算法（java实现）

/**

 *

 * 各种排序算法

 *1、排序：直接插入排序

 * --依次将每个元素插入到前面已经排好的序列当中

 *2、排序：冒泡排序

 * --从列表的第一个数（0）字到倒数第二个（i=n-2）{i--}数字，逐个检查，

 *   若某一位上的数字大于他的下一位，则交换

 *3、排序：选择排序

 * --每次都在未排序的序列中选取一个最小或者最大的元素，放在最终的位置

 *4、排序：折半插入排序

 * --直接插入法的改进，通过二分搜索的方式找出需要插入的位置，在将后面的

 *   元素全部向后移动一位

 *5、排序：shell排序

 * --以n/2的步长分组直接插入排序，逐步减少步长，直到步长为1

 *6、排序：快速排序

 * --a.递归实现

 * --b.非递归实现

 *7、归并排序

 * --利用分治的思想

 *8、堆排序

 * --将数组转化为二叉树，在转化为堆。

 */

 

package Paixu;

public class Paixu {

    /**

     * @param args

     */

    public static void main(String[] args) {

       // TODO Auto-generatedmethod stub

     int arr[]={5,4,3,2,1};

     int arr1[]=new int[5];

 

       //直接插入排序

         Zhijie  zhijie=new Zhijie();

         zhijie.zhijie(arr);

       //冒泡排序

         Maopao mp=new Maopao();

         mp.maopao(arr);

       // 选择排序

         Xuanze xz=new Xuanze();

        xz.xuanze(arr);

       //快速排序法

         quicksort  qs=new quicksort();

         qs.data=arr;

         qs.sort(0, arr.length-1);

         qs.display();

       //归并排序

         guibing   gb=new guibing();

         gb.mergesort(arr, 0,arr.length-1, arr1);

       //堆排序

         Dui  dui=new Dui();

         dui.Sort(arr);

       //折半插入排序法

         Charu_youhua  cry=new Charu_youhua();

        cry.binaryInsertSort(arr);

       //shell排序

         Shell_Sort ss=new Shell_Sort();

     ss.ShellSort(arr);

    }

}

 

//直接插入排序方法

class  Zhijie{

    public void zhijie(int arr[]){

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

           //判断这个元素是否需要交换

           int exchange=arr[i];

          

           for (int j =i-1; j >=0; j--) {

             

              if(exchange<arr[j]){

                 

                  arr[j+1]=arr[j];

              }

              arr[j]=exchange;

           }

       }

    }

}

 

//冒泡排序

class  Maopao{

       public void maopao(int arr[]){

          //外层，定义需要多少躺比较

          int tmp=0;

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

          

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

                if(arr[j]>arr[j+1]){

                   tmp=arr[j+1];

                   arr[j+1]=arr[j];

                    arr[j]=tmp;

                } 

           }

       }

       }

}

 

//选择排序

class  Xuanze{

   

      public void xuanze(int arr[]){

         //定义需要寻找多少次

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

          

             int minIndex=i;

             int tmp=0;

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

                while(arr[minIndex]>arr[j]){

                    minIndex=j;

                }

            tmp=arr[i];

           arr[i]=arr[minIndex];

            arr[minIndex]=tmp;

             }

       }

      }

}

//折半插入排序

 

class  Charu_youhua{

   

    public void binaryInsertSort(int[] array){

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

           int temp = array[i];

           int low = 0;

           int high = i - 1;

          

           while(low <= high){

             int mid = (low + high)/ 2;

              if(temp < array[mid]){

                  high = mid -1;

                 }else{

                  low = mid +1;

                 }

            }

       for(int j = i; j >= low + 1; j--){

           array[j] = array[j -1];

          }

           array[low] = temp;

       }

    }

}

 

//shell排序

class  Shell_Sort{

       public void ShellSort(int[] array) { 

           int k=array.length/2;

           //如果分组长度小于1时，结束循环

             while(k>=1){

                 int j=0;

                 while(true){

                      //对各个分组进行插入排序

                      for(int i=j;i<array.length;i=i+k){ //j=0时分组1 排序  j=1时分组2排序

                          int temp = array[i];

                          int t=i-k;

                          //查找适当位置,进行插入数据

                          while(t>=0&&array[t]>temp){

                          array[t+k]=array[t];

                          t=t-k;

                          }

                         array[t+k]=temp;

                      }

                        j++;

                      //j%k==0表明起始元素前面第一次已经出现过.

                      if(j%k==0) //列表只能有k个分组

                       break;

                 }

                k--;//分组的密度越来越细

             }

             //return ;

     }

}

 

//快速排序

class quicksort

{

    public int data[];

    

    private int partition(int sortArray[],int low,int hight)

    {

        int key = sortArray[low];

        

        while(low<hight)

        {

            while(low<hight &&sortArray[hight]>=key)

                hight--;

            sortArray[low] = sortArray[hight];

            

            while(low<hight && sortArray[low]<=key)

                low++;

            sortArray[hight] = sortArray[low];

        }

        sortArray[low] = key;

        return low;

    }

    

    public void sort(int low,int hight)

    {

        if(low<hight)

        {

            int result = partition(data,low,hight);

            sort(low,result-1);

            sort(result+1,hight);

        }

    }

    public void display()

    {

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

        {

            System.out.print(data[i]);

            System.out.print(" ");

        }

    }

}

 

//归并排序

class  guibing{

    public  int[] mergesort(int[] num, int s, int t, int[] num1) {

 

         int m;

         int[] num2 = new int[t + 1];

         if (s == t)

          num1[s] = num[s];

 

         else {

          m = (s + t) / 2;

          mergesort(num, s, m,num2);//左半部分递归调用

          mergesort(num, m + 1,t, num2);//右半部分递归调用

          merg(num2, s, m, t,num1);// 由num2去归并，返回的值放到num1中,num1赋新值，其实就是更新num2,然后让num2再去归并，返回新的num1

         }

         return num1;

        }

       //有序表的合并

        public  void merg(int[] num, int l, int m, int n, int[] num1) {

         System.out.print("l=" + l + " m=" + m + " n=" + n);

         System.out.println();

         int i, j, k;

         i = l;

         j = m + 1;

         k = l;

         while (i <= m&& j <= n) {

          if (num[i] <num[j])

           num1[k++] =num[i++];

          else {

           num1[k++] =num[j++];

          }

         }

 

         while (i <= m) {

          num1[k++] = num[i++];

         }

         while (j <= n) {

          num1[k++] = num[j++];

         }

 

        }

}

//堆排序

 

class  Dui{

      public void Sort(int[] arr){

         int n=arr.length;

         int tmp=0;

         for (int i = n/2; i>0;i--) {

              Adjust(arr,i-1,n);

         }

         for (int i =n-2 ; i >=0;i--) {

             tmp=arr[i+1];

             arr[i+1]=arr[0];

             arr[0]=tmp;

             Adjust(arr,0,i+1);

           }

      }

      public  void Adjust(int[] arr,int i, int n){

         int j=0;

         int tmp=0;

         tmp=arr[i];

         j=2*i+1;

         while(j<=n-1){

             if(j<n-1&&arr[j]<arr[j+1]){

                j++;}

               if (tmp>=arr[j]) {

                  break;}

               arr[(j-1)/2]=arr[j];

                j=2*j+1;

         }

         arr[(j-1)/2]=tmp;

      }

}