嵌入式学习——数据结构（单向无头链表）——day46

已于 2024-06-22 16:25:02 修改
阅读量257 收藏 5
点赞数 2
文章标签： 数据结构 学习 链表 c语言 开发语言
于 2024-06-17 10:41:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47798402/article/details/139732055
版权

1. 数据结构

1.1 定义

        数据结构是指计算机中数据的组织、管理和存储方式。它不仅包括数据元素的存储方式，还包括数据元素之间的关系，以及对数据进行操作的方法和算法。数据结构的选择和设计直接影响算法的效率和程序的性能，是计算机科学与编程中非常重要的基础

1.2 数据结构的分类

（1）逻辑角度

        1. 线性结构（一对一）数组、链表、队列、栈

        2. 树型结构（一对多）二叉树

        3. 图形结构（多对多）网状结构

（2）存储角度

        1. 顺序存储：采用一段连续的内存空间保存元素（数组）

                        优点：空间连续，访问方便

                        缺点：插入删除需要移动大量元素、需要预分配内存空间，容易造成存储空间碎片

        2. 链式存储：采用一组非连续的内存空间保存元素（链表）

                        优点：插入和删除数据方便、不需要预分配内存

                        缺点：访问元素效率低

        3. 散列存储（哈希存储）将数据元素的存储位置与关键码之间建立确定对应关系从而实现查找的存储方式

        4. 索引存储：通过关键字构建索引表、通过索引表来找到数据的存储位置

补充：

        1. 重点学习内容

        顺序表、链式表、顺序栈、链式栈、顺序队列、链式队列、二叉树、哈希表

        2. 程序  =  数据结构 + 算法 

2. 分析算法效率的两个指标

2.1 时间复杂度

        是指算法在执行过程中所需时间的量度。它衡量的是算法的执行时间随输入规模的变化情况，通常用大O记号表示，如O(n)、O(log n)等

2.2 空间复杂度

        是指算法在执行过程中所需存储空间的量度。它衡量的是算法的内存使用情况，通常也用大O记号表示。

3.无头单向链表代码

3.1 makefile

OBJ:=seqlist
OBJS+=SeqList.c
CC:=gcc 

$(OBJ):$(OBJS)
	$(CC) $^ -o $@
.PHONY:
clean:
	rm $(OBJ)
test:
	valgrind --tool=memcheck --leak-check=full ./$(OBJ)

3.2 头文件

#ifndef _LINKLIST_H_
#define _LINKLIST_H_

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef int DataType;

typedef struct node
{
    DataType Data;
    struct node *pNext;
}LinkNode;

typedef struct list
{
    LinkNode *pHead;
    int cLen;
}LinkList;

extern LinkList *create_LinkList(void);
extern int is_empty_link(LinkList *pTmpList);
extern int push_head_link(LinkList *pTmpList, DataType Data);//头插、空链表也能使用
extern int push_tail_link(LinkList *pTmpList, DataType Data);//尾插、空链表也能使用
extern void link_for_each(LinkList *pTmpList);
extern int pop_head_link(LinkList *pTmpList);
extern int pop_tail_link(LinkList *pTmpList);
extern LinkNode *find_data(LinkList *pTmpList, DataType Data);
extern int modify_data(LinkList *pTmpList, DataType old_data, DataType new_data);
extern void destory_link(LinkList *pTmpList);
extern LinkNode *find_mid_node(LinkList *pTmpList);//找中间节点
extern LinkNode *find_last_k_node(LinkList *pList, int k);//寻找倒数第k个节点
extern int pop_data_link(LinkList *pTmpList, DataType Data);//删除数据为key的节点
extern void invert_link(LinkList *pTmpList);
extern void insert_sort_link(LinkList *pTmpList);

#endif

3.3 主函数

#include "LinkList.h"

LinkList *create_LinkList(void)//创建空链表
{
    LinkList *pList = NULL;

    pList = malloc(sizeof(LinkList));
    if (NULL == pList)
    {
        perror("fail to malloc");
        return NULL;
    }

    pList->pHead = NULL;
    pList->cLen = 0;

    return pList;
}

int is_empty_link(LinkList *pTmpList)//判断链表是否为空链表
{
    if (NULL == pTmpList->pHead)
    {
        return 1;
    }

    return 0;
}

int push_head_link(LinkList *pTmpList, DataType Data)//头插、空链表也能使用
{
    LinkNode *pTmpNode = NULL;

    pTmpNode = malloc(sizeof(LinkNode));
    if (NULL == pTmpNode)
    {
        perror("fail to malloc");
        return -1;
    }

    pTmpNode->pNext = NULL;//插入节点初始化
    pTmpNode->Data = Data;
    
    pTmpNode->pNext = pTmpList->pHead;
    pTmpList->pHead = pTmpNode;
    pTmpList->cLen++;

    return 0;
}

int push_tail_link(LinkList *pTmpList, DataType Data)//尾插、空链表也能使用
{
    LinkNode *pTmpNode = NULL;
    LinkNode *pLastNode = NULL;

    pTmpNode = malloc(sizeof(LinkNode));
    if (NULL == pTmpNode)
    {
        perror("fail to malloc");
        return -1;
    }

    pTmpNode->pNext = NULL;
    pTmpNode->Data = Data;
    
    if (is_empty_link(pTmpList))
    {
        pTmpList->pHead = pTmpNode;
    }
    else 
    {
        pLastNode = pTmpList->pHead;
        while (pLastNode->pNext != NULL)
        {
            pLastNode = pLastNode->pNext;
        }
        pLastNode->pNext = pTmpNode;
    }
    pTmpList->cLen++;

    return 0;
}

void link_for_each(LinkList *pTmpList)//遍历输出链表
{
    LinkNode *pTmpNode = NULL;

    pTmpNode = pTmpList->pHead;
    while (pTmpNode != NULL)
    {
        printf("%d ", pTmpNode->Data);
        pTmpNode = pTmpNode->pNext;
    }
    putchar('\n');
}

int pop_head_link(LinkList *pTmpList)//头删
{
    if (is_empty_link(pTmpList))
    {
        return -1;
    }

    LinkNode *pTmpNode = NULL;

    pTmpNode = pTmpList->pHead;
    pTmpList->pHead = pTmpNode->pNext;
    free(pTmpNode);
    pTmpList->cLen--;
    
    return 0;
}

int pop_tail_link(LinkList *pTmpList)//尾删
{
    if (is_empty_link(pTmpList))
    {
        return -1;
    }
    if (1 == pTmpList->cLen)
    {
        pop_head_link(pTmpList);
    }
    else
    {
        LinkNode *pTmpNode = NULL;

        pTmpNode = pTmpList->pHead;
        while (pTmpNode->pNext->pNext != NULL)
        {
            pTmpNode = pTmpNode->pNext;
        }
        free(pTmpNode->pNext);
        pTmpNode->pNext = NULL;
        pTmpList->cLen--;
    }
    
    return 0;
}

LinkNode *find_data(LinkList *pTmpList, DataType Data)//在链表中寻找数据
{
    LinkNode *pTmpNode = NULL;

    pTmpNode = pTmpList->pHead;

    while (pTmpNode)
    {
        if (Data == pTmpNode->Data)
        {
            return pTmpNode;
        }
        pTmpNode = pTmpNode->pNext;
    }

    return NULL;
}

int modify_data(LinkList *pTmpList, DataType old_data, DataType new_data)//修改数据
{
    LinkNode *pTmpNode = NULL;

    pTmpNode = find_data(pTmpList, old_data);
    if (pTmpNode != NULL)
    {
        pTmpNode->Data = new_data;
        return 0;
    }
    else 
    {
        return -1;
    }
}

void destory_link(LinkList *pTmpList)//销毁链表
{
    while (!is_empty_link(pTmpList))
    {
        pop_head_link(pTmpList);
    }
    free(pTmpList);
}

LinkNode *find_mid_node(LinkList *pTmpList)//找中间节点
{
    LinkNode *pSlowNode = NULL;
    LinkNode *pFastNode = NULL;

    pFastNode = pTmpList->pHead;
    pSlowNode = pFastNode;

    while (pFastNode != NULL)
    {
        pFastNode = pFastNode->pNext;
        if (NULL == pFastNode)
        {
            break;
        }
        pFastNode = pFastNode->pNext;//pFastNode 速度是 pSlowNode的两倍
        pSlowNode = pSlowNode->pNext;
    }

    return pSlowNode;
}

LinkNode *find_last_k_node(LinkList *pTmpList, int k)//寻找倒数第k个节点
{
    LinkNode *pFastNode = NULL;
    LinkNode *pSlowNode = NULL;
    int i = 0;

    pFastNode = pTmpList->pHead;
    pSlowNode = pFastNode;

    for (i = 0; i < k; i++)//快慢指针相差k个位置
    {
        if (NULL == pFastNode)
        {
            return NULL;
        }
        pFastNode = pFastNode->pNext;
    }

    while (pFastNode != NULL)
    {
        pFastNode = pFastNode->pNext;
        pSlowNode = pSlowNode->pNext;
    }

    return pSlowNode;
}

int pop_data_link(LinkList *pTmpList, DataType Data)//删除数据为key的节点
{
    if (is_empty_link(pTmpList))
    {
        return 1;
    }

    LinkNode *pTmpNode = NULL;
    LinkNode *pPreNode = NULL;

    pTmpNode = pTmpList->pHead;
    while (pTmpNode != NULL)
    {
        if (Data == pTmpNode->Data)//找到数据
        {
            if (pTmpNode == pTmpList->pHead)//判断是否只有头结点
            {
                pTmpList->pHead = pTmpNode->pNext;
                free(pTmpNode);
                pTmpNode = pTmpList->pHead;
            }
            else
            {
                pPreNode->pNext = pTmpNode->pNext;
                free(pTmpNode);
                pTmpNode = pPreNode->pNext;
            }
            pTmpList->cLen--;
        }
        else
        {
            pPreNode = pTmpNode;
            pTmpNode = pTmpNode->pNext;
        }
    }
}

void invert_link(LinkList *pTmpList)//链表的倒置
{
    LinkNode *pTmpNode = NULL;
    LinkNode *pInsertNode = NULL;

    pTmpNode = pTmpList->pHead;
    pTmpList->pHead = NULL;
    
    while (pTmpNode != NULL)
    {
        pInsertNode = pTmpNode;
        pTmpNode = pTmpNode->pNext;

        pInsertNode->pNext = pTmpList->pHead;
        pTmpList->pHead = pInsertNode;
    }
}

void  insert_sort_link(LinkList *pTmpList)
{
    if (is_empty_link(pTmpList) || NULL == pTmpList->pHead->pNext)//空链表或者只有一个节点，不用排序
    {
        return ;
    }

    LinkNode *pTmpNode = NULL;//记录剩余节点的起始位置
    LinkNode *pInsertNode = NULL;//插入节点的位置
    LinkNode *p = NULL;//插入排序中遍历已经插入的节点的指针

    pTmpNode = pTmpList->pHead->pNext;//第一个节点不排序，从第二个节点开始排序
    pTmpList->pHead->pNext = NULL;//从原链表的第一个节点之后断开

    while (pTmpNode != NULL)//判断剩余未排序节点是否存在，最后一个节点参与操作
    {
        pInsertNode = pTmpNode;
        pTmpNode = pTmpNode->pNext;

        if (pInsertNode->Data <= pTmpList->pHead->Data)//判断要插入节点数据的大小是否小于第一个节点的数据
        {
            pInsertNode->pNext = pTmpList->pHead;//头插
            pTmpList->pHead = pInsertNode;
        }
        else //往后插
        {
            p = pTmpList->pHead;
            while (p->pNext != NULL && p->pNext->Data < pInsertNode->Data)
            {
                p = p->pNext;
            }

            pInsertNode->pNext = p->pNext;
            p->pNext = pInsertNode;
        }
    }
}

int main(void)
{
    LinkList *pList = NULL;
    LinkNode *pTmpNode = NULL;
    
    pList = create_LinkList();//创建
    if (NULL == pList)
    {
        return -1;
    }
#if 0
    push_head_link(pList, 3);//头插
    push_head_link(pList, 2);
    push_head_link(pList, 1);
    link_for_each(pList);
#endif
    push_tail_link(pList, 1);//尾插
    push_tail_link(pList, 2);
    push_tail_link(pList, 3);
    push_tail_link(pList, 4);
    push_tail_link(pList, 5);
    push_tail_link(pList, 6);
    push_tail_link(pList, 7);
    link_for_each(pList);
#if 0
    pop_head_link(pList);//头删
    link_for_each(pList);

    pop_tail_link(pList);//尾删
    link_for_each(pList);
#endif
    pTmpNode = find_data(pList, 4);//找数据
    if (NULL != pTmpNode)
    {
        printf("find node data = %d\n", pTmpNode->Data);
    }
    else
    {
        printf("not find this node\n");
    }

    modify_data(pList, 2, 20);//修改数据
    modify_data(pList, 3, 30);
    modify_data(pList, 4, 40);
    modify_data(pList, 5, 50);
    link_for_each(pList);

    pTmpNode = find_mid_node(pList);//找链表中间节点
    if (pTmpNode != NULL)
    {
        printf("Mid node data = %d\n", pTmpNode->Data);
    }
    link_for_each(pList);

    pTmpNode = find_last_k_node(pList, 5);//寻找链表倒数第k个节点
    if (pTmpNode != NULL)
    {
        printf("last node data = %d\n", pTmpNode->Data);
    }

    link_for_each(pList);
    pop_data_link(pList, 30);//删除链表数据
    link_for_each(pList);

    invert_link(pList);//链表倒置
    link_for_each(pList);

    insert_sort_link(pList);
    link_for_each(pList);
    

    destory_link(pList);//销毁链表
    
    return 0;
}

4. 快慢双指针解决链表问题

4.1 寻找中间节点——（后面的指针前进速度是前面指针的一半）

LinkNode *find_mid_node(LinkList *pTmpList)//找中间节点
{
    LinkNode *pSlowNode = NULL;
    LinkNode *pFastNode = NULL;

    pFastNode = pTmpList->pHead;
    pSlowNode = pFastNode;
    
    while (pFastNode != NULL)//要操作pFastNod
    {
        pFastNode = pFastNode->pNext;
        if (NULL == pFastNode)
        {
            break;
        }
        pFastNode = pFastNode->pNext;//pFastNode 速度是 pSlowNode的两倍
        pSlowNode = pSlowNode->pNext;
    }

    return pSlowNode;
}

4.2 寻找倒数第k个节点——（两指针相差k）

LinkNode *find_last_k_node(LinkList *pTmpList, int k)//寻找倒数第k个节点
{
    LinkNode *pFastNode = NULL;
    LinkNode *pSlowNode = NULL;
    int i = 0;

    pFastNode = pTmpList->pHead;
    pSlowNode = pFastNode;

    for (i = 0; i < k; i++)//快慢指针相差k个位置
    {
        if (NULL == pFastNode)//节点数不足k程序直接结束
        {
            return NULL;
        }
        pFastNode = pFastNode->pNext;
    }

    while (pFastNode != NULL)
    {
        pFastNode = pFastNode->pNext;
        pSlowNode = pSlowNode->pNext;
    }

    return pSlowNode;
}

4.3 删除数据为key的节点

int pop_data_link(LinkList *pTmpList, DataType Data)//删除数据为key的节点
{
    if (is_empty_link(pTmpList))
    {
        return -1;
    }

    LinkNode *pTmpNode = NULL;
    LinkNode *pPreNode = NULL;

    pTmpNode = pTmpList->pHead;
    while (pTmpNode != NULL)
    {
        if (Data == pTmpNode->Data)//找到数据
        {
            if (pTmpNode == pTmpList->pHead)//判断是否只有头结点
            {
                pTmpList->pHead = pTmpNode->pNext;
                free(pTmpNode);
                pTmpNode = pTmpList->pHead;
            }
            else
            {
                pPreNode->pNext = pTmpNode->pNext;
                free(pTmpNode);
                pTmpNode = pPreNode->pNext;
            }
            pTmpList->cLen--;
        }
        else
        {
            pPreNode = pTmpNode;
            pTmpNode = pTmpNode->pNext;
        }
    }
}

5. 单向链表算法

5.1 链表的倒置

void invert_link(LinkList *pTmpList)//链表的倒置
{
    LinkNode *pTmpNode = NULL;
    LinkNode *pInsertNode = NULL;

    pTmpNode = pTmpList->pHead;
    pTmpList->pHead = NULL;//断开链表
    
    while (pTmpNode != NULL)
    {
        pInsertNode = pTmpNode;
        pTmpNode = pTmpNode->pNext;

        pInsertNode->pNext = pTmpList->pHead;
        pTmpList->pHead = pInsertNode;
    }
}

5.2 链表的插入排序（从小到大）

void  insert_sort_link(LinkList *pTmpList)//插入排序法
{
    if (is_empty_link(pTmpList) || NULL == pTmpList->pHead->pNext)//空链表或者只有一个节点，不用排序
    {
        return ;
    }

    LinkNode *pTmpNode = NULL;//记录剩余节点的起始位置
    LinkNode *pInsertNode = NULL;//插入节点的位置
    LinkNode *p = NULL;//插入排序中遍历已经插入的节点的指针

    pTmpNode = pTmpList->pHead->pNext;//第一个节点不排序，从第二个节点开始排序
    pTmpList->pHead->pNext = NULL;//从原链表的第一个节点之后断开

    while (pTmpNode != NULL)//判断剩余未排序节点是否存在，最后一个节点参与操作
    {
        pInsertNode = pTmpNode;
        pTmpNode = pTmpNode->pNext;

        if (pInsertNode->Data <= pTmpList->pHead->Data)//判断要插入节点数据的大小是否小于第一个节点的数据
        {
            pInsertNode->pNext = pTmpList->pHead;//头插
            pTmpList->pHead = pInsertNode;
        }
        else //往后插
        {
            p = pTmpList->pHead;
            while (p->pNext != NULL && p->pNext->Data < pInsertNode->Data)
            {
                p = p->pNext;
            }

            pInsertNode->pNext = p->pNext;
            p->pNext = pInsertNode;
        }
    }
}

6. 测试链表是否被销毁

        valgrind ./a.out——查看开辟的空间是否全部被释放

Summit-
关注
【嵌入式面试】2022年嵌入式经典面试题汇总（数据结构）
一位才工作的工程师，持续学习，持续输出。更多内容，关注公众号“不想脱发的基兄”。
02-11 1959
2022年秋招我面试嵌入式MCU开发方向，经过了多场的笔试与面试，在准备的过程中看了非常多的资料，我的汇总的笔记一直写在有道云笔记中，没有分享出来。现在已经到了23年春招了，特此整理后分享出来。资料看过了觉得不错就保存下来了，如果有不对的地方，欢迎批评指正，侵权联删！数据结构自己遇到的面试题比较少，因此可以参考我发的或者网上的其他资料。本栏前文【嵌入式面试】2022年嵌入式经典面试题汇总（C语言）
嵌入式学习——数据结构（双向无头无环链表）——day47
qq_47798402的博客
06-18 317
【代码】嵌入式学习——数据结构（双向无头链表）——day47。
嵌入式学习——数据结构（双向无头有环链表、内核链表、栈）——day48
qq_47798402的博客
06-21 463
先进后出 first in last out。增：栈顶指针向内存高地址移动（0x1000低地址 ——0x2000高地址）快指针每走一步，判断是否为空或者是否与慢指针相遇。只允许从一端进行插入和删除的数据结构称为栈。利用快慢指针判断是否相遇。2. 函数的形参、返回值。浏览器返回上一层操作。满、空栈：栈顶所在位置是否存有数据。减：栈顶指针向内存低地址移动。1. 判断单向链表是否有环。
【嵌入式学习】数据结构day01.24---单向链表
m0_60905006的博客
01-24 576
** function: 创建新节点* @return*/p->data=0;return p;/** function: 头插* @return*/head=s;elsehead=s;/** function: 输出* @return*/return;while(p!puts("");/** function: 尾插* @return*/head=s;
嵌入式学习——C语言基础——day14
qq_47798402的博客
05-06 1100
3. 内存碎片：由于频繁malloc和free小空间,导致大的连续空间由于中间存在小空间被占用而无法得到申请空间的现象称为内存碎片。1. 空间不需要连续(访问数据麻烦、空间不需要连续,可以使用小的分散空间)1. 内存大端：内存低地址处存放高数据位，内存高地址处存放低数据位。2. 内存小端：内存低地址处存放低数据位，内存高地址处存放高数据位。1. 空间连续(访问数据方便、空间必须连续)1. （或1得1、或0不变）（全0为0，有1得1）1. 与0得0、与1不变）（全1为1，有0得0）2. 数组元素必须是有限。
嵌入式学习-数据结构-Day3-单链表
m0_56018621的博客
12-22 394
【代码】嵌入式学习-数据结构-Day3-单链表。
嵌入式学习day17（数据结构）
新手嵌入式学习的博客
08-15 1124
数据结构和算法
嵌入式学习-线性表Day05-双向链表
Xiaomo1536的博客
10-10 464
双向链表//双向链表的节点定义//数据域//指向下一个节点的指针 next 下一个//指向前一个节点的指针 prior 先前的//将双向链表的头指针和尾指针封装到一个节点体里//思想上有点像学的链式队列//指向双向链表的头指针//指向双向链表的尾指针int len;//用来保存当前双向链表的长度操作函数1）创建一个空的双向链表2）双向链表中间插入。
嵌入式学习day16(链表)
m0_37565374的博客
03-16 138
链表概念
嵌入式软件应用层开发常用API
CSDN_Xian的博客
07-04 2919
文章目录标准IO和文件IO1.fopen打开流2.perror错误处理3.strerror错误处理4.fclose关闭流5.fgetc按字符输入6.fputc按字符输出7.fgets按行输入8.fputs按行输出9.fread和fwrite对象的输入和输出10.fflush刷新流11.ftell、fseek、rewind定位流12.ferror、feof判断流是否出错或结束13.格式化输出14.格式化输入15.open打开文件16.close关闭文件17.read读文件18.write写文件19.lseek
BAT 大厂Java 面试题集锦之核心篇附参考答案
热门推荐
AI天才研究院
11-05 1万+
核心篇数据结构与算法网路:TCP/IP,HTTP操作系统, 文件, shell, CPU, IO, epoll, 非阻塞IO,进程/线程/协程,锁HashMap, Co...
《果壳中的C# C# 5.0 权威指南》 (01-08章) - 学习笔记
GATTACA2011
02-05 1348
《果壳中的C# C# 5.0 权威指南》 ========== ========== ========== [作者] (美) Joseph Albahari (美) Ben Albahari [译者] (中) 陈昇 管学理 曾少宁 杨庆川 [出版] 中国水利水电出版社 [版次] 2013年08月 第1版 [印次] 2013年08月 第1次 印刷 [定价] 118.00元 ========== =...
vue面试题目|MVVM、MVC、MVP,数据劫持
2301_79125431的博客
04-28 1388
目前一个日常实习在走流程，六月中旬学校放假，这段时间可以投其他的公司吗，暑假想去大城市实习，大家实习。19号一面的，但隔了快一周25号才发二面通知，26号二面完，是不是排名有点低，后面再过几天就是五一了。专升本，gap一年，非全双非硕，零实习，秋招 0offerbuff 真的叠满了最近终于有了一个大厂。中建三局，宁德时代，科锐国际（计算机类），途游游戏，得物，蓝禾，顺丰，康冠科技24春招内推①得物【岗。uu们，毕业论文盲审两个b通过了，有一个意见是说我的模型虽然指标上升，但是没有考虑复杂度的问题，针对。
Java学习（上）
Lzdnydppx的博客
08-09 820
Java简介、Java程序基础、流程控制、数组操作、面向对象基础、Java核心类、异常处理、反射、注解、泛型、集合、IO、日期与时间、单元测试
数据结构-5.2.树的性质
最新发布
ADCvbV的博客
10-12 239
一个分支中，如父结点B，两个子结点为E和F，结点B的度的值为2，等于子结点数量，加上这一个父结点(父结点只能有一个)，就是结点B，E，F组成的树的总结点数即结点数 = 总度数 + 1高度为h的m叉树至少有h个结点(每层至少一个结点，共h层，所以至少共h个结点)；高度为h，度为m的树至少有h+m-1个结点(首先度为m，表明至少要有m个分支，最少时一个分支上只有一个结点，此时有m个结点，这些分支占一层，此外有h-1层，每层最少1个结点，因此这h-1层至少h-1个结点，所以整个树至少h-1+m个结点)为了达到最小
数据结构之顺序表——静态顺序表(C语言版)
努力码字中······
10-09 1192
首先我们来介绍一下顺序表的概念：线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构，也就说是连续的一条直线。
（JAVA）浅入数据结构 “堆” - 实现和理论
拔高、提升、创新！
10-09 585
在树结构上做出一部分改变的堆结构，是如何实现的呢？强烈建议初学者来看一看噢~！
栈的操作算法实现（数据结构）
m0_61903191的博客
10-09 384
验证性实验内容：编写一个程序sqstack.cpp,实现顺序栈(假设栈中元素类型ElemType为char的各种基本运算，并在此基础上设计一个程序exp3-1.cpp。验证性实验：实现顺序栈各种基本运算的算法掌握栈的存储结构的表示和实现方法。目的：领会顺序栈存储结构和掌握顺序栈中各种基本运算算法设计。(3)依次进栈元素a、b、c、d、e。(2)判断栈s是否非空。(4)判断栈s是否非空。(6)判断栈s是否非空。(5)输出出栈序列。
数据结构-八大排序之堆排序
m0_75163045的博客
10-08 600
原理：1. 利用完全二叉树构建大顶堆2. 堆顶元素和堆底元素进行交换，除堆底元素之外其余元素继续构建大顶堆3. 重复2，直到所有元素都不参与构建 整个数组排序完成完全二叉树：数据从上到下，从左到右排列大顶堆：父节点的值大于或等于其左右孩子的值堆顶元素和堆底元素进行交换数组的形式：完全二叉树：arr [ i ] 的左孩子 arr [ 2i+1 ]arr [ i ] 的右孩子 arr [ 2i+2 ]arr [ i ] 的父节点 arr [ (i-1) / 2 ]大顶堆：arr [ i ] >=
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值