数据结构A3，补充

最新推荐文章于 2024-09-07 23:49:10 发布
最新推荐文章于 2024-09-07 23:49:10 发布
阅读量833 收藏 20
点赞数 20
文章标签： 数据结构 c语言 学习 c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_75038092/article/details/141726849
版权

二叉树和BST

树与二叉树

基本概念

树是一种非线性结构，其严格的数学定义是：如果一组数据中除了第一个节点（第一个节点称为根节点，没有直接前驱节点）之外，其余任意节点有且仅有一个直接前驱，有零个或多个直接后继，这样的一组数据形成一棵树。这种特性简称为一对多的逻辑关系。即用于描述具有层次关系，类似组织架构关系的一种数据结构。

树的组成：根，分支，叶子

常见例子

日常生活中，很多数据的组织形式本质上是一棵树。比如一个公司中的职员层级关系，一个学校中的院系层级关系，淘汰赛中的各次比赛队伍，一个家族中的族谱成员关系等，这些都是树状逻辑结构。由于树状结构表现出来都是具有层次的，因此也被称为层次结构。

相关术语

通常，在逻辑上表达一棵抽象的树状结构的时候，习惯于将树根放在顶部，树枝树杈向下生长，如下图所示

在这里插入图片描述

对于一棵树来说，有如下基本术语：

  1. 结点：
    树中的元素 及其子树

  2. 根（root）：
    树的第一个节点，没有直接前驱。如上图中的A。

  3. 双亲节点/父节点（parent）：
    某节点的直接前驱称为该节点的双亲节点，或成为父节点。例如上图中A是B的父节点。

  4. 孩子节点/子节点（child）：
    某节点的直接后继称为该节点的孩子节点。例如上图中B、C、D均为A的孩子节点。

  5. 节点的层次（level）：
    根节点所在的层次规定为第1层，其孩子所在的层次为第2层，后代节点以此类推。比如上图中节点E的层次是3。

  6. 节点的度（degree）：
    一个节点拥有的孩子节点的总数，称为该节点的度。比如上图中节点B的度为2。

  7. 叶子（leaf）：
    一棵树中度等于0的节点，被称为叶子，又称为终端节点。比如上图中K、L、F、G、M、I、J均为叶子。

  8. 树的高度（height）：
    一棵树中所有节点的层次的最大值，称为这棵树的高度，又称为树的深度。比如上图的树的高度为4。

  9. 有序树与无序树：
    一棵树中，如果某个节点的孩子节点之间是有次序的，则称这棵树为有序树，反之称为无序树。

二叉树

在各种不同的树状结构中，最常见也最重要的是二叉树（Binary Tree），下面是二叉树的定义：

  • 有序树
  • 任意节点的度小于等于2

比如如下这棵树就是一棵二叉树。其中8是根节点，14是10的右孩子（因为二叉树是有序树，因此严格区分左右），而13则是14的左孩子。

在这里插入图片描述

为了方便对二叉树进行操作，通常会对一棵它进行标号：从上到下，从左到右进行标号：

在这里插入图片描述

对于二叉树而言，有如下特性：

  1. 第𝑖层上，最多有2𝑖−1个节点。

  2. 高度为𝑘的二叉树，最多有2𝑘−1个节点。

  3. 假设叶子数目为𝑛0，度为2的节点数目为𝑛2，则有：n0 = n2 + 1

二叉树的一般结构：
满二叉树
一棵深度为k，且有2^k-1个结点的二叉树，称为满二叉树。这种树的特点是每一层上的结点数都是最大结点数。
简单理解： 除了叶子节点之外，其余节点的度都为2；其特点是： 如果深度为 K，则节点数为 2^K-1

在这里插入图片描述

完全二叉树
在一棵二叉树中，除最后一层外，若其余层都是满的，或者最后一层是满的，或者是最后一层在右边缺少连续若干结点，则此二叉树为完全二叉树。

简单理解：除最后一层叶子节点外。是一颗满二叉树，最后一层由右向左有连续缺省的0个,1个或多个节点。

在这里插入图片描述
二叉搜索树(BST)
特点：

  1. 如果节点具有左子树，则左子树上所有节点都不大于该节点的值；
  2. 节点具有右子树，则右子树上所有节点都不小于该节点的值；
  3. 子树又是二叉搜索数

在这里插入图片描述

二叉搜索树（BST）

二叉树（BST）的组成

  • 根指针：指向根节点的指针

  • 节点：

  • 数据域 (存储的实际数据)

  • 指针域 (左，右指针)

  • 结构设计：

typedef int data_t;
typedef struct _node
{
data_t data; // 数据域
struct _node *left; // 左子树指针
struct _node *right;// 右子树指针
}NODE;

二叉树（BST）的算法

创建二叉树

int btree_create(NODE** root,data_t data);

二叉树数据添加

int btree_add(NODE** root,data_t data);

在这里插入图片描述

二叉树数据遍历

  • 前序遍历（先序遍历，即 根左右 )）
void Preorder(const NODE* root);

前序遍历通俗的说就是从二叉树的根结点出发，先输出根结点数据，然后输出左结点，最后输
出右结点的数据。

在这里插入图片描述

从根结点出发，则第一次到达结点A，故输出A;继续向左访问，第一次访问结点B，故输出B；
按照同样规则，输出D，输出H；当到达叶子结点H，返回到D，此时已经是第二次到达D，故不
在输出D，进而向D右子树访问，D右子树不为空，则访问至I，第一次到达I，则输出I；I为叶子
结点，则返回到D，D左右子树已经访问完毕，则返回到B，进而到B右子树，第一次到达E，故
输出E；向E左子树，故输出J；按照同样的访问规则，继续输出C、F、G。
前序遍历输出结果：ABDHIEJCFG

  • 中序遍历（即 左根右 ）

    void Midorder(const NODE* root);

    中序遍历通俗的说就是从二叉树的根结点出发，先输出左结点数据，然后输出根结点，最后输
    出右结点的数据。

    在这里插入图片描述

    从根结点出发，则第一次到达结点A，不输出A，继续向左访问，第一次访问结点B，不输出
    B；继续到达D，H；
    到达H，H左子树为空，则返回到H，此时第二次访问H，故输出H；H右子树为空，则返回至
    D，此时第二次到达
    D，故输出D；由D返回至B，第二次到达B，故输出B；按照同样规则继续访问，输出J、E、A、
    F、C、G；
    中序遍历输出结果：HDIBJEAFCG

    • 后序遍历（即 左右根 ）

      void Postorder(const NODE* root);

      后序遍历通俗的说就是从二叉树的根结点出发，先输出左结点数据，然后输出右结点，最后输出根结点的数据。

      在这里插入图片描述

      从根结点出发，则第一次到达结点A，不输出A，继续向左访问，第一次访问结点B，不输出
      B；继续到达D，H；
      到达H，H左子树为空，则返回到H，此时第二次访问H，不输出H；H右子树为空，则返回至
      H，此时第三次到达
      H，故输出H；由H返回至D，第二次到达D，不输出D；继续访问至I，I左右子树均为空，故第
      三次访问I时，输出
      I；返回至D，此时第三次到达D，故输出D；按照同样规则继续访问，输出J、E、B、F、G、
      C，A

      后序遍历输出为： HIDJEBFGCA

      • 层序遍历
      void Levelorder(const NODE* root);
      • 二叉树数据查询
      NODE* btree_find(const NODE* root,data_t data);

      从根结点出发
      ② 如果比根节点小，那么就去其左子树找
      ③ 如果比根节点大就去其右子树找
      ④ 找到叶子都没找到， 就代表查找失败

      在这里插入图片描述

      • 二叉树数据更新
      int btree_update(const NODE* root,data_t old,data_t newdata);
      • 二叉树回收
      void btree_destroy(NODE** root);
      • 二叉树数据删除
      int btree_delete(NODE** root,data_t data);

      原则：将待删除的节点尽量转换为删除叶子节点，因为删除叶子节点对BST树影响是最小的；
      思路：
      ① 从根节点开始遍历BST找到待删除的节点；
      ② 对待删除的节点状态进行判断，如果节点有左子树，找到左子树中最大的节点，然后利用
      左子树中最大的节
      点数据替换待删除的节点数据，删除左子树中最大的节点；左子树中最大的节点大概率
      是叶子节点。
      ③ 如果节点只有右子树，找到右子树中最小的节点，然后 利用右子树中最小的节点数据替
      换待删除的节点数
      据，删除右子树中最小的节点；右子树中最小的节点大概率是叶子节点。
      ④ 如果待删除节点是叶子节点，直接删除。

      在这里插入图片描述

      二叉树（BST）完整实现

      队列实现

      • SQueue.h
      Queue.h
    SQueue.c
    #ifndef __SQUEUE_H
    #define __SQUEUE_H
    #include "btree.h"
    typedef NODE* type_t;
typedef struct
{
    type_t *pData;
    int size;
    int head;
    int tail;
}SQueue;
int SQ_init(SQueue *q, int num);
int SQ_isfull(SQueue *q);
int SQ_isempty(SQueue *q);
int SQ_push(SQueue *q,type_t data);
int SQ_pop(SQueue *q,type_t *data);
int SQ_free(SQueue *q);
#endif
      • SQueue.c
      #include <stdlib.h>
#include "SQueue.h"
int SQ_init(SQueue* q,int num)
{
    q -> pData = (type_t*)calloc(sizeof(type_t),num);
    if(q -> pData == NULL)
        return -1;
    q -> size = num ;
    q -> head = q -> tail = 0;
    return 0;
}
int SQ_isfull(SQueue *q)
{
    return (q -> tail + 1) % q -> size == q -> head;
}
int SQ_isempty(SQueue *q)
{
    return q -> tail == q -> head;
}
int SQ_push(SQueue *st,type_t data)
{
    if(SQ_isfull(st))
        return -1;
    st -> pData[st -> tail] = data;
    st -> tail = (st -> tail+1) % st -> size;
    return 0;
}
int SQ_pop(SQueue *st,type_t *data)
{
    if(SQ_isempty(st))
        return -1;
    *data = st -> pData[st -> head];
    st -> head = (st -> head+1) % st -> size;
    return 0;
}
int SQ_free(SQueue *st)
{
    if(st -> pData)
    {
        free(st->pData);
        st -> pData = NULL;
    }
    st -> head = st -> tail = 0;
}

      树的实现

      • btree.h
      ree.h
btree.c
#ifndef __BTREE_H
#define __BTREE_H
typedef int data_t;
typedef struct _node
{
data_t data; // 节点上的数据
struct _node *left; // 该节点左侧子节点的地址
struct _node *right;// 该节点右侧子节点的地址
}NODE;
// 创建搜索二叉树
int btree_create(NODE** root,data_t data);
// 二叉树数据添加
int btree_add(NODE** root,data_t data);
// 二叉树数据删除
int btree_delete(NODE** root,data_t data);
// 二叉树前序遍历
void Preorder(const NODE* root);
// 二叉树中序遍历
void Midorder(const NODE* root);
// 二叉树后序遍历
void Postorder(const NODE* root);
// 二叉树层序遍历
void Levelorder(const NODE* root);
// 二叉树数据查询
NODE* btree_find(const NODE* root,data_t data);
// 更新二叉树数据old 为 newdata
int btree_update(const NODE* root,data_t old,data_t newdata);
// 二叉树回收
void btree_destroy(NODE** root);
#endif
      • btree.c
      #include "btree.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h
#include "SQueue.h"
/*
@function: int btree_create(NODE** root,data_t data)
@brief: 创建搜索二叉树
@argument: root: 根指针地址
@argument: data: 存储的数据
@ret : 0 成功
-1 失败
*/
int btree_create(NODE** root,data_t data)
{
    if(*root)
        return -1;
    NODE* p = (NODE*)malloc(sizeof(NODE));
    if(!p)
        return -1;
    p -> data = data;
    p -> left = NULL;
    p -> right = NULL;
    *root = p;
    return 0;
}
/*
@function: int btree_add(NODE** root,data_t data)
@brief: 二叉树数据添加
@argument: root: 根指针地址
@argument: data: 添加的数据
@ret : 0 成功
-1 失败
*/
int btree_add(NODE** root,data_t data)
{
    NODE* pNew = (NODE*)malloc(sizeof(NODE));
    if(!pNew)
        return -1;
    pNew -> data = data;
    pNew -> left = NULL;
    pNew -> right = NULL;
    NODE* p = *root, *q = NULL;
    if(!p)
    {
        *root = pNew;
        return 0;
    }
    while(p)
    {
        q = p;
        if(memcmp(&data,&(p -> data),sizeof(data_t)) < 0)
            p = p -> left;
        else
            p = p -> right;
    }
    if(memcmp(&data,&(q -> data),sizeof(data_t)) < 0)
        q -> left = pNew;
    else
        q -> right = pNew;
    return 0;
}
/*
@function: int btree_delete(NODE** root,data_t data)
@brief: 二叉树数据删除
@argument: root: 根指针地址
@argument: data: 待删除的节点数据
@ret : 0 成功
-1 失败
*/
int btree_delete(NODE** root,data_t data)
{
    /*
原则：将待删除的节点尽量转换为删除叶子节点，因为删除叶子节点对BST树影响是最小的；
思路：
1. 从根节点开始遍历BST找到待删除的节点；
2. 对待删除的节点状态进行判断，如果节点有左子树，找到左子树中最大的节点，然后利用左子树中最大的
节点数据替换待删除 的节点数据，删除左子树中最大的节点；左子树中最大的节点大概率是叶子节点
3. 如果节点只有右子树，找到右子树中最小的节点，然后 利用右子树中最小的节点数据替换待删除的节点
数据，删除右子树中 最小的节点；右子树中最小的节点大概率是叶子节点
4. 如果待删除节点是叶子节点，直接删除。
*/  
    NODE* del = *root; //指向待删除的节点
    NODE* parent = NULL; //指向实际删除节点的双亲节点
    NODE* replace = NULL; //指向实际删除的节点
    while(del)
    {
        if(memcmp(&(del -> data),&data,sizeof(data_t)) < 0) //待删除的数据大于当前节点数据，向右子
            树继续查找
        {
            parent = del;
            del = del -> right;
        }
        else if(memcmp(&(del->data),&data,sizeof(data_t)) > 0) //待删除的数据小于当前节点数据，向
            左子树继续查找
        {
            parent = del;
            del = del -> left;
        }
        else // 找到了待删除的节点
        {
            if(del -> left) //待删除的节点有左子树
            {
                parent = del ;
                replace = del -> left;
                while(replace -> right) //找左子树中最大的节点
                {
                    parent = replace;
                    replace = replace -> right;
                }
                del -> data = replace -> data;
                if(parent -> right == replace) //实际删除的节点在双亲节点的右子树上
                    parent -> right = replace -> left;
                else
                    parent -> left = replace -> left;
                free(replace);
            }
            else if(del -> right) //待删除的节点只有右子树
            {
                parent = del;
                replace = del -> right;
                while(replace -> left)
                {
                    parent = replace;
                    replace = replace -> left;
                }
                del -> data = replace -> data;
                if(parent -> right == replace)
                    parent -> right = replace -> right;
                else
                    parent -> left = replace -> right;
                free(replace);
            }
            else //待删除的节点是叶子
            {
                if(!parent)
                {
                    free(del);
                    *root = NULL;
                    return 0;
                }
                if(parent -> left == del)
                    parent -> left = NULL;
                else
                    parent -> right = NULL;
                free(del);
            }
            return 0;
        }
    }
    return -1;
}
/*
@function: void Preorder(const NODE* root)
@brief: 二叉树前序遍历
@argument: root: 根指针
@ret : 无
*/
void Preorder(const NODE* root)
{
    if(!root)
        return ;
    printf("%4d",root -> data);
    Preorder(root->left);
    Preorder(root->right);
}
/*
@function: void Midorder(const NODE* root)
@brief: 二叉树中序遍历
@argument: root: 根指针
@ret : 无
*/
void Midorder(const NODE* root)
{
    if(!root)
        return ;
    Midorder(root->left);
    printf("%4d",root -> data);
    Midorder(root->right);
}
/*
@function: void Postorder(const NODE* root)
@brief: 二叉树后序遍历
@argument: root: 根指针
@ret : 无
*/
void Postorder(const NODE* root)
{
    if(!root)
        return ;
    Postorder(root->left);
    Postorder(root->right);
    printf("%4d",root -> data);
}
/*
@function: void Postorder(const NODE* root)
@brief: 二叉树层序遍历
@argument: root: 根指针
@ret : 无
*/
void Levelorder(const NODE* root)
{
    SQueue q;
    SQ_init(&q,100);
    SQ_push(&q,(type_t)root);
    while(!SQ_isempty(&q))
    {
        type_t dt;
        if(0 == SQ_pop(&q,&dt))
        {
            printf("%4d",dt -> data);
            if(dt -> left)
                SQ_push(&q,dt->left);
            if(dt -> right)
                SQ_push(&q,dt->right);
        }
    }
    printf("\n");
    SQ_free(&q);
}
/*
@function: NODE* btree_find(const NODE* root,data_t data)
@brief: 二叉树数据查询
@argument: root: 根指针
@argument: data: 待查询的数据
@ret : 成功：返回查询到的节点地址
失败: NULL
*/
NODE* btree_find(const NODE* root,data_t data)
{
    const NODE *p = root;
    while(p)
    {
        if(memcmp(&data,&(p -> data),sizeof(data_t)) < 0)
            p = p -> left;
        else if(memcmp(&data,&(p -> data),sizeof(data_t)) > 0)
            p = p -> right;
        else
            return (NODE*)p;
    }
    return NULL;
}
/*
@function: int btree_update(const NODE* root,data_t old,data_t newdata)
@brief: 更新二叉树数据old 为 newdata
@argument: root: 根指针
@argument: old: 待更新的数据
@argument: newdata: 更新后的数据
@ret : 成功：0
失败: -1
*/
int btree_update(const NODE* root,data_t old,data_t newdata)
{
    NODE* pfind = btree_find(root,old);
    if(!pfind)
        return -1;
    pfind -> data = newdata;
    return 0;
}
/*
@function: void btree_destroy(NODE** root)
@brief: 二叉树回收
@argument: root: 根指针地址
@ret : 无
*/
static void btree_free(NODE* root)
{
    if(!root)
        return ;
    btree_free(root->left);
    btree_free(root->right);
    free(root);
}
void btree_destroy(NODE** root)
{
    btree_free(*root);
    *root = NULL;
}
      • btree_main.c
      #include "btree.h"
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#define N 10
int main(void)
{
    NODE *root = NULL;
    register int i = 0;
    data_t a[] = {20,15,25,10,19,28,6,13,26,30,11,27};
    int n = sizeof a / sizeof a[0];
    srand(time(NULL));
    for(; i < n ; i++)
    {
        // int data = rand() % 99 + 1;
        // printf("%4d",data);
        // btree_add(&root,data);
        btree_add(&root,a[i]);
    }
    printf("\n");
    puts("====先序遍历====");
    Preorder(root);
    printf("\n");
    puts("====中序遍历====");
    Midorder(root);
    printf("\n");
    puts("====后序遍历====");
    Postorder(root);
    printf("\n");
    puts("====层序遍历====");
    Levelorder(root);
    printf("\n");
    data_t deldata = 0;
    while(1)
    {
        printf("请输入要删除的数据(-1退出):");
        scanf("%d",&deldata);
        if(deldata == -1)
            break;
        if(btree_delete(&root,deldata) == -1)
        {
            puts("删除失败请重试...");
            continue;
        }
        puts("====先序遍历====");
        Preorder(root);
        printf("\n");
    }
    btree_destroy(&root);
    return 0;
}

    puts(“中序遍历”);
    Midorder(root);
    printf(“\n”);
    puts(“后序遍历”);
    Postorder(root);
    printf(“\n”);
    puts(“层序遍历”);
    Levelorder(root);
    printf(“\n”);
    data_t deldata = 0;
    while(1)
    {
    printf(“请输入要删除的数据(-1退出):”);
    scanf(“%d”,&deldata);
    if(deldata == -1)
    break;
    if(btree_delete(&root,deldata) == -1)
    {
    puts(“删除失败请重试…”);
    continue;
    }
    puts(“先序遍历”);
    Preorder(root);
    printf(“\n”);
    }
    btree_destroy(&root);
    return 0;
    }
    ```

Night03
关注
  • 20
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
第4章 二叉树和BST
m0_74916669的博客
08-29 786
树是一种非线性结构，其严格的数学定义是：如果一组数据中除了第一个节点（第一个节点称为根节 点，没有直接前驱节点）之外，其余任意节点有且仅有一个直接前驱，有零个或多个直接后继，这样 的一组数据形成一棵树。这种特性简称为一对多的逻辑关系。即用于描述具有层次关系，类似组织架 构关系的一种数据结构。树的组成：根，分支，叶子。
简单树和特殊树题目（2道）
oziang20120318的博客
07-15 240
假设最极端情况下，每个父结点仅有右节点一个子节点，会形成高度2016的类似于一条直线的另类二叉树，最后一层仅有1个叶子节点。最小高度需要构造完全二叉树来获得，高度为10的完全二叉树最多有1023个结点，所以最小高度为11。一棵结点数为 2016 的二叉树最少有（）个叶子结点；独根树的高度为 1,具有 61 个结点的完全二叉树的高度为( )。答案：B，拥有61个结点的完全二叉树，高度为6。第1层 1个结点 累计结点：1个。第2层 2个结点 累计结点：3个。
python数据结构之线性表
m0_71417856的博客
04-12 1365
python线性表的一些基本操作，包括顺序表和单链表
数据结构总体概述
qq_28576837的博客
08-09 860
线性表是描述一种逻辑结构，也就是线性结构。线性表的定义线性表是具有相同数据类型的n(n>0)个数据元素的有限序列。(其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，则其一般表示为)1. 存在惟一的第一个元素。2. 存在惟一的最后一个元素。3. 除第一个元素之外，每个元素均只有一个直接前驱。4. 除最后一个元素之外，每个元素均只有一个直接后继1. ai是线性表中的“第i个”元素线性表中的位序。2. a1是表头元素;an是表尾元素。
数据结构——查找与排序
weixin_46067095的博客
03-29 2925
查找 静态查找表 顺序查找(Sequential Search) 原理： 对于任意一个序列以及一个给定的元素，将给定元素与序列中元素依次比较，直到找出与给定关键字相同的元素，或者将序列中的元素与其都比较完为止。 代码实现类似于数组遍历，理解即可。 顺序查找的平均查找长度ASL = (n + 1)/2 折半查找( Binary Search ) 定义：折半查找也叫二分查找。要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。 查找过程：表中元素按照一定顺序进行排列，将需要查找的元素与表中间位置元素
数据结构导论 笔记整理
NorthStar的博客
06-22 2276
据结构导论 第一章 概论 1.概述及引言 1>概述:<<数据结构导论>>主要介绍如何组织各种数据在计算机中的存储,传递和转换; 内容包括: *1.线性表,栈,队列,数组,树,二叉树,图等基本数据结构及其应用; *2.排序和查找的原理与方法;数据在外存上的组织方法; *3.四色定理,只需用4种颜色可使相邻的两个省或国家没有相同的颜色; *算法+数据结构=程序; 2>数据结构的概念 *1.数据结构(Data str
数据结构（完结）
Aston_Baymax的博客
09-18 1634
第一章 绪论 1.基本概念：数据，数据元素，数据对象，数据类型（原子类型，结构类型，抽象数据类型），数据结构 2.数据结构三要素：逻辑结构（线性，非线性），存储结构（顺序存储，链式存储，索引存储，散列存储），数据的运算（算法） 3.算法特征：有穷性，确定性，可行性，输入，输出；算法目标：正确性，可读性，健壮性，效率与低存储量需求 4.效率度量：时间复杂度与空间复杂度 第二章 线性表 1. 线性表的定义与基本操作 1.1 概念 定义：由相同数据类型的有限序列。 表中元素具有：有限性，顺序性，单个元素，类型相同
数据结构实验1：栈的应用
weixin_58628068的博客
01-07 1072
define MAX_SIZE 100//最大为100个元素，且为全局变量//这里定义的是int型数组，也可以定义其他类型的数组int top;//栈顶，指向末尾元素的起始地址}Stack;可以把栈当作一个数组看待，data数组最多储存100个元素，从0~99，top的范围为-1~98若对结构体定义不清晰，可以参考。
大话数据结构笔记
SuPer_Ivan的博客
06-30 1782
《大话数据结构》第一章 数据结构绪论前言1.3 数据结构起源1.4 基本概念和术语1.5 逻辑结构与物理结构 第一章 数据结构绪论 前言 数据结构（data structure）的简单解释：相互之间存在一种或多种特定关系的数据元素（data element）的集合。 1.3 数据结构起源 首先计算机的应用场景是解决实际问题，步骤为： 从实际问题抽象出一个适当的数学模型； 设计解此模型的算法； 编出程序。 其中，寻找数学模型的实质是： 分析问题； 从中提取操作的对象，并找出这些操作对象之间含
数据结构学习——线性表
weixin_44337028的博客
03-30 692
2.1线性表的定义和基本操作
数据结构 算法与应用（c++ 描述） 自练答案
qq_57065913的博客
09-12 4433
有不正确请提出 第一章 1.1 应该把形参 换成引用 int x--> int &x 1.2 #include<iostream> using namespace std; template <class T,class T1> //模板形参的类型 int count (T array,int end,T1 value){ int i =0,count=0; while(i<...
数据结构与算法习题库
热门推荐
27Up的博客
12-26 2万+
第一章  绪论 一．选择题 1．数据结构被形式地定义为（K，R），其中K是①_B_的有限集合，R是K上的②_D_的有限集合。   ①A．算法      B．数据元素    C．数据操作     D．逻辑结构   ②A．操作      B．映象        C．存储         D．关系 2．算法分析的目的是①C，算法分析的两个主要方面是②A。     ①A．找出数据结构的合理性 ...
数据结构C语言版（李云清）实验3 带头结点的单链表
CSDNadmin00的博客
12-28 1万+
实验3 带头结点的单链表 1、编写函数void delx(linklist head, datatype x)，删除带头结点单链表head中第一个值为x 的结点。 并构造测试用例进行测试。 /**********************************/ /*文件名称：lab3_01.c */ /******************************...
【经典回放】多种语言系列数据结构线性表之一：顺序表
「 刘一哥与GIS的故事」
04-12 891
一、实验任务描述 建立线性表的ADT后，编程完成： 1 用C语言完成一个顺序表结构； 2 为顺序表完成追加、删除、插入、查找的功能； 3 建立一个链表的结点； 4 完成链表的追加、删除、插入功能； 5 用C#完成一个结点的类； 6 C#完成链表的追加、删除、插入功能的类； 7 C#编写泛型的链表类； 8 用JavaScript完成顺序表； 9 任选一种语言完成教材中线性表合并的任务。 二、实验目的
数据结构（五）----树（含堆）
weixin_73579966的博客
09-04 1022
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的.1.最上面的称为根结点，它没有前驱结点。2.除了根结点，其余结点被分成多个互不相交的集合，其中每个集合又是一棵子树，这些子树的根节点只有一个前驱，可以有0或多个后继3.树是递归定义的。一棵树：子树不能相交总的来说，二叉树的主要难点在于链式二叉树，而其中最重要的思想在于——递归，把大事化为一个重复递归的小事，而贯穿其中的方法是：画图。
数据结构----树
2301_77841194的博客
09-07 716
1、树(Tree)是n(n≥0)个结点的有限集。n=O时称为空树。在任意一棵非空树中:(1）有且仅有一个特定的称为根(Root)的结点;(2)当n>1时,其余结点可分为m(m>0)个互不相交的有限集T1、T2、……、Tm,其中每一个集合本身又是一棵树,并且称为根的子树(SubTree)2、树的结点包含一个数据元素及若干指向其子树的分支。结点拥有的子树数称为结点的度(Degree)。度为0的结点称为叶结点（Leaf）或终端结点;度不为0的结点称为非终端结点或分支结点。
Java-数据结构-栈和队列-Stack和Queue (oﾟ▽ﾟ)o
最新发布
2303_80388948的博客
09-07 492
栈：是一种特殊的线性表，其 只允需在固定的一端进行插入和删除操作。 进行插入和删除的一端叫做栈顶，另一端叫做栈底。并且要遵循 先进后出 的规则。 队列：是一种只允许一端进行插入元素，在另一端进行删除元素的特殊的线性表。 队列具有 先进先出 的性质：进行插入的一端叫做队尾，进行删除的一端叫做队头。也就是队尾进，队头出。
数据结构（六）----排序
weixin_73579966的博客
09-07 448
上面这三个是比较基础的排序算法，通常归在一起比较，从性能上来说，插入>冒泡>选择（诶嘿冒泡居然还不是倒数第一）下面将要介绍的则是一些改进的、有技术含量的排序了完结撒花！！！相信如果你掌握了本讲的所有排序算法并且能熟练手撕出来，你绝对是面试中的佼佼者1。
数据结构（1）数据结构基础（单向链表）
weixin_68239724的博客
09-03 644
数据结构是一组用来保存一种或多种特定关系的数据的集合。其主要目的是组织和存储数据，以便于高效的访问和修改。程序 = 数据结构 + 算法单向链表是一种线性数据结构，由一系列节点构成，每个节点包含数据部分和指向下一个节点的指针。它是一种灵活的存储方式，相比于数组，单向链表不需要连续的内存空间。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值