微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

【数据结构】堆heap，Trie树，位图Bitmap

分类：数据结构作者：佚名

本节研究堆heap、Trie树、位图Bitmap的实现；


堆

说明几点

（1）堆分为大根堆和小根堆；大根堆的根为最大值，每一个节点的值都不小于其孩子的值；

（2）可以利用大根堆实现升序排序；主要是利用大根堆的头和需要排序的最后一个数字交换的思想；

（3）使用大根堆实现最大优先级队列，类似stl中queue的操作，只是对于元素在队列中的元素优先级是不一样的，在最大优先级中，队列头为值最大元素；可利用大根堆来维护一个最大优先级队列；向优先级队列中push元素，类似像堆的末尾添加一个元素，然后使用_makeHeapUp寻找该元素的存放位置，进而维护大根堆；当向优先级队列中pop元素，将首元素和最后一个元素对换，然后使用_makeHeapDown来从首元素向下维护大根堆，类似堆排序，最后再将尾部元素pop_back；

（4）stl中使用sort_heap对容器进行堆排序，注意该容器需保证已经符合堆的特性；

（5）stl中使用make_heap对对一个容器中的值进行建堆；pop_heap，push_heap分别对队进行出堆（出堆之后，出堆值保存在容器的尾部）和入堆（入堆之前，入堆值已经保存在容器的尾部）；


堆排序

inline int left(int parent)
{
  return parent*2 + 1;
}

inline int right(int parent)
{
  return parent*2 + 2;
}

inline int parent(int child)
{
  return (child-1) / 2;
}

void _makeHeapDown(vector<int>& array,int top,int end)
{
  while (left(top) < end)
    {
      int leftChild = left(top);
      int rightChild = right(top);

      int min = top;
      if (array[top] < array[leftChild])
        min = leftChild;

      if (rightChild < end && array[min] < array[rightChild])
        min = rightChild;

      if (top == min)
        break;

      swap(array[min],array[top]);

      top = min;
    }
}

void heapSort(vector<int>& array)
{
  for (int i = array.size() / 2; i >= 0; --i)
    _makeHeapDown(array,i,array.size());

  for (int i = array.size()-1; i >= 1; --i)
    {
      swap(array[i],array[0]);
      _makeHeapDown(array,i);
    }
}

说明几点：

（1）在堆排序中，仅仅使用了向下维护堆特性，但是优先级队列中使用了向上和向下维护堆特性；


优先级队列

inline int left(int parent)
{
  return parent*2 + 1;
}

inline int right(int parent)
{
  return parent*2 + 2;
}

inline int parent(int child)
{
  return (child-1) / 2;
}

void _makeHeapDown(vector<int>& array,array[top]);

      top = min;
    }
}

void _makeHeapUp(vector<int>& array,int last)
{
  if (last < 0)
    return;

  int value = array[last];
  while (last > 0)
    {
      int parentIndex = parent(last);

      if (array[parentIndex] < value)
        {
          array[last] = array[parentIndex];
          last = parentIndex;
        }
      else
        {
          break;
        }
    }

  array[last] = value;
}

class PriorityQueue
{
public:
  int size() const
  {
    return _seq.size();
  }

  bool empty() const
  {
    return _seq.empty();
  }

  void push(int x)
  {
    _seq.push_back(x);
    _makeHeapUp(_seq,_seq.size()-1);
  }

  int top()
  {
    if (_seq.empty())
      return -1;

    return _seq[0];
  }

  void pop()
  {
    if (_seq.empty())
      return;

    swap(_seq[0],_seq[_seq.size()-1]);
    _makeHeapDown(_seq,_seq.size()-1);

    _seq.pop_back();
  }

private:
  vector<int> _seq;
};


Trie树

基本知识

（1）Trie的核心思想是空间换时间，利用字符串的公共前缀来降低查询时间的开销以达到提高效率的目的；

（2）根节点不包含字符，除根节点外每一个节点都只包含一个字符，节点保存对应的字符值；

（3）从根节点到某一节点，路径上经过的字符（节点）连接起来，为该节点对应的字符串；

（4）每个节点的所有子节点包含的字符都不相同；

（5）由于某些单词是其他单词的前缀，因此每一个节点增加是否为单词的标识；

（6）Trie树，即字典树，是一种树形结构，最大限度地减少无谓的字符串比较；典型应用是用于统计和排序大量的字符串（但不仅限于字符串）；


基本实现

struct TrieNode
{
  char value;
  vector<TrieNode*> children;
  bool word;
};

class Trie
{
public:
  Trie()
  {
    root = new TrieNode();
    root->word = false;
  }

  ~Trie()
  {
    _deleteTrieNode(root);
  }

  void insert(string s)
  {
    TrieNode* node = root;
    for (int i=0; i < s.size(); ++i)
      {
        if (!isalpha(s[i]))
          return;

        vector<TrieNode*>& children = node->children;
        if (children.empty())
          children.assign(26,NULL);

        int index = tolower(s[i]) - 'a';
        if (children[index])
          {
            node = children[index];

            if (i == s.size()-1)
              node->word = true;
          }
        else
          {
            TrieNode* child = new TrieNode();
            child->value = s[i];

            if (i < s.size()-1)
              {
                child->word = false;
              }
            else
              {
                child->word = true;
              }

            children[index] = child;

            node = child;
          }
      }
  }

  bool search(string key)
  {
    TrieNode* node = root;
    int i = 0;
    bool flag = false;
    for (i=0; i < key.size(); ++i)
      {
        if (!isalpha(key[i]))
          return false;

        vector<TrieNode*>& children = node->children;
        if (children.empty())
          return false;

        int index = tolower(key[i]) - 'a';

        TrieNode* child = children[index];
        if (child)
          {
            node = child;
            flag = child->word;
          }
        else
          {
            return false;
          }
      }

    return flag;
  }

  bool startsWith(string prefix)
  {
    TrieNode* node = root;
    for (int i=0; i < prefix.size(); ++i)
      {
        if (!isalpha(prefix[i]))
          return false;

        vector<TrieNode*>& children = node->children;
        if (children.empty())
          return false;

        int index = tolower(prefix[i]) - 'a';
        TrieNode* child = children[index];
        if (child)
          {
            node = child;
          }
        else
          {
            return false;
          }
      }

    return true;
  }

private:
  void _deleteTrieNode(TrieNode* node)
  {
    for (int i=0; node && i < node->children.size(); ++i)
      _deleteTrieNode(node->children[i]);

    if (node)
      delete node;
  }

  TrieNode* root;
};

说明几点

（1）本程序的Trie树的建立，仅仅建立对应的小写字符的字典树，对于大写字符将转换为小写字符；遇到非单词字符将会提前返回；

（2）在TrieNode中word标识该节点是否为一个单词；

（3）在析构函数中，利用递归来释放每一个节点的内存；


基本应用

描述：给你100000个长度不超过10的单词。对于每一个单词，我们要判断他出没出现过，如果出现了，求第一次出现在第几个位置。

解决办法：

（1）由于单词长度不超过10，建立Trie树也是可以忍受的，空间的花费不会超过（单词数*单词长度）个TrieNode；还且可以在边查询时边建立Trie树；

（2）若单词第一次出现，查询时建立Trie树，在最后一个节点标识该单词第一次出现的位置，可以修改TrieNode的word标识类型为int（默认值为-1），存放第一次出现的位置；

（3）若单词不是第一次出现，那么在查询到该单词最后一个字符时，该字符的word标识不为-1，说明已经该单词已经出现，word的值为该单词第一次出现的位置；


位图Bitmap

基本知识

（1）在C++中，我们可以直接使用bitset来进行位图相关的操作；

（2）位图可以使用在海量数据相关处理中，比如一个文件中含有1000亿个32位整数，请找出文件中未出现的整数；此时我们就可以使用位图，所有的32位数有2^32，即4G个数，那么4G个数可以使用4Gbit，即512MB内存来存放，然后遍历文件中的每一个数，对位图中相应的位置进行置位，最后找出位图中未置位的数就可以了；


基本实现

template <unsigned N>
class Bitmap final
{
public:
  explicit Bitmap(unsigned val = 0):
    _size((N-1)/32 + 1),_bits(_size,0)
  {
    _init(val);
  }
  
  bool any() const
  {
    for (int i = 0; i < _bits.size(); ++i)
    {
      if (_bits[i] > 0)
        return true;
    }
    
    return false;
  }
  
  bool none() const
  {
    return !any();
  }
    
  void reset()
  {
    for (int i = 0; i < _bits.size(); ++i)
      _bits[i] = 0;
  }
  
  bool test(int pos) const
  {
    if (pos < 0)
      return false;
    
    int m = pos / 32;
    int n = pos % 32;
    
    return (_bits[m] & (1 << n)) > 0; 
  }
  
  void set(int pos,bool flag)
  {
    if (pos < 0)
      return;
    
    int m = pos / 32;
    int n = pos % 32;
    
    if (flag) {
      _bits[m] |= 1 << n; 
    } else {
      _bits[m] &= ~(1 << n); 
    }
  }
  
  void reset(int pos)
  {
    if (pos < 0)
      return;
    
    int m = pos / 32;
    int n = pos % 32;
    _bits[m] &= ~(1 << n); 
  }
  
  size_t size() const
  {
      return N;
  }
  
  void print() const
  {
    for(int i = _bits.size()-1; i >= 0; --i)
    {
      cout << hex << _bits[i] << " ";
    }
    
    cout << endl;
  }
private:
  void _init(unsigned val)
  {
    int i = 0;
    while (val > 0)
    {
      if (val & 0x01)
      {
        int m = i / 32;
        int n = i % 32;
        _bits[m] |= 1 << n; 
      }
      
      val >>= 1;
      ++i;
    }
  }
  
  int _size;
  vector<int> _bits;
};

int main(void)
{
  Bitmap<132> bits;
  bits.print();
  
  cout << bits.test(0) << endl;
  cout << bits.test(15) << endl;
  cout << bits.test(16) << endl;
  
  bits.set(117,true);
  bits.print();
  cout << bits.test(16) << endl;
  cout << bits.test(117) << endl;
  
  bits.reset(1);
  bits.print();
  
  cout << dec << bits.size() << endl;
  
  cout << dec << bits.any() << endl;

  return 0;
}
说明几点：

（1）该位图仅仅实现相关的基本操作，底层使用vector<int>来进行实现；

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

【啊哈！算法】算法3：最常用的排序——快速排序
【啊哈！算法】算法3：最常用的排序——快速排序       上一节的冒泡排序可以说是我们学习第一个真正的排序算法，并且解决了桶排序浪费空间的问题，但在算法的执行效率上却牺牲了很多，它的时间复杂度达到了O(N2)。假如我们的计算机每秒钟可以运行10亿次，那么对1亿个数进行排序，桶排序则只需要0.1秒，而冒泡排序则需要1千万秒，达到115天之久，是不是很吓人。那有没有既不浪费空间又可以快一点的排序算法
[数据结构与算法]模式匹配与文本处理-匿名组与命名组
匿名组 这里可能用到几个不同的分组构造。通过括号内围绕的正则表达式就可以组成第一个构造。正如稍后要介绍的一样，既然也可以命名组，大家就有考虑把这个构造作为匿名组。作为一个实例，请看看下列字符串： “08/14/57 46 02/25/59 45 06/05/85 18 03/12/88 16 09/09/90 13“ 这个字符串就是由生日和年龄组成的。如果需要匹配年两而不要生日，就可以把正则
[C#]选择排序
选择排序：从数组的起始位置处开始，把第一个元素与数组中其他元素进行比较。然后，将最小的元素方式在第0个位置上，接着再从第1个位置开始再次进行排序操作。这种操作一直到除最后一个元素外的每一个元素都作为新循环的起始点操作过后才终止。 public void SelectionSort() { int min, temp;
[数据结构与算法]队列的优先级
public struct Pqitem { public int priority; public string name; } class CQueue { private ArrayList pqueue; public CQueue() { pqueue
[数据结构与算法]模式匹配-数量词
在编写正则表达式的时候，经常会向要向正则表达式添加数量型数据，诸如”精确匹配两次”或者”匹配一次或多次”。利用数量词就可以把这些数据添加到正则表达式里面了。 数量词(+):这个数量词说明正则表达式应该匹配一个或多个紧紧接其前的字符。 string[] words = new string[] { "bad", "boy", "baad", "baaad" ,"bear", "b
[数据结构与算法]白话经典算法系列之五 归并排序的实现
来自：http://blog.csdn.net/morewindows/article/details/6678165/归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列
[C#]插入排序
插入排序算法有两层循环。外层循环会啄个遍历数组元素，而内存循环则会把外层循环所选择的元素与该元素在数组内的下一个元素进行比较。如果外层循环选择的元素小于内存循环选择的元素，那么瘦元素都想右移动以便为内存循环元素留出位置。 public void InsertionSort() { int inner, temp;
[C#]二叉查找法
public int binSearch(int value) { int upperBround, lowerBound, mid; upperBround = arr.Length - 1; lowerBound = 0; while (lowerBound <= upper
[数据结构与算法]双向链表
虽然从表内第一个节点到最后一个节点的遍历操作是非常简单的，但是反向遍历链表却不是一件容易的事情。如果为Node类添加一个字段来存储指向前一个节点的连接，那么久会使得这个反向操作过程变得容易许多。当向链表插入节点的时候，为了吧数据复制给新的字段会需要执行更多的操作，但是当腰吧节点从表移除的时候就能看到他的改进效果了。 首先需要修改Node类来为累增加一个额外的链接。为了区别两个连接，这个把指
[数据结构]树及树的遍历
八、树（Tree）树，顾名思义，长得像一棵树，不过通常我们画成一棵倒过来的树，根在上，叶在下。不说那么多了，图一看就懂：当然了，引入了树之后，就不得不引入树的一些概念，这些概念我照样尽量用图，谁会记那么多文字？树这种结构还可以表示成下面这种方式，可见树用来描述包含关系是很不错的，但这种包含关系不得出现交叉重叠区域，否则就不能用树描述了，看图：面试的时候我们经常被考到的是一种叫“二叉树”的结构，二叉
苹果市值2025年有望达4万亿美元
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot