C++博客-野猪世界-随笔分类-算法

二叉树动态规划回溯算法

野猪红 — Thu, 14 Jun 2012 09:20:00 GMT

算法博大精深平时就多积累点
1.二叉树的非递归遍历
*先序
思想：a.根树进栈；
      b.只要栈不为空得到栈顶节点开始循环遍历其左树同时访问并进栈一直到左树为空；
      c.出栈直到找到有右子树的节点；
      d.访问该右子树并进栈；
      e.转到b步骤
大概如下：

void preOrderTravel(BinTree* t)
{
    std::stack<BinTree*,std::list<BinTree*>> s;
    BinTree* p=NULL;
    if(!t) return;
    cout<<t->data<<endl;
    s.push(t);
    while(!s.empty())
    {
        p=s.top();
        while(p->left)
        {
            cout<<p->left->data<<endl;
            s.push(p->left);
            p=p->left;
        }
        p=s.pop();
        while(!(p->right)&&!s.empty())
        {
            p=s.pop();
        }
        if(p->right)
        {
            cout<<p->right->data<<endl;
            s.push(p->right);
        }
    }
}

野猪红 2012-06-14 17:20 发表评论

boost pool object_pool

野猪红 — Tue, 26 Apr 2011 10:18:00 GMT

好看了一天的object_pool 容易嘛现在总结下

这个什么的继承自pool

class pool
{
details::PODptr list;
}

这里list干什么的呢如下所示保存着分配的所有数据块

其中的sz不仅仅包含数据本身的大小还包括下个数据块的指针和大小

所以整个数据块就可以串联起来就像名字list一样

class PODptr
{
char * ptr;
size_type sz;
}

一个pool的内存就在ptr里面了一开始空的

1   const size_type partition_size = alloc_size();
2   const size_type POD_size = next_size * partition_size +
3       details::pool::ct_lcm<sizeof(size_type), sizeof(void *)>::value + sizeof(size_type);
4   char * const ptr = UserAllocator::malloc(POD_size);
5   next_size <<= 1;

在这里就分配内存了第一次next_size=32 然后是64,128...partition_size 大概就是我们要分配类型的字节大小

后面两个值details::pool::ct_lcm::value和sizeof(size_type)

一个是指向下个内存块的指针，一个是下个内存块的大小

一般都为4个字节，加起来就是8个字节，

所以其总大小为数据块大小+8个字节

好下面就是比较关键的就是对这块内存块的管理

好 pool继承自simple_segregated_storage

class simple_segregated_storage
{
protected:
void * first;
}

然后嘛 first在一开始内存分配的时候就指向内存块的开始

并且采用boost大无上手法可以让内存块串联起来不管怎么样 nextof(first)就是下一个我们的类型块，

一开始不是分配了32块那样的类型嘛，值得注意的是，

first始终是指向第一个空闲块的，每次要分配一个类型块时，取first值，返回给请求者，然后first=nextof(first)

好那么释放怎么做的呢事实上很简单即把要释放的块重新用first回收起来并且是有序的串起来即按照内存从小到大用next()

串起来这样有啥好处呢在~object_pool发生时，比较方便快速，具体看代码就是了为了每次在destroy()时保持有序：

1  void ordered_free(void * const chunk)
2  {
3       // This (slower) implementation of 'free' places the memory
4       //  back in the list in its proper order.
5       // Find where "chunk" goes in the free list
6       void * const loc = find_prev(chunk);
7       // Place either at beginning or in middle/end
8       if (loc == 0)
9         free(chunk);
10       else
11       {
12         nextof(chunk) = nextof(loc);
13         nextof(loc) = chunk;
14       }
15  }
16 template
17 void * simple_segregated_storage::find_prev(void * const ptr)
18 {
19   // Handle border case
20   if (first == 0 || std::greater<void *>()(first, ptr))
21     return 0;
22   void * iter = first;
23   while (true)
24   {
25     // if we're about to hit the end or
26     //  if we've found where "ptr" goes
27     if (nextof(iter) == 0 || std::greater<void *>()(nextof(iter), ptr))
28       return iter;
29     iter = nextof(iter);
30   }
31 }

很容易构造一种最坏复杂度的情况：

1      const int N = 10000;
2      Sample* a[N];
3      for( i=0; i4           a[i] = pool.cunstruct();
5      for(i=0; i6           pool.destory( a[i] );

在这种情况下，每次的find_prev会耗费O(N)时间，需要注意下。。。

野猪红 2011-04-26 18:18 发表评论

迷宫问题回溯法

野猪红 — Thu, 12 Aug 2010 08:07:00 GMT

如图，有如此的一个迷宫，要从起点到终点，紫色方格是障碍物方格，不可通行。
求：
找出一条从起点到终点的道路，在到达终点之前，必须走遍所有可通行的方格一次，而且到达终点的
转弯次数要最少，每改变一次前进方向算作转弯一次。

经典的回溯法解题思路：

1 //方格m*n,k个障碍物
2 int m,n,k;
3 //目标方格
4 int dx,dy;
5 //当前拐弯数，最右拐弯数
6 int dirs,best;
7 //总共找到几条路线
8 int count;
9
10 void search(int depth,int x,int y,int di)
11 {
12     if(depth==m*n-k && dx==x && dy==y && )
13     {
14         //找到一条路线
15         count++;
16
17         if(dirs<best)
18         {
19             best=dirs;
20             //保存最优路径，即标记不为0的方格
21             save();
22         }
23         else
24         {
25             return;
26         }
27     }
28     else
29     {
30         for(int i=1;i<=8;i++)
31         {
32             if(没有出边界 && 该方格未行走过)
33             {
34                 board[x+dx[i]][y+dy[i]]=depth+1;
35                 if(di!=i) dirs++;
36                 search(depth+1,x+dx[i],y+dy[i],i);
37                 //恢复转弯次数
38                 if(di!=i) dirs--;
39                 //恢复未行走标记
40                 board[x+dx[i]][y+dy[i]]=0;
41             }
42         }
43     }
44
45 }

看上去挺复杂的问题，用回溯法可以很好地解决，还可以加入剪枝函数，即检测当前dirs是否已经大于best，如果
是的话，直接返回。

野猪红 2010-08-12 16:07 发表评论

C++博客-野猪世界-随笔分类-算法

二叉树 动态规划 回溯算法

boost pool object_pool

迷宫问题 回溯法

二叉树动态规划回溯算法

迷宫问题回溯法