线索化二叉树

最新推荐文章于 2024-02-17 18:05:59 发布
原创 最新推荐文章于 2024-02-17 18:05:59 发布 · 939 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#线索化二叉树 

    线索化二叉树为我们提供了一种不需要递归和借助栈就能遍历一颗二叉树的方法，如果将二叉树写成STL的形式，那么线索化就可以为之提供迭代器，这也是线索化二叉树的最主要的用法。线索化二叉树有三种方式，前序线索化，中序线索化和后序线索化。一般只要掌握前序线索化和中序线索化就可以了。后序线索化遍历的时候要借助于三叉链表或者FindParent(寻找父亲结点的函数)。
    将一颗搜索二叉树转换成有序双向链表，借助中序线索化的思想，将当前结点的left当成链表的前驱指针，将prev的right当成双向链表的后继指针。

前序线索化：
#pragma once
enum
{
       LINK,
       THREAD,
};
template<typename T>
struct ThreadTreeNode
{
       T _data;
       ThreadTreeNode<T> *_left;
       ThreadTreeNode<T> *_right;
       int _leftTag;
       int _rightTag;
       ThreadTreeNode(const T& data)
              :_data(data)
              , _left(NULL)
              , _right(NULL)
              , _leftTag(LINK)
              , _rightTag(LINK)
       {}
};
template<typename T>
class ThreadBinaryTree
{
       typedef  ThreadTreeNode<T> Node;
public:
       ThreadBinaryTree()
              :_root(NULL)
       {}
       ThreadBinaryTree(const T* a, size_t size, const T& invalid)
       {
              size_t index = 0;
              _root = _CreatTree(a, size, index, invalid);      //构造一颗二叉树
              PrevThreadTree();                                  //前序线索化二叉树
       }
       //前序遍历 前序线索化二叉树
       void PrevOder()
       {
              if (_root == NULL)
                     return;
              Node* cur = _root;
              while (cur)
              {
                     while (cur->_leftTag == LINK)
                     {
                           cout << cur->_data << " ";
                           cur = cur->_left;
                     }
                     cout << cur->_data << " ";
                     cur = cur->_right;
              }
              cout << endl;
       }
protected:
       //前序线索化二叉树
       void PrevThreadTree()
       {
              Node* prev = NULL;
              _PrevThreadTree(_root, prev);
              prev->_rightTag = THREAD;
       }
       Node* _CreatTree(const T* a, size_t size, size_t& index, const T& invalid)
       {
              //创建一颗二叉树
              Node* root = NULL;
              if (index < size&&a[index] != invalid)
              {
                     root = new Node(a[index]);
                     root->_left = _CreatTree(a, size, ++index, invalid);
                     root->_right = _CreatTree(a, size, ++index, invalid);
              }
              return root;
       }
       //前序 线索化二叉树
       void _PrevThreadTree(Node* root, Node* &prev)
       {
              if (root == NULL)
                     return;
              if (root->_left != NULL)
              {
                     if (prev&&prev->_right == NULL)
                     {
                           prev->_right = root;
                           prev->_rightTag = THREAD;
                     }
                     prev = root;
              }
              else
              {
                     root->_leftTag = THREAD;
                     root->_left = prev;
                     if (prev->_right == NULL)
                     {
                           prev->_right = root;
                           prev->_rightTag = THREAD;
                     }
                     prev = root;
              }
              if (root->_leftTag != THREAD)
              {
                     _PrevThreadTree(root->_left, prev);
              }
              if (root->_rightTag != THREAD)
              {
                     _PrevThreadTree(root->_right, prev);
              }
       }
protected:
       Node* _root;
};



中序线索化：
#pragma once
enum
{
       LINK,
       THREAD,
};
template<typename T>
struct ThreadTreeNode
{
       T _data;
       ThreadTreeNode<T> *_left;
       ThreadTreeNode<T> *_right;
       int _leftTag;
       int _rightTag;
       ThreadTreeNode(const T& data)
              :_data(data)
              , _left(NULL)
              , _right(NULL)
              , _leftTag(LINK)
              , _rightTag(LINK)
       {}
};
template<typename T>
class ThreadBinaryTree
{
       typedef  ThreadTreeNode<T> Node;
public:
       ThreadBinaryTree()
              :_root(NULL)
       {}
       ThreadBinaryTree(const T* a,size_t size,const T& invalid)
       {
              size_t index = 0;
              _root =_CreatTree(a,size,index,invalid);
           InThreadTree();
       }
       
       //中序遍历 中序线索化 二叉树
       /*void InOder()
       {
              if (_root == NULL)
                     return;
              Node* cur = _root;
              while (cur)
              {
                     while (cur->_leftTag == LINK)
                           cur = cur->_left;
                     cout << cur->_data << " ";
                     while (cur->_rightTag == THREAD)
                     {
                           cur = cur->_right;
                           cout << cur->_data << " ";
                     }
                     cur = cur->_right;
              }
              cout << endl;
       }*/
       //中序遍历 （2）
       void InOder()
       {
              Node* cur = NULL;
              for (cur = Frist(_root); cur != NULL; cur = Next(cur))
              {
                     cout << cur->_data << " ";
              }
              cout << endl;
       }
       //先序遍历   中序线索化二叉树
       void PrevOder()
       {
              if (_root == NULL)
              {
                     return;
              }
              Node* cur = _root;
              while (cur)
              {
                     while (cur->_leftTag!=THREAD)
                     {
                           cout << cur->_data<<" ";
                           cur = cur->_left;
                     }
                     cout << cur->_data<<" ";
                     if (cur->_rightTag == LINK)
                     {
                           cur = cur->_right;
                     }
                     else
                     {
                           while (cur&&cur->_rightTag == THREAD)
                           {
                                  cur = cur->_right;
                           }
                           if (cur != NULL)
                           {
                                  cur = cur->_right;
                           }             
                     }
              }
              cout << endl;
       }
       //后序遍历 中序线索化二叉树
       void PostOder()
       {
              if (_root == NULL)
                     return;
              Node* cur = _root;
              while (cur->_leftTag == LINK || cur->_rightTag == LINK)       //寻找第一个访问的结点
              {
                     if (cur->_leftTag == LINK)
                           cur = cur->_left;
                     else if (cur->_rightTag==LINK)
                         cur = cur->_right;             
              }
              cout << cur->_data << " ";           //访问第一个结点
              Node* p = NULL;
              while ((p=Parent(cur))&&p!=NULL)
              {
                     if (p->_right == cur||p->_rightTag==THREAD)  //如果已经访问完了右子树,或者右子树是线索
                           cur = p;                                  //cur跳转到父节点
                     else
                     {
                           cur =p->_right;
                           while (cur->_leftTag == LINK                //找到右子树下第一个访问的结点
                                  || cur->_rightTag == LINK)  
                           {
                                  if (cur->_leftTag == LINK)
                                         cur = cur->_left;
                                  else if (cur->_rightTag==LINK)
                                         cur = cur->_right;
                           }                    
                     }
                     cout << cur->_data << " ";
              }
              cout << endl;
       }
protected:
       //中序线索化二叉树
       void InThreadTree()
       {
              Node* prev = NULL;
              _InThreadTree(_root, prev);
              prev->_rightTag = THREAD;
       }
       Node* Parent(Node* root)          //寻找root结点的父节点
       {
              if (root == NULL || root == _root) //如果root是空结点或根结点，则返回NULL
                     return NULL;
              Node* cur =root;
              while (cur->_leftTag != THREAD)
                     cur = cur->_left;
              if (cur->_left != NULL)
              {
                     for (cur = cur->_left;
                           cur&&cur->_left!=root&&cur->_right!= root;
                           cur = cur->_right);
              }
              if (cur == NULL|| cur->_left == NULL)
              {
                     cur = root;
                     while (cur->_rightTag != THREAD)
                     {
                           cur = cur->_right;
                     }
                     for (cur = cur->_right;
                           cur&&cur->_left != root&&cur->_right != NULL;
                           cur=cur->_left);
              }
              return cur;
       }
       Node* Frist(Node* root)        //寻找以root为根节点的树,中序遍历下的第一个结点
       {
              if (root == NULL)
                     return NULL;
              Node* cur = root;
              while (cur->_leftTag != THREAD)
              {
                     cur = cur->_left;
              }
              return cur;
       }
       Node* Next(Node *root)          //寻找中序遍历下root的后继结点
       {
              if (root == NULL)
                     return NULL;
              Node* cur = root;
              if(cur->_rightTag ==THREAD)
                     return cur->_right;                   //直接返回后继
              return Frist(cur->_right);                 //返回右子树下访问的第一个结点
       }
       Node* Last(Node *root)         //寻找以root为根节点的树,中序遍历下的最后一个结点
       {
              if (root == NULL)
                     return NULL;
              Node* cur = root;
              while (cur->_right==LINK)
                     cur = cur->_right;
              return cur;
       }
       Node* Prior(Node *root)        //寻找中序遍历下root的前继结点
       {
              if (root == NULL)
                     return NULL;
              Node* cur = root;
              if (cur->_leftTag == THREAD)
                     return cur->_left;              //直接返回前继几点
              return Last(cur->_left);            //返回左子树下最后一个访问的结点
       }
       Node* _CreatTree(const T* a, size_t size, size_t& index, const T& invalid)
       {
              //创建一颗二叉树
              Node* root = NULL;
              if (index < size&&a[index] != invalid)
              {
                     root = new Node(a[index]);
                     root->_left = _CreatTree(a, size, ++index, invalid);
                     root->_right = _CreatTree(a, size, ++index, invalid);
              }
              return root;
       }
       //中序线索化二叉树
       void _InThreadTree(Node* root, Node* &prev)
       {
              if (NULL == root)
                     return;
              _InThreadTree(root->_left, prev);
              if (root->_left == NULL)                //线索化前驱
              {
                     root->_leftTag = THREAD;
                     root->_left = prev;
                     prev = root;
              }
              if (prev != root&&prev->_right == NULL)      //线索化后继
              {
                     prev->_rightTag = THREAD;
                     prev->_right = root;
                     prev = root;
              }
              _InThreadTree(root->_right, prev);
       }
protected:
       Node* _root;
};



后序线索化：
#pragma once
enum
{
       LINK,
       THREAD,
};
template<typename T>
struct ThreadTreeNode
{
       T _data;
       ThreadTreeNode<T> *_left;
       ThreadTreeNode<T> *_right;
       ThreadTreeNode<T> *_parent;
       int _leftTag;
       int _rightTag;
       ThreadTreeNode(const T& data)
              :_data(data)
              , _left(NULL)
              , _right(NULL)
              , _parent(NULL)
              , _leftTag(LINK)
              , _rightTag(LINK)
       {}
};
template<typename T>
class ThreadBinaryTree
{
       typedef ThreadTreeNode<T> Node;
public:
       ThreadBinaryTree()
              :_root(NULL)
       {}
       ThreadBinaryTree(const T* a,size_t size,const T& invalid)
       {
              size_t index = 0;
              Node* prev = NULL;
              _root = _CreatTree(a,size,index,invalid,prev);
              PostThreadTree();
       }
       void PostOder()          //后序遍历  后序线索化二叉树
       {
              if (_root == NULL)
                     return;
              Node* cur = _root;
              while (cur->_leftTag == LINK || cur->_rightTag == LINK) //找到左子树后序遍历下的第一个结点
              {
                     if (cur->_leftTag == LINK)
                           cur = cur->_left;
                     else if (cur->_rightTag == LINK)
                           cur = cur->_right;
              }
              cout << cur->_data << " ";
              Node* p = NULL;
              while ((p = cur->_parent) != NULL)
              {
                     if (p->_right == cur || p->_rightTag == THREAD)
                           cur = p;
                     else
                     {
                           cur = p->_right;
                           while (cur->_leftTag == LINK || cur->_rightTag == LINK)
                           {
                                  if (cur->_leftTag == LINK)
                                         cur = cur->_left;
                                  else if (cur->_rightTag == LINK)
                                         cur = cur->_right;
                           }
                     }
                     cout << cur->_data << " ";
              }
              cout << endl;
       }
protected:
       Node* _CreatTree(const T* a,size_t size,size_t& index,const T& invalid,Node* prev)
       {
              Node* root = NULL;
              if (index <size&&a[index] != invalid)
              {
                     root = new Node(a[index]);
                     root->_parent = prev;
                     prev = root;
                     root->_left = _CreatTree(a,size,++index,invalid,prev);
                     root->_right = _CreatTree(a,size,++index,invalid,prev);
              }
              return root;
       }
       void PostThreadTree()        //后序线索化二叉树
       {
              Node* prev = NULL;
              _PostThreadTree(_root,prev);
              if (prev->_right == NULL)
                     prev->_rightTag = THREAD;
       }
       void _PostThreadTree(Node* root,Node* &prev)
       {
              if (root == NULL)
                     return;
              _PostThreadTree(root->_left, prev);
              _PostThreadTree(root->_right, prev);
              if (root->_left == NULL)             //线索化前驱
              {
                     root->_left = prev;
                     root->_leftTag = THREAD;
                     if (prev&&prev->_right == NULL)
                     {
                           prev->_right = root;
                           prev->_rightTag = THREAD;
                     }
                     prev = root;
              }
              else if(prev&&prev->_right==NULL)                 //线索化后继
              {
                     prev->_right = root;
                     prev->_rightTag = THREAD;
                     prev = root;
              }      
       }
protected:
       Node* _root;
};


中序线索化二叉树的迭代器：
#pragma once
#include<cassert>
enum
{
       LINK,
       THREAD,
};
template<typename T>
struct ThreadTreeNode
{
       T _data;
       ThreadTreeNode<T> * _left;
       ThreadTreeNode<T>* _right;
       int _leftTag;
       int _rightTag;
       ThreadTreeNode(const T& data)
              :_data(data)
              , _left(NULL)
              , _right(NULL)
              , _leftTag(LINK)
              , _rightTag(LINK)
       {}
};
template<typename T>
class TreeIterator
{
       typedef ThreadTreeNode<T> Node;
       typedef TreeIterator<T> Iterator;
public:
       TreeIterator()
       {}
       TreeIterator(Node* root)
              :_cur(root)
       {}
       Iterator& operator++()
       {
              assert(_cur);
              if (_cur->_rightTag == THREAD)
                     _cur = _cur->_right;
              else
              {
                     _cur=_cur->_right;
                     while (_cur->_leftTag == LINK)
                           _cur = _cur->_left;
              }
              return *this;
       }
       Iterator& operator--()
       {
              assert(_cur);
              if (_cur->_leftTag== THREAD)
                     _cur = _cur->_left;
              else
              {
                     _cur = _cur->_left;
                     while (_cur->_rightTag == LINK)         //找到_cur的左子树下最后一个访问的结点
                           _cur = _cur->_right;
              }
              return *this;
       }
       Iterator operator++(int)
       {
              assert(_cur);
              Node* cur = _cur;
              if (_cur->_rightTag == THREAD)
                     _cur = _cur->_right;
              else
              {
                     _cur = _cur->_right;
                     while (_cur->_leftTag == LINK)
                           _cur = _cur->_left;
              }
              return cur;
       }
       Iterator operator--(int)
       {
              assert(_cur);
              Node* cur = _cur;
              if (_cur->_leftTag== THREAD)
                     _cur = _cur->_left;
              else
              {
                     _cur = _cur->_left;
                     while (_cur->_rightTag == LINK)         //找到_cur的左子树下最后一个访问的结点
                           _cur = _cur->_right;
              }
              return cur;
       }
       bool operator!=(const Iterator& it)const
       {
              return _cur!= it._cur;
       }
       bool operator==(const Iterator& it)const
       {
              return _cur == it._cur;
       }
       
       T& operator*()
       {
              assert(_cur);
              return _cur->_data;
       }
       T* operator->()
       {
              assert(_cur);
              return &(_cur->_data);
       }
protected:
       Node* _cur;
};
template<typename T>
class ThreadBinaryTree
{
       typedef  ThreadTreeNode<T> Node;
public:
       typedef TreeIterator<T> Iterator;
       ThreadBinaryTree()
              :_root(NULL)
       {}
       ThreadBinaryTree(const T* a, size_t size, const T& invalid)
       {
              size_t index = 0;
              _root = _CreatTree(a, size, index, invalid);
              //中序线索化二叉树
              Node* prev = NULL;
              _InThreadTree(_root, prev);
              prev->_rightTag = THREAD;
       }
       Iterator Begin()                   //获得这棵树第一个访问的结点
       {
              return Frist();
       }
       Iterator End()                      //获得这棵树最后一个访问的结点
       {
              return NULL;
       }
protected:
       Node* Frist()       //返回第一个访问的结点；
       {
              if (_root == NULL)
                     return NULL;
              Node* cur = _root;
              while (cur->_leftTag == LINK)
                     cur = cur->_left;
              return cur;
       }
       Node* _CreatTree(const T* a, size_t size, size_t& index, const T& invalid)
       {
              //创建一颗二叉树
              Node* root = NULL;
              if (index < size&&a[index] != invalid)
              {
                     root = new Node(a[index]);
                     root->_left = _CreatTree(a, size, ++index, invalid);
                     root->_right = _CreatTree(a, size, ++index, invalid);
              }
              return root;
       }
       //中序线索化二叉树
       void _InThreadTree(Node* root, Node* &prev)
       {
              if (NULL == root)
                     return;
              _InThreadTree(root->_left, prev);
              if (root->_left == NULL)                //线索化前驱
              {
                     root->_leftTag = THREAD;
                     root->_left = prev;
                     prev = root;
              }
              if (prev != root&&prev->_right == NULL)      //线索化后继
              {
                     prev->_rightTag = THREAD;
                     prev->_right = root;
                     prev = root;
              }
              _InThreadTree(root->_right, prev);
       }
protected:
       Node* _root;
};

数据结构::线索化二叉树
海绵宝宝的欧尼~ 的博客
12-25 772
1、为什么要引入线索化二叉树？       我们知道二叉树是一种非线性结构，当我们遍历二叉树的时候，我们一般的方法是利用递归或者是借助栈来实现非递归，而不管是利用递归还是栈我们知道，它们所用的开销是很大的，即压栈，建立新的栈帧，当有时候我们递归的层次很深的时候，会出现溢出，而且一般递归虽然简单，但是效率比较低。       因此我们就想能不能采取一种方式，可以减小开销，遍历的时候可以一次解决，
如何将二叉树线索化
BubbleBulu的博客
08-02 2337
线索化存在的必要原因：对于一颗二叉树，遍历是一个经常性的操作，但是如果我们每次遍历时，都要通过递归或者通过栈实现二叉树的遍历，在遍历时需要进行很多判断，并且一定程度上浪费了一些空间和时间,因此我们考虑是否可以记录下其遍历时其”前驱”和”后继”。 方法：1.对每个二叉树节点增加两个字段”前驱”和”后继”来分别存储遍历过程中它的前一个节点位置和后一个节点位置，这种方式固然是方便，不过也不得不花费更多...
二叉树线索化
胡小哲的博客
12-05 1071
首先提出一个问题 为什么要线索化二叉树？二叉树遍历的本质上是将一个复杂的非线性结构转换为线性结构，使每个节点都有了唯一前驱和后继(第一个节点无前驱，最后一个节点无后继)。对于一个节点，查找其左右子树是方便的，但是查找其前驱和后继只能在遍历中找到。 线索化二叉树解决了无法直接找到该节点在某种遍历序列中的前驱和后继节点的问题。可以在节点结构中增加前驱和后继的指针，但是增加了存储开销。另一种方法是利用
线索化二叉树及其遍历
qq_44300280的博客
05-07 950
线索化二叉树及其遍历
线索化二叉树的作用
学Java，找哪吒
08-16 1万+
一、先看一个问题 将数列{1,3,6,8,10,14}构建成一颗二叉树。 问题分析： 当我们对上面的二叉树进行中序遍历时，数列为{8,3,10,1,6,14}。 但是6,8,10,14这几个节点的左右指针，并没有完全的利用上。 如果我们希望充分的利用各个节点的左右指针，让各个节点可以指向自己的前后节点，要怎么办？ 解决方案 --> 线索化二叉树 二、线索化二叉树 1、n个节点的二叉树链表总含有n+1（公式2n-(n-1)=n+1）个空指针域。...
中序线索化二叉树
热门推荐
waldeinNJU的博客
10-26 2万+
中序线索化二叉树1. 简介2. 中序线索化的方法3. 代码详细4. 测试 1. 简介 对于二叉树来说，只能是很直观地知道某个节点及其左右子节点，但是如果想知道此节点按照某种方式遍历时的前一个节点（前继节点）和后一个节点（后继节点）的话，就不得不按照此种遍历方式对二叉树遍历一次，只有这样才能知道前继或后继节点。因此，==为了避免这种不得不遍历的麻烦，是否可以寻找一种简便的方式从而更快地获取某节点的前继或后继节点？==我认为这是对二叉树线索化的主要原因。 另一方面是涉及到资源利用的问题。如上图所示，二叉树共有
Java版线索化二叉树
qq_37837621的博客
03-06 1215
文章收藏的好句子：当你足够强大，就能轻松抵挡住命运给的打击和考验。目录1、线索化二叉树1、线索化二叉树在介绍线索化二叉树之前，我们先看一个案例，我先画一棵二叉树，如图1所示：如果我们对图1...
中序线索化二叉树的非递归算法.doc
09-12
中序线索化二叉树的非递归算法 中序线索化二叉树的非递归算法是指对二叉树进行中序遍历，并将其转换为线索化二叉树的算法。这里，我们将详细介绍该算法的实现过程和相关知识点。 算法思想 中序线索化二叉树的非...
数据结构 | 线索化二叉树
qq_42190335的博客
08-13 1192
线索化二叉树的由来 在二叉树中，我们经常发现，有许多的叶子结点的左右指针没有完全利用上，于是我们希望能将这些指针充分的利用，所以就出现了线索化二叉树 线索化二叉树的基本介绍 1、n个结点的二叉链表中含有n+1个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为线索）； 2、这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树。根据线索性质的不同，线索二叉树可分为前序线索二叉树，中序以及后序三种； 3、每一个结点的前一个结点称之为前驱结点
【数据结构与算法】——线索化二叉树
秋雨绵绵
05-18 1415
 🎄：CSDN的小伙伴们大家好，今天跟大家分享二叉树的一个经典应用，线索化二叉树。如果这篇文章对你有用，麻烦给我点个小赞以示鼓励吧🎄
Python实现线索化二叉树 Python实现线索化存储二叉树 Python线索化二叉树的遍历
storyfull
12-28 3189
Python实现线索化二叉树 Python实现线索化存储二叉树 Python线索化二叉树的遍历
线索化二叉树（先序，中序，后序）+线索化二叉树的遍历【java详解】
最新发布
2302_79862386的博客
02-17 2893
n个结点的二叉链表中含有n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种一个结点的前一个结点，称为前驱结点一个结点的后一个结点，称为后继结点//线索化时记录前一个节点//节点存储结构。
时间复杂度&空间复杂度分析
Sunnylunch-blog
09-06 2万+
时间复杂度：   一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数f(n)，进而分析f(n)随n的变化情况并确定T(n)的数量级。这里用"O"来表示数量级，给出算法的时间复杂度。                      T(n)=O(f(n));   它表示随着问题规模的n的增大，算法的执行时间的增长率和f(n)的增长率相同，这称作算法的渐进时间复杂度，简称时间复杂度。而我们
揭秘——STL空间配置器
Sunnylunch-blog
12-07 8814
为什么要有空间配置器呢？这主要是从两个方面来考虑的。 1、小块内存带来的内存碎片问题   单从分配的角度来看。由于频繁分配、释放小块内存容易在堆中造成外碎片(极端情况下就是堆中空闲的内存总量满足一个请求，但是这些空闲的块都不连续，导致任何一个单独的空闲的块都无法满足这个请求)。 2、小块内存频繁申请释放带来的性能问题。   关于性能这个问题要是再深究起来还是比较
跳表分析与实现
Sunnylunch-blog
07-11 6935
一、什么是跳表 跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，可以被看做二叉树的一个变种，它在性能上和红黑树，AVL树不相上下，但是跳表的原理非常简单，目前在Redis和LeveIDB中都有用到。 在对有序顺序表进行搜索时，使用二分查找时间复杂度是O(logn)，但是有序顺序表的插入和删除却是O(n)的算法。 在对有序链表进行搜索时，时间复
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值