java版常用排序算法

一.简单排序
1.冒泡排序:
冒泡排序是一种简单的排序算法，它的基本思想是比较相邻的元素并交换位置，从而将较大的元素“冒泡”到数列的末尾，而较小的元素则会沉到数列的开头。该算法的时间复杂度为O(n^2),不适合处理大规模的数据。

     
   public void  maoPao(int [] arrays){
        for (int i = arrays.length-1; i >0 ; i--) {
            for (int j = 0; j < i; j++) {
                int first = arrays[j];
                int two = arrays[j + 1];
                if(first>two){
                    arrays[j]=two;
                    arrays[j+1]=first;
                }
            }
        }
    }

2.选择排序:
选择排序是一种简单的排序算法，其基本思想是每次从未排序的数据中选择最小（或最大）的元素，放到已排序序列的末尾，直到全部排序完毕。该算法的时间复杂度为O(n^2)，不适合处理大规模的数据。

 public void xunZe(int [] arrays){
        for (int i = 0; i < arrays.length-1; i++) {
            int minIndex=i;
            int min = arrays[i];
            for (int j = i+1; j < arrays.length; j++) {
                int two = arrays[j];
                //正序
                if(min>two){
                    minIndex=j;
                    min=two;
                }
            }
            int temp=arrays[i];
            arrays[i]=min;
            arrays[minIndex]=temp;
        }
    }

3.插入排序:
插入排序是一种简单的排序算法，其基本思想是将待排序的数据分为已排序和未排序两个部分，初始时已排序部分只包含第一个元素，然后从未排序部分依次取出元素，插入到已排序部分的适当位置，直到全部排序完毕。该算法的时间复杂度为O(n^2)，不适合处理大规模的数据。

public void chaRu(int [] arrays) {
        for (int i = 1; i < arrays.length; i++) {
            for (int i1 = i; i1 >0; i1--) {
                int first = arrays[i1];
                int two = arrays[i1 - 1];
                if(first<two){
                    arrays[i1 - 1]=first;
                    arrays[i1]=two;
                }else {
                    break;
                }
            }
        }
    }

二.高级排序
希尔排序:
希尔排序是插入排序的一种改进版本，也称为“缩小增量排序”。它通过将待排序的序列划分成多个子序列来提高插入排序的效率，每个子序列的元素是互相间隔固定的，然后对每个子序列进行插入排序，最终合并成一个完整的有序序列。
希尔排序的时间复杂度取决于选择的增量序列，通常使用的增量序列是Shell提出的序列：n/2, n/4, …, 1。该算法的时间复杂度为O(n^{2)，但实际运行效率比其他O(n}2)算法要高。

 public void xiRe(int[] a) {
        int n = a.length;
        int h = 1;
        //获取希尔排序得增量初始值
        while (h < n / 2) {
            h = h * 2 + 1;
        }
        xiReSort(a, h, n);
 }
public void xiReSort(int[] a, int h, int len) {
        while (h > 0) {
            for (int i = h; i < len; i++) {
                int temp = a[i];
                int j = i;
                while (j >= h && a[j - h] > temp) {
                    a[j] = a[j - h];
                    j -= h;
                }
                a[j] = temp;
            }
            h = h / 2;
        }
    }

归并排序:
归并排序是一种基于分治思想的排序算法，其基本思想是将待排序的数组分成若干个子数组，然后将每个子数组排序，最后将已排序的子数组合并成一个完整的数组。时间复杂度为O(nlogn)
具体步骤如下：
1.分割：将待排序的数组按照二分法原则分成左右两个子数组，直到每个子数组只剩下一个元素为止。
2.合并：对于两个已经排好序的子数组，将它们合并成一个有序的数组。
3.重复：对于每个子数组，递归地执行步骤1和步骤2，直到所有的子数组都排好序为止。

 public void guiBing(int[] array) {
        guiBingSort(array, 0, array.length - 1);
 }
    
 public void guiBingSort(int[] array, int lo, int hi) {
        if (hi <= lo) {
            return;
        }
        int mid = (lo + hi) / 2;
        guiBingSort(array, lo, mid);
        guiBingSort(array, mid + 1, hi);
        guiBingMerge(array, lo, mid, hi);
 }
  
private void guiBingMerge(int[] array, int lo, int mid, int hi) {
        //定义三个指针
        int left = lo, right = mid + 1, temp = 0;
        int[] tempArray = new int[hi - lo + 1];
        //合并数据左右数组
        while (left <= mid && right <= hi) {
            //拿出左边元素
            int leArray = array[left];
            //拿出右边元素
            int riArray = array[right];
            if (leArray < riArray) {
                tempArray[temp++] = array[left++];
            } else {
                tempArray[temp++] = array[right++];
            }
        }
        
        //如果右子数组没有数据 子数组又数据
        while (left <= mid) {
            tempArray[temp++] = array[left++];
        }
        //如果左子数组没有数据 右子数组又数据
        while (right <= hi) {
            tempArray[temp++] = array[right++];
        }
        //替换原数组数据
        int index = lo;
        int i = 0;
        while (index <= hi) {
            array[index++] = tempArray[i++];
        }
 }  

快速排序:
快速排序（QuickSort）是一种基于比较的排序算法，它采用分治的思想，将一个大的问题分成两个小的问题，然后将这些小问题递归地解决。具体而言，快速排序的算法流程如下：
选择一个基准元素（pivot），通常选择数组的第一个元素或最后一个元素。
将数组中小于基准元素的数移到基准元素的左边，将大于基准元素的数移到基准元素的右边。
对基准元素左右两个子数组重复步骤1和步骤2，直到子数组的大小为1或0。
由于快速排序采用分治的思想，它的时间复杂度为O(nlogn)。在实际应用中，快速排序是一种高效的排序算法，尤其是对于大规模的数据集合。

 public void kuaiPai(int[] array) {
      kuaiPaiSort(array, 0, array.length - 1);
 }

 public void kuaiPaiSort(int[] array, int low, int hi) {
        if (low >= hi) {
            return;
        }
        int i = kauiPaiPartition(array, low, hi);
        //左边
        kuaiPaiSort(array, low, i - 1);
        //右边
        kuaiPaiSort(array, i + 1, hi);
    }

 public void int kauiPaiPartition(int[] array, int low, int hi) {
        //最小得未分治分割点
        int key = array[low];
        int left = low + 1, height = hi;
        while (left < height) {
            if (array[left] < key) {
                left++;
            } else if (array[height] > key) {
                height--;
            } else {
                swap(array, left, height);
            }
        }
        swap(array, left, low);
        return left;
    }
    
public void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }