Data structure: linked list, queue, stack

JZ24 reverse linked list

Niuke network link
Difficulty: simple

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
    //The initialization part (initialization pointer p,pre, etc.) sometimes needs to initialize q, pNext
    ListNode*p=pHead; //The base pointer p starts with the first element
    ListNode*pre=nullptr;  //pre is naturally initialized to nullptr
    ListNode*pNext=nullptr;
    while(p!=nullptr)//Traversal condition part
    {
        //Operation part
        pNext=p->next;
        p->next=pre;
        //Traversal iteration part
        pre=p;
        p=pNext;
     }
     return pre;
    }
};

Linked list is one of the basic data structures - linear list, and the other is sequential list. Common arrays and strings of all kinds of data are sequential lists. Therefore, the sequence table will not be specially investigated.
General solution of simple linked list problem
As shown in the above code, a simple linked list problem solving method often includes only one traversal of a single linked list. This traversal can complete the operations required by many problems (printing, inversion, summation, deletion, search, etc.)
The code template is as follows:
It is divided into initialization part and traversal part (the traversal condition and iteration part need not be higher)
Obviously, just changing the initialization and operation parts is enough

    //The initialization part (initialization pointer p,pre, etc.) sometimes needs to initialize q, pNext
    ListNode*p=pHead; //The base pointer p starts with the first element
    ListNode*pre=nullptr;  //pre is naturally initialized to nullptr
	Other pointer initialization (if necessary)
    while(p!=nullptr)//Traversal condition part
    {
        //Operation part
        adopt p,pre Wait for the pointer to perform operations on the linked list
        //Traversal iteration part
        pre=p;
        p=pNext;
     }
     //Now p=nullptr, pre

Data structure: graph theory, tree

JZ82 binary tree and path with a certain value (I)

Niuke network link
Difficulty: simple

Topic: given a binary tree root and a value sum, judge whether there is a path where the sum of node values from the root node to the leaf node is equal to sum.
1. The problem path is defined as the node from the root node of the tree to the leaf node
2. Leaf nodes refer to nodes without child nodes
3. The path can only be from parent node to child node, not from child node to parent node
4. The total number of nodes is n

class Solution {
public:
    /**
     * 
     * @param root TreeNode class 
     * @param sum int integer 
     * @return bool Boolean
     */
    bool hasPathSum(TreeNode* root, int sum) {
          //The idea of traversal with rLR
        if(root==nullptr)return false;
         return(rLR_path(root,sum,0));
              // write code here
    }
    bool rLR_path(TreeNode* root, int sum, int path_val)
    {
        if(root==nullptr)return false;
        path_val+=root->val;
        if(path_val==sum&&root->left==nullptr
           &&root->right==nullptr)return true;
        else 
            return rLR_path(root->left,sum,path_val)||
                rLR_path(root->right,sum,path_val);
    }
};

Idea: rRL traversal is enough (in fact, all four traversal methods are OK). Judge whether the current node is the root node and has accumulated just the right path length, otherwise continue to scan downward
Like the linked list problem, the simple data structure problem solution is a slight modification of the basic traversal algorithm
There are four traversal methods of binary tree: rLR, LrR, LRr and hierarchical traversal

PS: further optimization method: pruning algorithm. If the above termination conditions are not met and the current accumulated path length exceeds sum, it will directly return false and will not traverse the children of this node
Because the current problem solution has been passed, there is no further optimization

JZ34 binary tree and path with a certain value (2)

Compared with JZ82, the difficulty is further improved. It is required to return all qualified paths in the form of vector. It is necessary to use stack operations (push, pop) to backtrack, so as to verify and store feasible paths
That is, DFS with memory / DFs under global variables

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    vector<vector<int>> FindPath(TreeNode* root,int expectNumber) {
        if(root==nullptr)return{};
        vector<vector<int>> all_path={};
        CollectPath(root,expectNumber,all_path,{});//DFS from root
        return all_path;
        
    }
    //DFS function part: DFS with memory
    void CollectPath(TreeNode* root,int s,
                   vector<vector<int>>& all_path,vector<int> path)
    {
    	//First access the node itself
        if(root==nullptr)return;
        path.push_back(root->val);
        if(root->left==nullptr&&root->right==nullptr
           &&root->val==s)
            {all_path.push_back(path);//Storage feasible path
            return; }
        //Then access the left and right child nodes
        CollectPath(root->left, s-root->val, all_path, path);
        CollectPath(root->right, s-root->val, all_path, path);
        //Backtracking operation (when it is required to output all feasible paths of a single node, backtracking is required to verify - record nodes, that is, when DFS is required, backtracking is used to discard the "impassable" nodes)
        path.pop_back();
    }
};

Important: for binary trees, the most commonly used DFS method is rLR + backtracking (stack). The stack (vector) used for backtracking can be a global variable or a formal parameter (reference type should be used)

The general method of problem solving is:

Access the node itself, check the return condition - (no return) - > recursive call, access the left and right child nodes - (no return) - > backtracking (bounce stack)