牛客题目——链表中的结点每k个一组翻转、判断是不是二叉搜索树

---

题目1——链表中的结点每k个一组翻转

将给出的链表中的结点每k个一组反转，返回翻转后的链表，如果链表中的结点数不是k的倍数，将最后剩下的结点保持原样，不能更改结点中的值，只能更改结点本身。
要求：空间复杂度O(1)，时间复杂度O(n)。

示例
输入：{1,2,3,4,5}, 2
输出：{2,1,4,3,5}

解题思路

首先可以遍历整个链表，计算出链表的长度；根据链表长度可求得需要反转区间的个数；然后针对每个区间，反转区间；最后连接剩余的结点，返回最终链表。

推荐使用递归，将k个结点分成一组，每次反转一组中的k个结点（如果不够k个结点，应直接返回这个分组的头结点；否则进行反转操作，反转后，原来的头结点变成尾结点），然后反转后的分组尾部应该接下一组的反转结果，这样递归反转。

代码实现

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    public ListNode reverseKGroup (ListNode head, int k) {
        if(head == null || head.next == null || k==1)
            return head;
        ListNode pre = head;
        ListNode cur = head.next;
        ListNode temp = null;
        ListNode res = new ListNode(0);
        ListNode t = res;
        ListNode dummy = res;
        ListNode firstk = null;
        int length = 0;
        //计算链表的长度
        while(head!= null){
            length++;
            head = head.next;
        }
        //循环对几个反转
        for(int i=0;i<length/k;i++){
            firstk = pre;   //每个分组反转后的尾结点
            //针对每个区间进行反转
            for(int j=1;j<k;j++){
                temp = cur.next;
                cur.next = pre;
                pre = cur;
                cur = temp;
            }
            //与下一个分组衔接
            t.next = pre;
            t = firstk;
            pre = cur;
            if(cur != null)   
                cur = cur.next;
        }
        t.next = pre;  //连接剩下的结点
        return dummy.next;
    }
}

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    public ListNode reverseKGroup (ListNode head, int k) {
        ListNode tail = head;
        ListNode pre = null;
        ListNode cur = head;
        ListNode temp = null;
        for(int i=0;i<k;i++){
            if(tail == null)
                return head;
            tail = tail.next;
        }
        while(cur != tail){
            temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        head.next = reverseKGroup(tail,k);
        return pre;
    }
}

题目2——判断是不是二叉搜索树

给定一个二叉树根结点，请你判断这棵树是不是二叉搜索树。
二叉搜索树具有以下性质：
若它的左子树不为空，则左子树上的所有结点的值均小于它的根结点的值；若它的右子树不为空，则右子树上所有结点的值均大于它的根结点的值；
它的左、右子树也分别为二叉搜索树。

示例
输入：{1,2,3}
输出：false

解题思路

利用递归，因为二叉搜索树的特性就是中序遍历是一个递增序列，所以我们可以利用中序遍历，只要当前的结点的值大于之前结点的值，那么就可以继续判断，否则直接返回false。

采用非递归方式，利用栈对树进行中序遍历，然后检查遍历的序列是否是递增的，具体做法如下：

• 首先判断树是否为空，不遍历空树；
• 准备一个数组记录中序遍历的结果；
• 准备一个辅助栈，从根结点开始，每次优先进入每棵子树的左边结点，将其不断加入到栈中；
• 到达最左后，开始访问结点，如果它还有右节点，则将右节点也加入到栈中，之后右子树的访问也是优先到最左；
• 遍历数组，依次比较相邻两个元素是否为递增顺序。

代码实现

//采用递归方式
import java.util.*;
/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    int pre = Integer.MIN_VALUE;
    public boolean isValidBST (TreeNode root) {
        if(root == null)
            return true;
        //先进入左子树
        if(!isValidBST(root.left))
            return false;
        //如果当前结点的值小于之前结点的值，直接返回false
        if(root.val < pre)
            return false;
        pre = root.val;  //否则，更新pre结点的值
        return isValidBST(root.right);
    }
}

//采用非递归方式
import java.util.*;
/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */
public class Solution {
    public boolean isValidBST (TreeNode root) {
        if(root == null)
            return true;
        ArrayList<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> st = new Stack<TreeNode>();
        while(root != null || !st.empty()){
            while(root != null){
                st.push(root);
                root = root.left;
            }
            TreeNode temp = st.pop();
            res.add(temp.val);
            if(temp.right!=null)
                root = temp.right;
        }
        for(int i = 0;i<res.size()-1;i++){
            if(res.get(i)>=res.get(i+1))
                return false;
        }
        return true;
    }
}