数据结构第二天

最新推荐文章于 2024-10-16 10:35:43 发布
最新推荐文章于 2024-10-16 10:35:43 发布
阅读量545 收藏 9
点赞数 13
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77143270/article/details/141267583
版权
分文件编程实现：

main.c

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

int main(int argc, char const *argv[])
{
    seqlist_p p = CreateEpSeqlist();
    InsertIntoSeqlist(p, 0, 10);
    InsertIntoSeqlist(p, 1, 20);
    InsertIntoSeqlist(p, 2, 30);
    ShowSeqlist(p);

    DeleteIntoSeqlist(p, 1);
    ShowSeqlist(p);

    ChangePostSeqList(p, 0, 99);
    ShowSeqlist(p);

    printf("search 99:%d\n", SearchDataSeqList(p, 99));
    return 0;
}

seqlist.c

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

// 创建一个空的顺序表
seqlist_p CreateEpSeqlist() //create创造 empty 空的 seqlist顺序表
{
    //动态申请一块顺序表结构体大小空间
    seqlist_p p = (seqlist_p)malloc(sizeof(seqlist_t));
    if (NULL == p)
    {
        perror("malloc lost"); //perror打印上一个函数报的错误信息
        return NULL;           //错误情况让函数返回空指针
    }
    //对结构体初始化
    p->last = -1;

    return p;
}

//判断顺序表是否为满，满返回1,未满返回0
int IsFullSeqlist(seqlist_p p) //full满
{
    return p->last + 1 == N;
}

//向顺序表的指定位置插入数据
int InsertIntoSeqlist(seqlist_p p, int post, int data)
{
    //容错判断：判满，对post做判断
    if (IsFullSeqlist(p) || post < 0 || post > p->last + 1)
    {
        printf("InsertIntoSeqlist err\n");
        return -1; //错误返回
    }
    //让最后一个元素到插入位置的元素向后移动一个单位
    for (int i = p->last; i >= post; i--)
        p->data[i + 1] = p->data[i];
    //插入数据
    p->data[post] = data;
    //让last加一
    p->last++;
    return 0;
}

//遍历顺序表sequence顺序list表
void ShowSeqlist(seqlist_p p)
{
    for (int i = 0; i <= p->last; i++)
        printf("%d ", p->data[i]);
    printf("\n");
}

//判断顺序表是否为空，为空返回1，不为空返回0
int IsEpSeqlist(seqlist_p p)
{
    return p->last == -1;
}

//删除顺序表中指定位置的数据，post为删除位置
int DeleteIntoSeqlist(seqlist_p p, int post)
{
    //容错判断：判空，对post判断
    if (IsEpSeqlist(p) || post < 0 || post > p->last)
    {
        printf("DeleteIntoSeqlist err\n");
        return -1;
    }

    //从删除位置元素的后一个元素到最后一个元素向前移动一个单位
    for (int i = post + 1; i <= p->last; i++)
        p->data[i - 1] = p->data[i];

    //让last减一，因为删除了一个元素有效元素少了一个
    p->last--;

    return 0;
}

// 修改指定位置上数据
int ChangePostSeqList(seqlist_p p, int post, int data)
{
    //容错判断：判空，对post判断
    if (IsEpSeqlist(p) || post < 0 || post > p->last)
    {
        printf("ChangePostSeqList err\n");
        return -1;
    }

    //修改指定位置数据
    p->data[post] = data;

    return 0;
}

// 查找指定数据出现的位置,返回下标，未找到返回-1
int SearchDataSeqList(seqlist_p p, int data)
{
    for (int i = 0; i <= p->last; i++)
    {
        if (p->data[i] == data)
            return i;
    }
    return -1;
}

// 清空顺序表（清空：访问不到，但是内存中还有。销毁：内存清空）
void ClearSeqList(seqlist_p p)
{
    p->last = -1;
}

seqlist.h

#ifndef __SEQLIST_H__
#define __SEQLIST_H__
#define N 10
typedef struct seqlist //封装顺序表结构体类型
{
    int data[N]; //用来存数据的数组
    int last;    //代表数组中最后一个有效元素的下标
} seqlist_t, *seqlist_p;

// 创建一个空的顺序表
seqlist_p CreateEpSeqlist(); //create创造 empty 空的 seqlist顺序表

//判断顺序表是否为满，满返回1,未满返回0
int IsFullSeqlist(seqlist_p p); //full满

//向顺序表的指定位置插入数据
int InsertIntoSeqlist(seqlist_p p, int post, int data);

//遍历顺序表sequence顺序list表
void ShowSeqlist(seqlist_p p);

//判断顺序表是否为空，为空返回1，不为空返回0
int IsEpSeqlist(seqlist_p p);

//删除顺序表中指定位置的数据，post为删除位置
int DeleteIntoSeqlist(seqlist_p p, int post);

// 修改指定位置上数据
int ChangePostSeqList(seqlist_p p, int post, int data);

// 查找指定数据出现的位置,返回下标，未找到返回-1
int SearchDataSeqList(seqlist_p p, int data);

// 清空顺序表（清空：访问不到，但是内存中还有。销毁：内存清空）
void ClearSeqList(seqlist_p p);

#endif

makefile

CC=gcc
GFLAGS=-c -g -Wall
OBJS=seqlist.o main.o

seqlist:$(OBJS)
	$(CC) $^ -o $@
%.o:%.c
	$(CC) $(GFLAGS) $< -o $@
.PHONY:clean
clean:
	$(RM) seqlist *.o

顺序表特点：

  1. 顺序表内存空间连续
  2. 顺序表长度固定
  3. 插入和删除操作效率低，修改和查找效率高。

3.2 链表 Linklist

链表又称单链表、链式存储结构，用于存储逻辑关系为“一对一”的数据。

和顺序表不同同，使用链表存储数据，不强制要求数据在内存中集中存储，各个元素可以分散存储在内存中。

所以在链表中，每个数据元素可以配有一个指针用于找到下一个元素即节点，这意味着，链表上的每个“元素”都长下图这个样子：

3.2.1 链表的特性

逻辑结构：线性结构

存储结构：链式存储

特点：内存不连续，需要通过指针链接，大小不固定。解决顺序表插入删除麻烦的问题。

操作：增删改查

struct node
{
    int data;   //数据域：存储数据
    struct node *next;    //指针域：存储下一个节点的地址
};

3.2.2 单向链表

有头链表：存在一个头节点，头节点数据域无效，指针域有效。

无头链表：每一个节点的数据域和指针域都有效。

遍历无头单向链表

#include <stdio.h>
#include <stdlib.h>
typedef char datatype;
typedef struct node
{
    datatype data;     //数据域用来存数据
    struct node *next; //指针域用来存下一个节点的地址
} node_t, *node_p;

// node_t A; //等同于 struct node A;
// node_p p; //等同于 struct node *p;

int main(int argc, char const *argv[])
{
    //1.定义4个节点
    node_t A = {'a', NULL};
    node_t B = {'b', NULL};
    node_t C = {'c', NULL};
    node_t D = {'d', NULL};

    //2.连接四个节点
    A.next = &B; //连接A和B
    B.next = &C;
    C.next = &D;

    //3.定义一个头指针指向第一个节点
    node_p p = &A;

    //4. 通过指针遍历无头单向链表
    while (p != NULL)
    {
        printf("%c ", p->data); //打印节点中的数据域 a b c d
        p = p->next;            //让p指向下一个节点
    }
    printf("\n");

    return 0;
}

遍历有头单向链表

#include <stdio.h>
#include <stdlib.h>
typedef char datatype;
typedef struct node
{
    datatype data;     //数据域用来存数据
    struct node *next; //指针域用来存下一个节点的地址
} node_t, *node_p;

// node_t A; //等同于 struct node A;
// node_p p; //等同于 struct node *p;

int main(int argc, char const *argv[])
{
    //1.定义4个节点
    node_t A = {'a', NULL};
    node_t B = {'b', NULL};
    node_t C = {'c', NULL};
    node_t D = {'d', NULL};

    //2.连接四个节点
    A.next = &B; //连接A和B
    B.next = &C;
    C.next = &D;

    //3. 定义头节点，数据域无效，指针域有效
    node_t H = {'\0', &A};

    //4. 定义一个头指针，指向头结点
    node_p p = &H;

#if 0
    p = p->next; //先跨越头节点，指向第一个数据域有效的节点A
    while (p != NULL)    //相当于遍历无头链表
    {
        printf("%c ", p->data);
        p = p->next;
    }
    printf("\n");
#else
    while (p->next != NULL)
    {
        p = p->next;
        printf("%c ", p->data);
    }
    printf("\n");
#endif

    return 0;
}
链表尾插法练习

写一个有头单向链表，用于保存输入的学生成绩，实现一输入学生成绩就创建一个新的节点，将成绩保存起来。再将该节点链接到链表的尾，直到输入-1结束。

要求：每个链表的节点由动态内存分配得到 , 也就是用malloc。

过程：

  1. malloc申请空间link_node_t大小作为头节点
  2. 将新节点放到链表尾部

#include <stdio.h>
#include <stdlib.h>
typedef int datatype;
typedef struct node
{
    datatype data;
    struct node *next;
} node_t, *node_p;

int main(int argc, char const *argv[])
{
    node_p pnew = NULL;
    node_p ptail = NULL;
    int score = -1;

    //1. 创建一个头结点，用头指针p指向头节点
    node_p p = (node_p)malloc(sizeof(node_t));
    if (NULL == p)
    {
        perror("p malloc err");
        return -1;
    }
    p->next = NULL; //初始化头节点
    ptail = p;      //让尾指针一开始指向头节点

    //2. 循环输入学生成绩直到-1结束，创建新节点保存学生成绩，尾插到链表。
    while (1)
    {
        scanf("%d", &score);
        if (score == -1)
            break;

        //(1) 创建新节点用来保存学生成绩
        pnew = (node_p)malloc(sizeof(node_t));
        if (NULL == pnew)
        {
            perror("pnew malloc err");
            return -1;
        }
        //(2) 初始化新节点，数据域保存学生成绩，指针域置空
        pnew->data = score;
        pnew->next = NULL;
        //(3) 将新节点连接到链表尾部，也就是ptail所指节点的指针域等于新节点地址
        ptail->next = pnew;
        //(4) 将尾指针移动到新节点，因为尾指针ptail要一直指向最后一个节点
        ptail = pnew;
    }

    //3. 遍历有头链表
    while (p->next != NULL)
    {
        p = p->next;
        printf("%d ", p->data);
    }
    printf("\n");

    return 0;
}
有头单向链表的函数操作

插入指定位置节点：

删除指定节点：

#include <stdio.h>
#include <stdlib.h>
typedef int datatype;
typedef struct node
{
    datatype data;
    struct node *next;
} node_t, *node_p;

//创建一个空的有头单向链表
node_p createEmptyLinkList() //create创建 Empty空的 LinkList单向链表
{
    //开辟链表节点大小空间
    node_p p = (node_p)malloc(sizeof(node_t));
    if (NULL == p)
    {
        perror("createEmptyLinkList");
        return NULL;
    }
    //初始化头节点
    p->next = NULL;

    return p;
}

//计算链表的长度。
int lengthLinkList(node_p p)
{
    int len = 0;
    while (p->next != NULL)
    {
        p = p->next;
        len++;
    }
    return len;
}

//向单向链表的指定位置插入数据
//p保存链表的头指针 post 插入的位置 data插入的数据
int insertIntoPostLinkList(node_p p, int post, datatype data)
{
    //容错判断
    if (post < 0 || post > lengthLinkList(p))
    {
        printf("insertIntoPostLinkList err\n");
        return -1;
    }

    node_p pnew = NULL; //记录新节点
    // 将指针 遍历到插入位置的前一个节点
    for (int i = 0; i < post; i++)
        p = p->next;
    // malloc创建一个新节点， 初始化新节点
    pnew = (node_p)malloc(sizeof(node_t));
    if (NULL == pnew)
    {
        perror("insertIntoPostLinkList err");
        return -1;
    }
    pnew->data = data;
    pnew->next = NULL;
    // 连接新节点到链表， 先连后面，再连前面。(不然前面断了后面就找不到了)
    pnew->next = p->next;
    p->next = pnew;

    return 0;
}

//遍历单向链表
void showLinkList(node_p p)
{
    while (p->next != NULL)
    {
        p = p->next;
        printf("%d ", p->data);
    }
    printf("\n");
}

int isEmptyLinkList(node_p p)
{
}

//删除单向链表中指定位置的数据 post 代表的是删除的位置
int deletePostLinkList(node_p p, int post)
{
}

int main(int argc, char const *argv[])
{
    node_p p = createEmptyLinkList();

    for (int i = 0; i < 5; i++)
        insertIntoPostLinkList(p, i, i);
    showLinkList(p);

    insertIntoPostLinkList(p, -1, 10); //insertIntoPostLinkList err 容错判断打印结果

    return 0;
}

敲代码的鹏鹏
关注
数据结构C语言严蔚敏版(第二版)超详细笔记附带课后习题
chongyang_的博客
11-07 27万+
根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 用计算机解决实际问题时，步骤：首先分析实际问题，从中抽象出一个适当的数学模型，然后设计一个解决此数学模型的算法，最后编程，调试，测试。 寻求数据模型的实质是分析问题，从中提取出计算机处理的对象，并找出这些对象之间的关系，然后用数学的语言加以描述。 关键：分析问题中所用到的数据是如何组织的，研究数据之间存在什么样的关系。 由于数据必须在计算机中处理，因此不能局限于数据本身的数学问题的研究，还必须考虑数据的物理结构，即数据在计算机中的存储结构。 1.
python 数据结构篇
qq_62047219的博客
07-07 2万+
python中的数据结构实现：数组、链表（单链表、双向链表、双向循环链表）、队列（FIFO、LIFO/栈、优先级队列、双端队列）、树（二叉树、堆、树、森林）、图
《数据结构》C语言版 (清华严蔚敏考研版） 全书知识梳理
12 26 25 的博客
01-20 19万+
写在前面： 恰逢期末复习，用了几天时间结合老师勾画的重点以及课件教材等，将全书重要内容做了个大整合。一方面便于自己复习记忆，另一方面po出来让更多需要的人也可以做个参考。 同类梳理： 《数据库系统概论》第五版(王珊版）全书知识梳理 《计算机组成原理》第五版(唐朔飞考研版） 全书知识梳理 《数据结构》C语言版 (清华严...
C#数据结构与算法
qq_41603955的博客
03-15 7816
一、数据结构介绍 为什么学习数据结构？ 对于同样的问题，有的人写出来的程序效率高，而有的人却用很复杂的方法解决。 学习数据结构的目的是：能用最有效的方法解决绝大多数的问题。 学习数据结构的三个目的： 1.讲授常用的数据结构 这些数据结构形成了程序员基本数据结构工具箱(toolkit)。对于许多常见的问题，工具箱里的数据结构是理想的选择。就像.NET Framework 中 Windows 应用程序开发中的工具箱，程序员可以直接拿来或经过少许的修改就可以使用，非常方便。 2.讲授常用的算法 它和
学算法先学数据结构？是否是无稽之谈？
英雄哪里出来
03-02 3万+
头发没了
数据结构课设——成绩分析问题
weixin_64086347的博客
01-29 5830
数据结构课程设计——成绩分析问题
数据结构——哈希表
云杉木屋
03-24 1万+
摘要：本篇笔记主要讲解了重要数据结构——哈希表，以及键值对的含义，为什么要用键值对，哈希表的应用场景，以及内存中运行的数据库的基础知识
php中的数据结构详解
Demo不是emo的博客
09-14 2628
学习php的第五天，今天学习的是php中的数组和数据结构，话不多说直接开始
《算法和数据结构》题海战术篇
英雄哪里出来
09-12 5万+
刷了 3333 题 算法题 后的一点点经验总结 —— 题不是这么刷的！
《数据结构》C语言版（清华严蔚敏考研版） 全书知识梳理 + 练习习题详解（超详细清晰易懂）
热门推荐
繁凡さん的博客
04-15 22万+
《数据结构》知识梳理，适合考前复习，高分冲刺。包含大量习题，偷偷告诉你，考试就考这个
Java数据结构和算法中文第二版（扫描版）
09-04
Java数据结构和算法中文第二版（扫描版）Java数据结构和算法中文第二版（扫描版）Java数据结构和算法中文第二版（扫描版）
PTA数据结构第二章线性表
????的博客
01-08 2833
顺序表 1-8 对于顺序存储的长度为N的线性表，访问结点和增加结点的时间复杂度分别对应为O(1)和O(N)。 T F 1-10 对于顺序存储的长度为N的线性表，删除第一个元素和插入最后一个元素的时间复杂度分别对应为O(1)和O(N)。 T F 1-9 若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用顺序表存储最节省时间。 T F 1-11 线性表L如果需要频繁地进行不同下标元素的插入、删除操作，此时选择顺序存储结构更好。 T F 2-10 在N
数据结构—文件
南风fahaxiki
04-19 2544
和表类似,文件是大量记录的集合。习惯上称存储在主存储器(内存储器)中的记录集合为表,称存储在二级存储器(外存储器)中的记录集合为文件。本章讨论文件在外存储器中的表示方法及其各种运算的实现方法。 1.有关文件的基本概念 ·文件及其类别 文件(file)是由大量性质相同的记录组成的集合。可按其记录的类型不同而分成两类:操作系统的文件和数据库文件。 操作系统中的文件仅是一维的连续的字符序列,无结构、无解释。它也是记录的集合,这个记录仅是一个字...
数据结构课设——计算器
m0_56144302的博客
07-07 2330
在实验-03、实验-05的作业内容基础上 （1）增加图形交互功能。 （2）增加3个逻辑运算符&&、||、！，并能处理逻辑运算符和算术运算符的混合运算。 （3）增加容错功能，能进行异常处理。
Python 数据结构和算法面试题，使用 Jupyter Notebook 编写
最新发布
hallo128的博客
10-16 486
【代码】Python 数据结构和算法面试题，使用 Jupyter Notebook 编写。
82.【C语言】数据结构之顺序表的初始化和销毁
2401_85828611的博客
10-15 558
在软件开发中,存储列表常用顺序表或链表。定义:n个具有相同特性的数据元素的有限序列(相当于一条直线)(用数组存储),要求数据依次存储静态顺序表：使用定长数组存储元素动态顺序表:使用与动态内存管理有关的函数
数据结构和算法之树形结构B树(6)
Liusp的专栏
10-12 931
B树基本概念和插入删除场景介绍
数据结构——排序（2）
zoelinkailuo的博客
10-15 1397
前面已经介绍了直接插入排序、希尔排序、直接选择排序、堆排序、冒泡排序已经递归版本的快速排序，在本篇将接着介绍快速排序的非递归版本、归并排序以及计数排序。时间复杂度：O(nlogn)空间复杂度：O(n)计数排序在数据范围集中时，效率很⾼，但是适⽤范围及场景有限。时间复杂度：ONrange空间复杂度：Orange稳定性：稳定.
C 408—《数据结构》算法题基础篇—链表（下）
Cyan_RA9的博客
10-15 962
408考研——《数据结构》算法题基础篇之链表（下）。
线性表与一元多项式表示——《数据结构》第二章解析
"《数据结构》第二章讲义主要涵盖了线性表的逻辑结构和存储结构，包括顺序表示和链式表示，以及一元多项式的表示和相加。此外，还涉及了线性结构的基本特征和线性表的抽象数据类型定义，包括线性表上的各种基本操作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值