数据结构与算法 java描述 第一章 算法及其复杂度

目录

• 数据结构与算法 java描述 笔记
• 第一章 算法及其复杂度
  • 算法的定义
  • 算法性能的分析与评价
    • 问题规模、运行时间及时间复杂度
      • 渐进复杂度
        • 大 O 记号
        • 大Ω记号
        • Θ记号
    • 空间复杂度
  • 算法复杂度及其分析
    • O(1)⎯⎯取非极端元素
    • O(logn)⎯⎯进制转换
    • O(n)⎯⎯数组求和
    • O(n$^2$ )⎯⎯起泡排序
    • O(2$^r$ )⎯⎯幂函数
  • 计算模型
  • 递归
    • 线性递归
    • 递归算法的复杂度分析
      • 递归跟踪法
      • 递推方程法
    • 二分递归
    • 多分支递归

数据结构与算法 java描述 笔记

第一章 算法及其复杂度

算法的定义

​ 在特定计算模型下，在信息处理过程中为了解决某一类问题而设计的一个指令序列。

要素

• ​ 输入：待处理的信息，即对具体问题的描述。
• ​ 输出：经过处理之后得到的信息，即问题的答案
• ​ 确定性：任一算法都可以描述为由若干种基本操作组成的序列。
• ​ 可行性：在相应的计算模型中，每一基本操作都可以实现，且能够在常数时间内完成。
• ​ 有穷性：对于任何输入，按照算法，经过有穷次基本操作都可以得到正确的输出。

算法性能的分析与评价

问题规模、运行时间及时间复杂度

​ 为了简化分析，我们通常只考虑输入规模这一主要因素。

​ 如果将某一算法为了处理规模为 n 的问题所需的时间记作 T(n)，那么随着问题规模 n 的增长，运行时间 T(n)将如何增长？我们将 T(n) 称作算法的时间复杂度。

渐进复杂度

​ 在评价算法的运行时间时，我们往往可以忽略其在处理小规模问题时的性能，转而关注其在处理足够大规模问题时的性能，即所谓的渐进复杂度（Asmpototic complexity）。

大 O 记号

​ 如果存 在正常数 a、N 和一个函数 f(n)，使得对于任何 n > N，都有

​ T(n) < a × f(n)

​ 我们就可以认为在 n 足够大之后，f(n)给出了 T(n)的一个上界。

​ 对于这种情况，我们记之为 T(n) = O(f(n)) 这里的 O 称作“大 O 记号（Big-O notation）”。

大Ω记号

​ 如果存在正常数 a、N 和一个函数 g(n)，使得对于任何 n > N，都有

​ T(n) > a × g(n)

​ 我们就可以认为在 n 足够大之后，g(n)给出了 T(n)的一个下界。

​ 对于这种情况，我们记之为 T(n) = Ω(g(n)) 这里的Ω称作“大Ω记号（Big-Ω notation）”。

Θ记号

​ 如果存在正常数 a N，都有

​ a × h(n) < T(n) < b × h(n)

​ 我们就可以认为在 n 足够大之后，h(n)给出了 T(n)的一个确界。

​ 对于这种情况，我们记之为 T(n) = Θ(h(n)) Θ记号是对算法执行效率的一种准确估计⎯⎯对于规模为 n 的任意输入，算法的运行时间都与 Θ(h(n))同阶。

空间复杂度

​ 算法所需使用的存储空间量，即算法空间复杂度。

​ 就渐进复杂度的意义而言，在任何一个算法的任何一次运行过程中，其实际占用的存 储空间都不会多于其间执行的基本操作次数。

​ 引入时间复杂度的各种记号来度量算法的空间复杂度。

算法复杂度及其分析

O(1)⎯⎯取非极端元素

​ 问题：给定整数子集S, +∞ > |S| = n ≥ 3，从中找出一个元素 a∈S，使得 a ≠ max(S)且 a ≠ min(S)。也就是说，在最大、最小者之外，取出任意一个数。

算法：NonextremeElement(S[], n)
输入：由n个整数构成的集合S
输出：其中的任一非极端元素
{
	任取的三个元素x, y, z ∈ S; //既然S是集合，这三个元素必互异
	通过比较，找出其中的最小者min{x, y, z}和最大者max{x, y, z};
	输出最小、最大者之外的那个元素;
}

思路：

S 是有限集，故其中的最大、最小元素各有且仅有一个。

因此，无论 S 的规 模有多大，在前三个元素 S[0]、S[1]和 S[2]中，必包含至少一个非极端元素。

我们可以取 x = S[0]、y = S[1]和 z = S[ 2]，这只需执行三次基本操作，耗费 O(3)时间。

为了确定这三个元 素的大小次序，我们最多需要做三次比较（请读者自己给出证明），也是 O(3)时间。

最后，输出居中 的那个元素只需 O(1)时间。

运行时间为： T(n) = O(3) + O(3) + O(1) = O(7) = O(1)

O(logn)⎯⎯进制转换

​ 问题：给定任一十进制整数，将其转换为三进制表示。比如

​ 23(10) = 212(3)

​ 101(10) = 10202(3)

算法：BaseConversion(n)
输入：十进制整数n
输出：n的三进制表示
{
	不断循环，直到n = 0 {
 		输出 n % 3; //取模
 		令 n = n/3; //整除
 	}
}

以 101(10)为例思路：

​ 第一轮循环，输出 101 mod 3 = 2，n = 100/3 = 33； 2

​ 第二轮循环，输出 33 mod 3 = 0，n = 33/3 = 11； 0

​ 第三轮循环，输出 11 mod 3 = 2，n = 11/3 = 3； 2

​ 第四轮循环，输出 3 mod 3 = 0，n = 3/3 = 1； 0

​ 第五轮循环，输出 1 mod 3 = 1，n = 1/3 = 0。 1

​ result=10202(3)

该算法由若干次循环构成， 每一轮循环内部，都只需进行两次基本操作（取模、整除）。

每经过一轮循环，n都至少减少至 1/3。于是，至多经过

\[1+[log3n]
\]

次循环，即 可减小至 0。

因此，该算法需要运行 O(2×(1+[log3n])) = O(log3n)时间。

鉴于大 O 记号的性质，我们通常会忽略对数函数的常底数。比如这里的底数为常数 3，故通常 将上述复杂度记作 O(logn)。

O(n)⎯⎯数组求和

问题：给定n个整数，计算它们的总和。

算法：Sum(A[], n)
输入：由n个整数组成的数组A[]
输出：A[]中所有元素的总和
{
	令s = 0;
	对于每一个A[i]，i = 0, 1, …, n-1
	 	令s = s + A[i];
	输出s;
}

思路

对s的初始化需要O(1)时间。

每一轮循环中只需进行一次累 加运算，这属于基本操作，可以在O(1)时间内完成。

O(1) + O(1)×n = O(n+1) = O(n)

O(n\(^2\) )⎯⎯起泡排序

问题：冒泡排序

算法：Bubblesort(S[], n)
输入：n个元素组成的一个序列S[]，每个元素由[0..n-1]之间的下标确定，元素之间可以比较大小
输出：重新调整S[]中元素的次序，使得它们按照非降次序排列
{
	从S[0]和S[1]开始，依次检查每一对相邻的元素;
	只要它们位置颠倒，则交换其位置;
	反复执行上述操作，直到每一对相邻元素的次序都符合要求;
}

思路：

为了对n个整数排序，该算法的外循环最多需要做n轮。

经过第i轮循环，元素 S[n-i-1]必然就位，i = 0, 1, …, n-1。\(r\)

在第i轮外循环中，内循环需要做n-i-1 轮。

在每一轮内循环中， 需要做一次比较操作，另外至多需要做三次赋值操作，这些都属于基本操作，可以在O(4)的时间内 完成。

\[T(n) = \sum_{i=0}^{n-1} {(n-i-1)} × O(4) = O(2n(n-1)) = O(2n^2–2n)
\]

\[
\]

鉴于大 O 记号的特性，低次项可以忽略，常系数可以简化为 1，故再次得到 T(n) = O(n^2 )

O(2\(^r\) )⎯⎯幂函数

问题:虑幂函数的计算

算法：PowerBruteForce(r)
输入：非负整数r
输出：幂2^r
{
 power = 1;
 while (0 < r--)
 	power = power * 2;
 return power;
}

共需要做r次迭代，每次迭代只涉及常数次基本操作，故总共需要运行O(r)时间。

问题的输入规模为n，故有O(r) = O(2\(^n\) )。

计算模型

• 可解性

  ​ 现代意义上的电子计算机所对应的计算模型，就是所谓的图灵机

• 有效可解

  具体来说就是指存在某一算法，能够在多项式时间以内解决这一问题。反之，若某问题的任一 算法都具有不低于指数的复杂度，则不是有效可解的

• 下界

  在任何一种特定计算模型下，对于任一可有效解决的问题，任何算法的时间复杂度都 不可能低于某一范围，我们称之为该问题在这一计算模型下的复杂度下界，或简称该问题的下界。

递归

当某个方法调用自己时，我们就称之为递归调用（Recursive call ）。

线性递归

​ 类方法的每个实例只能递归地调用自己至多一次.

​ 最后一次递归调用被称作递归的“基底”，简称“递归基”。

性质:经过有限的时间后，它必须能够终止。

线性递归式算法都具有如下形式：

• ​ 检测递归基。首先要检测是否到达递归基，也就是最基本、最简单的情况，在这些平凡情 况下无需做进一步递归调用。
• ​ 递归处理。如果尚未遇到平凡的情况，则执行一次递归调用。通常，递归调用有多种可能， 此时需要经过进一步的检测以判断具体应按何种方式做递归调用。

递归算法的复杂度分析

递归跟踪法

​ 一种直观的、可视的分析方法,就是将递归方法的执行过程表示为图形的形式.方法的每一实例都对应于一个方框，其中注明了该实例调用的参数；若方法实例 M 调用方法实例 N，则在 M 与 N 对 应的方框之间添加一条有向联线，指明调用与被调用的关系。

递推方程法

对递归的模式进行归纳从而导出关于复杂度函数的递推方程，递归方程的解将给出算法的复杂度。

二分递归

将一个大问题分解为两个子问题，然后分别通过递归调用来求解，这种情 况称作二分递归（Binary recursion ）。

多分支递归

一个问题可能需要分解为不止两个子问题，此时就要采用多分支递归（Multiple recursion）。