剑指Offer刷题-一些必须要会的知识点

一些必须要会的知识点：

树的遍历-递归-非递归-前序中序后序层序

前序遍历-非递归（栈）

// 方式一
void preOrder(treenode *root) {
       if (root) {
			stack<treenode *> st; // 借助 栈 结构进行前序遍历
			treenode *r =root;
			while (!st.empty()||r) { // 当栈不为空或树根不为空进入循环
				while (r) { // 这里循环遍历每棵左子树的根节点
				            // 当根节点为空，说明到了叶子的部分				
					st.push(r);	// 栈顶存放接下来要遍历的左子树的根节点
					cout << r->val;
					r = r->left;
				}
				if (!st.empty()) { // 左子树为空、遍历完毕的情况下，跳出上面的循环
					r = st.top(); // 访问当前左子树的父节点
					
					st.pop();
					r = r->right; // 开始以同样的方式遍历其右子树
				}
				
			}
		}	
}
// 方式二、
void preOrder(treenode *root)
{
  treenode * p = root;
  stack<treenode*> S;	//借助 栈
  S.push(p);
  while(!S.empty())
  {
	  p = S.top();
	  S.pop();
	  cout<<p->data<<" ";
	  if(p->rchild)	   //右节点先入栈
		  S.push(p->rchild);
	  if(p->lchild)	   //左节点后入栈 因此栈顶保存的是最先需要访问的左子树根节点
		  S.push(p->lchild);
  }
  return ;
}

前序遍历-递归

void preOrder(treenode *root)
{	
  if(root) // 子树根节点不为空
  {
	  cout<<root->data <<" ";
	  preOrder(root->lchild);
	  preOrder(root->rchild);
  }
}

中序遍历-非递归（栈）

void inOrder(treenode *root) {
	if (root) {
		stack<treenode *> st;
		treenode *r = root;
		while (!st.empty() || r) {
			while (r) {
				st.push(r);			
				r = r->left;
			}
			if (!st.empty()) {  // 以上访问完左子树
				r = st.top();   // 逻辑整体与前序遍历差不多，只是在取出子树父节点的时候再进行节点访问
				cout << r->val; // 访问 上面访问完的左子树的 父亲节点
				st.pop();
				r = r->right;   // 同时中序遍历右子树
			}

		}
	}
}

中序遍历-递归

void inOrder(treenode *root)
{	
  if(root) // 子树根节点不为空
  {
	  inOrder(root->lchild);
	  cout<<root->data <<" ";
	  inOrder(root->rchild);
  }
}

后序遍历-非递归（栈）

void postOrder(treenode *root) {
	if (root) {
		stack<treenode *> st;
		treenode * r=root,*r=NULL; // r用来标记上一个访问过的子树的根节点
		while (r || !st.empty()) {
			if (r) { // 只要r不为空，循环放入左节点
				st.push(r);
				r = r->left;
			}
			else {
				 r = st.top(); // 1.当左节点为空或左子树遍历完，取出父节点r
				 if(r->right!=NULL&&r->right != p){ // 如果父节点r右节点不为空，且右节点不等p(即没有被访问过)
					r = r->right; // 2.则开始后序遍历右子树
				 }
				 else {
					 st.pop(); // 当左节点为空，且父节点没有右节点或者右子树已经被访问过了
					 cout << r->val; // 3.再访问当前子树根节点r，这棵以r为根的子树被遍历完了
					 p = r; // 当前子树标记为被遍历完
					 r = NULL; // r置为空就可以直接进入当前子树父节点的右子树开始遍历了
				 }
			}
		}

	}
}

后序遍历-递归

 void postOrder(treenode* root)
{	
  if(root)
  {
	  postOrder(root->lchild); 
	  postOrder(root->rchild);
	  cout<<root->data <<" ";
  }
}

层序遍历-非递归（队列）- LeetCode 求数的深度

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    int TreeDepth(TreeNode* pRoot)
    {
    	int res = 0;
        if(pRoot==NULL)return res;
        queue<TreeNode*> tq;
        TreeNode* r = pRoot;
        tq.push(r);
        while(!tq.empty()){
            int level_node_num = tq.size(); // 当前层有多少个节点
            if(level_node_num!=0)res++;
            while(level_node_num--){ // 循环遍历当前层的节点
                r = tq.front();
                cout<<r->val<<endl;  // 在这里执行访问节点r的操作
                // 从左至右 把下一层的节点都放入队列中
                if(r->left!=NULL)tq.push(r->left);
                if(r->right!=NULL)tq.push(r->right);
                tq.pop(); // 从左至右，要把当前层遍历过的节点弹出队列，好统计下一层的节点数量来遍历下一层
            }
        }
        return res;
    }
};

包含min函数的栈

class Solution {
public:
    stack<int>mins;// 使用mins栈来存储数据栈中每个状态的最小值
    stack<int>data;
    void push(int value) {
        data.push(value);
        if(mins.empty()){
            mins.push(value);
        }else{
            if(value<mins.top()){
                mins.push(value);
            }else{
                mins.push(mins.top());
            }
        }
    }
    void pop() {
        if(data.empty()||mins.empty())return;
        data.pop();
        mins.pop();
    }
    int top() {
        if(data.empty())return -1;
        return data.top();
    }
    int min() {
        return mins.top();
    }
};

用两个栈实现队列

class Solution
{
private:
    stack<int> stack1;
    stack<int> stack2;
public:
    void push(int node) {
        stack1.push(node);
    }

    int pop() { // 队列的pop要实现先进先出
        if(stack1.empty()){
            return -1;
        }
        while(!stack1.empty()){ // 把stack1栈底的元素变成stack2栈顶的元素
            stack2.push(stack1.top());
            stack1.pop();
        }
        int res = stack2.top();
        stack2.pop(); // pop后再把stack2中的元素从顶至底压回stack1中
        while(!stack2.empty()){
            stack1.push(stack2.top());
            stack2.pop();
        }
        return res;
    }
};