数据结构笔记

已于 2023-09-11 11:02:33 修改
阅读量33 收藏
点赞数 1
文章标签： 数据结构 c语言
于 2023-09-11 07:06:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ldt47/article/details/132796748
版权

数据结构笔记

必须吐槽一下，我都学了c的数据结构了，这一下子来了c++，就很烦，我又得重新整理，又出来那么多不理解的东西。

乱七八糟的知识准备：

当初c语言没学好的，都是要还的。

首先了解一下&(当然不怪我，这是c++的内容），参数的引用，什么时候用，有什么含义那？，可以理解对参数的结果需要带回来。下面看一下代码理解：

#include "stdio.h"
void test(int x){
    x=1024;
    printf("test 内部函数的x的值为：%d\n",x);
}

int main(){
    int x =1;
    printf("调用test前x的值为%d\n",x);
    test(x);
    printf("调用test后x的值为%d\n",x);
}

请添加图片描述

这就属于对于参数的结果没有带回来。那么如果我们在test函数里面传入的不是是x而是**&x**那？结果你也许猜到了，没错结果的值带了回来。结果如下请添加图片描述

单链表

单链表的定义
typedef struct LNode{
    int data;
    struct LNode* next;
}LNode,*LinkList;

不说别的，就这个定义就够了解一壶的了。

首先给还原一下，上面的定义与下面的定义相同

typedef struct LNode{
    int data;
    struct LNode* next;
}
typedef struct LNode LNode;
typedef struct LNode* LinkList;

稍微明白一点了把，这是两个重命名，**一把这个结构体重命名为LNode ，另一个是把指向这个结构体的指针重命名为LinkList。**一脸懵逼，这是为什么？

而且LNode*其实是完全等价于LinkList，是不是感觉什么鬼，越来越乱，多此一举问什么要整两个那。不要急一点一点的表示。

先在此说一下，助于理解

  1. 强调这是一个单链表 ，–使用LinkList
  2. 强调这是一个节点 --使用LNode *
单链表的初始化

代码都是默认带头节点的

bool InitList(LinkList &L){
    L=new LNode;
    if(L==NULL) return false;
    L->next=NULL;
   return true;
}
//这是测试，不是属于初始化的内容但是检测初始化的内容
void test(){
    LinkList L;
    InitList(L);
}

算了都补一下把，不带头节点：

bool InitList(LinkList &L){
    if(L==NULL) //区别在这
   return true;
}
单链表的判空

为什么传入的参数是L而不是&L，很简单，我们只需要判断，也不需要带回

bool Empty(LinkList L){
    if(L->next==NULL) return false;
    else
        return true;
}

不带头节点：

bool Empty(LinkList L){
    if(L==NULL) return false;//区别在这
    else
        return true;
}
单链表的插入

请添加图片描述

bool InsertLink(LinkList &L,int index,int element){
    if(index<1)
        return false;
    LNode * p; //指正p指向当前扫描到的节点
    p=L;
    int j=0; //当前p指向的是第几个节点
    while (p!=NULL && j<index-1){
        p=p->next;
        j++;
    }
    if(p==NULL)
        return false;
    LNode* s=new LNode;//LNode* s =(LNode* s)malloc(sizeof(LNode));c语言可以这样写；
    s->data=element;
    s->next=p->next;
    p->next=s;
    return true;
}

不带头节点：请添加图片描述

bool InsertLink(LinkList &L,int index,int element){
    
    if(index<1)
        return false;
    //对于i==1进行特殊处理，插入第一个节点与其他操作不同
    if(i==1){
    LNode *s =new LNode;
    s->data =e;
    s->next =L;
    L=s;
    return true;
    }
    LNode * p; //指正p指向当前扫描到的节点
    p=L;
    int j=1; //去呗在这里
    while (p!=NULL && j<index-1){
        p=p->next;
        j++;
    }
    if(p==NULL)
        return false;
    LNode* s=new LNode;//LNode* s =(LNode* s)malloc(sizeof(LNode));c语言可以这样写；
    s->data=element;
    s->next=p->next;
    p->next=s;
    return true;
}

拓展一下，后插操作（很有作用）：

单链表的删除
bool DeleteList(LinkList &L,int index,int &e){
    if(index<1) return false;
    LNode *p;//指正p当前扫描的节点
    int j=0;//当前p指向第几个节点
    p=L;
    while (p!=NULL && j<index-1){
        p=p->next;
        j++;
    }
    if(p==NULL) return false;
    if(p->next==NULL) return false;
    LNode *q=p->next;
    e=q->data;
    p->next=q->next;
    free(q);
}
单链表按位查找

LNode *GetElem(LinkList L ,int index){
    if(index<0) return NULL;//因为我们是带头节点，所以头节点可以看做第0个元素
    LNode *p;
    int j=0;
    p=L;
    while (p!=NULL &&j<index){
        p=p->next;
        j++;
    }
    return p;

第二种，可以参考理解一下

LNode *GetElem(LinkList L ,int index){
    int j=1;
    LNode *p = L->next;
    if(index==0) return L;
    if(index<1) return NULL;
    while (p!=NULL &&j<index){
       p=p->next;
       j++;
    }
    return p;
}

这里提一下，在我们学完按位查找之后，可以利用其封装性，应用到单链表的插入和删除中搜索到前节点的过程

请添加图片描述
请添加图片描述

单链表的按值查找
LNode* LocateElem(LinkList L, int element) {
    LNode* p = L->next;
    while (p != NULL && p->data != element) {
        p = p->next;
    }
    return p;
}
总结：

下面是整个链表的展示，包括实现功能

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

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

// 初始化
bool InitList(LinkList& L) {
    L = new LNode;
    if (L == NULL) return false;
    L->next = NULL;
    return true;
}

// 判断是否为空
bool Empty(LinkList L) {
    if (L->next == NULL) return true;
    else return false;
}

// 插入操作
bool InsertList(LinkList& L, int index, int element) {
    if (index < 1) return false;
    LNode* p; //指针p指向当前扫描到的节点
    p = L;
    int j = 0; //当前p指向的是第几个节点
    while (p != NULL && j < index - 1) {
        p = p->next;
        j++;
    }
    if (p == NULL) return false;
    LNode* s = new LNode;
    s->data = element;
    s->next = p->next;
    p->next = s;
    return true;
}

// 删除操作
bool DeleteList(LinkList& L, int index, int& e) {
    if (index < 1) return false;
    LNode* p; //指针p当前扫描的节点
    int j = 0; //当前p指向第几个节点
    p = L;
    while (p != NULL && j < index - 1) {
        p = p->next;
        j++;
    }
    if (p == NULL || p->next == NULL) return false;
    LNode* q = p->next;
    e = q->data;
    p->next = q->next;
    free(q);
    return true;
}

// 按位置查找
LNode* GetElem(LinkList L, int index) {
    if (index < 0) return NULL; //因为我们是带头节点，所以头节点可以看做第0个元素
    LNode* p;
    int j = 0;
    p = L->next; // 从第一个节点开始查找
    while (p != NULL && j < index) {
        p = p->next;
        j++;
    }
    return p;
}

// 按值查找，找到数据域==element的节点
LNode* LocateElem(LinkList L, int element) {
    LNode* p = L->next;
    while (p != NULL && p->data != element) {
        p = p->next;
    }
    return p;
}

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

void test() {
    LinkList L;
    if (InitList(L)) {
        printf("链表初始化成功.\n");
    } else {
        printf("链表初始化失败。\n");
        return;
    }

    // 测试插入操作
    for (int i = 1; i <= 5; i++) {
        if (InsertList(L, i, i * 10)) {
            printf("在位置%d插入元素%d成功。\n", i, i * 10);
        } else {
            printf("位置%d的插入失败。\n", i);
        }
    }

    // 测试删除操作
    int deletedElement;
    if (DeleteList(L, 3, deletedElement)) {
        printf("删除的元素:%d\n", deletedElement);
    } else {
        printf("3号位置的删除失败。\n");
    }

    // 测试查找操作
    int findElement = 20;
    LNode* foundNode = LocateElem(L, findElement);
    if (foundNode) {
        printf("在位置%p找到元素%d。\n", foundNode, findElement);
    } else {
        printf("没有找到元素%d\n", findElement);
    }

    // 输出链表长度
    int len = Length(L);
    printf("链表长度:%d\n", len);
}

int main() {
    test();
    return 0;
}
白笔留墨
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
408数据结构笔记（2023更新中...）
m0_58200226的博客
07-17 2729
408计算机考研笔记
王道数据结构笔记
weixin_44582953的博客
03-23 3480
王道数据结构笔记2.2 线性表的顺序表示顺序表的实现——动态分配顺序表的特点总结 2.2 线性表的顺序表示 顺序表的实现——动态分配 由于需要将数据复制到新的区域因此时间开销大 #include <stblib.h> #define InitSize 10 //默认最大长度 typedef struct{ int *data; //指示动态分配数组的指针 int MaxSize; //顺序表的最大容量 int length; //顺序表的当前长度 }SeqList; void In
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 40万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构与算法学习笔记
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构学习笔记
liu320yj的博客
06-26 3576
数据结构指相互之间存在一种或多种特定关系的数据元素的集合，包括常用的数组、链表、栈、队列、二叉树等
数据结构—笔记整理—初识数据结构
好好读书
10-22 4万+
数据结构笔记及相关知识整理，冲冲冲！！！
数据结构笔记精华
summer_lele的博客
07-06 1577
数据结构笔记精华 （总共127页，知识点重点全面，有图形展示、伪代码。习题和思维导图，高清资源，让你玩转数据结构！） 部分演示如下： Word版下载地址：https://download.csdn.net/download/summer_lele/12582114 免费获取需要关注微信公众号：星谐 ...
中北大学811数据结构笔记
m0_46629663的博客
06-02 2303
中北大学大数据学院811数据结构考研笔记
数据结构笔记正式版8――手写
Shirley_WYH的博客
10-21 3194
栈 数据结构——栈
数据结构笔记：栈
BBJG_001的博客
03-05 1877
原文地址[ 分类目录——数据结构笔记](https://blog.csdn.net/bbjg_001/category_9753496.html) 栈（stack），有些地方也成为堆栈，是一种容器，可存储元素、访问元素、删除元素，他的特点是值能允许在容器的一段（称之为 栈顶 top）进行数据的追加（push）和数据读出（pop）。没有了位置/索引的概念，保证任何时候可以访问、删除的元素都是在此前左...
数据结构笔记.docx
12-19
数据结构笔记 数据结构是计算机科学中的一门重要学科，涉及到数据的存储、表示和操作等方面。本笔记涵盖了数据结构的基本概念、线性表、栈和队列、树、图、排序和查找等重要知识点。 一、数据结构的基本概念 数据...
郝斌数据结构笔记.pdf
09-11
郝斌数据结构笔记 数据结构概述： 数据结构是指在计算机中对数据的存储、组织和管理的方式。它是软件最核心的课程，学完了啥也干不了。数据结构 = 个体的存储 + 个体的关系存储，算法 = 对存储数据的操作。 知识点...
数据结构 笔记
07-20
这份“数据结构笔记”涵盖了这一主题的各个方面，旨在帮助学习者深入理解并掌握数据结构的基本原理和应用。 一、数组 数组是最基本的数据结构之一，它是由相同类型元素构成的有序集合。每个元素都有一个唯一的索引...
数据结构和算法（0-1）----递归
yanminghe66666的博客
07-09 636
递归算法，爬楼梯等解法
数据结构之顺序表
m0_73634434的博客
07-10 461
线性表(List)由零个或多个数据组成的有限数列，线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列，字符串。
数据结构第23节 线性搜索
最新发布
hummhumm的专栏
07-12 324
线性搜索（Linear Search），也称为顺序搜索，是最基本的搜索算法之一。它的工作原理是通过遍历数组或列表中的每一个元素，直到找到目标值为止，或者遍历完所有元素后确定目标值不存在于列表中。线性搜索的时间复杂度为O(n)，其中n是列表中元素的数量。这是因为最坏情况下，你可能需要检查列表中的每一个元素才能找到目标值或确定它不在列表中。
【排序 - 堆排序】
2302_80393814的博客
07-10 544
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
设备管理中的数据结构
yuanwu932730169的博客
07-11 456
它包含了通道标识符、通道状态（如忙/闲）、与通道连接的控制器表的指针、通道队列的队首指针和队尾指针等信息。功能：DCT主要用于记录单个设备的详细信息，包括设备类型、设备标识符、设备状态（如忙/闲、等待/不等待）、指向控制器表的指针、重复执行次数或时间、设备队列的队首指针等。功能：SDT是系统级别的数据结构，用于记录系统中所有物理设备的情况。功能：COCT主要用于记录单个控制器的详细信息，包括控制器标识符、控制器状态（如忙/闲）、与控制器连接的通道表指针、控制器队列的队首指针和队尾指针等。
数据结构学习笔记.docx
12-02
数据结构学习笔记.docx

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值