数据结构 -线性表

已于 2022-11-06 16:13:57 修改
阅读量994 收藏 12
点赞数 1
文章标签： 数据结构 c语言
于 2022-11-06 16:12:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59725429/article/details/127622693
版权

数据结构 -线性表

文章目录

1.线性表及其逻辑结构

1.1线性表的定义

  • 定义：线性表（linear list）是具有相同特性的数据元素的一个有限序列。

  • 线性表的逻辑表示为：( a1，a2，…，ai，ai+1，…，an ) ai（1≤i≤n）表示第i（i表示逻辑位序）个元素。

  • 前驱与后继：线性表中相邻的数据元素ai-1和ai之间存在序偶关系(ai-1, ai)，即ai-1是ai的前驱， ai是ai-1的后继；a1 无前驱，an无后继，其它每个元素有且仅有一个前驱和一个后继。

  • 线性表长度：线性表中元素的个数。

  • 线性表L=（a1,a2,a3……an）的图形化表示：

1.2线性表的抽象数据类型描述

ADT
{
    数据对象:
    	D={ ai | 1≤i≤n，n≥0，ai为ElemType类型}  //ElemType是自定义类型标识符
    数据关系：
    	R={<ai，ai+1>| ai、ai+1∈D，i=1，…，n-1}
    基本运算：
        InitList(&L)：初始化线性表，构造一个空的线性表L。
		DestroyList(&L)：销毁线性表，释放线性表L占用的内存空间。
		ListEmpty(L)：判线性表是否为空表，若L为空表，则返回真，否则返回假。
		ListLength(L)：求线性表的长度，返回L中元素个数n。
		DispList(L)：输出线性表，线性表L不为空时，顺序显示L中各结点的值域。
		GetElem(L，i，&e)：求线性表L中指定位置的某个数据元素，用e返回L中第i（1≤i≤n）个元素的值。
        LocateElem(L，e)：定位查找，返回L中第一个值域与e相等的逻辑位序。若这样的元素不存在，则返回值为0。
		ListInsert(&L，i，e)：插入一个数据元素，在L的第i（1≤i≤n）个元素之前插入新的元素e，L的长度增1。
		ListDelete(&L，i，&e)：删除数据元素，删除L的第i（1≤i≤n）个元素，并用e返回其值，L的长度减1。
}

1.3 线性表的知识结构

2.线性表的顺序存储结构

2.1线性表的顺序存储 ——— 顺序表

  • 线性表顺序存储结构：把线性表中的所有元素按照顺序存储方法进行存储。
  • 顺序表的声明
#define MaxSize 50
typedef struct 
{  
	ElemType data[MaxSize];	//存放线性表中的元素
   	int length;				//存放线性表的长度
} SqList;    				//顺序表类型 
注意：逻辑位序和物理位序相差1。

2.2顺序表基本运算的实现

假设ElemType为int类型，使用以下自定义类型语句
typedef int ElemType
2.2.1建立顺序表
void CreateList(SqList * &L，ElemType a[]，int n)//整体建立顺序表,由a中的n个元素建立顺序表
{  
    int i=0,k=0;								//k表示L中元素的个数，初始值为0
   	L=(SqList *)malloc(sizeof(SqList));			//分配存放线性表的空间
  	 while (i<n)								//i扫描a中元素
   	{  
         L->data[k]=a[i];						//将元素a[i]存放到L中
      	k++; i++;								//k记录插入到L中的元素个数
   	}
   	L->length=k;								//设置L的长度k
}

L是输出型参数，所以在形参L的前面需要加上引用符 “&”

2.2.2 顺序表的基本运算算法
  1. 初始化线性表：InitList(L)
void InitList(SqList *&L){
   L=(SqList *)malloc(sizeof(SqList));			//分配存放线性表的顺序表空间
   L->length=0;									//置空线性表的长度为0
}
  1. 销毁线性表：DestroyList(L)
void DestroyList(SqList *&L)
{
    free(L);									//释放线性表L占用的内存空间
}
  1. 判定是否为空表：ListEmpty(L)
bool ListEmpty(SqList *L)
{
   return(L->length==0);
}
//返回一个值表示L是否为空表。若L为空表，则返回true，否则返回false。
  1. 求线性表的长度：ListLength(L)
int ListLength(SqList *L)
{
   return(L->length);							//返回顺序表L的长度
}
  1. 输出线性表：DispList(L)
//当线性表L不为空时，顺序显示L中各元素的值
void DispList(SqList *L)
{  
    for (int i=0;i<L->length;i++)				//扫描顺序表输出各元素值
        printf("%d "，L->data[i]);
    printf("\n");
}
  1. 按序号求线性表中的元素：GetElem(L,i,&e)
//返回L中第 i（1≤i≤ListLength(L)）个元素的值，存放在e中。
bool GetElem(SqList *L，int i，ElemType &e)
{     
   if (i<1 || i>L->length)
      return false;								//参数i错误时返回false
   e=L->data[i-1];								//取元素的值
   return true;									//成功找到元素时返回true
}  
//体现顺序表的随机存取特性
  1. 按元素值查找：LocateElem(L，e)
//顺序查找第一个值域与e相等的元素的逻辑位序。若这样的元素不存在，则返回值为0。
int LocateElem(SqList *L，ElemType e)
{  
    int i=0;
    while (i<L->length && L->data[i]!=e)
        i++;								   //查找元素e
    if (i>=L->length)						   //未找到时返回0
        return 0;
    else
        return i+1;							   //找到后返回其逻辑序号
}
  1. 插入数据元素：ListInsert(L，i，e)
//在顺序表L的第i（1≤i≤ListLength(L)+1）个位置上插入新的元素e。
bool ListInsert(SqList *&L，int i，ElemType e)
{  
    int j;   
    if (i<1 || i>L->length+1 || L->length==MaxSize)      
        return false;							//参数错误时返回false   
    i--;									 	//将顺序表逻辑序号转化为物理序号   
    for (j=L->length;j>i;j--)                	//将data[i..n]元素后移一个位置	
        L->data[j]=L->data[j-1];   
    L->data[i]=e;								//插入元素e   
    L->length++;								//顺序表长度增1   
    return true;								//成功插入返回true
}
  • 时间复杂度分析：元素移动的次数不仅与表长L->length=n有关，而且与插入位置i有关：
    • 当i=n+1时，移动次数为0；（算法最好时间复杂度为O(1)）
    • 当i=1时，移动次数为n，达到最大值。（算法最坏时间复杂度为O(n)）
  • 平均情况分析：

  • 在插入元素ai时，若为等概率情况，则pi =1/(n+1)
  • 此时需要将ai～an的元素均后移一个位置，共移动n-i+1个元素。
  • 在长度为n的线性表中插入一个元素时所需移动元素的平均次数为：

因此插入算法的平均时间复杂度为O(n)。

  1. 删除数据元素：ListDelete(L，i，e)

bool ListDelete(SqList *&L，int i，ElemType &e)
{  
    int j;   
    if (i<1 || i>L->length)						//参数错误时返回false     
        return false;   
    i--;										//将顺序表逻辑序号转化为物理序号   
    e=L->data[i];   
    for (j=i;j<L->length-1;j++) 				//将data[i..n-1]元素前移	
        L->data[j]=L->data[j+1];   
    L->length--;								//顺序表长度减1   
    return true;								//成功删除返回true
}
  • 删除元素时移动元素的过程

3.线性表的链式存储结构

3.1线性表的链式存储结构——— 链表

  • 链表：线性表的链式存储结构称为链表

  • 设计链式存储结构时，每个数据元素用一个结点单独存储，为了表示逻辑关系，增加指针域。

  • 线性表两种存储结构的比较：

    • 顺序表

      • 优点

      1. 存储密度大：无须为表示线性表中元素之间的逻辑关系而增加额外的存储空间。

      2. 具有随机存取特性。

      • 缺点
      1. 插入和删除操作需要移动大量元素。
      2. 初始空间大小分配难以掌握。

    • 链表

      • 优点
      1. 由于采用结点的动态分配方式，具有良好的适应性。
      2. 插入和删除操作只需修改相关指针域，不需要移动元素。
      • 缺点
      1. 存储密度小：为表示线性表中元素之间的逻辑关系而需要增加额外的存储空间（指针域）。
      2. 不具有随机存取特性。

3.2单链表

  • 单链表：每个结点增加一个指向后继结点的指针域。
  • 单链表中结点类型LinkNode的声明
typedef struct LNode       //声明单链表结点类型
{  ElemType data;
   struct LNode *next;     //指向后继结点
}  LinkNode;

  • 带头结点单链表

  • 单链表的特点：当访问过一个结点后，只能接着访问它的后继结点，而无法访问它的前驱结点。

1.插入结点和删除结点操作
  • 插入操作：将值为x 的新结点 s 插入到 p 结点之后。
  • 特点：只需修改相关结点的指针域，不需要移动结点。

s->next = p->next;
p->next = s;
  • 删除操作：删除p结点之后的一个结点。
  • 特点：只需修改相关结点的指针域，不需要移动结点。

q=p->next;										//q临时保存被删结点
p->next = q->next;								//从链表中删除结点q
free(q);										//释放结点q的空间
2.整体建立单链表
  1. 头插法
  • 从一个空表开始，创建一个头结点。
  • 依次读取字符数组 a 中的元素，生成新结点。
  • 将新结点插入到当前链表的表头上，直到结束为止。
  • 注意：链表的结点顺序与逻辑次序相反。
头插法建表算法：
void CreateListF(LinkNode *&L，ElemType a[]，int n)
{  
    LinkNode *s;  
    int i;   
    L=(LinkNode *)malloc(sizeof(LinkNode));   
    L->next=NULL;	   							//创建头结点，其next域置为NULL 
    for (i=0;i<n;i++)							//循环建立数据结点  
    {  
        s=(LinkNode *)malloc(sizeof(LinkNode));     
        s->data=a[i];							//创建数据结点s     
        s->next=L->next;						//将s插在首结点之前，头结点之后     
        L->next=s;  
    }
}
算法复杂度为O(n)
  1. 尾插法
  • 从一个空表开始，创建一个头结点。
  • 依次读取字符数组a中的元素，生成新结点。
  • 将新结点插入到当前链表的表尾上，直到结束为止。
  • 注意：链表的结点顺序与逻辑次序相同。

尾插法
void CreateListR(LinkNode *&L，ElemType a[]，int n)
{  
    LinkNode *s，*r;  
    int i;   
    L=(LinkNode *)malloc(sizeof(LinkNode));  	//创建头结点  
    r=L;										//r始终指向尾结点，开始时指向头结点    
    for (i=0;i<n;i++)							//循环建立数据结点   
    {	
        s=(LinkNode *)malloc(sizeof(LinkNode));	
        s->data=a[i];							//创建数据结点s	
        r->next=s;								//将s插入r之后	
        r=s;   
    }   
    r->next=NULL;								//尾结点next域置为NULL
}
算法复杂度为O(n)

3.线性表的基本运算在单链表中的实现
  1. 初始化线性表：InitList(&L)
//建立一个空的单链表，即创建一个头结点。

void InitList(LinkNode *&L)
 {
    L=(LinkNode *)malloc(sizeof(LinkNode));     //创建头结点
    L->next=NULL;								//将其next域置为NULL
 }
  1. 销毁线性表：DestroyList(&L)
//释放单链表L占用的内存空间。逐一释放全部结点的空间。    

void DestroyList(LinkNode *&L)
{      
    LinkNode *pre=L， *p=L->next;              //pre指向p的前驱结点  
    while (p!=NULL)							  //扫描单链表L  
    {        
        free(pre);							  //释放pre结点       
        pre=p;								  //pre、p同步后移一个结点      
        p=pre->next;  
    }  
    free(pre);  							  //循环结束时p为NULL，pre指向尾结点，释放它
}

3.判线性表是否为空表：ListEmpty(L)

//若单链表L没有数据结点，则返回真，否则返回假。      

bool ListEmpty(LinkNode *L)
{
　　return(L->next==NULL);
}
  1. 求线性表的长度：ListLength(L)
//返回单链表L中数据结点的个数。    

int ListLength(LinkNode *L)
{  　
    int n=0;　  
    LinkNode *p=L;	         				//p指向头结点，n置为0（即头结点的序号为0）    
    while (p->next!=NULL)   
    {	
        n++;	
        p=p->next;  
    }   
    return(n);  							//循环结束，p指向尾，其序号n为结点个数
}
  1. 输出线性表：DispList(L)
//逐一扫描单链表L的每个结点，并显示各结点data域值。    

void DispList(LinkNode *L)
{   
    LinkNode *p=L->next;					//p指向开始结点  
    while (p!=NULL)							//p不为NULL，输出p结点的data域   
    { 
        printf("%d "，p->data);     
        p=p->next;							//p移向下一个结点  
    }  
    printf("\n");
}
  1. 求位置i的数据元素：GetElem(L，i，&e)
//在单链表L中从头开始找到第i个结点，若存在第i个数据结点，则将其data域值赋给变量e。
    
bool GetElem(LinkNode *L，int i，ElemType &e)
{    
    int j=0;   
    LinkNode *p=L;	 					//p指向头结点，j置为0（即头结点的序号为0）
   
    while (j<i && p!=NULL)   
    {	
        j++;	
        p=p->next;   
    }   
    if (p==NULL)						//不存在第i个数据结点，返回false     
        return false;   
    else								//存在第i个数据结点，返回true  
    {  
        e=p->data;     
        return true;   
    }
}
  1. 按元素值查找：LocateElem(L，e)
//在单链表L中从头开始找第一个值域与e相等的结点，若存在这样的结点，则返回位置，否则返回0。   

int LocateElem(LinkNode *L，ElemType e)
{   
    int i=1;  
    LinkNode *p=L->next;				//p指向开始结点，i置为1     
    while (p!=NULL && p->data!=e)    
    {       
        p=p->next;  					//查找data值为e的结点，其序号为i      
        i++;   
    }      
    if (p==NULL)						//不存在元素值为e的结点，返回0    
        return(0);  
    else								//存在元素值为e的结点，返回其逻辑序号i     
        return(i);
}
  1. 插入数据元素：ListInsert(&L，i，e)
//先在单链表L中找到第 i-1 个结点p，若存在这样的结点，将值为e的结点s插入到其后。

bool ListInsert(LinkNode *&L，int i，ElemType e)
{ 
    int j=0;  
    LinkNode *p=L，*s;          		//p指向头结点，j置为0     
    while (j<i-1 && p!=NULL)   
    {	
        j++;	
        p=p->next;  
    }   
    if (p==NULL)					//未找到第i-1个结点，返回false      
        return false;   
    else							//找到第i-1个结点p，插入新结点并返回true   
    {	
        s=(LinkNode *)malloc(sizeof(LinkNode));	
        s->data=e;					//创建新结点s，其data域置为e	
        s->next=p->next;			//将s插入到p之后	
        p->next=s;	
        return true;   
    }
}
  1. 删除数据元素：ListDelete(&L，i，&e)
//先在单链表L中找到第i-1个结点p，若存在这样的结点，且也存在后继结点，则删除该后继结点。 

bool ListDelete(LinkNode *&L，int i，ElemType &e)
{  
    int j=0;   
    LinkNode *p=L，*q;				//p指向头结点，j置为0   
    while (j<i-1 && p!=NULL)		//查找第i-1个结点   
    {	
        j++;	
        p=p->next;   
    }   
    if (p==NULL)					//未找到第i-1个结点，返回false	
        return false;  
    else							//找到第i-1个结点p  
    { 
        q=p->next;					//q指向第i个结点     
        if (q==NULL)				//若不存在第i个结点，返回false	
            return false;     
        e=q->data;     
        p->next=q->next;			//从单链表中删除q结点     
        free(q);					//释放q结点     
        return true;				//返回true表示成功删除第i个结点   
    }
}

3.3双链表

  • 双链表：在线性表的链式存储结构中，每个物理结点增加一个指向后继结点的指针域和一个指向前驱结点的指针域。

  • 优点：

    • 从任一结点出发可以快速找到其前驱结点和后继结点；
    • 从任一结点出发可以访问其他结点。

  • 双链表结点类型DLinkNode声明：

typedef struct DNode      //双链表结点类型
{  ElemType data;
   struct DNode *prior;   //指向前驱结点
   struct DNode *next;    //指向后继结点
} DLinkNode;
1.双链表插入结点操作

  • 操作语句：
s->next = p->next
p->next->prior = s
s->prior = p
p->next = s
2.双链表删除结点操作

  • 操作语句：
p->next->next->prior = p
p->next = p->next->next
3.建立双链表
  • 整体建立双链表也有两种方法：头插法和尾插法。与单链表的建表算法相似，主要是插入和删除的不同。
  1. 头插法建立双链表
void CreateListF(DLinkNode *&L，ElemType a[]，int n)
{ 
    DLinkNode *s; int i;    
    L=(DLinkNode *)malloc(sizeof(DLinkNode)); 		//创建头结点  
    L->prior=L->next=NULL;							//前后指针域置为NULL  
    for (i=0;i<n;i++)								//循环建立数据结点  
    {	
        s=(DLinkNode *)malloc(sizeof(DLinkNode));	
        s->data=a[i];								//创建数据结点s	
        s->next=L->next;							//将s插入到头结点之后	
        if (L->next!=NULL)   						//若L存在数据结点，修改前驱指针  	    
            L->next->prior=s;       
        L->next=s;      
        s->prior=L;   
    }
}
  1. 尾插法建立双链表
void CreateListR(DLinkNode *&L，ElemType a[]，int n)
{  
    DLinkNode *s，*r;  
    int i;  
    L=(DLinkNode *)malloc(sizeof(DLinkNode));    //创建头结点 
    L->prior=L->next=NULL;						//前后指针域置为NULL   
    r=L;										//r始终指向尾结点，开始时指向头结点
    for (i=0;i<n;i++)							//循环建立数据结点  
    { 
        s=(DLinkNode *)malloc(sizeof(DLinkNode));    
        s->data=a[i];							//创建数据结点s   
        r->next=s;s->prir=r;					//将s插入r之后 
        r=s;									//r指向尾结点 
    } 
    r->next=NULL;								//尾结点next域置为NULL
}
4.线性表基本运算在双链表中的实现
  1. 双链表的插入算法：
bool ListInsert(DLinkNode *&L，int i，ElemType e) //在第i个元素后插入e
{ 
    int j=0;  
    DLinkNode *p=L，*s;	      					//p指向头结点，j设置为0  
    while (j<i-1 && p!=NULL)					//查找第i-1个结点  
    {  
        j++;     
        p=p->next;  
    }       
    if (p==NULL)								//未找到第i-1个结点，返回false     
        return false; 
    else										//找到第i-1个结点p，在其后插入新结点s  
    {	
        s=(DLinkNode *)malloc(sizeof(DLinkNode));	
        s->data=e;								//创建新结点s	
        s->next=p->next;						//在p之后插入s结点	
        if (p->next!=NULL)						//若存在后继结点，修改其前驱指针   	    
            p->next->prior=s;	
        s->prior=p;	
        p->next=s;	
        return true;  
    }
}
  1. 双链表的删除算法：
bool ListDelete(DLinkNode *&L，int i，ElemType &e) 	//删除第i个节点
{ 
    int j=0; DLinkNode *p=L，*q; 					//p指向头结点，j设置为0  
    while (j<i-1 && p!=NULL)	  					//查找第i-1个结点   
    { 
        j++;      
        p=p->next;       
    }        
    if (p==NULL)									//未找到第i-1个结点	
        return false;  
    else			   								//找到第i-1个结点p   
    {		
        q=p->next;									//q指向第i个结点	
        if (q==NULL)							   	//当不存在第i个结点时返回false	   
            return false;	
        e=q->data;	
        p->next=q->next;							//从双单链表中删除q结点	
        if (q->next!=NULL)  					  	//若q结点存在后继结点           
            q->next->prior=p;						//修改q结点后继结点的前驱指针	
        free(q);		   							//释放q结点	
        return true;  
    }
}

3.4循环链表

  • 循环链表是另一种形式的链式存储结构形式。
  • 循环单链表：将表中尾结点的指针域改为指向表头结点，整个链表形成一个环。由此从表中任一结点出发均可找到链表中其他结点。

  • 循环双链表：形成两个环。

脚踏何处
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构-线性表-PPT
02-04
"数据结构-线性表-PPT" 数据结构是一门研究非数值计算的程序设计问题的学科，它研究的是计算机存储、表示、操作和保护非数值信息的方法和技术。线性表是数据结构的一种基本结构，它是一种线性结构，只有一个首结点...
c语言进阶——数据结构——线性表
最新发布
weixin_66547608的博客
09-22 361
线性表是一种常见的数据结构，它是一种有序的数据元素的集合，其中每个元素都有唯一的前驱和后继。线性表有两种实现方式：顺序存储和链式存储。顺序存储是将线性表的元素按顺序依次存放在一块连续的内存空间中。通过数组来实现线性表，可以通过下标直接访问和操作元素，查找元素的时间复杂度为O(1)。但是插入和删除元素需要平移其他元素，时间复杂度为O(n)。链式存储是通过节点和指针的方式来实现线性表。每个节点存储数据元素以及指向下一个节点的指针。插入和删除元素只需修改指针，时间复杂度为O(1)，但是查找元素需要遍历链
数据结构（C语言版）-线性表（顺序表）
czh2637750821的博客
01-04 1532
线性表一、线性表的基本概率1、线性表的定义2、线性表举例3、线性表的特点4、线性表的基本操作二、线性表的顺序存储1、顺序表的定义2、顺序表的存储特点3、顺序表的类型定义4、顺序表的基本运算的实现。三、配套实验 一、线性表的基本概率 1、线性表的定义 线性表是具有相同数据类型的n(n>= 0)个数据元素的有限序列。 2、线性表举例 （1）简单的线性表。例如，26个英文字母表；一周七天。 （2）复杂的线性表。例如，学生信息登记表。 在复杂的线性表，常把数据元素称为记录（Record），它由若干个数据项（I
(新人第二帖)循环链表建立,连接操作中的怪异bug分析与解决(C语言实现)
richard7234的博客
03-29 853
问题概述: 这是我在前一天晚上拿到手的问题.程序员想利用c语言实现循环链表的遍历和简单的连接操作(直接将一个链表插入另一个链表后面,不进行边插入边比较的操作).原程序较为复杂,有很多当时还没来得及调试和使用的函数,在此按下不表.本文只讨论我接到程序时主函数中用过的函数. 出错现象为无法输出任何数据,主函数返回值异常.这是c/c++中最为常见的错误之一,基本上都和指针访问密不可分.考虑在总览程序之后使用单步调试定位出现异常的指针操作并予以修改. 工具:Visual Studio Code,扩展包包括code
编写一个程序,实现顺序表的各种基本运算和整体建表算法（假设元素的类型 elemtype位为char)，并在此基础上设计一个程序完成以下功能
Ben1002的博客
04-08 4250
1. 初始化顺序表L。 2. 依次插入a,b,c,d,e元素。 3. 输出顺序表L。 4. 输出顺序表L的长度。 5.输出顺序表L 的第3个元素。 6.输出元素C的位置。 7.在第4个元素位置处插入f元素。 8.删除顺序表L的第3 个元素。 #include <iostream> #include <stdio.h> #include <malloc.h> using namespace std; typedef char ElemTyp
线性表的实现
振宇的博客
05-07 644
线性表
数据结构-线性表的链式存储
09-17
线性表是计算机科学中一种基础且重要的数据结构，它由有限个相同类型元素组成，按照线性顺序排列。在实际应用中，线性表的数据元素可以是数字、字符串、对象等各种类型。线性表的链式存储是数据结构课程中的核心概念...
数据结构-线性表的基本使用
10-26
线性表是数据结构中的基础概念，它是一种最简单但非常重要的数据组织形式。线性表是由n（n>=0）个相同类型元素构成的有限序列，这些元素在逻辑上是顺序排列的，可以通过索引访问。在计算机科学中，理解和掌握线性表...
数据结构-线性表-xmind思维导图
05-13
串、栈、队列的区分度在于数据的运算和逻辑结构，而他们的存储结构常用的都是顺序表和链表。 广义表和数组都是更抽象的线性表，数组对数据元素要求更严苛，广义表则是放开了数据元素的限定。他们都可以是递归定义，...
数据结构-线性表09
01-20
线性表是数据结构中的基础概念，它是一个包含零个或多个数据元素的有限序列，这些元素遵循特定的顺序规则。在线性表中，每个元素要么是序列的开头（无直接前驱），要么位于中间（有一个直接前驱和一个直接后继），...
15-单链表的基本运算实现
网络安全
05-30 1391
1. 单链表的数据抽象类型   对于单链表来说，它是线性表的一种存储结构，当我们把单链表的数据对象，数据关系，数据操作描述出来后，然后就可以考虑基本操作的实现了。 ADT ——线性表： ADT List { 数据对象： D = {ai | ai∈ElemType, i=1,2,…,n, n≧0 } //ElemType为类型标识符 数据关系： R = {&amp;amp;amp;amp;amp;amp;amp;amp;lt...
【数据结构】线性表的操作算法
慢热型网友的博客
06-12 3408
（1）创建一个线性表，将给定的含有n个元素的数组中的每个元素依次放入到顺序表中，并将n赋给顺序表的长度成员。算法如下 （2）初始化线性表 （3）销毁线性表，释放线性表L所占用的内存空间 （4）判断是否为空表，若L为空表则返回true，否则返回false （5）求线性表的长度ListLength（L） （6）输出运算表（DispList） 该运算当线性表L不为空时，顺序显示L中各元素的值 （7）求某个数据元素的值GetElem（L，i，&e）...
DisplayList与OpenGL
淡淡的宁静的博客
02-01 2214
OpenGL —- Display List Why do we use it? 使用display list可以提高OpenGL在绘图过程中的性能。它预先将要执行的OpenGL的命令存储在内存中间，当后面有调用时候，直接提取内存中的数据，这样可以很大程度上的缩短计算的时间。尤其是在需要多次重复绘制同一几何模型的时候，性能的提高特别明显。        那display l...
顺序表:：在顺序表L中的第i个位置插入元素e。
weixin_63381305的博客
09-12 4022
【代码】顺序表:：在顺序表L中的第i个位置插入元素e。
有关线性表的基本操作
absorb2601078490的博客
05-19 815
本文只有代码，介绍了有关线性表的基本操作，已经过调试没有很大问题 如有错误，还请批评指正
数据结构总结笔记1：线性表总结
Joye-joy的博客
05-28 1534
最近进行数据结构的复习，并将重点的一些线性表的知识点用图的方式进行总结，以方便进行复习、查看。 在此做一个总结记录。后续会更新上算法程序部分。 1，线性表的知识结构图 1.1线性表定义 线性表是一个具有相同特性的数据元素的有限序列。 相同特性：所有元素属于同一数据类型。 有限：数据元素个数是有限的。 序列：数据元素由逻辑序号唯一确定。一个线性表中可以有相同值的元素。 1....
函数形参和实参问题
whu_sky的AC之路
10-29 1351
今天闲着没事实现了一下数据结构里面的顺序表，在顺表初始创建的时候遇到了这样一个问题。 #include #include #define MaxSize 1000 #define ElemType int typedef struct { ElemType data[MaxSize]; int length; }SqList; int isListEmpty(SqLis
数据结构(基本运算验证性实践路线)——顺序表
Sailor_luo的博客
09-14 1133
目的是要测试“建立线性表”的算法CreateList，为查看建表的结果，需要实现“输出线性表”的算法DispList。 在研习DispList中发现，要输出线性表，还要判断表是否为空，这样，实现判断线性表是否为空的算法ListEmpty成为必要。 这样，再加上main函数，这个程序由4个函数构成。main函数用于写测试相关的代码。
【初学数据结构】顺序表
qq_62905657的博客
10-06 1171
初学数据结构之顺序表
数据结构 - 线性表
09-13
线性表是一种常见的数据结构，它表示具有相同数据类型的一组元素的有序序列。线性表中的元素之间存在一种顺序关系，每个元素都有一个前驱和一个后继（除了第一个元素没有前驱，最后一个元素没有后继）。线性表可以用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值