数据结构 | 线性表

已于 2023-04-02 18:00:16 修改
阅读量250 收藏
点赞数
分类专栏： 计算机学科专业基础综合408 | 数据结构 文章标签： 数据结构 c++ c语言 链表
于 2022-07-10 00:16:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44043952/article/details/125685791
版权

文章目录

线性表的定义和基本操作

在这里插入图片描述

定义

在这里插入图片描述

基本操作

//线性表的基本操作

//初始化
InitList(&L)

//销毁操作
DestroyList(&L)

//插入操作
ListInsert(&L,i,e)

//删除操作
ListDelete(&L,i,&e)

//按值查找操作
LocateElem(L,e)

//按位查找操作
GetElem(L,i)

//求表长
Length(L)

//输出操作
PrintList(L)

//判空操作
IsEmptyList(L)

在这里插入图片描述

  • 什么时候要传入参数的印用 “&” ——对参数的修改结果需要 “带回来” 的时候
  • 这里的印用 “&”是C++才支持的写法
//对参数的修改“没带回来”的情况

#include<stdio.h>
void test(int x){
	x = 1024;
	printf("test函数内部 x=%d\n",x);
}
int main(){
	int x = 1;
	printf("调用test函数前 x=%d\n",x);
	test(x);
	printf("调用test函数后 x=%d\n",x);
}

//输出结果：
//调用test函数前 x=1
//test函数内部 x=1024
//调用test函数后 x=1

在这里插入图片描述

  • 这里由于函数调用栈的存在，在test函数内部对x的修改可以看作main函数中的x的一个复制品，它的值的改变并不会影响到main函数里面的x的值
//对参数的修改“带回来了”的情况

#include<stdio.h>
void test(int &x){ //一个小小的印用&，结果却各不相同
	x = 1024;
	printf("test函数内部 x=%d\n",x);
}
int main(){
	int x = 1;
	printf("调用test函数前 x=%d\n",x);
	test(x);
	printf("调用test函数后 x=%d\n",x);
}

//输出结果：
//调用test函数前 x=1
//test函数内部 x=1024
//调用test函数后 x=1024

在这里插入图片描述

  • 这里由于test函数的形参x前加入了引用符号&，即使有函数调用栈的存在，但由于是引用，在test函数内部对x的修改确实是修改了x的真实的值，main函数中的x的值也相应地被修改了

在这里插入图片描述

  • 画黄色的部分就是要将对形参的修改结果带回来的情况，所以都加上了引用符号&

在这里插入图片描述
在这里插入图片描述

顺序表的定义

  • 用【顺序存储】的方式实现的线性表
    在这里插入图片描述

顺序表的定义

在这里插入图片描述

顺序表的实现—静态分配

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 既然存在脏数据那么 length = 0 这一步就不应该被省略
    在这里插入图片描述

顺序表的实现—动态分配

  • malloc函数所实现的原理是会申请一整片连续的存储空间，这个函数执行之后会返回指向这片连续的内存空间的开始地址的指针，可以实现动态申请内存空间
  • malloc函数使用的时候记得把返回的指针强制转化为你所定义的数据元素类型指针
  • free函数可以实现动态释放内存空间
    在这里插入图片描述
    在这里插入图片描述

顺序表的特点

在这里插入图片描述
在这里插入图片描述

顺序表的插入和删除

在这里插入图片描述

顺序表的基本操作—插入

在这里插入图片描述
在这里插入图片描述

  • 注意保证代码的健壮性，这里还需要对传入的参数进行判断，比如插入的位置必须在1~length+1之间；又或者顺序表存满了的话应该不允许插入行为的发生
    在这里插入图片描述

插入操作的时间复杂度

在这里插入图片描述

顺序表的基本操作—删除

在这里插入图片描述
在这里插入图片描述

删除操作的时间复杂度

在这里插入图片描述
在这里插入图片描述

顺序表的查找

在这里插入图片描述

顺序表的按位查找

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 用某一类型的指针加上数组下标的这种方式来访问数据的话，那么系统在背后为你取数据的时候，每一次取几个字节其实和你这个指针所指向的类型有关
  • 这就解释了为什么我们用malloc函数申请一片连续的内存空间之后要把函数返回的地址强制转化为和你的数据类型相对应的同类型的指针
  • 因为虽然指针指向的都是同一个地址，但是如果指针所指的数据类型你给它定义错了，那么在访问里面的数据元素的时候也会出现问题
    在这里插入图片描述

按位查找的时间复杂度

在这里插入图片描述

顺序表的按值查找

在这里插入图片描述
在这里插入图片描述

结构类型的比较

在这里插入图片描述
在这里插入图片描述

按值查找的时间复杂度

在这里插入图片描述
在这里插入图片描述

顺序表的基本操作代码实现

#include<stdio.h>
#include<stdlib.h>

//顺序表的定义（静态分配）
#define MaxSize 10 //最大长度
typedef struct{
  int data[MaxSize]; //用静态数组存放数据元素
  int length; //当前长度
}SqList;

//顺序表的定义（动态分配）
typedef struct{
  int *data; //动态分配数组的指针
  int length; //当前长度
  int Maxsize; //最大容量
}SeqList;

//静态顺序表初始化
#define InitSize 10 //最大长度
void InitList(SqList &L){
  for(int i = 0; i<L.length;i++){
    L.data[i] = 0;
  }
  L.length = 0;
}

//静态顺序表的插入操作
bool InsertList(SqList &L,int i,int e){
  if(i<1 || i>L.length+1){
    return false;
  }
  if(L.length>=MaxSize){
    return false;
  }
  for(int j = L.length;j>=i;j--){ //将第i个元素及其以后的所有元素后移
    L.data[j] = L.data[j-1]; 
  }
  L.data[i-1] = e; //在位置i处存入e
  L.length++; //顺序表长度+1
  return true;
}

//静态顺序表的删除操作
bool ListDelete(SqList &L,int i,int &e){
  if(i<1 || i>L.length+1){
    return false;
  }
  e = L.data[i-1];
  for(int j = i;j<L.length;j++){
    L.data[j-1] = L.data[j];
  }
  L.length--;
  return true;
}

//静态顺序表的按位查找
int GetElem(SqList L,int i){
  return L.data[i-1];
}

//静态顺序表的按值查找
int LocateElem(SeqList L,int e){
  for(int i = 0;i<L.length;i++){
    if(e == L.data[i]){
      return i+1;
    }
  }
  return 0;
}

//动态顺序表初始化
void InitList(SeqList &L){
  //用malloc函数申请一片连续的存储空间
  L.data = (int*)malloc(InitSize * sizeof(int));
  L.length = 0;
  L.MaxSize = InitSize;
}

//增加动态数组的长度
void IncreaseSize(SeqList &L,int len){
  int *p = L.data;
  L.data = (int *)malloc((L.MaxSize+len)*sizeof(int));
  for(int i = 0;i<p.length;i++){
    L.data[i] = p.data[i]
  }
  L.MaxSize += len; //顺序表最大长度增加len
  free(p); //释放原来的内存空间
}

int main(){
  SqList L; //声明一个顺序表
  InitList(L); //初始化

  if(InsertList(L,3,3)){
    printf("插入成功")
  }else{
    printf("插入失败")
  }
  int deleteElem = -1;
  if(ListDelete(L,3,deleteElem)){
    printf("已成功删除元素:%d\n",deleteElem);
  }else{
    printf("位序不合法，删除失败\n");
  }
  return 0;
}

单链表的定义

在这里插入图片描述
在这里插入图片描述

什么是单链表

在这里插入图片描述

用代码定义一个单链表

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

不带头结点的单链表

在这里插入图片描述

带头结点的单链表

在这里插入图片描述

不带头结点v.s.带头结点

在这里插入图片描述
在这里插入图片描述

单链表的插入删除

在这里插入图片描述

关于简化图示的说明

在这里插入图片描述

按位序插入（带头结点）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

按位序插入（不带头结点）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

指定结点的后插操作

在这里插入图片描述
在这里插入图片描述

指定结点的前插操作

给定头指针

在这里插入图片描述

不给头指针

在这里插入图片描述
在这里插入图片描述

按位序删除（带头结点）

在这里插入图片描述
在这里插入图片描述

指定结点的删除

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

封装的好处

在这里插入图片描述

单链表的查找

在这里插入图片描述

按位查找

  • 之前已经实现了按位查找的代码了，只不过只是找到了n-1位，这里只需要改为n位即可
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

封装（基本操作）的好处

在这里插入图片描述

按值查找

在这里插入图片描述
在这里插入图片描述

求表的长度

在这里插入图片描述
在这里插入图片描述

单链表的建立

在这里插入图片描述

尾插法建立单链表

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

头插法建立单链表

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

双链表

在这里插入图片描述

单链表 v.s. 双链表

在这里插入图片描述

双链表的初始化（带头结点）

在这里插入图片描述

双链表的插入

在这里插入图片描述
在这里插入图片描述

双链表的删除

在这里插入图片描述

双链表的遍历

在这里插入图片描述
在这里插入图片描述

循环链表

在这里插入图片描述

循环单链表

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 如果在你的应用场景当中经常需要对表头或者表尾进行操作的时候，当你使用循环单链表的时候可以把头指针指向表尾元素，这样可以大大简化我们的程序

循环双链表

在这里插入图片描述

循环双链表的初始化

在这里插入图片描述

双链表的插入

在这里插入图片描述

双链表的删除

在这里插入图片描述
在这里插入图片描述

静态链表

在这里插入图片描述

什么是静态链表

在这里插入图片描述

  • 指针指明的是具体的内存地址，而游标只是指明了下个元素的数组下标

用代码定义一个静态链表

在这里插入图片描述
在这里插入图片描述

  • 对于上面那种定义方式的理解：其实SLinkList是一个大小为MaxSize的Node型数组，每个数组元素是Node型的结构体
  • 如果用Node来定义一个Node的数组，很难让人联想到这是一个静态链表，但是用SLinkList这种方式就很一目了然，类比LNode和LinkList

对猜想的验证

在这里插入图片描述

简述基本操作的实现

初始化

在这里插入图片描述

查找&插入&删除

在这里插入图片描述

  • 设置为 -2 可以方便消除内存中脏数据的影响，便于我们判断哪里还有静态链表的剩余空间
    在这里插入图片描述

链表的基本操作代码实现

#include<stdio.h>

//定义一个结点
struct LNode{
  int data;
  struct LNode *next;
};

typedef struct LNode{
  int data;
  struct LNode *next;
}LNode *LinkList;

//增加一个新的结点
struct LNode *p = (struct LNode *)malloc(sizeof(struct LNode));

//为了使用的方便，做个数据类型重命名
typedef struct LNode LNode;

//增加一个新的结点
LNode *p = (LNode *)malloc(sizeof(LNode));

//删除一个结点
free(p);

//初始化一个单链表（不带头结点）
bool InitList(LinkList &L){
  L = NULL;
  return true;
}
//初始化一个单链表（带头结点）
bool InitList(LinkList &L){
  if(L == NULL){
    return false;
  }
  L -> next = NULL;
  return true;
}

//判断单链表是否为空
bool IsEmpty(LinkList L){
  if(L -> next == NULL){
    return true;
  }else{
    return false;
  }
}

//指定节点的后插操作
bool InsertNextNode(LNode *p,int e){
  if(p == NULL){
    return false;
  }
  LNode *s = (LNode *)malloc(sizeof(LNode));
  if(s == NULL){
    return false;
  }
  s->data = e;
  s->next = p->next;
  p->next = s;
  return true;
}

//指定结点的前插操作
bool InsertPriorNode(LNode *p,int e){
  if(p == NULL){
    return false;
  }
  LNode *s = (LNode *)malloc(sizeof(LNode));
  if(s == NULL){
    return false;
  }
  //这里前插操作的实现思路是p后插s然后交换p和s的数据，时间复杂度O(1)
  s->next = p->next;
  p->next = s;
  s->data = p->data;
  p->data = e;
  return true;
}

//按位序删除（带头结点）
bool ListDelete(LinkList &L,int i,int &e){
  if(i<1){
    return false;
  }
  LNode *p;
  int j = 0;
  p = L;
  while(p!=NULL && j<j-1){
    p = p->next;
    j++;
  }
  if(p == NULL){
    return false;
  }
  if(p->next = NULL){
    return false;
  }
  LNode *q = p->next;
  e =  q->data;
  p->next = q->next;
  free(q);
  return true;
}

//指定节点的删除
bool DeleteNode(LNode *p){
  if(p == NULL){
    return false;
  }
  LNode *q = p->next;
  p->data = q->data;
  p->next = q->next;
  free(q);
  return true;
}

//单链表的按位查找
LNode* GetElem(LinkList L,int i){
  int j=1;
  LNode *p=L->next;
  if(i==0){
    return L;
  }
  if(i<1){
    return NULL;
  }
  while(p!=NULL && j<i){
    p = p -> next;
    j++;
  }
  return p;
}

//单链表的按值查找
LNode * LocateElem(LinkList L,int e){
  LNode *p = L->next;
  while(p!=NULL && p->data != e){
    p = p->next;
  }
  return p;
}

//单链表的按位序插入(带头结点)
bool ListInsert(LinkList &L,int i,int e){
  if(i<1){
    return false;
  }
  LNode *p;
  int j = 0;
  p = L;
  while(p!=NULL && j<i-1){
    p = p->next;
    j++;
  }
  // if(p == NULL){
  //   return false;
  // }
  // LNode *s = (LNode *)malloc(sizeof(LNode));
  // s->data = e;
  // s->next = p->next;
  // p->next = s;
  // return true;
  return InsertNextNode(p,e);
}

//单链表的按位序插入(不带头结点)
bool ListInsert(LinkList &L,int i,int e){
  if(i<1){
    return false;
  }
  if(i == 1){
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next = L;
    L = s;
    return true;
  }
  LNode *p;
  int j = 1;
  p = L;
  while(p!=NULL && j<i-1){
    p = p->next;
    j++;
  }
  // if(p == NULL){
  //   return false;
  // }
  // LNode *s = (LNode *)malloc(sizeof(LNode));
  // s->data = e;
  // s->next = p->next;
  // p->next = s;
  // return true;
  return InsertNextNode(p,e);
}

//求单链表的长度
int Length(LinkList L){
  int len = 0;
  LNode *p = L;
  while(p->next != NULL){
    p = p->next;
    len++;
  }
  return len;
}

//尾插法建立单链表
LinkList ListTailInsert(LinkList &L){
  int x;
  L = (LinkList)malloc(sizeof(LNode));
  LNode *s,*r = L;
  scanf("%d",&x);
  while(x != 9999){
    s = (LNode *)malloc(sizeof(LNode));
    s->data = x;
    r->next = s;
    r = s;
    scanf("%d",&x);
  }
  r->next = NULL;
  return L;
}

//头插法建立单链表
LinkList ListHeadInsert(LinkList &L){
  int x;
  LNode *s;
  L = (LinkList)malloc(sizeof(LNode));
  L->next = NULL;
  scanf("%d",&x);
  while(x != 9999){
    s = (LNode *)malloc(sizeof(LNode));
    s->data = x;
    s->next = L->next;
    L->next = s;
    scanf("%d",&x);
  }
  return L;
}

//双链表的定义
typedef struct DNode{
  int data;
  struct DNode *prior;
  struct DNode *next;
}DNode,*DLinkList;

//初始化双链表
bool InitDLinkList(DLinkList &L){
  L = (DNode *)malloc(sizeof(DNode));
  if(L == NULL){
    return false;
  }
  L->prior = NULL;
  L->next = NULL;
  return true;
}

//双链表的插入
bool InsertNextDNode(DNode *p,DNode *s){
  if(p == NULL || s == NULL){
    return false;
  }
  s->next = p->next;
  if(p->next != NULL){
    p->next->prior = s;
  }
  s->prior = p;
  p->next = s;
  return true;
}

//双链表的删除
bool DeleteNextDNode(DNode *p){
  if(p == NULL){
    return false;
  }
  DNode *q = p->next;
  if(q == NULL){
    return false;
  }
  p->next = q->next;
  if(q->next!=NULL){
    q->next->prior = p;
  }
  free(q);
  return true;
}

//双链表的销毁
void DestoryList(DLinkList &L){
  while(L->next != NULL){
    DeleteNextDNode(L)
  }
  free(L);
}

//双链表的遍历
//后向
while(p!=NULL){
  p = p->next;
}
//前向
while(p!=NULL){
  p = p->prior;
}
//前向且跳过头结点
while(p->prior != NULL){
  p = p->prior;
}

int main(){
  LinkList L;
  InitList(L);
  return 0;
}

顺序表和链表的比较

在这里插入图片描述

逻辑结构

在这里插入图片描述

物理结构/存储结构

在这里插入图片描述

数据的运算/基本操作

在这里插入图片描述

创

在这里插入图片描述

销

在这里插入图片描述

  • 由malloc函数申请的空间是属于内存当中的堆区，在堆区的内存空间不会由系统自动地回收，需要手动free
  • 如果你用声明一个数组或者声明一个变量的方式申请的内存空间，会由系统自动地帮你完成回收工作
增&删

在这里插入图片描述

查

在这里插入图片描述

用顺序表 or 链表？

在这里插入图片描述
在这里插入图片描述

ErizJ
关注
专栏目录
数据结构——线性表的查找
Labrador_Katie的博客
02-22 5156
查找查找的概念线性表的查找顺序查找（线性查找）折半查找（二分或对分查找）分块查找 查找的概念 主关键字：可唯一地标识一个记录的关键字就是主关键字 次关键字：用以识别若干记录的关键字就是次关键字 对查找表经常进行的操作： 查询某个“特定的”数据元素是否在查找表中 检索某个“特定的”数据元素的各种属性 在查找表中插入一个数据元素 删除查找表中的某个数据元素 查找表可以分为两类： 静态查找表：   仅作“查询”（检索）操作的查找表 动态查找表：   作“插入”和“删除”操作的查找表   有时在查询之后，还需
数据结构之线性表讲解，助力软件设计师考试
08-11
数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试数据结构之线性表讲解，助力软件设计师考试...
数据结构｜线性表
weixin_41809224的博客
03-15 113
线性表的定义 线性表：零个或多个数据元素的有限序列 前驱元素、后继元素、线性表的长度 线性表的存储结构 顺序存储 链式存储：单链表、静态链表、循环链表、双向链表 线性表的基本操作 整表创建、整表删除 获得元素(get)、插入元素(insert)、删除元素(delete) ...
数据结构|线性表的顺序存储
m0_62689947的博客
11-26 470
顺序结构基本操作、优缺点。
数据结构——线性表
odoaobo的博客
08-31 2625
线性表的顺序储存又称顺序表概念：用一组地址连续的存储单元依次存储线性表中的数据元素的线性表。特点：表中的元素逻辑顺序和物理顺序相同。1. 静态顺序表：使用定长数组存储元素。//定长数组//有效数据个数}SeqList2. 动态顺序表：使用动态开辟的数组存储。//指向开辟空间的数组int size;//有效数据的个数//容量空间的大小}SL;线性表的链式存储又称单链表，它是指通过一组任意的存储单元来存储线性表中的数据元素。链表的节点处理存储元素自身的信息外，还需要存放一个后继的指针。
数据结构：线性表(List)【详解】
热门推荐
UniqueUnit的博客
02-18 12万+
线性表 一、线性表的定义 线性表（List）：零个或多个数据元素的有限序列。 线性表的数据集合为{a1,a2,…,an}，假设每个元素的类型均为DataType。其中，除第一个元素a1外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。 在较复杂的线性表中，一个数据元素可以由若干个数据项组成。在这种情况下，常把数据元素称为记录，含有大量记录的线性表又称为文件 二、线性表的顺序标识和实现 概念：用一组地址连续的存储单元依次存储
数据结构：线性表
y_h_k_666的博客
03-28 2869
线性表是基本的数据结构之一，是一组元素的抽象。 线性表包含顺序表和链接表（简称链表），顺序表在C语言中一般使用数组去实现，链表使用结构体去实现。在Python中，list对象是采用顺序表实现的。 1. 顺序表 顺序表是将表中的元素顺序的存储在连续的内存里。 优点： 查询速度快，时间复杂度为O(1) 缺点： 插入元素速度慢，时间复杂度为O(n) 表中元素个数需要提前定义 2. 链表 链表：通过链接各个结点实现的技术就叫做链表。链表中的结点分为指针域和数据域，具体见下图。结点中的data用来存放数据
【数据结构】线性表的知识点全面总结
小人物，大梦想！
09-08 1788
线性表的顺序表示 顺序表的定义及基本概念 顺序表的基本操作 插入 删除 查找 线性表的链式表示 单链表 基本操作 插入 删除 查找 双链表 基本操作 插入 删除 遍历 循环链表 循环单链表 循环双链表 静态链表 顺序表和链表的比较
python数据结构之线性表
m0_71417856的博客
04-12 1462
python线性表的一些基本操作，包括顺序表和单链表
数据结构，线性表有哪些
qq_52119661的博客
08-20 2586
线性表有哪些，线性表是一种常见的数据结构，它的特点是数据元素之间存在一对一的线性关系。根据线性表的存储方式和实现方式。
c语言数据结构：线性表
qq_51813155的博客
11-25 1732
线性表1.什么是线性表？2.线性表的基本运算： 1.什么是线性表？ 线性表是最基本、最简单、也是最常用的一种数据结构。 线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的 它的逻辑结构： 它的：存储结构： 线性表的顺序存储结构——————顺序表 把线性表的所有元素按照逻辑顺序依次存储在 存储位置开始的一块连续的存储空间中 2.线性表的基本运算： 建立线性
数据结构之线性表.rar
04-07
线性表是计算机科学中一种基础且重要的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。在本资料“数据结构之线性表.rar”中，我们将探讨如何使用C++实现线性表，并涵盖增、删、改、查等基本操作。 1. **...
数据结构考研线性表
06-04
这是数据结构中C语言版部分线性表的学习记录，有关动态在我的博客里有对应。方便大家参考。
数据结构实验线性表实验报告（代码是java编写的）
05-10
实验报告涉及的知识点主要集中在数据结构中的线性表，包括顺序表和循环链表的实现与操作。线性表是一种逻辑结构，其中的数据元素按照线性顺序排列，可以通过顺序存储或链式存储来实现。 1. **顺序表**：顺序表是用...
数据结构之线性表的实现.rar
07-27
在这个压缩包“数据结构之线性表的实现.rar”中，我们可以找到关于线性表实现的详细内容，特别是针对严蔚敏版数据结构的实现。 线性表的常见实现方式有两种：顺序表和链表。在顺序表中，元素在内存中是连续存储的，...
【数据结构】C语言二叉树中求度为2的结点的个数、交换二叉树的左右子树、二叉树中先序输出各结点及其层次
最新发布
samroom的博客
11-11 347
编写算法，在以二叉链表存储的二叉树中，按先序次序输出各结点的内容及相应的层次数，要求以二元组的形式输出。（输出格式参见样例）编写算法，在以二叉链表存储的二叉树中，交换二叉树各结点的左右子树。编写算法，在以二叉链表存储的二叉树中，求度为2的结点的个数。
SystemVerilog学习笔记（八）：循环
qq_38156104的博客
11-11 586
循环只不过是将需要多次运行的语句包含在循环中，而不是重复编写这些语句。循环将根据条件语句运行多次，如果条件始终为真，则它会变成无限循环，系统将挂起。
数据结构-查找以及效率分析
dametime_的博客
11-11 127
将被查概率高的放到靠前位置,可以提高查找成功的效率,但对于查找失败的情况需要从头看到尾,因为无序排列,根据实际情况选择不同的方式,经常查找成功可以考虑上图方式。折半查找的查找效率,绿色节点为查找成功,紫色为查找失败,一共11个结点,每一层结点的数量*查到该层结点需要的步数的综合/11就是成功的ASL,失败同理。因为右子树的节点数一定比左子树多1个或等于左子树的结点,所以当两个数折半查找,画出查找判断树,2结点在右子树。所以要想算出他们的查找效率,我们需要画出来对应的查找判定树(根据折半查找的思想画图)
编程之路，从0开始：练习篇
2401_87995839的博客
11-07 426
排序问题，阶乘计算，二分查找，基础算法思想引入
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ErizJ

觉得好的话给小弟一点鼓励吧

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值