2. 程式人生 > >數據結構（十三）——樹

數據結構（十三）——樹

阿新 • • 發佈：2018-02-04
釋放 有一個 valid bool nag height 分支 clear 目標

數據結構（十三）——樹

一、樹的簡介

1、樹的簡介

樹是一種非線性的數據結構，是由n（n >=0）個結點組成的有限集合。
如果n==0，樹為空樹。
如果n>0，
樹有一個特定的結點，根結點
根結點只有直接後繼，沒有直接前驅。
除根結點以外的其他結點劃分為m（m>=0）個互不相交的有限集合，T0，T1，T2，...，Tm-1，每個結合是一棵樹，稱為根結點的子樹。
樹的示例如下：
技術分享圖片

2、樹的度

樹的結點包含一個數據和多個指向子樹的分支
結點擁有的子樹的數量為結點的度，度為0的結點是葉結點，度不為0的結點為分支結點，樹的度定義為樹的所有結點中度的最大值。
技術分享圖片

3、樹的前驅和後繼

結點的直接後繼稱為結點的孩子，結點稱為孩子的雙親。

結點的孩子的孩子稱為結點的孫子，結點稱為子孫的祖先。
同一個雙親的孩子之間互稱兄弟。
技術分享圖片

4、樹中結點的層次

技術分享圖片
樹中根結點為第1層，根結點的孩子為第2層，依次類推。
樹中結點的最大層次稱為樹的深度或高度

5、樹的有序性

如果樹中結點的各子樹從左向右是有序的，子樹間不能互換位置，則稱該樹為有序樹，否則為無序樹。
技術分享圖片

6、森林

森林是由n棵互不相交的樹組成的集合。
三棵樹組成的森林如下：
技術分享圖片

二、樹的抽象實現

1、樹的抽象實現

樹在程序中表現為一種特殊的數據類型。
樹的抽象實現如下：

template <typename T>
  class Tree:public Object
  {
  protected:
    TreeNode<T>* m_root;//根結點
  public:
    Tree(){m_root = NULL;}
    //插入結點
    virtual bool insert(TreeNode<T>* node) = 0;
    virtual bool insert(const T& value, TreeNode<T>* parent) = 0;
    //刪除結點
    virtual SharedPointer< Tree<T> > remove(const T& value) = 0;
    virtual SharedPointer< Tree<T> > remove(TreeNode<T>* node) = 0;
    //查找結點
    virtual TreeNode<T>* find(const T& value)const = 0;
    virtual TreeNode<T>* find(TreeNode<T>* node)const = 0;
    //根結點訪問函數
    virtual TreeNode<T>* root()const = 0;
    //樹的度訪問函數
    virtual int degree()const = 0;
    //樹的高度訪問函數
    virtual int height()const = 0;
    //樹的結點數目訪問函數
    virtual int count()const = 0;
    //清空樹
    virtual void clear() = 0;
  };

2、樹結點的抽象實現

樹中的結點表現為一種特殊的數據類型。
結點的抽象實現如下：

template <typename T>
  class TreeNode:public Object
  {
  public:
    T value;
    TreeNode<T>* parent;
    TreeNode()
    {
      parent = NULL;
    }
    virtual ~TreeNode() = 0;
  };
  template <typename T>
  TreeNode<T>::~TreeNode()
  {
  }

三、樹的操作

1、樹和樹結點的存儲結構實現

GTreeNode能夠包含任意多個指向後繼結點的指針。

template <typename T>
  class GTreeNode:public TreeNode<T>
  {
  protected:
    LinkedList<GTreeNode<T>*> m_children;
  };
GTree為通用樹結構，每個結點可以存在多個後繼結點。
  template <typename T>
  class GTree:public Tree<T>
  {
  public:
  };

技術分享圖片
每個樹結點包含指向前驅結點的指針，優點在於可以將非線性的樹轉化為線性的結構。
技術分享圖片

2、樹中結點的查找

A、基於數據元素值的查找
定義在任意一個結點為根結點的樹中查找指定數據元素值所在的結點的函數。
技術分享圖片

GTreeNode<T>* find(GTreeNode<T>* node, const T& value)const
    {
      GTreeNode<T>* ret = NULL;
      if(node != NULL)
      {
          //如果根結點的就是目標結點
          if(node->value == value)
          {
              ret =  node;
          }
          else
          {
              //遍歷根節點的子結點
              for(node->m_children.move(0); !node->m_children.end() && (ret == NULL); node->m_children.next())
              {
                  //對每個子子結點進行查找
                  ret = find(node->m_children.current(), value);
              }
          }
      }
      return ret;
    }

    //查找結點
    virtual GTreeNode<T>* find(const T& value)const
    {
      return find(root(), value);
    }

B、基於樹中結點的查找
定義在任意一個結點為根結點的樹中查找指定結點的函數
技術分享圖片

 GTreeNode<T>* find(GTreeNode<T>* node, GTreeNode<T>* obj)const
    {
      GTreeNode<T>* ret = NULL;
      //根結點為目標結點
      if(node == obj)
      {
          ret =  node;
      }
      else
      {
          if(node != NULL)
          {
              //遍歷子結點
              for(node->m_children.move(0); !node->m_children.end() && (ret == NULL); node->m_children.next())
              {
                  ret = find(node->m_children.current(), obj);
              }
          }
      }
      return ret;
    }

    virtual GTreeNode<T>* find(TreeNode<T>* node)const
    {
      return find(root(), dynamic_cast<GTreeNode<T>*>(node));
    }

3、樹中結點的插入

樹是非線性的數據結構，無法采用下標的方式定位數據元素，由於每個結點的都有一個唯一的前驅結點（父結點），因此必須找到前驅結點才能找到插入的位置。
A、插入結點
插入結點的流程
技術分享圖片

bool insert(TreeNode<T>* node)
    {
      bool ret = true;
      if(node != NULL)
      {
          //樹為空，插入結點為根結點
          if(this->m_root == NULL)
          {
              node->parent = NULL;
              this->m_root = node;
          }
          else
          {
              //找到插入結點的父結點
              GTreeNode<T>* np = find(node->parent);
              if(np != NULL)
              {
                  GTreeNode<T>* n = dynamic_cast<GTreeNode<T>*>(node);
                  //如果子結點中無該結點，插入結點
                  if(np->m_children.find(n) < 0)
                  {
                      ret = np->m_children.insert(n);
                  }
              }
              else
              {
                  THROW_EXCEPTION(InvalidOperationException, "Invalid node...");
              }
          }
      }
      else
      {
          THROW_EXCEPTION(InvalidParameterException, "Parameter is invalid...");
      }
      return ret;
    }

B、插入數據元素
插入數據元素到樹中的流程如下：
技術分享圖片

bool insert(const T& value, TreeNode<T>* parent)
    {
      bool ret = true;
      GTreeNode<T>* node = GTreeNode<T>::NewNode();
      if(node != NULL)
      {
          node->value = value;
          node->parent = parent;
          insert(node);
      }
      else
      {
          THROW_EXCEPTION(NoEnoughMemoryException, "No enough memory...");
      }
      return ret;
    }

4、樹中結點的清除

樹的清空操作需要將樹中所有的結點清除，並釋放分配在堆中的結點。
定義清除樹中每個結點的函數
技術分享圖片
如果樹中的結點可能分配在棧上和堆上，需要將堆空間的結點進行釋放。
根據內存地址不能準確判斷結點所在的存儲空間，清除時存儲在棧上的結點並不需要釋放，只需要釋放存儲在堆空間的結點。
使用工廠模式對分配在堆空間的結點進行定制。
A、GTreeNode類中增加保護的堆空間標識成員m_flag
B、重載GTreeNode的operrator new操作符，聲明為保護
C、提供工廠方法NewNode（），在工廠方法中創建堆空間的結點，並將m_flag標識置為true。

template <typename T>
  class GTreeNode:public TreeNode<T>
  {
  protected:
    bool m_flag;//堆空間標識
    //重載new操作符，聲明為保護
    void* operator new(unsigned int size)throw()
    {
      return Object::operator new(size);
    }

  public:
    LinkedList<GTreeNode<T>*> m_children;
    GTreeNode()
    {
      //棧上分配的空間標識為false
      m_flag = false;
    }
    //工廠方法，創建堆空間的結點
    static GTreeNode<T>* NewNode()
    {
      GTreeNode<T>* ret = new GTreeNode<T>();
      if(ret != NULL)
      {
          //堆空間的結點標識為true
          ret->m_flag = true;
      }
      return ret;
    }
    //堆空間結點標識訪問函數
    bool flag()const
    {
      return m_flag;
    }
  };
結點的釋放：
    void free(GTreeNode<T>* node)
    {
      if(node != NULL)
      {
          for(node->m_children.move(0); !node->m_children.end(); node->m_children.next())
          {
              free(node->m_children.current());
          }
          //如果結點存儲在堆空間
          if(node->flag())
             delete node;//釋放
      }
    }
清空樹：
    void clear()
    {
        free(root());
        this->m_root = NULL;
    }

5、樹中結點的刪除

刪除函數的設計要點：
將被刪除結點的子樹進行刪除；
刪除函數返回一顆堆空間的樹；
具體返回值為指向樹的智能指針；
具體的結點刪除功能函數如下：
將node為根結點的子樹從原來的樹中刪除，ret作為子樹返回
技術分享圖片

void remove(GTreeNode<T>* node, GTree<T>*& ret)
    {
      ret = new GTree<T>();
      if(ret != NULL)
      {
          //如果刪除的結點是根結點
          if(root() == node)
          {
              this->m_root = NULL;
          }
          else
          {
              //獲取刪除結點的父結點的子結點鏈表
              LinkedList<GTreeNode<T>*>& child = dynamic_cast<GTreeNode<T>*>(node->parent)->m_children;
              //從鏈表中刪除結點
              child.remove(child.find(node));
              //結點的父結點置NULL
              node->parent = NULL;
          }
          //將刪除結點賦值給創建的樹ret的根結點
          ret->m_root = node;
      }
      else
      {
          THROW_EXCEPTION(NoEnoughMemoryException, "No enough memory...");
      }
    }

A、基於刪除數據元素值刪除結點

 SharedPointer<Tree<T>> remove(const T& value)
    {
      GTree<T>* ret = NULL;
      //找到結點
      GTreeNode<T>* node = find(value);
      if(node != NULL)
      {
          remove(node, ret);
      }
      else
      {
          THROW_EXCEPTION(InvalidParameterException, "Parameter invalid...");
      }
      return ret;
    }

B、基於結點刪除

 SharedPointer<Tree<T>> remove(TreeNode<T>* node)
    {
      GTree<T>* ret = NULL;
      node = find(node);
      if(node != NULL)
      {
          remove(dynamic_cast<GTreeNode<T>*>(node), ret);
      }
      else
      {
          THROW_EXCEPTION(InvalidParameterException, "Parameter invalid...");
      }
      return ret;
    }

6、樹中結點的屬性操作

A、樹中結點的數量
以node為結點的子樹的結點數量，遞歸模型如下：
技術分享圖片

int count(GTreeNode<T>* node) const
    {
      int ret = 0;
      if(node != NULL)
      {
          ret = 1;//根結點
          //遍歷根節點的子結點
          for(node->m_children.move(0); !node->m_children.end(); node->m_children.next())
          {
              ret += count(node->m_children.current());
          }
      }
      return ret;
    }
    //樹的結點數目訪問函數
    int count()const
    {
        count(root());
    }

B、樹的度
結點node為根的樹的度的功能函數的遞歸模型如下：
技術分享圖片

int degree(GTreeNode<T>* node) const
    {
      int ret = 0;
      if(node != NULL)
      {
          //結點的子結點的數量
          ret = node->m_children.length();
          //遍歷子結點
          for(node->m_children.move(0); !node->m_children.end(); node->m_children.next())
          {
              int d = degree(node->m_children.current());
              if(ret < d)
              {
                  ret = d;
              }
          }
      }
      return ret;
    }

    //樹的度訪問函數
    int degree()const
    {
        return degree(root());
    }

C、樹的高度
結點node為根的樹的高度的功能函數的遞歸模型如下：
技術分享圖片

int height(GTreeNode<T>* node)const
    {
      int ret = 0;
      if(node != NULL)
      {
          //遍歷子結點
          for(node->m_children.move(0); !node->m_children.end(); node->m_children.next())
          {
              //當前結點的高度
              int h = height(node->m_children.current());
              if(ret < h)
              {
                  ret = h;
              }
          }
          ret = ret + 1;
      }
      return ret;
    }
    //樹的高度訪問函數
    int height()const
    {
        height(root());
    }

7、樹中結點的遍歷

樹是一種非線性的數據結構，遍歷樹中結點可以采用遊標的方式。
A、在樹中定義一個遊標（GTreeNode<T>* node）
B、遍歷開始前將遊標指向根結點
C、獲取遊標指向的數據元素
D、通過結點中的m_children成員移動遊標
技術分享圖片
將根結點壓入隊列中

 bool begin()
    {
      bool ret = (root() != NULL);
      if(ret)
      {
          //清空隊列
          m_queue.clear();
          //根節點加入隊列
          m_queue.add(root());
      }
      return ret;
    }

判斷隊列是否為空

 bool end()
    {
        return (m_queue.length() == 0);
    }

隊頭元素彈出，將隊頭元素的孩子壓入隊列中

 bool next()
    {
      bool ret = (m_queue.length() > 0);
      if(ret)
      {
          GTreeNode<T>* node = m_queue.front();
          m_queue.remove();//隊頭元素出隊
          //將隊頭元素的子結點入隊
          for(node->m_children.move(0); !node->m_children.end(); node->m_children.next())
          {
              m_queue.add(node->m_children.current());
          }
      }
      return ret;
    }

訪問隊頭元素指向的數據元素

T current()
    {
      if(!end())
      {
          return m_queue.front()->value;
      }
      else
      {
          THROW_EXCEPTION(InvalidOperationException, "No value at current Node...");
        }
    }

四、通用樹結構的實現

1、通用樹節點的實現

 template <typename T>
  class GTreeNode:public TreeNode<T>
  {
  protected:
    bool m_flag;//堆空間標識
    //重載new操作符，聲明為保護
    void* operator new(unsigned int size)throw()
    {
      return Object::operator new(size);
    }
    GTreeNode(const GTreeNode<T>& other);
    GTreeNode<T>& operator = (const GTreeNode<T>& other);

  public:
    LinkedList<GTreeNode<T>*> m_children;
    GTreeNode()
    {
      //棧上分配的空間標識為false
      m_flag = false;
    }
    //工廠方法，創建堆空間的結點
    static GTreeNode<T>* NewNode()
    {
      GTreeNode<T>* ret = new GTreeNode<T>();
      if(ret != NULL)
      {
          //堆空間的結點標識為true
          ret->m_flag = true;
      }
      return ret;
    }
    //堆空間結點標識訪問函數
    bool flag()const
    {
      return m_flag;
    }
  };

2、通用樹的實現

 template <typename T>
  class GTree:public Tree<T>
  {
  protected:
    LinkedQueue<GTreeNode<T>*> m_queue;
    GTree(const GTree<T>& other);
    GTree<T>& operator=(const GTree<T>& other);
    GTreeNode<T>* find(GTreeNode<T>* node, const T& value)const
    {
      GTreeNode<T>* ret = NULL;
      if(node != NULL)
      {
          //如果根結點的就是目標結點
          if(node->value == value)
          {
              ret =  node;
          }
          else
          {
              //遍歷根節點的子結點
              for(node->m_children.move(0); !node->m_children.end() && (ret == NULL); node->m_children.next())
              {
                  //對每個子子結點進行查找
                  ret = find(node->m_children.current(), value);
              }
          }
      }
      return ret;
    }
    GTreeNode<T>* find(GTreeNode<T>* node, GTreeNode<T>* obj)const
    {
      GTreeNode<T>* ret = NULL;
      //根結點為目標結點
      if(node == obj)
      {
          ret =  node;
      }
      else
      {
          if(node != NULL)
          {
              //遍歷子結點
              for(node->m_children.move(0); !node->m_children.end() && (ret == NULL); node->m_children.next())
              {
                  ret = find(node->m_children.current(), obj);
              }
          }
      }
      return ret;
    }

    void free(GTreeNode<T>* node)
    {
      if(node != NULL)
      {
          for(node->m_children.move(0); !node->m_children.end(); node->m_children.next())
          {
              free(node->m_children.current());
          }
          //如果結點存儲在堆空間
          if(node->flag())
             delete node;//釋放
      }
    }

    void remove(GTreeNode<T>* node, GTree<T>*& ret)
    {
      ret = new GTree<T>();
      if(ret != NULL)
      {
          //如果刪除的結點是根結點
          if(root() == node)
          {
              this->m_root = NULL;
          }
          else
          {
              //獲取刪除結點的父結點的子結點鏈表
              LinkedList<GTreeNode<T>*>& child = dynamic_cast<GTreeNode<T>*>(node->parent)->m_children;
              //從鏈表中刪除結點
              child.remove(child.find(node));
              //結點的父結點置NULL
              node->parent = NULL;
          }
          //將刪除結點賦值給創建的樹ret的根結點
          ret->m_root = node;
      }
      else
      {
          THROW_EXCEPTION(NoEnoughMemoryException, "No enough memory...");
      }
    }

    int count(GTreeNode<T>* node) const
    {
      int ret = 0;
      if(node != NULL)
      {
          ret = 1;//根結點
          //遍歷根節點的子結點
          for(node->m_children.move(0); !node->m_children.end(); node->m_children.next())
          {
              ret += count(node->m_children.current());
          }
      }
      return ret;
    }

    int height(GTreeNode<T>* node)const
    {
      int ret = 0;
      if(node != NULL)
      {
          //遍歷子結點
          for(node->m_children.move(0); !node->m_children.end(); node->m_children.next())
          {
              //當前結點的高度
              int h = height(node->m_children.current());
              if(ret < h)
              {
                  ret = h;
              }
          }
          ret = ret + 1;
      }
      return ret;
    }

    int degree(GTreeNode<T>* node) const
    {
      int ret = 0;
      if(node != NULL)
      {
          //結點的子結點的數量
          ret = node->m_children.length();
          //遍歷子結點
          for(node->m_children.move(0); !node->m_children.end(); node->m_children.next())
          {
              int d = degree(node->m_children.current());
              if(ret < d)
              {
                  ret = d;
              }
          }
      }
      return ret;
    }
  public:
    GTree()
    {

    }
    //插入結點
    bool insert(TreeNode<T>* node)
    {
      bool ret = true;
      if(node != NULL)
      {
          //樹為空，插入結點為根結點
          if(this->m_root == NULL)
          {
              node->parent = NULL;
              this->m_root = node;
          }
          else
          {
              //找到插入結點的父結點
              GTreeNode<T>* np = find(node->parent);
              if(np != NULL)
              {
                  GTreeNode<T>* n = dynamic_cast<GTreeNode<T>*>(node);
                  //如果子結點中無該結點，插入結點
                  if(np->m_children.find(n) < 0)
                  {
                      ret = np->m_children.insert(n);
                  }
              }
              else
              {
                  THROW_EXCEPTION(InvalidOperationException, "Invalid node...");
              }
          }
      }
      else
      {
          THROW_EXCEPTION(InvalidParameterException, "Parameter is invalid...");
      }
      return ret;
    }
    bool insert(const T& value, TreeNode<T>* parent)
    {
      bool ret = true;
      GTreeNode<T>* node = GTreeNode<T>::NewNode();
      if(node != NULL)
      {
          node->value = value;
          node->parent = parent;
          insert(node);
      }
      else
      {
          THROW_EXCEPTION(NoEnoughMemoryException, "No enough memory...");
      }
      return ret;
    }
    //刪除結點
    SharedPointer<Tree<T>> remove(const T& value)
    {
      GTree<T>* ret = NULL;
      //找到結點
      GTreeNode<T>* node = find(value);
      if(node != NULL)
      {
          remove(node, ret);
          m_queue.clear();
      }
      else
      {
          THROW_EXCEPTION(InvalidParameterException, "Parameter invalid...");
      }
      return ret;
    }

    SharedPointer<Tree<T>> remove(TreeNode<T>* node)
    {
      GTree<T>* ret = NULL;
      node = find(node);
      if(node != NULL)
      {
          remove(dynamic_cast<GTreeNode<T>*>(node), ret);
          m_queue.clear();
      }
      else
      {
          THROW_EXCEPTION(InvalidParameterException, "Parameter invalid...");
      }
      return ret;
    }
    //查找結點
    GTreeNode<T>* find(const T& value)const
    {
      return find(root(), value);
    }
    GTreeNode<T>* find(TreeNode<T>* node)const
    {
        return find(root(), dynamic_cast<GTreeNode<T>*>(node));
    }
    //根結點訪問函數
    GTreeNode<T>* root()const
    {
        return dynamic_cast<GTreeNode<T>*>(this->m_root);
    }
    //樹的度訪問函數
    int degree()const
    {
        return degree(root());
    }
    //樹的高度訪問函數
    int height()const
    {
        height(root());
    }
    //樹的結點數目訪問函數
    int count()const
    {
        count(root());
    }
    //清空樹
    void clear()
    {
        free(root());
        this->m_root = NULL;
    }

    bool begin()
    {
      bool ret = (root() != NULL);
      if(ret)
      {
          //清空隊列
          m_queue.clear();
          //根節點加入隊列
          m_queue.add(root());
      }
      return ret;
    }

    bool end()
    {
        return (m_queue.length() == 0);
    }

    bool next()
    {
      bool ret = (m_queue.length() > 0);
      if(ret)
      {
          GTreeNode<T>* node = m_queue.front();
          m_queue.remove();//隊頭元素出隊
          //將隊頭元素的子結點入隊
          for(node->m_children.move(0); !node->m_children.end(); node->m_children.next())
          {
              m_queue.add(node->m_children.current());
          }
      }
      return ret;
    }

    T current()
    {
      if(!end())
      {
          return m_queue.front()->value;
      }
      else
      {
          THROW_EXCEPTION(InvalidOperationException, "No value at current Node...");
      }
    }
    virtual ~GTree()
    {
      clear();
    }
  };

數據結構（十三）——樹

相關推薦

數據結構（十三）——樹

釋放 有一個 valid bool nag height 分支 clear 目標 數據結構（十三）——樹 一、樹的簡介 1、樹的簡介 樹是一種非線性的數據結構，是由n（n >=0）個結點組成的有限集合。如果n==0，樹為空樹。如果n>0，樹有一個特定的結點，根結

數據結構（四）樹---樹的存儲結構

info -- 指向 node 十分 依次 ren 實現 過程 前提 樹中的某個結點的孩子可以有多個，所以僅僅使用簡單的順序結構或者鏈式結構是不能完全表示一整棵樹的。 充分利用順序存儲結構和鏈式存儲結構的特點，完全可以實現對樹的存儲結構的表示 我們表示一棵樹的方法有：

數據結構（四）樹---集合的表示及查找（並查集）

點數據 如何 某個結點 efault .data nts 結構 問題 amp 一：集合運算 交，並，補，差，判斷一個元素是否屬於某一集合 並查集將在判斷連通性和是否成環上面起到至關重要的作用 二：並查集 （一）集合並 並集間有一元素相連 （二）查某元素屬於什麽集

數據結構（七）二叉樹

廣度優先 -1 XML -o 滿二叉樹 nal 如果 數據 中序 定義 特點 特殊的二叉樹 斜樹 顧名思義，其中的結點都只有一個，又分為左斜樹和右斜樹，這時候又有疑惑了，這種數據結構不是有線性表一樣嗎，沒錯，線性表是一種特殊的樹 滿二叉樹 完全二叉樹

數據結構（12）_樹的概念及通用樹的實現

區域 指向 樹的高度 存儲結構 ges urn 深度 建堆 add 1.樹的定義與操作 1.1.樹的相關定義 1.樹的定義 樹是一種非線性的數據結構，右n(n>=0)個結點組成的有限集合，如果n=0,稱為空樹，如果n>0,則： 有一個特定的結點被稱之為跟結點(

數據結構（六）查找---二叉搜索樹（排序樹）

color 父節點 img hid warning close status 效率 spa 前提 前面的查找我們都是靜態查找，因為數據集是有序存放，查找的方法有多種，可以使用折半，插值，斐波那契等，但是因為有序，在插入和刪除操作上的效率並不高。 這時我們就需要一種動態查找

數據結構（一）-- 平衡樹

empty 閱讀 教程 參考 可變 min itl 樹性能 9.png 文章是對鄧俊輝老師數據結構教程的總結，部分圖片資料來自鄧俊輝老師的教學PPT 建議閱讀前先閱讀參考文章的第二，三文章，總結得非常好！ 文章部分代碼和圖片來自參考文章的第

數據結構（三）--- B樹（B-Tree）

高速緩存 .com 記得 ret 足夠 gin 行合並 add 樹和二叉樹 文章圖片代碼來自鄧俊輝老師的課件 概述 上圖就是 B-Tree 的結構，可以看到這棵樹和二叉樹有點不同---“又矮又肥”。同時子節點可以有若幹個小的子節點構成。那麽

數據結構（四）--- 紅黑樹（RedBlock-Tree）

rabl real-time 消息 ren linu 轉變 數據結構 replace 算法 文章圖片來自鄧俊輝老師課件 先提幾個問題去思考學習本文 ： 紅黑樹和2-4樹（B-Tree）很像，那麽它存在的動機又是什麽呢 插入和刪

數據結構（四）：樹

應用 ren earch pre nts 二叉 數據結構 lse bsp 樹 概念：樹是一些節點的集合，一棵樹由稱作根（root）的節點 r 以及0個或多個非空的（子）樹組成，這些子樹中每一棵的根都被來自根 r 的一條有向的邊（edge）連接。每一棵子樹的根叫做根 r 的

數據結構（二）:線性表的使用原則以及鏈表的應用-稀疏矩陣的三元組表示

查找 triple 表的操作 結構 循環鏈表 循環 大於 ria 幫助 上一篇博文中主要總結線性表中的鏈式存儲結構實現，比方單向鏈表、循環鏈表。還通過對照鏈表和順序表的多項式的存儲表示。說明鏈表的長處。能夠參看上篇博文http://blog.csdn.net/lg125

數據結構（二）線性表——鏈表

erro urn 找到 頭結點 tee 存在 結構 strong 函數 通常情況下，鏈接可分為單鏈表、雙向鏈表和循環鏈表三種常用類型。 一、單鏈表基本操作的實現 使用鏈式存儲結構來實現的線性表稱為鏈表。首元結點、頭結點、頭指針、空指針。 1.單鏈表的類型定義 typede

數據結構（五）串

src www 影響 algo res aaa edi note XML 定義 串的存儲結構 順序存儲結構 當長度超過了預分配的空間，需要重新動態分配新的空間 鏈式存儲結構 一個節點對應一個字符會造成資源浪費，所以一個節點可以放多個字符（相當於鏈式的每個節點內

Redis數據結構（四）

方式 lpush alt 擴展 操作 art 中間 star range 存儲list： list存儲方式采用頭和尾插入的方式，這樣效率快，如果沒有這個插入的數據，redis自己會創建這個數據，如果是中間插入的話，采用list方式效率就會很慢。 ArrayList

自制數據結構（容器）-java開發用的最多的ArrayList和HashMap

bject private java開發 技術 cep uil ould print ram public class MyArrayList<E> { private int capacity = 10; private

數據結構（一）之鏈表

存儲 鏈表操作 author void 復雜 pac 部分 地址 插入 一、鏈表 　　鏈表是一種物理存儲單元上非連續、非順序的存儲結構，數據元素的邏輯順序是通過鏈表中的指針鏈接次序實現的。 　　鏈表由一系列結點（鏈表中每一個元素稱為結點）組成，結點可以在運行時動態生成。每個

數據結構（三）之單鏈表反向查找

hid 默認 splay del 下標 com 設置 display fbo 一、反向查找單鏈表 1、簡單查找 　　先遍歷獲取單鏈表單長度n，然後通過計算得到倒數第k個元素的下標為n-k，然後查找下標為n-k的元素。 2、優化查找 先找到下標為k的元素為記錄點p

算法導論筆記——第十~十一章 數據結構（一） 散列

發生 情況 要求 sub 裝載 ted 因子 let 完全 第十章 基本數據結構 棧：可由數組表示 隊列：可由數組表示 指針和對象：可由多數組表示。可用棧表示free list 有根數： 　　二叉樹：左右孩子 　　分支無限制：左孩子右兄弟表示法 第十一章 散列表 數組：

第二章 python中重要的數據結構（下）

alt 檢查 testin and 淺復制 .py remove arr cti 二、元組(tuple)：不可變序列　 跟list一樣，也是一種序列，唯一不同的是，元組元素不能被修改，通常用(, ,)表示元組，也可以不加括號。 1 #創建元組 2 >>&

Python數據結構（一） 字典

字典0x 01 字典簡介 子典和列表是python中最常用的兩種數據類型，字典是鍵值對(key-value)格式的數據類型，它和列表一樣也有索引，但不是列表中的下標，而是使用key來作為索引，key所對應的值就是value，所以字典是無序的，因此任何時候只要訪問字典的key，便可以得到對應的value，