剑指offer(61-66)编程题

61、请实现两个函数，分别用来序列化和反序列化二叉树。
62、给定一棵二叉搜索树，请找出其中的第k小的结点。例如，（5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。
64、给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。

61、请实现两个函数，分别用来序列化和反序列化二叉树。

二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。

二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。

初始：

public class Solution {
    String Serialize(TreeNode root) {
        
  }
    TreeNode Deserialize(String str) {
       
  }
}

代码：

class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}

public class Solution {

    // 便于反序列化的操作
    int index = -1;// 不要 private static int index = -1 ,在牛客网这种写法会报错（非常的奇怪）

    String Serialize(TreeNode root) {

        // 创建结果集对象
        StringBuilder sb = new StringBuilder();

        // 递归的出口
        if (root == null) {
            sb.append("#!");// 序列化时通过某种符号表示空节点（#）
            return sb.toString();
        }

        sb.append(root.val + "!");// 若为非空节点，则输入“值!”
        sb.append(Serialize(root.left));// 递归序列化左子树
        sb.append(Serialize(root.right));// 递归序列化右子树

        return sb.toString();
    }

    TreeNode Deserialize(String str) {
        
        if (str == null || str.length() == 0) {
            return null;
        }

        String[] arr = str.split("!");// 分隔字符串

        index++;

        // 临界值
        if (index >= arr.length) {
            return null;
        }

        if ("#".equals(arr[index])) {
            return null;
        }

        TreeNode ans = new TreeNode(Integer.parseInt(arr[index]));// 重构二叉树
        ans.left = Deserialize(str);
        ans.right = Deserialize(str);

        return ans;

    }
}

62、给定一棵二叉搜索树，请找出其中的第k小的结点。例如，（5，3，7，2，4，6，8）    中，按结点数值大小顺序第三小结点的值为4。

思路：对于一个二叉搜索树而言，如果进行中序遍历，就可以获得从小到大排列的结点序列，然后只需返回指定的第k小的结点即可。

import java.util.ArrayList;

class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}

public class Solution {

    ArrayList<TreeNode> ans = new ArrayList<TreeNode>();

    TreeNode KthNode(TreeNode pRoot, int k) {

        // 中序遍历
        InOrder(pRoot);

        if (k <= 0 || k > ans.size()) {
            return null;
        }

        // 返回第k小的数
        return ans.get(k - 1);

    }

    // 中序遍历
    public void InOrder(TreeNode root) {

        if (root == null) {
            return;
        }

        InOrder(root.left);
        ans.add(root);
        InOrder(root.right);
    }

}

64、给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个： {[2,3,4],2,6,2,5,1}， {2,[3,4,2],6,2,5,1}， {2,3,[4,2,6],2,5,1}， {2,3,4,[2,6,2],5,1}， {2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。

分析：这道题注意通过滑动窗口的大小和数组的长度确认总轮数，为 num.length - size +1 次。然后比较每轮的最大值，比较过程可以借用选择排序思想。

import java.util.ArrayList;

public class Solution {
    public ArrayList<Integer> maxInWindows(int[] num, int size) {

        // 结果集对象
        ArrayList<Integer> ans = new ArrayList<Integer>();

        if (num == null || num.length == 0 || size == 0 || size > num.length) {
            return ans;
        }

        // 存储每次窗口中的最大值
        int curMax = 0;

        for (int i = 0; i <= num.length - size; i++) {// 控制轮数

            curMax = num[i];
            for (int j = i; j < i + size; j++) {
                if (num[j] > curMax) {
                    curMax = num[j];
                }
            }

            // 加入到结果集当中
            ans.add(curMax);
        }
        return ans;
    }
}

方式二：

import java.util.ArrayList;
import java.util.Arrays;

public class Solution {
    public ArrayList<Integer> maxInWindows(int[] num, int size) {

        // 创建结果集对象
        ArrayList<Integer> ans = new ArrayList<Integer>();

        if (size == 0) {
            return ans;
        }

        for (int i = 0; i < num.length - size + 1; i++) {
            int val = getMax(num, i, i + size);
            ans.add(val);
        }

        return ans;
    }

    public static int getMax(int[] num, int x, int y) {
        int[] arr = Arrays.copyOfRange(num, x, y); //包头不包尾
        Arrays.sort(arr);
        return arr[arr.length - 1];
    }
}