C++博客-I smell magic in the air-随笔分类-数据结构

一个趣味迷宫的问题(2011->2012)

izualzhy — Sat, 17 Nov 2012 02:21:00 GMT

Technorati 标记: 迷宫,bfs

原题在这里：

http://www2.stetson.edu/~efriedma/holiday/2011/index.html

题目：

有这样一个迷宫，从2011开始，不能回头，只能“朝前”走，走出迷宫的时候需要变成2012.

例如从2011开始，有+7,/2两种选择，选择/2后，又有+7,x3/-5三种选择。

解法：

其实就是2011为根的子树，不断的生成下一层的节点，直到节点值为2012。

dfs遍历肯定不现实的，bfs算是比较适合的方法了。不过有更快捷的办法，我使用的是最原始的bfs。

运算方式有四种，位置有三种，分别用枚举表示。

代码：

代码写的很长了，100行以内应该是没问题的，即使是使用我的这种笨方法o(╯□╰)o。为了条理清楚些，就多定义了些函数。

Code Snippet
 /*
 * =====================================================================================
 *       Filename:  puzzle.cpp
 *    Description:  
 *
 *        Version:  1.0
 *        Created:  11/16/2012 04:34:49 PM
 *
 *         Author:  zhy (), izualzhy@163.com
 * =====================================================================================
 */
 
#include 
#include 
#include 
#include 
using namespace std;
 
class PuzzleGuessor {
public:
    /*可选的数学运算*/
    enum Op {
        OpNone,
        AddSeven,
        DivTwo,
        MultiThree,
        SubFive,
        OpCount
    };
 
    /*位置，由位置和数学运算则可以推断下一步可选的运算方式*/
    enum Position {
        Left,
        Middle,
        Right
    };
 
    /*节点，记录当前的计算结果，位置和到达位置前的运算方式 */
    struct TreeNode {
        TreeNode(double d, Op op, Position position)
            : data(d)
            , oper(op)
            , pos(position)
        {
        }
 
        double data;
        Op oper;
        Position pos;
        vector<TreeNode*> children;
    };
 
    PuzzleGuessor();
    void BuildTree();//构造树
 
private:
    queue<TreeNode*> q;
    TreeNode* root;
    string OpTable[OpCount];//运算对应的字符串表，输出用
    string result;
    bool CreateNewChildForNode(TreeNode* node);//由节点处根据下一步可进行的运算产生下一层节点
    bool CalcNextFromLeft(TreeNode* node);//在左端时可能的节点
    bool CalcNextFromMiddle(TreeNode* node);//中间位置
    bool CalcNextFromRight(TreeNode* node);//右端
    bool Achieve2012(TreeNode* node);
    bool Find(TreeNode* node, TreeNode* objNode);
};
 
PuzzleGuessor::PuzzleGuessor()
{
    root = new TreeNode(2011.0, OpNone, Left);
    TreeNode* child1 = new TreeNode(root->data + 7, AddSeven, Middle);
    TreeNode* child2 = new TreeNode(root->data / 2, DivTwo, Middle); 
    root->children.push_back(child1);
    root->children.push_back(child2);
    q.push(child1);
    q.push(child2);
 
    OpTable[OpNone] = "none";
    OpTable[AddSeven] = "+7";
    OpTable[DivTwo] = "/2";
    OpTable[MultiThree] = "x3";
    OpTable[SubFive] = "-5";
    BuildTree();
}
 
void PuzzleGuessor::BuildTree()
{
    result.clear();
    while (!q.empty())
    {
        TreeNode* node = q.front();
        CreateNewChildForNode(node);
        for ( int i=0; i<node->children.size(); ++i)
        {
            if (node->children[i]->data - 2012 < 1e-6 && 2012 - node->children[i]->data < 1e-6)
            {
                cout << "Achieve 2012!\t" << node->children[i]->data << endl;
                Find(root, node->children[i]);
                cout << result << endl;
                result.clear();
                ///*如果不retunr，则会一直计算下去   */
                //return;
            }
            q.push(node->children[i]);
        }
        q.pop();
    }
}
 
bool PuzzleGuessor::Find(TreeNode* node, TreeNode* objNode)
{
    if (node == NULL)
        return false;
    if (node == objNode)
    {
        result = OpTable[node->oper];
        return true;
    }
    for ( int i=0; i<node->children.size(); ++i)
    {
       if( Find(node->children[i], objNode) )
       {
           //cout << node->data << endl;
           if (OpNone == node->oper)
               result.insert(0, "2011");
           else
               result.insert(0,OpTable[node->oper]);
           return true;
       }
    }
 
    return false;
}
 
bool PuzzleGuessor::CreateNewChildForNode(TreeNode* node)
{
    if (node == NULL)
        return false;
 
    switch (node->pos)
    {
        case Left:
            CalcNextFromLeft(node);
            break;
        case Middle:
            CalcNextFromMiddle(node);
            break;
        case Right:
            CalcNextFromRight(node);
            break;
    }
}
 
bool PuzzleGuessor::CalcNextFromLeft(TreeNode* node)
{
    if (node == NULL)
        return false;
 
    switch (node->oper)
    {
        case AddSeven:
            {
                TreeNode* newNode = new TreeNode(node->data / 2, DivTwo, Middle);
                node->children.push_back(newNode);
                break;
            }
        case DivTwo:
            {
                TreeNode* newNode = new TreeNode(node->data + 7, AddSeven, Middle);
                node->children.push_back(newNode);
                break;
            }
        default:
            return false;
    }
 
    return true;
}
bool PuzzleGuessor::CalcNextFromMiddle(TreeNode* node)
{
    if (node == NULL)
        return false;
 
    if (node->oper == AddSeven || node->oper == DivTwo)
    {
        TreeNode* newNode = new TreeNode(node->data * 3, MultiThree, Right);
        node->children.push_back(newNode);
        newNode = new TreeNode(node->data - 5, SubFive, Right);
        node->children.push_back(newNode);
 
        if (node->oper == AddSeven)
        {
            TreeNode* newNode = new TreeNode(node->data / 2, DivTwo, Left);
            node->children.push_back(newNode);
        }
        else if (node->oper == DivTwo)
        {
            TreeNode* newNode = new TreeNode(node->data + 7, AddSeven, Left);
            node->children.push_back(newNode);
        }
    }
    else if (node->oper == MultiThree || node->oper == SubFive)
    {
        TreeNode* newNode = new TreeNode(node->data + 7, AddSeven, Left);
        node->children.push_back(newNode);
        newNode = new TreeNode(node->data / 2, DivTwo ,Left);
        node->children.push_back(newNode);
 
        if (node->oper == MultiThree)
        {
            TreeNode* newNode = new TreeNode(node->data - 5, DivTwo, Right);
            node->children.push_back(newNode);
        }
        else if (node->oper == SubFive)
        {
            TreeNode* newNode = new TreeNode(node->data * 3, MultiThree, Right);
            node->children.push_back(newNode);
        }
    }
    else
    {
        return false;
    }
 
    return true;
}
 
bool PuzzleGuessor::CalcNextFromRight(TreeNode* node)
{
    if (node == NULL)
        return false;
 
    switch (node->oper)
    {
        case MultiThree:
            {
                TreeNode* newNode = new TreeNode(node->data - 5, SubFive, Middle);
                node->children.push_back(newNode);
                break;
            }
        case SubFive:
            {
                TreeNode* newNode = new TreeNode(node->data * 3, MultiThree, Middle);
                node->children.push_back(newNode);
                break;
            }
        default:
            return false;
    }
 
    return true;
}
 
int main()
{
    PuzzleGuessor guesser;
    return 0;
}
 

部分输出：

Achieve 2012!    2012
2011+7/2+7/2+7x3-5/2+7x3-5/2+7x3-5x3-5/2+7/2+7/2+7/2+7x3-5+7
Achieve 2012!    2012
2011+7/2+7/2+7x3-5/2+7x3-5/2+7-5x3+7/2+7/2+7/2+7/2x3-5x3-5+7
Achieve 2012!    2012
2011+7/2+7/2+7x3-5x3-5+7/2+7/2+7/2+7/2x3-5/2+7x3-5x3-5+7/2+7
Achieve 2012!    2012
2011+7/2+7/2+7x3-5x3-5+7/2+7/2+7/2+7/2x3-5/2+7-5x3/2+7x3-5+7
Achieve 2012!    2012
2011+7/2+7/2+7-5x3/2+7x3-5+7/2+7/2+7/2x3-5/2+7x3-5x3-5+7/2+7
Achieve 2012!    2012
2011+7/2+7/2+7-5x3/2+7x3-5+7/2+7/2+7/2x3-5/2+7-5x3/2+7x3-5+7
Achieve 2012!    2012
2011+7/2+7/2+7-5x3/2+7/2+7x3-5/2+7-5x3+7/2+7/2x3-5x3-5+7/2+7
Achieve 2012!    2012
2011+7/2+7/2+7-5x3/2+7/2+7x3-5/2+7-5x3+7/2+7/2-5x3/2+7x3-5+7
Achieve 2012!    2012
2011+7/2+7/2+7-5x3/2+7/2+7-5x3/2+7x3-5/2+7x3-5+7/2+7/2x3-5+7

izualzhy 2012-11-17 10:21 发表评论

[转]Knuth-Morris-Pratt algorithm

izualzhy — Sat, 15 Sep 2012 06:07:00 GMT

看到实在是觉得写得不错，就就转过来了。

原文地址：

http://www.inf.fh-flensburg.de/lang/algorithmen/pattern/kmpen.htm

以下为原文内容：

Idea

After a shift of the pattern, the naive algorithm has forgotten all information about previously matched symbols. So it is possible that it re-compares a text symbol with different pattern symbols again and again. This leads to its worst case complexity of Θ(nm) (n: length of the text, m: length of the pattern).

The algorithm of Knuth, Morris and Pratt [KMP 77] makes use of the information gained by previous symbol comparisons. It never re-compares a text symbol that has matched a pattern symbol. As a result, the complexity of the searching phase of the Knuth-Morris-Pratt algorithm is in O(n).

However, a preprocessing of the pattern is necessary in order to analyze its structure. The preprocessing phase has a complexity ofO(m). Since mn, the overall complexity of the Knuth-Morris-Pratt algorithm is in O(n).

Basic definitions

Definition: Let A be an alphabet and x = x₀ ... x_k-1, k a string of length k over A.

A prefix of x is a substring u with

u = x₀ ... x_b-1 where b {0, ..., k}

i.e. x starts with u.

A suffix of x is a substring u with

u = x_k-b ... x_k-1 where b {0, ..., k}

i.e. x ends with u.

A prefix u of x or a suffix u of x is called a proper prefix or suffix, respectively, if ux, i.e. if its length b is less than k.

A border of x is a substring r with

r = x₀ ... x_b-1 and r = x_k-b ... x_k-1 where b {0, ..., k-1}

A border of x is a substring that is both proper prefix and proper suffix of x. We call its length b the width of the border.

Example: Let x = abacab. The proper prefixes of x are

ε, a, ab, aba, abac, abaca

The proper suffixes of x are

ε, b, ab, cab, acab, bacab

The borders of x are

ε, ab

The border ε has width 0, the border ab has width 2.

The empty string ε is always a border of x, for all x A⁺. The empty string ε itself has no border.

The following example illustrates how the shift distance in the Knuth-Morris-Pratt algorithm is determined using the notion of the border of a string.

Example:

The symbols at positions 0, ..., 4 have matched. Comparison c-d at position 5 yields a mismatch. The pattern can be shifted by 3 positions, and comparisons are resumed at position 5.

The shift distance is determined by the widest border of the matching prefix of p. In this example, the matching prefix is abcab, its length is j = 5. Its widest border is ab of width b = 2. The shift distance is j – b = 5 – 2 = 3.

In the preprocessing phase, the width of the widest border of each prefix of the pattern is determined. Then in the search phase, the shift distance can be computed according to the prefix that has matched.

Preprocessing

Theorem: Let r, s be borders of a string x, where |r| < |s|. Then r is a border of s.

Proof: Figure 1 shows a string x with borders r and s. Since r is a prefix of x, it is also a proper prefix of s, because it is shorter thans. But r is also a suffix of x and, therefore, proper suffix of s. Thus r is a border of s.

Figure 1: Borders r, s of a string x

If s is the widest border of x, the next-widest border r of x is obtained as the widest border of s etc.

Definition: Let x be a string and a A a symbol. A border r of x can be extended by a, if ra is a border of xa.

Figure 2: Extension of a border

Figure 2 shows that a border r of width j of x can be extended by a, if x_j = a.

In the preprocessing phase an array b of length m+1 is computed. Each entry b[i] contains the width of the widest border of the prefix of length i of the pattern (i = 0, ..., m). Since the prefix ε of length i = 0 has no border, we set b[0] = -1.

Figure 3: Prefix of length i of the pattern with border of width b[i]

Provided that the values b[0], ..., b[i] are already known, the value of b[i+1] is computed by checking if a border of the prefix p₀ ... p_i-1can be extended by symbol p_i. This is the case if p_b[i] = p_i (Figure 3). The borders to be examined are obtained in decreasing order from the values b[i], b[b[i]] etc.

The preprocessing algorithm comprises a loop with a variable j assuming these values. A border of width j can be extended by p_i, ifp_j = p_i. If not, the next-widest border is examined by setting j = b[j]. The loop terminates at the latest if no border can be extended (j = -1).

After increasing j by the statement j++ in each case j is the width of the widest border of p₀ ... p_i. This value is written to b[i+1] (to b[i] after increasing i by the statement i++).

Preprocessing algorithm

void kmpPreprocess()
{
    int i=0, j=-1;
    b[i]=j;
    while (i=0 && p[i]!=p[j]) j=b[j];
        i++; j++;
        b[i]=j;
    }
}

Example: For pattern p = ababaa the widths of the borders in array b have the following values. For instance we have b[5] = 3, since the prefix ababa of length 5 has a border of width 3.

Searching algorithm

Conceptually, the above preprocessing algorithm could be applied to the string pt instead of p. If borders up to a width of m are computed only, then a border of width m of some prefix x of pt corresponds to a match of the pattern in t (provided that the border is not self-overlapping) (Figure 4).

Figure 4: Border of length m of a prefix x of pt

This explains the similarity between the preprocessing algorithm and the following searching algorithm.

Searching algorithm

void kmpSearch()
{
    int i=0, j=0;
    while (i=0 && t[i]!=p[j]) j=b[j];
        i++; j++;
        if (j==m)
        {
            report(i-j);
            j=b[j];
        }
    }
}

When in the inner while loop a mismatch at position j occurs, the widest border of the matching prefix of length j of the pattern is considered (Figure 5). Resuming comparisons at position b[j], the width of the border, yields a shift of the pattern such that the border matches. If again a mismatch occurs, the next-widest border is considered, and so on, until there is no border left (j = -1) or the next symbol matches. Then we have a new matching prefix of the pattern and continue with the outer while loop.

Figure 5: Shift of the pattern when a mismatch at position j occurs

If all m symbols of the pattern have matched the corresponding text window (j = m), a function report is called for reporting the match at position i-j. Afterwards, the pattern is shifted as far as its widest border allows.

In the following example the comparisons performed by the searching algorithm are shown, where matches are drawn in green and mismatches in red.

Example:

Analysis

The inner while loop of the preprocessing algorithm decreases the value of j by at least 1, since b[j] < j. The loop terminates at the latest when j = -1, therefore it can decrease the value of j at most as often as it has been increased previously by j++. Since j++ is executed in the outer loop exactly m times, the overall number of executions of the inner while loop is limited to m. The preprocessing algorithm therefore requires O(m) steps.

From similar arguments it follows that the searching algorithm requires O(n) steps. The above example illustrates this: the comparisons (green and red symbols) form "stairs". The whole staircase is at most as wide as it is high, therefore at most 2ncomparisons are performed.

Since mn the overall complexity of the Knuth-Morris-Pratt algorithm is in O(n).

References

[KMP 77]
D.E. Knuth, J.H. Morris, V.R. Pratt: Fast Pattern Matching in Strings. SIAM Journal of Computing 6, 2, 323-350 (1977)

[1]
http://www-igm.univ-mlv.fr/~lecroq/string/

[2]
http://www.inf.fh-flensburg.de/lang/algorithmen/pattern/stringmatchingclasses/KmpStringMatcher.java Knuth-Morris-Pratt algorithm as a Java class source file

izualzhy 2012-09-15 14:07 发表评论

KMP字符串搜索算法学习笔记

izualzhy — Tue, 11 Sep 2012 12:26:00 GMT

写在前面：很多网站的文章里介绍到KMP算法时都会用简单，容易理解来形容，实际上，并不是这样的。
因此，对于要了解该算法，无论你接下来看不看这篇文章，都要给自己准备加起来至少有半天的时间来学习KMP算法，不要轻敌嘿嘿。
这里也只是根据我的理解做的笔记，希望了解的更多请直接移步《算法导论》或者参考资料里的链接。
我个人对于该方法的总结是：
通过关键字自身的比较进行预处理，得到当不匹配时的偏移量（朴素算法是1）。
一直要记住的就是，当两个字符串前n位相同时，如果第n+1位相同，则两个字符串前n+1位还是相同的...是不是太简单~~
KMP算法是对朴素的搜索算法的改进，因此，在学习KMP搜索算法前，先来介绍下朴素的搜索算法。
不妨设文本
S = "aaaaaaaaab"
关键字
T = "aaaab"
朴素的搜索算法，想法很简单，从s的下标0开始，逐个与T比较，成功则返回，否则s的下标+1，继续逐个与T比较，直到结束或返回。

for(int i = 0; i < Len[S]; i++)
{
    int j;
    for(j = 0; j < Len[T]); j++)
    {
        if(S[i+j] != T[j]) break;
    }
    if(j == Len[T])
        find T in S
}

如果不是很理解，看个直观的图，其中第一个行是S，第二行是T，可以看成一个T不断向后滑动的过程。

a	a	a	a	a	a	a	a	a	b
	a	a	a	a	b
		a	a	a	a	b
			a	a	a	a	b
				a	a	a	a	b
					a	a	a	a	b

比较到第5列时，发现不匹配，于是倒回到上一个下标开始的地方+1处(第三行)，继续，如此循环往复。
从这里不难看出，这种情况下算法复杂度为O(S.len*T.len).
KMP算法的改进点就在这里：
第二行不匹配后是否我们应当倒回到第三行的状态继续比较？如果不用，那么应该怎么比较。
我们先用这个例子来表示一下，S[0,4]表示的是S字符串下标从0到4的闭区间。
提前提示一下： T[0,2] = T[1,3]
第二行里，我们比较到了第5列（即下标为4的地方，接下来我们开始只用下标描述，以免产生混乱），即前面的字符串是匹配的，因此有这个结果：
S[0,3] = T[0,3],S[1,3] = T[1,3],S[2,3] = T[2,3]...
同时根据前面的提示:
T[0,2] = T[1,3] = S[1,3]
可以看到T[0,2] = S[1,3]就是第三行里前面要比较的内容，也就是说实际上是不需要的。
第二行失败后，我们可以直接从S[4]与T[3]比较!
也就是说KMP要解决的就是：如果在S的某个下标处不匹配了，那么S的改下标不需要退回，而是选择T的一个下标，来继续比较（因为像前面的例子，T[0,2]=T[1,3]了已经)。
简单直观点的说法，就是，当不匹配时，T不是直接滑动回去再前进一步，而是选择一个可以前进的最大值，同时，直接进行与S当前不匹配下标的比较。
注意这个最大值不一定为1，S当前选择与T的哪个下标比较，会决定这样一个前进值。
再看个例子：

a	b	a	d	e	a	b	a	d	f
a	b	a	d	f
	a
		a	b
			a	b

这是朴素的匹配算法的策略，其中S="abadeabadf",T="abadf"
而KMP的策略是：

a	b	a	d	e	a	b	a	d	f
a	b	a	d	f
				a	b	a	d	f

为什么可以这样选择？
因此，kmp就是要计算这样一个数组next[], 当文本S在其下标i处与T不匹配时，来决定与T哪个下标处开始继续比较。
我们先看下程序：

/*
* =====================================================================================
*       Filename:  kmpsearch.c
*    Description:  kmp search
*
*        Version:  1.0
*        Created:  09/10/2012 07:15:07 PM
*
*         Author:  zhy (), izualzhy@163.com
* =====================================================================================
*/

/**
* @brief KMPSearch kmp搜索字符串算法
*
* @param src 待搜索的文本
* @param srcLen 待搜索文本长度
* @param keyword 搜索关键字
* @param keywordLen 搜索关键字长度
*
* @return 搜索到第一个结果停止，返回关键字在文本出现的索引，否则返回-1
*/
int KMPSearch(const char* src, const int srcLen, const char* keyword, const int keywordLen)
{
    //存储kmp需要的next数组
    char* next = (char*)malloc(keywordLen*sizeof(char));
    if (!next)
        return -1;

    //初始化next数组的值
    CalcKMPNext(keyword, keywordLen, next);

    int i = 0, j = 0;
    for ( ; i        printf("next: %d\n", next[i]);
    i = 0;
    while (i < srcLen)
    {
        //如果比较结果不同，则需要回退关键字的索引，继续比较，如果回退至关键字开始处(j==0)时break，下次直接从当前i与关键字的第一个字符开始比较
        while (j >= 0 && src[i] != keyword[j])
            j = next[j];
        printf("i=%d,j=%d\n",i,j);
        i++;
        j++;
        if (j == keywordLen)
            return i - keywordLen;
    }

    return -1;
}

/**
* @brief CalcKMPNext 计算kmp算法需要的next数组
*
* @param keyword 关键字
* @param keywordLen 关键字长度
* @param next 存储next
*/
void CalcKMPNext(const char* keyword, const int keywordLen, char* next)
{
    int i = 0, j = -1;
    next[i] = j;//初始化next[0],没有什么意义
    while (i < keywordLen)
    {
        //如果不相等，回退直到相等，或者没有相等
        while (j >= 0 && keyword[i]!=keyword[j])
            j = next[j];
        ++i;
        ++j;
        if (i            next[i] = j;
    }
}

int main()
{
     char text[] = "abadeabadf";
     char keyword[] = "abadf";
    /*
     *char text[] = "this is a demo, is is not u , isnot it?";
     *char keyword[] = "is";
     */
    unsigned int textLen = strlen(text);
    unsigned int keywordLen = strlen(keyword);

    int startIndex = 0;
    while (1)
    {
        int foundIndex = KMPSearch(text + startIndex, textLen, keyword, keywordLen);
        if (foundIndex == -1)
            break;
        startIndex += foundIndex;
        printf("find in %d\n", startIndex);
        startIndex += keywordLen;
    }

    return 0;
}

参考资料：
http://www.inf.fh-flensburg.de/lang/algorithmen/pattern/kmpen.htm
http://chaoswork.com/blog/2011/06/14/kmp%E7%AE%97%E6%B3%95%E5%B0%8F%E7%BB%93/
http://www.matrix67.com/blog/archives/115

izualzhy 2012-09-11 20:26 发表评论

单调栈的介绍与应用

izualzhy — Sat, 25 Aug 2012 03:31:00 GMT

定义：

单调栈，顾名思义就是说栈内的元素，按照某种方式排序下，必须是单调的。如果新入栈的元素破坏了单调性，就弹出栈内元素，知道满足单调性。

它可以很方便地求出某个数的左边或者右边第一个比它大或者小的元素，而且总时间复杂度O(N)。

起源的题目：

这道题目在网上稍微搜了下，感觉已经是泛滥了，我就拿过来再贴一遍O(∩_∩)O哈哈~

题目大意：

给出一个柱形统计图(histogram), 它的每个项目的宽度是1，高度和具体问题有关。现在编程求出在这个柱形图中的最大面积的长方形。

例如：

7 2 1 4 5 1 3 3

7表示柱形图有7个数据，分别是 2 1 4 5 1 3 3，对应的柱形图如下，最后求出来的面积最大的图如右图所示。

看到这个题目我第一反应是，遍历每个矩形，左右寻找能扩展的最大距离，然后求面积，比较，得到结果。

太复杂，不是么？

主要是有很多重复的工作。

我是没有想到单调栈的，不过用了之后，发现代码比我想到的要好写，而且确实很容易。

 C++语言: 高亮代码由发芽网提供
01 /*
02 * =====================================================================================
03 *       Filename:  MonotoneStack.cpp
04 *    Description:  
05 *
06 *        Version:  1.0
07 *        Created:  08/24/2012 04:37:27 PM
08 *
09 *         Author:  zhy (), izualzhy@163.com
10 * =====================================================================================
11 */
12 #include 
13 #include 
14 using namespace std;
15 
16 struct Element
17 {
18    Element(int h, int index)
19        : height(h)
20        , startIndex(index)
21    {}
22 
23    int height;//矩形高度
24    int startIndex;//对应的索引位置
25 };
26 
27 int GetMaxRect(int rectHeights[], int len)
28 {
29    stack s;//使用std的stack
30    s.push(Element(-1, 0));//首先-1高度入栈，这样在之后的出栈策略上不会导致空栈，另外一种方法是可以在下文的while判断时加入对空栈的判断。
31    int maxArea = -1;
32    int height = -1;
33    
34    for ( int i=0; i35    {
36        if (i == len)//扫描完毕时，要全部出栈，计算可能的矩形面积
37        {
38            height = 0;
39        }
40        else//扫描过程，则记录此时的矩形高度
41        {
42            height = rectHeights[i];
43        }
44 
45        while (height < s.top().height)//如果矩形高度比栈顶要小，则说明之前的矩形无法继续往右扩展，需要弹出，并计算面积
46        {
47            //计算面积的公式，核心部分
48            //根据我们的策略，新元素高度要高，则表明我们的矩形还可以继续往右扩展，因此栈内元素时满足单调性的，对此时栈内每个元素，都是可以根据自己的高度，扩展矩形到i-1的
49            int area = (i - s.top().startIndex)*s.top().height;
50            maxArea = maxArea > area ? maxArea : area;
51            s.pop();
52        }
53        s.push(Element(rectHeights[i], i));
54    }
55 
56    return maxArea;
57 }
58 
59 int main()
60 {
61    int rects[] = {2, 1, 4, 5, 1, 3, 3};
62    cout << GetMaxRect(rects, 7) << endl;
63    return 0;
64 }

至于现在的复杂度是多少，我没想出来，欢迎告诉我

参考资料：

http://blog.csdn.net/hopeztm/article/details/7868581

izualzhy 2012-08-25 11:31 发表评论

字典树的介绍与实现

izualzhy — Wed, 22 Aug 2012 11:56:00 GMT

假若需要这样的实现，我有一个词典，词典内容如下：

pad

park

panda

pan

apply

apple

append

app

application

需要统计以p为前缀的单词个数，好的，最直观的办法，我遍历所有的字符串，记数，ok，作业完成了！

A: 完成的很好！那现在我想要pa开始的~

Me: 嗯~好的，遍历，记数，ok~

A:我要app前缀的个数~

Me: 嗯?~好吧。。

A:appl的，pan的，前缀个数~

Me: ….

是不是很无奈，这个时候字典树就派上用场了。当然首先要明确的是，我们的目标是以空间换时间。

字典树，从根节点开始，每个节点可能的child数是26（如果只有英文小写字母的话），当然是随着词汇添加而完善这棵树的。

/*
* =====================================================================================
*       Filename:  Trie.cpp
*    Description:  字典数的定义和使用
*
*        Version:  1.0
*        Created:  08/22/2012 07:01:05 PM
*
*         Author:  zhy (), izualzhy@163.com
* =====================================================================================
*/

#include
#include <string.h>

#define MAX 26//可以变化，比如只有数字则为10

//字典数的基础结构
struct Trie
{
    Trie()
    {
        for ( int i=0; i            next[i] = NULL;
        count = 1;
    }
    Trie *next[MAX];//下一层的节点数目，初始时指针全是null，当添加词汇后会逐步添加
    int count;//前缀数目
};

Trie* root = new Trie;//根节点

//根据str完善以root为根节点的词典树
void createTrie(const char *str)
{
    Trie* p = root;
    while (*str) {
        int index = *str - 'a';
        if (p->next[index]!=NULL) {
            p->next[index]->count++;//如果已经存在，前缀数目+1
        } else {
            p->next[index] = new Trie;//不存在则建立
        }
        p = p->next[index];
        str++;
    }
}
//查找str为前缀的词汇数目
int findTrie(const char* str)
{
    int len = strlen(str);
    if (len == 0)
        return 0;

    Trie* p = root;
    //逐个字符遍历str
    while (*str) {
        int index = *str - 'a';
        if (p->next[index] != NULL) {
            p = p->next[index];//该字符存在，试试下一个字符
        } else {
            return 0;//如果不存在该字符，则不存在该前缀
        }
        str++;
    }

    return p->count;
}

void destroyTrie(Trie* node)
{
    if (node == NULL)
        return;

    for ( int i=0; i        if (node->next[i] != NULL) {
            destroyTrie(node->next[i]);
        }
    }

    delete node;
}

int main()
{
    char s[100];
    printf("input the words for trie\n");
    while (gets(s) && strlen(s))
    {
        createTrie(s);
    }

    printf("search what u want?:\n");
    while (gets(s) && strlen(s))
    {
        printf("%s: %d\n", s, findTrie(s));
    }

    destroyTrie(root);
    return 0;
}

运行结果：

y@y-VirtualBox:/mnt/mydocuments/Training$ ./Trie
input the words for trie
pad
park
panda
pan
apply
apple
append
app
application

search what u want?:
p
p: 4
a
a: 5
pa
pa: 4
pan
pan: 2
par
par: 1
app
app: 5
appl
appl: 3
appe
appe: 1

izualzhy 2012-08-22 19:56 发表评论

有一串首尾相连的珠子，共有m个，每一个珠子有一种颜色，并且颜色的总数不超过n(n<=10)，求连续的珠子的颜色总数为n时，长度最小的区间。

izualzhy — Tue, 20 Mar 2012 12:28:00 GMT

依稀记得见到此题是在校园招聘的笔试题目上，也记得当时的感觉是一头雾水，完全不懂这个题目在干什么。

时间如流水，转眼已工作了一年，工作也阴差阳错的换了一个。偶然间看到这个题目，竟猛然间想起学校时的自己，背着书包，阳光，图书馆，那时自己也不喜欢研究这样的问题，天天在数学问题里泡着，什么算子，理想环的，拓扑的，可以那么没心没肺的只去学习自己喜欢的东西。

扯远了，看到这个问题，仔细想了下，想了种解决的方法，google了一下，发现博客园里有篇文章类似，却又编译不过而且一点注释没有。。。

贴下自己的代码，大家看下，哪里不对的地方请指出。

想想真的挺感谢之前的公司的，接纳了我这个小菜鸟，同时让我成长，为一个大菜鸟^_^

先考虑下简单情况并抽象下问题，珠子改为线性的而不是环，用数组表示，内容为其颜色（用数字表示），则表示为在该数组里找到最小的连续的区间，使得包含所有的数字。

想法是这样的：

先从index=0处搜索，每检查一颗珠子，响应的颜色数量+1，如果是新的颜色则总颜色数+1.

当颜色总数为n时，找到第一个满足条件的连续序列。

1.从该序列起始处搜索，若搜索处的颜色数量不为1，则表明该串还有别的珠子有该颜色，继续往前搜索并更新该序列，起始索引位置+1.

若搜索处颜色数量为1，停止搜索。

2。比较最佳序列长与当前序列长，更新最佳序列。记录当前序列起始位置。

从第一个满足条件的序列继续index++，并检查1,2条件。

//#######################################################################
//# Author: izualzhy@163.com
//# Created Time: 2012/3/15 14:15:46
//# File Name: pearls.cpp
//# Description: 
//#######################################################################
#include 
using namespace std;

#define MAXN 10
int colors[MAXN];//record the counter of one color
int colorsCounter;
void find(int arr[],int len, int colorsNeed)
{
    int bestStartIndex = 0;
    int bestLen = len;
    int lastStartIndex = 0;
    
    for ( int i=0; iif (!colors[arr[i]])
            colorsCounter++;
        colors[arr[i]]++;

        if (colorsCounter==colorsNeed) {
            int j = lastStartIndex;
            while (colors[arr[j]]>1) {
                colors[arr[j]]--;
                ++j;
            }
            if (i-j+1if (bestLen==colorsNeed)
                    break;
            }
            lastStartIndex = j;
        }
    }

    cout << bestStartIndex << endl;
    cout << bestLen << endl;
    for (int i=bestStartIndex; i" ";
    cout << endl;
}

int main()
{
    int arr[] = {1,2,3,3,2,1,4,1,3,4,5,6,2,3,4,1,5,2,3,4};
    int m = sizeof(arr)/sizeof(arr[0]);

    for ( int i=0; i" ";
    cout << endl;

    int n = 6;
    find(arr,m,n);

    return 0;
}

输出：

1 2 3 3 2 1 4 1 3 4 5 6 2 3 4 1 5 2 3 4
7
6
1 3 4 5 6 2

如果是环的话多了一遍循环：

//#######################################################################
//# Author: izualzhy@163.com
//# Created Time: 2012/3/15 14:15:46
//# File Name: pearls.cpp
//# Description: 
//#######################################################################
#include 
using namespace std;

#define MAXN 10
int colors[MAXN];//record the counter of one color
int colorsCounter;
void find(int arr[],int len, int colorsNeed)
{
    int bestStartIndex = 0;
    int bestLen = len;
    int lastStartIndex = 0;
    int firstFoundEnoughPearls = len;
    
    for ( int i=0; iif (!colors[arr[i]])
            colorsCounter++;
        colors[arr[i]]++;

        if (colorsCounter==colorsNeed) {
            firstFoundEnoughPearls = i;
        }
        
        if (firstFoundEnoughPearls!=len) {
            int j = lastStartIndex;
            while (colors[arr[j]]>1) {
                colors[arr[j]]--;
                ++j;
            }
            if (i-j+1if (bestLen==colorsNeed)
                    break;
            }
            lastStartIndex = j;
        }
    }

    for ( int i=0; iif (!colors[arr[i]])
            colorsCounter++;
        colors[arr[i]]++;
        int j = lastStartIndex;
        while (colors[arr[j]]>1) {
            colors[arr[j]]--;
            ++j;
        }
        if (i-j+1+lenif (bestLen==colorsNeed)
                break;
        }
        lastStartIndex = j;
    }

    int offset = bestStartIndex;
    for (int i=0; i" ";
        ++i;
        if (i+offset>=len)
            offset = 0-i;
    }
    cout << endl;
}

int main()
{
    int arr[] = {1,2,3,3,2,1,4,1,2,3,2,6,4,5,2,6,2,3,4,1,2,5,2,3,4,5,6};
    int m = sizeof(arr)/sizeof(arr[0]);
    int n = 6;
    find(arr,m,n);

    return 0;
}

输出：

2 3 4 5 6 1

izualzhy 2012-03-20 20:28 发表评论

[转]找出环的初始节点

izualzhy — Sat, 17 Mar 2012 04:49:00 GMT

[原帖在这里]：http://blog.csdn.net/nomad2/article/details/7362525
关于原帖的一些补充：
看了原帖的解释，还是有些不懂。
用数学公式稍微整理了一下，因为可能图示存在这样的问题，就是环的长度比前面链表长度要短的问题。
假设环之前链表（不包括环的开始节点）长度为n，两个指针相遇的地方距离环的开始点距离为m，环长为c，相遇时，n2指针绕环正在跑k2圈，n1正在跑k1圈，那么有：
n1指针跑的节点数*2=n2指针跑的节点数
即：
(n+k1*c-m)*2=(n+k2*c-m)
整理下有
n=m+(k2-2*k1)*c；
不妨设k2-2*k1=k3
图示里n=m，有可能n=m+k3*c,k3=0,1,2,...
感觉这样更好理解一些。
k3一定是>=0的，为什么？

Given a circular linked list, implement an algorithm which returns node at the beginning of the loop.

refer to careerup

分析的很形象，

If we move two pointers, one with speed 1 and another with speed 2, they will end up meeting if the linked list has a loop. Why? Think about two cars driving on a track—the faster car will always pass the slower one!
The tricky part here is finding the start of the loop. Imagine, as an analogy, two people racing around a track, one running twice as fast as the other. If they start off at the same place, when will they next meet? They will next meet at the start of the next lap.
Now, let’s suppose Fast Runner had a head start of k meters on an n step lap. When will they next meet? They will meet k meters before the start of the next lap. (Why? Fast Runner would have made k + 2(n - k) steps, including its head start, and Slow Runner would have made n - k steps. Both will be k steps before the start of the loop.)
Now, going back to the problem, when Fast Runner (n2) and Slow Runner (n1) are moving around our circular linked list, n2 will have a head start on the loop when n1 enters. Specifically, it will have a head start of k, where k is the number of nodes before the loop. Since n2 has a head start of k nodes, n1 and n2 will meet k nodes before the start of the loop.
So, we now know the following:
1. Head is k nodes from LoopStart (by definition).
2. MeetingPoint for n1 and n2 is k nodes from LoopStart (as shown above).
Thus, if we move n1 back to Head and keep n2 at MeetingPoint, and move them both at the same pace, they will meet at LoopStart.

izualzhy 2012-03-17 12:49 发表评论

两道题目

izualzhy — Mon, 27 Feb 2012 15:14:00 GMT

题目很简单，在csdn上看到的。
最近赋闲，难得在忙乱的生活里开始认真反思下自己捉襟见肘的技术水平，总结出的第一个问题就是不爱画流程图，虽然在敲代码这项体力劳动前也会有程序设计这项脑力劳动，但我很少写出来，写在纸上，结果编写的时候总会出错。
1.在一50人的队列中，从左至右报数，为单数者出列，其他人再从左至右报数，为单数者出列，直至剩下最后一人，问此人是初始队列中的第多少号?
1#include <iostream>
2using namespace std;
3
4int main()
5{
6    int n = 50;
7    int i = 1;
8    while (n!=1) {
9        n>>=1;
10        i<<=1;
11    }
12    cout << i << endl;
13
14    return 0;
15}
16

2.1到9的9个数，排成三行三列的正方形，如何使其所有行、列、对角线上三个数字相加都相等
1#include <iostream>
2#include <stdlib.h>
3using namespace std;
4
5
6const int numbers = 9;
7const int obj = 15;
8const int resourceArray[numbers] = {1,2,3,4,5,6,7,8,9};
9int array[numbers] = {0};
10
11void getResult(int currentIndex)
12{
13    if (currentIndex==9) {
14        cout << "array:\n";
15        for ( int i=0; i<numbers; ++i) {
16            cout << array[i] << "  ";
17            if (i%3==2)
18                cout << endl;
19        }
20        system("pause");
21        return;
22    }
23    for ( int i=0; i<numbers; ++i) {
24        int j=0;
25        for (; j<currentIndex; ++j)
26            if (array[j]==resourceArray[i])
27                break;
28        if (j==currentIndex)
29            array[currentIndex] = resourceArray[i];
30        else
31            continue;
32        if ((currentIndex==2 && (array[0]+array[1]+array[2])!=obj)
33                || (currentIndex==5 && (array[3]+array[4]+array[5])!=obj)
34                || (currentIndex==6 && (array[0]+array[3]+array[6])!=obj)
35                || (currentIndex==6 && (array[2]+array[4]+array[6])!=obj)
36                || (currentIndex==7 && (array[1]+array[4]+array[7])!=obj)
37                || (currentIndex==8 && (array[6]+array[7]+array[8])!=obj)
38                || (currentIndex==8 && (array[2]+array[5]+array[8])!=obj)
39                || (currentIndex==8 && (array[0]+array[4]+array[8])!=obj)
40           )
41            continue;
42        getResult(currentIndex+1);
43    }
44
45}
46
47int main()
48{
49    getResult(0);
50    return 0;
51}
52

izualzhy 2012-02-27 23:14 发表评论

[转]由二叉树的前序遍历序列和中序遍历序列求后序遍历序列

izualzhy — Fri, 24 Feb 2012 13:48:00 GMT

http://blog.csdn.net/aegeaner/article/details/7289558
写在转载前：
看到这篇题目时，思路和作者基本相同，不过后来看了下实现稍微复杂了些。于是大概看了遍又修改了自己的代码。
前序：中|左|右
中序：左|中|右

要推出后序遍历的结果：
就是递归的得到：左|右|中的序列即可。
想到递归之后，题目就容易了。
关于更详细的思路，原作者写的比较清楚了。

给出二叉树的前序遍历序列和中序遍历序列，求后序遍历序列。比如节点内存储的数据类型为char的二叉树，给出前序遍历序列"abdec"，中序遍历序列"dbeac"，则输出后序遍历序列。

可以写一个递归函数实现，首先由前序遍历序列的第一个元素确定根节点，然后再中序遍历序列中找出等于该元素的位置索引，则根据中序遍历的定义，该位置以左为左子树，以右为右子树。根据前序遍历的定义，第一个元素之后跟着的也分别是左子树的前序遍历和右子树的前序遍历，由中序序列可以分别确定这两个子树序列的长度，从而可以分隔。对两个子树的前序遍历序列和中序遍历序列分别递归进行后序遍历，然后最终打印根节点，即为整棵树的后续遍历。

转换算法不难，难点在于没有左子树和没有右子树的情况。如果没有左子树，则不对左子树递归遍历，右子树也一样。如果既没有左子树也没有右子树，则退化为叶子节点，这是递归处理的边界情况。

最后贴下我自己的代码,大概都差不多：

#include <iostream>
using namespace std;

void postOrder(const char *preStart,const char *preEnd, const char *inStart, const char *inEnd)
{
    char root = *preStart;
    int len = preEnd-preStart,i = 0;
    for ( ; *(inStart+i)!=root && i<=len; ++i)
        ;

    if (i!=0)
        postOrder(preStart+1,preStart+i,inStart,inStart+i-1);//traverse left child tree
    if (i!=len)
        postOrder(preStart+i+1,preEnd,inStart+i+1,inEnd);//traverse right child tree

    cout << root;
}

int main()
{
    char preOrder[]="abdcef";
    char inOrder[]="dbaecf";
    postOrder(preOrder,preOrder+5,inOrder,inOrder+5);
    cout << endl;
    return 0;
}

note：
如果节点内容相同，算法不可用。比如：
pre:aca
in:caa

则
      a
    /   \
   c     a

与
      a
    /
   c
     \
      a
都满足要求，
而后序遍历分别为：
caa，aca。

izualzhy 2012-02-24 21:48 发表评论

堆排序简单示例

izualzhy — Wed, 22 Feb 2012 15:35:00 GMT

好久不写排序，快忘了，花了10分钟才写好，如果让直接在纸上写代码，估计难写对。。。

1#include <iostream>
2using namespace std;
3
4const int Len = 10;
5int array[Len] = {9,2,6,4,3,7,8,1,0,5};
6
7int leftChild(int index)
8{
9    return 2*index + 1;
10}
11
12void print()
13{
14    for ( int i=0; i<Len; ++i)
15        cout << array[i] << " ";
16    cout << endl;
17}
18
19void percDown(int i, int heapSize)
20{
21    int temp = array[i];
22    int child = leftChild(i);
23    while (child<heapSize) {
24        if (child+1<heapSize)//note here
25            if (array[child]>array[child+1])
26                child++;
27
28        if (array[child]>temp)
29            break;
30        array[i] = array[child];
31        i = child;
32        child = leftChild(i);
33    }
34
35    array[i] = temp;
36}
37
38void buildHeap()
39{
40    for ( int i=Len/2-1; i>=0; --i) {
41        percDown(i,Len);
42        print();
43    }
44}
45
46
47void deleteMax(int curSize)
48{
49    int temp = array[curSize-1];
50    array[curSize-1] = array[0];
51    array[0] = temp;
52
53    percDown(0,curSize-1);
54}
55
56int main()
57{
58    buildHeap();
59    for ( int i=Len; i>0; --i)
60        deleteMax(i);
61
62    print();
63
64    return 0;
65}
66

izualzhy 2012-02-22 23:35 发表评论

约瑟夫问题

izualzhy — Sun, 12 Feb 2012 02:51:00 GMT

题目很简单，就是循环链表的应用~主要是周末稍微动下手，要不静不下心来。。

#include <iostream>
using namespace std;

typedef struct Node{
    Node(int n=int(), Node *ne=NULL) :
        number(n) ,
        next(ne)
    {
    }

    int number;
    Node *next;
}Node;

void Josephus(const int personCounter, const int luckyNumber)
{
    Node *lastnode = new Node(personCounter);
    Node *node = lastnode;
    for ( int i=personCounter-1; i>=1; --i) {
        Node *currentNode = new Node(i,node);
        node = currentNode;
    }
    lastnode->next = node;

    int counter = personCounter;
    while (counter>0) {
        Node *prevNode = lastnode;
        for ( int i=1; i<6; ++i) {
            prevNode = node;
            node = node->next;
        }
        prevNode->next = node->next;
        cout << node->number << endl;
        prevNode = node;
        node = node->next;
        delete prevNode;
        --counter;
    }
}

int main()
{
    Josephus(10,6);
    return 0;
}
#include <iostream>
using namespace std;

typedef struct Node{
    Node(int n=int(), Node *ne=NULL) :
        number(n) ,
        next(ne)
    {
    }

    int number;
    Node *next;
}Node;

void Josephus(const int personCounter, const int luckyNumber)
{
    Node *lastnode = new Node(personCounter);
    Node *node = lastnode;
    for ( int i=personCounter-1; i>=1; --i) {
        Node *currentNode = new Node(i,node);
        node = currentNode;
    }
    lastnode->next = node;

    int counter = personCounter;
    while (counter>0) {
        Node *prevNode = lastnode;
        for ( int i=1; i<6; ++i) {
            prevNode = node;
            node = node->next;
        }
        prevNode->next = node->next;
        cout << node->number << endl;
        prevNode = node;
        node = node->next;
        delete prevNode;
        --counter;
    }
}

int main()
{
    Josephus(10,6);
    return 0;
}

。

izualzhy 2012-02-12 10:51 发表评论

逆转含有n个元素的单链表

izualzhy — Thu, 09 Feb 2012 13:58:00 GMT

该题目是算法导论10.2-7的习题，拿出来做下，题目要求O（n）的非递归过程，且除了链表本身占用的空间外，该过程仅使用固定量的存储空间。

代码如下：

/********************************************************************************

**

** Filename: ReverseList.cpp

**

** Description: reverse a list by two methods: recursive and nonrecursive

**

** Version: 1.0

** Created: 2012年02月09日 12时18分59秒

*********************************************************************************/

#include 

using namespace std;

typedef struct node{

node(int d=int(), node *n=NULL) :

data(d) ,

next(n)

{

}

int data;

node *next;

}node;

node *head;

void print(const char *s)

{

cout << s << endl;

node *temp = head;

while (temp!=NULL) {

cout << temp->data << " ";

temp = temp->next;

}

cout << endl;

}

void reverseListNonRecursive()

{

print("before reverse list nonrecursive:");

node *temp = head;

node *next = temp->next;

node *prev = NULL;

while (temp!=NULL) {

next = temp->next;

temp->next = prev;

prev = temp;

temp = next;

}

head = prev;

print("after reverse list nonrecursive:");

}

void reverseListRecursive(node* n)

{

node* nextNode = n->next;

if (nextNode==NULL) {

head = n;

return;

}

reverseListRecursive(nextNode);

nextNode->next = n;

}

void reverseListRecursive()

{

print("before reverse list recursive:");

node* temp = head;

reverseListRecursive(head);

temp->next = NULL;

print("after reverse list recursive:");

}

int main()

{

node n5(5);

node n4(4,&n5);

node n3(3,&n4);

node n2(2,&n3);

node n1(1,&n2);

head = &n1;

reverseListNonRecursive();

reverseListRecursive();

return 0;

}

输出：

zhy@desktop:~/doublemint/factory$ ./a.out

before reverse list nonrecursive:

1 2 3 4 5

after reverse list nonrecursive:

5 4 3 2 1

before reverse list recursive:

5 4 3 2 1

after reverse list recursive:

1 2 3 4 5

个人感觉非递归和递归过程都有一点要注意的地方：

1. 非递归要记录previous,current,next三个结点，这样代码编写会很方便。如果只用两个指针应该也行，但我没想出来怎么做。

2. 递归。。。真心难懂，想了很久，发现代码写起来很短。。。

izualzhy 2012-02-09 21:58 发表评论

找循环节的问题

izualzhy — Thu, 05 Jan 2012 14:27:00 GMT

该问题是下述问题的子问题：

如何将一个无限循环小数转化为分数？

比如3.12345234234234 = 3+12345/100000+（找到循环节，等比序列之和求之）。

循环节为234，怎么找到呢?

例子是我想到的一个办法：

#include 

#include 

using namespace std;

/** return true if the two substrs,started at position left1(left2) ,has a length of len characters, have no differences*/

bool compare(const string &str, int left1, int left2, int len)

{

int i = 0;

for ( ; i
if (str[left1+i]!=str[left2+i])

break;

return (i==len);

}

int main(int argc, char *argv[])

{

string str(argv[1]);

size_t len = str.size();

int i=len-1;

int repetendLen = 0;

int repetendCount = 0;

//这个条件是我自己给的，即何时结束搜索判断有无循环节,假定为循环的字符数出现一半以上才判断为真

while (i>=repetendLen*repetendCount) {

i--;//逐个向前搜索

if (str[i]==str[len-1]) {//如果当前char与最后一个相同，接下来判断是否为循环节

repetendLen = len-1-i;//记录循环节（可能是）长度

repetendCount = 1;//循环节出现次数，刚开始为1.

while (i>=repetendLen*repetendCount) {//判断该循环节是否循环出现了足够多的次数

if (compare(str,i+1,i+1-repetendLen,repetendLen)) {//为真，则继续向前判断

repetendCount++;

i-=repetendLen;

}

else {//没有的话返回主循环继续搜索

break;

}

}

}

}

if (repetendCount>1)

cout << str.substr(len-repetendLen) << endl;

return 0;

}

izualzhy 2012-01-05 22:27 发表评论

大整数相乘

izualzhy — Thu, 05 Jan 2012 14:26:00 GMT

翻到之前自己写的大整数相乘的例子，有很多出错的地方。最近碰到这个问题，别人指点了下，自己又重新整理了一遍思路，重写了一遍。代码里都写上了注释，想到了两种方法。第一种要逐个求目标数的每一位，第二种方法是类似于我们手动算乘法时的思想。我想到的是第一种方法，但是似乎temp的值会变的比较大，如果超出了int的范围就出错了。不过两个方法一般情况下都是正确的。

#include 

#include 

using namespace std;

class BigNumber {

public:

BigNumber(const string &str=string())

{

for ( int i=str.size()-1; i>=0; --i)

mDigit.push_back(str[i]);

}

const BigNumber operator*(const BigNumber& other) const;

size_t digitNums() const { return mDigit.length(); }

int operator[](int i) const

{

//assert(i>=0&&i

return mDigit[i] - '0';

}

friend ostream &operator<<(ostream &out, const BigNumber& bn)

{

for ( int i=bn.mDigit.size()-1; i>=0; --i)

out << bn.mDigit[i];

return out;

}

private:

string mDigit;

};

const BigNumber BigNumber::operator*(const BigNumber &other) const

{

BigNumber obj;

size_t thisSize = this->digitNums();

size_t otherSize = other.digitNums();

size_t maxSize = thisSize + otherSize;

int temp = 0;

/** 

* 逐个计算结果每一位的值，

* 例如：

* 个位是由两个数的个位乘积mod10(如果比10大，则用temp记录下来供接下来的位数计算时使用),

* 十位则是由第一个数的个位乘以第一个数的十位

* 与 第一个数的十位乘以第二个数的个位

* 与 之前一位剩余的数字之和mod10

* 其他位数类推

* */

for ( size_t i=0; i
for ( size_t j=0; j
if ((i-j)
temp += (*this)[j]*other[i-j];

}

obj.mDigit.push_back(temp%10 + '0');

temp/=10;

}

/** 

* 与乘法的基本原理非常类似

* 最后结果可以这么获得：

* 1.第二个数的个位逐个乘以第一个数的所有位,记录该结果

* (注意跟前一方法类似，比如当十位数字大于10时需要加到百位上来)

* 2.第二个数的十位逐个乘以第一个数的所有位，但所有的位都提高一位存储（因为是十位乘的）

* 同时计算时先与前一次结果相加,依次类推

* */

//obj.mDigit = string(maxSize,'0');

//for ( size_t i=0; i

//for ( size_t j=0; j

//temp += (obj.mDigit[i+j] - '0');

//if (j

//temp += (*this)[i]*other[j];

//obj.mDigit[i+j] = temp%10 + '0';

//temp /=10;

//}

//}

return obj;

}

int main(int argc, char*argv[])

{

BigNumber bn1(argv[1]);

BigNumber bn2(argv[2]);

cout << bn1 << endl;

cout << bn2 << endl;

BigNumber bn3 = bn1*bn2;

cout << bn3 << endl;

return 0;

}

izualzhy 2012-01-05 22:26 发表评论

24点游戏续

izualzhy — Sun, 25 Dec 2011 14:45:00 GMT

之前写过自己的解法：http://www.cppblog.com/izualzhy/archive/2011/11/29/161187.html

后来别人指点了下，于是修改了一番。

主要是几个方面：

1.界面先暂时去掉了，主要是算法本身增加了些判断。不过基本的想法没有改。

2.现在可以计算任意的输入了，不过我试了下，超过6个数就非常慢。。。不知道怎么修改。。。

3.写了一个新的类记录中间过程得到的数，重写了加减乘除等方法，这样就可以不像用之前ABS(a-b）<1e-5的方法判断两个数相等。

以四个数为例，记录下主要想法：

首先输入的数假定为 A B C D

排列共有24种情况，设一种为 a b c d

在肯定为该排列方式的情况下，有3种加括号的方式,同时设@为加减乘除的任意一种，于是有

(a@b) c d

a (b@c) d

a b (c@d)

共3x4=12种情况，于是之后得到三个数x y z,同样的加括号的方式有2种

(x@y) z

x (y@z)

得到两个数m n,一种加括号的方式：

m@n

于是得到一个数

检测这个M是否是目标数值。

最近开始学习数据结构与算法，想尽快补上之前计算机系学的基本课程来。感觉这个有点像回溯算法。

如果你又兴趣同时看完了代码的话，希望能告诉我一下哪里在复杂度需要改进的。

#include 
#include 
#include 
using namespace std;
const int cardCounter = 4;
const double obj = 24;
//#define DEBUG

void calTwoCards(double a[], int lenA, double b[], int lenB, double src[lenA][lenB][4])
{
    for ( int i=0; i        for ( int j=0; j            calTwoCards(a[i], b[j], src[i][j]);
        }
}

void calTwoCards(double a, double b, int lenB, double src[lenB][4])
{
    for ( int i=0; i        calTwoCards(a, b[i], src[i]);
}

void calTwoCards(double a, double b, double src[])
{
    //a opeartor src[i] = b
    src[0]=b+a;
    src[1]=b-a;
    src[2]=b*a;
    src[3]=b/a;
}

char getOperator(int i)
{
    if (i==0) return '+';
    if (i==1) return '-';
    if (i==2) return '*';
    if (i==3) return '/';
}

void parseM(int m)
{
    char c = getOperator(m%6);
    char b = getOperator(m/6%6);
    char a = getOperator(m/6/6%6);

    cout << " " << a << " " << b << " " << c << endl;
}

void copy(double a[], double b[], int lenB)
{
    for (int i=0; i        a[i] = b[i];
}

void calCorrentExpression(double src[], double obj)
{
    for ( int i=0; i        double srcFirst[cardCounter];
        calTwoCards(src[i], obj, srcFirst);
        for ( int j=0; j            if (j==i) continue;
            double srcSecond[cardCounter][cardCounter];
            calTwoCards(src[j], srcFirst, cardCounter, srcSecond);
            for ( int p=0; p                if (p==j || p==i) continue;
                double srcThird[cardCounter*cardCounter][cardCounter];
                calTwoCards(src[p], srcSecond, cardCounter*cardCounter, srcThird);
                for ( int q=0; q                    if (q==i || q==j || q==p) continue;
                    for ( int m=0; m                        for ( int n=0; n                            if (src[q]-srcThird[m][n])
                }
            }
        }
    }

}

int main()
{
    double baseDigit[4] = {5,5,5,1};
    calCorrentExpression(baseDigit, 24);
    return 0;
}

izualzhy 2011-12-25 22:45 发表评论

赫夫曼算法Huffman algorithm构造赫夫曼树

izualzhy — Tue, 20 Dec 2011 14:29:00 GMT

这篇笔记主要为了解决文件包含不同频率的字符时构造其赫夫曼编码的问题。

具体可参考附录练习10.3

基本介绍：

贪心算法的一个应用，称为文件压缩file compression.

具体就不说了，主要是为了根据字符出现频率而采取不同长度的编码。同时保证解析后的结果是唯一的（只要没有任何字符编码是别的字符编码的前缀就行）。这样的编码称为前缀码prefix code。即要将所有字符放在叶子节点上。赫夫曼给出了一个算法，因此，这种编码系统通常称为赫夫曼编码Huffmancode。

Huffman algorithm可以描述如下：假设字符的个数为C，维护一个由树组成的森林。一棵树的权等于它的叶子的频率的和。任一选取最小权的两棵树T1和T2，并任意形成以T1和T2为子树的新树，将这样的过程进行C-1次。在算法的开始，存在C棵单结点树—每个字符一棵。在算法结束时得到一棵树，这棵树就是最优赫夫曼编码树。新树的总的权正是那些老树的权的和。

具体代码如下：

/********************************************************************************

**

** Filename: HuffmanCode.cpp

**

** Description: Huffman algorithm,generating prefix code.Note of learning greedy algorithm

**

** Version: 1.0

** Created: 2011年12月16日 14时35分24秒

** Revision: none

** Compiler: gcc

**

** Author: zhy (),izualzhy@163.com 

*********************************************************************************/

#include 

#include 

using namespace std;

struct HuffmanNode {

char nodeChar;

int counter;

HuffmanNode *leftChild;

HuffmanNode *rightChild;

string code;

HuffmanNode(char c='?', int t=0, HuffmanNode *l=NULL, HuffmanNode *r=NULL, string ce=string()) :

nodeChar(c) ,

counter(t) ,

leftChild(l) ,

rightChild(r) ,

code(ce)

{}

bool operator<(const HuffmanNode& node) { return this->counter
};

template<typename T>

class PriorityQueue {

public:

PriorityQueue(T a[], int size)

{

array = a;

currentSize = size;

for ( int i=size/2; i>=0; --i)

percolateDown(i);

}

void deleteMin(T &minItem)

{

minItem = array[0];

array[0] = array[--currentSize];

percolateDown(0);

}

void insert(const T &item)

{

array[currentSize++] = item;

//percolate Up

T temp = item;

int curhole = currentSize-1;

while (curhole>0 && temp
array[curhole] = array[(curhole-1)/2];

curhole = (curhole-1)/2;

}

array[curhole] = temp;

}

private:

int leftChild(int i) { return 2*i+1; }

void percolateDown(int hole)

{

int child;

T temp = array[hole];

while (leftChild(hole)
child = leftChild(hole);

if (child!=currentSize-1 && array[child+1]
child++;

if (array[child]
array[hole] = array[child];

else

break;

hole = child;

}

array[hole] = temp;

}

void percolateUp(int hole)

{

T temp = array[hole];

while (hole>0 && temp
array[hole] = array[(hole-1)/2];

hole = (hole-1)/2;

}

array[hole] = temp;

}

public:

int currentSize;

T *array;

};

int totalCodeNum;

void postorderTraverse(HuffmanNode *node,char left,string base)

{

if (!node) return;

base.append(1,left);

node->code = base;

if (node->leftChild) postorderTraverse(node->leftChild,'0',base);

if (node->rightChild) postorderTraverse(node->rightChild,'1',base);

if (node->nodeChar!='?') cout << node->nodeChar << "\t" << node->code << "\t" << (base.size()-1)*node->counter << endl;

totalCodeNum+=(base.size()-1)*node->counter;

}

int main()

{

HuffmanNode node[14];

node[0].nodeChar = ':';node[0].counter = 100;

node[1].nodeChar = ' ';node[1].counter = 605;

node[2].nodeChar = '/';node[2].counter = 100;

node[3].nodeChar = ',';node[3].counter = 705;

node[4].nodeChar = '0';node[4].counter = 431;

node[5].nodeChar = '1';node[5].counter = 242;

node[6].nodeChar = '2';node[6].counter = 176;

node[7].nodeChar = '3';node[7].counter = 59;

node[8].nodeChar = '4';node[8].counter = 185;

node[9].nodeChar = '5';node[9].counter = 250;

node[10].nodeChar = '6';node[10].counter = 174;

node[11].nodeChar = '7';node[11].counter = 199;

node[12].nodeChar = '8';node[12].counter = 205;

node[13].nodeChar = '9';node[13].counter = 217;

PriorityQueue queue(node,14);

HuffmanNode *temp1,*temp2,*t;

while (queue.currentSize>1) {

temp1 = new HuffmanNode;

temp2 = new HuffmanNode;

queue.deleteMin(*temp1);

queue.deleteMin(*temp2);

t = new HuffmanNode('?',temp1->counter+temp2->counter,temp1,temp2);

cout << t->counter << endl;

queue.insert(*t);

}

postorderTraverse(t,0,"");

cout << "total: " << totalCodeNum << endl;

return 0;

}

问题：

还有一个问题就是感觉空间的问题，优先队列里存储的是对象本身，感觉存储指针会节省不少空间。因为最初的基本思路是，构造树的结点都重新new出来，如果跟优先队列里使用相同的结点应该会好很多。

附录：

数据结构与算法分析—C++描述

izualzhy 2011-12-20 22:29 发表评论

选择问题---堆的应用

izualzhy — Mon, 12 Dec 2011 14:09:00 GMT

设有一组N个数，要确定其中第k个最大者。这称为选择问题（selection problem）。

题目很简单，解决这个问题主要是为了加深对二叉堆应用的印象。

解法：

1A：将这N个数读进一个数组中，再通过某种简单的算法，比如冒泡排序法，已递减的顺序将数组排序，然后返回位置k上的元素。

1B：先把前k个元素读入数组并（以递减的顺序）对其排序。接着，将剩下的元素读入。当读到一个新元素时，如果该元素小于数组中的第k各元素则忽略之，否则将其放到数组中的正确位置上，同时将数组中的一个元素挤出数组。当算法结束时，返回第k个位置上的元素作为答案。

6A: 假设我们只考虑找出k个最小元素。该算法很简单。先将N个元素读入一个数组，然后对数组应用buildHeap算法。最后，执行k次deleteMin操作。最后从该堆提取的元素就是正确答案。显然，只要改变堆序性质，就可以求解原始问题：找出第k个最大的元素。

6B：跟1B相似，不同的是数组替换为堆。

1A如果使用的是简单的排序算法，则运行时间为O(N²).

1B为O(N*k),如果k=N/2，那么还是O(N²).

6A如果使用buildHeap，构造堆的最坏时间为O(N)时间而每次执行deleteMin是O(logN)时间。由于有k次deleteMin，因此我们得到总运行时间为O(N+klogN)。如果k=O(N/logN)，那么运行时间取决于buildHeap操作，即O(N)。对于大的k值，运行时间为O(klogN)。如果k=N/2，那么运行时间为O(NlogN)。

注意如果令k=N，并在元素离开堆时记录这些元素的值，那么实际上就是对输入文件以时间O(NlogN)排序，即为堆排序。

6B buildHeap以总时间O(k)放入堆中。处理其余的每个元素的时间为O(1)，还要加上O(logk)时间，用来检测元素是否放入S，并在需要时删除sk并插入新元素。因此，总的时间是O(k+(N-k)logk) = O(Nlogk)。

还有其他一些更好的方法，不过我没有写。

看下输出：

$ ./a.out 5 && ./a.out 4 && ./a.out 3 && ./a.out 2 && ./a.out 1

method6B:

using time: 0.261759

4987030

method6A:

using time: 0.419211

4987030

method1B:

using time: 2276.7

4987030

method1A2(insert sort):

using time: 3327.25

4987030

method1A1(bubble sort):

using time: 9631.47

4987030

不相交集类以及应用迷宫生成

izualzhy — Sun, 11 Dec 2011 02:23:00 GMT

简单介绍：

考虑一个迷宫的生成，一个简单算法就是从各处的墙壁开始（除入口和出口之外）。此时，不断地随机选择一面墙，如果被该墙分割的单元彼此不联通，那么就把这面墙拆掉。重复这个过程直到开始单元和终止单元联通，那么就得到一个迷宫。实际上不断的拆掉墙壁直到每个单元都可以从其他单元到达更好（这会使迷宫产生更多误导的路径）。

因此主要是两个问题：

1. 拆掉墙如果两个单元不连通。

2. 保留墙如果两个单元已经联通。

这里用于判断不同单元是否在同一集合的数据结构即为不相交集类。

基本知识：

即我们要建立多个等价类，联通的元素放在同一个等价类里面。

对应的，需要两个操作：

1. 将两个元素放到一个等价类里的话，采用union操作。

2. 查找某个元素在哪个等价类里，采用find操作。根据find的返回值可以判断两个元素是否在一个等价类里。

可以用数组来记录，程序里我使用的是vector（仿照书里的）。

举个例子看可能比较清楚：

假设元素ID刚开始为 0 1 2 3 4 5 6 7 8 9

建立相同大小的数组s，数组初始化值均为-1。

最直观的处理，比如union(4,5)即使s[5] = 4。（约定union(x,y)使得s[y]=x，效果是相同的）。

find(4)会直接返回4本身，因为s[4]<0。

而find(5)则递归调用，实际上为:find(5) = find(s[5]) = 4，因此判断出4，5属于同一个等价类（我觉得可以理解为4这个结点即为等价类的代表）。

find最坏情形运行时间为O（N），因为对N个元素，有可能建立一个深度为N-1的树。

因此对union和find操作都进行了改进。

为了控制树的深度，可以重写union的方式，比如unionBySize,unionByHeight，书上都介绍，这里就不说了。此时find运行时间为O(N)。

另外对于find巧妙的改进是路径压缩，即当find（x）调用时，修改递归找到的结点直接指向等价类的代表结点，使得路径上的结点移近根结点，这样下次调用时就很快了。

正如书上所说：

这种数据结构实现起来很简单，每个例程只需要几行代码，而且可以使用一个简单的数组。

可以看到迷宫差别很大，我只是使得入口出口两个单元连通起来即结束循环。

效率什么的没有考虑。

所有的代码：数据集合类，迷宫生成类

/********************************************************************************
 **
 **       Filename:  DisjSets.h
 **
 **    Description:  
 **
 **        Version:  1.0
 **        Created:  2011年12月06日 11时43分46秒
 **       Revision:  none
 **       Compiler:  gcc
 **
 **         Author:  zhy (), izualzhy@163.com
 **        Company:  
 **
 *********************************************************************************/
#ifndef DISJSETS_H
#define DISJSETS_H
#include 
#include 
using namespace std;

class DisjSets {

public:
    explicit DisjSets(int numElements);

    int find(int x);
    void unionSets(int root1, int root2);

private:
    vector<int> s;
};
#endif//DISJSETS_H

/********************************************************************************
 **
 **       Filename:  DisjSets.cpp
 **
 **    Description:  
 **
 **        Version:  1.0
 **        Created:  2011年12月06日 11时45分09秒
 **       Revision:  none
 **       Compiler:  gcc
 **
 **         Author:  zhy (), izualzhy@163.com
 **        Company:  
 **
 *********************************************************************************/
#include "DisjSets.h"

DisjSets::DisjSets(int numElements) : s(numElements)
{
    for ( int i=0; i        s[i] = -1;
}

int DisjSets::find(int x)
{
    //cout << "DisjSets::find x= " << x << "\ts[x] = " << s[x] << endl;
    if (s[x]<0)
        return x;
    else {
        s[x] = find(s[x]);
        return s[x];
    }
}

void DisjSets::unionSets(int root1, int root2)
{
    if (s[root1]>s[root2]) {
        s[root1] = root2;
    } else {
        if (s[root1]==s[root2])
            s[root1]--;
        s[root2] = root1;
    }
}

/********************************************************************************
 **
 **       Filename:  MazeDataGenerator.h
 **
 **    Description:  generator the data of maze
 **
 **        Version:  1.0
 **        Created:  2011年12月06日 14时49分09秒
 **       Revision:  none
 **       Compiler:  gcc
 **
 **         Author:  zhy (), izualzhy@163.com
 **        Company:  
 **
 *********************************************************************************/
#ifndef MAZEDATAGENERATOR_H
#define MAZEDATAGENERATOR_H
#include 
#include "DisjSets.h"
class Room{

public:
    Room(int row, int col) :
        i(row) ,
        j(col)
    {
        for ( int i=0; i<4; ++i)
            wall[i] = true;
    }
    int i;
    int j;
    bool wall[4];

    bool operator==(const Room &room2)
    {
        return ((this->i)==(room2.i) && (this->j==room2.j));
    }
};

class MazeDataGenerator {

public:
    enum Direction{
        NORTH,
        EAST,
        SOUTH,
        WEST
    };

    MazeDataGenerator(int row, int column);
    ~MazeDataGenerator()
    {
        delete mData;
        mData = NULL;
        for ( int i=0; i            for ( int j=0; j                delete mRoom[i][j];
        for ( int i=0; i            delete [] mRoom[i];
        delete [] mRoom;
    }

    void print();

private:
    bool isConnected(Room *room1, Room *room2) {
        return (mData->find(room1->i*mColumns+room1->j)==mData->find(room2->i*mColumns+room2->j));
    }
    void initRoad();
    bool connectTworoom(Room *room1, Room *room2, Direction d);

private:
    DisjSets *mData;
    Room ***mRoom;
    int mColumns;
    int mRows;
};
#endif//MAZEDATAGENERATOR_H

/********************************************************************************
 **
 **       Filename:  MazeDataGenerator.cpp
 **
 **    Description:  
 **
 **        Version:  1.0
 **        Created:  2011年12月06日 14时51分42秒
 **       Revision:  none
 **       Compiler:  gcc
 **
 **         Author:  zhy (), izualzhy@163.com
 **        Company:  
 **
 *********************************************************************************/
#include 
#include 
#include 
#include "MazeDataGenerator.h"

MazeDataGenerator::MazeDataGenerator(int row, int column) :
    mRows(row) ,
    mColumns(column) 
{
    srand(time(NULL));
    mData = new DisjSets(row*column);
    mRoom = new Room**[row];
    for ( int i=0; i        mRoom[i] = new Room*[column];
    for ( int i=0; i        for ( int j=0; j            mRoom[i][j] = new Room(i,j);
    mRoom[0][0]->wall[NORTH] = mRoom[0][0]->wall[EAST] = false;
    mRoom[mRows-1][mColumns-1]->wall[SOUTH] = mRoom[0][0]->wall[WEST] = false;
    initRoad();
}

void MazeDataGenerator::initRoad()
{
    printf("%s\n",__FUNCTION__);
    Room *room = mRoom[0][0];
    while (!isConnected(mRoom[0][0],mRoom[mRows-1][mColumns-1])) {
        Direction side = (Direction)(rand()%4);
        int i = room->i;
        int j = room->j;
        switch(side) {
            case NORTH:
                i = room->i-1;
                break;
            case SOUTH:
                i = room->i+1;
                break;
            case EAST:
                j = room->j-1;
                break;
            case WEST:
                j = room->j+1;
                break;
        }

        if (i<0 || i>=mRows || j<0 || j>=mColumns)
            continue;
        if (!isConnected(mRoom[room->i][room->j],mRoom[i][j]))
            connectTworoom(mRoom[room->i][room->j],mRoom[i][j],side);
        room = mRoom[i][j];
        //print();
    }
}

bool MazeDataGenerator::connectTworoom(Room *room1, Room *room2, Direction d)
{
    //printf("%s\n",__FUNCTION__);
    //printf("(%d,%d)-->(%d,%d)\n",room1.i,room1.j,room2.i,room2.j);
    if (room1==room2)
        return false;

    int index1 = room1->i*mColumns+room1->j;
    int index2 = room2->i*mColumns+room2->j;
    int root1 = mData->find(index1);
    int root2 = mData->find(index2);

    if (root1==root2) return false;
    mData->unionSets(root1,root2);
    room1->wall[d] = false;
    room2->wall[(d+2)%4] = false;
    return true;
}

void MazeDataGenerator::print()
{
    printf("%s\n",__FUNCTION__);
    for ( int i=0; i        for ( int j=0; j            printf("%2d ",mData->find(mRows*i+j));
        printf("\n");
    }
   for (int j=0; j        printf("__");
    printf("\n");
    for ( int i=0; i        for ( int j=0; j            char s[3] = "  ";
            if (((j-1<0) && i!=0) || mRoom[i][j]->wall[1]) s[0]='|';
            if ((i+1)>=mRows || mRoom[i][j]->wall[2]) s[1]='_';
            printf("%s",s);
            if ((j+1)==mColumns && i!=mRows-1) printf("|");
        }
        printf("\n");
    }
}

参考资料：

数据结构与算法分析—C++描述

izualzhy 2011-12-11 10:23 发表评论

优先队列--二叉堆

izualzhy — Fri, 02 Dec 2011 14:51:00 GMT

关于二叉堆的学习笔记，如果改进或不对的地方请指出。

之前学习线程的时候，我们直到线程有解锁队列，条件队列等。这些队列并不完全按照先进先出来执行的，如果某个线程优先级较高，可能就会优先执行。这种特殊的应用需要的特殊队列，称之为优先队列（priority queue）

模型：

至少允许下列两种操作：

insert(插入)，deleteMin删除最小项（比如优先级最高的线程优先级值最小）。

insert操作等价于enqueue（入队）。

deleteMin则是队列操作dequeue（出队）在优先队列中的等价操作。

一些简单的实现：

链表？插入为O（1），但删除最小值需要遍历,为O(N).如果始终让表有序，则插入花费O（N），而删除花费O（1）。

二叉查找树？两种操作均为O（logN）。同时二叉查找树支持大量并不需要的操作。

二叉堆(binary heap)：

二叉堆是一棵完全填满的二叉树，可能的例外是在底层，底层上的元素从左到右插入。这样的树称为完全二叉树(complete binary tree)。

完全二叉树完全可以用一个数组表示，而不需要使用链。

根节点数组下标为1，由上往下，由左到右，依次递增。

对于数组任一位置i上的元素，其左儿子在位置2i上，其右儿子在左儿子后的单元2i+1上，它的父亲在位置i/2上(取整)。

这种实现方法唯一的问题是：堆的大小是固定的，不过一般情况下这不成问题，需要时我们可以重新调整。

性质：

跟之前的AVL树一样，插入，删除都可能破坏其性质，因此需要重新调整堆到满足其性质。

使操作可以快速执行的性质是堆序性质(heap-order property)。

我们是想快速找到最小元，因此将其放在根上。如果考虑到任意子树也应该是堆，那么可以得到堆序性质：

对于每一个结点（X），X的父亲中的键小于（或等于）X中的键，根结点最小。

基本操作：

1. 插入

跟AVL树处理相同，我们先尝试在数组下一位置创建一个空穴（hole，注意先不填入要插入的数值）。否则，该堆将不是完全二叉树。

如果该数值比父结点大，并不破坏堆序性质，插入完成。

如果该数值比父结点小，则该空穴的值修改为父结点的值。这样，空穴就朝着根的方向上行一步，继续该过程直到x能被放到空穴。

这种一般的策略叫做上滤(percolate up).

注意，这里编程时不用使用递归完成。同时没有交换的操作。

，类似于插入排序时的操作。

插入的时间为O（logN）。

2. 删除

删除最小元后，根节点形成为空穴。因此移动最后一个元素x到恰当的地方即可。

这里一般的策略叫做下滤（percolate down）

如果x可以被放到空穴，操作完成。

反之，先比较空穴的两个子结点,取到最小的一个（如果只有一个则直接取，如果0个则删除完成）。空穴的值修改为子结点较小的那个的值，空穴下移一层。直到X可以放入空穴。

注意，判断第i个结点的子结点数目：

2*i>当前结点数目，则0个子结点。

2*i=当前结点数目，则1个子结点。

2*i<当前结点数目，则2个子结点。

比较与交换都只与较小的结点进行即可。

删除的时间为O（logN）

堆还是很简单的，书上说：

我们将看到的这类数据结构属于计算机科学中最雅致的一种。

参考资料：

数据结构与算法分析—C++描述

#ifndef    BINARYHEAP_H
#define BINARYHEAP_H

#include 
#include 
using namespace std;

template<typename Comparable>
class BinaryHeap {

public:
    explicit BinaryHeap( int capacity=100 )
    {
        array.resize(capacity);
    }
    explicit BinaryHeap( const vector &items);

    bool isEmpty() const { return currentSize==0; }
    const Comparable &findMin() const { return array[1]; }

    void insert(const Comparable &x);
    void deleteMin();
    void deleteMin( Comparable &minItem);

    void print()
    {
        for ( int i=1; i<=currentSize; ++i) {
            cout << array[i] << " ";
            if (i%5==0)
                cout << endl;
        }
        cout << endl;
    }

private:
    int currentSize; //Number of elements in heap
    vector array;//The heap array

    void buildHeap();
    void percolateDown(int hole);
};

template<typename Comparable>
void BinaryHeap::insert(const Comparable &x)
{
    if (currentSize==(array.size()-1))
        array.resize(currentSize*2);

    int hole = ++currentSize;
    while (hole>1 && array[hole/2]>x) {
        array[hole] = array[hole/2];
        hole/=2;
    }
    array[hole] = x;
}

template<typename Comparable>
void BinaryHeap::deleteMin()
{
    if (isEmpty())
        return;

    array[1] = array[currentSize--];
    percolateDown(1);
}

template<typename Comparable>
void BinaryHeap::deleteMin(Comparable &minItem)
{
    if (isEmpty())
        return;
    minItem = array[1];
    array[1] = array[currentSize--];
    percolateDown(1);
}

template<typename Comparable>
void BinaryHeap::percolateDown(int hole)
{
    int child;
    Comparable tmp = array[hole];
    
    while (hole*2<=currentSize) {
        child = hole*2;
        if (child!=currentSize && array[child+1]            child++;
        if (array[child]            array[hole] = array[child];
        else
            break;
        hole = child;
    }
    array[hole] = tmp;
}

template<typename Comparable>
BinaryHeap::BinaryHeap(const vector &items) : 
    array(items.size()+10) ,
    currentSize(items.size())
{
    for ( int i=0; i        array[i+1] = items[i];
    buildHeap();
}

template<typename Comparable>
void BinaryHeap::buildHeap()
{
    for ( int i=currentSize/2; i>0; --i)
        percolateDown(i);
}
    
#endif//BINARYHEAP_H

izualzhy 2011-12-02 22:51 发表评论

数据结构------AVL树

izualzhy — Mon, 21 Nov 2011 14:40:00 GMT

数据结构------AVL树

学习数据结构的笔记，有不对或者需要改进的地方请指出。

为什么要用AVL树？

插入一组有序的数据到树中，实际上树变成了链表。

基本知识：

AVL(Adelson-Velskii and Landis)树是带有平衡条件的二叉搜索树。

一棵AVL树是其每个结点的左子树和右子树的高度最多差1的二叉查找树（空子树的高度定义为-1）。

在高度为h的AVL树中，最少结点树S(h)=S(h-1)+S(h-2)+1，对于h=0,S(h)=1,h=1,S(h)=2。函数S(h)与斐波那契数密切相关。

例如下面两个图，只有右边的是AVL树。

旋转的定义，图示（重要）:

感觉这一部分文字描述起来很难，看图的话相对容易理解多了。而且印象会深刻一些。而且代码实现总是有差别的，例如我看到有的例子用的返回结点指针，而我从书上学习的例子则是传递指针的引用。

两者共同的地方就是在方法的使用上没有区别。因此，理解旋转很重要，理解清楚了以后，代码就好写的多了。因此，为了篇幅不至于过长，旋转我另写了一篇笔记。

代码编写注意：

AVLTree从BinarySearchTree继承而来，不得不重新修改了BinarySearchTree，以及BinaryTree的一些函数。

1. 结点高度

空子树的高度定义为-1.我在之前的BinaryTree里又加了一个函数getDepth求结点高度。刚开始用的返回值是size_t，因此就出现了问题。

2. 关于单旋转，双旋转看明白了。可还是不知道怎么编程去实现。

总之我是这样子的。不知道从哪里入手。其实过程是这样的：

仍然按照二叉搜索树的插入过程插入结点。这时有部分结点的高度发生了变化，因此可能不满足AVL性质了。书上是这么说的：

在插入之后，只有那些从插入点到根节点的路径上的结点的平衡可能被改变，因为只有这些结点的子树可能发生变化。当我们沿着这条路径上行到根并更新平衡信息时，可以发现一个结点，它的新平衡破坏了AVL条件。我们将指出如何在第一个这样的结点（即最深的结点）重新平衡这棵树，并证明这一重新平衡保证整个树满足AVL性质。因此，我又对前面的二叉搜索树代码做了改动

virtual void BinarySearchTree::insert

virtual void BinarySearchTree::remove，因为此时我们要重新实现这两个函数。在路径上检查每个结点左子树和右子树的高度，由于递归的性质，第一个检查到的不平衡的结点即是最深的结点。（可能不容易想明白，书上讲的仔细些，自己编下代码就容易理解了，我的代码附在最下面）。当检查到第一个节点后，就去判断该使用哪一种旋转的方式。传入该结点指针（我传递的指针的引用），修改相应的结点关系就可以了。例如书上左子树单旋转是这么写的：

void rotateWithLeftChild(AvlNode *&k2)//k2为检查到的第一个结点，k1为其左子树的根节点

{

AvlNode *k1 = k2->left;//取k2左子树的根节点

k2->left = k1->right;//修改k2左子树为k1的右子树

k1->right = k2;//k1的右子树现在是k2了！

k2 = k1;//提升k1的高度，之前k2的位置是k1了，因为这里是对k2的引用。

}

双旋转实际上可以用两次单旋转来完成，编程实现过程可以由此而来。

双旋转的效果与现在第一个不平衡的结点node的儿子和孙子之间单旋转，然后再在node和它的新儿子之间单旋转效果相同。

问题：

1. 递归对效率的影响，例如每个结点的高度是否写在结点struct里。书上结点类型重新定义，为了使用之前的GUI程序直观的看下，没有修改结点的结构体定义，我重写了一个获得结点高度的函数。

2. 从解决大型的实际问题编程考虑，程序哪部分还存在问题？

3. 我写的删除过程与插入是不可逆的，不知道怎么修改插入删除如何才能是可逆的？
/Files/izualzhy/AVLTree.rar

参考资料：

《数据结构与算法分析------C++描述》中文版 Mark Allen Weiss著

izualzhy 2011-11-21 22:40 发表评论

数据结构------二叉查找树

izualzhy — Thu, 17 Nov 2011 13:50:00 GMT

数据结构------二叉查找树

学习数据结构的笔记，有不对或者需要改进的地方请指出。

基本概念：

使二叉树称为二叉查找树的性质是，对于树中的每个结点X，它的左子树中所有项的值小于X中的项，而它的右子树中所有项的值大于X中的项。

左边的树是二叉查找树，而右边不是。

6 6

/ \ / \

2 8 2 8

/ \ / \

1 4 1 4

/ / \

3 3 7

有了这个性质，查找就方便多了，最大值只要从root一直往右查找，最小值只要一直往左查找就可以了。

编写代码心得：

由于树的递归定义，通常是递归地编写关于树的操作。因为二叉查找树的平均深度是O(logN),所以我们一般不必担心栈空间被用尽。

public的成员函数使用private递归函数的常规定义。因此我们只讨论private的函数。

分别写了以下几个：

1. contains：判断是否包含该数值。

首先判断树是否为空。注意该函数里的两个递归都是尾递归（尾递归什么意思？）。该函数实现也可以用用一个while来实现。

2. FindMin，FindMax：寻找最大值最小值

从根开始只要有左儿子就向左进行。终止点就是最小的元素。

递归编写FindMin，非递归编写FindMax。注意这只是实现方式上的区别就行了。

FindMax里对t的改变是安全的，因为我们只用指针的副本来工作。

3. insert：插入数值到树中。

如果数值本来就在树中，我们什么都不做。

程序里插入时不会改变原来结点的位置，比如我们的树现在只有一个根节点1，插入2实际上结果有多种可能：

1 2

\ /

2 1

即程序里我采用的是第一种，也是书上的做法。因此相同的一组数值插入过程的不同生成的树就不相同，稍后我们打印会看一下。

代码本身传入的是指针的引用。

注意，在递归例程中，只有当一个新树叶生成的时候，t才改变。当这种情况发生的时候，就说明递归例程被其他结点p调用了。该节点p是树叶的父亲。调用将是insert(x,p->left),or insert(x,p->right)。

在任何一种方法中，t是到p->left or p->right的引用。这意味着p->left or p->right将会改变为指向新节点。总而言之，这是一个老套的技巧。

4. remove:删除某个数值的结点

同许多数据结构一样，最困难的操作是删除。一旦发现要被删除的结点，就需要考虑集中可能的情况。

针对二叉搜索树，有三种情况：

1. 如果结点是一片树叶，那么它可以被立即删除。

2. 如果结点有一个儿子，那么该节点的父节点绕过它后链到其子节点即可。

3. 如果结点有两个儿子，一般的删除策略是用其右子树的最小的数据（很容易找到）代替该节点的数据并递归的删除那个结点（现在它是空的）。因为右子树的最小的结点不可能有左儿子，所以第二次remove会很容易（1or2的情况）。挺抽象的，没办法。。。画个树的图或者看下代码就容易理解了！

如前面提到的，不同的插入顺序，即使数值相同，树的形状也会有差别，你能猜到我插入这几个字符的顺序么？

附件是源文件，画图的话只要修改前面上传的gui的main.cpp就行了，有兴趣的可以看下insert remove是不是的确按照我们的策略进行的。

关于第一张图，是我们开始AVL树的原因。

平均情况分析：

上面提到的删除算法有助于使得左子树比右子树深度深，因为我们总是用右子树的一个结点来代替删除的结点。

在删除操作中，可以通过随即选取右子树的最小元素或者左子树的最大元素来代替被删除的元素以消除这种不平衡问题。

如果插入是有序的，那么此时的树将只由那些没有左儿子（右儿子）的结点组成（第一张图）。

一种解决办法就是要有一个称为平衡(balance)的附加的结构条件：任何结点的深度均不得过深。

有许多一般的算法实现平衡树。但是，大部分算法都要比标准的二叉搜索树复杂得多，更新要平均花费更长的时间。不过，它们确实防止了处理起来非常麻烦的一些简单问题。AVL树是最老的一种平衡二叉搜索树。

另外，较新的办法是放弃平衡条件，允许树有任意的深度，但是在每次操作之后要使用一个调整规则进行调整，使得后面的操作效率更高。这种类型的数据结构一般属于自调整(self-adjusting)类结构。

下篇笔记开始学习AVL树。
程序源码：/Files/izualzhy/binarySearchTree.rar

参考资料：

《数据结构与算法分析------C++描述》中文版 Mark Allen Weiss著

izualzhy 2011-11-17 21:50 发表评论

数据结构------利用Qt画出树的结构

izualzhy — Thu, 17 Nov 2011 13:48:00 GMT

数据结构------利用Qt画出树的结构

这两天学习二叉树的时候，总感觉不够直观，又在csdn上看到了一篇利用Qt画出一棵树的结构。试着自己写了下，总没人家画的好看。不过有了这个经验，正好就用在了正在学习的数据结构上。

基本介绍：

TreeWidget类负责绘制，构造该类的时候需要传入一个BinaryTreeNode（在之前的数据结构笔记BinaryTree里使用的节点类，我在学习二叉搜索树等时也用了这个类作为树的结点，因此也可以用来画其他类型的树），当然该结点必须已经是构造好的树的根节点（该类只负责根据结点关系绘制），然后根据该结点的leftChild,rightChild去不断的递归绘制结点间的线段。

主要是重写了paintEvent函数

virtual void paintEvent(QPaintEvent *e);

里面负责递归绘制的是：

void draw(BinaryTreeNode *node, int x, int y, int angle, bool isLeft, int depth, QPainter *p);// 其实跟树的遍历是一个想法

其中

x,y是该结点坐标,angle表示边的角度，isLeft表示是否是左儿子，传入这个值主要是想是树画得别两条边交叉到一块了，不过结果并不理想，知道如何设置参数才能使树的边不交叉的同学教我一下，谢谢:-D。depth是深度，深度越大时，画得线相应短一些。

如上篇笔记里的，二叉树画出来的样子：

二叉树的文件我放在了binaryTree文件夹下，该gui程序源文件放在了gui文件夹下，两个文件夹是同级的。所以TreeWidget.h有这一句：

#include "../binaryTree/binaryTree.h"，如果不这么放需要修改这里。

对应的，#include "../binarySearchTree/binarySearchTree.h"是为了画二叉搜索树，没有这个文件就先注掉，等学习并写好二叉搜索树的代码后，我会放上来。

问题：

1. 之前提到的，因为角度都用的随机数，需要设置上其他合适的参数，否则树的边会有交叉。

2. 模板的实现必须放在h文件里，而Qt实现放在h文件里好像容易出问题，所以写了这么一句typedef char T;本来想写成template的。发现自己懂得太少，写不通。。。。

程序源代码： /Files/izualzhy/gui.rar

izualzhy 2011-11-17 21:48 发表评论