【数据结构】二叉树

已于 2023-03-05 10:13:09 修改
阅读量56 收藏
点赞数
分类专栏： 数据结构系列 文章标签： 数据结构
于 2022-10-04 12:19:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sustzc/article/details/127160988
版权

文章目录

1. 目录结构

├── binary_tree.c
├── Include
│   ├── binary_tree.h
│   ├── Queue
│   │   └── queue.h
│   └── Stack
│       └── stack.h
├── Makefile
├── queue.c
├── stack.c
└── test_binary_tree.c

2. Makefile

.PHONY: clean

CC = gcc
CFLAGS = -g -Wall -DDEBUG -std=c99
C_INCLUDE_PATH = -I ./Include/ -I ./Include/Queue/ -I ./Include/Stack/
#EXTRA_FLAGS = -DUSE_RECURSION

SOURCE = $(wildcard ./*.c)
BIN = test_binary_tree

$(BIN): $(SOURCE)
	$(CC) $(CFLAGS) $(EXTRA_FLAGS) $(C_INCLUDE_PATH) $(SOURCE) -o $@

clean:
	rm -rf $(BIN)

3. Include/

3.1 Queue/queue.h

/*
* File Name: queue.h
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#ifndef __QUEUE_H__
#define __QUEUE_H__

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

#ifdef __cplusplus
extern "C" {
#endif

typedef void * queue_data_t;
typedef struct node_s {
    queue_data_t data;
    struct node_s *next;
} node_t;

typedef struct queue_s {
    node_t *front;
    node_t *rear;
    int size;
} queue_t;

void init_queue(queue_t *queue);

int get_queue_size(const queue_t *queue);

int is_queue_empty(const queue_t *queue);

void queue_push(queue_t *queue, queue_data_t data);

void queue_pop(queue_t *queue);

queue_data_t get_front(const queue_t *queue);

queue_data_t get_back(const queue_t *queue);

void destroy_queue(queue_t *queue);

#ifdef __cplusplus
}
#endif

#endif // __QUEUE_H__

3.2 Stack/stack.h

/*
* File Name: stack.h
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#ifndef __STACK_H__
#define __STACK_H__

#include <stdio.h>

#ifdef __cplusplus
extern "C" {
#endif

#define MAX_STACK_SIZE 10

typedef void * stack_data_t;
typedef struct stack_s {
    stack_data_t data[MAX_STACK_SIZE];
    int top; /* stack top pointer  */
} stack_t;

void init_stack(stack_t *stack);

int get_stack_size(const stack_t *stack);

int is_stack_empty(const stack_t *stack);

int is_stack_full(const stack_t *stack);

stack_data_t get_stack_top(const stack_t *stack);

void stack_push(stack_t *stack, stack_data_t data);

void stack_pop(stack_t *stack);

void clear_stack(stack_t *stack);

void destroy_stack(stack_t *stack);

#ifdef __cplusplus
}
#endif

#endif // __STACK_H__

3.3 binary_tree.h

/*
* File Name: binary_tree.h
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#ifndef __BINARY_TREE_H__
#define __BINARY_TREE_H__

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

#ifdef __cplusplus
extern "C" {
#endif

typedef char binary_tree_data_t;
typedef struct binary_tree_s {
    binary_tree_data_t data;
    struct binary_tree_s *left;
    struct binary_tree_s *right;
} binary_tree_t;

binary_tree_t *build_binary_tree(binary_tree_data_t array[],
                                 int size,
                                 int *index);

void pre_order(const binary_tree_t *root);

void in_order(const binary_tree_t *root);

void post_order(const binary_tree_t *root);

void level_order(const binary_tree_t *root);

int get_binary_tree_size(const binary_tree_t *root);

int get_binary_tree_leaf_size(const binary_tree_t *root);

int get_binary_tree_k_layer_size(const binary_tree_t *root, int k);

int get_binary_tree_height(const binary_tree_t *root);

binary_tree_t *binary_tree_find_by_data(const binary_tree_t *root,
                                        binary_tree_data_t data);

bool is_complete_binary_tree(const binary_tree_t *root);

void destroy_binary_tree(binary_tree_t *root);

#ifdef __cplusplus
}
#endif

#endif // __BINARY_TREE_H__

4. queue.c

/*
* File Name: queue.c
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#include "queue.h"

void init_queue(queue_t *queue)
{
    queue->front = queue->rear = NULL;
    queue->size = 0;
}

int get_queue_size(const queue_t *queue)
{
    return queue->size;
}

int is_queue_empty(const queue_t *queue)
{
    return 0 == get_queue_size(queue);
}

void queue_push(queue_t *queue, queue_data_t data)
{
    node_t *new_node = (node_t *)calloc(1, sizeof(node_t));
    if (NULL == new_node) {
        perror("calloc new_node fail");
        return;
    }

    new_node->next = NULL;
    new_node->data = data;
    ++queue->size;

    if (NULL == queue->rear) {
        queue->front = queue->rear = new_node;
    } else {
        queue->rear->next = new_node;
        queue->rear = new_node;
    }
}

void queue_pop(queue_t *queue)
{
    if (is_queue_empty(queue)) {
        return;
    }

    node_t *pop_node = queue->front;
    queue->front = pop_node->next;
    free(pop_node);

    --queue->size;

    if (NULL == queue->front) {
        queue->rear = queue->front;
    }
}

queue_data_t get_front(const queue_t *queue)
{
    if (!is_queue_empty(queue) && queue->front) {
        return queue->front->data;
    }

    return NULL;
}

queue_data_t get_back(const queue_t *queue)
{
    if (!is_queue_empty(queue) && queue->rear) {
        return queue->rear->data;
    }

    return NULL;
}

void destroy_queue(queue_t *queue)
{
    node_t *cur = queue->front;
    node_t *next_node = NULL;

    for (; NULL != cur; cur = next_node) {
        next_node = cur->next;
        free(cur);
    }

    queue->front = queue->rear = NULL;
    queue->size = 0;
}

5. stack.c

/*
* File Name: stack.c
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#include "stack.h"

void init_stack(stack_t *stack)
{
    stack->top = 0;
}

int get_stack_size(const stack_t *stack)
{
    return stack->top;
}

int is_stack_empty(const stack_t *stack)
{
    return 0 == get_stack_size(stack);
}

int is_stack_full(const stack_t *stack)
{
    return MAX_STACK_SIZE == get_stack_size(stack);
}

stack_data_t get_stack_top(const stack_t *stack)
{
    return stack->data[stack->top - 1];
}

void stack_push(stack_t *stack, stack_data_t data)
{
    if (is_stack_full(stack)) {
        return;
    }

    stack->data[stack->top++] = data;
}

void stack_pop(stack_t *stack)
{
    if (is_stack_empty(stack)) {
        return;
    }

    --stack->top;
}

void clear_stack(stack_t *stack)
{
    stack->top = 0;
}

void destroy_stack(stack_t *stack)
{
    clear_stack(stack);
}

6. binary_tree.c

/*
* File Name: binary_tree.c
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#include "binary_tree.h"

#include "queue.h"
#include "stack.h"

binary_tree_t *build_binary_tree(binary_tree_data_t array[],
                                 int size,
                                 int *index)
{
    binary_tree_t *root = NULL;

    do {
        if (*index >= size) {
            break;
        }

        // '#' 代表叶子节点
        if ('#' == array[*index]) {
            ++(*index);
            break;
        }

        root = (binary_tree_t *)calloc(1, sizeof(binary_tree_t));
        if (NULL == root) {
            perror("calloc root fail");
            break;
        }

        root->data = array[*index];
        ++(*index);
        root->left = build_binary_tree(array, size, index);
        root->right = build_binary_tree(array, size, index);
    } while (0);

    return root;
}

void pre_order(const binary_tree_t *root)
{
#ifdef USE_RECURSION
    if (NULL != root) {
        printf("%c ", root->data);
        pre_order(root->left);
        pre_order(root->right);
    }
#else
    stack_t stack;
    binary_tree_t *cur = (binary_tree_t *)root;
    binary_tree_t *top = NULL;
    init_stack(&stack);

    // 当右子树为空时, 栈中可能还有元素, 即 此时 可能只是访问了 左子树
    while (NULL != cur || !is_stack_empty(&stack)) {
        while (NULL != cur) {
            // 1, 访问左路节点，左路节点入栈
            printf("%c ", cur->data);
            stack_push(&stack, cur);
            cur = cur->left;
        }

        // 2, 取出栈顶节点，用于访问它的右子树
        top = get_stack_top(&stack);
        stack_pop(&stack);
        // 3, 访问右子树
        cur = top->right;
    }

    destroy_stack(&stack);
#endif /// USE_RECURSION
}

void in_order(const binary_tree_t *root)
{
#ifdef USE_RECURSION
    if (NULL != root) {
        in_order(root->left);
        printf("%c ", root->data);
        in_order(root->right);
    }
#else
    stack_t stack;
    binary_tree_t *cur = (binary_tree_t *)root;
    binary_tree_t *top = NULL;
    init_stack(&stack);

    while (NULL != cur || !is_stack_empty(&stack)) {
        while (NULL != cur) {
            // 1, 左路节点入栈
            stack_push(&stack, cur);
            cur = cur->left;
        }

        // 2, 取出栈顶节点，先访问该节点
        top = get_stack_top(&stack);
        printf("%c ", top->data);
        stack_pop(&stack);
        // 3, 访问它的右子树
        cur = top->right;
    }

    destroy_stack(&stack);
#endif /// USE_RECURSION
}

void post_order(const binary_tree_t *root)
{
#ifdef USE_RECURSION
    if (NULL != root) {
        post_order(root->left);
        post_order(root->right);
        printf("%c ", root->data);
    }
#else
    stack_t stack;
    binary_tree_t *cur = (binary_tree_t *)root;
    binary_tree_t *prev = NULL;
    init_stack(&stack);

    while (NULL != cur || !is_stack_empty(&stack)) {
        while (NULL != cur) {
            // 1, 左路节点入栈
            stack_push(&stack, cur);
            cur = cur->left;
        }

        // 2, 取出栈顶节点
        binary_tree_t *top = get_stack_top(&stack);

        // 3, 栈顶节点的右子树不为空, 并且右子树还没被访问过
        if (NULL != top->right && prev != top->right) {
            cur = top->right;
        } else {
            // 如果栈顶节点的右子树为空, 那么可以直接访问根节点（左右 根）
            // 判断是不是 栈顶节点的右子树已经被访问过了（左右 根）
            printf("%c ", top->data);
            stack_pop(&stack);
            // 更新上一次访问的节点为 top
            prev = top;
        }
    }

    destroy_stack(&stack);
#endif /// USE_RECURSION
}

void level_order(const binary_tree_t *root)
{
    if (NULL == root) {
        return;
    }

    queue_t queue;
    binary_tree_t *queue_front = NULL;
    init_queue(&queue);
    queue_push(&queue, (queue_data_t)root);

    while (!is_queue_empty(&queue)) {
        queue_front = get_front(&queue);
        printf("%c ", queue_front->data);

        queue_pop(&queue);

        if (NULL != queue_front->left) {
            queue_push(&queue, (queue_data_t)queue_front->left);
        }
        if (NULL != queue_front->right) {
            queue_push(&queue, (queue_data_t)queue_front->right);
        }
    }

    destroy_queue(&queue);
}

int get_binary_tree_size(const binary_tree_t *root)
{
    if (NULL == root) {
        return 0;
    }

    return get_binary_tree_size(root->left) +
            get_binary_tree_size(root->right) + 1;
}

int get_binary_tree_leaf_size(const binary_tree_t *root)
{
    if (NULL == root) {
        return 0;
    }

    if (NULL == root->left && NULL == root->right) {
        return 1;
    }

    return get_binary_tree_leaf_size(root->left) +
            get_binary_tree_leaf_size(root->right);
}

int get_binary_tree_k_layer_size(const binary_tree_t *root, int k)
{
    if (NULL == root || k < 1) {
        return 0;
    }

    if (NULL != root && 1 == k) {
        return 1;
    }

    return get_binary_tree_k_layer_size(root->left, k - 1) +
            get_binary_tree_k_layer_size(root->right, k - 1);
}

int get_binary_tree_height(const binary_tree_t *root)
{
    if (NULL == root) {
        return 0;
    }

    int left_height = get_binary_tree_height(root->left);
    int right_height = get_binary_tree_height(root->right);

    return left_height > right_height ?
            left_height + 1 : right_height + 1;
}

binary_tree_t *binary_tree_find_by_data(const binary_tree_t *root,
                                        binary_tree_data_t data)
{
    if (NULL == root || data == root->data) {
        return (binary_tree_t *)root;
    }

    binary_tree_t *found = binary_tree_find_by_data(root->left, data);
    if (NULL != found) {
        return found;
    }

    return binary_tree_find_by_data(root->right, data);
}

bool is_complete_binary_tree(const binary_tree_t *root)
{
    if (NULL == root) {
        return true;
    }

    queue_t queue;
    binary_tree_t *queue_front = NULL;
    init_queue(&queue);
    queue_push(&queue, (queue_data_t)root);

    while (NULL != (queue_front = get_front(&queue))) {
        queue_push(&queue, queue_front->left);
        queue_push(&queue, queue_front->right);
        queue_pop(&queue);
    }

    /* 第一次出现 NULL 后, 后边还会出现其他非 NULL 的节点,
       这时候只需要去判断 队列中的元素是否全为 NULL 即可 */
    while (!is_queue_empty(&queue)) {
        queue_front = get_front(&queue);
        if (NULL != queue_front) {
            destroy_queue(&queue);
            return false;
        }

        queue_pop(&queue);
    }

    destroy_queue(&queue);

    return true;
}

void destroy_binary_tree(binary_tree_t *root)
{
    if (NULL == root) {
        return;
    }

    destroy_binary_tree(root->left);
    destroy_binary_tree(root->right);

    free(root);
    root = NULL;
}

7. test_binary_tree.c

/*
* File Name: test_binary_tree.c
*
* Copyright (c) 2022, c code from sustzc.
* All rights reserved.
*/

#include "binary_tree.h"

void test()
{
    binary_tree_t *root = NULL, *found = NULL;
    int index = 0;

    /* 这里用 # 表示叶子节点，即不再有子节点 */
    /* 先构建 左子树，再构建 右子树 */

    /* Not a complete binary tree */
    /*
             ----------A----------
             +                   +
        -----B              -----C-----
        +                   +         +
        D                   E         F

        pre_order:
            A B D C E F
        in_order:
            D B A E C F
        post_order:
            D B E F C A
        level_order:
            A B C D E F
    */
    char array[] = {
        'A', 'B', 'D', '#', '#', '#', 'C', 'E', '#', '#', 'F'
    };

    /* A complete binary tree */
    // char array[] = {'#'};
    // char array[] = {'A', '#', '#'};
    // char array[] = {'A', 'B', '#', '#', '#', '#'};
    // char array[] = {'A', 'B', '#', '#', 'C', '#', '#'};

    /*
             ----------A----------
             +                   +
        -----B-----         -----C-----
        +         +         +         +
        D         G         E         F

        pre_order:
            A B D G C E F
        in_order:
            D B G A E C F
        post_order:
            D G B E F C A
        level_order:
            A B C D G E F
    */
    // char array[] = {
    //     'A', 'B', 'D', '#', '#', 'G', '#', '#', 'C', 'E', '#', '#', 'F'
    // };

    root = build_binary_tree(array, sizeof(array) / sizeof(char), &index);
    printf("pre_order: \n\t");
    pre_order(root);
    printf("\nin_order: \n\t");
    in_order(root);
    printf("\npost_order: \n\t");
    post_order(root);
    printf("\nlevel_order: \n\t");
    level_order(root);

    found = binary_tree_find_by_data(root, 'G');
    if (NULL == found) {
        printf("\n\nNot Found 'G'\n");
    } else {
        printf("\n\nFound %c\n", found->data);
    }

    if (is_complete_binary_tree(root)) {
        printf("It is complete binary tree\n");
    } else {
        printf("It is not complete binary tree\n");
    }

    printf("\nThe number of nodes in the tree: %d\n", get_binary_tree_size(root));
    printf("The number of nodes in the tree leaf: %d\n", get_binary_tree_leaf_size(root));
    printf("The number of nodes in the %d layer: %d\n", 0, get_binary_tree_k_layer_size(root, 0));
    printf("The number of nodes in the %d layer: %d\n", 1, get_binary_tree_k_layer_size(root, 1));
    printf("The number of nodes in the %d layer: %d\n", 2, get_binary_tree_k_layer_size(root, 2));
    printf("The number of nodes in the %d layer: %d\n", 3, get_binary_tree_k_layer_size(root, 3));
    printf("The number of nodes in the %d layer: %d\n", 4, get_binary_tree_k_layer_size(root, 4));
    printf("Tree height: %d\n", get_binary_tree_height(root));

    printf("\ndestroy_binary_tree\n");
    destroy_binary_tree(root);
    root = NULL;
    printf("Tree height: %d\n", get_binary_tree_height(root));
}

int main(void)
{
    test();

    return 0;
}
sustzc
关注
专栏目录
数据结构——二叉树先序、中序、后序及层次四种遍历（C语言版）
正弦定理的博客
12-09 36万+
数据结构——二叉树先序、中序、后序三种遍历二叉树先序、中序、后序三种遍历三、代码展示： 二叉树先序、中序、后序三种遍历 先序遍历：3 2 2 3 8 6 5 4 中序遍历：2 2 3 3 4 5 6 8 后序遍历: 2 3 2 4 5 6 8 3 三种遍历不同之处在，输出数据放在不同之处 三、代码展示： #include<stdio.h> #include<stdlib.h> typedef struct Tree{ int
数据结构二叉树题库
闲狗的博客
08-01 1万+
《数据结构二叉树之闲死攻略（一）》 目录 华文课后题 王道课后题 华文课后题 1、一棵有512个结点的完全二叉树的高度为多少？（独根树高度为1） 解析： 答案： 10 2、请写出下面这棵二叉树的中序遍历 解析： 左-根-右 left-root-right 答案： LXMECKPBQHDA 3、下列关于二叉树性质的说法正确的有： A、非空满二叉树的结点个数...
【数据结构】——二叉树详解
热门推荐
atwdy的博客
07-28 5万+
二叉树(Binary Tree)是由n个结点构成的有限集(n≥0)，n=0时为空树，n>0时为非空树。对于非空树TTT有且仅有一个根结点；除根结点外的其余结点又可分为两个不相交的子集TLT_LTL​和TRT_RTR​，分别称为TTT的左子树和右子树，且TLT_LTL​和TRT_RTR​本身又都是二叉树。很明显该定义属于递归定义，所以有关二叉树的操作使用递归往往更容易理解和实现。从定义也可以看出二叉树与一般树的区别主要是两点，一是每个结点的度最多为2；
数据结构之二叉树
qq_37080455的博客
06-27 6107
1、基本概念：树就是一种类似现实生活中的树的数据结构（倒置的树）。任何一颗非空树只有一个根节点。2、一棵树具有以下特点：3、树的形状如下图所示： 4、区别： 层数：从根节点开始算，为第一层。 高度：从最下面的叶子节点开始算，且从0开始计数。 深度：从根节点开始算，从0开始计数。树的基本名词解释：二叉树（Binary tree）是每个节点最多只有两个分支（即不存在分支度大于 2 的节点）的树结构。二叉树 的分支通常被称作“左子树”或“右子树”。并且，二叉树 的分支具有
数据结构二叉树实验报告
weixin_45590210的博客
11-22 4568
第一个实验是求一颗树的结点个数,叶子结点个数,某一个结点的深度,以及整颗树的宽度. 先来考虑一下如何读入一颗树.其实递归的读入左右子树即可. 参考代码: 树的结构体: struct Tree{ char data; Tree * lson,* rson; }; 读入部分 bool input(Tree *now){ // 这部分只是读入这颗树,不一定要这么写 cin >> now->data; if(now->data == '0') return
【数据结构】二叉树详解
waywt1的博客
11-14 4248
二叉树概念及结构 二叉树：树中节点的度不大于2的有序树，它是一种最简单且最重要的树。. 二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 二叉树的性质 1. 若规定根节点的层数为1，则一棵非空二叉树的第 i 层上最多有 个结点 2. 若规定根节点的层数为1，则深度为 h 的二叉树的最大结点数是 3. 对任何一棵二叉树, 如果度为0其叶结点个数为 , 度为2的分支结点个数为 ,则有 =＋...
数据结构：二叉树的链式结构
Yikefore的博客
06-03 5868
链式二叉树创建非常详细的过程：包含如何前序遍历创建二叉树、对二叉树的前、中、后序遍历、二叉树节点个数、二叉树叶子节点个数、二叉树的高度、第k层节点个数、查找节点、层序遍历、判断二叉树是否为完全二叉树、二叉树的销毁.....附带完整代码以及图解
【数据结构】二叉树的遍历
有道无术, 术尚可求。有术无道, 止于术。
01-13 9365
本章将会详细讲解二叉树的遍历的四种方式，分别为前序遍历、中序遍历、后续遍历和层序遍历。在学习遍历之前，会先带大家回顾一下二叉树的基本概念。学习二叉树的基本操作前，需要先创建一颗二叉树，然后才能学习其相关的基本操作，考虑到我们刚刚接触二叉树，为了能够先易后难地进行讲解，我们将暂时手动创建一颗简单的二叉树，用来方便大家学习。等二叉树结构了解的差不多后，后期我们会带大家研究二叉树地真正的创建方式。
数据结构二叉树的相关代码（伪码）
桃子的博客
12-18 2325
数据结构考研代码伪码总结 二叉树的递归遍历 1.前序遍历 void PerOrder(BiTree T){ BiTree p=T; if(p){ visit(p);//访问节点并输出 PerOrder(p->lchild);//递归访问左子树 PerOrder(p->rchild);//递归访问右子树 } } 2.中序遍历 void InOrder(BiTree T){ BiTree p=T; if(p){ InOrder(p->lchild);//
头歌数据结构二叉树的顺序存储及基本操作
05-18
在计算机科学中，二叉树是一种重要的数据结构，它的每个节点最多有两个子节点，分别称为左子树和右子树。这种特殊的树形结构在很多领域都有应用，特别是在文件系统和数据库系统中，利用二叉树可以实现高效的排序和...
数据结构二叉树功能展示
06-02
数据结构二叉树功能展示包括以完全前序序列创建二叉树"; cout以前序和中序序列创建二叉树"; cout前序遍历二叉树"; cout中序遍历二叉树"; cout后序遍历二叉树"; cout广度优先遍历二叉树"; cout求某结点的双亲";...
C语言数据结构二叉树简单应用
08-30
本文主要介绍了C语言数据结构二叉树简单应用的相关知识点，涵盖了二叉树的创建、先中后序递归遍历、统计叶子结点的总数、求树的高度、反转二叉树、输出每个叶子结点到根节点的路径、输出根结点到每个叶子结点的路径...
数据结构 二叉树
03-20
数据结构中的二叉树是一种非常重要的非线性数据结构，其在计算机科学中扮演着核心角色，尤其是在数据存储和检索方面。本文将深入探讨二叉树的定义、特性、操作及其实现细节，旨在帮助读者全面理解二叉树及其在实际...
数据结构二叉树家谱
12-17
数据结构二叉树家谱：文件操作功能，家谱操作功能
【算法竞赛】堆
Sakura_ding的博客
10-01 995
堆是一种树形结构,树的根是堆顶,堆顶始终保持为所有元素的最优值。有最大堆和最小堆,最大堆的根节点是最大值,最小堆的根节点是最小值。本节都以最小堆为例进行讲解。堆一般用二叉树实现,称为二叉堆。二叉堆的典型应用有堆排序和优先队列。
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 348
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】【顺序表算法】 删除特定范围内的元素
最新发布
Indigo____的博客
10-04 251
题目：从顺序表中删除其值在给定值s和t之间（s<t）的所有元素，若s或t不合理或顺序表为空，则显示错误信息并退出运行。
（JAVA）队列 和 符号表 两种数据结构的实现
ZunXin_2580的博客
09-27 675
如果想要清晰的认识队列或者符号表是怎样的结构，那么就来看看这篇文章吧！！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值