package com.algorithms;

import java.util.Stack;

public class BinaryTree {

    /**
     * 二叉树前序打印-递归实现
     *
     * @param node 根节点
     */
    public static void preSearch(Node node) {
        if (node == null) {
            return;
        }
        System.out.print(node.val + " ");
        preSearch(node.left);
        preSearch(node.right);
    }

    /**
     * 二叉树前序打印-遍历实现
     *
     * @param node 根节点
     */
    public static void preSearchV2(Node node) {
        Stack<Node> stack = new Stack<>();
        stack.add(node);
        while (!stack.empty()) {
            Node n = stack.pop();
            System.out.print(n.val + " ");
            if (n.right != null) {
                stack.add(n.right);
            }
            if (n.left != null) {
                stack.add(n.left);
            }
        }
    }

    /**
     * 二叉树中序打印-递归实现
     *
     * @param node 根节点
     */
    public static void midSearch(Node node) {
        if (node == null) {
            return;
        }
        midSearch(node.left);
        System.out.print(node.val + " ");
        midSearch(node.right);
    }

    /**
     * 二叉树中序打印-遍历实现
     *
     * @param node 根节点
     */
    public static void midSearchV2(Node node) {
        Stack<Node> stack = new Stack<>();
        while (!stack.empty() || node != null) {
            if (node != null) {
                stack.push(node);
                node = node.left;
            } else {
                node = stack.pop();
                System.out.print(node.val + " ");
                node = node.right;
            }
        }
    }

    /**
     * 二叉树后序打印-递归实现
     *
     * @param node 根节点
     */
    public static void postSearch(Node node) {
        if (node == null) {
            return;
        }
        postSearch(node.left);
        postSearch(node.right);
        System.out.print(node.val + " ");
    }

    /**
     * 二叉树后序打印-遍历实现
     *
     * @param node 根节点
     */
    public static void postSearchV2(Node node) {
        if (node == null) {
            return;
        }
        Stack<Node> stack = new Stack<>();
        Node c;
        stack.push(node);

        while (!stack.empty()) {
            c = stack.peek();
            if (c.left != node && c.left != null && node != c.right) {
                stack.push(c.left);
            } else if (c.right != node && c.right != null) {
                stack.push(c.right);
            } else {
                c = stack.pop();
                System.out.print(c.val + " ");
                node = c;
            }
        }
    }

    public static void main(String[] args) {
        Node root = new Node(1);
        Node n2 = new Node(2);
        Node n3 = new Node(3);
        root.left = n2;
        root.right = n3;
        Node n4 = new Node(4);
        Node n5 = new Node(5);
        n2.left = n4;
        n2.right = n5;
        Node n6 = new Node(6);
        Node n7 = new Node(7);
        n3.left = n6;
        n3.right = n7;
        Node n8 = new Node(8);
        Node n9 = new Node(9);
        n5.left = n8;
        n5.right = n9;

        preSearch(root);
        System.out.println();
        preSearchV2(root);
        System.out.println();
        System.out.println();
        midSearch(root);
        System.out.println();
        midSearchV2(root);
        System.out.println();
        System.out.println();
        postSearch(root);
        System.out.println();
        postSearchV2(root);
    }
}

private void swim(int k){
  while (k > 1 && less(k/2, k)){ // k/2即为父节点的索引
      exch(k/2, k); // 交换
      k = k/2;  // 把索引换成父节点，并继续循环比较父节点与它的父节点
  }
}

private void sink(int k){
  while (2*k <= N){
      int j = 2*k;
      if (j < N && less(j, j+1)) j++;  //使用子节点中比较大的那个
      if (!less(k, j)) break; // 如果比子节点大，退出
      exec(k, j); // 与子节点中比较大的那个交换
      k = j; // 使用交换后的索引继续下沉
  }
}

public static void sort(Comparable[] a){
  int N = a.length;
  for (int k = N/2; k >= 1; k--){ // 从拥有子节点的节点开始做sink操作，直到根节点
     sink(a, k, N); // 将数组构造为堆
  }

  while(N>1){
    exch(a, 1, N--); // 把根节点与堆最后一个节点进行交换
    sink(a, 1, N); // 进行下沉排序
  }
}

//FilterUtf8SizeGreaterThree mysql数据库utf8只能存储字节3的utf8数据，这里把不符合的字符过滤掉
func FilterUtf8SizeGreaterThree(content string) string {
	bf := bytes.NewBufferString("")
	for _, value := range content {
		if size := utf8.RuneLen(value); size <= 3 {
			bf.WriteRune(value)
		}
	}
	return bf.String()
}

kubectl apply -f deployment.yaml

kubectl apply -f myapp.yaml
if ! kubectl rollout status deployment myapp; then
    kubectl rollout undo deployment myapp
    kubectl rollout status deployment myapp
    exit 1
fi

生成指定名称ssh key命令：
ssh-keygen -t rsa -f ~/.ssh/id_rsa.key2 -C "email"

# github1
Host github1.com
HostName github.com
PreferredAuthentications publickey
IdentityFile ~/.ssh/id_rsa

# github2
Host github2.com
HostName github.com
PreferredAuthentications publickey
IdentityFile ~/.ssh/id_rsa.key2

测试key1：ssh -T [email protected]
测试key2：ssh -T [email protected]
测试命令成功时会返回ssh key对应的帐号信息

例：[email protected]:watermelon-ping/watermelon-ping.github.io.git
github1中的项目真实使用：[email protected]:watermelon-ping/watermelon-ping.github.io.git
github2中的项目真实使用：[email protected]:watermelon-ping/watermelon-ping.github.io.git

git remote set-url origin remote-url