嵌入式养成计划-20-数据结构之双向链表

最新推荐文章于 2024-10-10 06:15:00 发布
最新推荐文章于 2024-10-10 06:15:00 发布
阅读量88 收藏
点赞数
分类专栏： C/C++ 数据结构与算法 文章标签： c语言 c++ linux 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52625576/article/details/132567833
版权

五十二、双向链表

52.1 双向链表的概念

  • 在单向链表的基础上增加一个指向前驱结点的指针域
  • 可以通过指向前驱结点的指针进行访问前一结点

52.2 双向链表与单向链表的区别

  • 单向链表:
    1. 只有一个指针域next，指向后继结点
    2. 只能顺序向下访问，一去不回头
    3. 插入与删除时只需要进行操作即可，不需要判断是否与尾结点相关
  • 双向链表:
    1. 有两个指针域，指向前驱结点的precursor指针，指向后继结点的next指针
    2. 可以通过指向前驱结点的指针域访问前面的结点，可以回头
    3. 插入时需要考虑是否插入到尾结点之后，如果插入到尾结点之后，则不能再让被插入结点的原next指针域指向的precursor指针域指向待插入结点，因为此时被插入结点的next指针域指向NULL，不能对NULL取precursor指针
    4. 删除结点是，需要考虑待删除结点是否是尾结点，如果不是尾结点，则将待删除结点的后一结点的pre指针指向待删除结点的前一结点

52.3 双向链表的组成

  • 数据域: 由一项或多项数据构成，数据类型不定
  • 指针域: 该结构体类型的指针，两个指针域，指向前驱结点的precursor指针，指向后继结点的next指针

52.4 双向链表的功能实现

52.4.1 双向链表的结构体

//  数据域是一个联合体，指针域指向前驱结点和后继结点
typedef struct double_linked_list
{    
    union
    {
        data num;   //  表示数据内容
        int len;    //  len表示当前有多少结点(头结点除外)
    };
    //  指向前驱结点的指针
    struct double_linked_list *pre;
    //  指向后继结点的指针
    struct double_linked_list *next;
} dbLinkNode; //  结构体类型名重命名为dbLinkNode

52.4.2 双向链表功能图解

  1. 双向链表的头插

在这里插入图片描述

  1. 尾插

    • 找到尾结点，把尾结点和新结点之间的关系连上
      在这里插入图片描述

  2. 头删
    在这里插入图片描述

  3. 尾删
    在这里插入图片描述

  4. 按位置插入
    在这里插入图片描述

  5. 按位置删除

    • 找到pos-1位置的结点
      在这里插入图片描述
    • 找到pos位置的结点
      在这里插入图片描述

52.5 双向链表的代码(接口,功能实现,测试用主函数,Makefile)

52.5.1 接口(head.h)

#ifndef __HEAD_H__
#define __HEAD_H__

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

//	重命名数据域的数据类型名
typedef int data;

//  数据域是一个联合体，指针域指向前驱结点和后继结点
typedef struct double_linked_list
{ 
    union
    {
        data num;   //  表示数据内容
        int len;    //  len表示当前有多少结点(头结点除外)
    };
    //  指向前驱结点的指针
    struct double_linked_list *pre;
    //  指向后继结点的指针
    struct double_linked_list *next;
} dbLinkNode; //  结构体类型名重命名为dbLinkNode

// 创建单链表
dbLinkNode *init();
// 单链表的判空
int is_empty(dbLinkNode *l);
// 单链表的头插
int head_insert(dbLinkNode *l, data value);
// 单链表的尾插
int tail_insert(dbLinkNode *l, data value);
//  指定下标插入
int inset_by_index(dbLinkNode *l, int index, data value);
//  头删
int head_del(dbLinkNode *l);
//  尾删
int tail_del(dbLinkNode *l);
//  指定下标删除
int del_by_index(dbLinkNode *l, int index);
//  按值删除,返回删除的下标
int del_by_value(dbLinkNode *l, data value);
// 单链表的按值查找，返回下标
int find_by_value(dbLinkNode *l, data value);
// 单链表的按值修改,返回下标
int change_by_value(dbLinkNode *l, data old_value, data new_value);
// 单链表的按位置查找，返回对应的值
data find_by_index(dbLinkNode *l, int index);
//  输出单链表
int output(dbLinkNode *l);
//  释放单链表
int free_dbLinkNode(dbLinkNode **l);

#endif

52.5.2 功能实现(double_linked_list.c)

#include "head.h"

// 创建双向链表
dbLinkNode *init()
{
    dbLinkNode *p = (dbLinkNode *)malloc(sizeof(dbLinkNode));
    if (NULL == p)
    {
        /* code */
    }
    //	申请失败时返回NULL
    if (NULL == p)
    {
        printf("创建双向链表失败\n");
        return NULL;
    }
    //  初始结点数为0(头结点除外)
    p->len = 0;
    //  初始结点的pre指针域指向NULL
    p->pre = NULL;
    //  初始结点的next指针域指向NULL
    p->next = NULL;
    //  返回申请的堆区空间的首地址
    return p;
}

// 双向链表的判空
int is_empty(dbLinkNode *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    //  头结点后无结点,或者结点数为0(头结点除外),此时链表为空,返回1
    if (NULL == l->next || l->len == 0)
    {
        return 1;
    }
    return 0; //  链表不是空,返回0
}

// 双向链表的头插
int head_insert(dbLinkNode *l, data value)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点
    dbLinkNode *p = l;
    //  新申请一个结点的空间,用ll指向
    dbLinkNode *ll = (dbLinkNode *)malloc(sizeof(dbLinkNode));
    //  新结点的值为传进来的值
    ll->num = value;
    //  新结点的next指针域指向头结点的原下一结点,即原第一结点
    ll->next = p->next;
    //  新结点的前驱结点指针域pre指向头结点
    ll->pre = p;
    //  让头结点next指针域指向这个新结点
    p->next = ll;
    //  如果这个双向链表不是空的,那么还有让原第一结点的pre指针域指向刚插入的结点
    if (!is_empty(l))
        ll->next->pre = ll;
    //  结点计数变量+1
    l->len++;
    return 0;
}

// 双向链表的尾插
int tail_insert(dbLinkNode *l, data value)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点
    dbLinkNode *p = l;
    //  循环向后指,直到p指向最后一个结点
    while (NULL != p->next)
    {
        p = p->next;
    }
    //  新申请一个结点的空间,用ll指向
    dbLinkNode *ll = (dbLinkNode *)malloc(sizeof(dbLinkNode));
    //  新结点的值为传进来的值
    ll->num = value;
    //  新结点的next指针域指向NULL
    ll->next = NULL;
    //  新结点的pre指针域指向原最后一个结点
    ll->pre = p;
    //  新结点插到最后
    p->next = ll;
    //  结点计数变量+1
    l->len++;
    return 0;
}

//  指定下标插入
int inset_by_index(dbLinkNode *l, int index, data value)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (index <= 0 || index > l->len)
    {
        printf("传入的下标有问题\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点
    dbLinkNode *p = l;
    //  记录当前下标
    int i = 1;
    while (1)
    {
        //  如果当前下标与传进来的下标相等,进行头插
        //  因为此时指针p已经循环指向了此下标对应的结点的首地址
        if (i == index)
        {
            //  新申请一个结点的空间,用ll指向
            dbLinkNode *ll = (dbLinkNode *)malloc(sizeof(dbLinkNode));
            //  新结点的值为传进来的值
            ll->num = value;
            //  新结点的next指针域指向被插入结点的下一结点
            ll->next = p->next;
            //  新结点的pre指针域指向被插入结点
            ll->pre = p;
            //  让头结点指向这个新结点
            p->next = ll;
            //  如果插进去的这个结点不在最后,
            //  那么让刚插进去的这个结点的下一结点的pre指针域指向刚插进去的这个结点
            if (NULL != ll->next)
                ll->next->pre = ll;
            //  插入后退出循环
            break;
        }
        //  如果找到了最后还没找到,说明位置参数不对
        if (NULL == p->next)
        {
            printf("传入位置参数不合法\n");
            //  位置参数不对,return -1 表示函数异常结束
            return -1;
        }
        //  这一圈没找到则当前下标+1向后找
        ++i;
        //  p向后指,继续向后找
        p = p->next;
    }
    //  找到并插入后,结点数+1
    l->len++;
    return 0;
}

//  头删
int head_del(dbLinkNode *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点,无法进行删除\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点
    dbLinkNode *p = l;
    //  保存待删除的结点,即第一结点
    dbLinkNode *q = l->next;
    //  将头结点的next指针域指向下下一结点,越过第一结点
    p->next = q->next;
    //  如果双向链表不是只有一个数据结点的链表
    //  那么让待删除结点的后继结点的pre指针域指向头结点
    if (NULL != q->next)
        q->next->pre = p;
    //  释放第一结点的空间
    free(q);
    q = NULL;
    //  结点计数变量-1
    l->len--;
    return 0;
}

//  尾删
int tail_del(dbLinkNode *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点,无法进行删除\n");
        return -1;
    }

    //  防止头结点指向改变,故新建一个指针指向头结点
    dbLinkNode *p = l;
    //  循环找到最后一个结点
    while (1)
    {
        //  如果下一结点的next指针域指向NULL
        //  说明当前结点是倒数第二个结点
        if (NULL == p->next->next)
        {
            //  q指向最后这个结点
            dbLinkNode *q = p->next;
            //  倒数第二个结点的next指针域指向NULL
            p->next = NULL;
            //  释放最后这个结点的空间
            free(q);
            q = NULL;
            //  退出循环
            break;
        }
        //  当前结点不是倒数第二个结点时继续向下找
        p = p->next;
    }
    //  删除后,结点计数变量-1
    l->len--;
    return 0;
}

//  指定下标删除
int del_by_index(dbLinkNode *l, int index)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (index <= 0 || index > l->len)
    {
        printf("传入的下标有问题\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点
    dbLinkNode *p = l;
    //  记录当前下标
    int i = 1;
    while (1)
    {
        //  如果当前下标与传进来的下标相等,进行删除
        //  此时指针p的next指针域已经循环指向了要找的下标对应的结点
        //  即p指向要删除的结点的前一结点
        if (i == index)
        {
            //  q指向这个要删除的结点
            dbLinkNode *q = p->next;
            //  让要删除的结点前一结点和后面一个结点连接
            //  越过要删除的这个结点
            p->next = q->next;
            //  如果待删除结点不是尾结点
            //  那么让待删除结点的后继结点的pre指针域指向前一结点
            if (NULL != q->next)
                q->next->pre = p;
            //  释放要删除的这一结点的空间
            free(q);
            q = NULL;
            //  删除后退出循环
            break;
        }
        //  循环到了最后还没找到这个下标对应的结点
        if (NULL == p->next)
        {
            //  提示位置参数不对,并返回-1表示函数异常结束
            printf("传入位置参数不合法\n");
            return -1;
        }
        //  这一圈没找到则当前下标+1向后找
        ++i;
        //  p继续向后指,向后接着找
        p = p->next;
    }
    //  删除后,结点计数变量-1
    l->len--;
    return 0;
}

//  按值删除,返回删除的下标
int del_by_value(dbLinkNode *l, data value)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (NULL == l->next)
    {
        printf("只有头结点\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点
    dbLinkNode *p = l;
    //  记录当前下标
    int i = 1;
    //  循环向后找
    while (1)
    {
        //  如果找到了最后还没找到就退出循环
        if (NULL == p->next)
        {
            break;
        }
        //  如果下一结点的值与传进来的值相同,则进行删除
        if (value == p->next->num)
        {
            printf("准备删除\n");
            //  指针q指向下一结点,即要删除的结点
            dbLinkNode *q = p->next;
            //  当前结点的next指针域指向要删除的结点的下一个结点
            p->next = q->next;
            //  如果待删除结点不是尾结点
            //  那么让待删除结点的后继结点的pre指针域指向前一结点
            if (NULL != q->next)
                q->next->pre = q;
            //  释放要删除的结点的空间
            free(q);
            l->len--;
            printf("已删除\n");
            //  返回当前所在下标
            return i;
        }

        //  这一圈没找到则当前下标+1向后找
        ++i;
        //  p继续向后指,向后接着找
        p = p->next;
    }
    //  循环没找到,输出找不到这个值
    printf("找不到这个值\n");
    //  返回-1表示函数异常结束
    return -1;
}

// 双向链表的按值查找，返回下标
int find_by_value(dbLinkNode *l, data value)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (NULL == l->next)
    {
        printf("只有头结点\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点的下一结点
    dbLinkNode *p = l->next;
    //  记录当前位置
    int i = 1;
    //  循环向后找
    while (1)
    {
        //  如果下一结点的值与传进来的值相同,则返回当前位置
        if (value == p->num)
        {
            return i;
        }
        //  如果找到了最后还没找到就退出循环
        if (NULL == p->next)
        {
            break;
        }
        //  这一圈没找到则当前下标+1向后找
        ++i;
        //  p继续向后指,向后接着找
        p = p->next;
    }
    //  循环没找到,输出找不到这个值
    printf("链表中没有这个值\n");
    //  返回-1表示函数异常结束
    return -1;
}

// 双向链表的按值修改,返回下标
int change_by_value(dbLinkNode *l, data old_value, data new_value)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点的下一结点
    dbLinkNode *p = l->next;
    //  记录当前位置
    int i = 1;
    //  循环向后找
    while (1)
    {
        //  如果下一结点的值与传进来的旧值相同,则用新值进行修改并返回当前位置
        if (old_value == p->num)
        {
            p->num = new_value;
            return i;
        }
        //  如果找到了最后还没找到就退出循环
        if (NULL == p->next)
        {
            break;
        }
        //  这一圈没找到则当前下标+1向后找
        ++i;
        //  p继续向后指,向后接着找
        p = p->next;
    }
    //  循环没找到,输出找不到这个值
    printf("链表中没有这个值\n");
    //  返回-1表示函数异常结束
    return -1;
}

// 双向链表的按位置查找，返回对应的值
data find_by_index(dbLinkNode *l, int index)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (index < 0 || index > l->len)
    {
        printf("传入的下标有问题\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("只有头结点\n");
        return -1;
    }
    //  防止头结点指向改变,故新建一个指针指向头结点的下一结点
    dbLinkNode *p = l->next;
    //  记录当前位置
    int i = 1;
    //  循环向后找
    while (1)
    {
        //  如果当前位置与传进来的下标相同,则返回这个位置的值
        if (i == index)
        {
            return p->num;
        }
        //  如果找到了最后还没找到则提示位置参数不对
        if (NULL == p->next)
        {
            printf("传入位置参数不合法\n");
            //  返回-1表示函数异常结束
            return -1;
        }
        //  这一圈没找到则当前下标+1向后找
        ++i;
        //  p继续向后指,向后接着找
        p = p->next;
    }
}

//  输出双向链表
int output(dbLinkNode *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }

    //  防止头结点指向改变,故新建一个指针指向头结点
    //  用于指向待输出的结点
    dbLinkNode *p = l;
    //  记录当前到第几个结点
    int i = 0;
    while (1)
    {
        //  输出当前结点
        //  是头结点时
        if (0 == i)
        {
            printf("除头结点外,其余结点个数为:%d\n", p->len);
        }
        else //  非头结点时
        {
            printf("第%d位数据为:%d\n", i, p->num);
        }
        //  位置变量+1
        ++i;
        //  如果当前结点最后一个结点,那么就退出(因为是先输出的,所以已经输出过了)
        if (NULL == p->next)
            break;
        //  待输出的结点向后逐位移动
        p = p->next;
    }
    return 0;
}

//  释放双向链表
int free_dbLinkNode(dbLinkNode **l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    //  用于接收传来的头结点指针
    //  传来的是头结点指针的地址,所以需要解引用获得其指向的地址
    dbLinkNode *p = *l;
    //  用于存放准备释放的结点的下一结点,免得找不到了
    dbLinkNode *q = p->next;
    //  进入循环,准备逐个释放
    while (1)
    {
        //  释放当前结点
        free(p);
        //  让下一结点变成当前结点
        p = q;
        //  如果当前结点到了最后,指针已经指向NULL,表示空间都释放了
        //  所以需要将头结点指针的指向更改,所以需要解引用指向NULL,然后退出
        if (NULL == p)
        {
            *l = NULL;
            return 0;
        }
        //  待释放结点的下一结点向后挪
        //  因为上面已经把原来待释放结点的下一结点变成了当前准备释放的结点了
        q = q->next;
    }
}

52.5.3 测试用主函数(main.c)

#include "head.h"
int main(int argc, char const *argv[])
{
    dbLinkNode *l = init();
    printf("刚创建\n");
    output(l);

    printf("%d\n", is_empty(l));
    printf("头插\n");

    head_insert(l, 32);
    output(l);
    printf("%d\n", is_empty(l));

    putchar(10);
    printf("头插\n");
    head_insert(l, 35);
    output(l);

    putchar(10);
    printf("尾插\n");
    tail_insert(l, 100);
    output(l);
    putchar(10);

    printf("头插\n");
    head_insert(l, 32);
    output(l);
    putchar(10);

    printf("头插\n");
    head_insert(l, 39);
    output(l);
    putchar(10);

    printf("在第3个位置插入\n");
    inset_by_index(l, 3, 99);
    output(l);
    putchar(10);

    printf("值6所在位置为:%d\n",find_by_value(l, 6));
    putchar(10);

    printf("值100所在位置为:%d\n",find_by_value(l, 100));
    putchar(10);

    printf("将第一个32修改为55\n");
    change_by_value(l,32,55);
    output(l);
    putchar(10);

    printf("第三个位置上的值为:%d\n",find_by_index(l, 3));
    putchar(10);

    printf("第9个位置上的值为:%d\n",find_by_index(l, 9));

    putchar(10);

    printf("头删\n");
    head_del(l);
    output(l);
    putchar(10);

    printf("尾删\n");
    tail_del(l);
    output(l);
    putchar(10);

    printf("在第2个位置删除\n");
    del_by_index(l, 2);
    output(l);
    putchar(10);

    printf("删除32\n");
    del_by_value(l, 32);
    output(l);
    putchar(10);

    printf("删除33\n");
    del_by_value(l, 33);
    output(l);
    putchar(10);

    return 0;
}

52.5.1 Makefile

EXE=double_linked_list
CC=gcc
CFLAGs=-c
OBJs+=double_linked_list.o
OBJs+=main.o

all:$(EXE)

$(EXE):$(OBJs)
	$(CC) $^ -o $@

%.o:%.c
	$(CC) $(CFLAGs) $^ -o $@

clean:
	rm *.o double_linked_list

思维导图

zhk___
关注
专栏目录
嵌入式单片机中链表操作与实现详解
嵌入式技术开发
06-08 513
包含单链表，双链表，循环单链表，实际应用中的功能不同，但实现方式都差不多。单链表就像是美国男篮，一代一代往下传；双链表像是中国男足，你传球给我，我传球给你，最终传给了守门员；循环链表就像是中国男篮，火炬从姚明传给王治郅，王治郅传给易建联，现在易建联伤了，又传给了姚明单链表是指结点中只有一个指向其后继的指针，具有单向性，但是有时需要搜索大量数据的时候，就需要多次进行从头开始的遍历，这样的搜索就不是很高效了。
嵌入式全栈开发学习笔记---数据结构（双向链表）
xiaobaivera的博客
08-07 362
双向链表的删除操作 比如我们要删除第二个节点，在删除之前我们得先把第三个结点的位置存放在第一个结点的next指针域中，然后将第一个结点的位置存放在第三个结点的prior指针域中，最后再释放掉第二个节点的空间。
嵌入式全栈开发学习笔记---数据结构（双向循环链表）
xiaobaivera的博客
08-07 514
​双向循环链表同时具有双向链表和循环链表的特性，是效率最高的一种链表。我们也是在单链表的代码基础上修改。 双向循环链表的初始化 在双向循环链表中，从头到尾我们都不能出现NULL这个字眼。 初始化的时候，头结点的Prior和next指针域都初始化为它自己的地址。
【数据结构】拆分详解 - 双向链表
bubble_shadow的博客
11-14 303
本文拆分讲解带头双向循环链表的实现
嵌入式全栈开发学习笔记---数据结构（链表的分类）
xiaobaivera的博客
08-06 189
常见的链表有：静态链表（用的很少，有点类似于顺序表）、单链表、双向链表、循环链表、双向循环链表（效率最高）
嵌入式全栈开发学习笔记---数据结构（顺序栈）
xiaobaivera的博客
08-09 714
当我们初始化一个空栈的时候，栈顶指针（下标）应该设置为-1，如果设置为0的话就还不能表示空栈。 我们在程序上如果来表示一个栈呢？ 我们还是用结构体来表示： 只要知道栈顶在哪了，就知道这个栈的容量有多大了。
嵌入式全栈开发学习笔记---C++(STL)
xiaobaivera的博客
09-06 1701
STL概述 STL（Standard Template Library，标准模板库）是惠普实验室开发的一系列软件的统称。现然主要出现在C++中，但在被引入C++之前该技术就已经存在了很长的一段时间。 STL的从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），容器和算法通过迭代器可以进行无缝地连接。几乎所有的代码都采用了模板类和模板函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。在C++标准中，STL被组织为下面的13个头文 件
一口气搞懂「链表」，就靠这20+张图了
张巧龙的博客
09-14 714
顺序存储和链式存储数组—顺序存储数组作为一个顺序储存方式的数据结构，可是有大作为的，它的灵活使用为我们的程序设计带来了大量的便利；但是，但是，数组最大的缺点就是我们的插入和删除时需要...
嵌入式养成计划-41----C++ auto--lambda表达式--C++中的数据类型转换--C++标准模板库（STL）--list--C++文件操作
This code no bug！
10-14 844
C++auto--C++的lambda表达式--C++中的数据类型转换--C++标准模板库（STL）--list--C++文件操作
严蔚敏数据结构c语言版本可运行源码、完全c语言代码实现.zip
06-14
1. **线性表**：包括顺序表和链表的实现，如动态数组、单链表、双向链表等。学习者可以通过这些源码理解数据的增删改查操作。 2. **栈和队列**：这些是两种重要的抽象数据类型，用于实现“后进先出”（LIFO）和...
华清远见嵌入式培训_第五周回顾与反思
Anccccc的博客
09-25 630
这是在华清学习的第五个周末，这一周主要学习的是数据结构。老师说数据结构是一门非常庞大的学科，单单是数据结构里的一个小分支，单拎出来一周都未必可以学透，因此这周的数据结构课程里更多的是思维方向的学习，学习数据结构的思维方式和算法、拓宽思路，大方向上，利用好的数据结构和算法，来提升程序的执行效率，合理的使用内存资源；现阶段上，学习数据结构可以提高代码的质量，提升代码量，强化对C语言知识的理解和认识，养成编程思维、逻辑思维。 这一周里主要的学习内容有：顺序表、链表、栈、队列、数和哈希数组，每一部
2024年最新紫光嵌入式面试题及参考答案
大模型大数据攻城狮的专栏
09-03 2662
由于不同的子类对象的虚函数表指针指向不同的虚函数表，所以可以根据对象的实际类型来调用正确的虚函数实现，从而实现多态。应用程序开发的挑战在于需要满足用户的需求，提供良好的用户体验。库函数可以提供更高层次的抽象：库函数可以在系统调用的基础上提供更高层次的抽象，使得程序员可以更专注于业务逻辑的实现，而不必关心底层的操作系统细节。例如，C++ 的标准模板库（STL）提供了各种容器和算法，这些容器和算法都是在系统调用的基础上实现的，但程序员可以直接使用这些容器和算法，而不必关心底层的内存管理和数据结构实现。
C语言基本概念
ROBIN__dyc的博客
10-03 765
标识符：编写程序时，需要对变量、函数、宏和其他实体进行命名，这些名字称为标识符。函数是C语言中构建程序的构建块，事实上，C语言是函数的集合。函数分为两大类，一类是程序员编写的函数，一类是作为C语言实现的一部分提供的函数，即库函数。所有指令都是以字符#开始的，默认只占一行，每条指令的结尾没有分号或其他特殊标记。int 型变量取值的范围是有限的，通常为-2³¹～2³¹-1，但某些计算机上最大整数可能只有32767。语句是程序运行时执行的命令，C语言规定每条语句都要以分号结尾（复合语句是例外）。
C 共用体
最新发布
lly202406的博客
10-10 287
在C语言中，共用体使用union关键字定义。共用体的所有成员共享同一块内存空间，这意味着在任何时刻，共用体只能存储其中一个成员的数据。// ...其中，union_name是共用体的名称，type是成员的数据类型，member1member2等是共用体的成员。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1275
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
【C++】List
m0_46676283的博客
10-08 284
文章目录1.list的介绍及使用1.1 list的介绍 本节目标 1.list的介绍及使用 2.list的深度剖析及模拟实现 3.list与vector的对比 4.本节习题 1.list的介绍及使用 1.1 list的介绍
（STL）map与set的封装--采用红黑树
2302_80190394的博客
10-04 829
（STL）map与set的封装--采用红黑树
C++之多态篇(超详细版)
2302_79795375的博客
10-04 899
public:cout
数据结构-双向链表前插操作详解
"双向链表的前插操作算法及其在数据结构中的重要性" 在计算机科学中，数据结构是研究如何高效地存储和处理数据的重要领域。清华大学严蔚敏教授的《数据结构》C语言版中详细阐述了各种数据结构及其操作，其中包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zhk___

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值