红黑树

最新推荐文章于 2024-12-11 00:02:12 发布
原创 最新推荐文章于 2024-12-11 00:02:12 发布 · 917 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

红黑树是一种平衡的二叉排序树，首先它是二叉排序树，即它的节点之间都是有序的; 其次，它是一种平衡树，因此它的查找效率是比较优的

红黑树的五个性质：

1、每个节点要么是红色的要么是黑色的

2、根节点必须是黑色的

3、叶子节点（即NULL节点）是黑色的

4、如果一个节点是红色的，那么它的两个孩子必须是黑色的

5、对于每一个节点，它到叶子节点的所有路径包含的黑色节点的个数都相同


由于性质5的原因，新插入的节点的颜色必须是红色的！

由于性质4的原因，新插入节点可能破坏了红黑树的平衡，因此需要调整

注意每一个节点的初始插入位置都是在树的最底层，插入之后判断是否违反了红黑树的性质，如果违反了，那么需要进行调整


实现：

#ifndef RB_RBTree_H
#define RB_RBTree_H

#include <iostream>
#include <string>

using namespace std;

struct RBTreeNode;

// 树节点数据的比较函数，如果不设置那么就默认按照指针进行比较
typedef int (*RBTreeDataCompareFunc)(void* data1,void* data2);

// 遍历一棵树的处理函数
typedef void (*RBTreeNodeHandle)(void* userData,RBTreeNode* node);


// 红黑树的节点
struct RBTreeNode
{
    enum RBTreeNodeColor
    {
        // 红色
        red,
        // 黑色
        black,
    };

    RBTreeNode()
    {
        data = 0;
        left = 0;
        right = 0;
        parent = 0;
        color = red;
    }

    // 数据
    void* data;
    // 颜色
    int color;
    // 父亲
    struct RBTreeNode* parent;
    // 左孩子
    struct RBTreeNode* left;
    // 右孩子
    struct RBTreeNode* right;

    // 取得以node为根的子树的最小节点
    static RBTreeNode* Mini(RBTreeNode* node)
    {
        if(node == 0)
            return 0;

        while(node->left != 0)
            node =node->left;

        return node;
    }

    // 取得以node为子树的最大节点
    static RBTreeNode* Max(RBTreeNode* node)
    {
        if(node == 0)
            return 0;

        while(node->right != 0)
            node = node->right;

        return node;
    }
};


typedef RBTreeNode* PRBTreeNode;

// 红黑树
class RBTree
{
public:
    RBTree();
    RBTree(RBTreeDataCompareFunc compareFunc);
    ~RBTree();

    RBTreeNode* Root();
    size_t Size();
    bool Empty();
    void Clear();

    // 插入节点
    RBTreeNode* Insert(void* data);

    // 获得最左边的节点
    RBTreeNode* LeftMost();

    // 获得最右边的节点
    RBTreeNode* RightMost();

    // 重新调整平衡
    void ReBalance(RBTreeNode* x);
    // 向左旋转
    void RotateLeft(RBTreeNode* x);
    // 向右旋转
    void RotateRight(RBTreeNode* x);

    // 删除值等于data的节点
    void Remove(void* data);

    // 删除node节点，连同它的子节点
    void Remove(RBTreeNode* node);

    // 删除node节点的左节点（连同它的子节点）
    void RemoveLeft(RBTreeNode* node);
    // 删除node节点的右节点（连同它的子节点）
    void RemoveRight(RBTreeNode* node);

    // 中序递归遍历
    void MidOrderTraverse(RBTreeNodeHandle handle,void* userData,RBTreeNode* node = 0);
    // 前序递归遍历
    void PreOrderTraverse(RBTreeNodeHandle handle,void* userData,RBTreeNode* node = 0);
    // 后续递归遍历
    void PostOrderTraverse(RBTreeNodeHandle handle,void* userData,RBTreeNode* node = 0);

    // 查找
    RBTreeNode* Find(void* data);

    RBTreeNode* Find(void* data,PRBTreeNode& parentNode);

    size_t Depth(RBTreeNode* node = 0);
    size_t Leafs(RBTreeNode* node = 0);
private:
    void ClearRecu(RBTreeNode* node);
    RBTreeNode* FindRecu(RBTreeNode* node,void* data,PRBTreeNode& parentNode);
    // 中序递归遍历
    void MidOrderTraverseRecu(RBTreeNodeHandle handle,void* userData,RBTreeNode* node );
    // 前序递归遍历
    void PreOrderTraverseRecu(RBTreeNodeHandle handle,void* userData,RBTreeNode* node );
    // 后续递归遍历
    void PostOrderTraverseRecu(RBTreeNodeHandle handle,void* userData,RBTreeNode* node );

    size_t DepthRecu(RBTreeNode* node );
    size_t LeafsRecu(RBTreeNode* node );
private:

    // m_pHead的父亲始终指向根节点
    // m_pHead的left指向最左的节点（也就是值最小的节点）
    // m_pHead的right指向最右的节点（也就是值最大的节点）
    RBTreeNode* m_pHead;

    // 红黑树中节点的个数
    size_t m_nSize;

    // 比较函数
    RBTreeDataCompareFunc m_CompareFunc;
};

#endif // RBTree_H


#include "rbtree.h"

// 默认的节点值比较函数
int DefaultRBTreeNodeCompareFunc(void* data1,void* data2)
{
    if(data1 == data2)
        return 0;

    if(data1 < data2)
        return -1;

    return 1;
}

// 构造函数
RBTree::RBTree()
{
    m_pHead = new RBTreeNode;
    m_pHead->color = RBTreeNode::red;
    m_pHead->left = m_pHead;
    m_pHead->right = m_pHead;
    m_pHead->parent = 0;

    m_nSize = 0;

    m_CompareFunc = DefaultRBTreeNodeCompareFunc;
}

RBTree::RBTree(RBTreeDataCompareFunc compareFunc)
{
    m_nSize = 0;

    m_pHead = new RBTreeNode;
    m_pHead->color = RBTreeNode::red;
    m_pHead->left = m_pHead;
    m_pHead->right = m_pHead;
    m_pHead->parent = 0;

    m_CompareFunc = compareFunc;
}

RBTree::~RBTree()
{
    Clear();
    delete m_pHead;
}

// 返回根节点
RBTreeNode* RBTree::Root()
{
    return m_pHead->parent;
}

// 返回红黑树最左边的节点，即最小值所在的节点
RBTreeNode* RBTree::LeftMost()
{
    return m_pHead->left;
}

// 返回红黑树最优边的节点，即最大值所在的节点
RBTreeNode* RBTree::RightMost()
{
    return m_pHead->right;
}

// 返回红黑树的节点个数
size_t RBTree::Size()
{
    return m_nSize;
}

bool RBTree::Empty()
{
    if(0 == m_nSize)
        return true;

    return false;
}

// 清理红黑树
void RBTree::Clear()
{
    ClearRecu(m_pHead->parent);

    m_pHead->color = RBTreeNode::red;
    m_pHead->left = m_pHead;
    m_pHead->right = m_pHead;
    m_pHead->parent = 0;
    m_nSize = 0;
}

// 递归清理
void RBTree::ClearRecu(RBTreeNode *node)
{
    if(node == 0)
        return ;

    ClearRecu(node->left);
    ClearRecu(node->right);
    delete node;
    --m_nSize;
}

// 节点node的值要大于等于左孩子的值
// 插入节点
RBTreeNode* RBTree::Insert(void* data)
{
    // 创建一个新节点
    RBTreeNode* insertNode = new RBTreeNode;
    insertNode->data = data;
    // 新插入节点的颜色是红色的
    insertNode->color = RBTreeNode::red;

    ++m_nSize;

    // 如果根节点为空，那么把当前节点设置为根节点
    // 把颜色调整为黑，因为红黑树的根是黑色的
    if(m_pHead->parent == 0)
    {
        m_pHead->parent = insertNode;
        m_pHead->parent->color = RBTreeNode::black;

        m_pHead->left = insertNode;
        m_pHead->right = insertNode;
    }
    else
    {
        RBTreeNode* node = m_pHead->parent;
        RBTreeNode* currentpNode = node;

        // 找到新节点应该插入的位置
        while(node != 0)
        {
            currentpNode = node;

            int compareRet = m_CompareFunc(node->data,data);

            if(compareRet < 0)
            {
                node = node->right;
            }
            else
            // compareRet >= 0
            {
                node = node->left;
            }
        }

        // 把新节点插入红黑树中
        if(m_CompareFunc(currentpNode->data,data) < 0)
        {
            currentpNode->right = insertNode;
            insertNode->parent = currentpNode;

            if(RightMost() == currentpNode)
                m_pHead->right = insertNode;
        }
        else
        {
            currentpNode->left = insertNode;
            insertNode->parent = currentpNode;

            if(LeftMost() == currentpNode)
                m_pHead->left = insertNode;
        }
    }

    // 插入好了
    // 接下来需要进行调整
    ReBalance(insertNode);
}

// 红黑树的特点：
// （1）根节点是黑色的
// （2）父子节点不能同时是红色（即如果父亲节点是红色，那么子节点必须是黑色）
// （3）任一节点到NULL（即树尾端）的任何路径包含的黑色节点个数都相同

// 假设插入节点是X，X的父亲节点是P，X的祖父是G，X的曾祖父是GG，X的伯父或者叔叔（即P的兄弟）是S
// 有四种情况：
// 1、如果P的颜色是黑色，插入之后可以直接返回
// 2、如果P的颜色是红色，那么进行如下处理
// 2.1、S是黑色：
// 2.1.1、LL：如果X是外侧插入，直接进行LL旋转（对P和G），改变P和G的颜色（P改成黑，G改成红色）
// 2.1.2、LR：如果X是内侧插入，进行LR旋转，先对P、X进行旋转，然后改变G和X的颜色（G改成红色，X改成黑色）
//           再对G进行旋转
// 2.2、S是红色：
// 2.2.1、LL：如果X是外侧插入，直接进行LL旋转（对P和G），改变X的颜色（变成黑色），如果GG是黑色，那么完成
//           否则还需要继续向上处理
//


/*
 * 预处理过程：
 * 从某个节点依次向上，如果遇到某个节点X的两个子节点的颜色都是红色
 * 那么把X两个子节点的颜色改成黑色，X的颜色改成红色，然后继续向上
 * 如果变换之后，X的父亲和X都是红色（那此时X的祖父必是黑色，因为X的父亲是红色），
 * 如果此时X的兄弟是红色，那么可以继续向上处理（因为符合P的两个子节点都是红色这一条件）
 * 如果此时X的兄弟是黑色（那么不满足继续向上的条件了），需要进行旋转
 * 那么对X的父亲进行旋转即可，这里只需要一个LL（或RR）或LR（或RL）旋转即可，而不需要进行多次的向上遍历然后旋转
 * 单旋转的时候需要改变P和G的颜色
 * 双旋转的第一次旋转需要改变X和G的颜色，第二次旋转不需要改变颜色
 */

void RBTree::ReBalance(RBTreeNode *x)
{
    // 插入节点的起始颜色都是红色
    x->color = RBTreeNode::red;

    // 如果P的颜色是黑色，对应情况1，不会进入循环

    // 一直从x向上遍历，直到到达根节点
    while(x != m_pHead->parent && x->parent->color == RBTreeNode::red)
    {
        // P的颜色是红色！！！


        // 如果P是G的左孩子
        if(x->parent == x->parent->parent->left)
        {
            // 取得S
            RBTreeNode* uncle = x->parent->parent->right;

            // S的颜色是红色
            if(uncle && uncle->color == RBTreeNode::red)
            {
                // 这是预处理过程

                // P的颜色设置为黑色
                x->parent->color = RBTreeNode::black;
                // S的颜色设置为黑色
                uncle->color = RBTreeNode::black;
                // G的颜色设置为红色
                x->parent->parent->color = RBTreeNode::red;
                // 然后把X向上移动到G，继续向上遍历，这是一个自下而上的预处理过程
                x = x->parent->parent;
            }
            else
            // S的颜色是黑色
            {
                // 如果X是P的右孩子，而P是G的左孩子，那么将进行LR旋转
                // LR选择即先左旋转，再右旋转
                if(x == x->parent->right)
                {
                    x = x->parent;
                    RotateLeft(x);
                }

                // 如果X是P的左孩子，而P是G的左孩子，那么将进行LL旋转（直接右旋转即可）
                // P的颜色变为黑色
                x->parent->color = RBTreeNode::black;
                // G的颜色变为红色
                x->parent->parent->color = RBTreeNode::red;
                // 进行旋转
                RotateRight(x->parent->parent);
            }
        }
        else
        // 如果P是G的右孩子
        {
            RBTreeNode* uncle = x->parent->parent->left;

            // S的颜色是红色
            if(uncle && uncle->color == RBTreeNode::red)
            {
                // 这是预处理过程


                // P的颜色设置为黑色
                x->parent->color = RBTreeNode::black;
                // S的颜色设置为黑色
                uncle->color = RBTreeNode::black;
                // G的颜色设置为红色
                x->parent->parent->color = RBTreeNode::red;
                // 把X移动到G，依次向上处理，这是一个子下而上的预处理过程
                x = x->parent->parent;
            }
            else
            // S的颜色是黑色
            {
                // 如果X是P的左孩子，而P是G的右孩子，那么需要进行RL旋转（先右旋转，再左旋转）
                if(x == x->parent->left)
                {
                    x =x->parent;
                    RotateRight(x);
                }
                // 如果X是P的右孩子，那么直接进行RR旋转即可（即进行左旋转）
                // P的颜色改成黑色
                x->parent->color = RBTreeNode::black;
                // G的颜色改成红色
                x->parent->parent->color = RBTreeNode::red;
                // 旋转
                RotateLeft(x->parent->parent);
            }
        }
    }

    m_pHead->parent->color = RBTreeNode::black;
}

// 左旋转（以X为中间进行逆时针旋转）
// 旋转之后，X的右孩子right取代X的位置，而X则成为right的左孩子
// 因此right的左孩子应该成为X的右孩子
void RBTree::RotateLeft(RBTreeNode *x)
{
    // 取得x的左孩子
    RBTreeNode* right = x->right;

    // x的右孩子应该是right的左孩子
    x->right =right->left;

    if(right->left != 0)
    {
        // right的左孩子的父亲是x
        right->left->parent = x;
    }

    // right的父亲是x原来的父亲
    right->parent = x->parent;

    if(x == m_pHead->parent)
    {
        m_pHead->parent = right;
    }
    else if(x == x->parent->left)
    {
        x->parent->left = right;
    }
    else
    {
        x->parent->right = right;
    }

    // x变成right的左孩子
    right->left = x;
    x->parent = right;
}

// 右旋转（以X为中心，按照顺时针进行旋转）
// 旋转之后X的左孩子left取代X的位置，X成为left的右孩子
// left原来的右孩子变成X的左孩子
void RBTree::RotateRight(RBTreeNode *x)
{
    RBTreeNode* left = x->left;
    x->left =left->right;

    if(left->right != 0)
    {
        left->right->parent = x;
    }

    left->parent = x->parent;

    if(x == m_pHead->parent)
    {
        m_pHead->parent = left;
    }
    else if(x == x->parent->right)
    {
        x->parent->right = left;
    }
    else
    {
        x->parent->left = left;
    }

    left->right = x;
    x->parent = left;
}


RBTreeNode* RBTree::Find(void *data)
{
    PRBTreeNode node = 0;
    return FindRecu(m_pHead->parent,data,node);
}

RBTreeNode* RBTree::Find(void *data, PRBTreeNode &parentNode)
{
    parentNode = 0;
    return FindRecu(m_pHead->parent,data,parentNode);
}

RBTreeNode* RBTree::FindRecu(RBTreeNode *node, void *data,PRBTreeNode& parentNode)
{
    if(node == 0)
    {
        parentNode = 0;
        return 0;
    }

    if(m_CompareFunc(node->data,data) == 0)
        return node;

    parentNode = node;

    RBTreeNode* temp = FindRecu(node->left,data,parentNode);



    if(0 != temp)
        return temp;

    parentNode = node;

    return FindRecu(node->right,data,parentNode);
}


void RBTree::PreOrderTraverse(RBTreeNodeHandle handle, void *userData, RBTreeNode *node)
{
    if(node == 0)
        return PreOrderTraverseRecu(handle,userData,m_pHead->parent);
    return PreOrderTraverseRecu(handle,userData,node);
}

void RBTree::MidOrderTraverse(RBTreeNodeHandle handle, void *userData, RBTreeNode *node)
{
    if(node == 0)
        return MidOrderTraverseRecu(handle,userData,m_pHead->parent);
    return MidOrderTraverseRecu(handle,userData,node);
}

void RBTree::PostOrderTraverse(RBTreeNodeHandle handle, void *userData, RBTreeNode *node)
{
    if(node == 0)
        return PostOrderTraverseRecu(handle,userData,m_pHead->parent);
    return PostOrderTraverseRecu(handle,userData,node);
}

void RBTree::PreOrderTraverseRecu(RBTreeNodeHandle handle, void *userData, RBTreeNode *node)
{
    if(node == 0)
        return ;
    handle(userData,node);
    PreOrderTraverseRecu(handle,userData,node->left);
    PreOrderTraverseRecu(handle,userData,node->right);

}

void RBTree::MidOrderTraverseRecu(RBTreeNodeHandle handle, void *userData, RBTreeNode *node)
{
    if(node == 0)
        return ;

    MidOrderTraverseRecu(handle,userData,node->left);
    handle(userData,node);
    MidOrderTraverseRecu(handle,userData,node->right);

}

void RBTree::PostOrderTraverseRecu(RBTreeNodeHandle handle, void *userData, RBTreeNode *node)
{
    if(node == 0)
        return ;

    PostOrderTraverseRecu(handle,userData,node->left);
    PostOrderTraverseRecu(handle,userData,node->right);
    handle(userData,node);
}

size_t RBTree::Depth(RBTreeNode *node)
{
    if(node == 0)
        return DepthRecu(m_pHead->parent);
    else
        return DepthRecu(node);
}

size_t RBTree::DepthRecu(RBTreeNode *node)
{
    if(node == 0)
        return 0;

    if(node->left == 0 && node->right == 0)
        return 1;

    int leftDepth = DepthRecu(node->left);
    int rightDepth = DepthRecu(node->right);

    if(leftDepth > rightDepth)
        return leftDepth + 1;
    else
        return rightDepth + 1;

}

size_t RBTree::Leafs(RBTreeNode *node)
{
    if(node == 0)
        return LeafsRecu(m_pHead->parent);
    else
        return LeafsRecu(node);
}

size_t RBTree::LeafsRecu(RBTreeNode *node)
{
    if(node == 0)
        return 0;

    if(node->left == 0 && node->right == 0)
        return 1;
    else
        return LeafsRecu(node->left) + LeafsRecu(node->right);
}


红黑树精通指南：面试、实战与源码分析
张彦峰的博客
05-12 177万+
本文深入探讨了红黑树的基本原理、实现方法及其在实际应用中的重要性。红黑树是一种自平衡的二叉搜索树，通过一系列颜色标记和旋转操作保证了查找、插入和删除操作的时间复杂度始终保持在 O(log n) 级别。文章首先介绍了红黑树的关键性质和与 AVL 树的区别，分析了红黑树在数据库索引、内存管理等领域的应用。接着，详细讲解了红黑树的插入和删除操作，以及如何通过旋转和颜色调整保持树的平衡。最后，文章通过源码分析展示了红黑树在 Java 和 Linux 内核中的实现，帮助读者更好地理解这一数据结构的实际应用和开发过程。
解析红黑树（ppt文档）.ppt
03-01
解析红黑树（ppt文档） 红黑树是一种自平衡二叉查找树，它的每个节点都包含一个键值和对应的值。红黑树的主要特点是它可以自动维持平衡，从而保证查找、插入、删除操作的时间复杂度为 O(log n)。 红黑树的五个性质...
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
热门推荐
小七的博客
01-18 27万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
红黑树 详解
最新发布
T_Y_F_的博客
12-11 957
红黑树 详解
C++红黑树
~
03-26 7000
C++红黑树零、前言一、红黑树的概念及性质二、红黑树结点的定义三、红黑树的插入操作1、变色处理2、单旋+变色3、双旋+变色4、插入实现四、红黑树的验证五、红黑树的删除六、红黑树与**AVL**树的比较 零、前言 本章继AVL树后继续讲解学习C++中另一个二叉搜索树–红黑树 一、红黑树的概念及性质 概念： 红黑树，是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长
红黑树详解
lucyLee的博客
09-12 10万+
1. 概述 1.1 红黑树的引入 有了二叉搜索树，为什么还需要平衡二叉树？ 在学习二叉搜索树、平衡二叉树时，我们不止一次提到，二叉搜索树容易退化成一条链 这时，查找的时间复杂度从O(log2N)O(log_2N)O(log2​N)也将退化成O(N)O(N)O(N) 引入对左右子树高度差有限制的平衡二叉树，保证查找操作的最坏时间复杂度也为O(log2N)O(log_2N)O(log2​N) 有了平衡二叉树，为什么还需要红黑树？ AVL的左右子树高度差不能超过1，每次进行插入/删除操作时，几乎都需要通过旋
图解红黑树
Dablelv 的博客专栏。
08-10 1996
1.红黑树简介 红黑树（Red Black Tree）是一种含有红黑结点并能自平衡二叉查找树，典型的用途是实现 map。 它必须满足下面规则： 规则1：每个结点要么是黑色，要么是红色。 规则2：根结点是黑色。 规则3：每个叶子结点（NIL）是黑色。 规则4：每个红色结点的两个子结点都是黑色。 规则5：任意一结点到每个叶子结点的路径都包含相同数量的黑结点。 记住上面的规则也不难，我们会发现黑色结点非常特殊，规则1即“非红即黑”，规则2和3即“首尾全黑”，规则4即“红子双黑”，规则5即“路径等黑”。 这些规则
红黑树简介
Charge8的博客
12-28 959
红黑树简介
C++：红黑树
HZzzzzLu的博客
11-07 1万+
红黑变换之间，平衡之道也
面试常问：什么是红黑树？
Mr.TS的博客
10-22 7万+
什么是红黑树？   ———————————— 二叉查找树（BST）具备什么特性呢？ 1.左子树上所有结点的值均小于或等于它的根结点的值。 2.右子树上所有结点的值均大于或等于它的根结点的值。 3.左、右子树也分别为二叉排序树。 下图中这棵树，就是一颗典型的二叉查找树： 1.查看根节点9： 2.由于10 &gt; 9，...
红黑树的插入详细图解，直接拿下红黑树
08-17
红黑树是一种自平衡二叉查找树，它的主要特点是在保持二叉查找树特性的同时，通过特定的颜色规则来确保树的平衡，以达到快速查找、插入和删除的目的。红黑树的每个节点都有一个颜色属性，可以是红色或黑色。在插入新...
红黑树java操作代码 红黑树是java里面遍历性能最好数据结构
10-17
红黑树（Red-Black Tree）是一种自平衡二叉查找树，它在计算机科学中扮演着重要的角色，尤其是在实现高效的数据结构和算法时。在Java中，虽然标准库并未直接提供红黑树的类，但我们可以自定义实现，如提供的`Red...
使用内存文件映射实现共享内存
NB_vol_1的专栏
07-15 2534
不使用IPC中的共享内存（shm），使用内存文件映射的方式来实现共享内存 共享内存写入者： // 使用文件内存映射进行内存共享 #include #include #include #include #include #include #include #include #include #include using namespace std; // 用户自定义的一个数
非阻塞connect的实现
NB_vol_1的专栏
04-13 1223
需要非阻塞connec的几种情况： 1.三路握手需要时间，这个要视具体的网络情况而定。当然也有可能失败。在三路握手的时候我们并不需要在原地等待三路握手的完成，可以用这些时间来完成其它事情，然后当这些事情完成后，再去检测连接是否建立（也就是三路握手是否完成）。 2.可以用这种技术来同时建立多个连接。（WEB浏览器中很常用）。 3.connect超时需要很长时间才会通知，如果我们认为超过0.1秒
http协议解析
NB_vol_1的专栏
11-12 991
http协议解析 一、http协议的特点： 1、支持客户/服务器模式 2、简单快速：客户向服务器请求时，只需传请求方法和路径 3、灵活：http允许传输任意类型的数据对象。正在传输的数据的类型由Content-Type加以标记 4、无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并受到客户的应答后，即断开连接；从1.1版本开始支持持续连接机制。 5、无状态
文件内存映射（mmap）
NB_vol_1的专栏
07-15 828
实例： // 文件内存映射 #include #include #include #include #include #include #include #include #include #include using namespace std; // 主函数 int main(int argc,char* argv[]) { // 文件描述符 int f
linux的一些操作
NB_vol_1的专栏
02-23 744
vi编辑器操作 1、打开文件：vi filename 2、打开文件后进入命令模式，单击‘i’进入编辑模式 3、在编辑模式中按esc键，退出编辑模式，进入命令模式 4、在命令模式输入‘：’，然后选择退出，‘wq’是保存退出，‘q!’是不保存退出 5、在编辑模式下如果发现输入错误想删除，那么应该回到命令模式下，将光标移动到你需要删除的字符前面，然后按‘x’就可以删除该字符了， ‘X
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值