【Java·数据结构】七大排序及其思想

最新推荐文章于 2023-06-10 22:29:03 发布

LXL7868

最新推荐文章于 2023-06-10 22:29:03 发布

阅读量901

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/LXL7868/article/details/99685639

版权

JAVA 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

本文详细介绍了排序算法中的直接插入排序、希尔排序、冒泡排序、快速排序、直接选择排序、堆排序和归并排序，包括它们的基本思想、时间空间复杂度、稳定性以及代码示例。对于每种排序算法，都提供了相应的排序过程图解，帮助读者更好地理解和掌握这些经典排序方法。

摘要由CSDN通过智能技术生成

文章目录

排序时间空间复杂度表

\	平均时间复杂度	最坏时间复杂度	最好时间复杂度	空间复杂度	稳定性
直接插入排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定
希尔排序	O(nlogn)	O(nlogn)	O(n^1.3)	O(1)	不稳定
冒泡排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定
快速排序	O(nlogn)	O(n^2)	O(nlogn)	O(nlogn)	不稳定
直接选择排序	O(n^2)	O(n^2)	O(n^2)	O(1）	不稳定
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	不稳定
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O（n）	稳定

一、直接插入排序

思路：
当插入第 i (i>=1) 个元素时，前面的 array[0] , array[1] , … , array[i-1] 已经排好序，此时用array[i] 的排序码与 array[i-1] , array[i-2] , … 的排序码顺序进行比较，找到插入位置即将 array[i] 插入，原来位置上的元素顺序后移
图解：
代码:

 public static void insertSort(int[] array){
        int temp = 0;
        for (int i = 1; i < array.length; i++) {
            temp = array[i];
            int j = 0;
            for (j = i-1; j >= 0 ; j--) {
                if (array[j] > temp){
                    array[j + 1] = array[j];
                }
                else {
                    break;
                }
            }
           array[j + 1] = temp;
        }
    }

直接插入排序的特性总结：

元素集合越接近有序，直接插入排序算法的时间效率越高
时间复杂度：O(N^2)
空间复杂度：O(1)，它是一种稳定的排序算法
稳定性：稳定

二、希尔排序

思路：
先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
图解：
代码：

public  static void shell(int[] array,int gap) {
        int j = 0;
        int temp = 0;
        for (int i = gap; i < array.length ; i+=gap) {
 		temp= array[i];
            for (j = i - gap; j >= 0; j -= gap) {
                if (array[j] > temp) {
                    array[j + gap] = array[j];
                } else {
                    break;
                }
            }
            array[j + gap] = temp;
        }
    }
    public  static void shellSort(int[] array) {
        int[] arr = {5, 3, 1};
        for (int i = 0; i < arr.length; i++) {
            shell(array, arr[i]);
        }
    }

希尔排序是对直接插入排序的优化。
当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。
希尔排序的时间复杂度不好计算，需要进行推导，推导出来平均时间复杂度 O(N^1.3—N2）
稳定性：不稳定

三、冒泡排序

思路：从第一个数开始和后一个比较，如果前一个数大于后一个数，交换前后次序，重复以上操作直到有序为止（其中每一趟都可以找到当前参与交换的（n-i）个数中最大值并沉底）
图解：
代码：

public static void bubbleSort(int[] arr,int n) {
	for(int i = 0 ; i < n  ; i++ ) {
	int tmp = arr[i];
		for(int j = 1 ; j < n ; j++){
		if(arr[i] > arr[j]){
		arr[i] = arr[j];
		arr[j] = tmp;
		}
}

冒泡排序的特性总结：

冒泡排序是一种非常容易理解的排序
时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：稳定

四、快速排序

思想：
1）快排递归：先把数组组中的一个数作为基数，一般为左边第一个数，然后从两边检索，先从右边检索比基数小的，再从左边检索比基数大的，如果检索到了，就停下，然后交换这两个元素，然后再继续检索。
2）快排非递归：递归是使用编译器自动用栈来实现，容易造成栈溢出，非递归可以使用栈模拟递归过程，我们每一次从栈顶取出一部分划分之后，再把两部分的起始位置分别入栈。
3）快排优化：使用三数取中法，其中小部分排序可以考虑直接插入排序
代码：
1）快排递归

public int portion1(int[] arr,int left,int right){
    int tmp = arr[left];
    while (left < right){
        while (left < right && arr[right] >= tmp){
            --right;
            }
            arr[left] = arr[right];
 while (left < right && arr[left] <= tmp){
            ++left;
            }
            arr[right] = arr[left];
    }
    arr[left] = tmp;
    return left;
}
public  void quickSort1(int[] arr,int start,int end){
    int par = portion1(arr,start,end);
    if(par > start + 1){
        quickSort1(arr,start,par - 1);
    }
    if (par < end - 1){
        quickSort1(arr,par + 1,end);
    }
}

2）快排非递归

public static int partion(int[] array,int low,int high) {
    int tmp = array[low];
    while (low < high) {
        while (low < high && array[high] >= tmp) {
            --high;
        }
        if (low >= high) {
            break;
        } else {
            array[low] = array[high];
        }
        while (low < high && array[low] <= tmp){
            ++low;
        }
        if (low >= high){
            break;
        }else {
            array[high] = array[low];
        }
    }
    array[low] = tmp;
    return low;
}
public static void quickSort(int[] array) {
    int[] stack = new int[array.length * 2];
    int top = 0;
    int low = 0;
    int high = array.length - 1;
    //先进行一趟快排
    int par = partion(array, low, high);
    //1、判断当前par两边是否有两个数据以上
    if (par > low + 1) {
        stack[top++] = low;
        stack[top++] = par - 1;
    }
    if (par < high - 1) {
        stack[top++] = par + 1;
        stack[top++] = high;
    }
    //此时两边数已经全部入栈
    //判断栈是否为空，不为空，取出栈顶两个数
    //进行partion();
    while (top > 0) {
        high = stack[--top];
        low = stack[--top];
        par = partion(array, low, high);
        if (par > low + 1) {
            stack[top++] = low;
            stack[top++] = par - 1;
        }
        if (par < high - 1) {
            stack[top++] = par + 1;
            stack[top++] = high;
        }
    }
}

3）快排优化：

public static void medianOfThree(int[] array,int low,int high){
    int mid = (low + high) >>> 1;
    //使满足 array[mid] <= array[low] <= array[high]
    if (array[mid] > array[low]){
        swap(array,mid,low);
    }
    if(array[mid] > array[high]){
        swap(array,mid,high);
    }
    if (array[low] > array[high]){
        swap(array,low,high);
    }
}
public static void quick(int[] array,int start,int end){
    if(end-start+1 <= 16){
        insertSort(array);
        return;
    }
    medianOfThree(array,start,end);
    int par = partion(array,start,end);
    //左边是否有两个数据以上
    if (par > start + 1){
        quick(array,start,par - 1);
    }
    //右边是否有两个数据以上
    if (par < end -1){
        quick(array,par + 1,end);
    }
}

五、直接选择排序

思想：每次扫描剩余待排序数组中的最小的放到排好序的序列中，直到最后一个数为止。
图解：
代码：

public static void choiceSort(int[] arr){
    if (arr == null || arr.length < 1){
        return;
    }
    int min = 0;
    int tmp;
    //初始化当前最小的
    for (int i = 0; i < arr.length - 1; i++) {
        min = i;
        for (int j = i + 1; j < arr.length ; j++) {
            if (arr[min] > arr[j]){
                //记住最小元素下标
                min = j;
            }
        }
        if (min != i){
            tmp = arr[i];
            arr[i] = arr[min];
            arr[min] = tmp;
        }
    }
}

六、堆排序

思想：排升序建大堆，排降序建小堆
代码：

 public static void adjust( int[] array,int start,int end ){       
        int temp = array[start];  
        for (int i = 2*start+1 ; i <= end ; i = i*2+1) {
                    if ((i < end) && array[i] < array[i+1]){
                                    i++;          
                      }   
                   if (array[i] > temp){ 
                                  array[start] = array[i];
                                  start = i; 
                   }  else { 
                                break;    
                   }
                               array[start] = temp; 
              }  
      }
 public static void heapSort( int[] array ){ 
        for (int i = (array.length - 1 - 1 )/2 ; i >= 0 ; i--) 
              adjust(array,i,array.length-1);//log2n       
         }        把这颗树一次调整为大根堆的时间复杂度是多少？n*log2n        //交换       
        for (int j = 0; j < array.length; j++) {
                int tmp = array[array.length - 1 - j]; 
                array[array.length - 1 - j] = array[0];
                array[0] = tmp; 
                         //不需要调整有序的数据          
                adjust(array,0,array.length - 1 - j - 1);
          }
  }

七、归并排序

思想：
即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
代码：

 public static void merge(int[] array,int start,int mid,int end){
        int[] tmpArray = new int[array.length];
        int tmpIndex = start;
        int start2 = mid + 1;
        int i = start;
        while (start <= mid && start2 <= end){
            if (array[start] < array[start2]){
                tmpArray [tmpIndex++] = array[start++];
            }
            else {
                tmpArray [tmpIndex++] = array[start2++];
            }
        }
        //循环可能退出的情况
        //1
        while (start <= mid){
            tmpArray [tmpIndex++] = array[start++];
        }
        //2
        while (start2 <= end){
            tmpArray [tmpIndex++] = array[start2++];
        }
        //从 tmpArray 拷到 array
        while (i <= end){
            array[i] = tmpArray[i];
            i++;
        }
    }

    public static void mergeSout(int[] array,int start,int end){
        if (start >= end){
            return;
        }
        int mid = (start + end) / 2;
        mergeSout(array,start,mid);
        mergeSout(array,mid + 1,end);//分解
        //肯定是一个一个有序的序列
        //合并
        merge(array,start,mid,end);
    }