算法入门篇二 认识O(NlogN)的排序

最新推荐文章于 2023-04-10 23:44:15 发布
最新推荐文章于 2023-04-10 23:44:15 发布
阅读量362 收藏
点赞数
分类专栏： 算法入门 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CHYabc123456hh/article/details/106611762
版权

递归

例子引出

  • 使用递归的方法求出数组中的最大值（利用的是栈）
  • 求中点的方法改进
mid = (left + right) / 2  //但是如果left和right的数很大，相加会造成内容溢出
改进为 mid = left + (right - left) / 2  //(right - left)得到整个的长度，除以2之后，再加上左边的点，就可以得到中点的位置
改进为 mid = left + (right - left) >> 1 //使用位运算，加快计算速度

代码 

package com.example.demo.class01;

public class Code08_GetMax {
    public static void main(String[] args) {
        int arr[] = {1,2,4,3,2,8,6};
        int c = 0;
        c = getMax(arr);
        System.out.println(c);
    }
    public static int getMax(int[] arr){
        if(arr == null || arr.length == 0){
            System.out.println("输入数组不合理");
        }
        return process(arr,0,arr.length - 1);
    }
    public static int process(int[] arr,int L,int R){
        if(L == R){
            return arr[L];
        } //arr[L..R]只有一个数的时候，直接返回，base case
        int mid = L + ((R - L)>>1);
        int leftMax = process(arr,L,mid);
        int rightMax = process(arr,mid+1,R);
        return Math.max(leftMax,rightMax);
    }
}
//8

master公示的使用

  • 用于分析递归，用于解决 子问题规模 是一致的问题
T(N) = a*T(N/b) + O(N^d)

1,log(b,a) > d -> 复杂度为O(N^log(b,a))
2,log(b,a) = d -> 复杂度为O(N^d * logN)
3,log(b,a) < d -> 复杂度为O(N^d)

归并排序

  • 整体就是一个简单排序，左边排好顺序，右边排好顺序，使整体有序
  • 时间复杂度是O(N*logN)
  • 额外复杂度是O(N)

  • 代码

package com.example.demo.class01;

import java.util.Arrays;

public class MergeSort {

    public static void mergeSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        process(arr, 0, arr.length - 1);
    }

    public static void process(int[] arr, int L, int R) {
        if (L == R) {
            return;
        }
        int mid = L + ((R - L) >> 1);
        process(arr, L, mid);
        process(arr, mid + 1, R);
        merge(arr, L, mid, R);
    }

    public static void merge(int[] arr, int L, int M, int R) {
        int[] help = new int[R - L + 1];
        int i = 0;
        int p1 = L;
        int p2 = M + 1;
        while (p1 <= M && p2 <= R) {
            help[i++] = arr[p1] <= arr[p2] ? arr[p1++] : arr[p2++];
        }
        while (p1 <= M) {
            help[i++] = arr[p1++];
        }
        while (p2 <= R) {
            help[i++] = arr[p2++];
        }
        for (i = 0; i < help.length; i++) {
            arr[L + i] = help[i];
        }
    }

    // for test
    public static void comparator(int[] arr) {
        Arrays.sort(arr);
    }

    // for test
    public static int[] generateRandomArray(int maxSize, int maxValue) {
        int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
        }
        return arr;
    }

    // for test
    public static int[] copyArray(int[] arr) {
        if (arr == null) {
            return null;
        }
        int[] res = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            res[i] = arr[i];
        }
        return res;
    }

    // for test
    public static boolean isEqual(int[] arr1, int[] arr2) {
        if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
            return false;
        }
        if (arr1 == null && arr2 == null) {
            return true;
        }
        if (arr1.length != arr2.length) {
            return false;
        }
        for (int i = 0; i < arr1.length; i++) {
            if (arr1[i] != arr2[i]) {
                return false;
            }
        }
        return true;
    }

    // for test
    public static void printArray(int[] arr) {
        if (arr == null) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    // for test
    public static void main(String[] args) {
        int testTime = 500000;
        int maxSize = 100;
        int maxValue = 100;
        boolean succeed = true;
        for (int i = 0; i < testTime; i++) {
            int[] arr1 = generateRandomArray(maxSize, maxValue);
            int[] arr2 = copyArray(arr1);
            mergeSort(arr1);
            comparator(arr2);
            if (!isEqual(arr1, arr2)) {
                succeed = false;
                printArray(arr1);
                printArray(arr2);
                break;
            }
        }
        System.out.println(succeed ? "Nice!" : "Fucking fucked!");

        int[] arr = generateRandomArray(maxSize, maxValue);
        printArray(arr);
        mergeSort(arr);
        printArray(arr);

    }

}

小和问题

  • 定义：在一个数组中，每一个数比前数小的数进行累加，叫做这个数的小和。
  • 转化为 （右边大于我的个数 * 我本身大小） 累加和，这个数值和小和得到的数据一致

  • res += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;p1指向左边的数，p2指向右边的数，r是右边部分最右边的边界。r-p2 +1 得到比当前左边元素大的个数 ，再乘以当前元素本身；将所有元素按照上述流程进行，最后就得到了小和

  • 例子：【1，3，4，2，5】，1左边比1小的数：无；3左边比3小的数：1；4左边比4小的数：1，3；2左边比2小的数：1；5左边比5小的数：1，3，4，2；累加求和：16

使用归并排序解决小和问题

  • 归并排序，遇到相同的元素，先移动左侧，是为了保证程序的稳定性；而这里先移动右侧的元素，是为了确定比左侧指针指向的元素大的右侧区块中的元素的个数
  • 小和问题出现在三个地方：左侧区块内排序；右侧区块内排序；左右侧区块合并

代码

package class02;

public class Code02_SmallSum {

	public static int smallSum(int[] arr) {
		if (arr == null || arr.length < 2) {
			return 0;
		}
		return process(arr, 0, arr.length - 1);
	}

	// arr[L..R]既要排好序，也要求小和
	public static int process(int[] arr, int l, int r) {
		if (l == r) {
			return 0;
		}
		int mid = l + ((r - l) >> 1);
		return process(arr, l, mid) + process(arr, mid + 1, r) + merge(arr, l, mid, r);
	}

	public static int merge(int[] arr, int L, int m, int r) {
		int[] help = new int[r - L + 1];
		int i = 0;
		int p1 = L;
		int p2 = m + 1;
		int res = 0;
		while (p1 <= m && p2 <= r) {
			res += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;
			help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
		}
		while (p1 <= m) {
			help[i++] = arr[p1++];
		}
		while (p2 <= r) {
			help[i++] = arr[p2++];
		}
		for (i = 0; i < help.length; i++) {
			arr[L + i] = help[i];
		}
		return res;
	}

	// for test
	public static int comparator(int[] arr) {
		if (arr == null || arr.length < 2) {
			return 0;
		}
		int res = 0;
		for (int i = 1; i < arr.length; i++) {
			for (int j = 0; j < i; j++) {
				res += arr[j] < arr[i] ? arr[j] : 0;
			}
		}
		return res;
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			if (smallSum(arr1) != comparator(arr2)) {
				succeed = false;
				printArray(arr1);
				printArray(arr2);
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");
	}

}
  • 类似于逆序对问题：如果左边的数比右边的数大，则二者构成一个逆序对，原理类似
  • res += arr[p1] > arr[p2] ? (m - p1 +1) : 0;

荷兰国旗问题

  • 快速排序 
  • 给定数组arr和数num，将小于等于num的数放在数组的左边，大于num的数放在数组的右边，要求时间复杂度为O(N),空间复杂度为O(1);不要求内部有序

  • 将数组分为三个部分，以num为界限，分为小于等于区、大于区和待定区。指针指向数组的第一个元素，判定指针指向的元素是否小于等于num，如果成立当前数和小于等于区的下一个数交换，然后小于等于区向右移动，指针也向右移动
  • 如果指针指向的元素大于num，那么指针直接跳过该元素，向右移动。
package class02;

public class Code05_NetherlandsFlag {

	public static int[] partition(int[] arr, int l, int r, int p) {
		int less = l - 1;
		int more = r + 1;
		while (l < more) {
			if (arr[l] < p) {
				swap(arr, ++less, l++);
			} else if (arr[l] > p) {
				swap(arr, --more, l);
			} else {
				l++;
			}
		}
		return new int[] { less + 1, more - 1 };
	}

	// for test
	public static void swap(int[] arr, int i, int j) {
		int tmp = arr[i];
		arr[i] = arr[j];
		arr[j] = tmp;
	}

	// for test
	public static int[] generateArray() {
		int[] arr = new int[10];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) (Math.random() * 3);
		}
		return arr;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	public static void main(String[] args) {
		int[] test = generateArray();

		printArray(test);
		int[] res = partition(test, 0, test.length - 1, 1);
		printArray(test);
		System.out.println(res[0]);
		System.out.println(res[1]);

	}
}

第二个问题

  • 荷兰国旗问题：给定数组arr和数num，将小于等于num的数放在数组的左边，等于num的数放在数组的中间，大于num的数放在数组的右边，要求时间复杂度为O(N),空间复杂度为O(1)

  • 将数组分为三个部分，小于区、中间区和大于区。
  • 首先用指针指向数组的第一个元素，如果当前指向的数小于num，则小于区下一个元素和当前数值侧面交换，小于区域向右边扩，指针向右边移动
  • 如果当前指针指向的元素和num相等，那么指针直接跳过，移动到下一个位置
  • 如果当前指针指向的元素大于num，那么大于区的前一个元素和当前指针指向的元素交换，大于区域向左边扩展，但是当前指针不可以移动位置，因为，交换了元素，不知道这个交换元素和num的大小
package class02;

import java.util.Arrays;

public class Code06_QuickSort {

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

	public static void quickSort(int[] arr, int l, int r) {
		if (l < r) {
			swap(arr, l + (int) (Math.random() * (r - l + 1)), r);
			int[] p = partition(arr, l, r);
			quickSort(arr, l, p[0] - 1);
			quickSort(arr, p[1] + 1, r);
		}
	}

	public static int[] partition(int[] arr, int l, int r) {
		int less = l - 1;
		int more = r;
		while (l < more) {
			if (arr[l] < arr[r]) {
				swap(arr, ++less, l++);
			} else if (arr[l] > arr[r]) {
				swap(arr, --more, l);
			} else {
				l++;
			}
		}
		swap(arr, more, r);
		return new int[] { less + 1, more };
	}

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

	// for test
	public static void comparator(int[] arr) {
		Arrays.sort(arr);
	}

	// for test
	public static int[] generateRandomArray(int maxSize, int maxValue) {
        //l到r随机选一个数做等概率划分 ，最差情况发生概率下降
		int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
		}
		return arr;
	}

	// for test
	public static int[] copyArray(int[] arr) {
		if (arr == null) {
			return null;
		}
		int[] res = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			res[i] = arr[i];
		}
		return res;
	}

	// for test
	public static boolean isEqual(int[] arr1, int[] arr2) {
		if ((arr1 == null && arr2 != null) || (arr1 != null && arr2 == null)) {
			return false;
		}
		if (arr1 == null && arr2 == null) {
			return true;
		}
		if (arr1.length != arr2.length) {
			return false;
		}
		for (int i = 0; i < arr1.length; i++) {
			if (arr1[i] != arr2[i]) {
				return false;
			}
		}
		return true;
	}

	// for test
	public static void printArray(int[] arr) {
		if (arr == null) {
			return;
		}
		for (int i = 0; i < arr.length; i++) {
			System.out.print(arr[i] + " ");
		}
		System.out.println();
	}

	// for test
	public static void main(String[] args) {
		int testTime = 500000;
		int maxSize = 100;
		int maxValue = 100;
		boolean succeed = true;
		for (int i = 0; i < testTime; i++) {
			int[] arr1 = generateRandomArray(maxSize, maxValue);
			int[] arr2 = copyArray(arr1);
			quickSort(arr1);
			comparator(arr2);
			if (!isEqual(arr1, arr2)) {
				succeed = false;
				printArray(arr1);
				printArray(arr2);
				break;
			}
		}
		System.out.println(succeed ? "Nice!" : "Fucking fucked!");

		int[] arr = generateRandomArray(maxSize, maxValue);
		printArray(arr);
		quickSort(arr);
		printArray(arr);

	}

}
  • 快排的时间复杂度是 o(N*logN)
MY CUP OF TEA
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
排序算法：归并排序
程序员囧辉
06-07 2835
前言 这篇文章本该发表于2018年4月份末，在排序算法：快速排序之后，但是不知道什么原因，这篇文章忘了在CSDN上发表，今天在看博客的时候突然发现，因此补上。 概述 之前介绍过排序算法中效率很高的“快速排序”。本文将介绍另一个高效的排序算法——“归并排序”。 基本思想 归并排序的主要思想是分治法。主要过程是： 将n个元素从中间切开，分成两部分。（左边可能比右边多1个...
浅谈算法分析
weixin_54929649的博客
07-12 1530
浅谈算法分析 算法的时间复杂程度分析 计算原子操作 随输入变化进行测量操作 最坏情况输入研究 七种常见函数 常数函数 线性函数 二次函数 对数函数 nlogn函数 三次函数 指数函数 O符号 Ω符号 Θ符号 ...
O（NlogN）的约瑟夫环
m0_59206144的博客
04-10 279
众所周知，程序的组成可以分为数据结构和算法两部分组成，约瑟夫环普遍上的解法使用的数据结构为数组，链表，队列，其算法为暴力模拟法，时间复杂度O（N^2），而我今天给大家分享两个O(NlogN)的方法，帮助大家解决大规模数据下的约瑟夫环问题。那我们就正式开始吧！我们的优化思路是在数据结构方面进行优化，采用高级数据结构线段树和树状数组来实现对约瑟夫环问题的优化。
归并排序 O(nLogn)
gg199402的博客
07-20 623
归并排序 归并排序的思想是分治法+回溯，将一个无序的数组先按照原来的一半进行拆分，一直拆分到最后一个元素，然后开始回溯，排序开始的过程是再回溯时开始排序的。 思想总结： 将源数组进行拆分，每次拆分一半，由图可以分析出，当arr.length=n,需要拆分log2^8=3次。 当拆分到不能再拆分，也就是分组到每个组只有1个元素，停止拆分 开始排序并回溯排序，每次排序的时间复杂度为O(n) 总的时间复杂度为n x log2^n,时间复杂度不考虑系数和底数，所以n x log2^n等价于 O(nlogn)
排序算法————归并排序
码放南山
04-01 262
归并排序原理 将两个或两个以上的有序表组合成一个新的有序表。 归并排序举例 原始序列：35 22 65 84 73 90 56 1、将原始序列看成7个子序列，则子序列有序。 子序列1：35 子序列2：22 子序列3：65 子序列4：84 子序列5：73 子序列6：90 子序列7：56 两两合并，形成若干有序二元组： ｛22，35｝，｛65，84｝，｛...
【0基础学算法】归并排序(超详细讲解+私人笔记+源码）
感谢您的关注！
08-23 1040
归并排序是一个稳定的排序算法，在进行子数组合并的时候，我们可以设置当元素大小相等时，先将前半部分的数据放入临时数组，这样就可以保证相等元素在排序后依然保持原来的顺序，并且归并排序的执行效率与原始数据的有序程度无关，其时间复杂度是非常稳定的，都是O(nlogn) 。......
NlogN经典排序算法的实现-希尔排序，快速排序，归并排序.zip
11-17
本资料包聚焦于三类时间复杂度为O(nlogn)的经典排序算法：希尔排序、快速排序和归并排序。接下来，我们将深入探讨这三种算法的原理、实现及其优缺点。 **希尔排序（Shell Sort）** 希尔排序是一种改进的插入排序，...
排序算法（二）希尔排序+归并排序+快速排序+堆排序–O(nlogn)的排序
01-21
文章目录希尔排序归并排序快速排序（20世纪对世界影响最大的算法之一）牛掰！堆排序 希尔排序 排序思想：希尔排序可以说是插入排序的一种变种。无论是插入排序还是冒泡排序，如果数组的最大值刚好是在第一位，要将它...
算法之NlogN排序算法（csdn）————程序.pdf
12-05
归并排序是一种常见的排序算法，时间复杂度为O(NlogN)。其过程可以分为两个步骤：左边排好序，右边排好序，让其整体有序。merge过程使用了外排序方法，时间复杂度为O(N)。 代码实现中，使用了递归方法来实现归并...
详解Java常用排序算法-快速排序
08-26
* 高效排序：快速排序算法的时间复杂度为 O(nlogn)，使其在大型列表上的性能优于其他排序算法。 * 稳定排序：快速排序算法是一种稳定的排序算法，保持了原始顺序中的相对顺序。 * 广泛应用：快速排序算法广泛应用于...
实现了7种排序算法.三种复杂度排序.三种nlogn复杂度排序（堆排序，归并排序，快速排序）一种线性复杂度的排序.zip
最新发布
04-27
直接插入排序（Straight Insertion Sort）是一种简单且古老的排序算法，其基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表。12 直接插入排序的算法过程如下： 假设待排序...
归并排序 归并排序示例
05-13
归并排序，比较高效的排序算法之一。这是一个例子，一个关于归并排序的例子。
归并排序算法详解及示例
qq_43679351的博客
05-24 2956
归并排序 归并排序算法是在分治算法的基础上设计出来的一种排序算法，它可以可以对指定的序列完成升序，（由小到大），或降序（由大到小），时间复杂度为O(nlogn)O(nlogn)O(nlogn)。 实现排序的思路 1.将整个待排序划分成多个不可再分的待排序序列，每个子序列中仅有一个元素； 2.所有的子序列进行两两合并，合并过程中完成排序操作，最终合并得到的新序列，就是排序序列。 示例 使用归并排序算法对{7,6,8,9,3,4,1,0},实现升序排序的过程。 1.将{7,6,8,9,3,4,1,0}分割成多个
排序算法(二):时间复杂度为O(nlogn)的排序算法
qq_42138662的博客
06-24 8467
一、希尔排序（实际上很少用到，了解即可） 1、算法步骤 将待排序数组按照一定的间隔进行排序，如此时排序间隔为gap：则从index=gap处的元素开始排序；对于index = i的元素，每次和当前index - gap处的元素进行比较，直到符合插入条件；然后继续比较index = i++的元素，直到数组末尾，完成当前间隔的排序 逐渐缩小间隔进行下一轮排序 最后一轮时，取间隔为 1，也就相当于直接使用插入排序。但这时经过前面的「宏观调控」，数组已经基本有序了，所以此时的插入排序只需进行少量交换便可完成
时间复杂度O(nlogn)的排序算法
热门推荐
qq_43533956的博客
04-05 1万+
时间复杂度O(nlogn)的排序算法有四种，分别是希尔排序，堆排序，快速排序和归并排序。这四个排序都非常重要。 希尔排序 希尔排序本质上是插入排序的优化，先对间隔较大的元素进行插入排序，完成宏观调控，然后逐步缩小间隔，最后一轮一定是间隔为 1 的排序，也就是插入排序。间隔在希尔排序中被称为「增量」，增量序列不同，希尔排序的效率也不同。 堆排序 堆排序的关键在于建堆，堆分为大顶堆和小顶堆，大顶堆中最大的元素在堆顶，小顶堆同理。 堆实际上是一颗完全二叉树，不过为了方便我们把它用数组的形式储存，储存的顺
归并排序
u012828739的专栏
12-21 103
归并排序的基本思想，就是采用分治的策略。先使子序列都有序，然后再将子序列归并成一个有序的序列。 例如：一个原始序列为： （9，2，3，1，6，4，5，8，9，7） 分成 （9，2，3，1，6）      （4，5，8，9，7） （9，2，3）（1，6）    （4，5，8）（9，7） （9，2）（3）   （1）（6）    （4，5）（8）   （9）（7） （9）（2）（3）（1...
非常详细——归并排序merge sort
czh_vegetable的博客
06-30 4849
归并排序
归并排序介绍、详解、案例
Pumpkin's Blog
04-05 655
如果慢指针一次走一步，快指针一次走两步，当快指针走到链表尾部时，慢指针只走到链表的中央，这样也就找到了链表后半部分的头节点。例如输入的是：[3 -> 5 -> 1 -> 4 -> 2 -> 6] 输出的则是：[1 -> 2 -> 3 -> 4 -> 5 -> 6]。归并排序也是基于分治法的排序算法，为了排序长度为n的数组，需要先排序长度为n/2的字数组，然后合并这两个排序字数组于是整个数组也就排序完毕。归并排序的主要思想是将链表分成两个子链表，在对两个子链表排序后再将它们合并成一个排序的链表。
数据结构与算法 —— O(nlogn)排序算法（快排和归并）（c++)
Charles Ren's Tech Blog
04-26 1258
文章目录希尔排序快速排序（分治+挖坑法）测试用例 希尔排序 https://blog.csdn.net/u012918361/article/details/68921601 希尔排序作为第一批突破O(n^2)的算法之一,在数据中等规模时候性能很好,大规模时候没有快排好 时间复杂度O(nlogn)不好证明 基本思路：插入排序的改进，就是不断分组，每组进行插入排序 注意传入引用，不然按值传递速度很慢...
排序算法的时间复杂度O(nlogn)
09-03
时间复杂度为O(nlogn)的排序算法有希尔排序，堆排序，快速排序和归并排序。其中归并排序是一种稳定的排序算法，而希尔排序、堆排序和快速排序是不稳定的排序算法。 <span class="em">1</span><span class="em">2...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值