4-9 顺时针打印数组/包含min函数的栈/树的子结构；

1、顺时针打印数组

思路：

1. 先判断鲁棒性，输入是不是合适；

2. 设置四个变量 left=0；right=cols-1；top=0;buttom=rows-1;//分别表示上下左右四个；

3. while(left<=right&&top<=buttom)判断程序循环进行的条件；

4. 循环1：从左到右打印 for(int j=left;j<=right;j++) result.push_back(a[top][j]);

5. 循环2：从上到下打印 for(int i=top+1;i<=buttom;i++);push;

6. 循环3：从右到左，需要判断左右的关系 if(left<right&&top<buttom);但是包含循环2的条件；

   ​ for(int j=right-1;j>=left;j--);push;

7. 循环4：从下到上： 需要判断上下的关系，也要包含前面步骤3的条件if(top+1<buttom&&left<right)

   ​ for(int i=buttom-1;i>top;i--)push;

   vector<int> printMatrix(vector<vector<int> > matrix)
{
    int rows = matrix.size();
    int cols = matrix[0].size();
    vector<int >result;
    if (rows == 0 || cols == 0)
        return result;
    
    int left = 0;
    int right = cols - 1;
    int top = 0;
    int buttom = rows - 1;
​
    while (left<=right&&top<=buttom)
​
    {
        //第一步、从左往右打印第一行
        for (int j = left; j <= right; j++)
            result.push_back(matrix[top][j]);
        //从顶到下打印最右侧；//保证有一个数就可以；
        //if (top<buttom)//可以加 可以不加；
            for (int i = top + 1; i <= buttom; i++)
                result.push_back(matrix[i][right]);
        //从右向左打印最底层；保证有一个数就可以；
            if (top<buttom&&left<right)
            for (int j = right - 1; j >= left; j--)
                    result.push_back(matrix[buttom][j]);
        //从下到上打印最左侧；完成一圈；
        if (top+1<buttom&&left<right)
            for (int i = buttom - 1; i >= top + 1; i--)
                result.push_back(matrix[i][left]);
            left++;
            right--;
            top++;
            buttom--;
    }
    return result;
}

2、包含min函数的栈

思路：自己没想起来 看的答案，看的别人的解法；

构建一个辅助栈，用来保存最小的值；

stack<int>stk;
stack<int>min_stk;//最小值的栈；
void push(int value)；//入栈操作；
 void pop()；//出栈操作
 int top()；//栈顶；
  int min()；//最小值；
  
 void push(int value)
{
    stk.push(value);
  if(min_stk.empty())
    min_stk.push(value);
  if(min_stk.top()>value)
    min_stk.push(value);
}
void pop()
{
  if(stk.top()==min_stk.top())
    min_stk.pop();
  stk.pop(); 
}
int top(){ return stk.top();}
 int min(){return min_stk.top();}
  
  

3、树的子结构

思路：自己倒是没想起来怎么做；

1. 先排除异常；鲁棒性

2. 判断两个树的根节点的值是否相等 if(root1.val==root2.val) return IsSubTree(root1,root2);

3. 当两个树的根节点不相等的时候

   1. 左子树的根节点 递归；返回值直接是 bool值；

   2. 否则，进行右子树的根节点递归 返回bool值；

4. 对 IsSubTree(root1,root2)函数进行编写；这个函数 是判断 树2是不是树1的根节点；

   1. 判断两个树是不是为空，root1为空返回false；root2==null，返回true；

   2. 判断两个节点的值是不是相等 if(root1.val==root2.val);相等的话判断左子树和右子树；返回值是两个&运算；

      return (IsSubTree(root1.left,root2.left)&&IsSubTree(root1.right,root2.right));

   3. 否则的话 返回false

bool Tree1_has_tree2(TreeNode* pRoot1, TreeNode* pRoot2)//判断树2是不是树1的子树；
    {
        if(pRoot2==nullptr)//树1为空 直接返回true；
            return true;
        if(pRoot1==nullptr)//树2为空 返回true；
            return false ;
        if(pRoot1->val!=pRoot2->val)//如果两个节点不相等；那么返回false；
            return false;
        else//相等的话 判断两个树的左右子树 是不是都相等；
            return Tree1_has_tree2(pRoot1->left,pRoot2->left) && Tree1_has_tree2(pRoot1->right,pRoot2->right);
        
    }
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if(pRoot1==nullptr||pRoot2==nullptr)//判断不合理的输入；
            return false;
        if(pRoot1->val==pRoot2->val)//如果两个树的根节点相等；则转入新函数判断树1是不是包含树2；
        {
            if(Tree1_has_tree2(pRoot1,pRoot2))
                return true;
        }
        if(HasSubtree(pRoot1->left,pRoot2))//如果不相等的话；递归到树1的左子树；看树1的左子树是不是包含树2；
            return true;
        if(HasSubtree(pRoot1->right,pRoot2))//再不然；递归到树1的右子树；看是不是树1的右子树的子树；
            return true;
        return false;//否则的话返回false；
    }