Python 每日一记248>>>Java二叉树实现折纸问题

一、什么是折纸问题

上图摘自B站学习视频，再简单描述一下，将一张纸放在桌面上，为了方便，定义方向：
靠近你的方向是—近
远离你的方向是—远
左边方向是—左
右边方向是—右
纸面朝上方向是—上
纸面朝下方向是—下
从后往前折叠，折叠完毕后，原路展开，不要旋转也不要翻面，然后就会看到折痕，从远往近的折痕就是我们要输出的折痕，假如折叠了两次，那么折痕从远到近就是down—down—up。
要模拟成树的结构，先把纸顺时针旋转90度，直到正对你的是原来的右方向，然后翻面（左右翻转，而不是远近翻转），这个时候就变成了树结构，每个节点左节点都是down，右节点都是up。

二、Java代码实现

package mypackage;

import java.util.Iterator;

//队列类，用链表实现,遍历二叉树时需要用来装键
class Queue<T> implements Iterable<T>{
//    节点个数，头节点，尾节点
    private int N;
    private Node head;
    private Node last;
//节点类
    public class Node {
        public T data;
        public Node next;

        public Node(T data, Node next) {
            this.data = data;
            this.next = next;
        }
    }
//构造方法，初始化
    public Queue() {
        this.N = 0;
        this.head = new Node(null,null);
        this.last = null;
    }
//队列长度
    public int size(){
        return N;
    }
//队列是否为空
    public boolean isEmpty(){
        return N==0;
    }
//入队列
    public void enqueue(T data){
//        如果队列为空，说明尾节点为空，让新节点为尾节点，头借点指向尾节点
        if (isEmpty()){
            last=new Node(data,null);
            head.next=last;
//            如果队列不为空，让新节点为尾节点，老的尾节点指向新尾节点
        }else {
            Node oldlast=last;
            last=new Node(data,null);
            oldlast.next=last;
        }
//        最后元素+1
        N++;
    }
//出队列，注意先入先出，每次出的节点就是head指向的第一个节点，然后让head只想第二个节点即可
//    且注意，如果队列为空，要将last=null
    public T dequeue(){
//        如果为空，返回null
        if (isEmpty()){
            return null;
//            如果不为空，让head只想第二个节点，元素-1，且如果队列为空，要将last=null
        }else {
            Node oldfirst=head.next;
            head.next=oldfirst.next;
            N--;

            if (isEmpty()){
                last=null;
            }
//            返回弹出的元素
            return oldfirst.data;
        }
    }

    //    遍历
    @Override
    public Iterator iterator() {
        return new QIterator();
    }
    //    创建一个内部类实现Iterator接口
    public class QIterator implements Iterator {
        //        定义一个遍历的节点
        private Node n;

        public QIterator() {
//            初始化为0索引位置
            this.n = head;
        }

        //重写两个方法
        @Override
        public boolean hasNext() {
//            这个方法判断是否超出最大索引，如果超出会停止遍历
            return n.next != null;
        }

        @Override
        public Object next() {
//            这个方法会遍历得每个节点
            n = n.next;
            return n.data;
        }
    }
}


//测试
public class MyJava {

    public static void main(String[] args) {
//        返回树，其实是根节点
        Node tree=createtree(2);
        System.out.println("折叠2次，折痕从远到近依次如下:");
//        打印树，传入根节点
        midergodicPrint(tree);
    }
//    模拟折纸产生树,N为折叠次数，第一次折叠，为根节点down，此后每折叠一次，会将叶子节点左节点赋值为down，右节点赋值为up
    public static Node<String> createtree(int N){
//        定义根节点
        Node<String> root=null;
//        循环折叠次数
        for (int i = 1; i <=N ; i++) {
//            第一次折叠
            if (i==1){
                root=new Node<String>("down",null,null);
//             非第一次折叠，开始循环
            } else {
//                采用层序循环为叶子节点添加左右节点
//                先定义一个队列，用于层序循环
                Queue<Node> queue=new Queue<>();
//                先将root装进队列
                queue.enqueue(root);
//                如果队列不为空，开始循环，
//                循环中要经历的步骤为：
//                1、弹出队列中的一个元素
//                2、判断如果有左节点，将左节点加入到队列中
//                3、判断如果有右节点，将右节点加入到队列中
//                4、判断如果没有左右节点，将左节点赋值为down,右节点赋值为up
//                5、循环完毕后，返回根节点，后续通过这个根节点就可以遍历所有的节点
                while (!queue.isEmpty()){

                    Node node=queue.dequeue();
                    if (node.left!=null){
                        queue.enqueue(node.left);
                    }
                    if (node.right!=null){
                        queue.enqueue(node.right);
                    }
                    if (node.left==null&&node.right==null){
                        node.left=new Node("down",null,null);
                        node.right=new Node("up",null,null);
                    }
                }
            }
        }
//        返回根节点，代表整个数
        return root;
    }

//  遍历树并打印，采用中序遍历，左子树-根节点-右子树
    public static void midergodicPrint(Node<String> node){
//        如果为空，直接返回
        if (node==null){
            return;
        }
//        递归左子树
        if (node.left!=null){
            midergodicPrint(node.left);
        }
//        打印根节点
        System.out.print(node.data+"---");
//        递归左子树
        if (node.right!=null){
            midergodicPrint(node.right);
        }
    }
//    节点类
    public static class Node<T> {
        public T data;
        public Node left;
        public Node right;

        public Node( T data, Node left,Node right) {
            this.data = data;
            this.left =left;
            this.right =right;
        }
    }
}

结果：
PS：折痕是从远到近距
折叠2次：

折叠3次：