【学习总结】在Unity中用C#写一棵红黑树

最新推荐文章于 2022-08-13 14:53:45 发布
最新推荐文章于 2022-08-13 14:53:45 发布
阅读量566 收藏 1
点赞数 2
分类专栏： Unity 算法 一些总结和笔记 文章标签： unity c# 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43890220/article/details/120281648
版权
算法 同时被 3 个专栏收录
150 篇文章 0 订阅
订阅专栏
Unity
34 篇文章 5 订阅
订阅专栏
一些总结和笔记
13 篇文章 0 订阅
订阅专栏

红黑树作为基本的二叉查找数据结构，大概是属于游戏客户端这边必须知道的东西。所以一不做二不休，干脆手写一个出来。

参考文章或视频：

文章结构

红黑树的特性

首先需要知道的是红黑树的特性：

  1. 红黑树的每一个节点都必须是红色或者是黑色
  2. 红黑树的根节点一定是黑色的
  3. 每个叶子节点（这里指的是NULL的那些节点）是黑色
  4. 如果一个节点是红色的，则其子节点一定是黑色的，即不存在两个连续的红色节点
  5. 从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点
    在这里插入图片描述
    与AVL树相同，红黑树由于也是一棵平衡二叉树，所以自然也需要旋转操作来帮助整个树进行平衡，于是这里引出平衡二叉树的两个基本操作，左旋和右旋。

左旋与右旋的父子节点变化（与AVL并无不同）：
在这里插入图片描述
（在文末的代码部分，在RBTree中可以找到该Rotate算法对照着看）

知道了旋转的基本原理之后，就会对应两个比较重要的，会产生红黑树平衡冲突的操作，添加节点和删除节点。

红黑树添加节点

添加节点的大致步骤如下：

  1. 先将红黑树当作一棵二叉查找树，将节点插入树中
  2. 将该插入的节点颜色设置为红色（设置为红色可以有效减少旋转次数）
  3. 通过解决冲突，即通过旋转和变换着色的一系列操作，将红黑树变回标准的红黑树

而根据被插入节点造成的冲突，又可以分为三种情况：

  1. 被插入的节点是根节点，此时直接将该节点变为黑色即可
  2. 被插入的节点的父节点是黑色，由于当前插入节点是红色，所以不会影响黑色高度（即特性五），不处理
  3. 被插入节点的父节点是红色，产生了连续的两个红色节点，此时才需要解决冲突

而产生的冲突类型概括起来又会分为三种：
CASE1：当父节点是红色，且父节点的兄弟节点也是红色
解决方案：
1.将父节点和父节点的兄弟节点都设置为黑色
2.将祖父节点设置为红色
3.将祖父节点设置为当前需要解决冲突的节点向上递归
在这里插入图片描述
CASE2：当父节点是红色，且父节点的兄弟节点是黑色，并且父节点的兄弟节点和当前节点在异侧（一个是左节点，一个是右节点）
1.将父节点变更为黑色
2.将祖父节点变更为红色
3.旋转父节点和祖父节点即可
在这里插入图片描述

CASE3：当父节点是红色，且父节点的兄弟节点是黑色，并且父节点的兄弟节点和当前节点在同侧（两个都是右节点或者左节点）

  1. 首先不改变任何颜色，旋转当前节点和父节点（这样就会变成CASE2的情况）
  2. 按照CASE2的情况进行进一步的旋转
    PS：CASE3的处理方式在引用的视频和文章中并不相同，我这里采用的是视频中的解法，因为文章中的解法还需要进一步递归，看着挺别扭的。
    在这里插入图片描述

红黑树删除节点

删除节点的操作步骤：

  1. 先按照二叉排序的方式进行删除（直接删除叶子节点，或者是找到一个可替换的子节点）
  2. 进行重新的着色和旋转

所有的删除操作又可以归纳为一下几种情况

  1. 删除的是一个红色的节点，整个红黑树的性质不发生变化
  2. 删除的节点是一个黑色的节点，但是它是根节点，整个红黑树的性质不发生变化
  3. 删除的节点是一个黑色的节点，且不是根节点
    对于第三种情况，是最复杂的情况，也是最常见的情况。因为对应路径上少了一个黑色节点，因此无法维持特性五，即所有节点黑色高度一样。这种情况我们一般称之为DOUBLE BLACK。一般还可以分为以下三种情况：

CASE1：Double Black产生的节点的兄弟节点至少有一个红色子节点
CASE1.1：红色子节点在DoubleBlack节点的异侧：

  1. 旋转父节点和兄弟节点
  2. 交换原本的父节点和兄弟节点的颜色（父为黑色，兄弟不变；父为红色，兄弟变红）
  3. 将红色子节点的颜色变为黑色
    在这里插入图片描述

CASE1.2：红色子节点在DoubleBlack节点的同侧

  1. 旋转红色的子节点和兄弟节点
  2. 交换两个节点的颜色
  3. 此时被转变为了CASE1.1，做进一步处理
    在这里插入图片描述

CASE2：DoubleBlack产生的节点的兄弟节点的两个子节点都是黑色
CASE2.1：父节点是红色

  1. 父节点变为黑色
  2. 兄弟节点变为红色
    在这里插入图片描述

CASE2.2：父节点是黑色

  1. 将兄弟节点替换为红色
  2. 父节点标记为DoubleBlack并且进一步向上递归
    在这里插入图片描述

CASE3：DoubleBlack产生的节点的兄弟节点是红色

  1. 旋转父节点和兄弟节点
  2. 交换这两个节点的颜色
  3. 此时以A为根节点的子树就被转换成了CASE1/CASE2的情况
    在这里插入图片描述

红黑树维持平衡的核心原则

综上，从插入和删除的思路算法不难看出，红黑树调整平衡的核心原则是维持特性五，即每一个节点的黑色高度应该是平衡的。
所有的调整都是为了保持每一个路径上黑色的子节点个数相同而存在的

代码部分

总共有三个文件：
红黑树接口文件：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;


public interface BSTADT<IndexType,DataType> where IndexType : IComparable<IndexType>
{
    void Add(IndexType index, DataType data);
    DataType Get(IndexType index);
    void Remove(IndexType index);
    bool Contains(IndexType index);
    int GetSize();
    bool IsEmpty();
}

红黑树本体实现文件

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;

public enum NodeColor { RED, BALCK};
public class RedBlackTree<IndexType,DataType> : MonoBehaviour,BSTADT<IndexType,DataType>
    where IndexType : IComparable<IndexType>
{
    public class RBNode//红黑树的节点
    {
        public IndexType index;
        public DataType data;
        public RBNode parent;
        public RBNode leftchild;
        public RBNode rightchild;
        public NodeColor nodecolor;

        public bool IsLeftChild
        {
            get
            {
                if(parent==null)
                {
                    return false;
                }

                if(parent.leftchild!=this)
                {
                    return false;
                }

                return true;
            }
        }

        public RBNode(IndexType index,DataType data)
        {
            this.index = index;
            this.data = data;
            this.nodecolor = NodeColor.RED;
        }
        public override string ToString()
        {
            return this.nodecolor.ToString() + "-" + this.index.ToString() + "-" + this.data.ToString();
        }
    }

    private RBNode root;
    private int size;
    public RBNode getRoot()
    {
        return this.root;
    }
    public void Add(IndexType index, DataType data)
    {
        if(this.root==null)//如果根节点为空的话
        {
            this.root = new RBNode(index, data);
            this.root.nodecolor = NodeColor.BALCK;//根节点一定是黑色

            return; //不用再向下插入了
        }

        RBNode newNode = new RBNode(index, data);//重新创建一个节点
        RBNode currentNode = this.root;//从根节点开始遍历插入
        while(true)
        {
            int res = newNode.index.CompareTo(currentNode.index);
            if(res==0)
            {
                throw new ArgumentException("The index already exit");
            }
            else if(res>0)//插入值比当前节点值大
            {
                if(currentNode.rightchild==null)
                {
                    //简单放入
                    currentNode.rightchild = newNode;
                    newNode.parent = currentNode;

                    //需要调整红黑树结构
                    if (CheckInsertConflict(newNode))
                    {
                        SolveInsertConflict(newNode);
                    }


                    this.size++;//增加节点数
                    return;
                }
                else
                {
                    currentNode = currentNode.rightchild;//继续往下递归遍历
                }

            }
            else//插入值比当前节点要小
            {
                if(currentNode.leftchild==null)
                {
                    currentNode.leftchild = newNode;
                    newNode.parent = currentNode;
                    //需要调整红黑树结构
                    if (CheckInsertConflict(newNode))
                    {
                        SolveInsertConflict(newNode);
                    }

                    this.size++;
                    return;
                }
                else
                {
                    currentNode = currentNode.leftchild;
                }

            }

        }
    }

    public DataType Get(IndexType index)
    {
        throw new NotImplementedException();
    }

    #region "Remove function"
    public void Remove(IndexType index)//1.使用传统二叉排序树的方式进行删除  2.解决冲突
    {
        RBNode currentNode = root;
        while(true)
        {
            int res = index.CompareTo(currentNode.index);
            if (res == 0)//说明找到了当前节点
            {
                RemoveHelper(currentNode);
                return;
            }
            else if (res > 0)
            {
                if (currentNode.rightchild == null)
                {
                    throw new ArgumentException("没有找到需要删除的那个节点");
                }
                else
                {
                    currentNode = currentNode.rightchild;
                }
            }
            else
            {
                if (currentNode.leftchild == null)
                {
                    throw new ArgumentException("没有找到需要删除的那个节点");
                }
                else
                {
                    currentNode = currentNode.leftchild;
                }
            }
        }
    }

    private void RemoveHelper(RBNode node)
    {
        //1.如果当前节点是一个叶子节点
        if(node.leftchild==null && node.rightchild==null)
        {
            if(node.nodecolor == NodeColor.BALCK)
            {
                SolveDoubleBlack(node);
            }

            if(node.IsLeftChild)
            {
                node.parent.leftchild = null;
            }
            else
            {
                node.parent.rightchild = null;
            }
            //之后会自动触发GC回收机制

            return;
        }
        //2.如果有两个子节点
        if(node.leftchild!=null && node.rightchild != null)
        {
            //这里采用的方法是找到右子树中最左边的那个节点进行替换
            RBNode successor = node.rightchild;
            while(successor.leftchild!=null)
            {
                successor = successor.leftchild;
            }

            node.index = successor.index;
            node.data = successor.data;

            RemoveHelper(successor);
        }
        //3.只有一个子节点，这样子写会比较简洁
        else
        {
            //先得到唯一的子节点
            RBNode child;
            if (node.leftchild != null)
            {
                child = node.leftchild;
            }
            else
            {
                child = node.rightchild;
            }

            //删除掉原本的节点
            if(node.IsLeftChild)
            {
                node.parent.leftchild = child;
            }
            else
            {
                node.parent.rightchild = child;
            }
            child.parent = node.parent;

            //3.1如果颜色相同
            if(node.nodecolor == child.nodecolor)
            {
                child.nodecolor = NodeColor.BALCK;
            }
            else//如果不具有相同颜色
            {
                SolveDoubleBlack(node);
            }
        }
    }
    private void SolveDoubleBlack(RBNode node)
    {
        //Case0:Double Black出现在根节点上
        if (node.parent == null)
        {
            return;
        }
        //其它情况先预存一些数据
        bool currentNodeIsLeft = node.IsLeftChild;
        RBNode parent = node.parent;
        RBNode sibling;//根据红黑树原则，这里的兄弟节点不可能是空节点
        if (currentNodeIsLeft)//根据左右节点得到相应的兄弟节点
            sibling = node.rightchild;
        else
            sibling = node.leftchild;

        RBNode siblingSameSideChild;//这里的两个节点有可能是Null
        RBNode siblingOppoSideChild;
        if(currentNodeIsLeft)
        {
            siblingSameSideChild = sibling.leftchild;
            siblingOppoSideChild = sibling.rightchild;
        }
        else
        {
            siblingSameSideChild = sibling.rightchild;
            siblingOppoSideChild = sibling.leftchild;
        }

        NodeColor siblingSameSideColor;
        if(siblingSameSideChild==null)
        {
            siblingSameSideColor = NodeColor.BALCK;//所有的空节点也是黑色
        }
        else
        {
            siblingSameSideColor = siblingSameSideChild.nodecolor;
        }
        NodeColor siblingOppoSideColor;
        if (siblingOppoSideChild == null)
        {
            siblingOppoSideColor = NodeColor.BALCK;//所有的空节点也是黑色
        }
        else
        {
            siblingOppoSideColor = siblingOppoSideChild.nodecolor;
        }

        //Case1:Double Black出现的节点有一个黑色的兄弟，并且兄弟节点的子节点至少有一个是红色
        if (sibling.nodecolor == NodeColor.BALCK && (siblingOppoSideColor == NodeColor.RED || siblingSameSideColor == NodeColor.RED))
        {
            //1.1 siblingsameside 是红色,将它变为1.2
            if (siblingSameSideChild.nodecolor == NodeColor.RED)
            {
                Rotate(siblingSameSideChild, sibling);
                siblingSameSideChild.nodecolor = NodeColor.BALCK;
                sibling.nodecolor = NodeColor.RED;
                SolveDoubleBlack(node);//这里取巧了，进行了一次重新调用
                return;
            }
            //1.2 siblingOppoSideColor 是红色
            Rotate(sibling, parent);
            sibling.nodecolor = parent.nodecolor;
            parent.nodecolor = NodeColor.BALCK;
            siblingOppoSideChild.nodecolor = NodeColor.BALCK;
        }
        //Case2:Double Black出现的节点有一个黑色的兄弟，并且兄弟节点的子节点两个都是黑色
        else if (sibling.nodecolor == NodeColor.BALCK && (siblingOppoSideColor == NodeColor.BALCK && siblingSameSideColor == NodeColor.BALCK))
        {
            sibling.nodecolor = NodeColor.RED;
            //2.1 parent 是红色
            if (parent.nodecolor == NodeColor.RED)
            {
                parent.nodecolor = NodeColor.BALCK;
                //这样处理之后不会存在两个连续红色的节点，因为CASE1中已经解决了
            }
            //2.2 parent 是黑色，需要递归解决
            else
            {
                SolveDoubleBlack(node);
            }
        }
        //CASE3:父节点为黑，兄弟节点为红色，变为CASE1或者CASE2的情况
        else
        {
            Rotate(parent, sibling);
            parent.nodecolor = NodeColor.RED;
            sibling.nodecolor = NodeColor.BALCK;
            SolveDoubleBlack(node);
        }

    }
    #endregion

    public bool Contains(IndexType index)
    {
        throw new NotImplementedException();
    }

    public int GetSize()
    {
        throw new NotImplementedException();
    }

    public bool IsEmpty()
    {
        throw new NotImplementedException();
    }


    private void Rotate(RBNode child,RBNode parent)
    {
        if(child.parent!=parent)
        {
            throw new ArgumentException("父子节点的关系好像错了~请检查一下程序");
        }

        if(child.IsLeftChild)//对应右旋的情况
        {
            //1.暂存一些关键数据
            RBNode grandparent = child.parent.parent;//方便之后转换
            bool parentSatus = parent.IsLeftChild;//是否为祖父节点左边的节点
            RBNode rightChildTmp = child.rightchild;
            //2.旋转整个树的结构
            if (grandparent != null)
            {
                if (parentSatus)
                    grandparent.leftchild = child;
                else
                    grandparent.rightchild = child;
            }
            else
            {
                root = child;
            }
            child.parent = grandparent;
            child.rightchild = parent;
            parent.parent = child;
            parent.leftchild = rightChildTmp;
            if(rightChildTmp!=null)
            {
                rightChildTmp.parent = parent;
            }
        }
        else//需要左旋的情况
        {
            //1.暂存一些关键数据
            RBNode grandparent = child.parent.parent;//方便之后转换
            bool parentSatus = parent.IsLeftChild;//是否为祖父节点左边的节点
            RBNode leftChildTmp = child.leftchild;
            //2.旋转整个树的结构
            if (grandparent != null)
            {
                if (parentSatus)
                    grandparent.leftchild = child;
                else
                    grandparent.rightchild = child;
            }
            else
            {
                root = child;
            }
            child.parent = grandparent;
            child.leftchild = parent;
            parent.parent = child;
            parent.rightchild = leftChildTmp;
            if(leftChildTmp!=null)
            {
                leftChildTmp.parent = parent;
            }
        }
    }

    private bool CheckInsertConflict(RBNode node)//检查红黑树的平衡是否产生冲突
    {
        //如果根节点是红色的，则需要调整，返回true
        if(node.parent==null && node.nodecolor == NodeColor.RED)
        {
            return true;
        }
        //标准的冲突，即连续两个节点都是红色
        if(node.parent.nodecolor==NodeColor.RED && node.nodecolor == NodeColor.RED)
        {
            return true;
        }
        return false;
    }

    private void SolveInsertConflict(RBNode node)//解决冲突的函数
    {
        //如果当前解决遍历到根节点了
        if(node.parent == null)//这种情况是在节点数小于3的情况下被触发的
        {
            node.nodecolor = NodeColor.BALCK;
            return;
        }
        else if(node.parent.parent == null)
        {
            node.parent.nodecolor = NodeColor.BALCK;
            return;
        }

        RBNode parent = node.parent;
        RBNode grandparent = node.parent.parent;
        //其余的标准情况
        RBNode siblingnode;
        if(parent.IsLeftChild)//得到父节点的兄弟节点
        {
            siblingnode = grandparent.rightchild;
        }
        else
        {
            siblingnode = grandparent.leftchild;
        }

        if(siblingnode==null || siblingnode.nodecolor == NodeColor.BALCK)//这里其实对应了CASE1的情况
        {
            //1.当前节点和父节点的兄弟节点在同一侧
            if (node.IsLeftChild != parent.IsLeftChild)
            {
                //先旋转一次当前节点和父节点
                Rotate(node, parent);
                //在旋转当前节点和组父节点（因为当前节点此时已经变成了父节点）
                Rotate(node, grandparent);
                //改变节点的颜色
                node.nodecolor = NodeColor.BALCK;
                grandparent.nodecolor = NodeColor.RED;
            }
            //2.当前节点和父节点的兄弟节点不在同一侧
            else
            {
                //这种情况旋转父节点和祖父节点
                Rotate(parent, grandparent);
                //改变父节点和组父节点的颜色
                parent.nodecolor = NodeColor.BALCK;
                grandparent.nodecolor = NodeColor.RED;
            }
        }
        //父节点和父节点的兄弟节点都是红色，这种情况需要递归处理
        else
        {
            //改变同层节点的颜色
            parent.nodecolor = NodeColor.BALCK;
            siblingnode.nodecolor = NodeColor.BALCK;
            //将祖父节点设置成红色
            grandparent.nodecolor = NodeColor.RED;
            //然后递归的检查是否有冲突
            if(CheckInsertConflict(grandparent))
            {
                SolveInsertConflict(grandparent);
            }
        }

    }

}

//每个节点或者是黑色，或者是红色
//根节点一定是黑色
//每个叶子节点（NULL）是黑色
//如果一个节点是红色的，则他的子节点必须是黑色的
//从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑色节点
//插入的节点一般为红色

测试脚本，随便挂个地方就行

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class RedBlackTreeTest : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        TestRedBalckTreeAdd();
    }

    void TestRedBalckTreeAdd()
    {
        RedBlackTree<float, string> RBTree = new RedBlackTree<float, string>();
        RBTree.Add(10,"five");
        RBTree.Add(5, "one");
        RBTree.Add(15, "four");
        RBTree.Add(3, "three");
        RBTree.Add(7, "two");
        RBTree.Add(13, "thirdteen");
        RBTree.Add(17, "seventeen");
        RBTree.Add(6, "seventeen");
        RBTree.Add(6.5f, "seventeen");
        RBTree.Add(5.5f, "seventeen");
        printInLayer(RBTree.getRoot());
    }


    void printRBTreeInorder(RedBlackTree<float, string>.RBNode p)//尽量避免使用递归
    {
        Stack<RedBlackTree<float,string>.RBNode> sup = new Stack<RedBlackTree<float, string>.RBNode>();
        while(sup.Count!=0 || p!=null)
        {
            if(p!=null)
            {
                sup.Push(p);
                p = p.leftchild;
            }
            else
            {
                p = sup.Pop();
                Debug.Log(p.index + "-" + p.nodecolor + "  " );
                p = p.rightchild;
            }
        }
    }

    void printInorder(RedBlackTree<float, string>.RBNode p)//尽量避免使用递归
    {
        if(p==null)
        {
            return;
        }
        printInorder(p.leftchild);
        Debug.Log(p.index+"-"+p.nodecolor);
        printInorder(p.rightchild);
    }

    void printInLayer(RedBlackTree<float, string>.RBNode p)
    {
        Queue<RedBlackTree<float, string>.RBNode> sup = new Queue<RedBlackTree<float, string>.RBNode>();
        sup.Enqueue(p);
        while(sup.Count!=0)
        {
            p = sup.Dequeue();
            Debug.Log(p.index + "-" + p.nodecolor);
            if (p.leftchild != null)
            {
                sup.Enqueue(p.leftchild);
            }
            if(p.rightchild!=null)
            {
                sup.Enqueue(p.rightchild);
            }
        }
    }
}

PS:以上就是红黑树大致的全部内容了，为什么不做可视化呢？因为最近实在有点忙，而且红黑树也不算很难理解的算法，只是调整比较复杂而已，所以就没想着去做可视化了。
红黑树作为常用的二叉查找树结构还是十分重要的，特别是程序开发这一块，红黑树具有很好的查找时间复杂度（logn），所以算是必会的内容~

空、白、
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Unity结构树
08-18
简单的Unity结构树
学科小知识扩充
qq842447820的博客
09-29 493
局部变量：每次进入子函数都重新赋值，生命周期是子函数结束，内存就会被释放 static局部变量：开始定义时赋值，虽然它的作用域也只是子函数，但是它的生命周期却是整个程序结束。 static函数与普通函数的区别： static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝（堆栈），全局变量存在于（静态区）中，动态申请数据存在于（堆）中。 static全局变量和全局变量的区别： 全局变量的说...
C#数据结构与算法—红黑树
qq_44921148的博客
04-11 336
2—3树
【学习总结】Unity内存解析
cyf649669121的博客
08-25 1589
前言 之前看的一个Unity官方的视频：浅谈Unity内存管理（https://www.bilibili.com/video/BV1aJ411t7N6）；觉得干货满满，但是一时又不能完全记下来，当时就想记个笔记。但是后面要么忘了，要么没时间，一直没有实现（主要还是懒）。 这一次重新看一遍视频，再结合我自己的一些理解，一边学习一边总结。 正文 1、什么是内存 内存分为物理内存、虚拟内存。 关于物理内存： 关于物理内存需要记住：CPU访问内存是一个满速过程。CPU在需要访问内存时，先是..
观《Unite ShangHai 2019 高川先生 Unity内存》演讲笔记
Kayn_Liu的博客
03-15 729
无意中发现了干货满满的一期演讲视频，废话不多说，开始正题： 第一节： 既然要讲Unity的内存详解，那么就先要从什么是内存讲起。高老师从以下三个方面剖析了内存是什么： 物理内存 虚拟内存 内存寻址范围 物理内存（： ...
马程序员学习笔记——红黑树解析一
cdl的专栏
05-30 882
---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------
算法学习二，红黑树查找算法
u013617851的博客
05-16 1160
二叉查找树，对于大多数情况下的查找和插入在效率上来说是没有问题的，但是他在最差的情况下效率比较低。 红黑树保证在最坏的情况下插入和查找效率都能保证在对数(Log(n))的时间复杂度内完成。 1.红黑树的性质： 性质1.节点是红色或黑色 性质2.根是黑色 性质3.所有叶子都是黑色（叶子是NIL节点） 性质4.如果一个节点是红的，则它的两个子节点都是黑的(从每个叶子到根的所有路径上不能有两个连续的红色节点) 性质5.从任一节点到其叶子的所有路径都包含相同数目的黑色节点。 注：清晰理解红黑树的性质，
自己写的Unity红黑树，简单明了。
qq_41041725的博客
10-21 1481
红黑树是个强大的工具，方便定位。 算了不说了，直接上代码 public enum RedBlack { Red, Black, } public class RedBlackTree<T> where T : IComparable { public class RedBlackTreeNode { public T Value; public Red
红黑树C#实现
d65793577的专栏
08-13 820
一、红黑树的性质 红黑树是一种特殊的二叉搜索树 每个节点只有红色或者黑色。 根节点一定是黑色。 叶子节点一定是空节点，且是黑色。 每个红色节点一定有两个黑色节点，即不能有连续的红色节点。 从一个节点到他的所有叶子节点，所经历的黑色节点数目相同。 二、红黑树的优点 红黑树的结构复杂，但它的操作有着良好的最坏情况运行时间，并且在实践中高效：它可以在O(logn)O(log_n)O(logn​)时间内完成查找、插入和删除，这里的nnn是树中元素的数目。 三、实现红黑树 3.1 基本结构 3.1.1 节点
Unity中C#编程学习指南训练视频教程
05-07
Unity中C#编程学习指南训练视频教程
C# Unity3d读写Excel配置文件RWExcel——源码Demo
07-10
Unity3D开发过程中，对于Excel表的读取是很频繁的一件事情，主要是用来记录各种数据，各个平台可能有很多方式方法，比如Android，你可以插件，也可以用第三方Java开发，打包成Plugin下用的.dll包，再C#和Java交互...
主要用来学习Unity游戏开发，带点C#.zip
10-18
主要用来学习Unity游戏开发，带点C#.zip主要用来学习Unity游戏开发，带点C#.zip主要用来学习Unity游戏开发，带点C#.zip主要用来学习Unity游戏开发，带点C#.zip
unity c#手机短信验证码登陆注册
最新发布
10-25
例如unity c#控制台等，任何支持c#语言的地方调用，秩序把接口文件放进去，并把写好的调用方法复制到需要发送验证码的地方调用或者添加按钮执行即可，小白也可轻松入手，也可以放在服务器中，在接收到客户端消息时...
unity读写.txt文件
03-22
无需其他插件和脚本，直接用静态方法执行
【学习总结】通用网络服务端框架(一)
weixin_43890220的博客
03-09 5924
以下内容摘自《Unity3D网络游戏实战》 PS:好久没发版号了，感觉要失业了~ 服务端架构 服务端的大致框架如下图所示 服务端程序的两大核心是处理客户端的消息和存储玩家数据。（也可以将一些消耗性能的计算放到服务端来进行）。“网络底层”是指处理网络连接的底层模块，它有处理粘包半包，协议解析等功能。消息处理模块属于游戏的逻辑层，比如当收到客户端的MsgMove协议的时候，服务端会在消息处理模块中记录玩家坐标，然后将MsgMove协议广播给所有的客户端。在服务端中，事件处理指的是玩家上线和下线之类的操作，这些
【学习总结】通用服务端框架（二）
weixin_43890220的博客
03-12 5777
玩家的数据结构 当客户端连接服务端时，它还只是一个连接，只需要处理网络信息收发和心跳。当玩家输入用户名和密码，点击登录按钮之后，客户端会和某个游戏角色关联起来，因此需要一个数据结构来记录这些信息。（这里设置为player对象） 当玩家成功登录之后，程序会给player对象赋值，player对象包含id（帐号）等信息，代表一个游戏角色。游戏角色的某些数据需要保存到数据库而另一些则不需要。因此给Player对象定义一个PlayerData类型，它记录了所有需要保存到数据库的信息。 public clas
【学习总结】通用客户端网络模块
weixin_43890220的博客
03-06 4140
内容摘自最近继续看的《Unity3D网络游戏编程》 NetMannger和ByreArray综述 同前文，网络模块的核心静态类是NetManager，它将提供一些基础的网络方法。 NetManager基于异步Socket实现，异步Socket回调函数把收到的消息按顺序存入队列msgList中。Update方法依次读取消息，再跟几乎监听表和协议名，调用相应的处理方法。 网络模块分为两个部分，第一部分是框架部分Net。Net包含网络管理器NetManager、为提高运行效率使用的Byte
Unity使用VSCODE编写C#脚本如何使用智能提示
weixin_43890220的博客
10-25 3290
完成效果图 首先需要以下工具：（在VSCODE中搜索安装） 而后打开一个Unity中的C#脚本 如果发现提示（一般是个Warning） “.NET Framework,Version=v4.5 were not found.” 如上类似的错误，就要去下载对应的NET Framework版本 然后注意： 1.如果你的电脑上没有安装过了NET Frmaework的其它版本，则下载第一个RunTime执行 2.如果你已经有了NET Framework，则下载第二个开发包版本 安装完成之后重启电脑，重新打开C
switch和枚举结合使用 在unity中用C#语法
06-03
在 Unity 中使用 C# 语言，可以使用类似的方法来结合 switch 和枚举类型： ```csharp public enum Color { Red, Green, Blue } public class Example : MonoBehaviour { public Color color = Color.Blue; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值