【数据结构】Liner-List 线性表（更新时间：2016-04-06）

最新推荐文章于 2022-04-17 14:52:46 发布
最新推荐文章于 2022-04-17 14:52:46 发布
阅读量804 收藏 1
点赞数 1
分类专栏： 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pjzck/article/details/51076006
版权

【数据结构】Liner-List 线性表（更新时间：2016-04-06）

趁着室友刚刚开始学习数据结构，赶紧配合着他的进度来写关于数据结构的相关内容
博文中的代码均使用C++语法，部分代码（主要是函数重载等）无法在C语言环境下编译

线性表 是最简单、最基本也是最常用的数据结构，它是以数组为基础定义的使得所需要的 元素 和 存储空间 一一对应的一种数据结构，即每一个存储元素都对应于一个特定的存储位置。

常见的线性表是用数组来存储，也就是我们常说的顺序存储：

struct ListNode;                        //定义线性表表头节点
typedef ListNode* PtrToNode;            //定义线性表表头指针
typedef PtrToNode LinerList;            //重定义表头指针
typedef int ElementType;                //重定义数据类型
struct ListNode                         //数据结构描述
{       
    int capacity;                       //表的容量 
    int tail;                           //指向当前表的尾部
    ElementType* Element;               //数据域
};
const int MAX_CAP = 100;                //初始容量

示意图：

线性存储链表示意图

基础操作

初始化

将线性表初始化，通过指针操作，将表头地址传入初始化函数，并以指针的形式返回表头。初始化表的容量以及表的尾指针。

LinerList Initial( void )                                                           //表的初始化
{
    LinerList L = NULL;

    L = ( LinerList ) malloc ( sizeof(ListNode) );                                  //分配表头地址
    L->capacity = MAX_CAP;                                                          //初始化数值域空间
    L->tail = 0;                                                                    //表尾部指针指向表头
    L->Element = ( ElementType* ) malloc( L->capacity * sizeof( ElementType ) );    //分配数值域地址
    return L;                                                                       //返回表头
}
删除表

将整个线性表删除，表头置为空指针

void Delete( LinerList L )                                                          //表的删除
{
    if( L != NULL )
    {
        free( L->Element );                                                         //释放数值域空间
        free( L );                                                                  //释放表头
        L = NULL;                                                                   //表头置空
    }
}
扩充表

在我们向线性表中插入数据的时候，由于线性表的有限性，会出现线性表容量溢出的情况，在这种情况下，我们可以使用realloc函数来达到重新分配数值空间的目的。

LinerList Expansion( LinerList L )                                                  //表的扩容
{
    L->capacity++;                                                                  //容量扩充
    L->Element = ( ElementType* ) realloc ( L->Element, L->capacity * sizeof( ElementType ) );  //重分配数据空间
}
查找

对于线性表，我们经常需要查询其中是否存在某特定的元素。

int Find( const LinerList L, const ElementType X )                                  //查找元素
{
    int pos = 0;                                                                    //游标初始化

    while( L->Element[pos] != X && pos < L->tail )                                  //游标遍历搜索
        pos++;
    if( pos != L->tail )                                                            //如果找到返回pos
        return pos;
    else
        return 0;
}
插入元素

对于线性表的插入主要分为简单插入和定点插入两种(使用函数重载来进行插入类别的判断)：
简单插入 是指直接在表的尾部插入元素，如果表已满，则对表进行扩容。

LinerList Insert( LinerList L, const ElementType X )                                //简单插入
{
    if( L->tail == L->capacity )                                                    //判断是否过载
        Expansion( L );                                                             //扩容
    L->Element[ L->tail++ ] = X;                                                    //插入
    return L;                                                                       //返回表头
}

定点插入 是指插入位置与表的容量和表尾的相对状况进行插入，当插入位置在表尾内，则插入元素，如果插入位置非法，则返回原表。

LinerList Insert( LinerList L, const ElementType X, const int Pos )                 //定点插入
{
    int p = L->tail;                                                                //游标指向表尾

    if( Pos > L->tail )                                                             //判断插入位置合法性
    {
        cout << "Wrong insert position!\n";
        return L;
    }
    if( L->tail == L->capacity )                                                    //判断是否过载
    {
        Expansion( L );
        L->tail++;
    }
    for( ; p > Pos; p-- )                                                           //将数值逐个后移
        L->Element[p+1] = L->Element[p];
    L->Element[p] = X;                                                              //插入
}
删除元素

在线性表的使用过程中，除了插入一些元素之外，我们还需要删除一些元素。删除顺序线性表的方法是使用后面的元素填充到前面的元素之中。插入也分为简单删除和定点删除。由于代码中的Element类型为int，故暂时无法使用函数重载来在同一个代码区实现。
简单删除 调用代码中的Find函数来查找所要删除的元素是否出现在表中，如果出现则删除。

LinerList Delete( LinerList L, const ElementType X )                                //简单删除
{
    int pos = Find( L, X );                                                         //游标初始化

    if( !pos )                                                                      //未找到指定元素
    {
        cout << X << " is not found in the LinerList!\n";
        return L;
    }
    else
    {
        L->tail--;                                                                  //尾表前移
        while( pos < L->tail )                                                      //元素逐个前移
            L->Element[pos] = L->Element[pos+1];
        return L;
    }
}

定点删除 同定点插入。

LinerList Delete( LinerList L, const int Pos )                                      //定点删除
{
    int p = Pos;

    if( Pos > L->tail || Pos < 0 )                                                  //判断是否越界
    {
        cout << "Wrong deletion postion!\n";
        return L;
    }
    L->tail--;                                                                      //尾标前移
    while( p < L->tail )                                                            //元素逐个前移
        L->Element[p] = L->Element[p+1];
    return L;
}
打印表

在使用线性表的时候我们会需要将表格打印出来，在这里简单示例用空格隔开每个元素。

void Print( const LinerList L )                                                     //打印表
{
    int pos = 0;                                                                    //游标初始化

    if( L == NULL )
    {
        cout << "Empty List!\n";
        return;
    }
    while( pos < L->tail )
    {
        cout << L->Element[pos] << ' ';                                             //打印元素并添加空格
        pos++;
    }
    cout << endl;                                                                   //输出换行
}

代码示例

注：其中的一个删除元素的函数被注释掉了，不体现实际功能

#include <cstdio>
#include <cstdlib>
#include <iostream>

using namespace std;
/*********************************************************/
struct ListNode;                        //定义线性表表头节点
typedef ListNode* PtrToNode;            //定义线性表表头指针
typedef PtrToNode LinerList;            //重定义表头指针
typedef int ElementType;                //重定义数据类型
struct ListNode                         //数据结构描述
{       
    int capacity;                       //表的容量 
    int tail;                           //指向当前表的尾部
    ElementType* Element;               //数据域
};
const int MAX_CAP = 100;                //初始容量
/*********************************************************/
void        Delete( LinerList L );                                      //表的删除
LinerList   Initial( void );                                            //表的初始化
LinerList   Expansion( LinerList L );                                   //表的扩充
int         Find( const LinerList L, const ElementType X );             //查找元素
LinerList   Insert( LinerList L, const ElementType X );                 //简单插入
LinerList   Insert( LinerList L, const ElementType X, const int Pos );  //定点插入
LinerList   Delete( LinerList L, const ElementType X );                 //简单删除
LinerList   Delete( LinerList L, const int Pos );                       //定点删除
void        Print( const LinerList L );                                 //打印表
/*********************************************************/
int main()
{
    LinerList L;
    ElementType X;
    int i;

    L = Initial();
    for( i = 0; i < MAX_CAP-1; i++ )
        Insert( L, i );
    Insert( L, 99 );
    Insert( L, 100, 100 );
    Print( L );
    Insert( L, 101, 102 );
    Delete( L, 103 );
    Delete( L );
}
/*********************************************************/
void Delete( LinerList L )                                                          //表的删除
{
    free( L->Element );                                                             //释放表的数值域空间
    free( L );                                                                      //释放表头
    L = NULL;                                                                       //表头置空
}

LinerList Initial( void )                                                           //表的初始化
{
    LinerList L = NULL;

    L = ( LinerList ) malloc ( sizeof(ListNode) );                                  //分配表头地址
    L->capacity = MAX_CAP;                                                          //初始化数值域空间
    L->tail = 0;                                                                    //表尾部指针指向表头
    L->Element = ( ElementType* ) malloc( L->capacity * sizeof( ElementType ) );    //分配数值域地址
    return L;                                                                       //返回表头
}

LinerList Expansion( LinerList L )                                                  //表的扩容
{
    L->capacity++;                                                                  //容量扩充
    L->Element = ( ElementType* ) realloc ( L->Element, L->capacity * sizeof( ElementType ) );  //重分配数据空间
}

int Find( const LinerList L, const ElementType X )                                  //查找元素
{
    int pos = 0;                                                                    //游标初始化

    while( L->Element[pos] != X && pos < L->tail )                                  //游标遍历搜索
        pos++;
    if( pos != L->tail )                                                            //如果找到则返回pos
        return pos;
    else
        return 0;
}

LinerList Insert( LinerList L, const ElementType X )                                //简单插入
{
    if( L->tail == L->capacity )                                                    //判断是否过载
        Expansion( L );                                                             //扩容
    L->Element[ L->tail++ ] = X;                                                    //插入
    return L;                                                                       //返回表头
}

LinerList Insert( LinerList L, const ElementType X, const int Pos )                 //定点插入
{
    int p = L->tail;                                                                //游标指向表尾

    if( Pos > L->tail )                                                             //判断插入位置合法性
    {
        cout << "Wrong insert position!\n";
        return L;
    }
    if( L->tail == L->capacity )                                                    //判断是否过载
    {
        Expansion( L );
        L->tail++;
    }
    for( ; p > Pos; p-- )                                                           //将数值逐个后移
        L->Element[p+1] = L->Element[p];
    L->Element[p] = X;                                                              //插入
}

LinerList Delete( LinerList L, const ElementType X )                                //简单删除
{
    int pos = Find( L, X );                                                         //游标初始化

    if( !pos )                                                                      //未找到指定元素
    {
        cout << X << " is not found in the LinerList!\n";
        return L;
    }
    else
    {
        L->tail--;                                                                  //尾表前移
        while( pos < L->tail )                                                      //元素逐个前移
            L->Element[pos] = L->Element[pos+1];
        return L;
    }
}
/*
LinerList Delete( LinerList L, const int Pos )                                      //定点删除
{
    int p = Pos;

    if( Pos > L->tail || Pos < 0 )                                                  //判断是否越界
    {
        cout << "Wrong deletion postion!\n";
        return L;
    }
    L->tail--;                                                                      //尾标前移
    while( p < L->tail )                                                            //元素逐个前移
        L->Element[p] = L->Element[p+1];
    return L;
}
*/
void Print( const LinerList L )                                                     //打印表
{
    int pos = 0;                                                                    //游标初始化

    if( L == NULL )
    {
        cout << "Empty List!\n";
        return;
    }
    while( pos < L->tail )
    {
        cout << L->Element[pos] << ' ';                                             //打印元素并添加空格
        pos++;
    }
    cout << endl;                                                                   //输出换行
}
KuroNeko黑猫
关注
专栏目录
DS----线性表（顺序表和链表）更新
weixin_45302844的博客
06-02 226
线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 我们要学会这两个数据结构对于数据的存放以及增删查改 顺序表 静态顺序表 #define N 100 typedef struct SeqList{ int arr[N];//存放元素的数组 s
c2.LinerList(SeqList)
SIYIY的博客
12-03 261
c2.LinerList(SeqList)
线性表的更新，查找，遍历
04-11
包含头文件，实现文件，测试文件 {//多项式的项 public: int coef;//多项式的系数 int exp;//多项式的指数 term(int c=0,int e=0):coef(c),exp(e){}; }; class PolyArith
线性表List
weixin_30341735的博客
03-09 82
数组array是基本的数据结构，但它的功能有限，线性表list可以认为是扩展了功能的数组。可以自动调整大小。添加和删除元素不需要其他元素移位。 根据指针数量和指向的不同，线性表分为单向链表、双向链表和循环链表。 一、单向链表 单项链表有一个头指针，指向链表的第一个元素，除最后一个元素外，其它元素都有一个指针指向其后的元素。如图： 这种结构简单有效，可以非常方便的对链表进行遍历、查询、添...
线性表（List）
yzcwansui的博客
06-14 338
线性表 线性表的抽象定义： 线性表是 - 具有相同类型的 - 0≤n≤N0≤n≤N0 \leq n\leq N - 有限 序列 线性表性质： - a0a0a_{0} （线性表的第一个元素），只有一个后继 - an−1an−1a_{n-1} （线性表最后一个元素），只有一个前驱 - 除a0a0a_{0} 和an−1an−1a_{n-1} 外，其他元素aiaia_...
one-liner-joke:一个简单的节点模块，可以随机提供一个或来自特定标签的笑话
05-07
npm install one-liner-joke --save 用法 var oneLinerJoke = require('one-liner-joke'); /* The variable getRandomJoke will contain a random joke with a format: {"body":"Artificial intelligence is no ...
程序员考试刷题-Bash-Oneliner-by-onceupon:Bash-Oneliner-by-onceupon
07-07
程序员考试刷题Bash-Oneliner 我很高兴你在这里！ 几年前我从事生物信息学工作，对那些比我枯燥的脚本快得多的单字 bash 命令感到惊讶，通过学习命令行快捷方式和脚本编写节省了时间。 最近几年我在研究云计算，我...
commit-msg-linter:git commit消息linter钩子
05-03
欢迎来到git-commit-msg-linter :waving_hand: :eyes: 立即查看您的每条git commit消息 :rocket: 。 一个git“ commit-msg”挂钩，用于根据流行的来替换您的git commit消息。 作为一个挂钩，它将在每次提交时运行...
数据结构之线性表（linear_list）一
当凌绝顶,俯瞰天下
10-24 1063
线性结构的特点（非空   有限   集合）： 1、存在唯一一个头元素； 2、存在唯一一个尾元素； 3、除头元素外，每个元素都有唯一前驱； 4、除尾元素外，每个元素都有唯一后继； 线性表中数据元素的组成：若干个数据项，此种情况下，通常把线性表称为记录；含有大量记录的线性表称为文件。 注意：同一线性表中的元素必定具有相同特性（组成、顺序），相邻元素间有序偶关系。序偶
webcrypto-liner:webcrypto-liner是一个polyfill，它使低级用户代理（如IEEdge）使用依赖于WebCrypto的库。 （关键字
05-07
webcrypto-liner是webcrypto-liner的包装程序，旨在解决这些问题，同时将其设计为模块化的，以便将来还可用于测试向WebCrypto添加新算法。 尽管有意使用webcrypto-liner确实使用了加密库，但它并未实现任何加密。 ...
线性表(Linear List)
Edgar_LQS的博客
04-17 1116
线性表(Linear List)
线性表（list）
现实派理想主义的博客
07-29 616
线性表的逻辑特性 只有一个表头元素，只有一个表尾元素，表头元素没有前驱，表尾元素没有后继，除表头和表尾元素之外，其他元素只有一个直接前驱，也只有一个直接后继。 线性表的存储结构 顺序存储结构（称为顺序表）和链式存储结构（称为链表） 顺序表——1）随机访问特性；2）要求占用连续的存储空间。 链表——1）不支持随机访问；2）链表中结点的存储空间利用率较顺序表稍低一些；3）支持存储空间的动态分...
线性表(list)
Tracy Mcgrady的专栏
03-28 1716
线性表(list) 一、线性表定义 线性表是0或多个元素组成的有序序列，若将线性表记为：(a1, ..., ai-1, ai, ai+i, ..., an)，则称ai-1是ai的直接前驱元素，ai+1为ai的直接后继元素，当i=1, 2, ..., n-1时，ai有且只有一个直接后继元素，当i=2, 3, ..., n时，ai有且只有一个直接前驱元素。线性表中元素的个数n(n>=0)定义为线性
利用线性表进行UPDATE操作
eastlift的专栏
05-12 2336
public void updateChannel(Channel channel) throws Exception ...{        //构造一线性表,然后将数据库字段的名称逐一加入该线性表        List colums = new ArrayList() ;        colums.add("channel_name") ;        colums.add("cha
MyLinerList
qq_44834369的博客
04-17 97
线性表Java实现 顺序表 MyArrayList.java package MYLINERLIST; /** * **************************** * * 顺序表 * * **************************** * */ import java.util.Iterator; import java.util.NoSuchElementException; public class MyA
《数据结构》——第二章 线性表（Linear List）
weixin_41969113的博客
07-18 281
学习目标 理解线性表的逻辑结构 顺序表和链表之间的优缺点 线性表 定义 线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列。 重点： 必须是具有相同的数据类型 且得有限 还得是序列 线性表特点： 表中元素个数有限。 表中元素具有逻辑上得顺序性，表中的元素有其先后次序。 表中元素都是数据元素，每个元素都是单个元素。 表中元素的数据类型都相同，这意味着每个元素占有相同大小的存储空间。 线性表基本操作: InitList(&L) ：初始化表 Length(L) ：求.
fit-a-liner-数据集
03-27
标题“fit-a-liner-数据集”提示我们关注的是一个与数据分析或机器学习相关的数据集，其中可能包含用于训练模型的数据。"fit-a-liner"可能是对“fit a linear model”（拟合线性模型）的简写，暗示这个数据集可能被...
线性表——List（集合）
linsa_pursuer的博客
10-12 526
  1.List集合的特点是：可重复，并且有序。List提供了一组独有的方法，特点都是可以通过下标操作元素。   list.add(1,"2"); list.remove(2);   package day08; import java.util.ArrayList; import java.util.List; /** * java.util.List * List是Coll...
数据结构-线性表（List）1
u_geek的博客
09-28 463
线性表（list）：零个或多个元素（相同的数据类型）的有限序列（有先后顺序）。 线性表的基本操作： 线性表的基本操作： Operation： 返回值： InitList(*L) 建立一个空的线性表 ListEmpty(L)
动态链表类linearList
陈风的博客
04-09 481
对类的要求： 定义一个由int型元素所构成的动态链表类LinearList，成员函数包括： bool insert(int x, int pos); //在位置pos之后插入一个元素x； //pos为0时，在第一个元素之前插入。 //操作成功时返回true，否则返回false。 bool remove(int &amp;x, int pos); //删除位置pos处的元素。 //操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值