排序算法整理

冒泡排序

//bubble sort

     public static void bubbleSort(int[] array, int n){

        int i = 0;// loop

        int j = 0; // element index

        while(i < n) {

           for(j=0; j<n-i-1; j++){

              if( array[j] > array[j+1] ){ //swap condition

                 swap( array, j, j +1 );

               }

           }

           i++;

        }

     }

快速排序

//quick sort

    public static void quickSort(int[] array, int lo, int hi){

        if(lo>hi) return;

        int pivot = array[lo]; 

        int i = lo;

        int j = hi;

        while( i<j ){

            //get smaller after pivot 

            //warning: while condition, here and next while

            //at least one item is >=

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

                j--;

            }

            array[i] = array[j]; //so at j an element is void

            //get bigger before pivot

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

                i++;

            }

            array[j] = array[i]; // at i an element is to fill at j

        }

        //here, i bumps into j

        array[i] = pivot;

        //here, before index i smaller than pivot, after bigger than pivot

        // lo~i quick sort

        quickSort(array, lo, i-1);  

        // i+1~hi quick sort

        quickSort(array, i+1, hi); 

     }

直接选择排序

//direct select sort

    public static void selectSort(int[] array, int n){

        int i=0; //sorted last element

        int j=0; //unsorted first element

        while(i<n){

            int min=array[i];

            int index = i;

            for(j=i+1; j<n;j++){

                if(array[j]<min){

                    min = array[j];

                    index = j;

                }

            }

            swap(array,i,index);

            i++;

        }

    }

堆排序

 //heap sort

        public static void heapSort(int[] array, int n){    

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

                buildHeap(array, n, i);

            int len = n - 1;

            while (len > 0) {           

                swap(array, 0, len);

                buildHeap(array, len, 0);

                len--;

            }

        }

        private static void buildHeap(int[] array, int n, int i){

            for (; left(i) < n; i = left(i)) {

                int bigger =

                    right(i) < n ? max(array, left(i), right(i)) : left(i);

                if (array[bigger] > array[i]) //swap

                    swap(array, bigger, i);

                else break;

            }

        }



    private static int left(int i){

        return 2*i+1;

    }

    private static int right(int i){

        return 2*i+2;

    }

    private static int max(int[] array, int i, int j){

        return array[i]>array[j]? i:j;

    }

直接插入排序

// insert sort

    public static void insertSort(int[] array, int n){

       int i = 1; //unsorted first index

       while (i < n) {

        int j = i - 1; //sorted last index

        int insert = array[i]; //warning: label array[i]

        while (j > 0 && insert < array[j]){                

            array[j + 1] = array[j];

            j--;

         }               

        array[j + 1] = insert; //j+1 is insert pos

        i++;

       }

    }

希尔排序

//shell Sort

     public static void shellSort(int[] array, int n, int group){

        if (group > n) return;

        int d = n / group; //d: number for each group

        while (d > 0){

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

                 int j = i; // number index

                 int k = 1; //distance index

                 while (j < n){

                        int insert = array[j]; //label unsorted first

                        j -= d; //sorted last index

                        while (j > 0 && insert < array[j]){

                            array[j + d] = array[j];

                            j -= d;

                        }

                   array[j + d] = insert; //insert pos: j+d

                   j = i + (++k) * d; //next number index

                }

           }

          d /= 2;

        }

     }   

归并排序

//merge sort

public static void mergeSort(int[] array, int n){

            var sorted = new int[n];

            mergeSort(array,sorted,0,n-1);

  }



 private static void mergeSort(int[] array, int[] sorted, int lo, int hi){

            if (lo < hi){

                int mid = lo + (hi - lo) / 2;

                mergeSort(array, sorted,lo, mid);

                mergeSort(array, sorted, mid + 1, hi);

                merge(array, sorted, lo, mid, hi);

            }

   }

        //beg: part1 beginning index

        //mid: part1 end index

        //mid+1: part2 beginning index

        //end: part2 end index

   private static void merge(int[] array, int[] sorted, int beg, int mid, int end){

            int i = beg; //part1 index

            int j = mid + 1; //part2 index

            int k = 0; //merged index

            while (i <= mid && j <= end)

                sorted[k++] = 

                    array[i] <= array[j] ? array[i++] : array[j++];                

            while (i <= mid)

                sorted[k++] = array[i++];

            while (j <= end)

                sorted[k++] = array[j++];

            for (i = 0; i < k; i++)

                array[beg + i] = sorted[i]; 

     }