1、2）以大O的形式分析这些操作的时间复杂度。4、重新编写一个优先队列的数据结构，该数据结构采用的物理实现是BST。【实验步骤】第一题【需求分析】根据数学狭义函数的定义，一个函数的函数值随参数的确定而确定。推广到泛函（参数不一定是数的称泛函）也一样， 所以如果两个参数的函数值不相等，则两个参数绝对不相等。但是反之不成立。因为存在多重解（同义词）。根据这个性质，我们定义一个Hash函数 从“字符串域” 到 “非负整数域”，对应法则是H（x） = x 各个字符的ASCII 编码算术和。 比如 H（“AB”） = 65 + 66 = 131;这种方法的好处是很容易从前一个Hash值计算出next Has
2、h值，且计算速度很快。坏处是重码比较多。先对模式串求 Hash函数值， 保存在hash_pattern 中，这是个定值。然后对目标传的各个子串（长度同模式串）求Hash函数值。从Hash的定义上来看，目标子串后移一位，很容易就能从前一个 Hash 函数值中 计算出当前字串的 Hash值。然后比较 两个的 hash值，如果不等，那么肯定不可能匹配。 如果相等，进一步检查。检查方法是逐字比较，BruteForce穷举法。我们让目标串当前字符指针和模式串指针如果 指的值相等，那么一直向后移。如果最后发现 模式串指针到达“尽头”，那么说明 逐字相等。【源代码】/*- StringMatching.CP
3、P - whether target string and pattern string match Version alpha （c）Xianfu Pan , 2010 -*/ #include stdio.h#include string.h#define Testconst int TAR = 30;const int PAT = 10;int Hash（const char* aKeyStr, const int nLen） / get Hash value char* p = （char*） aKeyStr; int i = 0; int h = 0; while（i+ nLen）
4、h = （h + *p+）; /add every ASCII code return h;int search（const char* TargetStr, const char* PatternStr） /search char* p1 = （char*） （TargetStr）; const int len = strlen（PatternStr）; int hash_target = Hash（p1,len）; const int hash_pattern = Hash（PatternStr,len）; while （0 != *p1） if （ hash_target = hash_
5、pattern） char* temp = p1; char* p2 = （char*） PatternStr; while（*temp != & *p2 ! *temp+ = *p2+） /only if every character is equal can *p reach the end （*p2 = 0）; if （*（p2） = ） return p1 - TargetStr; / p1 - TargetStr is the position first match / if Hash vaule is not equal , get next subStrings Hash v
6、alue; hash_target = （hash_target - *p1） + *（p1 + len）; p1+; return -1; / if cant match , then return -1int main （int arg, char* argv） std:cout search（Computer is my best friend, est ） endl;I love programming very muchem search （DataStructure is of charmingis return 0;【运行结果】经验证， 16, -1 ,14都是预期的值，该算法是
7、有效的。【复杂度分析】假设 目标串的长度是 m,模式串的是 n，那么 计算两个串Hash值耗费的时间是 n+ n = 2n ,而从前一个字串hash值 计算后一个基本上不耗时，耗费时间为 1（常数）。通过比较，如果任意和模式串等长度的子串hash值 都不等于 模式串Hash值，那么就是匹配失败。AML unsucc= m n +1;如果成功的话，平均比较 （m n + 1）/2次。 而每次计算hash值的时间又是 1，平均一共计算了（m n + 1）/2 次Hash值，若是两个Hash值相等，那么继续逐字比较，消耗的时间也不过是 n/2 所以时间复杂度应该 是 O（mn），但是值得注意的是；
8、两个Hash值相等的概率比较小，虽然复杂度仍然是O（mn） 但是运算次数肯定较原版bruteforce少。【小结】关键是如何从前一个Hash值很快得到下一个Hash值。本题加深了同义词的概念的理解。Hash值相等，并不一定 关键码相同。第二题判断两棵二叉树是否相似，首先得得到两棵二叉树，笔者采用输入字符串的方式建立二叉树。假定”RefValue” = #表示一个结点无孩子，应为二叉树不是线性结构，采用前序遍历顺序 穿插 RefValue 的字符串（线性结构）来构建一个非线性的 二叉树比如：字符串“AB#D#C#”就构建出如下的树关于相似性的定义如下：由定义： 很容易得出关键代码为Similar
9、（a,b）If （a 空 & b 空） Return 相似 /递归终止条件If （a 不空& b 不空 & similar（a的左子树，b的左子树） & similar（a的右子树，b的右子树）Return 相似Else Return 不相似完全是运用定义。现在提供版本二，也是定义，先假定相似，给flag赋予true； 然后把flag的引用传递到各个递归层，（级数越高引用越多，但是flag的值始终是引用传递，任意一个递归层改变了参数值就会影响到Flag 的真假） 运用相似的定义去尝试否定 flag。 一旦有一个某级子树不相似，就给 flag赋假。如果没有找到一个子树不是对应相似的，那么flag
10、 保持默认值为真。 SIMILAR BinaryTree.CPP - judgement to two binary trees whether similar alpha/#define Testtemplate class BinTreeNodepublic: BinTreeNode（ T x, BinTreeNode *left = NULL ,BinTreeNode *right = NULL） :m_Data（x）, m_LeftChild（left）, m_RightChild（right） BinTreeNode（） / because Similar function is a
11、 global function rather than a member function,so public: T m_Data; BinTreeNode *m_LeftChild, *m_RightChild;class BinTree BinTree（） m_Root = NULL; BinTree（const char* strTree） / constructor to build a tree char* p = （char*） strTree; CreateTree（p , m_Root）; / PreOrder to create a tree / is very impor
12、tant. It play a role passing down address void CreateTree（char*& p , BinTreeNode*& subTree） if（= *p） / define # a mark to declare that this node has no left / right child node if（ = *p ） / allocate memory and initial the node with data *p,and NULL,NULL subTree = new BinTreeNodem_LeftChild）;m_RightCh
13、ild）; else subTree = NULL; / if = *p then , no child,so assign NULL BinTree（） /define destructor in case of memory leak Destroy（m_Root）; void PreOrder（） std: PreOrder Traverse are as follows m_Root）; void PreView（BinTreeNodem_Data void Destroy（BinTreeNode #ifdef Testdeleting std: #endif delete aTree
14、; / ONLY postOrder Deleting is available to Destroy;* m_Root;/Version 1, Defination based;templatebool Similar（BinTreeNode *aTree, BinTreeNodem_LeftChild, bTree-m_LeftChild） m_RightChild, bTree-m_RightChild）/ else /else, not similar; return false;/Version 2, Greed algorithmvoid Similar （BinTreeNodem
15、_LeftChild, flag）;m_RightChild, flag）; else /one is empty but one not,which draw a conclusion that not similar flag = false;int main（int argc, char* argv） char buffer50; cout buffer; BinTree fTree（buffer）;input second tree like sTree（buffer）; fTree.PreOrder（）; sTree.PreOrder（）;- bool flag = Similar（
16、fTree.m_Root, sTree.m_Root）; /Similar function version 1 if （flag）They are similar else They are not similar flag = true; / assump they are similar,then make every attemp to deny it, / following function does the job Similar（sTree.m_Root, fTree.m_Root, flag）; / Similar function version 2 flag 相似的情况
17、不相似的情况递归算法，在similar （n-1）返回前，similar（n）被挂起。因为是遍历（变相遍历）二叉树，所以时间复杂度是：O（n） n为二叉树的结点数。但是注意到 &运算的短路性质，故真正 用的时间是 O（log n）;理解递归思想很重要，递归的思想来自于事物的定义。把大的问题分解成小的问题，但是小问题和大问题“相似”，那么就可以考虑用递归。每一层递归只要考虑当前层就行，另外递归需要一个终止条件， 那就是找到 n = 1时，强行定义 f（1） = 某个值。第三题依据题意，编写一个基于堆的栈，就是说：对外部来说，栈还是栈结构，即FILO或者LIFO 先进后出或后进先出。但是，这个栈是
18、基于堆的，对于内部来说，数据是按照堆序排列的。所以说如果从 栈的 操作 Push Pop 转化到堆的操作 Insert, Remove就是一个最大的问题。由于栈表示的是一种时间上的先后，基于数组或者链表的栈时间上的先后性其实就反映在空间上的先后性。因为后（后表示时间概念）进来的元素总是比先进来的元素存放的地址（地址表示空间概念）靠后。两者的关系是一次线性对应。而堆序只是一种数值大小的先后，空间的先后无法反映到进栈时间的先后,当栈Push的时候，只要按堆序存入，调整位置就行。当然没有问题，而当Pop的时候， 存在堆中的数据 因为缺乏一种空间上的顺序性，无法确定是哪个元素出栈。 解决这个问题的方法
19、就是给进入的元素增加时间标签这个信息，使得进了堆的元素在Pop的时候能够知道是哪个该出堆了。时间标签的值就是栈大小的值，或者说是栈顶元素的位置。 HeapBasedStack.CPP - a Stack Based On Heap （minHeap）const int MAX = 40;struct Node int m_iTimeTag; /when function argument pass down,it use operator = indirectly; /youd better overload operator =,though here is not nessesary Node operator=（Node other） m_Data = other.m_Data; m_iTimeTag = other.m_iTimeTa
