[数据结构]经典排序算法-Java版

已于 2023-11-01 20:33:11 修改
阅读量94 收藏
点赞数
文章标签： 排序算法 java 数据结构
于 2023-10-21 15:12:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjh0223/article/details/133715395
版权

排序算法

1.插入排序

排序思想：

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中,直到所有的记录插入完为止,得到一个新的有序序列

实现思路：
插入排序一般在数组上实现。采用数组，并使用升序排序举例说明。
1.假设从首元素下标位置开始，我们认为首元素已经有序。
2.取出下一个元素(待插入元素)，并记录待插入元素下标位置，认定待插入元素之前的元素已完成排序，然后从后往前进行比较。
3.如果待插入元素小于上一个元素(已排序元素)，已排序元素向后移动。
4.重复步骤3，直到找到已排序元素小于或者等于待插入元素的位置。
5.插入已经找到的位置。重复2~5的步骤。
动画演示：
Java代码实现：

public static void insertSort(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            //记录待插入元素的下标
            int index = i;
            //待插入元素
            int cur = arr[i];
            //元素移动
            while (index > 0){
                //升序排序，后面的元素小于前面的就往前插入
                if(cur < arr[index - 1]){
                     arr[index] = arr[index - 1];
                    index--;
                }else {
                    break;
                }

            }
            //将待插入元素插入对应位置
            arr[index] = cur;
        }
    }

插入排序算法特性总结:

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

2.冒泡排序

排序思想:

从下标较小的元素开始，依次比较相邻元素的值，如果发现元素排序顺序不对，进行交换，使元素较大(或者较小)者后移。

实现思路：
1.从下标较小元素开始，比较其相邻元素，顺序不对，进行交换。
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数(或者最小的数)。
3.重复以上步骤。
动画演示：
在这里插入图片描述
代码实现：

public static void bubbleSort(int[] elem){
        //优化冒泡排序,判断在排序时元素是否已经有序，避免不必要的交换
        int flag = 0;
        for (int i = 0; i < elem.length - 1; i++) {                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      
            //elem.length - i 减少比较趟数，在每次交换，放到后面的元素已经排序好了
            for (int j = 0; j < elem.length- 1 - i; j++) {
                if(elem[j] > elem[j + 1]){
                    swap(elem,j,j + 1);
                    flag = 1;
                }
            }
            if(flag == 0){
                break;
            }
        }
    }
    public static void swap(int[] elem,int start,int end){
        int cur = elem[start];
        elem[start] = elem[end];
        elem[end] = cur;
    }

冒泡排序算法特性总结：

时间复杂度：O(N^2)
空间复杂度：O(1)
稳定性：稳定

3.希尔排序

排序思想：

希尔排序是记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

实现思路：
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,这里以数组举例。
1.先选定一个小于数组长度N的整数gap作为第一增量，然后将所有距离为gap的元素分在同一组，并对每一组的元素进行直接插入排序。然后将gap减小，例如gap = gap / 2，重复上述操作…
2.当gap = 1时，就相当于整个序列被分到一组，进行一次直接插入排序，此时排序完成。

代码实现：

private static void shellSort(int[] arr) {
        int gap = arr.length / 2;
        while (gap >= 1){
            for (int i = 0; i < arr.length - gap; i++) {
                int end = i;
                int tmp = arr[end + gap];
                while (end >= 0){
                    if(arr[end] > tmp){
                        arr[end+gap] = arr[end];
                        end -= gap;
                    }else {
                        break;
                    }
                }
                arr[end + gap] = tmp;
            }
            gap /= 2;
        }
    }

希尔排序算法特性总结：

时间复杂度：O(N^(1.3~2))
空间复杂度：O(1)
稳定性：不稳定

4.选择排序

排序思想：
首先从未排序的序列中选取最大(或者最小)的元素，放到序列的起始位置，然后再从未排序的序列中取出最大(或者最小的元素)放到已排序序列末尾，以此类推，直到所有元素都排序完。
实现思路：
1.假设未排序序列的首元素为最小(或者最大)元素，记录其下标。
2.从最小(或者最大)元素下标下一位置开始和记录的最小(或者最大)元素进行比较，更新最小元素下标，一直比较到未排序序列末尾位置。
3.将我们假设的最小(或者最大)元素和实际找到的最小(或者最大)元素进行交换。
动画演示：
在这里插入图片描述代码实现：

private static void selectSort(int[] arr) {
        int minindex = 0;
        int index = 0;
        for (int i = 0; i < arr.length; i++) {
            //假设i下标为最小元素位置
            minindex = i;
            //从最小元素的下一位置开始寻找
            index = minindex + 1;
            while (index < arr.length){
                if(arr[minindex] > arr[index]){
                    minindex = index;
                }
                index++;
            }
            int tmp = arr[i];
            arr[i] = arr[minindex];
            arr[minindex] = tmp;
        }
    }

选择排序算法特性总结：

  1. 时间复杂度: O(N^2)
  2. 空间复杂度: O(1)
  3. 稳定性:不稳定

5.堆排序

排序思想：

堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。它是通过堆来进行选择数据。 需要注意的是排升序要建大堆,排降序建小堆。

实现思路：
1.首先建立一个大根堆；
2.把堆首（最大值）和堆尾互换；
3.把堆的尺寸缩小 1，调用建队方法中的向下调整方法，目的是把新的数组顶端数据调整到相应位置；
4.重复步骤 2~3，直到堆的尺寸为 0。

代码实现：

public static void main(String[] args) {
        //给定一个数组,将其变成堆的方式存储
        int[] heap ={1,2,4,3,5,7,6,9,8,10};
        int usedSize = heap.length;
        //根据给定的数据建立大根堆
        heapCreate(heap,usedSize);
        heapSort(heap );
        for (int x: heap) {
            System.out.print(x + " ");
        }
    }
    //排序
    public static void heapSort(int[] heap){
        int end = heap.length - 1;
        while (end > 0){
            swap(0,end,heap);
            shiftDown(0,end,heap);
            end--;
        }
    }
    //建立大根堆
    public static void heapCreate(int[] heap,int usedSize){
        //堆排序从最后一个父节点开始调整
        for (int parent = (usedSize - 1 - 1) / 2; parent >= 0 ; parent--) {
            shiftDown(parent,usedSize,heap);
        }
    }
    //向下调整,结束位置不能超过数组长度
    public static void shiftDown(int parent,int len,int[] heap){
        // 找到传入父节点孩子节点的下标
        int child = parent * 2 + 1;
        // 判断孩子节点是否存在
        while (child < len){
            //判断左右孩子节点的值谁更大
            if(child + 1 < len && heap[child] < heap[child + 1]){
                 child ++;
            }
            //child下标 一定是左右孩子最大值的下标
            if(heap[child] > heap[parent]){
                swap(child,parent,heap);
                parent = child;
                child = 2 * parent + 1;
            }else {
                break;
            }
        }
    }
    public static void swap(int start,int end,int[] heap){
        int tmp = heap[start];
        heap[start] = heap[end];
        heap[end] = tmp;
    }

堆排序算法特性总结：

1.时间复杂度: O(N*logN)
2. 空间复杂度: O(1)
3. 稳定性:不稳定

6.快速排序

排序思想：

任取待排序元素序列中的某元素作为基准值,按照该排序码将待排序集合分割成两子序列,左子序列中所有元素均小于基准值,右子序列中所有元素均大于基准值,然后最左右子序列重复该过程,直到所有元素都排列在相应位置上为止。

挖坑法动图：
在这里插入图片描述

排序思路：
1.从数列中挑出一个元素，称为 “基准”（pivot）；
2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

代码实现：

  public static void quickSort(int[] elem,int start,int end){
        if(start >= end){
            return;
        }
        //每次寻找基准值
        int reference = reference(elem,start,end);
        //找左区间的基准值
        quickSort(elem,start,reference - 1);
        //找右区间的基准值
        quickSort(elem,reference+1,end);
    }
    //挖坑法
    public static int reference(int[] elem,int left,int right){
        int tmp = elem[left];
        while (left < right){
            while (left < right && tmp < elem[right]){
                right--;
            }
            elem[left] = elem[right];
            while (left < right && tmp > elem[left]){
                left ++;
            }
            elem[right] = elem[left];
        }
        elem[left] = tmp;
        return left;
    }

hoare版代码实现：
hoare版和挖坑法思路基本相似，只有微小改动，不再进行过多阐述，自行理解即可。

public static void quickSort(int[] elem,int start,int end){
        if(start >= end){
            return;
        }
        //每次寻找基准值
        int reference = hoareReference(elem,start,end);
        //找左区间的基准值
        quickSort(elem,start,reference - 1);
        //找右区间的基准值
        quickSort(elem,reference+1,end);
    }
public static int hoareReference(int[] elem,int left,int right){
        int tmp = elem[left];
        int i = left;
        while (left < right){
            while (left < right && tmp <= elem[right]){
                right--;
            }
            while (left < right && tmp >= elem[left]){
                left ++;
            }
            swap(left,right,elem);
        }
        swap(left,i,elem);
        return left;
    }
    public static void swap(int start,int end,int[] elem){
        int tmp = elem[start];
        elem[start] = elem[end];
        elem[end] = tmp;
    }

前后指针法代码实现：
基本思路：
1、选出一个key，并记录其下标位置。
2、起始时，prev指针指向序列开头，cur指针指向prev+1。
3、cur指向元素小于key，prev向后移动一位，交换prev和cur指针指向的内容，然后cur继续向后移动；若cur指向元素大于key，不进行元素交换，cur继续向后移动。直到cur到达end位置，此时将key和++prev指针指向的内容交换即可。

public static void quickSort(int[] elem,int start,int end){
        if(start >= end){
            return;
        }
        //每次寻找基准值
        int reference = pointerReference(elem,start,end);
        //找左区间的基准值
        quickSort(elem,start,reference - 1);
        //找右区间的基准值
        quickSort(elem,reference+1,end);
    }

public static int pointerReference(int[] elem,int left,int right){
        int prev = left;
        int cur = left + 1;
        while (cur <= right){
            if (elem[cur]  < elem[left] && elem[++prev] != elem[cur]){
                swap(cur,prev,elem);
            }
            cur++;
        }
        swap(prev,left,elem);
        return prev;
    }
public static void swap(int start,int end,int[] elem){
        int tmp = elem[start];
        elem[start] = elem[end];
        elem[end] = tmp;
    }

快速排序优化：
因为每次取的基准值是随机的，我们更希望基准值能将元素均匀分开，使用三数取中法进行优化，并且在数据逐渐趋于有序时，使用插入排序,在这种场景下，插入排序的效率更高。
代码实现：

//挖坑法
    public static int reference(int[] elem,int left,int right){
        int tmp = elem[left];
        while (left < right){
            while (left < right && tmp < elem[right]){
                right--;
            }
            elem[left] = elem[right];
            while (left < right && tmp > elem[right]){
                left ++;
            }
            elem[right] = elem[left];
        }
        elem[left] = tmp;
        return left;
    }
     //用三位取中法对快排进行优化
    public static void Sort(int[] elem,int start,int end){
        int left = start;
        int right = end;
        if(left >= right){
            return;
        }
        //使用插入排序
        //2为随机取的值，具体情况根据使用场景来指定
        if(end - start < 2){
            insertSort(elem,left,right);
            return;
        }
        //找基准值的下标，使基准值左边的值小于基准值，基准值右边的值大于基准值
        //三数取中法找到更适合当基准值的数的下标
        int index = midThree(elem,start,end);
        //交换更合适当基准值的位置和排序开始的位置
        swap(start,index,elem);
        int tmp = elem[left];
        int benchmark = reference(elem,start,end);
        //通过递归再次在基准值左右两边再次找基准
        //找左边基准值
        quickSort(elem,start,benchmark-1);
        //找右边基准值
        quickSort(elem,benchmark+1,end);
    }
    //三数取中法
    public static int midThree(int[] array,int left,int right){
        int mid = (left+right)/2;
        if(array[left] < array[right]){
            if(array[mid] < array[left]){
                return left;
            }else if(array[mid] > array[right]){
                return right;
            }else {
                return mid;
            }
        }else{
            if(array[mid] > array[left]){
                return left;
            }else if(array[mid] < array[right]){
                return right;
            }else {
                return mid;
            }
        }
    }
    //插入排序
    public static void insertSort(int[] arr,int left,int right){
        for (int i = left + 1; i <= right; i++) {
            //记录待插入元素的下标
            int index = i;
            //待插入元素
            int cur = arr[i];
            //元素移动
            while (index > 0){
                //升序排序，后面的元素小于前面的就往前插入
                if(cur < arr[index - 1]){
                    arr[index] = arr[index - 1];
                    index--;
                }else {
                    break;
                }

            }
            //将待插入元素插入对应位置
            arr[index] = cur;
        }
    }

快速排序算法特性总结：

1.时间复杂度:O(NlogN)
2.空间复杂度:O(NlogN)
稳定性:不稳定

7.归并排序

排序思想：

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2路归并。

实现思路：
1.把长度为n的输入序列分成两个长度为n/2的子序列；
2.对这两个子序列分别采用归并排序；
3.将两个排序好的子序列合并成一个最终的排序序列

代码实现：

//递归实现归并排序
    public static void mergeSort(int[] array,int left,int right){
        if (left >= right){
            return;
        }
        int mid = (left+right)/2;
        mergeSort(array,left,mid);
        mergeSort(array,mid+1,right);
        merge(array,left,right,mid);

    }
    //对排序好的数据进行合并
    public static void merge(int[] array,int start,int end,int mid){
        int s1 = start;
        int s2 = mid+1;
        int[] tmp = new int[end-start+1];
        int k = 0;
        while (s1 <= mid && s2 <= end ){
            if(array[s1] > array[s2]){
                tmp[k++] = array[s2++];
            }else {
                tmp[k++] = array[s1++];
            }
        }
        while (s1 <= mid){
            tmp[k++] = array[s1++];
        }
        while (s2 <= end){
            tmp[k++] = array[s2++];
        }
        for (int i = 0; i < tmp.length; i++) {
            array[i+start] = tmp[i];
        }
    }

归并排序算法特性总结：

1.时间复杂度：O(N*logN)
2.空间复杂度：O(N)
3.稳定性：稳定

闲敲键盘落灯花
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构之经典排序算法
明天，你好
04-02 287
常用排序算法 冒泡排序 (升序)从前往后两两比较，若后者比前者小，则交换，继续向后对比，每一趟排序挑选出至少一个元素在其正确位置上. 冒泡排序最好的时间复杂度为O(n)O(n)O(n),最坏情况为O(n2)O(n^2)O(n2),平均时间复杂度为O(n2)O(n^2)O(n2).稳定排序。 鸡尾酒排序 鸡尾酒排序的原理跟冒泡排序差不多，只不过冒泡排序每一轮的比较都是从左至右依次比较，而鸡尾酒排序则...
数据结构--经典排序算法
qq_44797904的博客
12-03 259
1、冒泡排序 思想：逐个比较每个元素 像泡泡一样，使大的下沉至底部。设置标志位。如果进行到中间一步的时候，元素已经有序则不需要再进行多于的排序，提高效率。
十大经典排序算法-归并排序算法详解
热门推荐
qq_35344198的博客
06-19 12万+
一、什么是归并排序 1.概念 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分 序列逐层拆分如下 然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并 创建一个大序列，序列长度为两个小序列长度
数据结构-十大经典排序算法
qq_64010161的博客
12-09 3572
数据结构-十大经典排序算法（冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序）
十大经典排序算法-快速排序算法详解
qq_35344198的博客
06-16 8万+
一、什么是快速排序 1.概念 快速排序（Quick Sort）是从冒泡排序算法演变而来的，实际上是在冒泡排序基础上的递归分治法。快速排序在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成了两个部分 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照快速排序的思想，我们先选择一个基准元素，进行排序 我们选取4为我们的基准元素，并设置基准元素的位置为index，设置两个指针left和right，分别指向最左
数据结构和算法-Java版.zip
01-14
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
数据结构与排序算法------通过代码示例，讲解：数据结构和9种排序算法。.zip
01-15
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录-Java-下载.zip
09-15
在本压缩包“用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录-Java-下载.zip”中，包含的是一个Java编程项目，主要目的是通过代码实践来理解和掌握数据结构、排序算法以及经典的计算机算法。...
数据结构与算法-学习笔记 Java 版.zip
01-15
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
【面试题】数据结构：堆排序的排序思想？
最新发布
Colorful___的博客
07-18 633
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
数据结构小测试：排序算法
m0_63432840的博客
07-14 600
冒泡排序：将相邻元素之间的比较和交换，使得每一轮比较后，最大的元素能够到达数组的末尾。重复这个过程，直到整个数组有序。选择排序：在每一轮中，找到数组中最小的元素，并将其与当前轮的第一个元素交换位置。重复这一操作，使得每一轮过后，都有一个元素被放到了正确的位置上。插入排序：将数组分为已排序部分和未排序部分，每次从未排序部分取出一个元素，插入到已排序部分的正确位置上。希尔排序：首先确定一个间隔序列，按此间隔将数组元素分组并进行插入排序。随后逐渐缩小间隔并重复排序过程，直到间隔为1。
【C语言】深入解析快速排序
Easonmax的博客
07-15 834
快速排序（Quick Sort）是一种基于比较的排序算法。它通过选择一个“基准”元素（pivot），将数组分割成两部分：一部分元素小于基准元素，另一部分元素大于基准元素。然后，递归地对这两部分进行快速排序。快速排序的核心思想是分治法。
Python算法实现之排序算法的Python实现详解
Rocky006的博客
07-18 687
排序算法是计算机科学中最基础和最重要的算法之一。它们在数据处理中起着关键作用，广泛应用于搜索、数据分析和优化等领域。本文将详细介绍几种常见的排序算法及其Python实现，包括冒泡排序、选择排序、插入排序、归并排序和快速排序，并通过具体示例代码展示它们的工作原理和性能比较。
【C语言】全面解析冒泡排序
Easonmax的博客
07-15 987
冒泡排序（Bubble Sort）是一种简单的排序算法，它通过重复遍历待排序的序列，依次比较相邻元素并交换它们的位置，使较大的元素逐渐“冒泡”到序列的末端。冒泡排序的核心思想是通过不断的比较和交换，将未排序的元素逐步移到正确的位置。
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 834
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 905
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1026
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
m0_69266818的博客
07-15 835
介绍了Redis命令和用java操作redis还有营业额状态接口的书写
《数据结构》C语言版-堆排序算法详解
本文主要探讨了数据结构中的堆排序算法，并引用了《数据结构》（C语言版）一书中的相关内容。堆排序是一种基于比较的排序算法，通过构建和调整最大堆或最小堆来实现数据的排序。文章还提到了其他相关数据结构和算法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值