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

最新推荐文章于 2022-05-04 14:11:35 发布

LXL7868

最新推荐文章于 2022-05-04 14:11:35 发布

阅读量880

点赞数

分类专栏： 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);
    }

LXL7868

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【Java·数据结构】七大排序及其思想

文章目录排序时间空间复杂度表一、直接插入排序二、希尔排序三、冒泡排序四、快速排序五、直接选择排序六、堆排序七、归并排序排序时间空间复杂度表\平均时间复杂度最坏时间复杂度最好时间复杂度空间复杂度稳定性直接插入排序O(n^2)O(n^2)O(n)O(1)稳定希尔排序O(nlogn)O(nlogn)O(n^1.3)O(1)不稳定...
复制链接

扫一扫

专栏目录