一、数据结构与算法练习整理

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

1.关于栈的应用实例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
typedef struct Node // 节点
{
    int data;
    struct Node *pNode;
} NODE, *PNODE;

typedef struct Stack // 栈
{
    PNODE pTop;
    PNODE pBottom;
} STACK, *PSTACK;

void init_stack(PSTACK); // 初始化
void push_stack(PSTACK); // 压栈
bool go_stack(PSTACK);   // 出栈
void traverse_stack(PSTACK ps)
{
    if (NULL == ps->pBottom)
    {
        printf("该栈已销毁！请初始化。\n");
        return 0;
    }
    else if (ps->pTop == ps->pBottom)
    {
        printf("空栈！\n");
        return 0;
    }
    PNODE t = ps->pTop;
    while (t != ps->pBottom)
    {
        printf("%d\n", t->data);
        t = t->pNode;
    }
    return 0;
}
void empty_stack(PSTACK);   // 清空
void destroy_stack(PSTACK); // 销毁
// 主函数
int main(void)
{
    STACK s;
    init_stack(&s);
    push_stack(&s);
    push_stack(&s);
    push_stack(&s);
    go_stack(&s);
    traverse_stack(&s);
    empty_stack(&s);
    traverse_stack(&s);
    // destroy_stack(&s);
    // traverse_stack(&s);
    return 0;
}
// 初始化
void init_stack(PSTACK ps)
{
    ps->pTop = (PNODE)malloc(sizeof(NODE));
    if (ps->pTop == NULL)
    {
        printf("内存不足！1\n");
        exit(-1);
    }
    ps->pBottom = ps->pTop;
    ps->pBottom->pNode = NULL;
    return;
}
void push_stack(PSTACK ps)
{
    PNODE t = (PNODE)malloc(sizeof(NODE));
    if (NULL == t)
    {
        printf("内存不足！2\n");
        exit(-1);
    }
    printf("要压值：");
    scanf("%d", &t->data);
    t->pNode = ps->pTop;
    ps->pTop = t;
    return;
}
// 出栈
bool go_stack(PSTACK ps)
{
    if (ps->pTop == ps->pBottom)
    {
        printf("空栈！");
        return false;
    }
    PNODE t = ps->pTop;
    printf("出栈的元素是：%d\n", t->data);
    ps->pTop = ps->pTop->pNode;
    free(t);
    return true;
}
// 遍历

void empty_stack(PSTACK ps)
{
    while (ps->pTop != ps->pBottom)
    {
        PNODE t = ps->pTop;
        ps->pTop = ps->pTop->pNode;
        free(t);
    }
    printf("已清空！\n");
    return;
}

2、关于循环队列的应用实例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//该长度要大于实际操作队列长度+1，以避免数据刚好卡在临界情况
#define len_size 13
typedef struct buffer
{
    int buf[len_size];
    volatile int in;
    volatile int out;
} ris_buf;
/* 循环队列 ，对数据要求要小于队列长度的数据传输才可，超出队列长度数据传输会出现两种情况
1、一种是刚好是队列长度的数据长度，传输为零。
2、超出队列长度的数据，其长度传输为超出的数据长度。*/
//入队
int write(ris_buf *sring, int *wbuf, int len)
{
    int i;

    for (i = 0; i < len; i++)
    {
        if ((sring->in + 1) % len_size == sring->out)
        {
            printf("full");
        }
        sring->buf[sring->in] = wbuf[i];
        sring->in = (++(sring->in)) % len_size;
    }
    return 0;
}
//出队
int read(ris_buf *sring, int *rbuf, int len)
{
    int i;
    for (i = 0; i < len; i++)
    {
        if (sring->out == sring->in)
        {
            printf("NULL");
        }
        rbuf[i] = sring->buf[sring->out];
        sring->out = (++sring->out) % len_size;
    }
    return 0;
}
//获取队列中的数据长度
int date_len(ris_buf *sring)
{

    return (sring->in - sring->out + len_size) % len_size;
}

int main(int argc, char **argv)
{
    ris_buf ringbuf = {0};
    /*要写入数据区的数据*/
    int buf1[12] = {164, 7, 89, 41, 12, 3, 97, 81, 23, 12, 56, 78};
    /*接收数据区*/
    int buf3[12] = {0};
    /*进行数据入队操作*/
    write(&ringbuf, buf1, 12);
    /*进行出队操作，buf3的数据应当和buf1的数据一致。*/
    read(&ringbuf, buf3, date_len(&ringbuf));
    int i=0;
    do
    {
    printf(" $ %d \n",buf3[i]);
	i++;
	}while(i<12)
    printf("\n");
    getchar();
    return 0;
}

3、关于单项队列应用实例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct stdool
{
    int *buf;
    int in;
    int out;
    int size;

} std;
// 单项队列受限于in和out的数据类型的最大值。
std stdol;
#define min(x, y) ((x) < (y) ? (x) : (y))
int init(int *rbuf, int size)
{
    std *per = &stdol;
    if (rbuf == NULL || size == 0)
    {
        return -1;
    }
    memset(per, 0, sizeof(stdol));
    per->buf = rbuf;
    per->in = per->out = 0;
    per->size = size;
    return 0;
}

int write(int *wbuf, int len)
{
    int i = 0, j = 0;
    std *per = &stdol;
    j = per->in % per->size;
    len = min(len, per->size - per->in + per->out);
    i = min(len, per->size - j);
    memcpy(per->buf + j, wbuf, i);
    memcpy(per->buf, wbuf + i, len - i);
    per->in += len;
    return len;
}

int read(int *rbuf, int len)
{
    int i = 0, j = 0;
    std *per = &stdol;
    j = (per->out % per->size);
    len = min(len, per->in - per->out);
    i = min(len, per->size - j);
    memcpy(rbuf, per->buf + j, i);
    memcpy(rbuf + i, per->buf, len - i);
    per->out += len;
    return len;
}
int get_speac_len()
{
    std *per = &stdol;
    return (per->size - (per->in - per->out));
}
int get_date_len()
{
    std *per = &stdol;
    return (per->in - per->out);
}
void clear()
{
    std *per = &stdol;
    per->in = per->out = 0;
}

int main(int argc, char **argv)
{

    int buf[10] = {0}, buf1[10] = {15, 49, 8, 71, 23, 19, 68, 7, 8, 9};
    int len;
    init(buf, sizeof(buf));

    write(buf1, sizeof(buf));
    len = get_date_len();
    if (len > 0)
    {
        len = len > 40 ? 40 : len;
        read(buf, len);
    }
    int i = 0;
    while (i < 10)
    {
        printf("$ %d \n", buf[i]);
        i++;
    }
    getchar();
    return 0;
}

4、单链表的应用实例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
typedef struct list
{
    int date;
    struct list *next;

} li, *lis;
/*
    单链表
    1、初始化
    2、显示
    3、头插
    4、插入
    5、删除
    6、删除
    7、排序
*/
lis init(lis new)
{
    new = (lis)malloc(sizeof(li));
    new->next = NULL;
    return new;
}
// 显示数据
int show(lis n_list)
{

    while (n_list->next)
    {
        n_list = n_list->next;
        printf("-%d", n_list->date);
    }
    return 0;
}
// 以头插入法进行插入
lis add(lis n_list, int date)
{
    lis new = (lis)malloc(sizeof(li));
    new->date = date;
    new->next = NULL;
    new->next = n_list->next;
    n_list->next = new;
    return n_list;
}
// 在x位置插入数据date
bool insert(lis n_list, int x, int date)
{

    int i = 0;
    while (n_list != NULL && i < x - 1)
    {
        n_list = n_list->next;
        ++i;
    }
    if (i > x - 1 || NULL == n_list)
    {
        return 0;
    }
    lis new = (lis)malloc(sizeof(li));
    new->next = NULL;
    new->date = date;

    new->next = n_list->next;
    n_list->next = new;
    return 1;
}
// 删除x位置数据
bool delets(lis n_list, int x)
{
    int i = 0;
    lis p;
    while (n_list->next != NULL && i < x - 1)
    {
        n_list = n_list->next;
        p = n_list;
        ++i;
    }
    if (i > x - 1 || n_list->next == NULL)
    {
        return 0;
    }
    lis q = p->next;
    p->next = p->next->next;
    free(q);
    q = NULL;
    return 1;
}
// 查找date数据的位置，与出现的总数量
lis find(lis list_n, int date)
{
    int i, j;
    while (list_n->next)
    {
        if (list_n->date == date)
        {
            i++;
            printf("%d", j); // 序号
        }
        j++;
        list_n = list_n->next;
    }
    printf("tol: %d ", i); // 总数量

    return list_n;
}
// 更改node位置的数据为date
lis list_exch(lis list_n, int node, int date)
{
    for (int i = 1; i < node; i++)
    {
        list_n = list_n->next;
    }
    add(list_n, date);
    return list_n;
}
// 该种删除数据只能删除遇到第一个相同数据，当数据中存在多个相同数据时操作就不实用了。
lis del(lis n_list, int date)
{
    lis p;
    while (n_list->date != date)
    {
        p = n_list;
        n_list = n_list->next;
        /* code */
    }

    p->next = n_list->next;

    free(n_list);
    return n_list;
}
// 排序
int sort(lis n_list, int len)
{
    lis p, q, t;
    int j, i;
    for (i = 0, p = n_list->next; i < len - 1; i++, p = p->next)
    {
        for (j = i + 1, q = p->next; j < len; j++, q = q->next)
        {
            if ((p->date) > (q->date))
            {
                p->date = p->date ^ q->date;
                q->date = p->date ^ q->date;
                p->date = p->date ^ q->date;
            }
            /* code */
        }
    }

    return 0;
}

int main(int argc, char **argv)
{
    lis list_new = init(list_new);

    for (int i = 1; i < 10; i++)
    {
        add(list_new, i);
    }
    show(list_new);
    printf("--\n");

    insert(list_new, 5, 56);
    show(list_new);
    printf("--\n");
    // del(list_new, 3);
    delets(list_new, 4);
    show(list_new);
    printf("--\n");
    sort(list_new, 9);
    show(list_new);

    getchar();
    return 0;
}

5、双向链表的应用实例

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

typedef struct list
{
    int date;
    struct list *prev;
    struct list *next;
} li, *lis;
/*双向链表
1、初始化
2、尾加法
3、插入
4、删除
6、显示

*/
lis init(lis list_n)
{
    list_n = (lis)malloc(sizeof(li));
    list_n->date = 0;

    list_n->next = list_n->prev = NULL;

    return list_n;
}
lis add(lis list_n, int x)
{
    int date;
    for (int i = 0; i < x; i++)
    {
        printf("请输入：");
        scanf("%d", &date);

        lis node = (lis)malloc(sizeof(li));
        node->date = date;
        node->next = node->prev = NULL;

        list_n->next = node;
        node->prev = list_n;

        list_n = list_n->next;
    }
    return list_n;
}
lis insert(lis list_n, int x, int date)
{
    lis node = (lis)malloc(sizeof(li));
    node->date = date;
    node->next = node->prev = NULL;

    if (x == 1)
    {
        node->next = list_n;
        list_n->prev = node;
        list_n = node;
    }
    else
    {
        for (int i = 1; i < x - 1; i++)
        {
            list_n = list_n->next;
        }
        if (list_n->next == NULL)
        {
            list_n->next = node;
            node->prev = list_n;
        }
        else
        {
            list_n->next->prev = node;
            node->next = list_n->next;
            list_n->next = node;
            node->prev = list_n;
        }
    }
    return list_n;
}

lis del(lis list_n, int date)
{
    while (list_n)
    {
        if (list_n->date == date)
        {
            list_n->prev->next = list_n->next;
            list_n->next->prev = list_n->prev;
            free(list_n);
            return list_n;
        }
        list_n = list_n->next;
    }
    return list_n;
}

lis show(lis list_n)
{
    while (list_n->next)
    {
        list_n = list_n->next;
        printf("-%d", list_n->date);
    }
}

int main(int argc, char **argv)
{
    lis list;
    int x, xi;
    list = init(list);

    add(list, 5);
    printf("\n");
    show(list);

    printf("\n");
    puts("请输入要删除的数值：");
    scanf("%d", &x);
    del(list, x);
    show(list);

    printf("\n");
    puts("请输入在第x位置要插入的数值：");

    scanf("%d %d", &xi, &x);
    insert(list, xi + 1, x);
    show(list);
    getchar();
    return 0;
}
离凌寒
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【超全汇总】学习数据结构与算法，计算机基础知识，看这篇就够了
帅地
01-18 10万+
由于文章有点多，并且发的文章也不是一个系列一个系列发的，不过我的文章大部分都是围绕着 数据结构 + 算法 + 计算机网络 + 操作系统 + Linux + 数据库 这几个方面发的，为了方便大家阅读，我整理了一波。不过公众号可以说是不支持修改文章，因为我决定每两三个月就整理一次，会非常详细着按照类别整理出来哦，并且也给出了目录哦。大家记得多看看哦，好多文章都是面试中常问滴 文章目录一、经验/经历/所...
学算法先学数据结构？是否是无稽之谈？
热门推荐
英雄哪里出来
03-02 2万+
头发没了
数据结构与算法之美
qq_40003391的博客
04-13 1424
的情况进行特殊处理。如果我们引入哨兵结点，在任何时候，不管链表是不是空，head 指针都会一直指向这个哨兵结点。我们也把这种有哨兵结点的链表叫带头链表。相反，没有哨兵结点的链表就叫作不带头链表。
数据结构与算法
qq_40093255的博客
08-15 1087
第一章 数据结构与算法 一.算法的基本概念 计算机解题的过程实际上是在实施某种算法，这种算法称为计算机算法。 1.算法的基本特征：可行性，确定性，有穷性，拥有足够的情报。 2.算法的基本要素：算法中对数据的运算和操作、算法的控制结构。 3.算法设计的基本方法：列举法、归纳法、递推、递归、减半递推技术、回溯法。 4.算法设计的要求：正确性、可读性、健壮性、效率与低存储量需求 二.算法的复杂度 1.算...
数据结构与算法01：绪论【LEARN FROM 李春葆《数据结构教程》】
是谢添啊
09-11 2103
数据：所有能够输入到计算机中，且能被计算机处理的符号的集合。数据结构中主要讨论结构化数据。数据元素：是数据（集合）中的一个“个体”，它是数据的基本单位。数据项：数据项是用来描述数据元素的，它是数据的最小单位。数据对象：具有相同性质的若干个数据元素的集合，如整数数据对象是所有整数的集合。默认情况下，数据结构中讨论的数据都是数据对象。数据结构。
数据结构之算法复杂度篇
终为nullptr
07-27 1229
如何写出高效率的代码，先来了解时间复杂度和空间复杂度吧，本篇将带你详解算法复杂度。
算法+数据结构 Python实现 + 图解
noobiee的博客
03-12 3206
排序算法 Sorting algorithms 插入排序 (Insertion sort) 第n个元素依次比较前n-1个已排序好的数组元素直到插入相应位置 平均时间复杂度：O(n²) 空间复杂度：O(1) def insertion_sort(seq): for j in range(1, len(seq)): key = seq[j] i = j - 1 while i >= 0 and seq[i] > key: seq[i + 1] = seq[i]
数据结构与算法题目及C++解答
Ankang的博客
06-03 1万+
前言 题目主要按照类型进行整理，包括leetcode，nowcoder等网站，对于可以使用多种方法的题目，不重复列举。推荐书籍《数据结构与算法分析--C++语言描述》第四版。 本文中所有源代码及博客中其他文章的VS源代码均在github：https://github.com/AnkangH，根据名称检索即可。 1.排序算法 SortAlgorithm 排序算法的源码见博客内排序算法的文章。...
一、如何学习数据结构与算法
RobertLab
10-11 628
文章目录什么是数据结构？什么是算法？(是什么)学习重点(学什么)学习技巧(怎么学)flag(制定目标) 什么是数据结构？什么是算法？(是什么) 数据结构是为算法服务的，算法要作用在特定的数据结构之上。 因此，我们无法孤立数据结构来讲算法，也无法孤立算法来讲数据结构； 举例： 图书馆储藏书籍你肯定见过吧？为了方便查找，图书管理员一般会将书籍分门别类进行“存储”。按照一定规律编号，就是书籍这种“数据”...
【数据结构和算法】如何学习数据结构与算法 ？过来人的建议（一）【方法篇】
Linux猿
07-01 1万+
学习数据结构与算法，过来人的建议！
leetcode卡-data-structure-algorithm:数据结构与算法练习与整理
07-06
数据结构与算法练习与整理 leetcode 练习 es6编写代码 jest做单元测试 简单算法 字符串 数组 正则 排序 递归 字符串 知识点： String.prototype.split String.prototype.match Array.prototype.map Array.prototype....
OnlineJudgeSolutions:数据结构与算法笔记
04-02
C ++学习 基础数据结构 ...第二阶段任务：PAT甲级练习数据结构 第二阶段任务，2020年3月4号开始，慢慢刷吧。比较难的数据结构还是不会。 第三阶段任务：leetcode按类型刷 2021年3月4号重启算法，慢慢来吧。
华为OD算法题练习与解答
06-18
本项目选取华为OD算法题，主要是该套算法题都是基于具体场景，通过精选100分题、200分题以及其他100分题能扩大数据结构知识体系，并采用模块化代码，形成解题思路。 **试题来源：** 华为OD联盟整理收集 ## 使用...
数据结构知识总结与结构网图
08-14
此外，还包括了常用的数据结构算法，如查找、排序和遍历等。该资源以简明易懂的方式呈现，旨在帮助读者快速掌握数据结构的基本理论和实际运用。 适用人群: 该资源适用于计算机科学、软件工程、数据科学等相关专业的...
北京地铁用什么数据结构来处理
qq_43071699的博客
06-23 339
北京地铁线路可以被建模为一个有向加权图，其中每个站点是一个节点，线路之间的连接是边，边的权重可以代表线路的长度、旅行时间或换乘成本。实际上，为了满足复杂的查询需求和实时性要求，现代地铁信息系统还会结合数据库技术（如关系型数据库或NoSQL数据库）、索引结构以及大数据处理框架，以实现数据的有效管理和高性能查询。：在实现诸如Dijkstra算法等寻找最短路径的算法时，优先队列（如二叉堆）用于维护待探索节点的顺序，确保每次都能访问到当前估计距离最小的节点。：用于存储地铁线路信息、站点列表等基础数据。
考研系列-数据结构第六章：图（上）
Nelson_hehe的博客
06-21 353
本文是408考研付费专栏系列-数据数据结构图章节（上半部分），本章内容比较多，本文先对图的概念包括定义、图的种类、度、边、连通性等术语进行总结，对几种特殊图的特征进行汇总对比；然后详细总结一下图的几种存储方式，最后对图的一些基本操作和实现方式进行总结整理。
常见排序算法及其C语言实现
最新发布
naughty0809的博客
06-24 692
概述： 排序算法在计算机科学中是一个非常重要的主题。本文将详细介绍几种常见的排序算法，包括快速排序、归并排序、堆排序、冒泡排序、选择排序、插入排序、桶排序和二分查找插入排序，并提供每种算法的C语言实现代码。
数据结构_绪论
qq_54503901的博客
06-21 536
描述操作执行之前数据结构和参数应满足的条件,若不满足,则操作失败,并返回相应出错信息.若初始条件为空,则省略。在使用高级程序设计语言编写程序时,必须对程序中出现的每个变量,常量或表达式,明确说明他们所属的。数据元素不是孤立存在的,他们之间存在着某种关系,数据元素相互之间的关系称之为。而另一些常用的数据结构,如栈,队列,树,图等,不能直接用数据类型来表示。对象 集合N={0,(-/+)1,(-/+)2,(-/+)3...}其中D是数据对象,S是D上的关系集,P是对D的基本操作。
数据结构_二叉树
m0_73620971的博客
06-20 677
1、一棵 n 个结点的树有 n-1 条边。2、二叉树不存在度大于 2 的结点。3、二叉树的存储结构分为：顺序存储和链式存储。4、前序（根左右）；中序（左根右）；后序（左右根）。5、层序遍历：自上而下、从左至右逐层访问树的结点的遍历过程。
数据结构 与 基础算法，语雀导出的
09-04
数据结构与基础算法是计算机科学中非常重要的一门学科，它与很多其它领域都有紧密的联系。数据结构是组织和存储数据的方式，而基础...因此，数据结构与基础算法是每个计算机科学学习者都应该重视和深入学习的内容之一。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值