线性表，顺序结构和链式结构的基本操作时间复杂度

最新推荐文章于 2023-08-10 20:26:25 发布

杨三金

最新推荐文章于 2023-08-10 20:26:25 发布

阅读量5.8k

点赞数 2

分类专栏：数据结构

本文链接：https://blog.csdn.net/weixin_43731369/article/details/88628198

版权

数据结构专栏收录该内容

9 篇文章 0 订阅

订阅专栏

浏览各种资料，对_时间复杂度_做个总结：

一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得T(n)/f(n)的极限值（当n趋近于无穷大时）为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n))，称O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。

分析：随着模块n的增大，算法执行的时间的增长率和 f(n) 的增长率成正比，所以 f(n) 越小，算法的时间复杂度越低，算法的效率越高。

在计算时间复杂度的时候，先找出算法的基本操作，然后根据相应的各语句确定它的执行次数，再找出 T(n) 的同数量级（它的同数量级有以下：1，log2n，n，n log2n ，n的平方，n的三次方，2的n次方，n!），找出后，f(n) = 该数量级，若 T(n)/f(n) 求极限可得到一常数c，则时间复杂度T(n) = O(f(n))

例：算法：


  for(i=1; i<=n; ++i)
  {
      for(j=1; j<=n; ++j)
      {
          c[i][j] = 0;//该步骤属于基本操作执行次数：n的平方次
          for(k=1; k<=n; ++k)
              c[i][j] += a[i][k] * b[k][j];//该步骤属于基本操作执行次数：n的三次方次
      }
  }

则有在这里插入图片描述，根据上面括号里的同数量级，我们可以确定 n的三次方为T（n）的同数量级

则有在这里插入图片描述，然后根据 T(n)/f(n) 求极限可得到常数c

则该算法的时间复杂度：T(n) = O(n^3) 注：n^3即是n的3次方。

3.容易计算的方法是：看看有几重for循环，只有一重则时间复杂度为O(n)，二重则为O(n^2)，依此类推，如果有二分则为O(logn)，二分例如快速幂、二分查找，如果一个for循环套一个二分，那么时间复杂度则为O(nlogn)。

分类

按数量级递增排列，常见的时间复杂度有：

常数阶O(1),
对数阶O(nlogn),
线性阶O(n),
线性对数阶O(nlog2n),
平方阶O(n^2)，
立方阶O(n^3),…，
k次方阶O(n^k),
指数阶O(2^n)。
随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。

关于对其的理解

整个算法的执行时间与基本操作重复执行的次数成正比
基本操作重复执行的次数是问题规模n的某个函数f(n)，于是算法的时间量度可以记为：T(n) = O(f(n))
如果按照这么推断，T(n)应该表示的是算法的时间量度，也就是算法执行的时间。
对“语句频度”也有定义：指的是该语句重复执行的次数。
如果是基本操作所在语句重复执行的次数，那么就该是f(n)。
上边的n都表示的问题规模。
上面的说明有些杂乱，但看不懂没关系，只需要记住下面的步骤，在瞅瞅我后面给的例子可以说，求解方法相当明了

具体的求解步骤

1.找到基本操作，计算执行次数
2.用常数1代替所有的加法常数
3.在修改后的运行次数函数中，只保留最高阶项
4.如果最高阶项的系数存在且不是1，则去除
最后得到的复杂度不外乎如下
对数阶O(nlogn),
线性阶O(n),
线性对数阶O(nlog2n),
平方阶O(n^2)，
立方阶O(n^3),…，
k次方阶O(n^k),
指数阶O(2^n)。

线性表，顺序结构的基本操作及其时间复杂度

#include<stdio.h>
#include <stdlib.h>  //malloc
//函数结果状态代码
#define OK 1
#define ERROR 0
#define OVERFLOW -2
//Status是函数的类型，其值是函数结果状态代码
typedef int Status;
typedef char ElemType;
//---------线性表的动态分配谁许存储结构--------
#define LIST_INIT_SIZE 100    //线性表存储空间的初始分配量
#define LISTINCREMENT 10     // 线性表存储空间的分配增量
typedef struct
{
    ElemType *elem;     //存储空间基址
    int length;     // 当前长度
    int listsize;   //当前分配的存储容量 （以sizeof(ElemType)为单位
} SqList;
ElemType *p;//常用指针变量
ElemType *q;
// 初始化操作
Status InitList_Sq(SqList &L)
{
    //构造一个空的线性表L
    L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    if(!L.elem) exit(OVERFLOW);
    L.length = 0;
    L.listsize = LIST_INIT_SIZE;
    return OK;
}
/*分析：所有操作的执行次数都是一，所以就无所谓基本操作了，时间复杂度就是O(1)*/
//加工型操作 在第i个位置前插入e
Status ListInsert_Sq(SqList &L,int i,ElemType e)
{
    if((i<1 || i>L.length+1)) return ERROR; //i不合法
    if(L.length>=L.listsize)
    {
        ElemType *newbase = (ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(char));
        if(!newbase) exit(OVERFLOW);
        L.elem = newbase;
        L.listsize += LISTINCREMENT;
    }
    q = &(L.elem[i-1]);
    for(p =&(L.elem[L.length-1]); p>=q; --p) *(p+1)=*p;
    *q = e;
    ++L.length;
    return OK;
}
/*基本操作 *(p+1) = *p 需要执行n-i+1次  所以算法的复杂度为O(n)*/
//加工型操作 删除第i个位置的元素 并用e返回其值
Status ListDelete_Sq(SqList &L,int i,ElemType &e)
{
    if((i<1) || (i>L.length)) return ERROR;
    p = &(L.elem[i-1]);
    e = *p;
    q = L.elem+L.length-1;
    for(++p; p<=q; ++p) *(p-1) = *p;
    --L.length;
    return OK;
}
/*基本操作 *(p+1) = *p 需要执行n-i次  所以算法的复杂度为O(n)*/
//引用型操作 查找第一个值与e满足compare()的元素的序位
int LocateElem_Sq(SqList L, ElemType e, Status(*compare)(ElemType,ElemType))
{
    int i=1;
    p=L.elem;
    while(i<=L.length && !(*compare)(*p++,e)) ++i;
    if(i<=L.length) return i;
    else return 0;
}
/*基本操作 ++i 时间复杂度为 O(n)  */
//引用型操作 求表长
int ListLength_Sq(SqList L)
{
    return L.length;
}
//时间复杂度 O(1)
//引用型操作 判断线性表是否为空
bool ListEmpty(SqList L){
    return (bool)L.length;
}
//时间复杂度O(1)
//引用型操作 获得第i个元素（从一开始计数）
Status GetElem(SqList L,int i,ElemType &e){
    if((i<1) || (i>L.length)) return ERROR;
    e = L.elem[i-1];
    return OK;
}
// 时间复杂度O(1)
//引用型操作 获取cur_e的前驱
Status PriorElem(SqList L,ElemType cur_e,ElemType &pre_e){
    if(L.elem[0]==cur_e) return ERROR;
    int i = 1;
    while(i<=L.length&&L.elem[i]!=cur_e) i++;
    if(i<=L.length){
        pre_e = L.elem[i-1];
        return OK;
    }
    return ERROR;
}
//时间复杂度O(n) while循环 基本操作 i++；
//引用型操作 获得cur_e的后继
Status NextElem(SqList L,ElemType cur_e,ElemType &next_e){
    int i = 0;
    while(i<=L.length-1&&L.elem[i]!=cur_e) i++;
    if(i<=L.length-1){
        next_e = L.elem[i+1];
        return OK;
    }
    return ERROR;
}
//时间复杂度O(n) while循环 基本操作 i++；
//对表中每一个元素调用函数visit()
Status ListTraverse(SqList L,Status (*visit)(ElemType)){
    int i=1;
    p=L.elem;
    while(i<=L.length && !(*visit)(*p++)) ++i;
    if(i<=L.length) return OK;
    else return ERROR;
}
//时间复杂度O(n) while循环 基本操作 ++i；
int main()
{
    return 0;
}

线性表，链式结构的基本操作及其时间复杂度

#include<stdio.h>
#include <stdlib.h>  //malloc
//函数结果状态代码
#define OK 1
#define ERROR 0
#define OVERFLOW -2
//Status是函数的类型，其值是函数结果状态代码
typedef int Status;
typedef char ElemType;
//---------线性表的单链表存储结构--------
typedef struct LNode
{
    ElemType data;     //存储空间基址
    struct LNode *next;
} LNode, *LinkList;
LinkList p,q,s;
// 初始化操作
void CreateList_L(LinkList &L,int n)
{
    //逆位输入n个元素，建立带表头结点的单链线性表L
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    for(int i = n; i > 0; --i)
    {
        p = (LinkList)malloc(sizeof(LNode));
        scanf(&p->data);
        p->next = L->next;
        L->next = p;
    }
}
//时间复杂度O(n)
bool ListEmpty_L(LinkList L)
{
    return (bool)(L->next);
}
//时间复杂度O(1)
int ListLength_L(LinkList L)
{
    p=L;
    int i=0;
    while(p->next)
    {
        p=p->next;
        ++i;
    }
    return i;
}
//时间复杂度O(n)
Status PriorElem_L(LinkList L,ElemType cur_e,ElemType &pre_e)
{
    if(L->next->data==cur_e) return ERROR;
    p=L->next;
    while(p->next)
    {
        if(p->next->data==cur_e)
        {
            pre_e = p->data;
            return OK;
        }
        p=p->next;
    }
    return ERROR;
}
//时间复杂度O(n)
Status NextElem_L(LinkList L,ElemType cur_e,ElemType &next_e)
{
    p=L;
    while(p->next)
    {
        if(p->data==cur_e)
        {
            next_e = p->next->data;
            return OK;
        }
        p=p->next;
    }
    return ERROR;
}
//时间复杂度O(n)
Status GetElem_L(LinkList L,int i,ElemType &e)
{
    p = L->next;
    int j =1;
    while(p&&j<i)
    {
        p = p->next;
        ++j;
    }
    if(!p || j>i) return ERROR;
    e=p->data;
    return OK;
}
//时间复杂度O(n)
Status ListInsert_L(LinkList &L,int i,ElemType e)
{
    p = L;
    int j=0;
    while(p&&j<i-1)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i-1)return ERROR;
    s=(LinkList)malloc(sizeof(LNode));
    s->data =e ;
    s->next = p->next;
    p->next = s;
    return OK;
}
//时间复杂度O(n)
Status ListDElete_L(LinkList &L, int i, ElemType &e)
{
    p=L;
    int j=0;
    while(p->next && j<i-1)
    {
        p=p->next;
        ++j;
    }
    if(!(p->next)||j>i-1) return ERROR;
    q = p->next;
    p->next = q->next;
    e = q->data;
    free(q);
    return OK;
}
int main()
{
    return 0;
}

附
在这里插入图片描述

杨三金

关注

2
点赞
踩
35

收藏

觉得还不错? 一键收藏
4
评论
线性表，顺序结构和链式结构的基本操作时间复杂度

浏览各种资料，对_时间复杂度_做个总结：一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得T(n)/f(n)的极限值（当n趋近于无穷大时）为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n))，称O(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。分析：随着模块n的增大，算法执行的时间的增长率和 f(...
复制链接

扫一扫