2021/3/2 Practise sum up

Question 1

My way

PS: This way is slow
mimic the exchange way like bubble sort th exchange each group of element’s position.

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    ListNode* reverseKGroup(ListNode* head, int k) {
        if(k == 1){
            return head;
        }
        

        // count how many elements
        int n = 0;
        ListNode* cnt = head;
        while(cnt != NULL){
            cnt = cnt->next;
            n+=1;
        }
        if(k == 2){
            ListNode* start = new ListNode(0);
            start->next = head;
            ListNode* start1 = start;
            for(int i = 0; i<=n-2; i+= 2){
                
                ListNode* p = start->next;
                ListNode* q = start->next->next;
                
                // exchange
                p->next = q->next;
                q->next = p;
                start->next = q;
                
                for(int j = 0; j<2;j++){
                    start = start->next;
                    
                }
            }
            return start1->next;
        }
        
        // Similar to bubble sort
        ListNode* start = new ListNode(0);
        start->next = head;
        ListNode* start0 = start;
        
        for(int i = 0; i<=n-k; i+= k){
            ListNode* start1 = start;
            ListNode* start2 = start;
            for(int o = 0; o<k-1;o++){
                start1 = start2;
                for(int l = k-1; l > o; l--){
                    ListNode* p = start1->next;
                    ListNode* q = start1->next->next;
                    
                    p->next = q->next;
                    q->next = p;
                    start1->next = q;
                
                    start1 = start1->next;
                }
                
            }
            
            for(int j = 0; j < k;j++){
                start = start->next;
            }
        }
        return start0->next;
     
    }
};

A Better way

import java.util.*;
public class Solution {
    public ListNode reverseKGroup (ListNode head, int k) {
        if(head==null||head.next==null||k==1) return head;
        ListNode res = new ListNode(0);
        res.next = head;
        int length = 0;
        ListNode pre = res,
                 cur = head,
                 temp = null;
        while(head!=null){
            length++;
            head = head.next;
        }
        //分段使用头插法将链表反序
        for(int i=0; i<length/k; i++){
            //pre作为每一小段链表的头节点，负责衔接
            for(int j=1; j<k; j++){
                temp = cur.next;
                cur.next = temp.next;
                //相当于头插法，注意：
                //temp.next = cur是错误的，temp需要连接的不是前一节点，而是子序列的头节点
                temp.next = pre.next;
                pre.next = temp;
            }
            //每个子序列反序完成后，pre，cur需要更新至下一子序列的头部
            pre = cur;
            cur = cur.next;
        }
        return res.next;
    }
}

Question 2

Solve

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param root TreeNode类 
     * @return bool布尔型
     */
    // is symmetric left and right
    bool isSym(TreeNode* left, TreeNode* right){
        
        if(left == NULL && right == NULL){
            return true;
        }
        else if(left == NULL || right == NULL){
            return false;
        }
        else if(left->val == right->val && isSym(left->left,right->right) && isSym(left->right,right->left)){
            return true;
        }else{
            return false;
        }
    }
    bool isSymmetric(TreeNode* root) {
        // write code here
        if (root == NULL){   // 少了这句，导致段错误而过不了
            return true;
        }
        TreeNode* left = root->left;
        TreeNode* right = root->right;
        
        return isSym(left,right);
    }
};

lesson: Didn’t check whether root is NULL, which resulting to segmentation fault continously.

Solve with iteration

import java.util.*;
public class Solution {

    public boolean isSymmetric (TreeNode root) {

        if(root == null)
            return true;
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root.left);
        q.offer(root.right);

        while(!q.isEmpty()){
            TreeNode left = q.poll();
            TreeNode right = q.poll();
            if(left == null && right == null)
                continue;
            if(left == null || right == null)
                return false;
            if(left.val != right.val)
                return false;

            q.offer(left.left);
            q.offer(right.right);
            q.offer(left.right);
            q.offer(right.left);
        }
        return true;
    }


}