数据结构--线性结构

最新推荐文章于 2024-06-29 17:19:32 发布
最新推荐文章于 2024-06-29 17:19:32 发布
阅读量394 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/miaoqiucheng/article/details/78106216
版权

顺序存储结构

typedef int Position; 
typedef struct LNode *List; 
struct LNode { 
    ElementType Data[MAXSIZE]; 
    Position Last; 
}; 

/* 初始化 */ 
List MakeEmpty() 
{ 
    List L; 

    L = (List)malloc(sizeof(struct LNode)); 
    L->Last = -1; 

    return L; 
} 

/* 查找 */ 
#define ERROR -1 

Position Find( List L, ElementType X ) 
{ 
    Position i = 0; 

    while( i <= L->Last && L->Data[i]!= X ) 
        i++; 
    if ( i > L->Last )  return ERROR; /* 如果没找到，返回错误信息 */ 
    else  return i;  /* 找到后返回的是存储位置 */ 
} 

/* 插入 */ 
/*注意:在插入位置参数P上与课程视频有所不同，课程视频中i是序列位序（从1开始），这里P是存储下标位置（从0开始），两者差1*/ 
bool Insert( List L, ElementType X, Position P )  
{ /* 在L的指定位置P前插入一个新元素X */ 
    Position i; 

    if ( L->Last == MAXSIZE-1) { 
        /* 表空间已满，不能插入 */ 
        printf("表满");  
        return false;  
    }   
    if ( P<0 || P>L->Last+1 ) { /* 检查插入位置的合法性 */ 
        printf("位置不合法"); 
        return false;  
    }  
    for( i=L->Last; i>=P; i-- ) 
        L->Data[i+1] = L->Data[i]; /* 将位置P及以后的元素顺序向后移动 */ 
    L->Data[P] = X;  /* 新元素插入 */ 
    L->Last++;       /* Last仍指向最后元素 */ 
    return true;  
}  

/* 删除 */ 
/*注意:在删除位置参数P上与课程视频有所不同，课程视频中i是序列位序（从1开始），这里P是存储下标位置（从0开始），两者差1*/ 
bool Delete( List L, Position P ) 
{ /* 从L中删除指定位置P的元素 */ 
    Position i; 

    if( P<0 || P>L->Last ) { /* 检查空表及删除位置的合法性 */ 
        printf("位置%d不存在元素", P );  
        return false;  
    } 
    for( i=P+1; i<=L->Last; i++ ) 
        L->Data[i-1] = L->Data[i]; /* 将位置P+1及以后的元素顺序向前移动 */ 
    L->Last--; /* Last仍指向最后元素 */ 
    return true;    
}

以上为顺序存储结构的初始化查找插入删除。

线性表基本操作
1、List MakeEmpty()：初始化一个空线性表L；
2、ElementType FindKth( int K, List L )：根据位序K，返回相应元素 ；
3、int Find( ElementType X, List L )：在线性表L中查找X的第一次出现位置；
4、void Insert( ElementType X, int i, List L)：在位序i前插入一个新元素X；
5、void Delete( int i, List L )：删除指定位序i的元素；
6、int Length( List L )：返回线性表L的长度n。
这里写图片描述

链式存储结构

 typedef struct LNode *PtrToLNode; 
struct LNode { 
    ElementType Data; 
    PtrToLNode Next; 
}; 
typedef PtrToLNode Position; 
typedef PtrToLNode List; 

/* 查找 */ 
#define ERROR NULL 

Position Find( List L, ElementType X ) 
{ 
    Position p = L; /* p指向L的第1个结点 */ 

    while ( p && p->Data!=X ) 
        p = p->Next; 

    /* 下列语句可以用 return p; 替换 */ 
    if ( p ) 
        return p; 
    else 
        return ERROR; 
} 

/* 带头结点的插入 */ 
/*注意:在插入位置参数P上与课程视频有所不同，课程视频中i是序列位序（从1开始），这里P是链表结点指针，在P之前插入新结点 */ 
bool Insert( List L, ElementType X, Position P ) 
{ /* 这里默认L有头结点 */ 
    Position tmp, pre; 

    /* 查找P的前一个结点 */         
    for ( pre=L; pre&&pre->Next!=P; pre=pre->Next ) ;             
    if ( pre==NULL ) { /* P所指的结点不在L中 */ 
        printf("插入位置参数错误\n"); 
        return false; 
    } 
    else { /* 找到了P的前一个结点pre */ 
        /* 在P前插入新结点 */ 
        tmp = (Position)malloc(sizeof(struct LNode)); /* 申请、填装结点 */ 
        tmp->Data = X;  
        tmp->Next = P; 
        pre->Next = tmp; 
        return true; 
    } 
} 

/* 带头结点的删除 */ 
/*注意:在删除位置参数P上与课程视频有所不同，课程视频中i是序列位序（从1开始），这里P是拟删除结点指针 */ 
bool Delete( List L, Position P ) 
{ /* 这里默认L有头结点 */ 
    Position tmp, pre; 

    /* 查找P的前一个结点 */         
    for ( pre=L; pre&&pre->Next!=P; pre=pre->Next ) ;             
    if ( pre==NULL || P==NULL) { /* P所指的结点不在L中 */ 
        printf("删除位置参数错误\n"); 
        return false; 
    } 
    else { /* 找到了P的前一个结点pre */ 
        /* 将P位置的结点删除 */ 
        pre->Next = P->Next; 
        free(P); 
        return true; 
    } 
}

链式存储结构的初始化查找插入删除。
这里写图片描述

这里写图片描述
这里写图片描述
这里写图片描述

堆栈

栈的顺序存储实现

typedef int Position; 
struct SNode { 
    ElementType *Data; /* 存储元素的数组 */ 
    Position Top;      /* 栈顶指针 */ 
    int MaxSize;       /* 堆栈最大容量 */ 
}; 
typedef struct SNode *Stack; 

Stack CreateStack( int MaxSize ) 
{ 
    Stack S = (Stack)malloc(sizeof(struct SNode)); 
    S->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType)); 
    S->Top = -1; 
    S->MaxSize = MaxSize; 
    return S; 
} 

bool IsFull( Stack S ) 
{ 
    return (S->Top == S->MaxSize-1); 
} 

bool Push( Stack S, ElementType X ) 
{ 
    if ( IsFull(S) ) { 
        printf("堆栈满"); 
        return false; 
    } 
    else { 
        S->Data[++(S->Top)] = X; 
        return true; 
    } 
} 

bool IsEmpty( Stack S ) 
{ 
    return (S->Top == -1); 
} 

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

栈的链式存储实现

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

Stack CreateStack( )  
{ /* 构建一个堆栈的头结点，返回该结点指针 */ 
    Stack S; 

    S = (Stack)malloc(sizeof(struct SNode)); 
    S->Next = NULL; 
    return S; 
} 

bool IsEmpty ( Stack S ) 
{ /* 判断堆栈S是否为空，若是返回true；否则返回false */ 
    return ( S->Next == NULL ); 
} 

bool Push( Stack S, ElementType X ) 
{ /* 将元素X压入堆栈S */ 
    PtrToSNode TmpCell; 

    TmpCell = (PtrToSNode)malloc(sizeof(struct SNode)); 
    TmpCell->Data = X; 
    TmpCell->Next = S->Next; 
    S->Next = TmpCell; 
    return true; 
} 

ElementType Pop( Stack S )   
{ /* 删除并返回堆栈S的栈顶元素 */ 
    PtrToSNode FirstCell; 
    ElementType TopElem; 

    if( IsEmpty(S) ) { 
        printf("堆栈空");  
        return ERROR; 
    } 
    else { 
        FirstCell = S->Next;  
        TopElem = FirstCell->Data; 
        S->Next = FirstCell->Next; 
        free(FirstCell); 
        return TopElem; 
    } 
}

这里写图片描述
这里写图片描述

队列

队列的顺序存储实现

typedef int Position; 
struct QNode { 
    ElementType *Data;     /* 存储元素的数组 */ 
    Position Front, Rear;  /* 队列的头、尾指针 */ 
    int MaxSize;           /* 队列最大容量 */ 
}; 
typedef struct QNode *Queue; 

Queue CreateQueue( int MaxSize ) 
{ 
    Queue Q = (Queue)malloc(sizeof(struct QNode)); 
    Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType)); 
    Q->Front = Q->Rear = 0; 
    Q->MaxSize = MaxSize; 
    return Q; 
} 

bool IsFull( Queue Q ) 
{ 
    return ((Q->Rear+1)%Q->MaxSize == Q->Front); 
} 

bool AddQ( Queue Q, ElementType X ) 
{ 
    if ( IsFull(Q) ) { 
        printf("队列满"); 
        return false; 
    } 
    else { 
        Q->Rear = (Q->Rear+1)%Q->MaxSize; 
        Q->Data[Q->Rear] = X; 
        return true; 
    } 
} 

bool IsEmpty( Queue Q ) 
{ 
    return (Q->Front == Q->Rear); 
} 

ElementType DeleteQ( Queue Q ) 
{ 
    if ( IsEmpty(Q) ) {  
        printf("队列空"); 
        return ERROR; 
    } 
    else  { 
        Q->Front =(Q->Front+1)%Q->MaxSize; 
        return  Q->Data[Q->Front]; 
    } 
}

队列的链式存储实现

typedef struct Node *PtrToNode; 
struct Node { /* 队列中的结点 */ 
    ElementType Data; 
    PtrToNode Next; 
}; 
typedef PtrToNode Position; 

struct QNode { 
    Position Front, Rear;  /* 队列的头、尾指针 */ 
    int MaxSize;           /* 队列最大容量 */ 
}; 
typedef struct QNode *Queue; 

bool IsEmpty( Queue Q ) 
{ 
    return ( Q->Front == NULL); 
} 

ElementType DeleteQ( Queue Q ) 
{ 
    Position FrontCell;  
    ElementType FrontElem; 

    if  ( IsEmpty(Q) ) { 
        printf("队列空"); 
        return ERROR; 
    } 
    else { 
        FrontCell = Q->Front; 
        if ( Q->Front == Q->Rear ) /* 若队列只有一个元素 */ 
            Q->Front = Q->Rear = NULL; /* 删除后队列置为空 */ 
        else                      
            Q->Front = Q->Front->Next; 
        FrontElem = FrontCell->Data; 

        free( FrontCell );  /* 释放被删除结点空间  */ 
        return  FrontElem; 
    } 
}

这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述

拂去烟尘
关注
专栏目录
数据结构（一）——线性表的顺序存储原理及实现
hml111666的博客
02-09 2708
一、线性表介绍 1、定义：由n（n>0）个相同类型的元素组成的有序集合，如图 这里所说的线性表是逻辑结构，表示元素一对一的相邻关系，是独立于存储结构（顺序表和链表）的，他们属于不同层面的概念 2、特点： ➢表中元素的个数是有限的。 ➢表中元素的数据类型都相同。意味着每一个元素占用相同大小的空间 ➢表中元素具有逻辑上的顺序性，在序列中各元素排序有其先后顺序 3、实现方式——顺序表及链表 3.1顺序表：线性表的顺序表示 逻辑上相邻的两个元素在物理位置上也相邻 以上代码描述：.
常用数据结构--线性结构
qzp1991的专栏
03-23 1735
常用数据结构--线性结构
线性表之顺序存储结构--C实现
热门推荐
懒人的技术笔记
02-24 5万+
说在前面 数据结构和算法是程序设计的灵魂。坦诚的说，我在这方面是弱的可以。虽然工作这么多年了，因为种种借口，这块知识一直是我的痛处。 曾经在面试时大言不惭的说，这些知识在工作中很少用到，所以当年学习的东西早就还给学校了。其实不然，失去了灵魂的程序员如我，总是要逆袭的。 所以以后的学习中会有一些如孩童笔记般的文章出现在我的blog中，请大师们不要嘲笑，要提携。 定义 线性表可以说是最简单的
线性表的顺序存储原理及实现
zebra_0的博客
03-22 513
帮你瞬间理解顺序表
实验一 线性表的顺序存储与实现_数据结构-链表（链表的基本实现C++）
weixin_39677203的博客
11-20 231
​线性表是最常用而且简单的一种数据结构，一个线性表是n个数据元素的有限序列。当线性表需要频繁查找，较少插入和删除时，通常采用顺序存储结构，若需要频繁插入和删除，通常采用基于链表的形式；当线性表的元素个数变化较大或不确定时，最好用链表，这样不需要考虑存储空间大小问题，当事先知道线性表的大小长度，用顺序存储结构效率会高一些。1、线性表的顺序表示和实现顺序表，基于数组的一种实现，一组地址连续的存储单元。...
线性表顺序存储结构（ArrayList底层实现原理）
各种西瓜的博客
05-11 678
public class ArrayList { private Object[] elementData; private size; //初始化空表 public ArrayList(int initalCapacity){ this.elementData = new Object[initalCapacity]; } //添加 public boole
数据结构-改进的线性查找算法（c++）实现
08-09
线性查找又称顺序查找，其基本思想位：从线性表的一端向另一端逐个将记录与给定值进行比较，若相等，则查找成功，给出该记录在表中的位置；若整个表检测完仍未找到与给定值相等的记录，则查找失败，给出失败信息。...
考研数据结构-学习笔记
05-17
综上所述，线性结构是数据结构的基础，通过对线性表、栈、队列等的理解，可以为后续更复杂的非线性结构的学习打下坚实的基础。在实际应用中，根据问题的具体需求选择合适的存储方式和操作方法至关重要。
数据结构与算法基础班------线性数据结构
04-09
数据结构与算法基础班------线性数据结构,有课件，代码，练习题，测试数据，欢迎下载！
计算机软件基础：第2章 线性数据结构-1.ppt
06-19
逻辑结构关注的是数据元素的抽象关系，如线性结构和非线性结构；存储结构涉及数据在内存中的实际布局，如顺序存储和链式存储；运算则包括检索、排序、插入、删除等基本操作。 【线性数据结构】是数据结构的一种，...
关于线性表的顺序存储和链式存储结构的实验报告
06-15
该文档饱含了数据结构课程中关于线性表的十二个基本操作的实现。对于不同的线性表的存储结构，利用C语言分别实现相应的算法
实验一 线性表的顺序存储与实现_数据结构之线性表
weixin_39634898的博客
11-23 1008
关于数据结构的绪论部分，昨日已经跟大家总结过了。有道友问关于我们进度的问题，这个数据结构书上总共有二十讲。分别是绪论，线性表三讲，栈和队列两讲，串两讲，数组和广义表两讲，树和二叉树三讲，图两讲，动态储存管理，查找，内部排序，外部排序和文件。一、线性表的逻辑结构（一）线性表的定义线性表的定义：线性表是一个具有n(n>=0)个数据元素的线性关系有限序列。元素的个数为线性表的长度，当n=0时，线性...
实验一 线性表的顺序表示与实现
uva code
09-12 3613
实验一  线性表的顺序表示与实现#include #include #include #define OVERFLOW -2 #define OK 1 #define ERROR 0 #define LIST_INIT_SIZE 1000 #define Elemtype int// typedef int Elemtype typedef struct {
线性表的顺序存储及运算的实现
Sniper-01的博客
09-21 3316
一、线性表的顺序存储 1、线性表的顺序存储原理 线性表的顺序存储（Sequential Mapping，简称顺序表），是指用一组地址连续的存储单元按线性表元素之间的逻辑顺序，依次存储线性表的数据元素。数据元素的逻辑顺序和物理上的存储顺序是完全一致的，物理上存放在位置 i 的元素，就是按照逻辑顺序存储时的第 i 个元素。因此在顺序存储结构下不需要另外建立空间来记录各个元素之间的关系。顺序存储的线性表是一种随机存取结构，因为只要确定了存储线性表的起始位置，就可以随机存取表中的任意一个数据元素。 2、顺序存储的线
线性表的顺序表示和实现
m0_74410842的博客
06-08 46
/输出当前Lc中的base数组元素和长度，屏幕应为显示：当前Lc中的元素为【2,3,3,4,5,6,6,8,9,10,11,14,17,18】,长度为14。//输出当前Lb中的base数组元素和长度，屏幕应为显示：当前Lb中的元素为【2,3,4,6,8,9,10,14,17,18】,长度为10。//为Lb赋值，里面的base数组元素赋值为【2,3,4,6,8,9,10,14,17,18】,length为10。//为La赋值，里面的base数组元素赋值为【3,5,8,11】,length为4。
数据结构实验报告：线性表顺序存储
最新发布
2401_86055263的博客
06-29 522
1．编写顺序表的插入和删除算法 2. 编写将两个顺序表合并的算法
实验一：线性表的顺序存储结构（验证性实验）
cpp_jia的专栏
03-31 1140
#include #include #include /*符号常量*/ #define ERROR 0 #define OK 1 #define EQUAL 1 #define OVERFLOW -1 #define LIST_INIT_SIZE 100 /* 线性表存储空间的初始分配量 */ #define LISTINCREMENT 10 /* 线性表存储空间的分配增量 */ s
数据结构——线性表的顺序表示与实现（顺序表）
流楚丶格念的博客
09-22 7864
文章目录线性结构的定义：线性表一、线性表的定义和特点例1 分析26 个英文字母组成的英文表例2 分析学生情况登记表顺序存储结构存在问题二、线性表的类型定义 线性结构的定义： 若结构是非空有限集，则有且仅有一个开始结点和一个终端结点，并且所有结点都最多只有一个直接前趋和一个直接后继。 可表示为：（a1 , a2 , ……, an） 线性表 线性结构表达式：（a1 , a2 , ……, an） 线性结构的特点： ① 只有一个首结点和尾结点； ② 除首尾结点外，其他结点只有一个直接前驱
数据结构-线性探测法优缺点解析
"该资源是严蔚敏教授的《数据结构》课程课件，主要讨论了线性探测法和二次探测法这两种哈希冲突解决策略，并提到了数据结构在计算机科学中的重要地位以及数据结构与算法的关系。" 线性探测法是一种解决哈希表中冲突...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值