1. Toy模板网首页
  2. > Toy博客

2023.7.15排序算法合集

9月前 作者：伊天凌 分类：Toy博客 阅读(41) 违法举报

这篇具有很好参考价值的文章主要介绍了2023.7.15排序算法合集。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

一、概述

  排序算法是计算机科学中的一类常见算法，用于将一组数据按照特定的顺序进行排列；排序算法的应用非常广泛，涉及到数据处理、搜索算法、数据库操作等众多领域。常见的排序算法有以下几种：

  1. 冒泡排序（Bubble Sort）
  2. 插入排序（Insertion Sort）
  3. 选择排序（Selection Sort）
  4. 快速排序（Quick Sort）
  5. 归并排序（Merge Sort）
  6. 堆排序（Heap Sort）
  7. 希尔排序（Shell Sort）
  8. 计数排序（Counting Sort）
  9. 桶排序（Bucket Sort）
  10. 基数排序（Radix Sort）

奈何本人技术不太行，对于树和堆的理解不够透彻，所以涉及到这两种数据结构的排序算法可能要以后再补充

二、排序算法

文章使用 Java语言 进行演示，使用 int数据 类型作为示范，操作的数据结构均以 数组 为准，排序的结果为 从小到大 排列，同时提供随机初始化数据的方法

相关的全局变量和初始化数据方法如下

    public static int number;//用例数据量
    public static int[] nums;//用例数组
    
    /**
     * 用例随机初始化
     * @param number 用例数据量
     * @param start  用例起始范围
     * @param end    用例结束范围
     */
    public static void initNums(int number, int start, int end) {
        nums = new int[number];
        for (int i = 0; i < nums.length; i++) {
            nums[i] = (int) (Math.random() * (end - start + 1) + start);
        }
    }

1.冒泡排序

  冒泡排序是一种简单直观的排序算法，它通过依次比较相邻的元素，并在必要时交换位置，使得每一轮循环后最大（或最小）的元素浮到序列的末尾。冒泡排序的过程可以描述如下：

  1. 从列表的第一个元素开始，依次比较相邻的两个元素。如果前一个元素大于（或小于）后一个元素，则交换它们的位置，使较大（或较小）的元素“冒泡”到后面
  2. 继续对剩余的元素进行相邻比较和交换操作，直到将最大（或最小）的元素移动到列表的最后位置
  3. 对除去最后一个元素的剩余列表重复上述步骤，每次循环将会确定一个最大（或最小）的元素到达正确的位置
  4. 重复上述步骤，直到整个列表排序完成

2023.7.15排序算法合集,Matrix,排序算法,算法,java

    /**
     * 冒泡排序:从左到右逐个比较相邻的元素，并进行交换，每一轮将最大的元素移到最右侧
     */
    public static void bubbleSort() {
        int[] bubbleSortNums = nums.clone();
        for (int i = 1; i < bubbleSortNums.length; i++) {
            for (int j = 0; j < bubbleSortNums.length - i; j++) {
                if (bubbleSortNums[j] > bubbleSortNums[j + 1]) {//已经确保两个数不相同，所以异或不会丢失数据
                    bubbleSortNums[j] ^= bubbleSortNums[j + 1];
                    bubbleSortNums[j + 1] ^= bubbleSortNums[j];
                    bubbleSortNums[j] ^= bubbleSortNums[j + 1];
                }
            }
        }
        System.out.print("冒泡排序： ");
        System.out.println(Arrays.toString(bubbleSortNums));
    }

冒泡排序的时间复杂度为O(N2)，其中N为待排序元素的数量

2.插入排序

  插入排序是一种简单直观的排序算法，它的工作原理类似于整理扑克牌的过程。插入排序的基本思想是将待排序的元素逐个插入到已经排序的序列中的正确位置，从而逐步构建有序序列。下面是插入排序的步骤：

  1. 将列表的第一个元素视为已排序序列
  2. 从第二个元素开始，逐个将元素插入到已排序序列的正确位置。插入时，将当前元素与已排序序列中的元素从后向前逐个比较，直到找到合适的位置插入
  3. 重复上述步骤，直到将所有元素插入到正确的位置。

2023.7.15排序算法合集,Matrix,排序算法,算法,java

    /**
     * 插入排序：逐个将元素插入到已排序的序列中的正确位置，构建最终有序序列
     */
    public static void insertSort() {
        int[] insertSortNums = nums.clone();
        int temp = 0;//记录待插入的值
        int index = 0;//记录插入的位置
        boolean isFlag;
        for (int i = 1; i < insertSortNums.length; i++) {
            isFlag = false;
            for (int j = 0; j < i; j++) {
                if (insertSortNums[i] < insertSortNums[j]) {
                    index = j;
                    temp = insertSortNums[i];
                    isFlag = true;
                    break;
                }
            }
            if (isFlag) {//当需要向前插入的时候才执行，否则不用移动
                System.arraycopy(insertSortNums, index, insertSortNums, index + 1, i - index);
//                for (int j = i; j > index; j--) {
//                    insertSortNums[j] = insertSortNums[j - 1];
//                }
                insertSortNums[index] = temp;
            }
        }
        System.out.print("插入排序： ");
        System.out.println(Arrays.toString(insertSortNums));
    }

插入排序的时间复杂度为O(N2)，其中N为待排序元素的数量

3.选择排序

  选择排序是一种简单直观的排序算法，其基本思想是每一次从待排序的元素中选择最小（或最大）的元素，放置在已排序序列的末尾，从而逐步构建有序序列。选择排序的步骤如下：

  1. 遍历待排序序列，将第一个元素标记为当前最小（或最大）元素
  2. 从剩余的未排序元素中依次找到最小（或最大）的元素，与当前最小（或最大）元素进行比较
  3. 如果找到比当前最小（或最大）元素更小（或更大）的元素，则更新当前最小（或最大）元素的位置
  4. 继续遍历剩余的未排序元素，重复上述步骤，直到将所有元素排序完成
  5. 重复上述过程，直到所有元素都被排序

2023.7.15排序算法合集,Matrix,排序算法,算法,java

    /**
     * 选择排序:每一轮从未排序的部分选择最小（或最大）的元素，放到已排序部分的末尾
     */
    public static void selectSort() {
        int[] selectionSortNums = nums.clone();
        for (int i = 0; i < selectionSortNums.length - 1; i++) {//计数
            int maxNum = 0;//记录极大值的索引
            for (int j = 0; j < selectionSortNums.length - i; j++) {
                if (selectionSortNums[maxNum] < selectionSortNums[j]) {
                    maxNum = j;
                }
            }
            //下面的if是用异或交换元素的重点，防止置0
            if (maxNum != selectionSortNums.length - i - 1) {//如果已经在对应位置就不需要移动，否则会导致异或同一个变量置0
                selectionSortNums[maxNum] ^= selectionSortNums[selectionSortNums.length - i - 1];
                selectionSortNums[selectionSortNums.length - i - 1] ^= selectionSortNums[maxNum];
                selectionSortNums[maxNum] ^= selectionSortNums[selectionSortNums.length - i - 1];
            }
        }
        System.out.print("选择排序： ");
        System.out.println(Arrays.toString(selectionSortNums));
    }

选择排序的时间复杂度为O(N2)，其中N为待排序元素的数量

4.快速排序

  快速排序是一种高效的排序算法，它采用分治法的思想。快速排序的基本思想是选择一个基准元素，将待排序序列划分为左右两个子序列，其中左边子序列的元素都小于等于基准元素，右边子序列的元素都大于等于基准元素，然后递归地对左右子序列进行排序，最终得到有序序列。快速排序的步骤如下：

  1. 选择一个基准元素（通常是列表的第一个或最后一个元素）
  2. 遍历整个序列，将小于等于基准元素的元素放到左边，大于等于基准元素的元素放到右边，形成两个子序列
  3. 递归地对左右子序列进行快速排序
  4. 将左子序列、基准元素、右子序列按照顺序连接起来，得到最终的有序序列

快速排序（双指针法）动画演示


快速排序（双指针法）动画演示 
    /**
     * 快速排序：选择一个基准元素，将数组分为小于基准值和大于基准值的两部分，递归地对这两部分进行排序(默认首元素为基准)
     */
    public static void quickSort() {
        int[] quickSortNums = nums.clone();
        quick(quickSortNums, 0, quickSortNums.length - 1);
        System.out.print("快速排序： ");
        System.out.println(Arrays.toString(quickSortNums));
    }

    /**
     * 快速排序：选择一个基准元素，将数组分为小于基准值和大于基准值的两部分，递归地对这两部分进行排序(默认首元素为基准)
     * @param quickSortNums 待排序数组
     * @param start 左起点
     * @param end 右起点
     */
    public static void quick(int[] quickSortNums, int start, int end) {
        if (start < end) {//直到序列内只有一个元素时，无需排序，结束递归
            int left = start;
            int right = end;
            int pivotIndex = start;//基准元素的索引值(选择第一个元素作为基准元素)
            //寻找基轴位置
            while (left < right) {
                //右侧扫描
                while (left < right && quickSortNums[right] >= quickSortNums[pivotIndex]) {//找到第一个小于基准的元素
                    right--;
                }//和基轴交换位置
                if (left < right) {//保证小于基准的元素在右侧
                    quickSortNums[right] ^= quickSortNums[pivotIndex];
                    quickSortNums[pivotIndex] ^= quickSortNums[right];
                    quickSortNums[right] ^= quickSortNums[pivotIndex];
                    pivotIndex = right;
                }
                //左侧扫描
                while (left < right && quickSortNums[left] <= quickSortNums[pivotIndex]) {//找到第一个大于基准的元素
                    left++;
                }//和基轴交换位置
                if (left < right) {//保证大于基准的元素在左侧
                    quickSortNums[left] ^= quickSortNums[pivotIndex];
                    quickSortNums[pivotIndex] ^= quickSortNums[left];
                    quickSortNums[left] ^= quickSortNums[pivotIndex];
                    pivotIndex = left;
                }
            }
            //左右子序列递归排序
            quick(quickSortNums, start, pivotIndex - 1);
            quick(quickSortNums, pivotIndex + 1, end);
        }
    }

快速排序的时间复杂度为O(NlogN)，其中N为待排序元素的数量

5.归并排序

  归并排序是一种高效的排序算法，它采用分治法的思想。归并排序的基本思想是将待排序序列分成两个较小的子序列，递归地对子序列进行排序，然后将两个有序子序列合并成一个有序序列。以下是归并排序的算法实现步骤：

  1. 分解：将待排序序列递归地分解为两个较小的子序列，直到每个子序列只剩下一个元素或为空
  2. 合并：将两个有序子序列合并成一个有序序列。比较两个子序列的首个元素，将较小的元素放入临时的辅助数组中，并将相应子序列的指针向后移动，重复此过程，直到两个子序列中的元素全部放入辅助数组中
  3. 将辅助数组中的有序序列复制回原始序列的对应位置
  4. 递归地对两个子序列重复上述步骤，直到整个序列排序完成

2023.7.15排序算法合集,Matrix,排序算法,算法,java

    /**
     * 归并排序：将数组递归地分成两半，对每个子数组进行排序，然后将两个有序子数组合并成一个有序数组
     */
    public static void mergeSort() {
        int[] mergeSortNums = nums.clone();
        merge(mergeSortNums, 0, mergeSortNums.length - 1);
        System.out.print("归并排序： ");
        System.out.println(Arrays.toString(mergeSortNums));
    }

    /**
     * 归并排序：将数组递归地分成两半，对每个子数组进行排序，然后将两个有序子数组合并成一个有序数组
     * @param mergeSortNums 子序列
     * @param start 子序列起点
     * @param end 子序列终点
     */
    public static void merge(int[] mergeSortNums, int start, int end) {
        if (start < end) {
            int middle = (end - start) / 2 + start;
            merge(mergeSortNums, start, middle);
            merge(mergeSortNums, middle + 1, end);
            //合并两个子序列，暂存到临时数组
            int num = start;
            int i = start;
            int j = middle + 1;
            int[] temp = new int[mergeSortNums.length];
            while (i <= middle && j <= end) {
                if (mergeSortNums[i] <= mergeSortNums[j]) {
                    temp[num++] = mergeSortNums[i++];
                } else {
                    temp[num++] = mergeSortNums[j++];
                }
            }
            while (i <= middle) {
                temp[num++] = mergeSortNums[i++];
            }
            while (j <= end) {
                temp[num++] = mergeSortNums[j++];
            }
            //拷贝回初始数组
            System.arraycopy(temp, start, mergeSortNums, start, end - start + 1);
        }
    }

归并排序的时间复杂度为O(NlogN)，其中N为待排序元素的数量

6.计数排序

  计数排序是一种非比较的排序算法，它通过统计待排序序列中每个元素出现的次数，进而确定每个元素在有序序列中的位置。计数排序适用于待排序序列中的元素都是非负整数，并且元素的范围相对较小的情况。计数排序的步骤如下：

  1. 找出待排序序列中的最大元素，并确定计数数组的大小。计数数组的大小为最大元素值加1
  2. 统计待排序序列中每个元素出现的次数，并将统计结果存储在计数数组中。计数数组的下标表示元素的值，数组中存储的值表示该元素出现的次数
  3. 对计数数组进行顺序求和操作。将计数数组中的每个元素与前一个元素相加，得到每个元素在有序序列中的最后位置的索引
  4. 创建一个与待排序序列大小相同的辅助数组
  5. 从后往前遍历待排序序列，根据元素的值找到其在计数数组中对应的索引，将元素放入辅助数组中的正确位置
  6. 将辅助数组中的元素复制回原始序列，完成排序。

2023.7.15排序算法合集,Matrix,排序算法,算法,java

    /**
     * 计数排序：对每个输入元素进行计数，然后根据计数值的顺序重构有序数组
     * @param start 数据左起始范围
     * @param end 数据右起始范围
     */
    public static void countSort(int start, int end) {
        int[] countSortNums = nums.clone();
        int[][] numCount = new int[Math.abs(start) + Math.abs(end) + 1][2];//计数
        int temp = start;
        for (int i = 0; i < numCount.length; i++) {
            numCount[i][0] = temp++;
        }
        for (int i = 0; i < countSortNums.length; i++) {
            numCount[countSortNums[i] + Math.abs(start)][1]++;
        }
        int index = 0;
        int indexNum = 0;
        for (int i = 0; i < numCount.length; i++) {
            if (numCount[i][1] != 0 && indexNum != 0) {
                numCount[i][1] += numCount[index][1];
                index = i;
            } else if (numCount[i][1] != 0 && indexNum == 0) {
                indexNum++;
                index = i;
            }
        }//计算排序位置
        int left = 0;
        int right = -1;
        for (int j = 0; j < numCount.length; j++) {
            if (numCount[j][1] != 0) {
                right = numCount[j][1];
                for (int i = left; i < right; i++) {
                    countSortNums[i] = numCount[j][0];
                }
                left = right;
            }
        }
        System.out.print("计数排序： ");
        System.out.println(Arrays.toString(countSortNums));
    }

三、完整源码

package Yskysoar;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @author Yskysoar
 * @createTime 2023-07-12 19:29
 * @description 排序算法
 * 1.所有测试对象为数组、链表或者树，默认为数组
 * 2.提供用例随机初始化方法
 * 3.排序结果从小到大排列
 */
public class SortAlgorithm {
    public static int number;//用例数据量
    public static int[] nums;//用例数组

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入数据量，数据起点，数据终点：");
        number = scanner.nextInt();
        int start = scanner.nextInt();
        int end = scanner.nextInt();
//        nums = new int[] {3, 8, 10, 5, 10, 10, 3, 4, 2, 9};
        initNums(number, start, end);
        System.out.print("初始数据： ");
        System.out.println(Arrays.toString(nums));
        //冒泡排序
        bubbleSort();
        //选择排序
        selectSort();
        //插入排序
        insertSort();
        //快速排序
        quickSort();
        //归并排序
        mergeSort();
        //计数排序
        countSort(start, end);
    }

    /**
     * 用例随机初始化
     * @param number 用例数据量
     * @param start  用例起始范围
     * @param end    用例结束范围
     */
    public static void initNums(int number, int start, int end) {
        nums = new int[number];
        for (int i = 0; i < nums.length; i++) {
            nums[i] = (int) (Math.random() * (end - start + 1) + start);
        }
    }

    /**
     * 冒泡排序:从左到右逐个比较相邻的元素，并进行交换，每一轮将最大的元素移到最右侧
     */
    public static void bubbleSort() {
        int[] bubbleSortNums = nums.clone();
        for (int i = 1; i < bubbleSortNums.length; i++) {
            for (int j = 0; j < bubbleSortNums.length - i; j++) {
                if (bubbleSortNums[j] > bubbleSortNums[j + 1]) {//已经确保两个数不相同，所以异或不会丢失数据
                    bubbleSortNums[j] ^= bubbleSortNums[j + 1];
                    bubbleSortNums[j + 1] ^= bubbleSortNums[j];
                    bubbleSortNums[j] ^= bubbleSortNums[j + 1];
                }
            }
        }
        System.out.print("冒泡排序： ");
        System.out.println(Arrays.toString(bubbleSortNums));
    }

    /**
     * 选择排序:每一轮从未排序的部分选择最小（或最大）的元素，放到已排序部分的末尾
     */
    public static void selectSort() {
        int[] selectionSortNums = nums.clone();
        for (int i = 0; i < selectionSortNums.length - 1; i++) {//计数
            int maxNum = 0;//记录极大值的索引
            for (int j = 0; j < selectionSortNums.length - i; j++) {
                if (selectionSortNums[maxNum] < selectionSortNums[j]) {
                    maxNum = j;
                }
            }
            //下面的if是用异或交换元素的重点，防止置0
            if (maxNum != selectionSortNums.length - i - 1) {//如果已经在对应位置就不需要移动，否则会导致异或同一个变量置0
                selectionSortNums[maxNum] ^= selectionSortNums[selectionSortNums.length - i - 1];
                selectionSortNums[selectionSortNums.length - i - 1] ^= selectionSortNums[maxNum];
                selectionSortNums[maxNum] ^= selectionSortNums[selectionSortNums.length - i - 1];
            }
        }
        System.out.print("选择排序： ");
        System.out.println(Arrays.toString(selectionSortNums));
    }

    /**
     * 插入排序：逐个将元素插入到已排序的序列中的正确位置，构建最终有序序列
     */
    public static void insertSort() {
        int[] insertSortNums = nums.clone();
        int temp = 0;//记录待插入的值
        int index = 0;//记录插入的位置
        boolean isFlag;
        for (int i = 1; i < insertSortNums.length; i++) {
            isFlag = false;
            for (int j = 0; j < i; j++) {
                if (insertSortNums[i] < insertSortNums[j]) {
                    index = j;
                    temp = insertSortNums[i];
                    isFlag = true;
                    break;
                }
            }
            if (isFlag) {//当需要向前插入的时候才执行，否则不用移动
                /*
                public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
                src:源数组
                srcPos:源数组要复制的起始位置
                dest:目的数组
                destPos:目的数组放置的起始位置
                length:复制的长度
                 */
                System.arraycopy(insertSortNums, index, insertSortNums, index + 1, i - index);
//                for (int j = i; j > index; j--) {
//                    insertSortNums[j] = insertSortNums[j - 1];
//                }
                insertSortNums[index] = temp;
            }
        }
        System.out.print("插入排序： ");
        System.out.println(Arrays.toString(insertSortNums));
    }

    /**
     * 快速排序：选择一个基准元素，将数组分为小于基准值和大于基准值的两部分，递归地对这两部分进行排序(默认首元素为基准)
     */
    public static void quickSort() {
        int[] quickSortNums = nums.clone();
        quick(quickSortNums, 0, quickSortNums.length - 1);
        System.out.print("快速排序： ");
        System.out.println(Arrays.toString(quickSortNums));
    }

    /**
     * 快速排序：选择一个基准元素，将数组分为小于基准值和大于基准值的两部分，递归地对这两部分进行排序(默认首元素为基准)
     * @param quickSortNums 待排序数组
     * @param start 左起点
     * @param end 右起点
     */
    public static void quick(int[] quickSortNums, int start, int end) {
        if (start < end) {//直到序列内只有一个元素时，无需排序，结束递归
            int left = start;
            int right = end;
            int pivotIndex = start;//基准元素的索引值(选择第一个元素作为基准元素)
            //寻找基轴位置
            while (left < right) {
                //右侧扫描
                while (left < right && quickSortNums[right] >= quickSortNums[pivotIndex]) {//找到第一个小于基准的元素
                    right--;
                }//和基轴交换位置
                if (left < right) {//保证小于基准的元素在右侧
                    quickSortNums[right] ^= quickSortNums[pivotIndex];
                    quickSortNums[pivotIndex] ^= quickSortNums[right];
                    quickSortNums[right] ^= quickSortNums[pivotIndex];
                    pivotIndex = right;
                }
                //左侧扫描
                while (left < right && quickSortNums[left] <= quickSortNums[pivotIndex]) {//找到第一个大于基准的元素
                    left++;
                }//和基轴交换位置
                if (left < right) {//保证大于基准的元素在左侧
                    quickSortNums[left] ^= quickSortNums[pivotIndex];
                    quickSortNums[pivotIndex] ^= quickSortNums[left];
                    quickSortNums[left] ^= quickSortNums[pivotIndex];
                    pivotIndex = left;
                }
            }
            //左右子序列递归排序
            quick(quickSortNums, start, pivotIndex - 1);
            quick(quickSortNums, pivotIndex + 1, end);
        }
    }

    /**
     * 归并排序：将数组递归地分成两半，对每个子数组进行排序，然后将两个有序子数组合并成一个有序数组
     */
    public static void mergeSort() {
        int[] mergeSortNums = nums.clone();
        merge(mergeSortNums, 0, mergeSortNums.length - 1);
        System.out.print("归并排序： ");
        System.out.println(Arrays.toString(mergeSortNums));
    }

    /**
     * 归并排序：将数组递归地分成两半，对每个子数组进行排序，然后将两个有序子数组合并成一个有序数组
     * @param mergeSortNums 子序列
     * @param start 子序列起点
     * @param end 子序列终点
     */
    public static void merge(int[] mergeSortNums, int start, int end) {
        if (start < end) {
            int middle = (end - start) / 2 + start;
            merge(mergeSortNums, start, middle);
            merge(mergeSortNums, middle + 1, end);
            //合并两个子序列，暂存到临时数组
            int num = start;
            int i = start;
            int j = middle + 1;
            int[] temp = new int[mergeSortNums.length];
            while (i <= middle && j <= end) {
                if (mergeSortNums[i] <= mergeSortNums[j]) {
                    temp[num++] = mergeSortNums[i++];
                } else {
                    temp[num++] = mergeSortNums[j++];
                }
            }
            while (i <= middle) {
                temp[num++] = mergeSortNums[i++];
            }
            while (j <= end) {
                temp[num++] = mergeSortNums[j++];
            }
            //拷贝回初始数组
            System.arraycopy(temp, start, mergeSortNums, start, end - start + 1);
        }
    }

    /**
     * 计数排序：对每个输入元素进行计数，然后根据计数值的顺序重构有序数组
     * @param start 数据左起始范围
     * @param end 数据右起始范围
     */
    public static void countSort(int start, int end) {
        int[] countSortNums = nums.clone();
        int[][] numCount = new int[Math.abs(start) + Math.abs(end) + 1][2];//计数
        int temp = start;
        for (int i = 0; i < numCount.length; i++) {
            numCount[i][0] = temp++;
        }
        for (int i = 0; i < countSortNums.length; i++) {
            numCount[countSortNums[i] + Math.abs(start)][1]++;
        }
        int index = 0;
        int indexNum = 0;
        for (int i = 0; i < numCount.length; i++) {
            if (numCount[i][1] != 0 && indexNum != 0) {
                numCount[i][1] += numCount[index][1];
                index = i;
            } else if (numCount[i][1] != 0 && indexNum == 0) {
                indexNum++;
                index = i;
            }
        }//计算排序位置
        int left = 0;
        int right = -1;
        for (int j = 0; j < numCount.length; j++) {
            if (numCount[j][1] != 0) {
                right = numCount[j][1];
                for (int i = left; i < right; i++) {
                    countSortNums[i] = numCount[j][0];
                }
                left = right;
            }
        }
        System.out.print("计数排序： ");
        System.out.println(Arrays.toString(countSortNums));
    }
}

本人技术水平一般，各位大佬如果发现我的不足之处或者有好的建议可以指出，谢谢大家文章来源地址https://www.toymoban.com/news/detail-571503.html

到了这里，关于2023.7.15排序算法合集的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 常见排序算法—面试编程题2023

    常见排序算法—面试编程题2023

    最近在看一些面试题，发现很多面试过程中都会要求手写排序编程题，经过一番查找整理，可以快速学习和使用相关排序算法题，通俗易懂，手撕代码吊打面试官。 冒泡排序 是一种简单的排序算法，它重复地遍历待排序的数组，每次比较相邻的两个元素，如果顺序不对就交

    2024年02月12日
    浏览(37)

  • 【排序算法略解】（十种排序的稳定性，时间复杂度以及实现思想）（含代码）（完工于2023.8.3）

    注：以下排序默认为升序排序。 稳定性：指的是排序的过程中是否会改变多个相同的值的相对次序，如果会改变则是不稳定的。 冒泡排序，选择排序，插入排序是最简单的排序方法。 排序方法：扫描的过程中，比较相邻两个数的大小关系，如果存在逆序就交换这两个数，这

    2024年02月13日
    浏览(50)
  • 十大排序算法及Java中的排序算法

    十大排序算法及Java中的排序算法

    常见的排序算法有十种，可以分为以下两大类： 非线性时间比较类排序 ：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(n log n)，因此称为非线性时间比较类排序 线性时间非比较类排序 ：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时

    2024年02月08日
    浏览(45)
  • JAVA算法（二）排序算法

    JAVA算法（二）排序算法

    定义：相邻的数据两两比较，小的 放前面，大的放后面 过程： 相邻的元素两两比较，小的放左边，大的放右边。 第一轮比较完毕之后，最大值就已经确定，第二轮可以少循环一次，后面以此类推。 如果数组中有n个数据，总共我们只要执行n-1轮的代码就可以。 定义： 从0索

    2024年02月05日
    浏览(36)
  • Java 与排序算法（1）：冒泡排序

    Java 与排序算法（1）：冒泡排序

    冒泡排序（Bubble Sort）是一种简单的排序算法，它的基本思想是通过不断交换相邻两个元素的位置，使得较大的元素逐渐往后移动，直到最后一个元素为止。冒泡排序的时间复杂度为 O ( n 2 ) O(n^2) O ( n 2 ) ，空间复杂度为 O ( 1 ) O(1) O ( 1 ) ，是一种稳定的排序算法。 其实现过程

    2024年02月11日
    浏览(43)
  • Java玩转《啊哈算法》排序之桶排序

    Java玩转《啊哈算法》排序之桶排序

    过去心不可得，现在心不可得，未来心不可得 大家好！本人最近看了下《啊哈算法》，写的确实不错，生动形象又有趣（ 我没收钱，确实如此 ）。 但对我来说，稍显遗憾的是，书籍代码是c语言，而不是本人常用的Java。 那就弥补遗憾，说干就干，把这本书的示例语言用ja

    2024年01月25日
    浏览(45)
  • Java：简单算法：冒泡排序、选择排序、二分查找

    Java：简单算法：冒泡排序、选择排序、二分查找

    2024年02月13日
    浏览(38)

  • 【满分】【华为OD机试真题2023 JAVA&JS】字符串重新排序

    知识点排序数组  时间限制：1s 空间限制：256MB 限定语言：不限 给定一个字符串s，s包含以空格分隔的若干个单词，请对s进行如下处理后输出： 1、单词内部调整：对每个单词字母重新按字典序排序； 2、单词间顺序调整：     1）统计每个单词出现

    2023年04月23日
    浏览(60)
  • 六大排序算法（Java版）：从插入排序到快速排序（含图解）

    六大排序算法（Java版）：从插入排序到快速排序（含图解）

    目录 插入排序 (Insertion Sort) 直接插入排序的特性总结： 选择排序 (Selection Sort) 直接选择排序的特性总结 冒泡排序 (Bubble Sort)  冒泡排序的特性总结 堆排序（Heap Sort） 堆排序的特性总结 希尔排序 (Shell Sort)   希尔排序的特性总结 快速排序（Quick Sort） Hoare版  挖坑法  前后指

    2024年02月09日
    浏览(51)
  • 【Java面试题】Java基础——排序算法

    【Java面试题】Java基础——排序算法

    冒泡排序★★★ 冒泡排序（Bubble Sort）也是一种简单直观的排序算法。 它重复的遍历过要排序的数列， 一次比较相邻的两个元素，如果他们的顺序错误就把他们交换过来 。 这个算法的名字由来是因为越大的元素会经由交换慢慢\\\"浮\\\"到最后面。 当然，大家可以按照从大到小的

    2024年02月12日
    浏览(33)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包