常用的算法的时间复杂度和空间复杂度
算法的时间复杂度和空间复杂度-总结分析
算法的时间复杂度和空间复杂度-总结通常，对于一个给定的算法，我们要做两项分析。
第一是从数学上证明算法的正确性，这一步主要用到形式化证明的方法及相关推理模式，如循环不变式、数学归纳法等。
而在证明算法是正确的基础上，第二部就是分析算法的时间复杂度。
算法的时间复杂度反映了程序执行时间随输入规模增长而增长的量级，在很大程度上能很好反映出算法的优劣与否。
因此，作为程序员，掌握基本的算法时间复杂度分析方法是很有必要的。
算法执行时间需通过依据该算法编制的程序在计算机上运行时所消耗的时间来度量。
而度量一个程序的执行时间通常有两种方法。
一、事后统计的方法这种方法可行，但不是一个好的方法。
该方法有两个缺陷：一是要想对设计的算法的运行性能进行评测，必须先依据算法编制相应的程序并实际运行；二是所得时间的统计量依赖于计算机的硬件、软件等环境因素，有时容易掩盖算法本身的优势。
二、事前分析估算的方法因事后统计方法更多的依赖于计算机的硬件、软件等环境因素，有时容易掩盖算法本身的优劣。
因此人们常常采用事前分析估算的方法。
在编写程序前，依据统计方法对算法进行估算。
一个用高级语言编写的程序在计算机上运行时所消耗的时间取决于下列因素：(1). 算法采用的策略、方法；(2). 编译产生的代码质量；(3). 问题的输入规模；(4). 机器执行指令的速度。
一个算法是由控制结构（顺序、分支和循环3种）和原操作（指固有数据类型的操作）构成的，则算法时间取决于两者的综合效果。
为了便于比较同一个问题的不同算法，通常的做法是，从算法中选取一种对于所研究的问题（或算法类型）来说是基本操作的原操作，以该基本操作的重复执行的次数作为算法的时间量度。
1、时间复杂度（1）时间频度一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。
但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。
并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。
常用算法时间复杂度
常用算法时间复杂度在计算机科学领域中，算法是解决问题的一种方法。
算法的好坏不仅与其解决问题的准确性相关，而且和其所需的时间和空间复杂度也有关。
时间复杂度是度量算法执行所需时间的数量级，通常用大O符号表示，因此也被称为大O复杂度。
下面介绍一些常用算法的时间复杂度。
1. 常数时间复杂度（O(1)）此类算法与输入规模大小无关，执行时间始终相同。
例如，访问数组的某个元素，可以通过索引直接访问，不需要循环遍历整个数组。
2. 线性时间复杂度（O(n)）此类算法的执行时间与输入规模成线性关系。
例如，遍历一个数组，需要循环访问每个元素一次，时间复杂度为O(n)。
3. 对数时间复杂度（O(logn)）此类算法的执行时间与输入规模成对数关系。
例如，二分查找算法，每次执行都能将待查找元素的搜索区间缩小一半，因此时间复杂度为O(logn)。
4. 平方时间复杂度（O(n^2)）此类算法的执行时间与输入规模的平方成正比。
例如，嵌套循环遍历二维数组，需要执行n*n次操作，时间复杂度为O(n^2)。
5. 立方时间复杂度（O(n^3)）此类算法的执行时间与输入规模的立方成正比。
例如，嵌套循环遍历三维数组，需要执行n*n*n次操作，时间复杂度为O(n^3)。
6. 指数时间复杂度（O(2^n)）此类算法的执行时间随着输入规模的增加呈指数级增长。
例如，求解某些NP问题（非确定性多项式问题）的暴力搜索算法，时间复杂度为O(2^n)。
7. 阶乘时间复杂度（O(n!)）此类算法的执行时间随着输入规模的增加呈阶乘级增长。
例如，通过枚举法求解某些问题，每次需要执行n!次操作，时间复杂度为O(n!)。
在实际应用中，时间复杂度是衡量算法效率的重要指标，因此开发人员需要在设计时考虑时间复杂度优化问题。
如果算法复杂度较高，可能会导致程序执行时间过长，甚至无法正常运行。
因此，开发人员需要根据具体情况来选择合适的算法，以达到更好的性能要求。
算法的时间复杂度和空间复杂度
相关知识介绍（所有定义只为帮助读者理解相关概念，并非严格定义）：1、稳定排序和非稳定排序简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就说这种排序方法是稳定的。
反之，就是非稳定的。
比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为a1,a2,a4,a3,a5，则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。
假如变成a1,a4, a2,a3,a5就不是稳定的了。
2、内排序和外排序在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。
3、算法的时间复杂度和空间复杂度所谓算法的时间复杂度，是指执行算法所需要的计算工作量。
一个算法的空间复杂度，一般是指执行这个算法所需要的内存空间。
功能：选择排序输入：数组名称（也就是数组首地址）、数组中元素个数算法思想简单描述：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
选择排序是不稳定的。
算法复杂度O(n2)--[n的平方void select_sort(int *x, int n){int i, j, min, t;for (i=0; i<n-1; i++) /*要选择的次数：0~n-2共n-1次*/{min = i; /*假设当前下标为i的数最小，比较后再调整*/for (j=i+1; j<n; j++)/*循环找出最小的数的下标是哪个*/{if (*(x+j) < *(x+min)){min = j; /*如果后面的数比前面的小，则记下它的下标*/}}if (min != i) /*如果min在循环中改变了，就需要交换数据*/{t = *(x+i);*(x+i) = *(x+min);*(x+min) = t;}}/*功能：直接插入排序输入：数组名称（也就是数组首地址）、数组中元素个数算法思想简单描述：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。
《计算机算法基础》教学大纲
《计算机算法基础》教学大纲计算机算法基础教学大纲课程简介本课程作为计算机科学与技术专业必修课，旨在让学生掌握计算机算法的基础知识和基本应用，为后续深入研究算法提供基础。
教学目标通过本课程的研究，学生将能够：- 熟练掌握常用的计算机算法- 理解各种算法的基本思想和运行原理- 能够运用算法进行简单的问题求解和程序设计- 培养编写高效算法的能力教学内容第一章算法基础1.1 算法的定义和特性1.2 算法的分类1.3 时间复杂度和空间复杂度第二章常用算法2.1 排序算法（冒泡排序、快速排序、归并排序）2.2 查找算法（顺序查找、折半查找、哈希查找）2.3 图算法（最短路径算法、最小生成树算法）第三章算法应用3.1 算法在智能搜索、机器研究等领域的应用3.2 算法在计算机游戏、网络安全等领域的应用3.3 算法在大数据处理中的应用教学方法本课程采用讲授和实践相结合的教学方法。
教师将通过课堂讲解、板书演示、案例分析等方式向学生介绍算法基础原理和应用技巧，并通过实例编程和练巩固学生的实际应用能力。
考核方式本课程考核方式包括课堂作业、实验报告、期中考试和期末考试。
其中，期中考试占30%的成绩，期末考试占50%的成绩，课堂作业和实验报告占20%的成绩。
教材与参考书目教材《数据结构与算法分析》，作者：Mark Allen Weiss，出版社：机械工业出版社参考书目《算法导论》，作者：Thomas H. Cormen，出版社：机械工业出版社《算法设计与分析基础》，作者：Sun Limin，出版社：高等教育出版社实验环境本课程实验环境为Windows操作系统，使用Java语言进行编程实现。
教学进度。
算法的时间复杂度和空间复杂度的关系
算法的时间复杂度和空间复杂度的关系
时间复杂度和空间复杂度是算法分析中最重要的概念，它们可以帮助我们评估算法的性能。
时间复杂度描述了算法执行所需的时间，而空间复杂度描述了算法执行所需的内存空间。
时间复杂度是指算法执行所需的时间，它可以用大O表示法来表示，其中O(n)表示算法
的时间复杂度为n，即算法的执行时间与输入数据的大小成正比。
一般来说，算法的时间
复杂度越低，它的执行效率就越高。
空间复杂度是指算法执行所需的内存空间，它也可以用大O表示法来表示，其中O(n)表
示算法的空间复杂度为n，即算法所需的内存空间与输入数据的大小成正比。
一般来说，
算法的空间复杂度越低，它的内存使用效率就越高。
时间复杂度和空间复杂度之间存在一定的关系，即算法的时间复杂度越低，它的空间复杂度也越低。
这是因为算法的时间复杂度越低，它所需的计算量就越少，因此它所需的内存
空间也就越少。
反之，算法的时间复杂度越高，它所需的计算量就越多，因此它所需的内
存空间也就越多。
因此，我们可以从算法的时间复杂度来推断它的空间复杂度，从而更好地评估算法的性能。
但是，有时候算法的时间复杂度和空间复杂度可能不是成正比的，因此我们还需要对算法
的空间复杂度进行具体的分析，以便更好地评估算法的性能。
总之，时间复杂度和空间复杂度是算法分析中最重要的概念，它们可以帮助我们评估算法的性能。
算法的时间复杂度越低，它的空间复杂度也越低，但有时候它们之间的关系可能
不是成正比的，因此我们还需要对算法的空间复杂度进行具体的分析，以便更好地评估算
法的性能。
常用排序算法的时间复杂度和空间复杂度
常⽤排序算法的时间复杂度和空间复杂度以上快速排序和归并排序的空间复杂度不正确没有的参考图1，以图2为准（对，就是懒得重新画图了）排序法最差时间分析平均时间复杂度稳定度空间复杂度冒泡排序O(n2)O(n2)稳定O(1)快速排序O(n2)O(n*log2n)不稳定O(log2n)~O(n)选择排序O(n2)O(n2)稳定O(1)⼆叉树排O(n2)O(n*log2n)不稳定O(n)序插⼊排序O(n2)O(n2)稳定O(1)堆排序O(n*log2n)O(n*log2n)不稳定O(1)希尔排序O O不稳定O(1)1.插⼊排序由N-1趟排序组成，对于p=1到p=N-1趟，插⼊排序保证从位置0到位置p上的元素为已排序状态。
时间复杂度：O(N^2)代码void InsertionSort(ElementType A[],int N){int j,p;ElementType Tmp;for(p=1;p<N;p++){Tmp=A[j];//把A[j]保存下来，因为它要被插⼊到前⾯的某个位置去for(j=p;j>0&&A[j-1]>Tmp;j--)//⼤于A[j]的元素逐个后移{A[j]=A[j-1];}A[j]=Tmp;}}2.希尔排序希尔排序使⽤⼀个序列h1，h2，h3，ht，叫做增量排序。
在使⽤增量hk的⼀趟排序之后，对于每个i我们有A[i]<A[i+hk]，所有相隔hk的元素被排序。
时间复杂度：O(N^(1+a))，其中0<a<1。
//代码不太好理解，使⽤了3层循环void ShellSort(ElementType A[],int N){int j,p,Increment;ElementType Tmp;for(Increment=N/2;Increment>0;Increment/=2){for(p=Increment;p<N;p++){Tmp=A[p];for(j=p;j>=Increment;j-=Increment){if(A[j]<A[j-Increment])A[j]=A[j-Increment];elsebreak;}A[j]=Tmp;}}}3. 堆排序思想：建⽴⼩顶堆，然后执⾏N次deleteMin操作。
如何判断程序的复杂程度：时间和空间复杂度
如何判断程序的复杂程度：时间和空间复杂度1. 时间复杂度：使⽤⼤O表⽰法来表⽰程序的时间复杂度常见的7种时间复杂度（复杂度由低到⾼排序）O(1):常数时间复杂度O(log(n): 对数时间复杂度O(n): 线性时间复杂度O(n^2):平⽅时间复杂度O(n^3):⽴⽅时间复杂度O(k^n):指数时间复杂度，k表⽰常数O(n!):阶乘时间复杂度ps：这⾥我们并不考虑前边的系数；O(1) 并不表⽰复杂度为1，也可以是2、3等常数；O(n)表⽰程序运⾏了n次或者2n、3n次；以此类推其他时间复杂度时间复杂度的判断，以⼀段代码的最⾼复杂度为准；如何判断⼀段代码的时间复杂度简⽽⾔之就是看内部某段代码的执⾏次数O(1):常数复杂度int n = 1;System.out.println(n);12int n = 1;System.out.println(n);System.out.println(n+1)System.out.println(n+2)1234O(n)：线性时间复杂度for (int j = 0; j < n; j++) {System.out.println(j);}123for (int i = 0; i < n; i++) {System.out.println(i);}for (int j = 0; j < n; j++) {System.out.println(j);}123456O(n^2)：平⽅时间复杂度for (int i = 0; i < n; i++) {for (int j = 0; j < n; j++) {System.out.println(i + j);345O(n^3)：⽴⽅时间复杂度for (int i = 0; i < n; i++) {for (int j = 0; j < n; j++) {for (int k = 0; k < n; k++) {System.out.println(i + j);}}}1234567O(log(n))：对数时间复杂度这⾥演⽰的是以2为底n的对数for (int i = 0; i < n; i = i * 2) {System.out.println(i);}123O(2^n)：指数时间复杂度/*** 递归求斐波那契数列的第n项；可以通过画运⾏树的⽅式获得时间复杂度*/int fib(int n) {if (n < 2) return n;return fib(n - 1) + fib(n - 2);}1234567O(n!)：阶乘时间复杂度todo⼩练习1：求和计算1~n的和O(n)int y = 2;for (int i = 0; i < n; i++) {y+=i;}1234O(1)使⽤了求和公式：sum = n(n+1)/2int y = 2;for (int i = 0; i < n; i++) {y+=i;4⼩练习2：求斐波那契数列O(2^n):int fib(int n) {if (n < 2) return n;return fib(n - 1) + fib(n - 2);}1234O(n)：该⽅法⽐递归要快得多int fib2(int n) {if (n == 1 || n == 2) {return 1;}int a = 1, b = 1, result = 0;for (int i = 3; i <= n; i++) {result = a + b;a = b;b = result;}return result;}123456789101112主定理主定理（英语：master theorem）提供了⽤渐近符号（⼤O符号）表⽰许多由分治法得到的递推关系式的⽅法常⽤算法中的应⽤算法递回关系式运算时间⼆分搜寻算法⼆叉树遍历最佳排序矩阵搜索(已排好序的⼆维矩阵)合并排序所有排序的最优算法都是O(nlog(n))2. 空间复杂度如何判断⼀段代码的空间复杂度主要通过两部分进⾏判断：数组的长度如果代码中应⽤了数组，那么数组的长度，基本上就是空间复杂度；e：⼀维数组的空间复杂度是O(n);⼆维数组的空间复杂度是O(n^2)递归的深度如果代码中有递归，那么递归的深度，就是代码的空间复杂度的最⼤值ps:如果代码中既有数组，⼜有递归，那么两者的最⼤值就是代码的空间复杂度leecode有个爬楼梯的复杂度分析情况；可以进⾏练习3. 数组和链表的时间复杂度分析数组随机增加：O(n)随机查询：O(1)随机删除：O(n)链表随机增加：O(1)随机查询：O(n)随机删除：O(1)跳表跳跃表（skiplist）是⼀种随机化的数据，由 William Pugh 在论⽂《Skip lists: a probabilistic alternative to balanced trees》中提出，跳跃表以有序的⽅式在层次化的链表中保存元素，效率和平衡树媲美 —— 查找、删除、添加等操作都可以在对数期望时间下完成，并且⽐起平衡树来说，跳跃表的实现要简单直观得多。
全国计算机等级考试二级Access知识总结
【ACCESS】全国计算机等级考试二级Access知识总结1. 算法的复杂度主要包括时间复杂度和空间复杂度。
2. 算法的时间复杂度是指执行算法所需要的计算工作量。
3. 算法的空间复杂度是指执行这个算法所需要的内存空间。
4. 一种数据的逻辑结构根据需要可以表示成多种存储结构。
而采用不同的存储结构，其数据处理的效率是不同。
5. 线性结构又称线性表，线性结构与非线性结构都可以是空的数据结构。
6. 线性表的顺序存储结构具有以下两个基本特点：①线性表中所有元素所占的存储空间是连续的；②线性表中各数据元素在存储空间中是按逻辑顺序依次存放的。
7. 栈是一种特殊的线性表，在这种线性表的结构中，一端是封闭的，不允许进行插入与删除元素；另一端是开口的，允许插入与删除元素。
先进后出或后进先出。
8. 队列（queue）是指允许在一端进行插入、而在另一端进行删除的线性表。
后进后出或先进先出。
9. 队列的顺序存储结构一般采用循环队列的形式。
10. 元素变动频繁的大线性表不宜采用顺序存储结构，而是采用链式存储结构。
11. 在链式存储方式中，要求每个结点由两部分组成：一部分用于存放数据元素值，称为数据域；另一部分用于存放指针，称为指针域。
12. 树（tree）是一种简单的非线性结构。
属于层次模型。
13. 二叉树通常采用链式存储结构14. 二叉树的基本性质性质1在二叉树的第k层上，最多有2k-1(k≥1)个结点。
性质2深度为m的二叉树最多有2m-1个结点。
性质3在任意一棵二叉树中，度为0的结点（即叶子结点）总是比度为2的结点多一个。
15. 二叉树的遍历可以分为三种：前序遍历（中前后）、中序遍历（前中后）、后序遍历（前后中）。
16. 对于长度为n的有序线性表，在最坏情况下，二分查找只需要比较log2n次，而顺序查找需要比较n次。
17. 在最坏情况下，冒泡排序需要比较次数为n(n-1)/2。
18. 在最坏情况下，简单插入排序需要n（n-1）/2次比较。
各种排序算法的时间复杂度和空间复杂度（阿里）
各种排序算法的时间复杂度和空间复杂度（阿⾥）⼆分查找法的时间复杂度：O(logn) redis,kafka,B+树的底层都采⽤了⼆分查找法参考：⼆分查找法 redis的索引底层的跳表原理实现参考：⼆分查找法参考：⼆分查找法：1.⼆分查找⼆分查找也称为折半查找，它是⼀种效率较⾼的查找⽅法。
⼆分查找的使⽤前提是线性表已经按照⼤⼩排好了序。
这种⽅法充分利⽤了元素间的次序关系，采⽤分治策略。
基本原理是：⾸先在有序的线性表中找到中值，将要查找的⽬标与中值进⾏⽐较，如果⽬标⼩于中值，则在前半部分找，如果⽬标⼩于中值，则在后半部分找；假设在前半部分找，则再与前半部分的中值相⽐较，如果⼩于中值，则在中值的前半部分找，如果⼤于中值，则在后半部分找。
以此类推，直到找到⽬标为⽌。
假设我们要在 2，6，11，13，16，17，22，30中查找22，上图所⽰，则查找步骤为：⾸先找到中值：中值为13（下标：int middle = (0+7)/2），将22与13进⾏⽐较，发现22⽐13⼤，则在13的后半部分找；在后半部分 16，17，22，30中查找22，⾸先找到中值，中值为17（下标：int middle=(0+3)/2），将22与17进⾏⽐较，发现22⽐17⼤，则继续在17的后半部分查找；在17的后半部分 22，30查找22，⾸先找到中值，中值为22（下标：int middle=(0+1)/2），将22与22进⾏⽐较，查找到结果。
⼆分查找⼤⼤降低了⽐较次数，⼆分查找的时间复杂度为：O(logn)，即。
⽰例代码：public class BinarySearch {public static void main(String[] args) {int arr[] = {2, 6, 11, 13, 16, 17, 22, 30};System.out.println("⾮递归结果,22的位置为:" + binarySearch(arr, 22));System.out.println("递归结果,22的位置为:" + binarySearch(arr, 22, 0, 7));}//⾮递归static int binarySearch(int[] arr, int res) {int low = 0;int high = arr.length-1;while(low <= high) {int middle = (low + high)/2;if(res == arr[middle]) {return middle;}else if(res <arr[middle]) {high = middle - 1;}else {low = middle + 1;}}return -1;}//递归static int binarySearch(int[] arr,int res,int low,int high){if(res < arr[low] || res > arr[high] || low > high){return -1;}int middle = (low+high)/2;if(res < arr[middle]){return binarySearch(arr, res, low, middle-1);}else if(res > arr[middle]){return binarySearch(arr, res, middle+1, high);}else {return middle;}}}其中冒泡排序加个标志，所以最好情况下是o(n)直接选择排序：排序过程：1 、⾸先在所有数据中经过 n-1次⽐较选出最⼩的数，把它与第 1个数据交换，2、然后在其余的数据内选出排序码最⼩的数，与第 2个数据交换...... 依次类推，直到所有数据排完为⽌。
计算机算法设计五大常用算法的分析及实例
计算机算法设计五⼤常⽤算法的分析及实例摘要算法（Algorithm）是指解题⽅案的准确⽽完整的描述，是⼀系列解决问题的清晰指令，算法代表着⽤系统的⽅法描述解决问题的策略机制。
也就是说，能够对⼀定规范的输⼊，在有限时间内获得所要求的输出。
如果⼀个算法有缺陷，或不适合于某个问题，执⾏这个算法将不会解决这个问题。
不同的算法可能⽤不同的时间、空间或效率来完成同样的任务。
其中最常见的五中基本算法是递归与分治法、动态规划、贪⼼算法、回溯法、分⽀限界法。
本⽂通过这种算法的分析以及实例的讲解，让读者对算法有更深刻的认识，同时对这五种算法有更清楚认识关键词：算法，递归与分治法、动态规划、贪⼼算法、回溯法、分⽀限界法AbstractAlgorithm is the description to the problem solving scheme ,a set of clear instructions to solve the problem and represents the describe the strategy to solve the problem using the method of system mechanism . That is to say, given some confirm import，the Algorithm will find result In a limited time。
If an algorithm is defective or is not suitable for a certain job, it is invalid to execute it. Different algorithms have different need of time or space, and it's efficiency are different.There are most common algorithms: the recursive and divide and conquer、dynamic programming method、greedy algorithm、backtracking、branch and bound method.According to analyze the five algorithms and explain examples, make readers know more about algorithm , and understand the five algorithms more deeply.Keywords: Algorithm, the recursive and divide and conquer, dynamic programming method, greedy algorithm、backtracking, branch and bound method⽬录1. 前⾔ (4)1.1 论⽂背景 (4)2. 算法详解 (5)2.1 算法与程序 (5)2.2 表达算法的抽象机制 (5)2.3 算法复杂性分析 (5)3．五中常⽤算法的详解及实例 (6)3.1 递归与分治策略 (6)3.1.1 递归与分治策略基本思想 (6)3.1.2 实例——棋盘覆盖 (7)3.2 动态规划 (8)3.2.1 动态规划基本思想 (8)3.2.2 动态规划算法的基本步骤 (9)3.2.3 实例——矩阵连乘 (9)3.3 贪⼼算法 (11)3.3.1 贪⼼算法基本思想 (11)3.3.2 贪⼼算法和动态规划的区别 (12)3.3.3 ⽤贪⼼算法解背包问题的基本步骤： (12)3.4 回溯发 (13)3.4.1 回溯法基本思想 (13)3.3.2 回溯发解题基本步骤 (13)3.3.3 实例——0-1背包问题 (14)3.5 分⽀限界法 (15)3.5.1 分⽀限界法思想 (15)3.5.2 实例——装载问题 (16)总结 (18)参考⽂献 (18)1. 前⾔1.1 论⽂背景算法（Algorithm）是指解题⽅案的准确⽽完整的描述，是⼀系列解决问题的清晰指令，算法代表着⽤系统的⽅法描述解决问题的策略机制。
算法评价指标
算法评价指标
算法评价指标，是用来评估一个算法优劣的指标体系。
常见的算法评价指标有以下几种：
1.准确率（Accuracy）：是指模型预测结果与真实值相符的概率。
通常用分类模型的预测结果与真实标签之间的一致性来衡量。
2.精确率（Precision）：是指模型在预测为正类的样本中真正为正类的比例。
用于评估模型识别出正例的能力。
3.召回率（Recall）：是指模型在所有真正为正类的样本中，成功预测出多少个正类。
用于评估模型识别出所有正例的能力。
4.F1值（F1-score）：是综合考虑了精确率和召回率的一个指标。
F1-Score越大，说明算法的性能越好。
5.ROC曲线下的面积（AUC）：是衡量分类器区分正例和负例的能力的一个指标。
AUC越大，说明算法的性能越好。
6.时间复杂度（Time Complexity）：是指算法完成任务所需的时间复杂度。
时间复杂度越小，说明算法的效率越高。
7.空间复杂度（Space Complexity）：是指算法需要占用的内存空间。
空间复杂度越小，说明算法的效率越高。
以上是常用的算法评价指标，根据具体研究目的和问题，选择合适的评价指标可以帮助我们更加准确地评价算法的性能。
计算机算法基础必学知识点
计算机算法基础必学知识点1. 时间复杂度和空间复杂度：算法的时间复杂度描述了算法执行时间随着输入规模增长时的增长率，空间复杂度描述了算法所需要的额外空间随着输入规模增长时的增长率。
常见的时间复杂度有常数时间O(1)，线性时间O(n)，对数时间O(log n)，平方时间O(n^2)等。
常见的空间复杂度有常数空间O(1)，线性空间O(n)，对数空间O(log n)，平方空间O(n^2)等。
2. 数组和链表：数组是由一组连续的内存地址组成的数据结构，可以通过索引快速访问其中的元素，插入和删除元素的时间复杂度较高。
链表是由一组节点组成的数据结构，节点包含元素以及指向下一个节点的指针，插入和删除元素的时间复杂度较低，但访问元素需要遍历链表。
3. 栈和队列：栈是一种后进先出（LIFO）的数据结构，只允许在栈的一端进行插入和删除操作，常用于实现函数调用、表达式求值等。
队列是一种先进先出（FIFO）的数据结构，只允许在队列的一端进行插入操作，在另一端进行删除操作，常用于实现任务调度、消息队列等。
4. 递归：递归是一种通过调用自身的方式解决问题的方法，在递归过程中，问题被分解为更小的子问题直到满足基本条件。
递归的实现需要注意递归终止条件和递归公式，避免出现无限递归。
5. 排序算法：常见的排序算法有冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序等，它们根据不同的原理和策略将一组无序的数据按照升序或降序排列。
6. 查找算法：常见的查找算法有线性查找、二分查找、哈希查找等，它们根据不同的数据结构和查找方式能够在给定的数据中快速定位到目标元素。
7. 图算法：图是一种由节点和边组成的数据结构，常用于描述各种复杂的关系和网络。
图算法包括深度优先搜索、广度优先搜索、最短路径算法、最小生成树算法等，用于解决图中各种问题。
8. 动态规划：动态规划是一种用于求解多阶段决策问题的算法思想，它通过将问题划分为多个子问题并存储子问题的解，避免重复计算，以提高算法的效率。
数据结构与算法（一）时间复杂度、空间复杂度计算
数据结构与算法（⼀）时间复杂度、空间复杂度计算⼀、时间复杂度计算1、时间复杂度的意义复杂度分析是整个算法学习的精髓，只要掌握了它，数据结构和算法的内容基本上就掌握了⼀半1. 测试结果⾮常依赖测试环境2. 测试结果受数据规模的影响很⼤所以，我们需要⼀个不⽤具体的测试数据来测试，就可以粗略地估计算法的执⾏效率的⽅法，即时间、空间复杂度分析⽅法。
2、⼤ O 复杂度表⽰法1)、可以将计算时间复杂度的⽅式和计算代码执⾏次数来进⾏类别int cal(int n) {int sum = 0;int i = 1;for (; i <= n; ++i) {sum = sum + i;}return sum;}第 2、3 ⾏代码分别需要 1 个 unit_time 的执⾏时间，第 4、5 ⾏都运⾏了 n 遍，所以需要 2n * unit_time 的执⾏时间，所以这段代码总的执⾏时间就是(2n+2) * unit_time。
可以看出来，所有代码的执⾏时间 T(n) 与每⾏代码的执⾏次数成正⽐。
2)、复杂⼀点的计算int cal(int n) { ----1int sum = 0; ----2int i = 1; ----3int j = 1; ----4for (; i <= n; ++i) { ----5j = 1; ----6for (; j <= n; ++j) { ----7sum = sum + i * j; ----8} ----9} ----10} ----11T(n) = (2n^2+2n+3)unit_timeT(n)=O(f(n))⼤ O 时间复杂度实际上并不具体表⽰代码真正的执⾏时间，⽽是表⽰代码执⾏时间随数据规模增长的变化趋势，所以，也叫作渐进时间复杂度（asymptotic time complexity），简称时间复杂度2、时间复杂度计算法则1. 只关注循环执⾏次数最多的⼀段代码2. 加法法则：总复杂度等于量级最⼤的那段代码的复杂度如果 T1(n)=O(f(n))，T2(n)=O(g(n))；那么 T(n)=T1(n)+T2(n)=max(O(f(n)), O(g(n))) =O(max(f(n), g(n))).3. 乘法法则：嵌套代码的复杂度等于嵌套内外代码复杂度的乘积T(n) = T1(n) * T2(n) = O(n*n) = O(n2)3、常见的是时间复杂度复杂度量级（递增）排列公式常量阶O(1)对数阶O(logn)线性阶O(n)线性对数阶O(nlogn)平⽅阶、⽴⽅阶...K次⽅阶O(n2),O(n3),O(n^k)指数阶O(2^n)阶乘阶O(n!)①. O(1)：代码的执⾏时间和n没有关系，⼀般情况下，只要算法中不存在循环语句、递归语句，即使有成千上万⾏的代码，其时间复杂度也是Ο(1)；②. O(logn)、O(nlogn)i=1;while (i <= n) {i = i * 2;}通过 2x=n 求解 x 这个问题我们想⾼中应该就学过了，我就不多说了。
习题1答案
一填空1.衡量算法效率的两个重要指标称为算法的______时间复杂度_和___空间复杂度2. 一个算法应具有有穷性，确定性，可行性，输入和输出这五个特性。
3. 线性表的长度是指___表中元素的个数___。
4. 在线性表的顺序存储中，元素之间的逻辑关系是通过元素存储的相对位置决定的；在线性表的链接存储中，元素之间的逻辑关系是通过相关元素的存储位置决定的。
5 在双向链表中，每个结点包含两个指针域，一个指向其直接前趋结点，另一个指向其直接后继结点。
二、判断题1．线性表的逻辑顺序与存储顺序总是一致的。
(FALSE)2．顺序存储的线性表可以按序号随机存取。
(TRUE)3．在线性表的顺序存储结构中，逻辑上相邻的两个元素在物理位置上并不一定紧邻。
（FALSE）4．在线性表的链式存储结构中，逻辑上相邻的元素在物理位置上不一定相邻。
（TRUE）5．在线性表的顺序存储结构中，插入和删除时，移动元素的个数与该元素的位置有关。
（TRUE）6．线性表的链式存储结构是用一组任意的存储单元来存储线性表中数据元素的。
（TRUE）三、单选题(请从下列A，B，C，D选项中选择一项)1．线性表是( ) 。
(A) 一个有限序列，可以为空；(B) 一个有限序列，不能为空；(C) 一个无限序列，可以为空；(D) 一个无序序列，不能为空。
答：A2．对顺序存储的线性表，设其长度为n，在任何位置上插入或删除操作都是等概率的。
插入一个元素时平均要移动表中的（）个元素。
(A) n/2 (B)（n+1）/2 (C) (n –1)/2 (D) n答：A3．线性表采用链式存储时，其地址( ) 。
(A) 必须是连续的；(B) 部分地址必须是连续的；(C) 一定是不连续的；(D) 连续与否均可以。
答：D4．用链表表示线性表的优点是（）。
(A)便于随机存取(B)花费的存储空间较顺序存储少(C)便于插入和删除(D)数据元素的物理顺序与逻辑顺序相同答：C5. 某链表中最常用的操作是在最后一个元素之后插入一个元素和删除最后一个元素，则采用( )存储方式最节省运算时间。
常见排序算法及它们的时间的时间复杂度，空间复杂度
常见排序算法及它们的时间的时间复杂度，空间复杂度⼀、概念扩展------有序度----1、有序元素对：a[i] <= a[j], 如果i < j; 逆序元素对：a[i] > a[j], 如果 i < j。
2、⼀组数据中有/逆序元素对的个数即为有/逆序度3、2,3,1,6这组数据的有序度为4（因为其有有序元素对为4个，分别是(2,3)、(2,6)、(3,6)和(1,6)）逆序度为2（因为其有逆序元素对为2个，分别是(2,3)和(2,1)）4、1,2,3,6这样完全有序的数组叫作满有序度；满有序度的计算公式为 n*(n-1)/2；5、逆序度 = 满有序度 - 有序度-----原地排序算法---空间复杂度是 O(1) 的排序算法，如：冒泡排序，插⼊排序----稳定排序算法---如果待排序的序列中存在值相等的元素，经过排序之后，相等元素之间原有的先后顺序不变⼆、冒泡排序1、冒泡排序只会操作相邻的两个数据。
每次冒泡操作都会对相邻的两个元素进⾏⽐较，看是否满⾜⼤⼩关系要求。
如果不满⾜就让它俩互换。
⼀次冒泡会让⾄少⼀个元素移动到它应该在的位置，重复 n 次，就完成了 n 个数据的排序⼯作2、冒泡的过程只涉及相邻数据的交换操作，只需要常量级的临时空间，所以它的空间复杂度为 O(1)，是⼀个原地排序算法3、当有相邻的两个元素⼤⼩相等的时候，我们不做交换，此时冒泡排序是稳定的排序算法。
4、冒泡排序每交换⼀次，有序度就加 1，直到满有序度；5、冒泡排序最坏情况下，初始状态的有序度是 0，所以要进⾏ n*(n-1)/2 次交换，最好情况下，初始状态的有序度是 n*(n-1)/2，就不需要进⾏交换。
我们可以取个中间值 n*(n-1)/4，换句话说，平均情况下，需要 n*(n-1)/4 次交换操作，所以平均时间复杂度就是 O(n^2)三、插⼊排序1、插⼊排序是将数据分为两个区间，已排序区间和未排序区间。
数据结构基础知识总结
数据结构基础知识总结数据结构是计算机科学中的一门重要课程，它研究如何组织和存储数据，以及如何在数据上进行操作和处理。
数据结构是计算机程序设计的基础，它能够帮助我们更好地理解计算机程序的本质，并提高程序的效率和可靠性。
本文将对数据结构的基础知识进行总结。
一、线性结构线性结构是指所有元素按照线性顺序排列，每个元素最多只有一个前驱和一个后继。
常见的线性结构有数组、链表、栈和队列。
1. 数组数组是一种线性结构，它由相同类型的元素组成，每个元素占用相同大小的内存空间，并按照一定顺序存储在连续的内存单元中。
数组可以通过下标来访问其中的元素，时间复杂度为O(1)。
2. 链表链表也是一种线性结构，它由节点组成，每个节点包含一个数据域和一个指针域。
指针域指向下一个节点或者上一个节点。
链表可以分为单向链表、双向链表和循环链表等多种形式。
3. 栈栈是一种特殊的线性结构，它只允许在栈顶进行插入和删除操作。
栈的特点是先进后出，后进先出。
栈可以用数组或链表来实现。
4. 队列队列也是一种特殊的线性结构，它只允许在队尾进行插入操作，在队头进行删除操作。
队列的特点是先进先出，后进后出。
队列可以用数组或链表来实现。
二、树形结构树形结构是一种非线性结构，它由节点和边组成，每个节点最多有一个父节点和多个子节点。
常见的树形结构有二叉树、堆、AVL树和红黑树等。
1. 二叉树二叉树是一种特殊的树形结构，每个节点最多有两个子节点。
二叉树可以分为满二叉树、完全二叉树、平衡二叉树等多种形式。
2. 堆堆是一种特殊的完全二叉树，它满足父节点的值总是大于或小于子节点的值。
堆可以分为大顶堆和小顶堆两种形式。
3. AVL树AVL树是一种自平衡二叉搜索树，它保证任何一个节点左右子树高度差不超过1，并且左右子树也是一棵AVL树。
4. 红黑树红黑树是一种自平衡二叉搜索树，它满足以下性质：每个节点要么是红色，要么是黑色；根节点是黑色；每个叶子节点都是黑色的空节点；如果一个节点是红色的，则它的两个子节点都是黑色的；任意一条从根到叶子的路径上不能出现连续的两个红色节点。
算法性能分析概念
算法性能分析概念算法性能描述
1.时间复杂度
2.空间复杂度
时间复杂度：
⽤⼀个算法需要的基本操作数量来描述该算法的性能
基本操作数通常被描述为问题规模的函数。
基本操作：
⼀些基础的操作，如运算符操作：i = 5, i*3, 或者排序算法中的交换swap(a,b)，都可看作基本操作。
基本操作的函数:T(n)
n是问题规模，T(n)是基本操作数的函数。
有名的渐近分析：令输⼊规模⽆限⼤，站在极限的⾓度看算法。
思想：当n趋于⽆穷时，⽤另⼀个常⽤函数来描述⽬标函数的⾏为。
(⽤于描述⽬标函数的简单函数，通常是我们常⽤的函数。
)
原则:
1.⼤规模，渐近分析(⼩规模的问题即使算法不怎么样也能很快执⾏)
2.不关⼼常数因⼦和低阶项
3.最坏情况，平均情况，(最好情况则不重要)。
渐近分析点：
1.有名的渐近分析
2.渐进分析标记法
3.常⽤渐近时间复杂度
多项式，对数，指数，阶乘
算法的渐近分析来源于数学渐近分析：
数学的渐进分析常⽤标记5种：
⼤O标记：渐近上界 <= (2个函数数量级关系)
omega标记：渐近下界 <= (2个函数数量级关系)
theta标记：渐近紧确界 = (2个函数数量级关系)
⼩o标记：⾮渐近紧确上界 < (2个函数数量级关系)
w标记：⾮渐近紧确下界 > (2个函数数量级关系)
算法分析中：我们关注的是算法的渐近上界和紧确界，常⽤⼤O标记和theta标记。
算法性能分析概念。
8种算法分析汇总
8种算法分析汇总算法是计算机科学中非常重要的概念，它指的是一系列解决问题的步骤和规则。
算法分析是对算法进行评估和比较的过程，目的是确定算法的效率和优劣。
下面将介绍8种常见的算法分析方法。
1.大O符号大O符号是一种算法复杂度的表示方法，它表示了算法执行时间与问题规模的关系。
常见的大O符号有O(1)、O(log n)、O(n)、O(nlogn)、O(n^2)等等。
通过分析算法中的基本操作的执行次数来确定算法的时间复杂度。
2.最坏情况分析最坏情况分析是根据在最坏情况下的执行时间来评估算法的效率。
在最坏情况下，算法所需的时间是所有可能情况中最长的时间。
3.平均情况分析平均情况分析是对算法在平均情况下的执行时间进行评估。
它需要对所有可能的输入情况进行加权平均。
4.最好情况分析最好情况分析是对算法在最理想情况下的执行时间进行评估。
在最好情况下，算法所需的时间是所有可能情况中最短的时间。
5.空间复杂度分析空间复杂度分析是对算法占用的额外内存空间进行评估。
它通常通过分析算法使用的数据结构和变量的空间要求来表示。
6.渐进分析渐进分析是一种对算法的性能进行评估的方法，它关注算法在问题规模变大时的行为。
通过分析算法在不同规模下的时间复杂度，可以确定算法的效率。
7.稳定性分析稳定性分析是对排序算法进行评估的方法，它关注算法是否能够保持相同值的元素的相对顺序不变。
稳定性分析对于一些问题是非常重要的，比如对于需要按照多个字段进行排序的情况。
8.可读性分析可读性分析是对算法代码的评估，它关注算法代码的易读性和可理解性。
可读性良好的代码可以提高代码的可维护性和调试效率。
总结：算法分析是评估和比较算法效率和优劣的过程。
大O符号、最坏情况分析、平均情况分析、最好情况分析、空间复杂度分析、渐进分析、稳定性分析、可读性分析是8种常用的算法分析方法。
常见排序算法及对应的时间复杂度和空间复杂度
常见排序算法及对应的时间复杂度和空间复杂度转载请注明出处：（浏览效果更好）排序算法经过了很长时间的演变，产⽣了很多种不同的⽅法。
对于初学者来说，对它们进⾏整理便于理解记忆显得很重要。
每种算法都有它特定的使⽤场合，很难通⽤。
因此，我们很有必要对所有常见的排序算法进⾏归纳。
排序⼤的分类可以分为两种：内排序和外排序。
在排序过程中，全部记录存放在内存，则称为内排序，如果排序过程中需要使⽤外存，则称为外排序。
下⾯讲的排序都是属于内排序。
内排序有可以分为以下⼏类： (1)、插⼊排序：直接插⼊排序、⼆分法插⼊排序、希尔排序。
(2)、选择排序：直接选择排序、堆排序。
(3)、交换排序：冒泡排序、快速排序。
(4)、归并排序 (5)、基数排序表格版排序⽅法时间复杂度（平均）时间复杂度（最坏)时间复杂度（最好)空间复杂度稳定性复杂性直接插⼊排序O(n2)O(n2)O(n2)O(n2)O(n)O(n)O(1)O(1)稳定简单希尔排序O(nlog2n)O(nlog2n)O(n2)O(n2)O(n)O(n)O(1)O(1)不稳定较复杂直接选择排序O(n2)O(n2)O(n2)O(n2)O(n2)O(n2)O(1)O(1)不稳定简单堆排序O(nlog2n)O(nlog2n)O(nlog2n)O(nlog2n)O(nlog2n)O(nlog2n)O(1)O(1)不稳定较复杂冒泡排序O(n2)O(n2)O(n2)O(n2)O(n)O(n)O(1)O(1)稳定简单快速排序O(nlog2n)O(nlog2n)O(n2)O(n2)O(nlog2n)O(nlog2n)O(nlog2n)O(nlog2n)不稳定较复杂归并排序O(nlog2n)O(nlog2n)O(nlog2n)O(nlog2n)O(nlog2n)O(nlog2n)O(n)O(n)稳定较复杂基数排序O(d(n+r))O(d(n+r))O(d(n+r))O(d(n+r))O(d(n+r))O(d(n+r))O(n+r)O(n+r)稳定较复杂图⽚版①插⼊排序•思想：每步将⼀个待排序的记录，按其顺序码⼤⼩插⼊到前⾯已经排序的字序列的合适位置，直到全部插⼊排序完为⽌。
算法的四个评价标准
算法的四个评价标准1.正确性：正确性是算法评价的首要宗旨，即算法能够按照预期的方式解决问题。
一个正确的算法应该具备以下几个方面的特点：-算法应该能够解决问题的所有实例；-算法的输出应该与问题要求的解是一致的；-算法应该经过充分的测试和验证，能够处理各种可能的输入情况；-算法不应该引发任何异常或错误。
2.可读性：可读性是指算法应该具备良好的可读性和可理解性，方便他人理解和修改。
一个具有良好可读性的算法应该具备以下特点：-算法应该采用清晰易懂的变量和函数命名，使代码容易理解；-算法应该采用模块化的设计结构，使代码逻辑清晰明了；-算法应该遵循正确的编码规范，使代码风格一致统一；-算法应该提供详尽的注释和文档，方便他人理解和使用。
3.效率：效率是指算法在解决问题过程中所消耗的时间和空间资源。
在评价算法时，常常需要考虑以下几个方面：-时间复杂度：算法执行所需的时间与问题规模的增长率之间的关系。
常用的时间复杂度包括线性时间、对数时间和指数时间等。
-空间复杂度：算法执行所需的存储空间与问题规模的增长率之间的关系。
常用的空间复杂度包括线性空间、常量空间和指数空间等。
-算法的优化能力：在保证正确性的前提下，通过改进算法结构和优化代码逻辑，提高算法的执行效率。
4.可扩展性：可扩展性是指算法在解决问题的基础上能够容易地进行功能扩展和性能优化的能力。
-算法的模块化设计能够容易地添加、删除和替换模块；-算法的接口设计能够方便地进行功能扩展；-算法的性能分析能够提供有效的基准数据，方便优化和改进；-算法的设计能够兼顾可扩展性和维护性，使得后期的修改和维护工作更加容易。
综上所述，算法的四个评价标准分别是正确性、可读性、效率和可扩展性。
正确性是算法的首要宗旨，而可读性、效率和可扩展性都对一个优秀的算法来说同样重要。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
2、类似于时间复杂度的讨论，一个算法的空间复杂度(Space Complexity)S(n)定义为该算法所耗费的存储空间，它也是问题规模n的函数。渐近空间复杂度也常常简称为空间复杂度。
在各种不同算法中，若算法中语句执行次数为一个常数，则时间复杂度为O(1),另外，在时间频度不相同时，时间复杂度有可能相同，如T(n)=n2+3n+4与T(n)=4n2+2n+1它们的频度不同，但时间复杂度相同，都为O(n2)。 按数量级递增排列，常见的时间复杂度有：常数阶O(1),对数阶O(log2n),线性阶O(n), 线性对数阶O(nlog2n),平方阶O(n2)，立方阶O(n3),...， k次方阶O(nk),指数阶O(2n)。随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。 2、空间复杂度 与时间复杂度类似，空间复杂度是指算法在计算机内执行时所需存储空间的度量。记作: S(n)=O(f(n)) 我们一般所讨论的是除正常占用内存开销外的辅助存储单元规模。讨论方法与时间复杂度类似，不再赘述。
常用的算法的时间复杂度和空间复杂度
1、时间复杂度
（1）时间频度 一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。一个算法在计算机存储器上所占用的存储空间，包括存储算法本身所占用的存储空间，算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。算法的输入输出数据所占用的存储空间是由要解决的问题决定的，是通过参数表由调用函数传递而来的，它不随本算法的不同而改变。存储算法本身所占用的存储空间与算法书写的长短成正比，要压缩这方面的存储空间，就必须编写出较短的算法。算法在运行过程中临时占用的存储空间随算法的不同而异，有的算法只需要占用少量的临时工作单元，而且不随问题规模的大小而改变，我们称这种算法是“就地\"进行的，是节省存储的算法，如这一节介绍过的几个算法都是如此；有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元，例如将在第九章介绍的快速排序和归并排序算法就属于这种情况。
（2）时间复杂度 在刚才提到的时间频度中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。但有时我们想知道它变化时呈现什么规律。为此，我们引入时间复杂度概念。 一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=Ｏ(f(n)),称Ｏ(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。
如当一个算法的空间复杂度为一个常量，即不随被处理数据量n的大小而改变时，可表示为O(1)；当一个算法的空间复杂度与以2为底的n的对数成正比时，可表示为0(10g2n)；当一个算法的空I司复杂度与n成线性比例关系时，可表示为0(n).若形参为数组，则只需要为它分配一个存储由实参传送来的一个地址指针的空间，即一个机器字长空间；若形参为引用方式，则也只需要为其分配存储一个地址的空间，用它来存ቤተ መጻሕፍቲ ባይዱ对应实参变量的地址，以便由系统自动引用实参变量。