精华内容
下载资源
问答
  • 如何对一个算法进行复杂度分析

    千次阅读 2017-06-27 12:05:23
    算法复杂度是在《数据结构》这门课程的第...一个是时间复杂度,一个是渐近时间复杂度。前者是某个算法的时间耗费,它是该算法所求解问题规模n的函数,而后者是指当问题规模趋向无穷大时,该算法时间复杂度的数量级。 

    算法复杂度是在《数据结构》这门课程的第一章里出现的,因为它稍微涉及到一些数学问题,所以很多同学感觉很难,加上这个概念也不是那么具体,更让许多同学复习起来无从下手,下面我们就这个问题给各位考生进行分析。

    首先了解一下几个概念。一个是时间复杂度,一个是渐近时间复杂度。前者是某个算法的时间耗费,它是该算法所求解问题规模n的函数,而后者是指当问题规模趋向无穷大时,该算法时间复杂度的数量级。 

    当我们评价一个算法的时间性能时,主要标准就是算法的渐近时间复杂度,因此,在算法分析时,往往对两者不予区分,经常是将渐近时间复杂度T(n)=O(f(n))简称为时间复杂度,其中的f(n)一般是算法中频度最大的语句频度。

    此外,算法中语句的频度不仅与问题规模有关,还与输入实例中各元素的取值相关。但是我们总是考虑在最坏的情况下的时间复杂度。以保证算法的运行时间不会比它更长。

    常见的时间复杂度,按数量级递增排列依次为:常数阶O(1)、对数阶O(log2n)、线性阶O(n)、线性对数阶O(nlog2n)、平方阶O(n^2)、立方阶O(n^3)、k次方阶O(n^k)、指数阶O(2^n)。

    下面我们通过例子加以说明,让大家碰到问题时知道如何去解决。

    1、设三个函数f,g,h分别为 f(n)=100n^3+n^2+1000 , g(n)=25n^3+5000n^2 , h(n)=n^1.5+5000nlgn 

    请判断下列关系是否成立:

    (1) f(n)=O(g(n)) 

    (2) g(n)=O(f(n)) 

    (3) h(n)=O(n^1.5)

    (4) h(n)=O(nlgn)

    这里我们复习一下渐近时间复杂度的表示法T(n)=O(f(n)),这里的"O"是数学符号,它的严格定义是"若T(n)和f(n)是定义在正整数集合上的两个函数,则T(n)=O(f(n))表示存在正的常数C和n0 ,使得当n≥n0时都满足0≤T(n)≤C?f(n)。"用容易理解的话说就是这两个函数当整型自变量n趋向于无穷大时,两者的比值是一个不等于0的常数。这么一来,就好计算了吧。 

    ◆ (1)成立。题中由于两个函数的最高次项都是n^3,因此当n→∞时,两个函数的比值是一个常数,所以这个关系式是成立的。 

    ◆ (2)成立。与上同理。

    ◆ (3)成立。与上同理。

    ◆ (4)不成立。由于当n→∞时n^1.5比nlgn递增的快,所以h(n)与nlgn的比值不是常数,故不成立。
    2、设n为正整数,利用大"O"记号,将下列程序段的执行时间表示为n的函数。

    (1) i=1; k=0 

    while(i<n)

    { k=k+10*i;i++;



    解答:T(n)=n-1, T(n)=O(n), 这个函数是按线性阶递增的。

    (2) x=n; // n>1 

    while (x>=(y+1)*(y+1))

    y++;

    解答:T(n)=n1/2 ,T(n)=O(n1/2), 最坏的情况是y=0,那么循环的次数是n1/2次,这是一个按平方根阶递增的函数。

    (3) x=91; y=100; 

    while(y>0)

    if(x>100)

    {x=x-10;y--;}

    else x++;

    解答: T(n)=O(1), 这个程序看起来有点吓人,总共循环运行了1000次,但是我们看到n没有? 没。这段程序的运行是和n无关的,就算它再循环一万年,我们也不管他,只是一个常数阶的函数。

    1、算法的时间性能分析
    (1)算法耗费的时间和语句频度
       一个算法所耗费的时间=算法中每条语句的执行时间之和
    每条语句的执行时间=语句的执行次数(即频度(Frequency Count))×语句执行一次所需时间
        算法转换为程序后,每条语句执行一次所需的时间取决于机器的指令性能、速度以及编译所产生的代码质量等难以确定的因素。
        若要独立于机器的软、硬件系统来分析算法的时间耗费,则设每条语句执行一次所需的时间均是单位时间,一个算法的时间耗费就是该算法中所有语句的频度之和。

    求两个n阶方阵的乘积 C=A×B,其算法如下:
    # define n 100 // n 可根据需要定义,这里假定为
    100
    void MatrixMultiply(int A[a],int B [n][n],
    int C[n][n])
    { //右边列为各语句的频度

    int i ,j ,k;
    (1) for(i=0; i
    n;j++) n+1
    (2)     for (j=0;j<
    n;j++) { n(n+1)
    (3)       C[i][j]=0; n2
    (4)       for (k=0; k<
    n; k++) n2(n+1)
    (5)         C[i][j]=C[i][j]+A[i][k]*B[k][j]; n3
             }
           }
        该算法中所有语句的频度之和(即算法的时间耗费)为:

               T(n)=2n3+3n2+2n+1 (1.1)
    分析:
       语句(1)的循环控制变量i要增加到n,测试到i=n成立才会终止。故它的频度是n+1。但是它的循环体却只能执行n次。语句(2)作为语句(1)循环体内的语句应该执行n次,但语句(2)本身要执行n+1次,所以语句(2)的频度是n(n+1)。同理可得语句(3),(4)和(5)的频度分别是n2,n2(n+1)和n3 
       算法MatrixMultiply的时间耗费T(n)是矩阵阶数n的函数。

    (2)问题规模和算法的时间复杂度
        算法求解问题的输入量称为问题的规模(Size),一般用一个整数表示。

    矩阵乘积问题的规模是矩阵的阶数。

    一个图论问题的规模则是图中的顶点数或边数。
       一个算法的时间复杂度(Time Complexity, 也称时间复杂性)T(n)是该算法的时间耗费,是该算法所求解问题规模n的函数。当问题的规模n趋向无穷大时,时间复杂度T(n)的数量级(阶)称为算法的渐进时间复杂度。

    算法MatrixMultidy的时间复杂度T(n)如(1.1)式所示,当n趋向无穷大时,显然有

       这表明,当n充分大时,T(n)和n3之比是一个不等于零的常数。即T(n)和n3是同阶的,或者说T(n)和n3的数量级相同。记作T(n)=O(n3)是算法MatrixMultiply的渐近时间复杂度。

    (3)渐进时间复杂度评价算法时间性能
      主要用算法时间复杂度的数量级(即算法的渐近时间复杂度)评价一个算法的时间性能。

    算法MatrixMultiply的时间复杂度一般为T(n)=O(n3),f(n)=n3是该算法中语句(5)的频度。下面再举例说明如何求算法的时间复杂度。

    交换i和j的内容。
          Temp=i;
          i=j;
          j=temp;
      以上三条单个语句的频度均为1,该程序段的执行时间是一个与问题规模n无关的常数。算法的时间复杂度为常数阶,记作T(n)=O(1)。
    注意:如果算法的执行时间不随着问题规模n的增加而增长,即使算法中有上千条语句,其执行时间也不过是一个较大的常数。此类算法的时间复杂度是O(1)。
    变量计数之一:

    (1) x=0;y=0;
    (2) for(k-1;k<=n;k++)
    (3)     x++;
    (4) for(i=1;i<=n;i++)
    (5)       for(j=1;j<=n;j++)
    (6)         y++;
      一般情况下,对步进循环语句只需考虑循环体中语句的执行次数,忽略该语句中步长加1、终值判别、控制转移等成分。因此,以上程序段中频度最大的语句是(6),其频度为f(n)=n2,所以该程序段的时间复杂度为T(n)=O(n2)。
      当有若干个循环语句时,算法的时间复杂度是由嵌套层数最多的循环语句中最内层语句的频度f(n)决定的。

    变量计数之二:
    (1) x=1;
    (2) for(i=1;i<=n;i++)
    (3)       for(j=1;j<=i;j++)
    (4)           for(k=1;k<=j;k++)
    (5)               x++;
      该程序段中频度最大的语句是(5),内循环的执行次数虽然与问题规模n没有直接关系,但是却与外层循环的变量取值有关,而最外层循环的次数直接与n有关,因此可以从内层循环向外层分析语句(5)的执行次数:


    则该程序段的时间复杂度为T(n)=O(n3/6+低次项)=O(n3)。
    (4)算法的时间复杂度不仅仅依赖于问题的规模,还与输入实例的初始状态有关。

    在数值A[0..n-1]中查找给定值K的算法大致如下:
        (1)i=n-1;
              (2)while(i>=0&&(A[i]!=k))
          (3)     i--;
          (4)return i; 
        
    此算法中的语句(3)的频度不仅与问题规模n有关,还与输入实例中A的各元素取值及K的取值有关:
    ①若A中没有与K相等的元素,则语句(3)的频度f(n)=n;

    ②若A的最后一个元素等于K,则语句(3)的频度f(n)是常数0。 


    展开全文
  • 缺失的第一个正数 文章目录Leetcode算法Java全解答--41. 缺失的第一个正数题目想法结果总结代码我的答案大佬们的答案测试用例其他 题目 给定一个未排序的整数数组,找出其中没有出现的最小的正整数。 说明: 你的...

    Leetcode算法Java全解答–41. 缺失的第一个正数

    题目

    给定一个未排序的整数数组,找出其中没有出现的最小的正整数。

    说明:
    你的算法的时间复杂度应为O(n),并且只能使用常数级别的空间。

    示例

    示例 1:
    
    输入: [1,2,0]
    输出: 3
    示例 2:
    
    输入: [3,4,-1,1]
    输出: 2
    示例 3:
    
    输入: [7,8,9,11,12]
    输出: 1
    

    想法

    1. 错了!使用二进制来存储,将第N位的数据改成1,原来想的有二十亿数据,后面发现int只有32位,只能保证32个,错了

    2. 交换法

    将1放到数组 索引0位置,将2放到数组 索引1的位置,将3放到数组索引1的位置

    假设交换的数据还是大于0且小于i+1,则放在合适的位置,且数据不相等,避免死循环

    用的是 if判断 加上 i–,别人的方法使用while循环

    然后去循环数组,数据不对就返回

    结果

    超过97%的测试案例

    时间复杂度/空间复杂度:O(n)/1

    总结

    // TODO

    代码

    我的答案

    public int firstMissingPositive(int[] nums) {
    
        if (nums.length == 0) {
            return 1;
        }
    
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > 0) {
                // 假设交换的数据还是大于0且<i+1,则放在合适的位置,且数据不相等,避免死循环
                if (nums[i] < nums.length + 1 && nums[i] != nums[nums[i] - 1]) {
                    int tmp = nums[nums[i] - 1];
                    nums[nums[i] - 1] = nums[i];
                    nums[i] = tmp;
                    i--;
                }
            }
        }
    
        // 然后去循环数组,数据不对就返回
        for (int i = 0; i < nums.length; i++) {
            if (i + 1 != nums[i]) {
                return i + 1;
            }
        }
        return nums.length + 1;
    }
    
    
    /**
         * 位运算,错误答案
         * @param nums
         * @return
         */
        public int bit(int[] nums) {
            long bitNum = 0;
            for (int i = 0; i < nums.length; i++) {
                if (nums[i] > 0) {
                    // 将bitNum的第nums[i]变为1
                    // 第 i 位与0 或,值不变。第 i 位与1 或,变成1。因此,我们的目标是 num 与 一个第 i 位值为1,其它位的值都为0的数相 或
                    bitNum = bitNum | (1 << nums[i]);
                }
            }
    
            for (int i = 1; i < nums.length + 1; i++) {
                boolean zeroBit = (bitNum & (1 << i)) == 0;
                if (zeroBit) {
                    return i;
                }
            }
    
            return nums.length + 1;
        }
    

    大佬们的答案

    /**************************************
     * 比我好的答案 better
     * ***********************************/
    public int better(int[] nums) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
                int temp = nums[nums[i] - 1];
                nums[nums[i] - 1] = nums[i];
                nums[i] = temp;
            }
        }
    
        for (int i = 0; i < n; i++) {
            if (nums[i] != i + 1) {
                return i + 1;
            }
        }
        return n + 1;
    }
    

    测试用例

    @Test
    public void test041() {
        // 创建测试案例
        int[] test1 = new int[] { 0, 1, 2 };
        int[] test2 = new int[] { 10, 4, 16, 54, 17, -7, 21, 15, 25, 31, 61, 1, 6, 12, 21, 46, 16, 56, 54, 12, 23, 20,
                38, 63, 2, 27, 35, 11, 13, 47, 13, 11, 61, 39, 0, 14, 42, 8, 16, 54, 50, 12, -10, 43, 11, -1, 24, 38,
                -10, 13, 60, 0, 44, 11, 50, 33, 48, 20, 31, -4, 2, 54, -6, 51, 6 };
        int[] test3 = new int[] { 0, 1, 2, 3, 5 };
        int[] test4 = new int[] { 2 };
    
        // 测试案例期望值
        int expResult1 = 3;
        int expResult2 = 3;
        int expResult3 = 4;
        int expResult4 = 1;
    
        Solution041 solution041 = new Solution041();
    
        int result1 = solution041.firstMissingPositive(test1);
        int result2 = solution041.firstMissingPositive(test2);
        int result3 = solution041.firstMissingPositive(test3);
        int result4 = solution041.firstMissingPositive(test4);
    
        Assert.assertEquals(expResult1, result1);
        Assert.assertEquals(expResult2, result2);
        Assert.assertEquals(expResult3, result3);
        Assert.assertEquals(expResult4, result4);
    }
    

    其他

    代码托管码云地址:https://gitee.com/lizhaoandroid/LeetCodeAll.git

    查看其他内容可以点击专栏或者我的博客哈:https://blog.csdn.net/cmqwan

    “大佬们的答案” 标签来自leetcode,侵权请联系我进行删改

    如有疑问请联系,联系方式:QQ3060507060

    展开全文
  • 算法学习总结(2)——温故十大经典排序算法

    万次阅读 多人点赞 2019-08-29 14:57:51
    一、什么是排序算法 1.1、排序定义 一序列对象根据某个关键字进行排序。 1.2、排序术语 稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面;...时间复杂度:一个算法执行所耗费的时间。空间...

    一、什么是排序算法

    1.1、排序定义

    对一序列对象根据某个关键字进行排序。

    1.2、排序术语

    稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面;
    不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b的后面;
    内排序:所有排序操作都在内存中完成;
    外排序:由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数据传输才能进行;
    时间复杂度: 一个算法执行所耗费的时间。
    空间复杂度运行完一个程序所需内存的大小。

    1.3、算法总结

    (注意:n指数据规模;k指“桶”的个数;In-place指占用常数内存,不占用额外内存;Out-place指占用额外内存

    1.4、算法分类

    1.5、比较和非比较的区别

    常见的快速排序、归并排序、堆排序、冒泡排序等属于比较排序在排序的最终结果里,元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较,才能确定自己的位置。冒泡排序之类的排序中,问题规模为n,又因为需要比较n次,所以平均时间复杂度为O(n²)。在归并排序、快速排序之类的排序中,问题规模通过分治法消减为logN次,所以时间复杂度平均O(nlogn)。比较排序的优势是,适用于各种规模的数据,也不在乎数据的分布,都能进行排序。可以说,比较排序适用于一切需要排序的情况。计数排序、基数排序、桶排序则属于非比较排序。非比较排序是通过确定每个元素之前,应该有多少个元素来排序。针对数组arr,计算arr[i]之前有多少个元素,则唯一确定了arr[i]在排序后数组中的位置。非比较排序只要确定每个元素之前的已有的元素个数即可,所有一次遍历即可解决。算法时间复杂度O(n)非比较排序时间复杂度底,但由于非比较排序需要占用空间来确定唯一位置。所以对数据规模和数据分布有一定的要求。

    二、冒泡排序(Bubble Sort)

    冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 

    2.1、算法描述

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

    2.2、动图演示

    2.3、代码实现

    /**
     * 冒泡排序
     *
     * @param array
     * @return
     */
    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;
    }

    2.4、算法分析

    最佳情况:T(n) = O(n)   最差情况:T(n) = O(n2)   平均情况:T(n) = O(n2)

    三、选择排序(Selection Sort)

    表现最稳定的排序算法之一,因为无论什么数据进去都是O(n2)的时间复杂度,所以用到它的时候,数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲,选择排序可能也是平时排序一般人想到的最多的排序方法了吧。选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理:首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。 

    3.1、算法描述

    n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下:

    • 初始状态:无序区为R[1..n],有序区为空;
    • 第i趟排序(i=1,2,3…n-1)开始时,当前有序区和无序区分别为R[1..i-1]和R(i..n)。该趟排序从当前无序区中-选出关键字最小的记录 R[k],将它与无序区的第1个记录R交换,使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区;
    • n-1趟结束,数组有序化了。

    3.2、动图演示

    3.3、代码实现

    /**
     * 选择排序
     * @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;
    }

    3.4、算法分析

    最佳情况:T(n) = O(n2)  最差情况:T(n) = O(n2)  平均情况:T(n) = O(n2)

    四、插入排序(Insertion Sort)

    插入排序(Insertion-Sort)的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间

    4.1、算法描述

    一般来说,插入排序都采用in-place在数组上实现。具体算法描述如下:

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

    4.2、动图演示

    4.3、代码实现

    /**
     * 插入排序
     * @param array
     * @return
     */
    public static int[] insertionSort(int[] array) {
    	if (array.length == 0)
    		return array;
    	int current;
    	for (int i = 0; i < array.length - 1; i++) {
    		current = array[i + 1];
    		int preIndex = i;
    		while (preIndex >= 0 && current < array[preIndex]) {
    			array[preIndex + 1] = array[preIndex];
    			preIndex--;
    		}
    		array[preIndex + 1] = current;
    	}
    	return array;
    }

    4.4、算法分析

    最佳情况:T(n) = O(n)   最坏情况:T(n) = O(n2)   平均情况:T(n) = O(n2)

    五、希尔排序(Shell Sort)

    希尔排序是希尔(Donald Shell)于1959年提出的一种排序算法。希尔排序也是一种插入排序,它是简单插入排序经过改进之后的一个更高效的版本,也称为缩小增量排序,同时该算法是冲破O(n2)的第一批算法之一。它与插入排序的不同之处在于,它会优先比较距离较远的元素。希尔排序又叫缩小增量排序希尔排序是把记录按下表的一定增量分组,对每组使用直接插入排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减至1时,整个文件恰被分成一组,算法便终止。

    5.1、算法描述

    我们来看下希尔排序的基本步骤,在此我们选择增量gap=length/2,缩小增量继续以gap = gap/2的方式,这种增量选择我们可以用一个序列来表示,{n/2,(n/2)/2...1},称为增量序列。希尔排序的增量序列的选择与证明是个数学难题,我们选择的这个增量序列是比较常用的,也是希尔建议的增量,称为希尔增量,但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,具体算法描述:

    • 选择一个增量序列t1,t2,…,tk,其中ti>tj,tk=1;
    • 按增量序列个数k,对序列进行k 趟排序;
    • 每趟排序,根据对应的增量ti,将待排序列分割成若干长度为m 的子序列,分别对各子表进行直接插入排序。仅增量因子为1 时,整个序列作为一个表来处理,表长度即为整个序列的长度。

    5.2、过程演示

    5.3、代码实现

    /**
     * 希尔排序
     *
     * @param array
     * @return
     */
    public static int[] ShellSort(int[] array) {
    	int len = array.length;
    	int temp, gap = len / 2;
    	while (gap > 0) {
    		for (int i = gap; i < len; 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;
    }

    5.4、算法分析

    最佳情况:T(n) = O(nlog2 n)  最坏情况:T(n) = O(nlog2 n)  平均情况:T(n) =O(nlog2n) 

    六、归并排序(Merge Sort)

    和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是O(n log n)的时间复杂度。代价是需要额外的内存空间。归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为2-路归并。 

    6.1、算法描述

    • 把长度为n的输入序列分成两个长度为n/2的子序列;
    • 对这两个子序列分别采用归并排序;
    • 将两个排序好的子序列合并成一个最终的排序序列。

    6.2、动图演示

    6.3、代码实现

    /**
     * 归并排序
     *
     * @param array
     * @return
     */
    public static int[] MergeSort(int[] array) {
    	if (array.length < 2) return array;
    	int mid = array.length / 2;
    	int[] left = Arrays.copyOfRange(array, 0, mid);
    	int[] right = Arrays.copyOfRange(array, mid, array.length);
    	return merge(MergeSort(left), MergeSort(right));
    }
    /**
     * 归并排序——将两段排序好的数组结合成一个排序数组
     *
     * @param left
     * @param right
     * @return
     */
    public static int[] merge(int[] left, int[] right) {
    	int[] result = new int[left.length + right.length];
    	for (int index = 0, i = 0, j = 0; index < result.length; index++) {
    		if (i >= left.length)
    			result[index] = right[j++];
    		else if (j >= right.length)
    			result[index] = left[i++];
    		else if (left[i] > right[j])
    			result[index] = right[j++];
    		else
    			result[index] = left[i++];
    	}
    	return result;
    }

    6.4、算法分析

    最佳情况:T(n) = O(n)  最差情况:T(n) = O(nlogn)  平均情况:T(n) = O(nlogn)

    七、快速排序(Quick Sort)

    快速排序的基本思想:通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。

    7.1、算法描述

    快速排序使用分治法来把一个串(list)分为两个子串(sub-lists)。具体算法描述如下:

    • 从数列中挑出一个元素,称为 “基准”(pivot);
    • 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;
    • 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。

    7.2、动图演示

    7.3、代码实现

    /**
     * 快速排序方法
     * @param array
     * @param start
     * @param end
     * @return
     */
    public static int[] QuickSort(int[] array, int start, int end) {
    	if (array.length < 1 || start < 0 || end >= array.length || start > end) return null;
    	int smallIndex = partition(array, start, end);
    	if (smallIndex > start)
    		QuickSort(array, start, smallIndex - 1);
    	if (smallIndex < end)
    		QuickSort(array, smallIndex + 1, end);
    	return array;
    }
    /**
     * 快速排序算法——partition
     * @param array
     * @param start
     * @param end
     * @return
     */
    public static int partition(int[] array, int start, int end) {
    	int pivot = (int) (start + Math.random() * (end - start + 1));
    	int smallIndex = start - 1;
    	swap(array, pivot, end);
    	for (int i = start; i <= end; i++)
    		if (array[i] <= array[end]) {
    			smallIndex++;
    			if (i > smallIndex)
    				swap(array, i, smallIndex);
    		}
    	return smallIndex;
    }
    
    /**
     * 交换数组内两个元素
     * @param array
     * @param i
     * @param j
     */
    public static void swap(int[] array, int i, int j) {
    	int temp = array[i];
    	array[i] = array[j];
    	array[j] = temp;
    }

     


    wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==7.4、算法分析

    最佳情况:T(n) = O(nlogn)   最差情况:T(n) = O(n2)   平均情况:T(n) = O(nlogn) 

    八、堆排序(Heap Sort)

    堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构,并同时满足堆积的性质:即子结点的键值或索引总是小于(或者大于)它的父节点。

    8.1、算法描述

    • 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆,此堆为初始的无序区;
    • 将堆顶元素R[1]与最后一个元素R[n]交换,此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n];
    • 由于交换后新的堆顶R[1]可能违反堆的性质,因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆,然后再次将R[1]与无序区最后一个元素交换,得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1,则整个排序过程完成。

    8.2、动图演示

     

    8.3、代码实现

    //声明全局变量,用于记录数组array的长度;
    static int len;
    /**
     * 堆排序算法
     *
     * @param array
     * @return
     */
    public static int[] HeapSort(int[] array) {
    	len = array.length;
    	if (len < 1) return array;
    	//1.构建一个最大堆
    	buildMaxHeap(array);
    	//2.循环将堆首位(最大值)与末位交换,然后在重新调整最大堆
    	while (len > 0) {
    		swap(array, 0, len - 1);
    		len--;
    		adjustHeap(array, 0);
    	}
    	return array;
    }
    /**
     * 建立最大堆
     *
     * @param array
     */
    public static void buildMaxHeap(int[] array) {
    	//从最后一个非叶子节点开始向上构造最大堆
    	for (int i = (len/2 - 1); i >= 0; i--) { //感谢 @让我发会呆 网友的提醒,此处应该为 i = (len/2 - 1) 
    		adjustHeap(array, i);
    	}
    }
    /**
     * 调整使之成为最大堆
     *
     * @param array
     * @param i
     */
    public static void adjustHeap(int[] array, int i) {
    	int maxIndex = i;
    	//如果有左子树,且左子树大于父节点,则将最大指针指向左子树
    	if (i * 2 < len && array[i * 2] > array[maxIndex])
    		maxIndex = i * 2;
    	//如果有右子树,且右子树大于父节点,则将最大指针指向右子树
    	if (i * 2 + 1 < len && array[i * 2 + 1] > array[maxIndex])
    		maxIndex = i * 2 + 1;
    	//如果父节点不是最大值,则将父节点与最大值交换,并且递归调整与父节点交换的位置。
    	if (maxIndex != i) {
    		swap(array, maxIndex, i);
    		adjustHeap(array, maxIndex);
    	}
    }

    8.4、算法分析

    最佳情况:T(n) = O(nlogn) 最差情况:T(n) = O(nlogn) 平均情况:T(n) = O(nlogn)

    九、计数排序(Counting Sort)

    计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数。计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C,其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

    9.1、算法描述

    • 找出待排序的数组中最大和最小的元素;
    • 统计数组中每个值为i的元素出现的次数,存入数组C的第i项;
    • 对所有的计数累加(从C中的第一个元素开始,每一项和前一项相加);
    • 反向填充目标数组:将每个元素i放在新数组的第C(i)项,每放一个元素就将C(i)减去1。

    9.2、动图演示

    9.3、代码实现

    /**
     * 计数排序
     *
     * @param array
     * @return
     */
    public static int[] CountingSort(int[] array) {
    	if (array.length == 0) return array;
    	int bias, min = array[0], max = array[0];
    	for (int i = 1; i < array.length; i++) {
    		if (array[i] > max)
    			max = array[i];
    		if (array[i] < min)
    			min = array[i];
    	}
    	bias = 0 - min;
    	int[] bucket = new int[max - min + 1];
    	Arrays.fill(bucket, 0);
    	for (int i = 0; i < array.length; i++) {
    		bucket[array[i] + bias]++;
    	}
    	int index = 0, i = 0;
    	while (index < array.length) {
    		if (bucket[i] != 0) {
    			array[index] = i - bias;
    			bucket[i]--;
    			index++;
    		} else
    			i++;
    	}
    	return array;
    }

    9.4、算法分析

    当输入的元素是n 个0到k之间的整数时,它的运行时间是 O(n + k)。计数排序不是比较排序,排序的速度快于任何比较排序算法。由于用来计数的数组C的长度取决于待排序数组中数据的范围(等于待排序数组的最大值与最小值的差加上1),这使得计数排序对于数据范围很大的数组,需要大量时间和内存。最佳情况:T(n) = O(n+k)  最差情况:T(n) = O(n+k)  平均情况:T(n) = O(n+k)

    十、桶排序(Bucket Sort)

    桶排序是计数排序的升级版。它利用了函数的映射关系,高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理:假设输入数据服从均匀分布,将数据分到有限数量的桶里,每个桶再分别排序(有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排。

    10.1、算法描述

    • 人为设置一个BucketSize,作为每个桶所能放置多少个不同数值(例如当BucketSize==5时,该桶可以存放{1,2,3,4,5}这几种数字,但是容量不限,即可以存放100个3);
    • 遍历输入数据,并且把数据一个一个放到对应的桶里去;
    • 对每个不是空的桶进行排序,可以使用其它排序方法,也可以递归使用桶排序;
    • 从不是空的桶里把排好序的数据拼接起来。 

    注意,如果递归使用桶排序为各个桶排序,则当桶数量为1时要手动减小BucketSize增加下一循环桶的数量,否则会陷入死循环,导致内存溢出。

    10.2、图片演示

    10.3、代码实现

    /**
     * 桶排序
     * 
     * @param array
     * @param bucketSize
     * @return
     */
    public static ArrayList<Integer> BucketSort(ArrayList<Integer> array, int bucketSize) {
    	if (array == null || array.size() < 2)
    		return array;
    	int max = array.get(0), min = array.get(0);
    	// 找到最大值最小值
    	for (int i = 0; i < array.size(); i++) {
    		if (array.get(i) > max)
    			max = array.get(i);
    		if (array.get(i) < min)
    			min = array.get(i);
    	}
    	int bucketCount = (max - min) / bucketSize + 1;
    	ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketCount);
    	ArrayList<Integer> resultArr = new ArrayList<>();
    	for (int i = 0; i < bucketCount; i++) {
    		bucketArr.add(new ArrayList<Integer>());
    	}
    	for (int i = 0; i < array.size(); i++) {
    		bucketArr.get((array.get(i) - min) / bucketSize).add(array.get(i));
    	}
    	for (int i = 0; i < bucketCount; i++) {
    		if (bucketSize == 1) { // 如果带排序数组中有重复数字时  感谢 @见风任然是风 朋友指出错误
    			for (int j = 0; j < bucketArr.get(i).size(); j++)
    				resultArr.add(bucketArr.get(i).get(j));
    		} else {
    			if (bucketCount == 1)
    				bucketSize--;
    			ArrayList<Integer> temp = BucketSort(bucketArr.get(i), bucketSize);
    			for (int j = 0; j < temp.size(); j++)
    				resultArr.add(temp.get(j));
    		}
    	}
    	return resultArr;
    }

    10.4、算法分析

    桶排序最好情况下使用线性时间O(n),桶排序的时间复杂度,取决与对各个桶之间数据进行排序的时间复杂度,因为其它部分的时间复杂度都为O(n)。很显然,桶划分的越小,各个桶之间的数据越少,排序所用的时间也会越少。但相应的空间消耗就会增大。 最佳情况:T(n) = O(n+k)   最差情况:T(n) = O(n+k)   平均情况:T(n) = O(n2)  

    十一、基数排序(Radix Sort)

    基数排序也是非比较的排序算法,对每一位进行排序,从最低位开始排序,复杂度为O(kn),为数组长度,k为数组中的数的最大的位数;基数排序是按照低位先排序,然后收集;再按照高位排序,然后再收集;依次类推,直到最高位有时候有些属性是有优先级顺序的,先按低优先级排序,再按高优先级排序。最后的次序就是高优先级高的在前,高优先级相同的低优先级高的在前。基数排序基于分别排序,分别收集,所以是稳定的。

    11.1、算法描述

    • 取得数组中的最大数,并取得位数;
    • arr为原始数组,从最低位开始取每个位组成radix数组;
    • 对radix进行计数排序(利用计数排序适用于小范围数的特点);

    11.2、动图演示

    11.3、代码实现

    /**
     * 基数排序
     * @param array
     * @return
     */
    public static int[] RadixSort(int[] array) {
    	if (array == null || array.length < 2)
    		return array;
    	// 1.先算出最大数的位数;
    	int max = array[0];
    	for (int i = 1; i < array.length; i++) {
    		max = Math.max(max, array[i]);
    	}
    	int maxDigit = 0;
    	while (max != 0) {
    		max /= 10;
    		maxDigit++;
    	}
    	int mod = 10, div = 1;
    	ArrayList<ArrayList<Integer>> bucketList = new ArrayList<ArrayList<Integer>>();
    	for (int i = 0; i < 10; i++)
    		bucketList.add(new ArrayList<Integer>());
    	for (int i = 0; i < maxDigit; i++, mod *= 10, div *= 10) {
    		for (int j = 0; j < array.length; j++) {
    			int num = (array[j] % mod) / div;
    			bucketList.get(num).add(array[j]);
    		}
    		int index = 0;
    		for (int j = 0; j < bucketList.size(); j++) {
    			for (int k = 0; k < bucketList.get(j).size(); k++)
    				array[index++] = bucketList.get(j).get(k);
    			bucketList.get(j).clear();
    		}
    	}
    	return array;
    }

    11.4、算法分析

    最佳情况:T(n) = O(n * k)   最差情况:T(n) = O(n * k)   平均情况:T(n) = O(n * k)。基数排序有两种方法:MSD 从高位开始进行排序 LSD 从低位开始进行排序 。基数排序 vs 计数排序 vs 桶排序。这三种排序算法都利用了桶的概念,但对桶的使用方法上有明显差异:

    • 基数排序:根据键值的每位数字来分配桶
    • 计数排序:每个桶只存储单一键值
    • 桶排序:每个桶存储一定范围的数值
    展开全文
  • 能被其中一个数(要指出哪一个数)整除; 不能被3,5,7任一个整除。   #include &lt;iostream&gt; using namespace std; int main() { int tmp; while(cin&gt;&gt;tmp) { int k = (tm...

     

    能同时被3,5,7整除;
    能被其中两个数(要指出哪两个数)整除;
    能被其中一个数(要指出哪一个数)整除;
    不能被3,5,7任一个整除。

     

    #include <iostream>
    using namespace std;
    
    int main()
    {
        int tmp;
        while(cin>>tmp)
        {
           int k = (tmp%3 == 0) + (tmp%5 == 0)*2 +(tmp%7 == 0)*4; //巧妙地运用了数学控制8次可能
            switch(k)
            {
            case 0: cout<<"n"<<endl;break;
            case 1: cout<<"3"<<endl;break;
            case 2: cout<<"5"<<endl;break;
            case 3: cout<<"3 5"<<endl;break;
            case 4: cout<<"7"<<endl;break;
            case 5: cout<<"3 7"<<endl;break;
            case 6: cout<<"5 7"<<endl;break;
            case 7: cout<<"3 5 7"<<endl;
            }
           
        }   
        return 0;
    }

     

    展开全文
  • 输入一个整形数组,数组里正数也负数,数组中连续的一个或多个整数组成一个子数组,每个子数组都一个和。 求所有子数组的和的最大值。要求时间复杂度为O(n)。 例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5,...
  • Leetcode算法Java全解答–缺失的第一个正数 题目 给定一个未排序的整数数组,找出其中没有出现的最小的正整数。 示例 1: 输入: [1,2,0] 输出: 3 示例 2: 输入: [3,4,-1,1] 输出: 2 示例 3: 输入: [7,8,9,11,12] 输出...
  • 算法的5个重要特性: ①穷性: 一个算法必须总是在执行穷步之后结束,且每一步都可在穷...④输入一个算法有零个或多个输入,这些输入取自于某个特定的对象集合。 ⑤输出:一个算法有一个或多个的输出,这些输
  • 算法学习笔记之阶低通滤波算法

    万次阅读 多人点赞 2016-09-27 11:29:13
    1. 一阶滤波算法的原理 一阶滤波,又叫一阶惯性滤波,或一阶低通滤波。是使用软件编程实现普通硬件RC低通滤波器的功能。 一阶低通滤波的算法公式为: Y(n)=αX(n) (1-α)Y(n-1) 式中:α=滤波系数;X(n)=本次采样...
  • 八大排序算法

    万次阅读 多人点赞 2012-07-23 16:45:18
    排序内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,次不能容纳全部的排序记录,在排序过程中需要访问外存。 我们这里说说八大排序就是内部排序。 当n较大,则...
  • 算法算法评价

    万次阅读 多人点赞 2019-07-05 20:42:11
    算法特定问题求解步骤的一种描述,它是指令的有限序列,其中的每条指令表示一个或多个操作。具有以下性质: 1.穷性:一个算法必须总是在执行穷步之后结束,且每一步都可在穷时间内完成 2.确定性:算法中...
  • SIFT算法详解

    万次阅读 多人点赞 2012-04-28 21:40:36
    尺度不变特征变换匹配算法详解 Scale Invariant Feature Transform(SIFT) Just For Fun zdd zddmail@gmail.com 对于初学者,从David G.Lowe的论文到实现,许多鸿沟,本文帮你跨越。 1、SIFT综述 尺度不变...
  • 如何成为名AI人工智能算法工程师?

    万次阅读 多人点赞 2019-06-30 12:25:21
    经常朋友私信问,如何学python呀,如何敲代码呀,如何进入AI行业呀? 正好回头看看自己这一年走过的路,进行次经验总结。 来看看你距离成为名AI工程师还有多远吧~ ⭐具体内容: 我是因为什么开始接触敲...
  • 1) 穷性一个算法必须总是(任何合法的输入值)在执行穷步之后结束,且每一步都可在穷时间内完成。 2) 确定性算法中每一条指令必须确切的含义,读者理解时不会产生二义性。即对于相同的输入只能得出相同的...
  • 文章目录、总览二、常用排序算法1、冒泡排序——交换类排序1.1 简介1.2 源码1.3 效果2、快速排序——交换类排序2.1 简介2.2 源码2.3 效果3、选择排序——选择类排序3.1 简介3.2 源码3.3 效果4、堆排序——选择类...
  • 数据结构分别为逻辑结构、(存储)物理结构和数据的运算三部分。 为什么要学数据结构? 首先,因为数据结构作为计算机专业的专业基础课程,是计算机考研的必考科目之,如果打算报考计算机专业的研究生,你...
  • 常用查找算法——python3实现

    万次阅读 多人点赞 2019-05-28 19:24:22
    文章目录1、顺序查找1.1 简介1.2 基本思路1.3 优缺点1.4 源代码1.5 效果2、二分查找2.1 简介2.2 复杂度分析2.3 源代码2.4 效果3、分块查找3.1 简介3.2 算法思想3.3 算法流程3.4 复杂度分析3.5 源代码3.6 效果4、...
  • 分析 1、n=0 和 n=1 的时候 并没有其他可选择的,所以可以得出f(0)=0;...=2时情况就变复杂起来,但是这时候可以操作的步骤也就2种 也就是走1步(n-1)与走2步(n-2)。所以可以得到f(n)=f(n-1)+f(n-2); 从当...
  • 一个非常适合单片机的滤波算法

    千次阅读 2015-04-17 11:55:32
    连接:http://bbs.21ic.com/icview-170880-1-1.html -------------------------------------------------以下为原文 ------------------- 连接:...单片机大多资源小,算法占用
  • 将K-means算法应用到图像分割的一个尝试

    万次阅读 多人点赞 2014-01-10 15:56:07
    最近我一直在研究图像分割,目标提取的算法,由于背景目标的复杂而且噪点很多,所以我一直更换尝试各种算法以达到最好的效果。如果大家什么经验传递的话,烦请在评论里面留言,感谢。...k-means算法种得
  • (注:标题里的算法,指机器学习算法,或者说“算法工程师”这职位名称里的“算法”,不是“算法与数据结构”里的那个算法。谁能告诉我有没有什么更好的名字来区别这它们,或许是“机器学习算法”与“传统算法”?...
  • 人工智能算法)进化算法

    万次阅读 多人点赞 2019-01-22 01:55:56
    相信大部分人工智能感兴趣的人都听说过进化算法(遗传算法,基因算法)。篇文章当然不可能把进化算法的方方面面都说清楚,因此,本文只会介绍进化算法的原理,流程,以及少许应用。最主要的是在学习算法时,我...
  • 随机算法 Las Vegas算法 Monte Carlo算法

    千次阅读 2018-10-22 15:35:22
    同一组输入,不要求同一个结果(不确定) 应用 有些使用确定性求解算法效率会很差的问题,如果用随机算法求解,可以很快得到相当可信的结果,典型用于公钥,RSA算法。 分类 主要分为LasVegas算法和MonteCarlo算法 Las...
  • Potrace:一个基于多边形的位图轮廓矢量化算法

    万次阅读 多人点赞 2014-02-09 23:16:05
    这是一个非常古老的算法 源于2003年,作者 Peter Selinger。 它的作用是输入一张二值图(不是黑就是白),输出此图的矢量化结果,也就是将位图轮廓矢量化。 下面是译文部分, 所有注释会放在文章最下方。  1 介绍 ...
  • java小算法—判断一个数是否为质数

    万次阅读 2017-05-26 18:09:06
    判断一个数是否为质数:只能被1和自身整除的数   1.代码 public class Test { public static void main(String[] args) { boolean b=isPrime(997); System.out.println("997是否是质数----:&...
  • SM2算法篇:ECC加密算法

    万次阅读 多人点赞 2016-04-17 20:55:35
    ECC椭圆曲线加密算法
  • 给定一个由n行数字组成的数字三角形,试设计一个算法,计算出从三角形的顶至底的一条路径,使该路径经过的数字总和最大(每一步只能一个数走到下一层上和它最近的左边的数或者右边的数)。 题目: 问题:  ...
  • 算法学习》 :为什么要学习算法?时间复杂度

    千次阅读 多人点赞 2020-01-05 15:36:20
    面试必问,面试官一上来,就让你写一个冒泡排序 ,你一脸懵逼,心想啥是冒泡排序,这就尴尬了,只能跟这家公司说good bye了,继续开始你的面试之旅。 作为一个开发人员,你想在这条道路上越走越远,算法是必学的,...
  • 一个栈依次压入1,2,3,4,5,那么从栈顶到栈底分别为5,4,3,2,1。将这个栈转置后,从栈顶到栈底为1,2,3,4,5,也就是实现栈中元素的逆序,但是只能用递归函数来实现,不能用其他数据结构。 题解 题源:《程序员代码面试...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 337,586
精华内容 135,034
关键字:

一个算法只能有一个输入对吗