【数据结构——八大排序】（全方面总结）

1.插入排序

排序原理：

类似于我们手动排序扑克牌的方式，将每个元素插入到已排序部分的正确位置。对于部分有序的数据，插入排序性能较好。

性能分析

时间复杂度：平均情况为O(n^2)，
最好情况为O(n)，最坏情况也为O(n^2)。对于部分有序的数据，性能较好。
空间复杂度：O(1)，只需要常量级的额外空间。
稳定性：稳定。

 public static void insertSort(int []arr){
//直接插入排序 最坏n^2     n
        for (int i = 1; i < arr.length; i++) {
            int tmp=arr[i];
            int j = i-1;
            for ( ; j >=0; j--) {
                if(tmp<arr[j]){
                    arr[j+1]=arr[j];
                }else{
                    arr[j+1]=tmp;
                    break;
                }

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

2.希尔排序

排序原理：

是插入排序的一种改进，通过允许非相邻元素的交换来加快排序速度。
使用不同的增量序列进行多次插入排序，直到增量为1时进行一次普通的插入排序。

性能分析

时间复杂度：依赖于增量序列的选择，通常介于O(n)和O(n^2)之间。
空间复杂度：O(1)，只需要常量级的额外空间。
稳定性：不稳定。
适用场景：适用于需要较快排序速度且数据规模不是特别大的场景。

public static void shell2Sort(int []arr){
        int gap=arr.length;
        while(gap>1){
            gap/=2;
            shell(arr,gap);
        }
}
    public static void shell(int []arr,int gap) {
        for (int i = gap; i < arr.length; i++) {
            int tmp = arr[i];
            int j = i - gap;
            for (; j >= 0; j -= gap) {
                if (tmp < arr[j]) {
                    arr[j + gap] = arr[j];
                } else {
                    arr[j + gap] = tmp;
                    break;
                }

            }
            arr[j + gap] = tmp;
        }
    }}

3.选择排序

排序原理：

关键在于每次从未排序部分选择最小（或最大）的元素，然后将其放到已排序部分的末尾。通过减少搜索范围来优化性能。

性能分析

时间复杂度：O(n^2)，无论数据情况如何，时间复杂度都是平方级别的。
空间复杂度：O(1)，只需要常量级的额外空间。
稳定性：不稳定。

public static void selectSort(int[] array){
            for (int i = 0; i <array.length ; i++) {
                int minIndex=i;
                for (int j = i+1; j < array.length ; j++) {
                    if(array[j]<minIndex){
                        minIndex=j;
                    }
                } swap(array, i,minIndex);
            }
        }
            

private static void creatHeap(int[] array){
            for (int parent =(array.length-1-1)/2   ; parent >=0 ; parent--) {
           shiftDown(0,array.length);
            }
        }
        private static void shiftDown(int parent,int length){
            int child =2*parent+1;
            while  (child<length){
                if(child+1<length&&array[child]<array[child+1]){
                    child++;
                }
                if(array[child]>array[parent ]){
                    swap(array,child,parent);
                    parent=child;
                    child=2*parent+1;
                    else{
                        break;
                    }
                }
            }
        }

4.堆排序

排序原理：

利用堆这种数据结构进行排序。
首先将数组构建成一个最大堆（或最小堆），然后将堆顶元素与末尾元素交换，并重新调整堆结构。
重复这个过程，直到整个数组有序。

性能分析

时间复杂度：O(nlogn)，无论数据情况如何，时间复杂度都是对数级别的。
空间复杂度：O(1)，只需要常量级的额外空间。
稳定性：不稳定。

// 堆排序
public static void heapSort(int[] array){
            creatHeap(array);
            int end=array.length-1;
            while(end>0){
                swap(array,0,end);
                shiftDown(0,end);
                end--;
            }
        }

5.冒泡排序

排序原理：

重点在于相邻元素之间的比较和交换。
通过重复遍历数组，每次将最大（或最小）的元素“冒泡”到数组的末尾。

性能分析

时间复杂度：平均和最坏情况为O(n^2)，最好情况为O(n)。
空间复杂度：O(1)，只需要常量级的额外空间。
稳定性：稳定。

public static void bubbleSort(int[] array){
            for (int i = 0; i <array.length ; i++) {
                boolean flg=false;
                for (int j = 0; j <array.length-i ; j++) {
                    if(array[j]>array[j+1]){
                        swap(array,j,j+1);
                        flg=true;
                    }
                }
                if(!flg){
                    break;
                }
            }
        }

6.快速排序

排序原理：

通过选择一个“基准”元素，将数组分为两部分：小于基准的和大于基准的。
递归地对这两部分进行快速排序，直到整个数组有序。
关键在于选择合适的基准和避免最坏情况的发生。

性能分析

时间复杂度：平均情况为O(nlogn)，最坏情况为O(n^2)。通过优化可以避免最坏情况。
空间复杂度：递归实现时空间复杂度为O(logn)至O(n)，取决于递归深度。
稳定性：不稳定。

public static void quickSort(int[] array){
            quick(array,0,array.length-1);
        }
            private static void quick(int[] array,int start,int end){
                if(start>=end){
                    return ;
                }
                int pivot=partition(array,start,end){
                    quick(array,start,pivot-1);
                    quick(array,pivot+1,end);
                }
            private static int partitionHoare(int [] array,int left,int right){
                    int tmp=array[left];
                    int i=left;
                    while(left<right){
                        if(left<right&&array[right]>=tmp){
                            right--;
                        }
                        if(left<right&&array[left]<=tmp){
                            left++;
                    }
                        swap(array,left,right);
                }
                    swap(array,left,i);
                    return left;}

7.归并排序

排序原理：

采用分治策略，将数组分成两半，分别对每半进行排序，然后将两个有序数组合并成一个。
合并操作是归并排序的关键，需要确保合并后的数组仍然有序。

性能分析

时间复杂度：O(nlogn)，无论数据情况如何，时间复杂度都是对数级别的。
空间复杂度：O(n)，需要额外的空间来存储合并过程中的临时数组。
稳定性：稳定。

public static void mergeSortFun(int []array,int start,int end){
if(start>=end){
    return ;
}
int mid=(start+end)/2;
mergeSortFun(array,start,mid-1);
mergeSortFun(array,mid+1,end);
merge(array,start,end,mid);
    }
        private static void merge(int[]array,int mid,int left,int right){
            int s1=left;
            int e1=mid;
            int s2=mid+1;
            int e2=right;
            int[] tmpArr=new int[right-left+1];
            int k=0;
            if(s1<=e1&&s2<=e2){
                if(array[s1]<array[s2]){
                tmpArr[k++]=array[s1++];}

            else{tmpArr[k++]=array[s2++];}
            }
            
            while(s1<=e1){
          tmpArr[k++]=s1++;
            }
            while(s2<=e2){
                tmpArr[k++]=s2++;
            }
            for (int i = 0; i <tmpArr.length ; i++) {
                array[i+left]=tmpArr[i];
            }
        }

private static void  swap(int[] array,int i,int j){
            int tmp=array[i];
           array[i]=array[j];
            array[j]=tmp;

        }

8.计数排序

排序原理：

计数排序算法的原理是基于待排序的数列中各个数值的频数（即每个值出现的次数）来进行排序的。它并不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

性能分析

时间复杂度：依赖于数据的范围和分布，通常具有较好的性能。
空间复杂度：根据具体算法实现和数据分布，可能需要额外的空间。
稳定性：通常是稳定的排序算法。
适用场景：适用于特定类型的数据，如整数或浮点数，且需要高效排序的场景。

public class CountingSort {
    public static void countingSort(int[] arr) {
        if (arr == null || arr.length == 0) {
            return;
        }

        // 找出待排序数组中的最大值和最小值
        int max = arr[0];
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
            if (arr[i] < min) {
                min = arr[i];
            }
        }

        // 初始化计数数组
        int[] countArr = new int[max - min + 1];
        for (int i = 0; i < arr.length; i++) {
            countArr[arr[i] - min]++;
        }

        // 排序
        int index = 0;
        for (int i = 0; i < countArr.length; i++) {
            while (countArr[i] > 0) {
                arr[index++] = i + min;
                countArr[i]--;
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {4, 2, 2, 8, 3, 3, 1};
        countingSort(arr);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }
}