数据结构---1绪论

最新推荐文章于 2022-01-23 11:58:30 发布

Asteroid 325

最新推荐文章于 2022-01-23 11:58:30 发布

阅读量300

点赞数

本文链接：https://blog.csdn.net/weixin_43846020/article/details/103700785

版权

数据结构专栏收录该内容

11 篇文章 0 订阅

订阅专栏

1.1

1.数据：所有输入到计算机中被计算机程序处理的符号总称
2.数据元素：数据的基本单位
3.数据对象：性质相同的数据元素的集合
4.数据结构：是相互之间存在一种或多种特定关系的数据元素的集合.数据+之间关系【为结构】
5.存储结构【物理结构】：数据结构在计算机中的表示
6数据类型：一个值的集合和定义在这个值集上的一组操作的总称
7.抽象数据类型：一个数学模型以及定义在该模型上的一组操作
【仅取决于他的一组逻辑特性，不论他的内部结构怎么变化】

1、简述下列概念：数据、数据元素、数据结构、逻辑结构、存储结构、线性结构、非线性结构。
逻辑结构：数据之间的逻辑关系
在这里插入图片描述
2、常用的存储表示方法有哪几种?各有什么优缺点？
1.顺序存储结构
特点：逻辑上相邻，在存储一定相邻
优点：可以随机访问a[i]
缺点：插入和删除需要移动大量元素
2.链式存储结构
特点：逻辑上相邻，但存储不一定相邻
优点：插入，删除不需要移动大量元素，只需要改变相邻结点的指针
缺点：不能随机访问

知识点:
. 数据结构包括数据的 逻辑结构 、数据的 存储结构 和数据的运算这三个方面的内容。

数据结构按逻辑结构可分为两大类，它们分别是 线性结构 和 非线性结构 。

线性结构中元素之间存在一对一关系，树形结构中元素之间存在一对多关系，图形结构中元素之间存在多对多关系。

．在线性结构中，第一个结点没有 前驱结点，其余每个结点有且只有 1个前驱结点；最后一个结点没有 后续结点，其余每个结点有且只有1个后续结点。
. 在树形结构中，树根结点没有前驱结点，其余每个结点有且只有 1 个前驱结点；叶子结点没有后续结点，其余每个结点的后续结点数可以任意多个
. 在图形结构中，每个结点的前驱结点数和后续结点数可以任意多个。
. 数据的运算最常用的有5种，它们分别是插入、删除、修改、查找、排序。
. 一个算法的效率可分为时间效率和空间效率。

**时间复杂度:**用来定性的描述算法的执行时间的一个函数,更类似于一个耗时的趋势,函数表示为: O(f(n))
名词解释:
n:问题的规模,重复执行的次数
T(n):一段程序运行,各种操作代码所执行的总次数
一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。
一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
f(n): 存在的某个函数,使得T(n)/f(n)=非零常数, 那么f(n)称为T(n)的同数量级函数
O:大O符号,一种符号,表示渐进于无穷的行为

穿起来:
算法中各种代码操作所执行的总次数用T(n)表示,存在某个函数f(n),使得T(n)/f(n)=非零常数,那么f(n)称为T(n)的同数量级函数(类想一下,在坐标轴中,当入参n趋于无穷时,两条曲线的商为常数),即:T(n)=O(f(n)),O(f(n))就是时间复杂度.O符号表示一个渐进常数. 在这个函数中可以忽略低阶项和首项系数,
称Ｏ(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。

   注意，时间频度与时间复杂度是不同的，
   时间频度不同但时间复杂度可能相同。
如：T(n)=n^2+3n+4与T(n)=4n^2+2n+1它们的频度不同，但时间复杂度相同，都为O(n^2)

常见的时间复杂度有：

常数阶O(1)<对数阶O(log2n)<线性阶O(n),<线性对数阶O(nlog2n)

<平方阶O(n^2)<方阶O(n3)<k次方阶O(n^k)

<指数阶O(2^n)<O(n!)<O(n^n)

在这里插入图片描述
二、求时间复杂度

1、根据定义，可以归纳出基本的计算步骤
（1.）计算出基本操作的执行次数T(n)
基本操作即算法中的每条语句的执行次数一般默认为考虑最坏的情况。

（2）计算出T(n)的数量级
求T(n)的数量级，只要将T(n)进行如下一些操作：
忽略常量、低次幂和最高次幂的系数
令f(n)=T(n)的数量级。
（3）用大O来表示时间复杂度

例:
  for（i=1;i<=n;++i）
  {
     for(j=1;j<=n;++j)
     {
    c[ i ][ j ]=0; //该步骤属于基本操作 执行次数：n^2

          for(k=1;k<=n;++k)
  c[ i ][ j ]+=a[ i ][ k ]*b[ k ][ j ]; 
 //该步骤属于基本操作 执行次数：n^3

     }

  }

  则有 T（n）= n^2+n^3，根据上面括号里的同数量级，
  我们可以确定 n^3为T（n）的同数量级

  则有f（n）= n^3，然后根据T（n）/f（n）求极限可得到常数c

  则该算法的 时间复杂度：T（n）=O（n^3)
  2、于是我们发现根本没必要都算，所以我们有了精简后的步骤：

1. 找到执行次数最多的语句 
2. 计算语句执行次数的数量级
3. 用大O来表示结果 

eg:

(1)   for(i=1;i<=n;i++)     //循环了n*n次，当然是O(n^2)

            for(j=1;j<=n;j++)

                 s++;

（2）for(i=1;i<=n;i++)   //循环了(n+n-1+...+1)≈(n^2)/2 ,同上                                              

           for(j=i;j<=n;j++)

                 s++;

(4)   i=1;k=0;

      while(i<=n-1){

           k+=10*i;

      i++;      }

//循环了

//n-1≈n次，所以是O(n)

(5)   for(i=1;i<=n;i++)

             for(j=1;j<=i;j++)

                 for(k=1;k<=j;k++)

                       x=x+1;

//循环了(1^2+2^2+3^2+...+n^2)=n(n+1)(2n+1)/6≈(n^3)/3，

//即O（n^3)

（6)

x=91; y=100;

while(y>0) if(x>100) {x=x-10;y--;} else x++;

 //T(n)=O(1)，与n无关

（7）i=n-1;            

while(i>=0&&(A[i]!=k))       

      i--;        

return i;   

//此算法中的语句(3)的频度不仅与问题规模n有关，
//还与输入实例中A的各元素取值及K的取值有关:
//①若A中没有与K相等的元素，则语句(3)的频度f(n)=n；
 //②若A的最后一个元素等于K,则语句(3)的频度f(n)是常数0。

综上：

1、取决于执行次数最多的语句，
如当有若干个循环语句时
，算法的时间复杂度是由嵌套层数最多的循环语句中
最内层语句的频度f(n)决定的。
2、如果算法的执行时间不随着问题规模n的增加而增长
，即使算法中有上千条语句
，其执行时间也不过是一个较大的常数。
此类算法的时间复杂度是O(1)
3、算法的时间复杂度不仅仅依赖于问题的规模
，还与输入实例的初始状态有关。

3、求解下列算法的时间复杂度

A）for(I=0;I<n;I++)                                                    
          for(j=0;j<m;j++)                                             
            A[I][j]=0;    
            o(m*n)                                              
B) I=0; s=0;                                                           
     while(s<n)                                                        
         {I++; s+=I;}
         o(n)                                                  
C) for(I=0;I<n;I++)                                                    
       for(j=0;j<n;j++)                                               
          s+=B[I][j];                                                  
   sum=s;    
   o(n^2)                                                          
D) I=1;                                                                
      while(I<=n)                                                      
         I=I*3;
         o(log3n)//3为底数,应该写在下标左右的位置
         因为：3^k<n(k为次数)
            k=log3的n