七大排序算法

最新推荐文章于 2024-10-31 16:16:13 发布
最新推荐文章于 2024-10-31 16:16:13 发布
阅读量990 收藏 16
点赞数 24
分类专栏： 算法 文章标签： 排序算法 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_77179144/article/details/136255115
版权

文章目录

排序的概念

所谓排序，就是使一串数据，按照某种比较规则，递增或递减地排列的操作。

稳定性：假定在待排序的数据中，存在多个相同数据，若经过排序，这些数据的相对次序保持不变，则称这种排序算法是稳定的；否则称为不稳定的。

  • 一个本身就不稳定的排序，是不可能变成一个稳定的排序的
  • 但是一个本身就稳定的排序，是可以实现为不稳定的排序的

在这里插入图片描述

内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，外存中的数据读入内存→在内存中排序→数据写入外存。

常见的排序算法

在这里插入图片描述

插入排序

直接插入排序的基本思想是：把数据逐个插入到一个已经有序的序列中，直到所有的记录插入完得到一个新的有序序列 。

在这里插入图片描述

    public static void insertSort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int tmp = array[i];
            int j = i-1;
            for (; j >= 0 ; j--) {
                //加不加等号能决定这个排序的稳定性,也就是array[j] >= tmp是不稳定的
                if(array[j] > tmp) {
                    array[j+1] = array[j];
                }else {
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

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

  1. 数据越趋于有序，直接插入排序算法的时间效率越高
  2. 时间复杂度：
    • 最好情况：数据有序的情况下：O(N)
    • 最坏情况：数据逆序的情况下:O( N 2 N^2 N2)
  3. 空间复杂度：O(1)
  4. 稳定性：稳定

希尔排序( 缩小增量排序 )

希尔排序的基本思想是：先选定一个整数gap，把待排序的元素分成gap组，所有距离为gap的元素分在同一组，并对每一组的元素进行插入排序。然后，取新的gap，重复上述分组和排序的工作。当gap ==1时，所有元素排好序。

  • 跳跃式分组尽可能把大的元素放到后边,小的元素放到前边
  • 除了gap == 1以外的排序都是预排序,每次预排序后都接近有序,最后gap == 1的时候,整体插入排序效率就高了
    在这里插入图片描述
    时间复杂度我们暂时就按照O( N 1.25 N^{1.25} N1.25)到O(1.6 N 1.25 N^{1.25} N1.25)来算。

’

以gap = gap/2为例

在这里插入图片描述

public static void shellSort(int[] array) {
        int gap = array.length;
        while (gap > 1) {
            gap = gap / 2;
            shell(array,gap);
        }
    }

    private static void shell(int[] array,int gap) {
        for (int i = gap; i < array.length; i++) {
            int tmp = array[i];
            int j = i-gap;
            for (; j >= 0 ; j-=gap) {
                if(array[j] > tmp) {
                    array[j+gap] = array[j];
                }else {
                    break;
                }
            }
            array[j+gap] = tmp;
        }
    }

希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序，目的是让数据更接近于有序。当gap == 1时，数据已经接近有序了，这样插入排序效率会高,可以达到优化的效果。
  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多
  4. 稳定性：不稳定

选择排序

每一次从待排序的数据中选出最小（或最大）的一个元素，存放在相应位置，直到全部数据排完 。

在这里插入图片描述

 public static void selectSort(int[] array) {
        for (int i = 0; i < array.length-1; i++) {
            int minIndex = i;
            for (int j = i+1; j < array.length; j++) {
                if(array[j] < array[minIndex]) {
                    minIndex = j;
                }
            }
            swap(array,i,minIndex);
        }
    }

    private static void swap(int[] array,int i,int j) {
        int tmp = array[j];
        array[j] = array[i];
        array[i] = tmp;
    }

还有一种:

    public static void selectSort2(int[] array) {
        int left = 0;
        int right = array.length-1;
        while (left < right) {
            int minIndex = left;
            int maxIndex = left;
            for (int i = left+1; i <= right ; i++) {
                if(array[i] < array[minIndex]) {
                    minIndex = i;
                }
                if(array[i] > array[maxIndex]) {
                    maxIndex = i;
                }
            }
            swap(array,minIndex,left);
            //第一次交换 最大值可能是left,然后被换到了minIndex的位置
            if(maxIndex == left) {
                maxIndex = minIndex;
            }
            swap(array,maxIndex,right);
            left++;
            right--;
        }
    }
	private static void swap(int[] array,int i,int j) {
        int tmp = array[j];
        array[j] = array[i];
        array[i] = tmp;
    }

【直接选择排序的特性总结】

  1. 直接选择排序效率不是很好。实际中很少使用
  2. 时间复杂度：O( N 2 N^2 N2)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

堆排序

堆排序即利用堆的思想来进行排序，总共分为两个步骤：

  1. 建堆
    升序：建大堆
    降序：建小堆
  2. 利用堆删除思想来进行排序
    用到向下调整
	public static void heapSort(int[] array){
        //创建大根堆
        createHeap(array);
        int end = array.length-1;
        while (end > 0) {
            swap(array,0,end);
            siftDown(array,0,end--);
        }
    }

    private static void createHeap(int[] array) {
        for (int parent = (array.length-1-1)/2; parent >= 0 ; parent--) {
            siftDown(array,parent,array.length);
        }
    }
    private static void swap(int[] array,int i,int j) {
        int tmp = array[j];
        array[j] = array[i];
        array[i] = tmp;
    }
    private static void siftDown(int[] array,int parent,int len) {
        int child = (2*parent)+1;
        while (child < len) {
            if(child + 1 < len && array[child] < array[child+1]) {
                child = child+1;
            }
            //child一定是 左右孩子最大值的下标
            if(array[child] > array[parent]) {
                swap(array,child,parent);
                parent = child;
                child = 2*parent+1;
            }else {
                break;
            }
        }
    }

常见习题：

1.一组记录排序码为(5 11 7 2 3 17),则利用堆排序方法建立的初始堆为()
A: (11 5 7 2 3 17) B: (11 5 7 2 17 3) C: (17 11 7 2 3 5)
D: (17 11 7 5 3 2) E: (17 7 11 3 5 2) F: (17 7 11 3 2 5)
答案：C

【堆排序的特性总结】

  1. 堆排序使用堆来选数，效率就高了很多。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

冒泡排序

在这里插入图片描述

    public static void bubbleSort(int[] array) {
        //i代表趟数
        for (int i = 0; i < array.length-1; i++) {
            boolean flg = false;
            for(int j = 0;j < array.length-1-i;j++) {
                if(array[j] > array[j+1]) {
                    swap(array,j,j+1);
                    flg = true;
                }
            }
            //没有交换证明有序了
            if(flg == false) {
                return;
            }
        }
    }

【冒泡排序的特性总结】

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

快速排序

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，以该元素为基准将待排序序列分割成两子列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

主框架如下:

    public static void quickSort(int[] array) {
        quick(array,0,array.length-1);
    }

 	void quick(int[] array, int start, int end) {
        if(start >= end) {
            return;
        }
        // 按照基准值对array数组的 [left, right)区间中的元素进行划分
        int pivot = partition(array, start, end);
        quick(array, start, pivot-1);
        quick(array, pivot+1, end);
    }

    int partition(int[] array, int left, int right) {

    }

只需分析如何按照基准值来对区间中数据进行划分即可。将区间按照基准值划分为左右两部分的常见方式有：

Hoare法

  • 时间复杂度：

    • 最好情况下：O(N*logN)
    • 最坏情况下(有序 / 逆序)： O ( N 2 ) O(N^2) O(N2)

  • 空间复杂度：

    • 最好情况下：O(logN)
    • 最坏情况下(有序 / 逆序)：O(N)

  • 稳定性: 不稳定的排序

	public static void quickSort(int[] array) {
        quick(array,0,array.length-1);
    }
	
	void quick(int[] array, int start, int end) {
        if(start >= end) {
            return;
        }
        int pivot = partition(array, start, end);
        quick(array, start, pivot-1);
        quick(array, pivot+1, end);
    }

    private static void swap(int[] array,int i,int j) {
        int tmp = array[j];
        array[j] = array[i];
        array[i] = tmp;
    }
    
    private static int partition (int[] array,int left,int right) {
        int tmp = array[left];//基准
        int i = left;
        while (left < right) {
            while (left < right && array[right] >= tmp) {
                right--;
            }
            while (left < right && array[left] <= tmp) {
                left++;
            }
            swap(array,left,right);
        }
        swap(array,i,left);
        return left;
    }

挖坑法

	private static int partition(int[] array,int left,int right) {
        int tmp = array[left];
        while (left < right) {
            while (left < right && array[right] >= tmp) {
                right--;
            }
            if(left == right) {
                break;
            }
            array[left] = array[right];
            while (left < right && array[left] <= tmp) {
                left++;
            }
            if(left == right) {
                break;
            }
            array[right] = array[left];
        }
        array[left] = tmp;
        return left;
    }

前后指针(只需了解)

写法一:

 private static int partition(int[] array, int left, int right) {
        int prev = left ;
        int cur = left+1;
        while (cur <= right) {
            if(array[cur] < array[left] && array[++prev] != array[cur]) {
                swap(array,cur,prev);
            }
            cur++;
        }
        swap(array,prev,left);
        return prev;
    }

写法二:

private static int partition(int[] array, int left, int right) {
        int end = left + 1;
        int pivot = array[left];
        for (int i = left + 1; i <= right; i++) {
            if (array[i] < pivot) {
                swap(array, i, end);
                end++;
            }
        }
        swap(array, end - 1, left);
        return end - 1;
    }

快速排序优化

  1. 三数取中法选key
  2. 递归到小的子区间时，因为已经趋于有序,可以考虑使用插入排序
private static void quick(int[] array,int start,int end) {
        if(start >= end) {
            return;
        }
        //小的子区间进行插入排序
        if(end-start+1 <= 15) {
            insertSort(array, start, end);
            return;
        }

        //1. 三数取中  index是中间大的数字 的 下标
        int index = middleNum(array,start,end);
        swap(array,index,start);

        int pivot = partition(array,start,end);

        quick(array,start,pivot-1);
        quick(array,pivot+1,end);
    }


    public static void insertSort(int[] array,int start,int end) {
        for (int i = start+1; i <= end; i++) {
            int tmp = array[i];
            int j = i-1;
            for (; j >= start ; j--) {
                if(array[j] > tmp) {
                    array[j+1] = array[j];
                }else {
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

    private static int middleNum(int[] array,int left,int right) {
        int mid = left+((right-left) >> 1);
        //相当于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[right]) {
                return right;
            }else if(array[mid] > array[left]) {
                return left;
            }else {
                return mid;
            }
        }
    }

快速排序非递归

	public static void quickSortNor(int[] array) {
        Stack<Integer> stack = new Stack<>();
        int left = 0;
        int right = array.length-1;
        int pivot = partition(array,left,right);

        if(pivot-1 > left) {
            stack.push(left);
            stack.push(pivot-1);
        }
        if(pivot + 1 < right) {
            stack.push(pivot+1);
            stack.push(right);
        }
        while (!stack.isEmpty()) {
            right = stack.pop();
            left = stack.pop();
            pivot = partition(array,left,right);

            if(pivot-1 > left) {
                stack.push(left);
                stack.push(pivot-1);
            }
            if(pivot + 1 < right) {
                stack.push(pivot+1);
                stack.push(right);
            }
        }
    }

快速排序总结

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才叫快速排序
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(logN)
  4. 稳定性：不稳定

归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将有序的子序列合并，得到完全有序的序列.

在这里插入图片描述

    public static void mergeSort(int[] array) {
        mergeFunc(array,0,array.length-1);
    }

    private static void mergeFunc(int[] array,int left,int right) {
        if(left >= right) {
            return;
        }
        int mid = left + ((right-left) >> 1);
        mergeFunc(array,left,mid);
        mergeFunc(array,mid+1,right);
        //左边分解完，右边分解完，开始合并
        merge(array,left,mid,right);
    }

    private static void merge(int[] array,int left,int mid,int right) {
        int s1 = left;
        int e1 = mid;
        int s2 = mid+1;
        int e2 = right;
        int[] tmpArr = new int[right-left+1];
        int k = 0;
        //1.保证两个表 都有数据
        while (s1 <= e1 && s2 <= e2) {
            if(array[s1] <= array[s2]) {
                tmpArr[k++] = array[s1++];
            }else {
                tmpArr[k++] = array[s2++];
            }
        }
        //2. 看哪个数组 还有数据 拷贝回去
        while (s1 <= e1) {
            tmpArr[k++] = array[s1++];
        }
        while (s2 <= e2) {
            tmpArr[k++] = array[s2++];
        }
        //3.拷贝到源数组
        for (int i = 0; i < k; i++) {
            array[i+left] = tmpArr[i];
        }
    }

非递归实现归并排序：

	public static void mergeSortNor(int[] array) {
        int  gap = 1;
        //gap是待排序的个子组的元素个数
        while (gap < array.length) {
            //对子组两两进行排序
            for (int i = 0; i < array.length; i = i+2*gap) {
                int left = i;
                int mid = left + gap-1;
                if(mid >= array.length) {
                    mid = array.length-1;
                }
                int right = mid+gap;
                if(right >= array.length) {
                    right = array.length-1;
                }
                merge(array,left,mid,right);
            }
            gap *= 2;
        }
    }
	private static void merge(int[] array,int left,int mid,int right) {
        int s1 = left;
        int e1 = mid;
        int s2 = mid+1;
        int e2 = right;
        int[] tmpArr = new int[right-left+1];
        int k = 0;
        //1.保证两个表 都有数据
        while (s1 <= e1 && s2 <= e2) {
            if(array[s1] <= array[s2]) {
                tmpArr[k++] = array[s1++];
            }else {
                tmpArr[k++] = array[s2++];
            }
        }
        //2. 看哪个数组 还有数据 拷贝回去
        while (s1 <= e1) {
            tmpArr[k++] = array[s1++];
        }
        while (s2 <= e2) {
            tmpArr[k++] = array[s2++];
        }
        //3.拷贝到源数组
        for (int i = 0; i < k; i++) {
            array[i+left] = tmpArr[i];
        }
    }

归并排序总结

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(N)
  4. 稳定性：稳定

海量数据的排序问题

外部排序：排序过程对在磁盘等外部存储进行的排序
前提：内存只有 1G，需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序

  1. 先把文件切分成 200 份，每个 512 M
  2. 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以
  3. 进行 2路归并，同时对 200 份有序文件做归并过程，最终结果就有序了

排序算法复杂度及稳定性分析

在这里插入图片描述
数据敏感的意思是数据越有序,排序速度越快(冒泡,插入,希尔),数据越有序,排序速度越慢(快排).对于其余排序,数据是否有序对其效率影响不大

排序方法最好时间平均时间最坏时间空间复杂度稳定性
冒泡排序优化后O(n)O( n 2 n^2 n2)O( n 2 n^2 n2)O(1)稳定
插入排序O(n)O( n 2 n^2 n2)O( n 2 n^2 n2)O(1)稳定
选择排序O( n 2 n^2 n2)O( n 2 n^2 n2)O( n 2 n^2 n2)O(1)不稳定
希尔排序O(n)O( n 1.3 n^{1.3} n1.3)O( n 2 n^2 n2)O(1)不稳定
堆排序O(n*logn)O(n*logn)O(n*logn)O(1)不稳定
快速排序O(n*logn)O(n*logn)O( n 2 n^2 n2)O(logn) ~ O(n)不稳定
归并排序O(n*logn)O(n*logn)O(n*logn)O(n)稳定

其他排序（只需了解）

计数排序

思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤：

  1. 统计相同元素出现次数
  2. 根据统计的结果将序列回收到原来的序列中

在这里插入图片描述

    public static void countSort(int[] array) {
        //1.求最值 
        int min = array[0];
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(min > array[i]) {
                min = array[i];
            }
            if(max < array[i]) {
                max = array[i];
            }
        }
        //2、定义计数数组 进行初始化 
        int[] count = new int[max-min+1];
        for (int i = 0; i < array.length; i++) {
            int index = array[i]-min;
            count[index]++;
        }

        //3、遍历计数数组 
        int k = 0;//表示array数组的下标
        for (int i = 0; i < count.length; i++) {
            while (count[i] != 0) {
                array[k++] = i + min;
                count[i]--;
            }
        }
    }
}

【计数排序的特性总结】

  1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
  2. 时间复杂度：O(范围+n)
  3. 空间复杂度：O(范围)
  4. 稳定性：稳定

基数排序

最大值的位数,就是进出的次数

在这里插入图片描述

桶排序

在这里插入图片描述

选择题

  1. 快速排序算法是基于()的一个排序算法。
    A：分治法 B：贪心法 C：递归法 D：动态规划法

选A

2.对记录（54,38,96,23,15,72,60,45,83）进行从小到大的直接插入排序时，当把第8个记录45插入到有序表时，为找到插入位置需比较()次？（采用从后往前比较）
A: 3 B: 4 C: 5 D: 6

在这里插入图片描述
5次,选C

3.以下排序方式中占用O(n)辅助存储空间的是()
A: 简单排序 B: 快速排序 C: 堆排序 D: 归并排序

没有简单排序,选D

4.下列排序算法中稳定且时间复杂度为O(n^2)的是()
A: 快速排序 B: 冒泡排序 C: 直接选择排序 D: 归并排序

选B

5.关于排序，下面说法不正确的是()
A: 快排时间复杂度为O(N*logN)，空间复杂度为O(logN)
B: 归并排序是一种稳定的排序,堆排序和快排均不稳定
C: 序列基本有序时，快排退化成 “冒泡排序”，直接插入排序最快
D: 归并排序空间复杂度为O(N), 堆排序空间复杂度的为O(logN)

选D,堆排序空间复杂度的为O(1)

6.设一组初始记录关键字序列为(65,56,72,99,86,25,34,66)，则以第一个关键字65为基准而得到的一趟快速排序结果是（）
A: 34，56，25，65，86，99，72，66 B: 25，34，56，65，99，86，72，66
C: 34，56，25，65，66，99，86，72 D: 34，56，25，65，99，86，72，66

首先试挖坑法,再是Hoare法,最后是前后指针法
选A

el psy congroo
关注
专栏目录
常见的七大排序算法Java实现.zip
07-30
本压缩包"常见的七大排序算法Java实现.zip"包含了七种经典的排序算法在Java语言中的实现。尽管文件列表中并未明确列出每种排序算法的名称，但根据常规，这七大排序算法可能包括冒泡排序、插入排序、选择排序、快速...
七大经典排序算法总结详解
12-29
以上七大排序算法各有特点，选择哪种取决于具体的应用场景。例如，如果数据基本有序，插入排序可能更合适；对于大规模数据，快速排序或归并排序是更好的选择。理解这些排序算法，不仅有助于编程实践，也有助于提升...
挑战七大排序算法-04堆排序
01-07
堆排序 1.原理 2.实现 3.性能分析 堆排序 1.原理 基本原理也是选择排序，只是不再使用遍历的方式查找无序区间的最大数，而是通过堆来选择无序区间的最大数 升序：大顶堆；降序：小顶堆 堆排序的基本思路： a.将无需...
C/C++每日一练：实现选择排序
weixin_60461563的博客
10-28 538
实现一个选择排序算法，用于对整数数组进行升序排序。输入是一个包含若干整数的数组，输出是排序后的数组。要求在原数组上进行排序，不借助额外的数组空间（即就地排序）。选择排序的基本思想是：每次从未排序部分选择最小的元素，将其放到已排序部分的末尾。这样经过多轮操作后，整个数组会被逐步排好序。假设有一个数组 arr，长度为 n。，其中 n 是数组长度，不适合大数据集的排序，适合于元素较少且对性能要求不高的场景。选择排序是一种简单直观的排序算法，时间复杂度为。
C++ | Leetcode C++题解之第514题自由之路
Ddddddd_158的博客
10-27 408
C++ | Leetcode C++题解之第514题自由之路
数对的最大曼哈顿距离[ABC178E] Dist Max
2301_80882026的博客
10-30 385
/曼哈顿距离化简绝对值之后最终可以化简为两种取最大的即可PII p[N];cin >> n;i <= n;
【二分查找】【三种写法】——在排序数组中查找元素的第一个和最后一个位置#力扣hot100
最新发布
weixin_47868976的博客
10-31 722
给你一个按照非递减顺序排列的整数数组nums，和一个目标值target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值target，返回[-1, -1]。必须设计并实现时间复杂度为O(log n)的算法解决此问题。
【支持在线评测】二叉树计算
春秋招笔试突围
10-28 73
给定一个二叉树，请生成一个新的二叉树，使得新树中的每个节点的值等于原始树中该节点的左子树和右子树所有节点值的和。左子树表示该节点左侧叶子节点为根节点的一颗新树；右子树表示该节点右侧叶子节点为根节点的一颗新树。首先，需要根据给定的中序遍历和前序遍历序列重建原始二叉树。这是因为只有重建出原始树的结构，才能正确计算每个节点的子树和。在重建树的过程中，同时计算每个节点的子树和。输出一行整数，表示生成的新二叉树（求和树）的中序遍历序列，以空格分隔。最后，对重建并计算好子树和的树进行中序遍历，输出结果。
算法笔记：Day-04（二维前缀和）
2302_78571314的博客
10-26 457
这道题真的很好，板子题😁。代码第一个方法是构造方法，构造出以左上角为a[0][0],右下角为a[i][j]的矩阵的和所构成的矩阵。然后第二个方法就可以计算任意子矩阵和了。
【深搜算法】（第四篇）
weixin_73861555的博客
10-27 1286
然⽽，通过观察我们可以发现，如果我们先删除最底部的叶⼦节点，然后再处理删除后的节点，最终的结果并不会受到影响。因此，在处理完⼦节点后，我们仍然需要处理当前节点。3. 函数作⽤：整合⽗节点的信息与当前节点的信息计算当前节点数字，并向下传递，在回溯时返回当前⼦树（当前节点作为⼦树根节点）数字和。前序遍历按照根节点、左⼦树、右⼦树的顺序遍历⼆叉树的所有节点，通常⽤于⼦节点的状态依赖于⽗节点状态的题⽬。后序遍历按照左⼦树、右⼦树、根节点的顺序遍历⼆叉树的所有节点，通常⽤于⽗节点的状态依赖于⼦节点状态的题⽬。
20240818 字节跳动 笔试
lc_guo的博客
10-22 3664
BSP驱动开发工程师-OS、4 道编程题
算法练习：四数之和
2302_80652761的博客
10-28 301
四数之和
算法有哪些
Mr.xing的博客
10-28 97
算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，代表着用系统的方法描述解决问题的策略机制。也就是说，算法能够对一定规范的输入，在有限时间内获得所要求的输出。算法应该具有有穷性、确切性、输入项、输出项以及可行性这五个重要的特征。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。在各个领域，算法都有着广泛的应用。例如，在数据分析与挖掘中，算法可以帮助开发人员有效地处理和分析海量数据，挖掘数据中隐藏的价值；
【算法】Kruskal最小生成树算法
Eristic0618的博客
10-29 677
算法学习笔记之Kruskal最小生成树算法
leetcode day7 442
m0_75005390的博客
10-27 431
给你一个长度为 n 的整数数组 nums ，其中 nums 的所有整数都在范围 [1, n] 内，且每个整数出现 最多两次。请你找出所有出现 两次 的整数，并以数组形式返回。你必须设计并实现一个时间复杂度为 O(n) 且仅使用常量额外空间（不包括存储输出所需的空间）的算法解决此问题。输入：nums = [4,3,2,7,8,2,3,1]输入：nums = [1,1,2]输入：nums = [1]
【从零开始的LeetCode-算法】3223. 操作后字符串的最短长度
九圣残炎的编程博客
10-26 339
无法对字符串进行任何操作，所以返回初始字符串的长度。请你返回执行完所有操作后，
算法的学习笔记—左旋转字符串(牛客JZ58)
业精于勤，荒于嬉
10-27 710
在这道题目中，使用三步翻转法避免了直接拼接带来的额外开销，使得操作更加高效简洁。无论是面试还是实际开发中，这种方法都非常实用。这个题目很好地锻炼了对字符串操作和数组翻转的理解，三步翻转法的思路在其他字符串旋转、数组循环移位等问题中也能得到广泛应用。希望这篇文章能帮助大家掌握并熟练应用这种方法。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区。
P11227 [CSP-J 2024] 扑克牌（民间数据）
xiebohang的博客
10-27 239
这道题在洛谷上被评定为红题，也确实挺简单的，就用到了STL里的set，set里的元素不会重复，就只需要把元素放到set里，在计算长度就可以，最后用52减去长度即可。
Java实现七大排序算法详解
"这篇文档包含了Java实现的七种排序算法，包括冒泡排序、选择排序、快速排序、插入排序、希尔排序、归并排序和堆排序。这些算法是编程学习中的基础部分，对于理解数据结构和算法有重要作用。" 详细说明： 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值