数据结构-知识梳理1-线性表

最新推荐文章于 2024-07-19 23:15:41 发布
最新推荐文章于 2024-07-19 23:15:41 发布
阅读量262 收藏 5
点赞数 5
分类专栏： 计算机 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39894599/article/details/140191449
版权

线性表基本操作

  1. InitList(&L)：初始化表
  2. Length(L)：求表长
  3. LocateElem(L, e)：按值查找
  4. GetElem(L, i)：按位查找
  5. ListInsert(&L, i, e)：插入，i 指位置，非下标
  6. ListDelete(&L, i, &e)：删除，i 指位置，非下标
  7. PrintList(L)：输出
  8. Empty(L)：判空
  9. DestroyList(&L)：销毁

线性表顺序表示

#include <iostream>
using namespace std;

#define MaxSize 50
#define ElemType int

typedef struct {
    ElemType data[MaxSize];
    int length;
} SqList;

//初始化
void InitList(SqList &L) {
    L.length = 0;
}

// 表长
int Length(SqList L) {
    return L.length;
}

//按值查找
int LocateElem(SqList L, ElemType e) {
    int index = 0;
    for(int i = 0; i < L.length; i ++) {
        if (L.data[i] == e) {
            // 返回位序 非下标
            index = i + 1;
            break;
        }
    }
    return index;
}

// 插入操作
bool ListInsert(SqList &L, int i, ElemType e) {
    // 插入位置错误
    if(i < 1 || i > L.length + 1) {
        return false;
    }
    // 线性表已满
    if( L.length >= MaxSize ) {
        return false;
    }
    for( int j = L.length - 1; j >= i; j-- ) {
        L.data[j + 1] = L.data[j];
    }
    L.data[i - 1] = e;
    L.length ++;
    return true;
}

// 删除操作
bool ListDelete(SqList &L, int i, ElemType &e) {
    // 删除位置错误
    if( i < 1 || i > L.length ) {
        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;
}

// 打印
void PrintList(SqList L) {
    cout << "打印序列：";
    for(int i = 0; i < L.length; i++) {
        cout << L.data[i] << ' ' ;
    }
    cout << endl;
}

// 判空
bool Empty(SqList L) {
    return L.length ? true : false;
}

int main() {
    SqList sqlist;
    InitList(sqlist);

    ListInsert(sqlist, 1, 3);
    ListInsert(sqlist, 2, 23);
    PrintList(sqlist);


    ElemType e;
    ListDelete(sqlist, 2, e);
    PrintList(sqlist);
    cout << e << endl;

    return 0;
}

线性表链式表示-单链表

#include <iostream>
using namespace std;

#define ElemType int

typedef struct LNode {
    ElemType data;
    struct LNode *next;
} LNode, *LinkList;

// 初始化
bool InitList (LinkList &L) {
    L = (LNode *) malloc(sizeof (LNode));
    L -> next = NULL;
    return true;
}

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

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

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

// 按位插入
bool ListInsert(LinkList &L, int i, ElemType e) {
    LNode *p = L;
    int j = 0;
    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;
}

// 头插法建立单链表
LinkList List_HeaderInsert(LinkList &L) {
    // 头节点
    L = (LNode*)malloc(sizeof (LNode));
    L -> next = NULL;

    LNode *s;
    ElemType e;
    cin >> e;

    while(e != 9999) {
        s = (LNode *) malloc(sizeof (LNode));
        s -> data = e;
        s -> next = L -> next;
        L -> next = s;
        cin >> e;
    }
    return L;
}

// 尾插法建立单链表
LinkList List_TailInsert(LinkList &L) {
    L = (LNode *) malloc(sizeof (LNode));
    L -> next = NULL;
    LNode *p = L;

    LNode *s;
    ElemType e;
    cin >> e;
    while(e != 9999) {
        s = (LNode *) malloc(sizeof(LNode));
        s -> data = e;
        s -> next = NULL;
        p -> next = s;
        p = s;
        cin >> e;
    }
    return L;
}

// 按位删除
bool ListDelete (LinkList &L, int i, ElemType &e) {
    LNode *p = L;
    int j = 0;
    while (p != NULL && j < i - 1) {
        p = p -> next;
        j ++;
    }

    // i 值不合法
    if(p == NULL || p -> next == NULL) {
        return false;
    }

    LNode *s = p -> next;
    e = s -> data;

    p -> next = s -> next;
    free(s);

    return true;
}


// 打印
void PrintList(LinkList L) {
    cout << "打印序列：";
    while(L != NULL && L -> next != NULL) {
        L = L -> next;
        cout << L -> data << ' ';
    }
    cout << endl;
}

int main() {
    LinkList L;

    // 创建
    // List_HeaderInsert(L);
    List_TailInsert(L);

    // 打印
    PrintList(L);

    int length = Length(L);
    cout << "链表长度：" << length << endl;

    LNode *item = GetElem(L, 2);
    if (item) {
        cout << item -> data;
    }

    return 0;
}

线性表链式表示-双链表

#include <iostream>
using namespace std;

#define ElemType int

typedef struct LNode {
    ElemType data;
    struct LNode *prior;
    struct LNode *next;
} LNode, *LinkList;

// 初始化
bool InitList (LinkList &L) {
    L = (LNode *) malloc(sizeof (LNode));
    L -> prior = NULL;
    L -> next = NULL;
    return true;
}

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

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

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

// 按位插入
bool ListInsert(LinkList &L, int i, ElemType e) {
    LNode *p = L;
    int j = 0;
    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 -> prior = p;
    s -> next = p -> next;

    p -> next = s;
    if( s -> next ) {
        s -> next -> prior = s;
    }

    return true;
}

// 头插法建立双链表
LinkList List_HeaderInsert(LinkList &L) {
    // 头节点
    L = (LNode*)malloc(sizeof (LNode));
    L -> prior = NULL;
    L -> next = NULL;

    LNode *s;
    ElemType e;
    cin >> e;

    while(e != 9999) {
        s = (LNode *) malloc(sizeof (LNode));
        s -> data = e;
        s -> prior = L;
        s -> next = L -> next;
        L -> next = s;
        // 不是第一次插入
        if(s -> next) {
            s -> next -> prior = s;
        }

        cin >> e;
    }
    return L;
}

// 尾插法建立双链表
LinkList List_TailInsert(LinkList &L) {
    L = (LNode *) malloc(sizeof (LNode));
    L -> prior = NULL;
    L -> next = NULL;
    LNode *p = L;

    LNode *s;
    ElemType e;
    cin >> e;
    while(e != 9999) {
        s = (LNode *) malloc(sizeof(LNode));
        s -> data = e;
        s -> prior = p;
        s -> next = NULL;
        p -> next = s;
        p = s;
        cin >> e;
    }
    return L;
}

// 按位删除
bool ListDelete (LinkList &L, int i, ElemType &e) {
    LNode *p = L;
    int j = 0;
    while (p != NULL && j < i - 1) {
        p = p -> next;
        j ++;
    }

    // i 值不合法
    if(p == NULL || p -> next == NULL) {
        return false;
    }

    LNode *s = p -> next;
    e = s -> data;

    p -> next = s -> next;

    if( s -> next) {
        s -> next -> prior = p;
    }

    free(s);

    return true;
}


// 打印
void PrintList(LinkList L) {
    cout << "打印序列：";
    while(L != NULL && L -> next != NULL) {
        L = L -> next;
        cout << L -> data << ' ';
    }
    cout << endl;
}

int main() {
    LinkList L;

    // 创建
    List_HeaderInsert(L);
    // List_TailInsert(L);

    // 打印
    PrintList(L);

    // 删除元素
    ElemType e;
    ListDelete(L, 1, e);
    cout << "删除元素：" << e <<endl;
    PrintList(L);

    // 插入元素
    ListInsert(L, 3, 44);
    PrintList(L);


    LNode *item = GetElem(L, 3);
    if (item) {
        cout << item -> data;
    }

    return 0;
}

线性表链式表示-循环双链表

#include <iostream>
using namespace std;

#define ElemType int

typedef struct LNode {
    ElemType data;
    struct LNode *prior;
    struct LNode *next;
} LNode, *LinkList;

// 初始化
bool InitList (LinkList &L) {
    L = (LNode *) malloc(sizeof (LNode));
    L -> prior = L;
    L -> next = L;
    return true;
}

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

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

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

// 按位插入
bool ListInsert(LinkList &L, int i, ElemType e) {
    LNode *p = L;
    int j = 0;
    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 -> prior = p;
    s -> next = p -> next;
    p -> next = s;
    if( s -> next != L) {
        s -> next -> prior = s;
    }
    return true;
}

// 头插法建立循环双链表
LinkList List_HeaderInsert(LinkList &L) {
    // 头节点
    L = (LNode*)malloc(sizeof (LNode));
    L -> prior = L;
    L -> next = L;

    LNode *s;
    ElemType e;
    cin >> e;

    while(e != 9999) {
        s = (LNode *) malloc(sizeof (LNode));
        s -> data = e;
        s -> prior = L;
        s -> next = L -> next;
        L -> next = s;
        // 不是第一次插入
        if(s -> next != L) {
            s -> next -> prior = s;
        } else {
            L -> prior = s;
        }
        cin >> e;
    }
    return L;
}

// 尾插法建立循环双链表
LinkList List_TailInsert(LinkList &L) {
    L = (LNode *) malloc(sizeof (LNode));
    L -> prior = L;
    L -> next = L;
    LNode *p = L;

    LNode *s;
    ElemType e;
    cin >> e;
    while(e != 9999) {
        s = (LNode *) malloc(sizeof(LNode));
        s -> data = e;
        s -> prior = p;
        s -> next = p -> next;
        p -> next = s;
        p = s;
        L -> prior = p;
        cin >> e;
    }
    return L;
}

// 按位删除
bool ListDelete (LinkList &L, int i, ElemType &e) {
    LNode *p = L;
    int j = 0;

    while (p != NULL && j < i - 1) {
        p = p -> next;
        j ++;
    }

    // i 值不合法
    if( p == NULL || p -> next == NULL ) {
        return false;
    }

    LNode *s = p -> next;
    e = s -> data;

    p -> next = s -> next;

    if( s -> next != L) {
        s -> next -> prior = p;
    }

    free(s);

    return true;
}


// 打印
void PrintList(LinkList L) {
    LinkList p = L, q = L;
    cout << "打印序列-正向：";
    while(p != NULL && p -> next != L) {
        p = p -> next;
        cout << p -> data << ' ';
    }
    cout << endl;

    cout << "打印序列-反向：";
    while(q != NULL && q -> prior != L) {
        q = q -> prior;
        cout << q -> data << ' ';
    }
    cout << endl;
}

int main() {
    LinkList L;

    // 创建
    // List_HeaderInsert(L);
    List_TailInsert(L);

    // 打印
    PrintList(L);


    ElemType e;
    ListDelete(L, 1, e);
    cout << "删除元素：" << e <<endl;

    PrintList(L);

    // 插入元素
    ListInsert(L, 3, 44);
    PrintList(L);

    LNode *item = GetElem(L, 3);
    if (item) {
        cout << item -> data;
    }

    return 0;
}
skrey
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-线性表
qq_62063545的博客
03-23 167
3）静态链表具有链表的部分优点，如在增删结点时不需要大量移动元素，而且可以利用数组中的碎片空间，但是其不如单链表灵活，失去了顺序表随机存取的特性，总的来说，是一种妥协的数据结构，可以使用在一些不支持指针的高级语言中。7）链表排序有两种思路，一种时间复杂度为n²，即每次拿出一个结点，遍历已经完成排序的结点，找到其应在的位序，插入该结点。，因为头结点可以使所有可能涉及到首个结点的操作得到简化，如删除第一个结点，没有头结点则需要单独处理首个结点（因为首个结点是没有前驱的，普通结点都需要处理前驱，但首节点不需要）
数据结构笔记-《考研王道笔记知识点整理》
05-23
《考研王道笔记知识点整理》中的内容涵盖了数据结构的基础概念、数据结构的三要素、算法的基本概念以及线性表的定义。 1. **数据结构的基本概念**： - 数据是描述客观事物属性的符号集合，数据元素是数据的基本...
数据结构2-线性表－知识点总结与梳理
m0_55213627的博客
10-05 799
线性表线性表的基本概念 线性表的基本概念
数据结构--线性表之顺序表
touchinaiyou的博客
04-24 754
数据结构--线性表之顺序表
数据结构----线性表
weixin_43685443的博客
03-23 113
数据结构----线性表 王道考研数据结构线性表知识整理 1. 线性表特点： （1）表中元素个数有限 （2）表中元素具有逻辑上的顺序性，各元素排序有先后次序 （3）表中元素都是数据元素，每个元素都是单个元素 （4）表中元素的数据类型相同，每个元素的存储空间相同 （5）表中元素具有抽象性 （6）线性表是一种逻辑结构，表示元素之间一对一的相邻关系 2.线性表的存储结构： （1）顺序存储：把逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构 （2）链式存储：逻辑上相邻的数据元素在物理上不一定相邻，通过指针来
数据结构思维导图--图.xmind
08-21
23考研数据结构思维导图，图章节。整理知识点。小记自用。
数据结构（C语言版） 第二章 线性表 知识梳理+作业习题详解1
08-03
线性表是数据结构中的基础概念，它由若干个数据元素组成，这些元素在逻辑上具有线性关系，即每个元素要么是第一个，要么有唯一的前驱，要么是最后一个，要么有唯一的后继。线性表可以采用两种主要的存储方式：顺序...
漫话数据结构-双向链表及基本操作.pptx
11-03
数据结构是计算机科学中的核心概念，它涉及到如何高效地组织和管理数据，以便于执行各种操作。...这些知识对于理解和掌握数据结构的基础至关重要，同时也是提升编程技能和解决实际问题能力的重要组成部分。
数据结构复习知识点总结笔记
10-01
这里面大致整理了作者本科课程《数据结构》的知识点，内容源自老师上课时的PPT。 其中分章节自线性表到查找排序，对可能出现的考点，综合《王道考研数据结构》习题书进行了分析和总结。 同时对常考点和冷考点进行了...
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1055
如有错误，欢迎指出~
数据结构第32节 无锁编程
hummhumm的专栏
07-17 835
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
常见排序算法总结
mydaily_的博客
07-16 825
大概是因为插入排序没预处理，极端情况可能让一个很小很右的数一直比比比比比，比到最开头，浪费比较次数。某种情况比计数排序好，因为数字，如果按照普通十进制理解，则只需准备10个不同数字的桶就好了！整体的quickSort函数swap后，再进行partition，划分三部分后，所以这种不基于比较的算法应用范围很局限，大部分情况下，不如之前的所有比较算法！前提得知道空间范围，比如人的年龄，正数[0-200]，否则内存爆炸！间隔分组，且分组间隔依次减半，每次分组后，每个组内排序都是插入排序。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1888
栈超超超详解
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 233
1%29%5D。
数据结构——栈
weixin_45942515的博客
07-19 206
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
《数据结构》预备
最新发布
U2396573637的博客
07-19 517
位段的声明和结构体是类似的，有两个不同：1.位段的成员必须是int、unsigned int、 signed int，在C99中位段成员也可以选择其它类型。2.位段的成员后边有一个冒号和一个数字。int _b:5;int _c:10;int _d:30;A就是一个位段类型。那位段A所占内存的大小是多少呢？
数据结构(4.4)——求next数组
m0_65240792的博客
07-14 376
next[1]都无脑写0next[2]都无脑写1其他next:在不匹配的位置前边，划一条分界线，模式串一步一步往后退，直到分界线之前"能对上"，或模式串能完全跨过分界线为止，此时j指向哪儿，next数组值就是多少ababaa的next数组//求next[1]??????->??????/i=1->i=2ababaa-> ababaa //j=0,第一个字符匹配失败，只能匹配下一个子串，++i，++jnext[1]=0;//求next[2]a?????->a??????//i=2。
数据结构初阶（C语言）-顺序表
xiuwoaiailixiya的博客
07-15 1044
在进行顺序表的介绍之前，我们先来了解下什么是线性表：线性表是n个具有相同特性的数据元素的有限序列。线性表是⼀种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，也就说是连续的⼀条直线。但是在物理结构上并不⼀定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储。
"C语言版数据结构第二章：线性表知识梳理及作业详解
本篇文章主要总结了《数据结构（C语言版）》中第二章线性表的知识，包括线性表的顺序存储结构和链式存储结构，以及常见的操作和应用场景。 文章首先通过一个样例引入了线性表的概念和应用场景，即多项式相加。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值