数据结构_线性结构

最新推荐文章于 2023-04-16 18:19:47 发布
最新推荐文章于 2023-04-16 18:19:47 发布
阅读量218 收藏
点赞数
分类专栏： dataStructure
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/canhaimingyue/article/details/106533930
版权

数据结构与算法学习笔记

第二章 线性结构

  • 使用数组表示多项式（下标表示多项式的指数，下标的值表示多项式的系数，有点操作方便，缺点浪费空间）

  • 使用结构体数组表示多项式（数组元素按照指数递减的规则存储，数组元素为结构体）!
    在这里插入图片描述

    struct PolynomialElement {
    int coef;
    int expon;
}

  • 使用链表表示多项式

在这里插入图片描述

typedef struct PolynomialElement *Polynomial;
struct PolynomialElement {
    int coef;
    int expon;
    Polynomial next;
}
线性表的抽象数据类型

线性表的顺序存储

  • 基本操作

    // 定义
typedef int ElementType;
typedef struct LNode* List;
struct LNode {
    ElementType Data[MAXSIZE];
    int Last;	// 末尾元素的下标
};
struct LNode L;
List PtrL;

// 创建一个空表
List MakeEmpty()
{
    List PtrL;
    PtrL = (List)malloc(sizeof(LNode));
    PtrL->Last = -1;
    retrun PtrL;
}

// 查找
int Find( ElementType X, List PtrL )
{
    int i = 0;
    while ( i < PtrL->Last && PtrL->Data[i] != X )
    {
        i++
    }
    if ( i > PtrL->Last ) 
        return -1;
    return i;
}

// 插入, i表示数组中第i个元素
int Insert( ElementType X, int i, List PtrL )
{
    int j;
    if ( PtrL->Last = MAXSIZE-1 )
    {
        printf("表满\n");
        return -1；
    }
    
    if ( i < 1 || i > PtrL->Last+2 )
    {
        printf("位置不合法\n");
        return -1;
    }
    
    for ( j = PtrL->Last; j > i-1; j-- )
    {
        PtrL->Data[j+1] = PtrL->Data[j];
    }
    PtrL->Data[i-1] = X;
    PtrL->Last++;
    return 0
}

// 删除（删除表的第 i (1≤i≤n)个位置上的元素) 
int Delete( int i, List PtrL )
{
    
    int j;
    // 判断位置合法性
    if ( i < 1 || i > PtrL->Last+1 )
    {
        printf("位置不合法");
        return -1;
    }
    
    temp = Ptrl->Data[i-1];
    for ( j = i; j <= Ptrl->Last; j++ )
    {
        Ptrl->Data[j-1] = Ptrl->Data[j];
    }
    Ptrl->Last--;
    return temp;
}

  • 线性表链式存储（链表）

    // 定义
typedef int ElementType;
typedef struct LNode *List;
struct LNode{
    ElementType Data;
    List Next;
};
struct LNode L;
List Ptrl;

// 求表长
int GetLen( List Ptrl )
{
    int len = 0;
    while ( Ptrl )
    {
        Ptrl = Ptrl->Next;
        len++;
    }
    return len;
}

// 查找元素
List Find( ElementType X, List Ptrl )
{
    while ( Ptrl && Ptrl->Data != X )
    {
        Ptrl = Ptrl->Next;
    }
    
    return Ptrl;
}

// 查找第K个元素
List  FindKth( int K, List PtrL ) {      
    List  p = PtrL;         
    int  i = 1;         
    while (p !=NULL && i < K )
    {               
        p = p->Next;                
        i++;           
    }        
    if ( i == K ) return p;                      
    /* 找到第K个，返回指针 */        
    else  return NULL;                                 
    /* 否则返回空 */ 
}

// 新增节点
List Insert( ElementType X, int i, List Ptrl )
{
    LNode *node, *tmp;
    if ( 1 == i )
    {
        s = (LNode*)malloc(sizeof(struct LNode));
        s->Data = X;
        s->Next = Ptrl;
        return s;
    }
    
    tmp = FindKth( i-1, Ptrl )
    if ( NULL == tmp )
    {
        printf("位置不对");
        return NULL;
    } else {
        s = (List)malloc(sizeof(struct LNode));
        s->Data = X;
        s->Next = tmp->Next;
        tmp->Next = s;
        return Ptrl;
    }
}

// 删除元素
List Delete( int i, List Ptrl )
{
    int data;
    LNode *node, *tmp;
    if ( Ptrl == NULL )
    {
        printf("表空了");
        return NULL
    }
    
    if ( 1 == i )
    {
        tmp = Ptrl;
        printf( "data = %d", Ptrl->Data );
        Ptrl = Ptrl->Next;
        free(tmp);
        return Ptrl;
    }
    
    node = FindKth( i-1, Ptrl )
    if ( NULL == node || NULL == node->Next )
    {
        printf("节点不存在\n");
        return NULL;
    } else {
        tmp = node->Next;	// 待删除结点
        node->Next = tmp->Next;
        printf( "删除的结点值：%d", tmp->Data );
        free( tmp );
        return Ptrl;
    }
}
广义表（难点）

  • 广义表的元素表示

    typedef struct GNode *PtrToGNode;
typedef PtrToGNode GList;
strcut GNode {
    int Tag;	// 标志域：0表示该结点是单元素；1表示该节点是广义表
    union {
        // 子表指针域 Sublist 与单元素数据域 Data 复用，即公用存储空间
        ElementType Data;
        Glist Sublist;
    } URegion;
    PtrToGNode Next;	// 指向后继结点
};
堆栈（LIFO）

  • 顺序存储

    #define MaxSize
typedef int ElementType
typedef  struct SNode *Stack; 
struct SNode{  
    ElementType Data[MaxSize];  
    int Top; 
};

void Push( Stack PtrS, ElementType item ) 
{     
    if ( PtrS->Top == MaxSize-1 ) 
    {
        printf(“堆栈满”);  
        return;  
    } else {
        PtrS->Data[++(PtrS->Top)] = item;       
        return;     
    }
} 

ElementType Pop( Stack PtrS ) 
{     
    if ( PtrS->Top == -1 ) 
    {            
        printf(“堆栈空”);            
        return ERROR;           /* ERROR是ElementType的特殊值，标志错误 */     
    } else             
        return ( PtrS->Data[(PtrS->Top)--] ); 
}

  • 链式存储

    typedef int ElementType;
typedef struct SNode *Stack;
struct SNode {
    ElementType Data;
    struct SNode *Next;
};

Stack CreateStack()  
{  /* 构建一个堆栈的头结点，返回指针 */   
    Stack S;   
    S =(Stack)malloc(sizeof(struct SNode));   
    S->Next = NULL;   
    return S; 
} 
 
int IsEmpty(Stack S)   
{  /*判断堆栈S是否为空，若为空函数返回整数1，否 则返回0*/  
    return ( S->Next == NULL ); 
}

// 第一个结点没有存数据
void Push( ElementType item, Stack S)     
{  /* 将元素item压入堆栈S  */ 
    struct SNode *TmpCell; 
    TmpCell=(struct SNode *)malloc(sizeof(struct SNode)); 
    TmpCell->Element = item; 
    TmpCell->Next = S->Next; 
    S->Next = TmpCell; 
}

ElementType Pop(Stack S) {  /* 删除并返回堆栈S的栈顶元素 */    
    struct SNode *FirstCell; 
    ElementType TopElem; 
    if( IsEmpty( S ) ) { 
        printf(“堆栈空”);  
        return NULL; 
    } else { 
        FirstCell = S->Next;  
        S->Next = FirstCell->Next; 
        TopElem = FirstCell ->Element; 
        free(FirstCell); 
        return TopElem; 
    } 
}
队列（FIFO）

  • 顺序存储

    #define MaxSize  <储存数据元素的最大个数> 
typedef int ElementType;
struct  QNode {  
    ElementType  Data[ MaxSize ];  
    int  rear;  // front, rear 初始值为-1，使用MaxSize-1个空间
    int  front; 
};  
typedef struct QNode *Queue;

void AddQ( Queue PtrQ, ElementType item) {          
    if ( (PtrQ->rear+1) % MaxSize == PtrQ->front ) 
    {            
        printf(“队列满”);                  
        return;       
    }       
    PtrQ->rear = (PtrQ->rear+1)% MaxSize;       
    PtrQ->Data[PtrQ->rear] = item; 
}

ElementType DeleteQ ( Queue PtrQ ) {                  
    if ( PtrQ->front == PtrQ->rear ) {              
        printf(“队列空”);              
        return ERROR;        
    }  else  {             
        PtrQ->front = (PtrQ->front+1)% MaxSize;             
        return  PtrQ->Data[PtrQ->f ront];        
    } 
}

  • 链式存储

在这里插入图片描述

struct Node{       
    ElementType  Data;       
    struct Node  *Next; 
};
struct QNode{         		 /* 链队列结构   */      
    struct Node  *rear;      /* 指向队尾结点 */      
    struct Node  *front;     /* 指向队头结点 */ 
};  
typedef struct QNode *Queue; 
Queue  PtrQ; 

ElementType DeleteQ ( Queue  PtrQ ) 
{    
    struct Node  *FrontCell;       
    ElementType FrontElem;         
    if  ( PtrQ->front == NULL) {              
        printf(“队列空”);     
        return ERROR;       
    }       
    FrontCell = PtrQ->front;       
    if ( PtrQ->front == PtrQ->rear)        /* 若队列只有一个元素 */              
        PtrQ->front = PtrQ->rear = NULL;   /* 删除后队列置为空 */       
    else                                   
        PtrQ->front = PtrQ->front->Next;       
    FrontElem = FrontCell->Data;       
    free( FrontCell );                     /* 释放被删除结点空间  */       
    return  FrontElem; 
}
蜗牛爱上牛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——线性结构
weixin_35016347的博客
09-03 1864
线性结构区别于非线性结构，通常这种数据结构中的数据元素呈现一种线性关系。 主要包括数组、链表、栈和队列这四种。数组数组是一组有序定长的元素集合。 如int array[] = {0,1,2,3,4,5,6}; 由于数组的元素在内存中的地址是连续的，因此它的特点是随机访问速度快。多维数组多维数组可以多下标表示类似平面甚至空间这种概念，其本质也是一维数组来实现。 如int array[2][3]
数据结构_02_线性结构
VargrantS的博客
06-26 247
一、线性表 1. 相关概念 定义：线性表是具有相同特性数据元素的一个有限序列。序列中所含元素的个数叫做线性表的长度，用 nnn 表示。当 n=0n=0n=0 时，即表示该表为空表。 表头、表尾、前驱、后继； 存储结构：顺序存储结构（顺序表）、链式存储结构（链表）； 链表的形式：单链表、双链表、循环单链表、循环双链表、静态链表； 2. 顺序表和链表的比较 顺序表：具有随机访问特性，要求占用连...
数据结构之线性结构
08-23 532
上次介绍了数据结构相关内容理解。这次介绍数据结构另一块内容线性结构理解。线性结构存储形式类似一列火车，这种包含有数组，链表，队列，栈。 1 数组 是数据结构中逻辑结构分类其中一种，物理结构 以连续地址存储单元把数据存储在一块。 1.1 有以下优势 通过下标快速查找到数据元素。劣势增加和删除 需要移动大量元素，为什么需要大量移动？举个例子 当创建一个长度为3的字符串数组,首先循环初始化数据，再新增进一个字符串，此时就会抛异常了，数组大小是固定的。那想要动态放进去，重新创建一个长度为4的数组，再把数据存进去
数据结构-线性结构
TxyITxs的博客
10-03 1337
一.线性结构 1.顺序线性表 1.1 线性结构是一种基本的数据结构，具有单一前驱和后继的数据关系描述。 1.2 线性表的存储结构分为顺序存储和链式存储。 1.3 顺序线性表的元素间的逻辑关系无需占用额外的空间来存储。 1.4 一般地，以LOC(a1a_1a1​)表示线性表中第一个元素的存储位置，在顺序存储结构中，第ｉ个元素aia_iai​的存储位置为 LOC(ai)=LOC(a1)+(i−1)∗L LOC(a_i) = LOC(a_1) + (i-1)*L LOC(ai​)=LOC(a1​)+(i−1)∗L
数据结构--线性结构
最新发布
YY不吃烤鸭的博客
04-16 971
线性表：零个或多个数据元素的有限序列。“线性表”是由同一类型的数据结构构成的有序序列的线性结构。线性表中的元素的个数n称为线性表的长度；当一个线性表中没有元素（n=0）时，称为空表。表的起始位置称为表头，表的结束位置称为表尾。线性表中元素ai-1为ai的直接前驱，元素ai+1为ai的直接后继。在一个线性表中，ai有且仅有一个直接前驱，有且仅有一个直接后继。第一个元素无前驱，最后一个元素无后继。1.线性表强调是有限的2.线性表为一个序列，即元素之间是有顺序的。
专家讲述C语言数据结构.rar_c 数据结构_c语言数据结构_数据结构
09-24
栈和队列是两种特殊的线性结构，栈遵循“后进先出”(LIFO)原则，队列则是“先进先出”(FIFO)。树是一种非线性数据结构，例如二叉树、平衡树等，它们在搜索、排序等方面有广泛应用。图用于表示对象之间的关系，哈希表...
data_structure_exercise.rar_struct_structure exerci_习题_数据结构_数据结构
09-23
1. **基础概念**：理解并定义各种数据结构及其特性，如线性结构、非线性结构、动态和静态存储等。 2. **操作和算法**：掌握插入、删除、查找等基本操作的时间复杂度分析，例如在数组、链表、栈和队列中的操作。 3....
数据结构_C语言_实验一_线性结构 ——一元多项式求导
Erostrate9
11-06 4799
文章目录实验一 线性结构1. 实验目的2. 实验内容3. 实验要求4. 实验过程(1) 问题描述(2) 数据结构与算法设计(3) 程序实现(4) 实验结果(5) 实验总结 实验一 线性结构 ——一元多项式求导 1. 实验目的 熟练掌握链式线性表的基本操作 2. 实验内容 设计函数求一元多项式的导数。 3. 实验要求 (1) 输入格式说明： 以指数递降方式输入多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。 (2) 输出格式说明： 以与输入相同的格式输出导数多项式非零项的系数和指数
陈越《数据结构》DS04_线性结构b
07-26
“数据结构”在计算机科学中是一门综合性的专业基础课，数据结构是介于数学、计算机硬件和计算机软件三者之间的一门核心课程。数据结构这一门课的内容不仅是一般程序设计（特别是非数值性程序设计）的基础，而且是...
陈越《数据结构》DS03_线性结构a
07-26
“数据结构”在计算机科学中是一门综合性的专业基础课，数据结构是介于数学、计算机硬件和计算机软件三者之间的一门核心课程。数据结构这一门课的内容不仅是一般程序设计（特别是非数值性程序设计）的基础，而且是...
数据结构：线性结构
一个小白的求知路
07-08 622
1：线性表线性表基本操作有：（1）List MakeEmpty():初始化一个新的线性表（2）ElementType FindKth(List L,int i):根据指定的位序i，返回L中相应元素ai（i是下标）（3）Position Find(List L,ElementType X):（4）（5）（6）...
【数据结构——线性结构】
W664160450的博客
03-06 3647
目录1. 简介 1. 简介
【数据结构】1.线性结构
蓝图的博客
03-24 433
此笔记根据中国大学MOOC上浙江大学《数据结构》课件整理 视频地址：https://www.icourse163.org/learn/ZJU-93001?tid=1003997005#/learn/announce 主讲： 陈越、何钦铭 2.1 线性表的引入 [例] 对于一元多项式：(多项式项数n; 各项系数ai 及指数 i) 方法1：顺序存储结构直接表示 例如： 表示成： 优点：运算方...
数据结构——线性数据结构
SilentLand的博客
05-11 4296
线性数据结构：栈、对列
数据结构——线性结构篇（线性表、堆栈、队列）
m0_66881249的博客
11-27 1337
初级数据结构的线性结构基本知识和相关代码
C#数据结构之线性结构
王利威的博客
08-06 450
线性结构是最简单，最基本，最常用的数据结构。 特点是：数据元素之间存在一对一的线性关系。一对一的关系指位置关系。 线性结构（List）由n个相同类型的数据元素构成的有限序列。常用的 数组，泛型 都是线性结构。 线性结构的基本操作：List<T> int GetLength(); //求长度 void Clear(); //清空 bool isEmoty(); //是否为...
数据结构——线性结构（线性表）
热门推荐
巧克力布丁的博客
10-24 1万+
定义把所有的结点用一根直线穿起来详细定义线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列，其中n为表长，n=0是一个空表。用L表示线性表a1是唯一的第一个数据元素，又称表头元素；an是唯一的最后一个元素，又叫表尾元素。除了第一个元素之外，每个元素有且仅有一个直接前驱。除了最后一个元素外，每个元素有且仅有一个直接后继。n个节点离散分配彼此通过指针相连每个节点只有一个前驱节点，每个节点只有一个后续节点首节点没有前驱节点，尾节点没有后续节点从某种角度而言。............
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值