继续刷--《常见的数据结构》

已于 2022-10-14 14:29:33 修改
阅读量392 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表
于 2022-10-13 23:03:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/To_be_a_fisher/article/details/127311030
版权

常见的数据结构

下面继续刷一刷常见的数据结构：链表，队列，二叉查找树。

后面若再碰到其他常用的数据结构体，有机会再补上来。

代码和内容参考或来源于《C Primer Plus》（第六版）第17章，这里是做了个总结，也作为自己的学习备忘。

1. 链表（Link List）

虽然结构不能含有与自身类型相同的结构，但是可以含有指向同类型结构的指针。这种定义是定义链表（Link List）的基础，链表中的每一项都包含着在何处能找到下一项的信息。

1.1 链表——数据结构总结

  • 类型名：简单链表（单向链表）
  • 类型属性：可以存储一系列项
  • 类型操作：
    1.初始化链表为空；
    2.确定链表是否为空；
    3.确定链表是否已满；
    4.获取链表中的项数；
    5.在链表的末尾添加项；
    6.遍历链表，处理链表中的项；
    7.清空链表；

1.2 链表——数据结构的定义

#define T_SIZE   45

typedef struct film
{
    char title[T_SIZE];
    int rating;
}Item;

typedef struct node
{
    Item item;
    struct node *next; //单向链表，双向链表还有个previos的指针
}Node;

typedef Node*  List;

1.3 链表——数据结构的操作

1.3.1 初始化链表，将链表初始化为空链表：

/*
    函数说明：
        初始化链表，将链表初始化为空链表
    参数：
        plist指向一个链表；
    返回值：
        无
*/
void InitializeList(List *plist)
{
    *plist = NULL;
}

1.3.2 判断链表是否为空：

/*
    函数说明：
        判断链表是否为空
    参数：
        plist指向一个已初始化的链表；
    返回值：
        true  : 链表为空
        false : 链表非空
*/
bool ListIsEmpty(const List *plist)
{
    if(NULL == *plist)
        return true;
    else
        return false;   
}

1.3.3 判断链表是否已满：

/*
    函数说明：
        判断链表是否已满
    参数：
        plist指向一个已初始化的链表；
    返回值：
        true  : 链表已满
        false : 链表非满
*/
bool ListIsFull(const List *plist)
{
    Node *  pNode;
    bool isFull = false;
    
    pNode = (Node *)malloc(sizeof(List));

    if(NULL == pNode)
        isFull =  true;
    else
        isFull =  false;
    
    free(pNode);
    pNode = NULL;
    return isFull;
}

1.3.4 获取链表中的项数：

/*
    函数说明：
        获取链表中的项数
    参数：
        plist指向一个已初始化的链表；
    返回值：
        unsigned int  : 链表中的项数
*/
unsigned int ListItemCount(const List *plist)
{
    unsigned int count = 0;
    Node * pNode;

    pNode = *plist;

    while (NULL != pNode)
    {
        pNode = pNode->next;
        count++;
    }
    return count;
}

1.3.5 在链表的末端添加项：

/*
    函数说明：
        在链表的末端添加项
    参数：
        item为待添加至链表的项
        plist指向一个已初始化的链表；
    返回值：
        true  : 添加成功
        false : 添加失败
*/
bool ListAddItem(Item item, List * plist)
{
    Node * pNewNode = NULL;
    Node * pNodeScan = *plist;

    pNewNode = (Node *)malloc(sizeof(Node));
    
    if(NULL == pNewNode)
        return false;

    copyItemToNode(item, pNewNode);
    pNewNode->next = NULL;

    if(NULL == pNodeScan)
    {
        *plist = pNewNode;
    }
    else
    {
        while (pNodeScan->next != NULL){
            pNodeScan = pNodeScan->next;
        }
        pNodeScan->next = pNewNode;
    }
    return true;
}

1.3.6 遍历链表，将函数作用于链表中的每一项：

/*
    函数说明：
        将函数作用于链表中的每一项
    参数：
        plist指向一个已初始化的链表；
        pfun指向一个函数，该函数接受Item类型的参数，且无返回值
    返回值：
        无
*/
void Traverse(const List *plist, void(*pfun)(Item* item))
{
    Node* pNode = NULL;

    if(NULL == *plist)
        return;
    
    pNode = *plist;

    while (NULL != pNode)
    {
        pfun(&pNode->item);
        pNode = pNode->next;
    }
}

1.3.7 清空链表：

/*
    函数说明：
        清空链表
    参数：
        plist指向一个已初始化的链表；
    返回值：
        无
*/
void EmptyList(List *plist)
{
    Node *  pNodeSave = NULL;

    while (NULL != plist)
    {
        pNodeSave = (*plist)->next;
        free(plist);
        *plist = pNodeSave;
    }
}

2. 队列（Queue）

队列（queue）是具有两个特殊属性的链表。第一，新项只能添加到链表的末尾。从这方面看，队列与简单链表类似。第二，只能从链表的开头移除项。队列是一种“先进先出”（First in, First out，FIFO）的数据形式。

2.1 队列——数据结构总结

  • 类型名：队列
  • 类型属性：可以存储一系列项
  • 类型操作：
    1.初始化队列为空；
    2.确定队列是否为空；
    3.确定队列是否已满；
    4.获取队列中的项数；
    5.在队列的末尾添加项；
    6.在队列开头删除项；
    7.清空队列；

2.2 队列——数据结构的定义

//方便扩展
typedef int Item;
/*
typedef struct item
{
    int kind;
    int size;
}Item;
*/

typedef struct node
{
    Item item;
    struct node *next;
}Node;

typedef struct queue
{
    Node* front;
    Node* rear;
    int items;
}Queue;

2.3 队列——数据结构的操作

2.3.1 初始化队列，初始队列为空：

//初始化队列，初始队列为空
void InitQueue(Queue* pq)
{
    pq->front = NULL;
    pq->rear = NULL;
    pq->items = 0;
}

2.3.2 检查队列是否为空：

//检查队列是否为空
bool QueueIsEmpty(const Queue* pq)
{
    return pq->items == 0;
}

2.3.3 检查队列是否已满：

//检查队列是否已满
bool QueueIsFull(const Queue* pq)
{
    return pq->items == MAX_QUEUE;
}

2.3.4 确定队列中的项数：

//确定队列中的项数
int QueueItemCount(const Queue* pq)
{
    return pq->items;
}

2.3.5 在队列末尾添加项：

//在队列末尾添加项
bool EnQueue(Item item, Queue* pq)
{
    Node* pnew;

    if(QueueIsFull(pq))
        return false;
    
    pnew = (Node*)malloc(sizeof(Node));
    if(NULL == pnew){
        exit(1);
    }

    CopyToNode(item, pnew);
    pnew->next = NULL;

    if(QueueIsEmpty(pq)){
        pq->front = pnew;//项位于队列首端
    }
    else{
        pq->rear->next = pnew;//链接到队列尾部
    }
    pq->rear = pnew;//记录队列尾部的位置

    pq->items++;
    return true;
}

2.3.6 在队列的开头删除项：

bool DeQueue(Item* pItem, Queue* pq)
{
    if(QueueIsEmpty(pq))
        return false;

    Node* pNodeTemp;

    CopyToItem(pItem, pq->front);

    pNodeTemp = pq->front;

    if(pq->front->next != NULL)
        pq->front = pq->front->next;
    else
        pq->rear = NULL;
    
    free(pNodeTemp);
    pNodeTemp = NULL;

    pq->items--;
    return true;
}

2.3.7 清空队列：

//清空队列
void EmptyQueque(Queue* pq)
{
    Item dummy;
    while(!QueueIsEmpty(pq))
        DeQueue(&dummy, pq);
}

一些局部函数：

//局部函数,将项复制给节点
static void CopyToNode(Item item, Node* pn)
{
    if(NULL == pn)
        return;

    pn->item = item;
}

//局部函数，将节点中的项复制出来
static void CopyToItem(Item* pItem, Node* pn)
{
    if(NULL == pn)
        return;

   *pItem = pn->item;
}

3. 二叉查找树（Binary search tree）

二叉查找树是一种结合了二分查找策略的链接结构。二叉树的每个节点都包含一个项和两个指向其他节点（称为子节点）的指针。二叉树的每个节点都包含两个子节点——左节点和右节点，其顺序按照如下规定确定：左节点的项在父节点的项前面，右节点的项在父节点的项后面。

3.1 二叉树——数据结构总结

  • 类型名：二叉查找树
  • 类型属性：二叉树要么是空节点的集合（空树），要么是有一个根节点的节点集合，每个节点都有两个子树，叫做左子树和右子树。每个子树本身也是一个二叉树，也有可能是空树，二叉查找树是一个有序的二叉树，每个节点包含一个项，左子树的所有项都在根节点项的前面，右子树的所有项都在根节点项的后面。
  • 类型操作：
    1.初始化树为空；
    2.确定树是否为空；
    3.确定树是否已满；
    4.获取树中的项数；
    5.在树中查找一个项；
    6.在树中添加一个项；
    7.在树中删除一个项；
    8.遍历树中的各个项；
    9.清空树；

3.2 二叉树——数据结构的定义

#define MAX_ITEMS 10
#define SLEN  20

typedef struct item
{
    char petName[SLEN];
    char petKind[SLEN];
}Item;

typedef struct treeNode
{
    Item item;
    struct treeNode *left; //指向左子树
    struct treeNode *right; //指向右子树
}TreeNode;

typedef struct tree
{
    TreeNode* root;
    int size;
}Tree;

//为了树查找定义的父子树结构
typedef struct pair
{
    TreeNode* parent;
    TreeNode* child;
}Pair;

3.3 二叉树——数据结构的操作

3.3.1 初始化树根节点：

//初始化树根节点
void InitTree(Tree* pTree)
{
    pTree->root = NULL;
    pTree->size = 0;
}

3.3.2 判断树是否为空：

bool TreeIsEmpty(const Tree* pTree)
{
    if(NULL == pTree->root)
        return true;
    else
        return false;
}

3.3.3 判断树是否为满树：

bool TreeIsFull(Tree* pTree)
{
    if(pTree->size >= MAX_ITEMS)
        return true;
    else
        return false;
}

3.3.4 获取当前树中的项数：

//获取当前树中的项数
int TreeItemCount(Tree* pTree)
{
    return pTree->size;
}

3.3.5 判断某个项是否在树中：

//判断某个项是否在树中
bool InTree(const Item* pItem, const Tree* pTree)
{
    return(SeekItemInTree(pItem, pTree).child == NULL ? false : true);
}

static Pair SeekItemInTree(const Item* pItem, const Tree* pTree)
{
    Pair look;
    look.parent = NULL;
    look.child = pTree->root;

    if(NULL == look.child)
        return look;

    while(look.child != NULL)
    {
        if(ToLeft(pItem, &(look.child->item)))
        {
            look.parent = look.child;
            look.child = look.child->left;
        }
        else if(ToRight(pItem, &(look.child->item)))
        {
            look.parent = look.child;
            look.child = look.child->right;
        }
        else
            break;
    }

    return look;
}

3.3.6 往树中添加新项：

//往树中添加新项
bool TreeAddItem(const Item* pItem ,Tree* pTree)
{
    TreeNode* pNewNode;

    //树已满
    if(TreeIsFull(pTree))
        return false;

    //树中已有相同的项
    if(SeekItemInTree(pItem, pTree).child != NULL)
        return false;

    pNewNode = MakeNode(pItem);
    if(NULL == pNewNode)
        return false;

    if(NULL == pTree->root)
        pTree->root = pNewNode;
    else{
        AddNode(pNewNode, pTree->root);
    }

    pTree->size++;
    return true;
}

//局部函数，使用递归的方法往树中添加新节点
//1.判断待添加项是在当前树节点的左节点还是右节点
//2.判断当前树的子节点的左节点或右节点是否为空，若空则插入，否则继续查找为空的节点
static void AddNode(TreeNode* pNewNode, TreeNode* root)
{
    if(ToLeft(&(pNewNode->item), &(root->item)))
    {
        if(root->left == NULL)
            root->left = pNewNode;
        else
            AddNode(pNewNode, root->left);
    }
    else if(ToRight(&(pNewNode->item), &(root->item)))
    {
        if(root->right == NULL)
            root->right = pNewNode;
        else
            AddNode(pNewNode, root->right);        
    }
    else
        cout<<"already have the Item, NO NEED TO ADD IT AGAIN."<<endl;
}

3.3.7 删除树中的某个项：

//删除树中的某个项
bool TreeDeleteItem(const Item* pItem, Tree* pTree)
{
    Pair look;

    look = SeekItemInTree(pItem, pTree);
    if(NULL == look.child)
        return false;

    if(look.parent == NULL)
        DeleteNode(&(pTree->root));
    else if(look.parent->left == look.child)
        DeleteNode(&(look.parent->left));
    else
        DeleteNode(&(look.parent->right));

    pTree->size--;

    return true;
}

//pTree 指向待删除节点的父节点指针成员（左指针或右指针）的地址
//局部函数，删除某个树节点，并链接好待删除节点的子节点
static void DeleteNode(TreeNode** pTree)
{
    TreeNode* pTemp;

    if((*pTree)->left == NULL)
    {
        //待删除项的左子节点为空，直接将待删除项的右子节点接到左节点上
        pTemp = *pTree;
        *pTree = (*pTree)->right;
        free(pTemp);
        pTemp = NULL;
    }
    else if((*pTree)->right == NULL)
    {
        //待删除项的右子节点为空，直接将待删除项的左子节点接到右节点上
        pTemp = *pTree;
        *pTree = (*pTree)->left;
        free(pTemp);
        pTemp = NULL;
    }
    else
    {
        //待删除项的左右子节点均不为空
        for(pTemp = (*pTree)->left; pTemp->right != NULL; pTemp = pTemp->right)
            continue;

        pTemp->right = (*pTree)->right;
        pTemp = (*pTree);
        (*pTree) = (*pTree)->left;
        free(pTemp);
        pTemp = NULL;
    }
}

3.3.8 遍历树中的各个项：

//遍历树的各个子节点项
void Traverse(const Tree* pTree, void (*pFunc)(Item item))
{
    if(NULL != pTree)
        InOrder(pTree->root, pFunc);
}

//局部函数，遍历某个树节点的各个子节点
static void InOrder(const TreeNode* root, void(*pFunc)(Item item))
{
    if(root != NULL)
    {
        InOrder(root->left, pFunc);
        (*pFunc)(root->item);
        InOrder(root->right, pFunc);
    }
}

3.3.9 清空树：

void UnInitTree(Tree* pTree)
{
    if(pTree != NULL)
        DeleteAllNodes(pTree->root);
    pTree->root = NULL;
    pTree->size = 0;
}

//局部函数，删除某个树节点下的所有子节点
static void DeleteAllNodes(TreeNode* root)
{
    TreeNode* pTemp;
    if(root != NULL)
    {
        // 从上至下地递归删除节点，释放内存
        pTemp = root->right;
        DeleteAllNodes(root->left);
        free(root);
        DeleteAllNodes(pTemp);
    }
}

一些局部函数：

//局部函数
static bool ToLeft(const Item* pItem1, const Item* pItem2)
{
    int comp1;

    if(comp1 = strcmp(pItem1->petName, pItem2->petName) < 0)
        return true;
    else if(comp1 == 0 && strcmp(pItem1->petKind, pItem2->petKind) < 0)
        return true;
    else
        return false;
}

//局部函数
static bool ToRight(const Item* pItem1, const Item* pItem2)
{
    int comp1;

    if(comp1 = strcmp(pItem1->petName, pItem2->petName) > 0)
        return true;
    else if(comp1 == 0 && strcmp(pItem1->petKind, pItem2->petKind) > 0)
        return true;
    else
        return false;
}

//局部函数
static TreeNode* MakeNode(const Item* pItem)
{
    TreeNode* pNewNode;

    pNewNode = (TreeNode*)malloc(sizeof(TreeNode));
    if(pNewNode != NULL)
    {
        pNewNode->left = NULL;
        pNewNode->right = NULL;
        pNewNode->item = *pItem;
    }
    return pNewNode;
}
To_be_a_fisher
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
自考-南大计算机应用-数据结构
11-20
自考-南大计算机应用-数据结构资料。包含一些真题、各章要点、模拟题、笔记等。真题2009年-2018年的都有，其余最近年份待后续继续更新。建议先看视频，再看课件，然后看复习题，最后刷真题
常见的数据结构与算法
qq_41559118的博客
01-25 8393
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 在这里简单介绍下常见的数据结构与算法，当然对于大多数人来说，数据结构 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt i.
c++实现大整数-数据结构
GuItArIsT_的博客
10-04 1712
c++实现大整数-数据结构 在C++中，整型有short int,long int ,long long，其中long long可表示范围最大，为[-2^63+1 , 2^63-1].但当遇到需要表示更大的整数的时候，就需要其他的方法来解决了。题主在刷算法题的时候遇到需要用大整数表示的题目，做完后特地对大整数类的部分常用运算和操作符进行完善与补充，并封装成类。 C++大整数的本质为容器(最好为顺序容器)，原理为将一个整数的每个基数用容器的每个元素表示，比如若整数“12345”用大整数表示，容器的每个元素的
【数据结构】十大排序
热门推荐
英雄哪里出来
01-11 7万+
打开算法大门，从排序开始
LeetCode每日一刷 --- 手撕单链表习题（2）
bit_zyx的博客
03-26 2731
目录 1、链表的回文结构 2、相交链表 3、复制带随机指针的链表 1、链表的回文结构 链接直达： 链表的回文结构 题目： 思路： 找中间节点再逆置 2、相交链表 3、复制带随机指针的链表 ...
猿创征文|【算法入门必刷】数据结构-栈（二）
MichaelKongChina的博客
08-31 831
【算法入门必刷】数据结构-栈篇（二） 📦个人主页：一二三o-0-O的博客 🏆技术方向：C/C++客户端资深工程师（直播+音视频剪辑） 👨‍💻作者简介：数据结构算法与音视频领域创作者 📒 系列专栏：牛客网面试必刷 📣专栏目标：帮助伙伴们通过系统训练，掌握数据结构与算法，收获心仪Offer 📝推荐一个找工作神器：牛客刷题网 【面试经验|实习招聘内推，求职就业一战解决】 🧡如果对您有帮助的话，欢迎点赞👍收藏📂，关注不迷路...
力扣算法合集 目前刷了50题
09-29
通过解题过程，我提高了对数据结构和算法的理解和应用能力。其中，遇到了一些挑战和难题，但我通过仔细分析问题、查阅资料、与他人交流等方式，成功地克服了困难，并找到了解决方案。刷题的过程中，我发现自己在某些...
leetcode答案-data-structure-algorithm-[removed]数据结构与算法知识点汇总(javascript版
06-30
数据结构与算法知识点汇总(javascript版) 如何学习知识 拆分知识点，连成大树，成为脑图 刻意练习， 一道leetcode题一定不要只刷一遍，针对弱项，反复练习 反馈，看牛人代码，或者让牛人看你的代码，指出问题。 刷题...
PT80-NEAT开发指南v1.1
06-24
移动数据终端 版本记录 版本号 版本描述 发布日期 V 1.0 初始版本。 2012-04-12 V1.1 修改前三章内容 2012-09-25 目录 第一章 关于本手册...........................................................................
leetcode双人赛-leetcode-study:C++刷leetcode
06-30
再也不会有老师一起组织安排的训练赛，之后的算法训练都得靠自己坚持，哪为什么要退出集训队呢，我想是因为现在的学习工作环境导致和之后准备暑假找一份实习，但就算退出了，我依旧会努力学习算法，学习数据结构，...
计算机408备考-数据结构重要知识点-数据结构的定义
Protinx的博客
05-02 261
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。数据结构包括三方面的内容：逻辑结构、存储结构和数据的运算。数据的逻辑结构和存储结构是密不可分的两个方面，一个算法的设计取决于所选定的逻辑结构，而算法的实现则依赖于所采用的存储结构。【计算机408备考-数据结构重要知识点-数据结构的定义-哔哩哔哩】
14.集合、常见的数据结构
weixin_50975714的博客
05-02 934
Java是一个面向对象语言，将来肯定会处理对象。为了方便操作多个对象，就需要把这些对象存储起来，存储多个对象，就需要一个容器Java之前提供了数组、StringBuffer这两个容器，但是他们用来存放对象不是很方便所以，Java就提供了Collection集合。ArrayList底层是一个可以动态扩容的数组，可以存放任意类型的元素，可以存放null元素，存取有序，元素可以重复，线程是不安全的。
【数据结构（邓俊辉）学习笔记】列表04——排序器
最新发布
weixin_44399845的博客
05-05 508
介绍有序列表的排序器算法。
《数据结构（C语言版）第二版》第三章-栈和队列（3.5 队列的表示和操作的实现）
qq_44883214的博客
05-03 327
100。
数据结构内容概览
weixin_44399845的博客
05-05 97
数据结构篇博文概览
数据结构：图
qq_41252520的博客
05-02 953
在自动化程序分析中，图和树的一些算法起到了至关重要的作用，所以在开始自动化程序分析的研究前，我用了两天复习了一遍数据结构中的图。本章主要内容有图的基本概念，图的存储和图相关的经典算法，并在附录中附带上完整代码的仓库链接。注：文章中并不会提到关于图的所有概念和定理，只有和程序分析中相关性比较大的那部分。文章中若有错误请指出，代码也存在可优化的空间，欢迎把你的优化代码提到中。
数据结构-队列
2302_81705247的博客
05-02 522
1，poll：如图，在栈中，4会最先从栈顶取出，而队列1中最先取出的是1，所以想要取出4，就要将1,2,3弹出放到队列2中。同理可得：想要取出元素，先判断的、那个队列中含有元素，将有元素的队列中的元素放到另一个队列中。1，poll：如图，队列中最先取出的是1，而栈1中最先取出的是4，所以要将栈1中的元素全部放到栈2中，然后取出栈2 的栈顶元素就是队列最先取出的元素。3，offer：增加元素，先判断那个队列中有元素，将添加的元素放到有元素的队列中。2，top：取出队头元素，与上述的方法大致相同。
数据结构--顺序表经典OJ题
zy1215058242的博客
05-02 380
给你两个按排列的整数数组nums1和nums2，另有两个整数m和n，分别表示nums1和nums2中的元素数目。请你nums2到nums1中，使合并后的数组同样按排列。最终，合并后数组不应由函数返回，而是存储在数组nums1中。为了应对这种情况，nums1的初始长度为m + n，其中前m个元素表示应合并的元素，后n个元素为0，应忽略。nums2的长度为n。设计实现一个时间复杂度为O(m + n)的算法解决此问题.解：对于这道题来说我们有多种思路，但是在限制了时间复杂度后，三变量就是最好的方法。
数据结构——二叉树链式结构的实现(上)
weixin_74795859的博客
05-02 529
学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。
数据结构与算法 - 字符串匹配
05-12
字符串匹配是指在一个主串中查找一个模式串的出现位置。在计算机领域中，字符串匹配是一个重要的基础问题，应用广泛。常见的字符串匹配算法有暴力匹配、KMP算法、Boyer-Moore算法等。 暴力匹配算法是最简单的一种字符串匹配算法，也称为朴素匹配算法。其基本思想是：从主串的第一个字符开始，与模式串的第一个字符进行比较，若相等，则继续比较主串和模式串的下一个字符；若不相等，则从主串的第二个字符开始，再重新与模式串的第一个字符进行比较，以此类推，直到找到模式串在主串中的匹配位置或者主串被匹配完为止。 KMP算法是一种高效的字符串匹配算法。它利用模式串的自身匹配特性，在匹配过程中尽可能减少比较次数，从而提高匹配效率。具体思路是：在匹配过程中，当模式串与主串某个字符不匹配时，根据已匹配的前缀和后缀信息，将模式串向右移动一定的位数，从而跳过一些不必要的比较。 Boyer-Moore算法是一种基于坏字符和好后缀规则的字符串匹配算法。它通过预处理模式串，得到每个字符在模式串中最后出现的位置和好后缀的后缀子串在模式串中匹配的位置，从而在匹配过程中尽可能跳过多余的比较，提高匹配效率。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值