【数据结构郝斌】3、模块一：线性结构

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

1、连续存储（数组）

　int a[10];
　int *pArr = (*int

　1)什么叫数组
　　元素类型相同，大小相等。
　2)数组的优缺点
　　优点：存取速度快
　　缺点：事先必须知道数组的长度，插入删除元素慢，空间通常是有限制，需要大块连续内存。
　　练习代码见:数据结构数组算法.c
　确定一个数组需要几个信息：
　　数组首地址
　　数组长度
　　有效位数
2、离散存储（链表）
　1)链表优缺点：
　　优点：空间没有限制，插入删除元素快
　　缺点：存取速度很慢。
　2)预备知识：typedef的用法：

typedef struct Student
{
    int sid;
    char name[100];
    char sex;
}*PST,ST;   //ST等价于struct Student，PST等价于:struct Student *
//给 struct Student类型的指针PST
//此时PST等价于:struct Student * 是一个指针

　　树与图都是靠链表实现的，所以，链表非常重要。
　3)定义：
　　n个节点离散分配
　　彼此通过指针相连
　　每个节点只有一个前去节点，每个节点只有一个后续节点。
　　首节点没有前驱结点，尾节点没有后续节点。
　　专业术语：
　　　首节点：
　　　　第一个有效节点
　　　尾节点：
　　　　最后一个有效节点，指向下一个元素的指针为空。
　　　头节点：
　　　　头节点数据类型与首节点数据类型相同
　　　　第一个有效节点前的节点
　　　　不存放有效数据
　　　　目的主要是为了方便对链表的操作。
　　　头指针：
　　　　指向头结点的指针变量
　　　尾指针：
　　　　指向尾节点的指针变量

　　如果希望通过一个函数来对链表进行处理，我们至少徐亚接收链表的那些参数（确定一个链表需要几个参数）：
　　　只需要一个参数：头指针
　　　因为我们通过头指针可以推算出链表的其他所有信息。
　　链表的定义：

typedef struct Node
{
    int data;               //数据域

    struct Node *pNext; //指针
}NODE,*PNODE;           //NODE等价于struct Node, PNODE等价于struct Node *

　4)分类：
　　单链表：
　　双链表：
　　　每个节点有两个指针域，指向前一个与后一个节点。
　　循环链表：
　　　能通过任何一个节点找到其他所有的节点。
　　非循环链表：
　5)算法：
　　遍历
　　查找
　　清空
　　销毁
　　求长度
　　排序
　　删除节点：

这里写图片描述

p->pNext = p->pNext->pNext; //内存泄漏(p后边节点的内存没释放)

不能free（p->pNext）;
正确做法：
r = p->pNext;           //r指向p后面的那个节点
p->pNext = r->pNext;
free（p->->pNext）;

　　插入节点：
　　　将新的节点q插入链表中p的后边：

这里写图片描述

r = p->pNext;  p->pNext = q;   q->pNext = r ;
或：q->pNext = p->pNext; p->pNext = q;

　　算法：
　　　狭义的算法与数据存储方式密切相关
　　　广义的算法与数据存储方式无关
　　　泛型：
　　　　利用某种技术达到的效果就是：不同的存储方式，执行的操作时一样的。
　　　学算法，最重要的不是自己编算法，重要的是看懂已有的算法。重要的是看懂答案。

3、线性结构的两种常见结构一：栈
　定义
　　一种可以实现“先进后出”的存储结构
　　栈类似于箱子，
　分类
　　静态栈
　　动态栈(用的较多)
　算法
　　出栈
　　压栈
　　每次压栈都压入栈顶
　应用
　　函数调用
　　中断
　　表达式求职
　　内存分配
　　缓冲处理
　　迷宫

4、线性结构的两种常见结构二：队列

5、专题：递归
　1)1+2+3+4….100的和（递归与循环的转换）
　2)求阶乘
　3)汉诺塔
　4)走迷宫

６、相关代码：
　１//链表操作代码
　２//数据存储位置相关代码
　３//栈操作相关代码

//链表操作代码
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

struct Node
{
    int data;               //数据与
    struct Node *pNext;     //指针域
}NODE ,*PNODE;      //NODE 等价于struct Node  PNODE等价于struct Node*

//函数声明
PNODE create_list(void);            //创建链表
void traverse_list(PNODE pHead);    //遍历链表
bool is_empty(PNODE pHead);         //判断链表为空
int length_list(PNODE);             //判断链表长度
bool insert_list(PNODE,int,int);    //插入    
//在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值是val，并且pos的值从1开始。
bool delete_list(PNODE,int,int *);  //删除
void sort_list(PNODE);              //排序

int main(void)
{
    PNODE pHead = NULL;     //等价于struct Node* pHead = NULL;

    pHead = create_list()       //创建一个非循环单链表，并将该链表的头结点的地址赋给pHead
    traverse_list(pHead);       //遍历链表

    //输出链表长度
    int len = length_list(pHead);
    printf("链表长度是%d",len);

    //判断链表是否为空
    if(is_empty(PNODE))
        printf("链表为空");
    else 
        printf("链表不为空");

    sort_list(pHead);           //排序
    traverse_list(pHead);       //遍历链表

    return 0;
}

PNODE create_list(void)
{
    int len,i,val;

    //分配了一个不存放有效数据的头节点
    PNODE pHead =  (PNODE)malloc(sizeof(NODE));
    if(NULL == pHead)
    {
        printf("分配失败");
        exit(-1);
    }

    //定义一个指向尾节点的指针
    PNODE pTail = pHead;
    pTail->pNext = NULL;

    printf("输入要生成链表节点的个数 : len = ");
    scanf("%d",%len);

    for(i=0;i<len;i++)
    {
        printf("请输入第%d个节点的值:",i+1);
        scanf("%d",&val);

        PNODE pNew = (PNODE)malloc(sizeof(NODE));
        if(NULL == pNew)
        {
            printf("分配失败");
            exit(-1);
        }
        pNew->data = val;
        pTail->pNext = pNew;
        pNew->pNext = NULL;
        pTail = pNew;
    }
    return pHead;
}

void traverse_list(PNODE pHead)
{
    PNODE p = pHead->pNext;

    while(NULL!=p)
    {
        printf("%d ",p->data);
        p = p->pNext;
    }
    printf("\n");

    return;
}

bool is_empty(PNODE pHead)
{
    if(NULL == pHead->pNext)
        return true;
    else
        return false;
}

int length_list(PNODE pHead)
{
    PNODE p = pHead->pNext;
    int cnt;

    while(NULL!=p)
    {
        cnt ++;
        p= p->pNext;
    }
    return cnt;
}

void sort_list(PNODE pHead)
{
    int i, j, t;
    PNODE p,q;

    int len = length_list(pHead);

    for(i=0,p = pHead->pNext;i<len-1;++i,p = p->pNext)
    {
        for(j=i+1,q = p->pNext;j<len;++j,q = q->pNext)
        {
            if(p->data > q->pNext)
            {
                t = p->data;        //类似于t=a[i];
                p->data = q->data;  //类似于a[i]=a[j];
                q->data = t;        //类似于a[j]=t;
            }
        }
    }

}

//在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值是val，并且pos的值从1开始。
bool insert_list(PNODE pHead,int pos,int val)       //插入
{
    int i=0;
    PNODE p = pHead;

    while(NULL !=p && i<pos-1)
    {
        p=p->pNext;
        ++i;
    }//指针p指向第pos个或最后一个节点。

    if(i>pos-1 || NULL = p)//pos小于1或pos大于链表长度
        return false;


    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    if(NULL== pNew)
    {
        printf("动态分配内存失败!");
        exit(-1);
    }
    pNew->data = val;

    //  pNew插入链表中
    PNODE q = p->pNext;
    p->pNext = pNew;
    pNew->pNext = q;

    retuen true;    
}

bool delete_list(PNODE pHead,int pos,int *pVal) //删除
{
    int i=0;
    PNODE p = pHead;

    while(NULL !=p->pNext&& i<pos-1)
    {
        p=p->pNext;
        ++i;
    }//指针p指向第pos-1个或最后一个节点。

    if(i>pos-1 || NULL = p->pNext)//pos小于1或pos大于链表长度
        return false;

    PNODE q = p->pNext;
    *pVal = q->data;

    //删除p节点后边的节点
    p->pNext = p->pNext->pNext;
    free(q);
    q = NULL;


    retuen true;    
}

//数据存储位置相关代码

#include<stdio.h>
#include<malloc.h>

void f(int k)
{
    int m;
    double *q = (doble *)malloc(200);
}

int main(void)
{
    int i = 10;     
    int *p = (int *)malloc(100);

    return 0;
}
//代码中 i、p、m、q，在栈里分配
//malloc开辟的100个，200个内存在堆里分配

//栈里的内存程序自动分配，动态内存需要程序员手动分配

//栈操作相关代码
/*
    创建
    压栈
    出栈
    遍历
    清空
*/

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

typedef struct Node
{
    intdata;
    struct Node *pNext;
}NODE, * PNODE;

struct Stack
{
    PNODE pTop;     //指向栈顶      
    PNODE pBottom;  //指向栈底
}STACK,* PSTACK;


void init(PSTACK);
void push(PSTACK pS,int val);
void traverse(PSTACK);
bool pop(PSTACK,int *);             //出栈
void clear(PSTACK pS);       //框架还在，里边的元素都没了

int main(void)
{
    STACK S;
    int val;

    init(&S);                   //  初始化
    push(&S,1);                 //压栈，不能指定位置，只能压栈到栈底
    push(&S,2);                 //压栈
    traverse(&S);               //遍历输出

    clear(&S);                  //清空
    traverse(&S);               //遍历输出

    if(pop(&S,&val))                //出栈
    {
        printf("出栈成功，出栈元素是%d\n",val);
    }
    else
    {
        printf("出栈失败");
    }

    return 0;
}

void init(PSTACK pS)
{
    pS->pTop = (PNODE)malloc(sizeof(NODE)); //栈顶，头结点(无数据节点)
    if(NULL == pS->pTop)
    {
            printf("分配失败");
    }
    else
    {
        pS->pBottom = pS->pTop;
        pS->pTop->pNext = NULL;     //pS->Bottom->pNext = NULL
    }
}
void push(PSTACK pS,int val)
{
    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    pNew->data = val;
    pNew->pNext = pS->pTop;         //新节点插入到原栈顶上方
    pS->pTop = pNew;                //新节点成为栈顶

    return;
}

void traverse(PSTACK pS)
{
    PNODE p = pS->pTop;

    while(p != pS->pBottom)
        {
        printf("%d  ",p->data);
        p=p->pNext;
        }
    printf("\n");
    retrun ;
}

bool empty(PSTACK pS)
{
    if(pS->pTop == pS->pBottom)
        return true;
    else
        return false;
}

//把pS所指向的栈出栈一次，并把出战的元素存入pVal形参所指向的变量中，
bool pop(PSTACK pS,int *pval)               //出栈
{
    if(empty(pS))
    {
        return false;
    }
    else
    {
        PNODE r = pS->pTop;
        *pval = r->data;
        pS->pTop = r->pNext;
        free(r);
        r = NULL;

        return true;
    }
}

void clear(PSTACK pS)       //框架还在，里边的元素都没了
{
    if(empty(pS))
    {
        return ;
    }
    else
    {
        PNODE p = pS->pTop;
        PNODE q = p->pNext;

        while(p!=pS->pBottom)
        {
            q=p->pNext;
            free(p);
            p = q;
        }
        pS->pTop = pS->pTop;
    }

/*自己写的代码
    PNODE r;

    while(NULL != pS->pTop )
    {
        r = pS->pTop;
        pS->pTop = r->pNext;
        free(r);
    }
*/
}
夏公瑾
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
郝斌老师数据结构数组和链表学习笔记
m0_46653117的博客
04-03 153
模块一：线性结构【把所有的结点用一根直线穿起来】 连续存储【数组】 1、什么叫数组？ # include <stdio.h> # include <malloc.h> # include <stdlib.h> typedef char bool; #define false 0 #define true 1 //定义了一个数据类型 struct Arr {...
郝斌 数据结构源代码和数据结构 大纲
11-23
5. **树**：树是一种非线性的数据结构，由节点和边构成。二叉树是最简单的一种，每个节点最多有两个子节点。二叉搜索树、平衡二叉树（如AVL树和红黑树）是常见的树形结构，它们在查找、插入和删除操作中表现出高效率...
【数据结构(郝斌)】01模块介绍
paxlhhh
07-07 104
郝斌老师的数据结构01-模块介绍
郝斌数据结构笔记01：课程笔记大纲
向东的笔记本
04-11 411
此数据结构笔记系列是笔者向东在学习郝斌老师【数据结构自学视频】这门课的学习记录，该课程可在哔哩哔哩免费学习，点击前面括号中课程名字可以直达课程页面。 同时欢迎大家关注我的微信公众号【程序员向东】，本公众号专注分享Python、爬虫学习资料与干货！后台回复「PYTHON」，送你一个学习大礼包！ 1.学习大纲 数据结构概述 预备知识 模块一：线性结构 连续存储（实际上就是数组） ...
数据结构（郝斌课程内容概述）
frighting_ing的博客
08-10 339
数据结构概述 定义 我们如何把现实中大量而复杂的问题以特定的数据类型和特定的存储结构保存到主存储器（内存）中，以及在此基础上为实现某个功能（比如查找某个元素，删除某个元素，对所有元素进行排序）而执行的相应操作，这个相应的操作也叫算法 数据结构 = 个体的存储 + 个体的关系存储 算法 = 对存储数据的操作 算法 解题的方法和步骤 衡量算法的标准 时间复杂度：大概程序要执行的次数，而非执行的时间 空间复杂度：算法执行过程中大概所占的最大内存 难易程度 健壮性 数据结构的地位 数据结构是软件
郝斌老师数据结构学习笔记（评论区附视频和源代码）
weixin_45708609的博客
11-15 1473
数据结构的学习
郝斌_数据结构入门笔记
JUSTfFUN的博客
02-09 1385
该笔记与郝斌《数据结构》视频课程相同 用者自取，自由分享
程序基础：数据结构（郝斌讲解）（一）
去向前方的博客
05-16 1016
开始写博客，目标一周一个项目总结，可能是一个具体的问题的求解方法，也可能是一周的学习笔记，还可能是一个算法的实现。 从2013年开始补起来 本周学习重点 数据结构 什么是数据结构？ 数据结构概述：数据结构，简单的说是怎么把数据存在电脑里方便我们处理 1定义 书籍作者：严蔚明，吴伟民，高一凡，黄国瑜。 数据结构定义： 将现实中大量复杂的问题以特定的数据类型和特定存储结构保存...
数据结构_郝斌老师自学大纲
Tomotoes.com
03-05 1734
数据结构概述（教材选用严蔚敏、吴伟民，该书程序是伪算法 具体的程序是高一凡，西电的，大牛，只有 程序。还有一本书，台湾的黄国瑜自己写的 只有思路，程序是另外一个合作的清华的写 的，可惜很多错的。） 学完数据结构之后会对面向过程的函数有一个更深的了解 定义
郝斌数据结构笔记
酱油哥的博客
02-28 1667
数据结构定义：        我们如何把现实中大量而复杂的问题以特定的数据类型和特定的存储结构保存到主存储器（内存）中，以及在此基础上为实现某个功能而执行的相应的操作（比如查找某个元祖，删除某个元素，对某个元素进行排序），这个相应的操作也叫作算法。 数据结构 = 个体 + 个体的关系         算法定义： 结题的方法和步骤 算法 = 对存储结构的
数据结构郝斌源码
12-08
1. **线性数据结构**：线性数据结构是一组数据元素按照线性的顺序排列，如数组、链表、队列和栈。数组是最基础的数据结构，提供随机访问但插入和删除操作较慢。链表则解决了数组在动态扩展时的效率问题，但访问元素...
郝斌数据结构笔记.pdf
09-11
郝斌数据结构笔记 数据结构概述： 数据结构是指在计算机中对数据的存储、组织和管理的方式。它是软件最核心的课程，学完了啥也干不了。数据结构 = 个体的存储 + 个体的关系存储，算法 = 对存储数据的操作。 知识点...
郝斌数据结构自学视频
07-23
资源名称：郝斌数据结构自学视频教程内容：┣━10_跨函数使用内存讲解及其示例┣━11_复习┣━12_连续存储数组的算法演示_1┣━13_连续存储数组的算法演示_2┣━14_链表的重要性┣━15_typedef的用法3┣━16_链表的...
郝斌数据结构视频源代码和大纲下载
10-20
数据结构是计算机科学中的核心课程之一，它主要研究如何在计算机中组织和管理数据，以提高数据处理的效率。郝斌老师的《数据结构》视频教程是许多初学者和专业人士学习此领域的宝贵资源。该压缩包文件包含了郝斌老师...
数据结构—链式二叉树-C语言
h_number_1的博客
07-11 999
上述内容，即是我个人对数据结构-链式二叉树-搜索二叉树-C语言的个人见解以及自我实现。若有大佬发现哪里有问题可以私信或评论指教一下我这个小萌新。
数据结构专项-字符串
qq_52241267的博客
07-16 124
面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。深拷贝和浅拷贝：浅拷贝实际上是复制了被拷贝对象的引用，也就是说浅拷贝的和被拷贝对象指向的是同一块内存空间，而深拷贝则是连同引用的对象也被拷贝，两者指向的是不同的内存空间。然后计算乘法，故之后是*，再计算加法，因此+要在6的前面，不然就是计算4*(x+3)+6了，故选D。中缀表达式中应该先计算x+3，因此后缀表达式中+应该出现在x和3的后面，排除BC。
数据结构（Java）：队列&Queue集合&力扣面试OJ题
2401_83595513的博客
07-12 2697
队列、Queue、Deque、循环队列、队列OJ题
【Java--数据结构】二叉树
最新发布
2301_80898480的博客
07-16 833
如有错误，欢迎指出~

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值