数据结构（5）—— 链表、二叉树代码重构实现

最新推荐文章于 2024-07-25 11:43:17 发布
最新推荐文章于 2024-07-25 11:43:17 发布
阅读量509 收藏 10
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构 二叉树 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Robot__Man/article/details/52761384
版权

3 链表

3.1 双向链表

#ifndef _LS_H
#define _LS_H

#include <sys/types.h>
typedef struct ListNode{
    int data;
    struct ListNode* next;
    struct ListNode* prv;
}LIST_NODE;

typedef struct List{
    LIST_NODE* head;
    LIST_NODE* tail;
    LIST_NODE* frwd;
    LIST_NODE* bkwd;
}LIST;

void list_init(LIST* list);
void list_deinit(LIST* list);

int list_empty(LIST* list);
void list_append(LIST* list,int data);//追加
int list_insert(LIST* list,size_t pos,int data);
int list_erase(LIST* list,size_t pos);//按位置删除
void list_remove(LIST* list,int data);//按数据删除
void list_clear(LIST* list);//全部删除数据
int *list_at(LIST* list,size_t pos);//按位置取数据
size_t list_size(LIST* list);//元素数量
void list_begin(LIST* list);//开始正向迭代
int *list_next(LIST* list);//向后移动frwd
int *list_prv(LIST* list);//向前移动frwd
int *list_current(LIST* list);//返回frwd
int list_end(LIST* list);//判断正向迭代结束

#endif
#include <stdio.h>
#include "ls.h"

//新建和销毁节点函数
static LIST_NODE* create_node(int data,LIST_NODE* next,LIST_NODE* prev){
    LIST_NODE* node = malloc(sizeof(LIST_NODE));
    node->data = data;
    node->next = next;
    node->prev = prev;
    return node;
}

static LIST_NODE* destroy_node(LIST_NODE* node,LIST_NODE* prev){//prev带回上一个节点的指针
    LIST_NODE* next = node->next;
    if (prev)
        *prev = node->prev;//带出前节点
    free(node);
    return next;
}

//创建链表和销毁链表
void list_init(LIST* list){
    list->head = NULL;
    list->tail = NULL;
}

void list_deinit(LIST* list){
    while (list->head)
        list->head = destroy_node(list->head,NULL);
    list->tail = NULL;
}

int list_empty(LIST* list){
    return !list->head && !list->tail;
}//判断是否为空

void list_append(LIST* list,int data){
    list->tail = create_node(data,NULL,list->tail);
    if (list->tail->prev)//如果前节点不为空，非空链表
        list->tail->prev->next = list->tail;
    else
        list->head = list->tail;//原来是空链表
}//追加

int list_insert(LIST* list,size_t pos,int data){
    LIST_NODE* find = list->head;
    for (;find;find = find->next){
        if (!pos--){
            LIST_NODE* node = create_node(data,find,find->prev);
            if (node->prev)//不为空，有前节点
                node->prev->next = node;
            else
                list->head = node;//为空，没有前节点
            node->next->prev = node;//改后节点的prev
            return 1;//插入成功
        }
    }
    return 0;//插入失败
}

int list_erase(LIST* list,size_t pos){
    LIST_NODE* find = list->head;
    for (;find;find = find->next){
        if (!pos--){
            LIST_NODE* prev = NULL;
            LIST_NODE* next = destroy_node(find,&prev);
            if (prev)//非首节点
                prev->next = next;
            else
                list->head = next;
            if (next)
                next->prev = prev;//非尾节点
            else
                list->tail = prev;
            return 1;
        }
    }
    return 0;
}

void list_remove(LIST* list,int data){
    LIST_NODE* find = list->head;
    LIST_NODE* next = NULL;//记录下一个节点
    for (;find;find = next){
        //如果找到第一个数据，find节点被销毁
        next = find-> next;//可以销毁find，不影响循环
        if (find->data == data){
            LIST_NODE* prev = NULL;
            LIST_NODE* next = destroy_node(find,&prev);
            if (prev)
                prev->next = next;
            else
                list->head = next;
            if (next)
                next->prev = prev;
            else
                list->tail = prev;
        }
    }
}

void list_clear(LIST* list){
    list_deinit(list);
}//全部删除数据

int* list_at(LIST* list,size_t pos){
    LIST_NODE* find = list->head;
    for (;find;find = find->next){
        if (!pos--)
            return &find->data;
    }
    return NULL;//没有找到，返回
}//按位置取数据

size_t list_size(LIST* list){
    size_t size = 0;
    LIST_NODE* find = list->head;
    for (;find;find = find->next)
        size++;
    return size;
}//元素数量

void list_begin(LIST* list){
    list->frwd = list->head;
}//开始正向迭代

int* list_next(LIST* list){
    int* data = &list->frwd->data;
    list->frwd = list->frwd->next;
    return data;
}//向后移动frwd

int* list_prev(LIST* list){
    int* data = &list->frwd->data;
    list->frwd = list->frwd->prev;
    return data;
}//向前移动frwd

int* list_current(LIST* list){
    return &list->frwd->data;
}//返回frwd

int list_end(LIST* list){
    return !list->frwd;
}//判断正向迭代结束
#include <stdio.h>
#include "ls.h"

int main(){
    LIST list;
    list_init(&list);
    list_append(&list,10);
    list_append(&list,30);
    list_append(&list,50);
    list_insert(&list,1,20);
    list_insert(&list,3,40);
    list_begin(&list);
    while (!list_end(&list))
        printf("%d\n",*list_next(&list));
    list_erase(&list,1);
    list_append(&list,40);
    list_remove(&list,40);
    list_begin(&list);
    while (!list_end(&list))
        printf("%d\n",*list_next(&list));
    list_deinit(&list);
}

3.2 单向链表

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

typedef struct ListNode{
    int data;
    struct ListNode* next;
}LIST_NODE;//链表节点结构体

typedef struct List{
    LIST_NODE* head;
    LIST_NODE* tail;
}LIST;//链表结构体

//创建链表节点
static LIST_NODE* create_node(int data){
    LIST_NODE* node = malloc(sizeof(LIST_NODE));
    node->data = data;
    node->next = NULL;
    return node;
}

//销毁链表节点
static LIST_NODE* destroy_node(LIST_NODE* node){
    LIST_NODE* next = node->next;
    free(node);
    return next;
}

//初始化链表
void list_init(LIST* list){
    list->head = NULL;
    list->tail = NULL;
}

//销毁链表
void list_deinit(LIST* list){
    while (list->head)
        list->head = destroy_node(list->head);
    list->tail = NULL;
}

//链表追加节点
void list_append(LIST* list,int data){
    LIST_NODE* node = create_node(data);
    if (list->tail)
        list->tail->next = node;
    else
        list->head = node;
    list->tail = node;
}

//获取链表节点数
size_t list_size(LIST* list){
    size_t size = 0;
    LIST_NODE* find = list->head;
    for (;find;find = find->next)
        size++;
    return size;
}

//打印链表
void list_print(LIST* list){
    LIST_NODE* find = list->head;
    for (;find;find = find->next)
        printf("%-4d",find->data);
    printf("\n");
}

//反向打印链表
void rprint(LIST_NODE* head){
    if (head){
        rprint(head->next);
        printf("%-4d",head->data);
    }
    return;
}

void list_rprint(LIST* list){
    rprint(list->head);
    printf("\n");
}

//反转链表
void reverse(LIST_NODE* head){
    if (head && head->next){
        reverse(head->next);
        head->next->next = head;
        head->next = NULL;
    }
}

void list_reverse(LIST* list){
    reverse(list->head);
    LIST_NODE* temp = list->head;
    list->head = list->tail;
    list->tail = temp;
}

//获取链表中间值
int list_mid(LIST* list){
    LIST_NODE* mid = NULL,*node = NULL;
    for (mid = node = list->head;
        node->next && node->next->next;
        node = node->next-next,mid = mid->next);
    return mid->data;
}

int main(){
    LIST list;
    list_init(&list);
    list_append(&list,1);
    list_append(&list,2);
    list_append(&list,3);
    list_print(&list);
    list_rprint(&list);
    list_reverse(&list);
    list_print(&list);
    printf("mid = %d\n",list_mid(&list));
    list_deinit(&list);
}

4 二叉树

/*有序二叉树*/
#ifndef __BT_H
#define __BT_H

#include <sys/types.h>
typedef struct BsTreeNode{//二叉链表节点
    int data;
    struct BsTreeNode* left;
    struct BsTreeNode* right;
}BSTREE_NODE;

typedef struct BsTree{
    BSTREE_NODE* root;
    size_t size;
}BSTREE;

void bstree_init(BSTREE* bstree);
void bstree_deinit(BSTREE* bstree);
void bstree_insert(BSTREE* bstree,int data);
int bstree_erase(BSTREE* bstree,int data);//删除
void bstree_clear(BSTREE* bstree);//清空
void bstree_update(BSTREE* bstree,int old,int new);
int bstree_exit(BSTREE* bstree,int data);//查询是否存在
void bstree_travel(BSTREE* bstree);//中序遍历
size_t bstree_size(BSTREE* bstree);//数量
size_t bstree_height(BSTREE* bstree);//层数

#endif
#include <stdio.h>
#include <stdlib.h>
#include "bt.h"

static BSTREE_NODE* create_node(int data){
    BSTREE_NODE* node = malloc(sizeof(BSTREE_NODE));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    return node;
}

static void destroy_node(BSTREE_NODE* node){
    free(node);
}

static void clear(BSTREE_NODE** root){
    if (*root){
        clear(&(*root)->left);
        clear(&(*root)->right);
        destroy_node(*root);
        *root = NULL;
    }
}

static void insert(BSTREE_NODE* node,BSTREE_NODE** root){
    if (!*root)
        *root = node;//空节点直接放入
    else if(node){
        if (node->data < (*root)->data)
            insert(node,&(*root)->left);
        else
            insert(node,&(*root)->right);
    }
}

//返回不是对应节点，是对应节点的父节点中指向对应节点的指针地址（二级指针）
static BSTREE_NODE** find(int data,BSTREE_NODE** root){
    if (!*root)
        return root;
    else{
        if (data == (*root)->data)
            return root;
        else if (data < (*root)->data)
            return find(data,&(*root)->left);
        else
            return find(data,&(*root)->right);
    }
}

void bstree_init(BSTREE* bstree){
    bstree->root = NULL;
    bstree->size = 0;
}

void bstree_deinit(BSTREE* bstree){
    clear(&bstree->root);
    bstree->size = 0;
}

void bstree_insert(BSTREE* bstree,int data){
    insert(create_node(data),&bstree->root);
    bstree->size++;
}

int bstree_erase(BSTREE* bstree,int data){
    BSTREE_NODE** node = find(data,&bstree->root);
    if (*node){//非空，找到啦
    //删除步骤：1 左插入右 2 替换父节点 3 删除
    insert((*node)->left,&(*node)->right);
    BSTREE_NODE* temp = *node;
    *node = (*node)->right;
    destroy_node(temp);
    bstree->size--;
    return 1;//找到并删除
    }
    return 0;
}//删除

void bstree_clear(BSTREE* bstree){
    bstree_deinit(bstree);
}//清空

void bstree_update(BSTREE* bstree,int old,int new){
    while (bstree_erase(bstree,old))
        bstree_insert(bstree,new);
}//修改

int bstree_exit(BSTREE* bstree,int data){
    return *find(data,&bstree->root) != NULL;
}//查询是否存在

static void travel(BSTREE_NODE* root){
    if (root){
        travel(root->left);
        printf("%d ",root->data);
        travel(root->right);
    }
}

void bstree_travel(BSTREE* bstree){
    travel(bstree->root);
    printf("\n");
}//中序遍历

size_t bstree_size(BSTREE* bstree){
    return bstree->size;
}//数量

static size_t height(BSTREE_NODE* root){
    if (root){
        size_t left = height(root->left);
        size_t right = height(root->right);
        return (left > right ? left : right) + 1;
    }
    return 0;
}

size_t bstree_height(BSTREE* bstree){
    return height(bstree->root);
}//层数
#include <stdio.h>
#include "bt.h"

int main(){
    BSTREE bstree;
    bstree_init(&bstree);
    bstree_insert(&bstree,50);
    bstree_insert(&bstree,70);
    bstree_insert(&bstree,20);
    bstree_insert(&bstree,60);
    bstree_insert(&bstree,40);
    bstree_insert(&bstree,30);
    bstree_insert(&bstree,10);
    bstree_insert(&bstree,90);
    bstree_insert(&bstree,80);
    bstree_travel(&bstree);
    printf("size = %d,height = %d\n",
      bstree_size(&bstree),bstree_height(&bstree));
    bstree_erase(&bstree,60);
    bstree_travel(&bstree);
    bstree_deinit(&bstree);
    printf("size = %d,height = %d\n",
      bstree_size(&bstree),bstree_height(&bstree));
}
Robot__Man
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构算法代码实现——循环链表、双向链表(五)
编程侯的专栏
06-09 1585
循环链表 循环链表是一种特殊的链表，其特点是，表中最后一个结点的指针域指向头结点，整个链表的首位结点相连形成一个环。因此，从循环链表中的任何结点出发都可以找到其他结点 循环链表的操作运算和单链表的我操作基本相同
简要数据结构讲义--配合严蔚敏c版数据结构使用
05-24
### 数据结构核心知识点详解 #### 一、绪论 ##### 1. 数据结构与抽象数据类型 - **数据结构**：研究数据元素之间的逻辑关系和物理存储方式。 - **抽象数据类型(ADT)**：对数据类型的一个抽象描述，包括数据对象、...
数据结构-几种链表的总结
viafcccy的博客
12-21 1731
LeetCode 143. 重排链表
G4N3
10-20 197
LeetCode 给定一个单链表 L：L0→L1→…→Ln-1→Ln ， 将其重新排列后变为： L0→Ln→L1→Ln-1→L2→Ln-2→… 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 示例 1: 给定链表 1->2->3->4, 重新排列为 1->4->2->3. 示例 2: 给定链表 1->2->3->4->5, 重新排列为 1->5->2->4->3. ==== /** * Definition
Java 【数据结构OJ题十道】—— 二叉树篇1
yzhcjl_的博客
02-23 614
收录十道二叉树相关OJ题, 感兴趣的小伙伴来看看吧~
LeetCodeLearn
03-26
2. **数据结构实现**：数据结构是解决问题的基础，如链表、栈、队列、树（二叉树、红黑树等）、图、哈希表等。在LeetCodeLearn中，我们可能看到如何用Java来实现这些数据结构，并应用于实际问题中。 3. **复杂度...
Topcoder-Tutorials.zip_zip
09-23
2. **数据结构**：数据结构是算法的基石，教程可能涵盖链表、树（二叉树、平衡树如AVL和红黑树）、图、堆、队列和栈等。理解和熟练运用这些数据结构对于解决复杂问题至关重要。 3. **设计模式**：在Topcoder的软件...
leetcodesolutions
03-28
5. 优化与重构：对解法进行迭代改进，提升代码质量和性能。 五、利用“leetcodesolutions-master” 这个压缩包提供的解决方案涵盖了各种难度级别的LeetCode问题，每个问题的解法都体现了不同的思考角度和编程技巧。...
Leetcoding：此存储库容纳了我对各种Leetcode问题的解决方案
02-23
1. **基础数据结构**：如数组、链表、栈、队列、哈希表、二叉树等，以及如何用Java实现这些数据结构。 2. **基本算法**：包括排序（冒泡、选择、插入、快速、归并等）、搜索（线性、二分等）、递归、动态规划、贪心...
数据结构（1）—— 数据结构的三大结构
热门推荐
Robot Man的技术博客
09-07 2万+
1 数据结构的三大结构计算机程序设计 = 数据结构 + 算法 数据结构研究变量的管理方式，算法研究解决特定问题的方法。 数据结构分三个层次：逻辑结构（抽象层）、物理结构（结构层）、运算结构（实现层）。1.1 数据结构的逻辑结构逻辑结构指人对数据之间关系的理解和看法，逻辑结构和计算机无关。 逻辑结构： 1、集合结构：这种结构表示数据可以合并成一个整体。 　　这是数据之间关系最弱的一种，就仅比
排序和查找算法
Robot Man的技术博客
09-09 2237
排序和查找是两种典型的算法1 排序算法冒泡排序算法是最简单的排序算法，它的执行效率最低，但冒泡排序算法既适用于顺序物理结构也适用于链式物理结构 冒泡排序任何时候比较的都是相邻的两个数，而选择排序是固定一个数字，拿它前面所有的数字和它比较 选择排序可以把数字直接放在最终位置，以位置为中心 选择排序有多种实现方法，选择排序也可以使用链式物理结构插入排序假设前面的数字都已经排序完成了，每次把后面的一
数据结构（2）—— 栈和队列
Robot Man的技术博客
09-08 882
堆栈 基本特征： 后进先出（类似垃圾箱） 栈顶指针用来记录最后进入数据的位置
数据结构（3）—— 链表和二叉树
Robot Man的技术博客
09-09 783
1 链表对链式存储结构进行系列操作的代码—链表，为了简化链式存储结构的使用而提出和编写的数据结构 带头结点的单链表是最简单的链表，单链表中每个节点都只有一个指针2 二叉树树状逻辑结构通常采用链式存储方式实现 树状结构中每个数据使用一个结构体变量表示 两个数据之间的关系使用一个指针变量表示，每个指针变量记录在上一个数据的结构体变量中 两个直接相关的节点中，靠上的节点叫父节点，另外一个叫子节点，
数据结构（4）—— 栈、队列代码重构实现
Robot Man的技术博客
09-21 503
1 栈2 队列3 链表3.1 双向链表3.2 单向链表4 二叉树
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 164
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
最新发布
weixin_64918301的博客
07-25 213
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构---二叉树
weixin_47808575的博客
07-22 295
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构——二叉树性质
鲸落博客
07-23 416
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
约瑟夫问题解决与数据结构实验——链表实现
“数据结构实验.doc”是一份关于数据结构的实验报告，涵盖了约瑟夫问题、回文判断、二叉树遍历以及哈希表设计等主题。实验中还涉及了不同排序算法（如直接插入排序、简单选择排序、冒泡排序、快速排序、堆排序和希尔...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值