Java 常用排序算法实现--快速排序、插入排序、选择、冒泡

public   class  ArrayOperation {

     // 二分查找算法
     public   static   int  branchSearch( int [] array,  int  searchNum) {
         if  (array  ==   null )
             throw   new  NullPointerException( " Null Referrence " );
         if  (array.length  ==   0 )
             throw   new  IllegalArgumentException( " Array Length is Zero " );
         int  low  =   0 , high  =  array.length;
         int  middle  =  (high  +  low)  /   2 ;
         int  index  =   - 1 ;
         if  (searchNum  <  array[ 0 ]  ||  searchNum  >  array[array.length  -   1 ])
             return  index;
         while  (middle  >=   0 ) {
             if  (array[middle]  ==  searchNum) {
                index  =  middle;
                 break ;
            }
             if  (searchNum  >  array[middle]) {
                low  =  middle;
            }  else  {
                high  =  middle;
            }
            middle  =  (low  +  high)  /   2 ;
        }

         return  index;

    }

     //  快速排序
    
     public   static   void  quickSort( int  a[],  int  left,  int  right) {
         int  i, j, temp;
        i  =  left;
        j  =  right;
         if  (left  >  right)
             return ;
        temp  =  a[left];
         while  (i  !=  j) /*  找到最终位置  */
        {
             while  (a[j]  >=  temp  &&  j  >  i)
                j -- ;
             if  (j  >  i)
                a[i ++ ]  =  a[j];
             while  (a[i]  <=  temp  &&  j  >  i)
                i ++ ;
             if  (j  >  i)
                a[j -- ]  =  a[i];

        }
        a[i]  =  temp;
        quickSort(a, left, i  -   1 ); /*  递归左边  */
        quickSort(a, i  +   1 , right); /*  递归右边  */
    }

     //  插入排序
     //  特点：用temp保存将要排序的临时值，然后把大的值插入到这个位置。
     public   static   int [] insert_Sort( int [] array) {
         int  i, j, temp;
         for  (i  =   1 ; i  <  array.length; i ++ ) {
             for  (j  =  i, temp  =  array[i]; j  >   0   &&  temp  <  array[j  -   1 ]; j -- )
                array[j]  =  array[j  -   1 ];
            array[j]  =  temp;
        }
         return  array;
    }

     //  冒泡排序
     //  特点：从第一个元素开始，如果需要交换，就一直冒泡到底，如果不需要交换，就从下一个元素开始比较
     public   void  bubble_Sort( int [] array,  int  size) {
         int  i, j, temp;
         for  (i  =  size  -   1 ; i  >   1 ; i -- )
             for  (j  =   0 ; j  <  i; j ++ )
                 if  (array[j]  >  array[j  +   1 ]) {
                    temp  =  array[j  +   1 ];
                    array[j  +   1 ]  =  array[j];
                    array[j]  =  temp;
                }
    }

     //  交换排序
     //  特点：始终是第一个元素与其他元素一一比较，交互后，继续用第一个元素与后面元素一一比较，重复下去。
     public   int [] change_Sort( int [] array,  int  size) {
         int  i, j, temp;
         for  (i  =   0 ; i  <  size; i ++ )
             for  (j  =  i  +   1 ; j  <  size; j ++ )
                 if  (array[i]  >  array[j]) {
                    temp  =  array[j];
                    array[j]  =  array[i];
                    array[i]  =  temp;
                }
         return  array;
    }

     //  选择排序一（便于区分：咱就叫：选择最小值排序法）
     //  特点：分有序区（第一个元素）和无序区（除第一元素外的元素），从无序区找出最小的元素移动到有序区
     public   void  SelectSort( int [] array) {
         int  i, j, k; //  分别为有序区，无序区，无序区最小元素指针
         for  (i  =   0 ; i  <  array.length; i ++ ) {
            k  =  i;
             for  (j  =  i  +   1 ; j  <  array.length; j ++ ) {
                 if  (array[j]  <  array[k])
                    k  =  j;
            }
             if  (k  !=  i) //  若发现最小元素，则移动到有序区
            {
                 int  temp  =  array[k];
                array[k]  =  array[i];
                array[i]  =  array[temp];
            }
        }
    }

     //  选择排序二
     public   int [] select_Sort( int [] array,  int  size) {
         int  i, j, temp, pos;
         for  (i  =   0 ; i  <  size; i ++ ) {
             for  (j  =  i  +   1 , temp  =  array[i], pos  =  i; j  <  size; j ++ )
                 if  (temp  >  array[j]) {
                    temp  =  array[j];
                    pos  =  j;
                }
            array[pos]  =  array[i];
            array[i]  =  temp;
        }

         return  array;
    }

     // 希尔排序
     //     属于插入类排序,是将整个无序列分割成若干小的子序列分别进行插入排序
     //   排序过程：先取一个正整数d1<n，把所有序号相隔d1的数组元素放一组，组内进行直接插入排序；
     //   然后取d2<d1，重复上述分组和排序操作；直至di=1，即所有记录放进一个组中排序为止 
     public   static   void  ShellSort( int [] array) {
         int  length  =  array.length;
         for  ( int  h  =  length  /   2 ; h  >   0 ; h  =  h  /   2 ) {
             //  here is insert sort
             for  ( int  i  =  h; i  <  length; i ++ ) {
                 int  temp  =  array[i];
                 if  (temp  <  array[i  -  h]) {
                     for  ( int  j  =   0 ; j  <  i; j  +=  h) {
                         if  (temp  <  array[j]) {
                            temp  =  array[j];
                            array[j]  =  array[i];
                            array[i]  =  temp;
                        }
                    }
                }
            }
        }
    }
}

转载于:https://www.cnblogs.com/hubcarl/archive/2011/04/07/2007823.html