精华内容
下载资源
问答
  • 思路:定义一个字典存储数组2,键为该元素,值为true,在字典...传统方法时间复杂度为n方,这种方法为2n。 using System.Collections; using System.Collections.Generic; using UnityEngine; public class Sort : Mo

    思路:定义一个字典存储数组2,键为该元素,值为true,在字典中判断是否含有数组1中的元素键,不含有就存入一个List中,最后得到的List转为Array数组就是不含有数组2元素的新数组1,如果要删除字典中含有数组1的元素,只需要判断键值true或false即可。传统方法时间复杂度为n方,这种方法为2n。

    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    
    public class Sort : MonoBehaviour
    {  
        int[] arr1 = new int[] { 1, 5, 6, 7, 8, 9, 4, 2 };
        int[] arr2 = new int[] { 2,3,4,5 };
        
        // Start is called before the first frame update
        void Start()
        {  
            foreach (var item in DeleteSamneData(arr1, arr2))
            {
                Debug.Log(item);
            }
        }
        int[] DeleteSamneData(int[] a1,int[] a2)
        {
            Dictionary<int, bool> temp1 = new Dictionary<int, bool>();
            List<int> temp2 = new List<int>();
            foreach (var item in a2)
            {
                temp1.Add(item, true);
            }
            foreach (var item in a1)
            {
                if (!temp1.ContainsKey(item))
                {
                    temp2.Add(item);
                }
            }
            return temp2.ToArray();
        }
    }
    
    
    展开全文
  • 算法的时间复杂度 度量一个程序执行时间的两种方法 事后统计的方法,这种方法可行,但是有两个问题:一是想对设计的算法的运行性能进行评测,需要实际运行该程序;二是所得旱的统计量依赖于计算机的硬件、软件等...

    050 排序算法介绍和分类

    排序也称排序算法(Sort,Algorithm),排序是将一组数据,依指定的顺序进行排列的过程
    排序的分类:

    1. 内部排序:指将需要处理的所有数据都加载到内部存储器(内存)中进行排序
    2. 外部排序法:数据量过大,无法全部加载到会败在中,需要借助外部存储进行排序

    在这里插入图片描述

    算法的时间复杂度

    度量一个程序执行时间的两种方法

    1. 事后统计的方法,这种方法可行,但是有两个问题:一是想对设计的算法的运行性能进行评测,需要实际运行该程序;二是所得旱的统计量依赖于计算机的硬件、软件等环境因素,这种方式,要在同一台计算机的相同状态下运行,才能比较哪个算法速度快
    2. 事前估算的方法:通过分析某个算法的时间复杂度来判断哪个算法更优

    051 时间频度介绍和特点

    时间频度
    基本介绍:一个算法花费的时间与算法中语句的执行次数成正比例,哪个算法中语句执行次数多,它花费时间就多。一个算法中的语句执行次数为语句频度 或时间频度。记为:T(n)

    例子:
    比如计算 1 - 100 所有数字之和,设计两种算法

    int total = 0 , end = 100;
    for(int i = 1; i <= end; i++{
    	total += i;
    }
    T(n) = n + 1;
    
    
    total = (1 + end) * end / 2;
    T(n) =1;
    

    忽略常数项
    在这里插入图片描述
    结论:

    1. 2n + 20 和 2n 随着 n 变大,执行曲线无限接近,20可以忽略
    2. 3n + 10 和 3n 随着 n 变大,执行曲线无限接近,10可以忽略

    忽略低次项
    在这里插入图片描述
    结论:
    3. 2n^2(2n的平方) + 3n + 10 和 2n^2 变化,执行曲线无限接近,可以忽略 3n + 10
    4. n^2 + 5n + 20 和 n^2随着 n 变大,执行曲线无限接近,可以忽略 5n + 20

    忽略系数
    在这里插入图片描述
    5. 随着 n 值变大, 5n^2 + 7n 和 3n^2 + 2n,执行曲线生命,说明这种情况下,5和3可以忽略
    6. 而 n^3 + 5n 和 6^3 +4n,执行曲线分离,说明多少次方是关键

    T(n)
    随着 n 的变大,常数项、低次项、系数可以忽略

    052 时间复杂度计算和举例说明

    1. 一般情况下,算法中的基本操作语句的重复执行次数是问题规模 n 的某个函数,用 T(n)表示,若有某个辅助函数f(n),使得当 n 趋近于无穷大时,T(n)/ f(n)的极限值为不等于零的常数,则称 f(n)是 T(n)的同数量级函数。记作T(n)= o(f(n)),称 o(f(n))为算法的渐进时间复杂度,简称时间复杂度
    2. T(n)不同,但时间复杂度可能相同。如: T(n) = n2 + 7n + 6 与 T(n) = 3n2 + 2n + 2 它们的 T(n)不同,但时间复杂度相同,都为 O(n2
    3. 计算时间复杂度的方法
      • 用常数1代替运行时间中的所有加法常数
      • 修改后的运行次数函数中,只保留最高阶项
      • 去除最高阶项的系数

    常见的时间复杂度


    说明: 常见的算法时间复杂度由小到大依次为:o(1) < o(log2n) < o(n) < o(nlog2n) < o(n2) < o(n3) < o(nk) < o(2n) ,随着问题规模 n 的不断增大,上述时间复杂度不断增大,算法的执行效率越低。
    应该尽可能避免使用指数阶的算法

    常数阶
    在这里插入图片描述

    对数阶

    在这里插入图片描述
    线性阶
    在这里插入图片描述

    线性对数阶
    在这里插入图片描述

    平方阶
    在这里插入图片描述

    立方阶、k次方阶
    在这里插入图片描述

    053 平均和最坏时间复杂度介绍

    • 平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下,该算法的运行时间
    • 最坏情况下的时间复杂度称最坏时间复杂度。一般讨论的时间复杂度是最坏情况下的时间复杂度。这样做的原因是:最坏情况下的时间复杂度是算法在任何输入实例上运行时间的界限,这就保证了算法的运行时间不会比最坏时间更长
    • 平均时间复杂度和最坏时间复杂度是否一致,和算法有关

    在这里插入图片描述

    算法的空间复杂度

    介绍:

    • 类似于时间复杂度的讨论,一个算法的空间复杂度(Space Complexity)定义为该算法所耗费的存储空间,它也是问题规模的函数
    • 空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。有的算法需要占用的临时工作单元数与解决问题的规模 n 有关,它随着 n 的增大而增大,当 n 较大时,将占用较多的存储单元,例如快速排序和归并算法就属于这种情况
    • 在做算法分析时,主要讨论的是时间复杂度。从用户使用体验上看,更看重的程序执行的速度。一些缓存产品(redis,memcache)和算法(基数排序)本质就是用空间换时间
    展开全文
  • JS数组排序||sort方法

    2020-08-19 10:57:12
    sort方法不传参数话,排序默认根据字符串Unicode排序; 传递参数情况,所传参数必须为一个函数,该函数对a,b两个参数进行比较,返回一个结果,具体如下: a 大于 b 返回一个大于0值,a在b位置后面; a ...

    sort方法不传参数的话,排序默认根据字符串的Unicode排序;
    传递参数的情况,所传的参数必须为一个函数,该函数对a,b两个参数进行比较,返回一个结果,具体如下:
    a 大于 b 返回一个大于0的值,a在b位置的后面;
    a 等于 b 返回一个等于0的值,a、b位置不变;
    a 小于 b 返回一个小于0的值,a在b位置的前面;

    冒泡排序
    原理:对数组进行遍历,相邻元素根据大小进行交换,每次遍历将最小值推至最前方,然后对剩下的值再次进行比较
       最坏时间复杂度:O(n^2)
    空间复杂度:O(1)

    function pop(array) {
        var len = array.length,
                i, j, tmp, result;
        result = array.slice(0);
        for (i = 0; i < len; i++) {
            for (j = len - 1; j > i; j--) {
                if (result[j] < result[j - 1]) {
                    tmp = result[j - 1];
                    result[j - 1] = result[j];
                    result[j] = tmp;
                }
            }
        }
        return result;
    }
        alert(pop([5,6,4,7,8]));

    快速排序
    原理:从数组中取一个值为基准值,并将剩下的值与之比较,小于基准值的放到左边,大于基准值的放到右边,并再次对左右两边进行快速排序,直至左右两边只剩一个元素。
    最坏时间复杂度:O(n^2) 当选择的基准值为最大值或最小值时
    稳定性:不稳定
    平均时间复杂度:O(n*log2n)

        function quick(arr){
            var len=arr.length;
     
            if(len<=1){
                return arr;
            }
            var index=Math.floor(len/2),//向下取整 根据中间的值作为比较对象
                    pindex=arr.splice(index,1)[0],//需要删除中间值,以缩小排序的数组大小
                    left=[],//定义左右两个数组 左大右小
                    right=[];
     
            for(var i=0;i<len-1;i++){ //遍历整个数组 大放右 小放左
                if(arr[i]>=pindex){
                    right.push(arr[i]);
                }else{
                    left.push(arr[i]);
                }
            }
            return quick(left).concat([pindex],quick(right)); //继续递归并将数组合并
        }
        alert(quick(arr));


    插入排序

    原理:从数组第二个值开始,依次将后续的数值经过比较与前面排序后的序列比较后插入
    最坏时间复杂度:O(n2):当数组是从大到小排列时,插入第一个元素需要移动一次,插入第二个需要移动两次,以此类推,所以一共为1+2+3+4+......+(n-1),与冒泡排序相同
    最优时间复杂度:最好的情况是数组已经由小到大排好,则为O(n)
    稳定性:稳定
    空间复杂度:O(1)
    function insert(array) {
        var len = array.length,
                i, j, tmp, result;
        // 设置数组副本
        result = array.slice(0);
        for(i=1; i < len; i++){ //数组第一个值为默认的衡量值
            tmp = result[i];      //从第二个值开始与之前的值进行比较
            j = i - 1;           //之前已经排好序的数组的最后一个
            while(j>=0 && tmp < result[j]){   //如果j大于等于零(否则越界) 与最后一个值进行比较,如果小于
                result[j+1] = result[j];       //则将最后一个值后移一位
                j --;                          //j往前移动一位
            }
            result[j+1] = tmp;                 //比较完成 这时result[j]<temp或者j已经为-1,则将tmp的值赋给j+1
        }
        return result;
    }

    希尔排序
    原理:由于直接插入排序每一次插入新值都要与之前已经序列化的部分进行比较,越往后所需要比较的次数越多,所以希尔排序通过设置步长,将整个数组依照步长分为一个个分块儿,将分块序列化之后再将整个数组进行插入排序。
    时间复杂度:希尔排序的时间复杂度和其增量序列有关系,这涉及到数学上尚未解决的难题;不过在某些序列中复杂度可以为O(n1.3);
    空间复杂度:O(1)
    稳定性:不稳定
        function shell(arr) {
            var len =arr.length,
                    i,j,temp,
                    gap = Math.floor(len/2);//设置步长
            while (gap>0) {                //当步长大于0时 每次步长减半
                for (i = gap; i < len; i++) {
                    temp = arr[i];
                    j = i-gap;
                    while (j>=0&&temp<arr[j]){     //J>=0且arr[i]<arr[j]时
                        arr[j+gap]=arr[j];          //a[j]的值向前移动一个步长
                        j -=gap;                     //j往前移动一个步长
                    }
                    arr[j+gap] =temp;
                }
                gap = Math.floor(gap/2);//每次步长缩短一半直至为1
            }
            return arr;
        }
        alert(shell([2,5,7,9,45,12,6,74]));


    选择排序
    原理:与冒泡排序类似,只不过选择排序不是通过相邻元素交换而将最小值“冒泡”到顶端,而是从数组第一个元素开始,与后面的的元素进行比较,如果后面的元素都比他大,则不需要交换,如果有比其小的,则两个值相互交换。
    最坏时间复杂度:O(n2)
    平均时间复杂度:O(n2)
    稳定性:稳定
    空间复杂度:O(1)
        function select(arr) {
            var len = arr.length,
                    i,j,temp,k;
            for (i=0;i<len;i++){     //遍历数组的每一个值,并于其后的值比较找出最小值之后互换
                k=i;
                for (j=i+1;j<len;j++){
                    if (arr[j]<arr[k])k=j;
                }
                if (k!=i){           //如果arr[i]已经是最小的则不需要互换
                    temp=arr[k];
                    arr[k]=arr[i];
                    arr[i]=temp;
                }
            }
            return arr;
        }
        alert(select([14,5,45,2,6,7,5,9]));

    展开全文
  • 4.利用Master Theorem求归并排序时间复杂度 我们上一篇博客重点回顾了复杂度概念,以及基本复杂度计算方法。这篇博客我们利用归并排序Merge Sort算法带着大家深入计算复杂度。 1.归并排序概念 假设我们有一...

    目录

    1.归并排序概念

    2.算法的复杂度

    3.主定理Master Theorem

    3.1 Master Theorem概念

    3.2 Master Theorem例子分析

    4.利用Master Theorem求归并排序时间复杂度


            我们上一篇博客重点回顾了复杂度的概念,以及基本的复杂度计算方法。这篇博客我们利用归并排序Merge Sort算法带着大家深入计算复杂度。

    1.归并排序概念

            假设我们有一个数组A,我们目标是sort(A)排序,整个算法流程为:首先把数组分成两部分,分完之后,针对每一个部分做排序,排序方法也是归并排序。我们做一个最后做一个整合,因为是排序过的两部分,从头部往后面依次比较即可。

            我们来想一下,这种排序算法的复杂度是多少?

    2.算法的复杂度

            假设我们数组有n个数子,我们用T(n)表示该算法的时间复杂度,我们将原来问题拆分为2个子问题,是原来问题的1/2。最后需要n个操作合并排序。我们怎么表示它的时间复杂度呢?{先揭晓答案:T(n)= 2*T(n/2) +n   ----->   O(n*log n)  }

    3.主定理Master Theorem

    3.1 Master Theorem概念

            主定理对上面那种可以把一个问题分解为若干子问题上非常有价值,

            T(n)= 2*T(n/2) +n 是我们上面分析得到的结果,这个就非常符合主定理适用形式。我们怎么得到这种递归函数复杂度呢?下面的三个符号(O/Θ/Ω)

            主定理的内容可以解释如下所示:只需要分别计算左右二者大小即可。

    这里写图片描述

    3.2 Master Theorem例子分析

    4.利用Master Theorem求归并排序时间复杂度

     

    展开全文
  • 时间复杂度比较高,来换取比较低空间复杂度(没有申请别空间,空间复杂度是O(1)?),并且不修改原数组,直接输出。 public void sort(int [] nums){ int count = 0, min = nums[0], min_cnt = 0, pre = -1; ...
  • 看上去似乎任何已知算法都无法做到,如果谁做到了,那么所有排序方法:QuickSort,ShellSort,HeapSort,BubbleSort等等等等,都可以扔掉了,还要这些算法干吗阿,呵呵。 不过实际上,在数字范围有限制情况下...
  • 其实也就是看哪种排序方法时间复杂度低,在不断尝试下,快速排序在数据巨多时还是最快,希尔排序可以通过,但时间性能没有快排好 /** * Note: The returned array must be malloced, assume caller calls free()...
  • 用递归树求解递归算法时间复杂度

    千次阅读 2019-07-01 23:27:38
    递归代码复杂度分析起来比较麻烦。一般来说有两种分析方法:递推公式和递归树。 1 递推公式法 ...我们假设对n个元素排序的时间是T(n),那分解成两个子数组排序的时间是T(n2)T(\dfrac{n}{2})T(...
  • 归并排序与快速排序时间复杂度均为O(nlogn),适合大规模数据排序且很常用,它们都用到了分治思想,将大问题分解成小问题来解决。接下来我们分别对其进行分析。 归并排序(Merge Sort) 思路:归并排序核心...
  • 归并排序基本思想归并排序法是将两个或以上有序表合并成一个新有序表,即把待排序序列分成若干个子序列,每个子序列是有序。然后再把有序子序列合并为整体有序... 置两个子表起始下标及辅助数组的起始下标
  • 冒泡排序 “”" 基本原理: ...时间复杂度为O(n^2), 空间复杂度为O(1)因为并没有创建新的数组. 是个稳定算法. “”" # 方法一: def bubble_sort(arr): length = len(arr) for i in range(length - 1
  • 6种字符串数组的java排序 (String array sort) 注意,本文不是字符串排序,是字符串数组的排序。 方法分别是: 1、低位优先键索引排序 2、高位优先建索引排序 3、Java自带排序(经过调优...
  • 归并操作,也叫归并算法,指是将两个顺序序列合并成一个顺序序列的方法。 归并排序图解 【思考】为什么要把一个数组先分成一半,然后再进行归并呢? 对于我们例子,有8个元素,一共可以分成3级,到第3级时候...
  • 看上去似乎任何已知算法都无法做到,如果谁做到了,那么所有排序方法:QuickSort,ShellSort,HeapSort,BubbleSort等等等等,都可以扔掉了,还要这些算法干吗阿,呵呵。 我们平常知道是排序算法都是O(n),...
  • 题目:给定一个大小为 n 的数组,找到其中多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 元素。... //该方法时间复杂度为O(n2) Arrays.sort(nums); return nums[nums.length/2]; 2.摩尔投
  • 从今天开始刷剑指offer,预计半个月刷完;在此记录做题方法,以备查看; 题目链接:数组中重复数字 解题方法1: 新建HashSet集合用于存储数组元素,使用contains()方法...将原数组使用Arrays.sort()方法进行排
  •   简单的方法便是双层循环嵌套遍历数组,直到找到第一个出现重复数字则输出,时间复杂度是O(n2),空间复杂度是O(1)。代码略。 2. 排序   遍历数组前完全可以先对数组进行排序,从而可降低时间复杂度,然后遍历...
  • 给你一个整数数组 nums,请你将该数组升序排列。 方法一: c++ sort class Solution { public: vector<int> sortArray(vector<int>& nums) { sort(nums.begin(),nums.end()); return nums; } }...
  • 看上去似乎任何已知算法都无法做到,如果谁做到了,那么所有排序方法:QuickSort,ShellSort,HeapSort,BubbleSort等等等等,都可以扔掉了,还要这些算法干吗阿,呵呵。不过实际上,在数字范围有限制情况下,...
  • 题目描述(数组) 在一个长度为n的数组所有数字都在0到n-1范围内。 数组中某些数字是重复,但不知道有几个数字是重复...【方法1】先把输入的数组排序(sort()),然后遍历数组,找出重复元素,时间复杂度为O(...
  • 看上去似乎任何已知算法都无法做到,如果谁做到了,那么所有排序方法:QuickSort,ShellSort,HeapSort,BubbleSort等等等等,都可以扔掉了,还要这些算法干吗阿,呵呵。不过实际上,在数字范围有限制情况下,...
  • 排序算法可以直接调封装好快速排序,代码不麻烦,且时间复杂度可以接收,遇到数字数组问题,不妨想想看排序后可以有什么巧妙解决办法 代码 class Solution { public int[] intersect(int[] nums1, int[] nums2)...
  • 题目解析方法一:多数投票算法+O(n)O(n)O(n)时间复杂度+最优解法方法二:sort()排序+O(logn)O(logn)O(logn)时间复杂度+投机解法 1. 题目来源 链接:数组中出现次数超过一半数字 来源:LeetCode——《剑指-Offer》...
  • 看上去似乎任何已知算法都无法做到,如果谁做到了,那么所有排序方法:QuickSort,ShellSort,HeapSort,BubbleSort等等等等,都可以扔掉了,还要这些算法干吗阿,呵呵。不过实际上,在数字范围有限制情况下,...
  • 题目链接: leetcode. 本题常见三种解法: 哈希表统计法: 遍历数组nums,用HashMap统计各数字数量,即可找出众数。...用了sort时间复杂度大于O(n)了 执行用时:28 ms, 在所有 C++ 提交中击败了65.81%用户 内

空空如也

空空如也

1 2 3 4 5 ... 19
收藏数 373
精华内容 149
关键字:

数组sort方法的时间复杂度