常用排序算法汇总

已于 2023-10-07 16:17:28 修改
阅读量53 收藏
点赞数
文章标签： 排序算法 java 算法
于 2023-09-13 17:38:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lycheewsh/article/details/132859693
版权

排序算法汇总（软考的可以看看）

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

一、冒泡排序

1.1 算法描述

1、比较相邻的元素。如果第一个比第二个大，就交换它们两个；  
2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；  
3、针对所有的元素重复以上的步骤，除了最后一个；   
重复步骤1~3，直到排序完成。

1.2 java代码

package my.sortingAlgorithm;

import java.util.Arrays;

/**
 * 冒泡排序
 * 1、比较相邻的元素。如果第一个比第二个大，就交换它们两个；
 * 2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
 * 3、针对所有的元素重复以上的步骤，除了最后一个；
 * 重复步骤1~3，直到排序完成。
 */
public class bubbleSort {
    public static int[] bubbleSort(int[] array) {
        if (array.length == 0)
            return array;
        for (int i = 0; i < array.length; i++)
            for (int j = 0; j < array.length - 1 - i; j++)
                if (array[j + 1] < array[j]) {
                    int temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
        return array;
    }

    public static void main(String[] args) {
        int[] arr = {2, 4, 1, 9, 19, 3, 5};
        int[] ints = bubbleSort(arr);
        System.out.println(Arrays.toString(ints));
    }
}

1.3 动画展示

请添加图片描述

二、选择排序

1.1 算法描述

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到
已排序序列的末尾。以此类推，直到所有元素均排序完毕。

1.2 java代码

package my.sortingAlgorithm;

import java.util.Arrays;

public class selectionSort {
    /**
     * 选择排序
     *
     * @param array
     * @return
     */
    public static int[] selectionSort(int[] array) {
        if (array.length == 0)
            return array;
        for (int i = 0; i < array.length; i++) {
            int minIndex = i;
            for (int j = i; j < array.length; j++) {
                if (array[j] < array[minIndex]) //找到最小的数
                    minIndex = j; //将最小数的索引保存
            }
            int temp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = temp;
        }
        return array;
    }

    public static void main(String[] args) {
        int[] arr = {2, 4, 1, 9, 19, 3, 5};
        int[] ints = selectionSort(arr);
        System.out.println(Arrays.toString(ints));
    }
}

1.3 动画展示

请添加图片描述

三、插入排序

1、算法描述

1、从第一个元素开始，该元素可以认为已经被排序；
2、取出下一个元素，在前面已排序的元素序列中，从后向前扫描；
3、如果该元素（已排序）大于新元素，将该元素移到下一位置；
4。重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5、将新元素插入到该位置后；
6、重复步骤2~5。

2、java 代码

package my.sortingAlgorithm;

import java.util.Arrays;

public class InsertSort {
    /**
     * 插入排序
     *
     * @param array
     * @return
     */
    public static int[] InsertSort(int[] array) {
        if (array == null || array.length < 2) {
            return array;
        }
        for (int i = 0; i < array.length - 1; i++) {
            //当前值
            int curr = array[i + 1];
            //上一个数的指针
            int preIndex = i;
            //在数组中找到一个比当前遍历的数小的第一个数
            while (preIndex >= 0 && curr < array[preIndex]) {
                //把比当前遍历的数大的数字往后移动
                array[preIndex + 1] = array[preIndex];
                //需要插入的数的下标往前移动
                preIndex--;
            }
            //插入到这个数的后面
            array[preIndex + 1] = curr;
        }
        return array;
    }

    public static void main(String[] args) {
        int[] arr = {2, 4, 1, 9, 19, 3, 5};
        int[] ints = InsertSort(arr);
        System.out.println(Arrays.toString(ints));
    }
}

3、动画展示

请添加图片描述

四、希尔排序（插入排序优化版）

1、算法描述

1、把数组分割成若干(h)个小组(一般数组长度length/2)
2、然后对每一个小组分别进行插入排序
3、每一轮分割的数组的个数逐步缩小，h/2->h/4->h/8，并且进行排序，保证有序。
4、当h=1时，则数组排序完成。

2、java 代码

package my.sortingAlgorithm;

import java.util.Arrays;

public class ShellSort {
    /**
     * 希尔排序
     *
     * @param array
     * @return
     */
    public static int[] ShellSort(int[] array) {
        if (array == null || array.length < 2) {
            return array;
        }
        int length = array.length;
        int temp;
        //步长
        int gap = length / 2;
        while (gap > 0) {
            for (int i = gap; i < length; i++) {
                temp = array[i];
                int preIndex = i - gap;
                while (preIndex >= 0 && array[preIndex] > temp) {
                    array[preIndex + gap] = array[preIndex];
                    preIndex -= gap;
                }
                array[preIndex + gap] = temp;
            }
            gap /= 2;
        }
        return array;
    }

    public static void main(String[] args) {
        int[] arr = {2, 4, 1, 9, 19, 3, 5};
        int[] ints = ShellSort(arr);
        System.out.println(Arrays.toString(ints));
    }
}

3、动画展示

请添加图片描述

五、快速排序

1、算法描述

1、从数组中选一个数做为基准值，一般选第一个数，或者最后一个数。
2、采用双指针(头尾两端)遍历，从左往右找到比基准值大的第一个数，从右往左找到比基准值小的第一个数，交换两数位置，直到头尾指针相等
或头指针大于尾指针，把基准值与头指针的数交换。这样一轮之后，左边的数就比基准值小，右边的数就比基准值大。
3、对左边的数列，重复上面1，2步骤。对右边重复1，2步骤。
4、左右两边数列递归结束后，排序完成。

2、java 代码

package my.sortingAlgorithm;

import java.util.Arrays;

public class QuickSort {
    /**
     * 快速排序 分治思想
     *
     * @param array
     * @return
     */
    public static void quickSort(int[] array, int start, int end) {
        if (start > end) {
            return;
        }
        int i = start;
        int j = end;
        int key = array[start];
        while (i < j) {
            while (i < j && array[j] > key) {
                j--;
            }
            while (i < j && array[i] <= key) {
                i++;
            }
            if (i < j) {
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
        array[start] = array[i];
        array[i] = key;
        quickSort(array, start, i - 1);
        quickSort(array, i + 1, end);
    }

    static int[] sort(int[] array) {
        if (array == null || array.length < 2) {
            return array;
        }
        quickSort(array, 0, array.length - 1);
        return array;
    }

    public static void main(String[] args) {
        int[] arr = {2, 4, 1, 9, 19, 3, 5};
        int[] ints = sort(arr);
        System.out.println(Arrays.toString(ints));
    }
}

3、动画展示

请添加图片描述

六、归并排序

1、算法描述

1、把数组不断划分成子序列，划成长度只有2或者1的子序列。
2、然后利用临时数组，对子序列进行排序，合并，再把临时数组的值复制回原数组。
3、反复操作1~2步骤，直到排序完成。

2、java代码

package my.sortingAlgorithm;

import java.util.Arrays;

public class MergeSort {
    /**
     * 归并排序
     * @param star
     * @param end
     * @param nums
     * @param temp
     */
    private static int[] mergeSort(int star, int end, int[] nums, int[] temp) {
        if (nums == null || nums.length < 2) {
            return nums;
        }
        //递归终止条件
        if (star >= end) {
            return nums;
        }
        int mid = star + (end - star) / 2;
        //左边进行归并排序
        mergeSort(star, mid, nums, temp);
        //右边进行归并排序
        mergeSort(mid + 1, end, nums, temp);
        //合并左右
        int[] merge = merge(star, end, mid, nums, temp);
        return merge;
    }
    private static int[] merge(int star, int end, int mid, int[] nums, int[] temp) {
        int index = 0;
        int i = star;
        int j = mid + 1;
        while (i <= mid && j <= end) {
            if (nums[i] > nums[j]) {
                temp[index++] = nums[j++];
            } else {
                temp[index++] = nums[i++];
            }
        }
        while (i <= mid) {
            temp[index++] = nums[i++];
        }
        while (j <= end) {
            temp[index++] = nums[j++];
        }
        //把临时数组中已排序的数复制到nums数组中
        if (index >= 0) System.arraycopy(temp, 0, nums, star, index);
        return nums;
    }
    public static void main(String[] args) {
        int[] arr = {2, 4, 1, 9, 19, 3, 5};
        int[] ints = mergeSort(0, arr.length - 1, arr, new int[arr.length]);
        System.out.println(Arrays.toString(ints));
    }
}

3、动画展示

在这里插入图片描述

7、堆排序

1、排序原理

1、对原数组构建成大顶堆。
2、交换头尾值，尾指针索引减一，固定最大值。
3、重新构建大顶堆。
4、重复步骤2~3，直到最后一个元素，排序完成。

2、java代码

package my.sortingAlgorithm;

import java.util.Arrays;

/**
 * 堆排序
 */
public class heapSort {
    public static void heapify(int[] arr, int len, int i) {
        int largest = i;
        int lson = i * 2 + 1;
        int rson = i * 2 + 2;
        if (lson < len && arr[largest] < arr[lson]) {
            largest = lson;
        }
        if (rson < len && arr[largest] < arr[rson]) {
            largest = rson;
        }
        if (largest != i) {
            swap(arr, largest, i);
            //因为交换破坏了稳定，需要把largest的重新组合
            heapify(arr, len, largest);
        }
    }

    /**
     * 堆排序入口
     * @param arr
     * @param len
     */
    static void heap_sort(int arr[], int len) {
        //第一步构建大顶堆
        for (int i = len / 2 - 1; i >= 0; i--) {
            heapify(arr, len, i);
        }
        //第二步排序
        for (int i = len - 1; i > 0; i--) {
            swap(arr, i, 0);
            heapify(arr, i, 0);
        }
    }

    /**
     * 交换
     * @param arr
     * @param left
     * @param right
     */
    static void swap(int[] arr, int left, int right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {2, 4, 1, 9, 19, 3, 5};
        heap_sort(arr, arr.length);
        System.out.println(Arrays.toString(arr));
    }
}

3、动画演示

请添加图片描述

奔四程序员
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
常用排序算法总结
nkltc的博客
05-15 409
常用排序算法
常用排序算法
新手村
01-02 522
排序算法： 内部排序算法大致分为两种： 一种是比较排序，时间复杂度最少可达到O(n log n)，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。 另一种是非比较排序，时间复杂度可以达到O(n)，主要有：计数排序，基数排序，桶排序等。 稳定性： 假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，
常见排序算法汇总
夜槿笙歌的博客
04-17 8274
整理一下之前学习的各种排序算法
十大排序算法
热门推荐
个人站点：javatv.net
08-20 2万+
冒泡排序 从数组头开始，比较相邻的元素。如果第一个比第二个大(小)，就交换它们两个 对每一对相邻元素作同样的工作，从开始第一对到尾部的最后一对，这样在最后的元素应该会是最大(小)的数 重复步骤1~2，重复次数等于数组的长度，直到排序完成 代码实现 对下面数组实现排序：{24, 7, 43, 78, 62, 98, 82, 18, 54, 37, 73, 9} 代码实现 public class BubbleSort { public static final int[] ARRAY = {2
python常用排序算法汇总
02-19
该程序包含7大排序算法: # sort.bubbleSort() #冒泡排序 # sort.shellSort() #希尔排序 # sort.insertionSort() #插入排序 # sort.Selectionsort1() #选择排序 # sort.heapSort() #堆排序 # sort.countSort() ...
PHP版本常用的排序算法汇总
10-23
在编程领域，排序算法是数据处理中的基础工具，它们用于将一组无序的数据按照特定顺序进行排列。在PHP中，有多种不同的排序算法可供选择，本文将重点介绍冒泡排序、归并排序以及两种二分查找算法。 1. **冒泡排序**...
Java排序算法汇总大全.doc
09-01
Java排序算法汇总大全 在计算机科学中，排序算法是用于对数据序列进行排列的算法，以便根据特定标准对其进行组织。本文将详细介绍Java中常见的几种排序算法，并提供它们的基本原理、性能分析以及适用场景。 1. ...
java常用的7大排序算法汇总
06-29
java常用的7大排序算法汇总文档汇总
插入排序 （直接插入排序与希尔排序）
babilunlaobanjiu的博客
07-14 306
1. 元素集合越接近有序，直接插入排序算法的时间效率越高2. 时间复杂度：O(N^2)3. 空间复杂度：O(1)4. 稳定性：稳定1. gap越大，大的可以越快跳到后面，小的数可以越快跳到前面，越不接近有序gap越小，跳得越慢，但是越接近有序。当gap==1相当于直接插入排序就有序了2. 时间复杂度：O(N^1.3)3. 空间复杂度：O(1)4. 稳定性：不稳定。
排序——归并排序及排序章节总结
Blusher1的博客
07-13 986
前面的文章中 我们详细介绍了排序的概念，插入排序，交换排序与选择排序，这篇文章就详细介绍一下另一种排序算法：归并排序，以及对于排序章节进行一下总结
常见排序算法
weixin_50956409的博客
07-11 1067
不能！！！考虑这样一种情况，如果去掉等号，right在找小的过程中，遇到了和key相等的值就会停下。而left在找大的过程恰好也停在和key相等的位置，left和right交换，进行下一轮循环，right和left在原地又会进行交换，如此就陷入了死循环……
排序——交换排序
Blusher1的博客
07-12 742
在上篇文章我们详细介绍了排序的概念与直接插入排序，这篇文章就介绍一下一种排序方式：交换排序。
常见的排序算法
2303_80187476的博客
07-10 1367
在生活中很多都需要用到排序算法，比如学生成绩的排序，手机销量的排序，抖音热榜的排序 将最大或者最小的数据元素排到最后 复杂度分析 时间复杂度： 最好：O(N) 最坏：O(N^2) 空间复杂度：O(1)每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，起始位置向后移，直到全部待排序的数据元素排完 。 这里我将其优化了一下，及在待排序序列中找到最大和最小的数据元素，分别将其排到序列的起始位置和最后位置。 复杂度分析 时间复杂度 最好：O(N^2) 最坏：O(N^2) 空间复杂度：O
python实现插入排序、快速排序
最新发布
qq_42568323的博客
07-16 357
快速排序是一种分治算法，通常被认为是目前最快的排序算法之一。它的基本思想是通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个过程可以递归进行，以达到整个数据变成有序序列。通过以上实现，可以看到这两种排序算法在不同场景下的适用性。插入排序算法简单直观，适用于小规模数据；快速排序则效率高，适用于大规模数据。它的基本思想是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
二分查找和斐波那契查找
weixin_50960004的博客
07-13 496
表面上看，后一调整存在风险，此时只能确定切分点arr[mid]＞target ，“贸然”地将arr[mi]排除在进一步的查找范围之外，似乎可能因遗漏这些元素，而导致本应成功的查找以失败告终。也就是说，无论朝哪个方向深入，都只需做1次元素的大小比较，其二，统一沿两个方向深入所需要执行的比较次数，比如都统一为一次。在有序向量中的查找，遇到重复的元素时会返回秩最大的那个，上述查找无法实现这个功能，因此加以改进。所以这样的话，想进入左半区间，进行一次比较，想进入右半区间，会进行两次比较，右侧比较会多。
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 611
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
persistence_PSH的博客
07-14 826
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
python常用算法手册 pdf
12-15
本手册包括了各种常用的算法，如排序算法、查找算法、图算法、字符串处理算法等。每种算法都有详细的说明和示例代码，让读者能够更好地理解和掌握。此外，手册还介绍了常用的数据结构，如数组、链表、栈、队列、树等...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值