DS博客作业03--树

0.PTA得分截图

1.本周学习总结（0-5分）

1.1 总结树及串内容

• 串的BFKMP算法
  串是由0个或者多个字符所组成的有限序列，串可以采用顺序存储和链式存储两种方式，在主串中查找子串问题是串的一个非常重要的问题，这类问题有两种算法：Brute-Force算法，简称BF算法和KMP模式匹配算法。
• BF算法
  BF算法是一种常规算法，子串的第一个字符与主串的第一个字符进行比较，若相等，则继续比较主串与子串的下一个字符，若不相等，子串的第一个字符与主串的第二个字符进行比较，依次比较下去，直到全部匹配。
  第一轮
  
  第二轮
  
  ······
  第五轮
  
  第六轮
  
  匹配成功，返回子串在主串中第一次出现的位置，匹配失败返回 -1。
  代码实现

int BF(String s,String t)
{
   int i=j=0;
   while(i<s.length&&j<t.length)
   {
       if(s.data[i]==t.data[j])
       {
          i++;j++;
       }
       else
       {
          i=i-j+1;
          j=0;
       }
   }
   if(j>=t.length) return (i-t.length);
   else return -1;
}

• KMP算法
  当数据量比较小时，BF算法还可以用，但当数据量很大时，BF算法就显得很耗时了，我们就可以用KMP算法了。KMP算法是由 D.E.Knuth，J.H.Morris，V.R.Pratt 提出的，它是一种对BF算法的改进，它减少了子主串的匹配次数，主串指针一直往后移动，子串指针回溯，主串不需回溯。
  如图所示直到第六个元素才配对失败，由于子串的前三个元素都不相同，所以子串与主串中的二和三两个元素一定是不匹配的，可以直接和主串的第四个元素开始配对。
  

因为子串中的1和2元素和4和5元素是相同的，而且还和主串配对成功了，那么子串中1和2元素一定与主串的4和5元素配对，所以可以直接进行如下图的操作。

next数组
next数组是存放失配时，模式串下一次匹配位置，取值如图所示。

求next数组代码实现

void getNext(String t, int next[]) 
{
    int j = 0, k = -1;
    next[0] = -1;
    while (j < t.length - 1)
    {
        if ((k == -1) || t.data[j] == t.data[k])
        {
            j++;k++;
            next[j] = k;
        }
        else  k = next[k];
    }
}

KMP算法代码实现

int KMP(String s,String t)
{
    int next[Max],i=j=0;
    getNext(t,next);
    while(i<s.length&&j<t.length)
    {
       if(j==-1||s.data[i]==t.data[j])
       {
           i++;j++;
       }
       else  j=next[j];
    }
    if(j>=t.length)  return (i-t.length);
    else return -1;
}

nextval数组
next数组也有需要改进的地方，当匹配字串时，有连着的多个相同的字符时，会重复操作同一个字符，比如s为aaabaaaab，t为aaaa时，因为前三个都是一样的，就没有必要重复做一种操作，所以我们可以定义一个nextval数组，避免做相同的操作。
nextval数组代码

void getNextval(String t, int nextval[])
 {
    int i = 0, j = -1;
    nextVal[0] = -1;
    while (i < t.length)
    {
        if ((k == -1) || (t.data[i] == t.data[j]))
        {
            i++;j++;
            if (t.data[i] != t.data[j])
                nextval[i] = j;
            else
                nextval[i] = nextval[j];
        }
        else 
            j = nextval[j];
    }
}

修改后的KMP算法代码实现

int KMP(String s,String t)
{
    int nextval[Max],i=j=0;
    getNextval(t,nextval);
    while(i<s.length&&j<t.length)
    {
       if(j==-1||s.data[i]==t.data[j])
       {
           i++;j++;
       }
       else  j=nextval[j];
    }
    if(j>=t.length)  return (i-t.length);
    else return -1;
}

• 二叉树存储结构、建法、遍历及应用
• 二叉树存储结构：顺序存储结构，二叉链表
  顺序存储结构：顺序存储就是把一串字符串存储在数组里面，根据下标来确定父亲和孩子的关系，一般对于一个i结点来说，父亲是i/2，左孩子是2i，右孩子是2i+1。这种存储结构有一定的缺点，就是空间利用率太低，一般只适用于完全二叉树，如图。
  

二叉链表：因为二叉树每个结点都有左孩子、右孩子，所以可以用一种链式存储结构来存放数据，这种结构内有结点数据，左孩子指针和右孩子指针。

typedef struct BinTNode
{
	ElemType data;
	struct BinTNode *lchild,*rchild;
} BinTNode,*BinTree;

• 二叉树建法：顺序存储结构转二叉链，先序遍历，先序+中序序列，中序+后序序列
  顺序存储结构转二叉链：
  
  
  根据根结点与两个孩子之间i的关系，可转换成二叉链建树。

void CreateBTree(BiTree& BT, string str, int i)
{
	int strlen;
	strlen = str.size();
	BT = new BiTNode;
	if (i > strlen - 1 || i < 1)
	{
		BT = NULL;
		return;
	}
	if (str[i] == '#')
	{
		BT = NULL;
		return;
	}
	BT->data = str[i];
	CreateBTree(BT->lchild, str, 2 * i);
	CreateBTree(BT->rchild, str, 2 * i + 1);
}

先序遍历：

BinTree CreatBinTree()
{
	char ch;
	BinTree T;
	scanf("%c", &ch);
	if (ch == '#')  T = NULL;
	else 
	{
		T = new TNode;
		T->Data = ch;
		T->Left = CreatBinTree();
		T->Right = CreatBinTree();			
	}

	return T;
}

先序+中序序列：
前序遍历第一位数字一定是这个二叉树的根结点。中序遍历中，根结点讲序列分为了左右两个区间。左边的区间是左子树的结点集合，右边的区间是右子树的结点集合。

void CreateTree(BiTree& T, char* pre, char* infix, int n)
{
	int i;
	char* pi;
	if (n <= 0)
	{
		T = NULL;
		return;
	}
	T = new BiTNode;

	T->data = *pre;
	for (pi = infix; pi < infix + n; pi++)
	{
		if (*pi == T->data)
		{
			break;
		}
	}
	i = pi - infix;
	CreateTree(T->lchild, pre+1, infix, i);
	CreateTree(T->rchild, pre+i+1, pi + 1, n - i - 1);
}

中序+后序序列：
找到根结点（后序遍历的最后一位）在中序遍历中，找到根结点的位置，划分左右子树，递归构建二叉树。思路和先序+中序序列遍历一样。

void CreateTree(BiTree& T, int* post, int* infix, int n)
{
	int i;
	int* pi;
	if (n <= 0)
	{
		T = NULL;
		return;
	}
	T = new BiTNode;

	T->data = *(post + n - 1);
	for (pi = infix; pi < infix + n; pi++)
	{
		if (*pi == *(post + n - 1))
		{
			break;
		}
	}
	i = pi - infix;
	CreateTree(T->lchild, post, infix, i);
	CreateTree(T->rchild, post + i, pi + 1, n - i - 1);

}

• 二叉树的遍历：前序，中序，后序，层次
  前序：二叉树先序遍历的实现思想是：访问根节点；访问当前节点的左子树；若当前节点无左子树，则访问当前节点的右子树。

void PreOrderTraverse(BiTree T)
{
    if (T)
    {
        cout<<T->data<<" ";
        PreOrderTraverse(T->lchild);
        PreOrderTraverse(T->rchild);
    }
}

中序：二叉树中序遍历的实现思想是：访问当前节点的左子树；访问根节点；访问当前节点的右子树。

void INOrderTraverse(BiTree T)
{
    if (T)
    {
        INOrderTraverse(T->lchild);
         cout<<T->data<<" ";
        INOrderTraverse(T->rchild);
    }
}

后序：二叉树后序遍历的实现思想是：从根节点出发，依次遍历各节点的左右子树，直到当前节点左右子树遍历完成后，才访问该节点元素。

void PostOrderTraverse(BiTree T)
{
    if (T) 
    {
        PostOrderTraverse(T->lchild);
        PostOrderTraverse(T->rchild);
        cout<<T->data<<" ";
    }
}

层次：层次遍历是从上到下、从左到右依次遍历每个结点。通过队列的应用，从根结点开始，将其左孩子和右孩子入队，然后根结点出队，重复次操作，直到队为空，出队顺序就是层次遍历的结果。

void LevelTravesal(BiTree T)
{
	queue<BiTree>qu;
	BiTree BT;
	int flag = 0;
	if (T == NULL)
	{
		cout << "NULL";
		return;
	}
	qu.push(T);
	while (!qu.empty())
	{
		BT = qu.front();
		if (flag == 0)
		{
			cout << BT->data;
			flag = 1;
		}
		else
		{
			cout << " " << BT->data;
		}
		qu.pop();
		if (BT->lchild != NULL)
		{
			qu.push(BT->lchild);
		}
		if (BT->rchild != NULL)
		{
			qu.push(BT->rchild);
		}
	}
}

• 二叉树的应用
  1．查找数据元素
  查找成功，返回该结点的指针；查找失败，返回空指针。

BiTree Search（BiTree bt，elemtype x）
{
    BiTree p;
    if (bt->data==x) return bt; /*查找成功返回*/
    if (bt->lchild!=NULL) return(Search(bt->lchild,x));
    if (bt->rchild!=NULL) return(Search(bt->rchild,x));
    return NULL; /*查找失败返回*/
}

2．统计出给定二叉树中叶子结点的数目

int CountLeaf2（BiTree bt）
{
    if (bt==NULL) return 0;
    if (bt->lchild==NULL && bt->rchild==NULL) return 1;
    return CountLeaf2(bt->lchild)+CountLeaf2(bt->rchild);
}

3．表达式运算
如图所示为表达式3x2+x-1/x+5的二叉树表示。树中的每个叶结点都是操作数，非叶结点都是运算符。

对该二叉树分别进行先序、中序和后序遍历，可以得到表达式的三种不同表示形式。
前缀表达式+-+3xxx/1x5
中缀表达式3xx+x-1/x+5
后缀表达式3xx**x+1x/-5+

• 树的结构、操作、遍历及应用
  树有双亲存储结构，孩子链存储结构，孩子兄弟链存储结构，我们常用的是最后一种。

typedef struct tnode
{
    ElemType data;
    struct tnode* son;
    struct tnode* brother;
}TSBNode;

树的遍历有先根遍历：若树不空，则先访问根结点，然后依次先根遍历各棵子树。后跟遍历：若树不空，则依次后根遍历各棵子树，然后访问根结点。层次遍历：若树不空，则自上而下，自左至右访问树中每个结点。具体代码和上面二叉树类似。
树的应用：可以求树的高度，建目录树。

• 线索二叉树
  二叉链存储结构时，每个结点都有两个指针，一共有2n个指针域，有效指针域为n-1个，空指针域有n+1个，可以利用空指针域指向该线性序列的前驱和后继指针，这称为线索。
  
  
  线索二叉树：若结点有左子树，则其lchild域指向左孩子，否则指向直接前驱；若结点有右子树，则其rchild域指向右孩子，否则指向直接后继。
  为了避免混淆，再增加两个标志域LTag和RTag。若LTag=0，lchild域指向左孩子；若LTag=1，lchild域指向其前驱；若RTag=0，rchild域指向右孩子；若RTag=1，rchild域指向其后继。
  
  存储结构

typedef struct Node
 {
   ElemType data;
   int LTag,RTag;
   struct Node *lchild,*rchild; 
 }TBTNode;

• 哈夫曼树、并查集
  哈夫曼树
  带权路径长度：若有n个叶结点，每个叶结点的权值为Wk，从根结点到叶结点的长度为Lk，带权路径长度WPL=
  哈夫曼树是最小带权路径长度的二叉树。哈夫曼树没有度为1的结点，如果有n个叶结点，则哈夫曼树的总结点数为2*n-1。
  构造哈夫曼树的原则：权值越大越靠近根结点，权值越小，离根结点越远。
  
  
  
  
  
  并查集
  在并查集中，每个分离集合都算一棵树，并查集主要有集合查找，集合合并两个操作，采用顺序方法存储。

typedef struct node
{
     int data;
     int rank;
     int parent;
}UFSTree;

1.2.谈谈你对树的认识及学习体会。

本章主要学习了树的结构，属于非线性结构。线性结构是一对一关系，而树结构是一对多的关系。树结构有二叉树，线索二叉树和哈夫曼树，二叉树由一个根节点和左子树和右子树组成。线索二叉树是利用空余的指针指向结点前驱，而哈夫曼树利用带权路径解决最优问题。树结构的运算大部分都是递归运算，所以只有用好递归才能更加的熟悉树的操作。一般递归体分为左子树和右子树，递归口为结点为空或者其他条件。对树结构有了一定的学习后，发现代码调试时很困难，因为有些复杂了，但也为多对多关系打了基础。

2.阅读代码（0--5分）

2.1 题目及解题代码

2.1.1 该题的设计思路

将树的每个节点t作为根，把相应子树和给定子树s进行比较，看是否相同。函数traverse(s,t)遍历树s，把每个节点都看成当前子树的根。equals(x,y) 函数检查两个子树是否相等。首先比较两个树的根是否相等，然后递归比较左子树和右子树是否都相等。

时间复杂度：O(mn)。
空间复杂度：O(n)。

2.1.2 该题的伪代码

    public boolean isSubtree(TreeNode s, TreeNode t) {
        返回调用的traverse(s, t)函数的值
    }
    private boolean traverse(TreeNode s, TreeNode t) {
        将每个节点视为当前正在考虑的子树的根，看是否为空，再调用equals()函数看是否相等
    }
    private boolean equals(TreeNode t1, TreeNode t2) {
        若相等 return true;
        否则 return false;
        递归判断左和右
    }
}

2.1.3 运行结果

2.1.4分析该题目解题优势及难点。

优势：时间复杂度和空间复杂度比较小
难点：在遍历给定的树s时，如何将每个节点视为当前正在考虑的子树的根，判断当前考虑的两个子树是否相等。

2.2 题目及解题代码

2.2.1 该题的设计思路

当 root.val > R，那么修剪后的二叉树会出现在节点的左边。当root.val < L时，那么修剪后的二叉树会出现在节点的右边。否则，修剪树的两边。
时间复杂度：O(N)。
空间复杂度：O(N)。

2.2.2 该题的伪代码

struct TreeNode* trimBST(struct TreeNode* root, int L, int R){
    root为空时，返回NULL
    若root->val < L
        返回trimBST(root->right, L, R);
    若R < root->val
        返回trimBST(root->left, L, R);
    接着找左孩子root->left = trimBST(root->left, L, R);
    接着找右孩子root->right = trimBST(root->right, L, R);
}

2.2.3 运行结果

2.2.4分析该题目解题优势及难点。

优势：利用递归的算法，减少了代码量，复杂度也相对较小。
难点：修减时如何替代前一个结点。

2.3 题目及解题代码

2.3.1 该题的设计思路

以树t1为基础，将t2合并到t1上。如果两棵树的根结点都不为空，则累加两个根结点的值；然后合并t1的左子树和t2的左子树；然后合并t1的右子树和t2的右子树；最后返回t1作为合并后的子树根结点。递归边界为：如果t1为空，则返回t2作为子树；如果t2为空，则返回t1作为子树。
空间复杂度和时间复杂度都为O(n)。

2.3.2 该题的伪代码

class Solution {
    public TreeNode mergeTrees(TreeNode t1, TreeNode t2) {
        若t1为空  return t2;
        若t2为空  return t1;
        两个根结点累加
        分别合并两棵树的左子树和右子树
    }
}

2.3.3 运行结果

2.3.4分析该题目解题优势及难点。

优势：不用新建一个树，而是在t1的基础上进行改动。
难点：根结点要怎么返回。

2.4 题目及解题代码

2.4.1 该题的设计思路

如果对一个节点的左孩子向下遍历最多有L个结点，右孩子向下遍历最多有R个结点，那么经过的节点数就为 L+R+1，记作dnode，则二叉树的直径就是dnode减一。函数depth(node）计算dnode。先求子树的深度L和R，则dnode为L+R+1，而全局变量ans记录dnode的最大值，最后返回的ans-1就是二叉树的直径。

时间复杂度：O(N)，其中 N为二叉树的节点数。
空间复杂度：O(H)，其中 H为二叉树的高度。

2.4.2 该题的伪代码

class Solution {
    定义全局遍历ans;
    int depth(TreeNode* rt){
        若rt为空，返回0
        求左孩子为根的子树的深度
        求右孩子为根的子树的深度
        计算dnode
    }
};

2.4.3 运行结果

2.4.4分析该题目解题优势及难点。

优势：采用递归调用，把一个大问题，分成了若干个相似的小问题，即找以孩子为结点树的高度。
难点：如何来计算ans的值并更新。