public void setData(int data) {
this.data = data;
}
public TreeNode getLeftNode() {
return leftNode;
}
public void setLeftNode(TreeNode leftNode) {
this.leftNode = leftNode;
}
public TreeNode getRightNode() {
return rightNode;
}
public void setRightNode(TreeNode rightNode) {
this.rightNode = rightNode;
}
}
//先序遍历——递归方法
public static void preOrder(TreeNode root) {
if (root != null) {
System.out.print(root.data + "\t");
preOrder(root.leftNode);
preOrder(root.rightNode);
}
}
//先序遍历——非递归方法
public static void preOrderNonRecursive(TreeNode root) {
//栈——先入后出
Stack<TreeNode> stack = new Stack<>();
while (true) {
while (root != null) {
System.out.print(root.data + "\t");
stack.push(root);
root = root.getLeftNode();
}
if (stack.isEmpty()) break;
root = stack.pop();
root = root.getRightNode();
}
}
//中序遍历
public static void inOrder(TreeNode root) {
if (root != null) {
inOrder(root.leftNode);
System.out.print(root.data + "\t");
inOrder(root.rightNode);
}
}
//后序遍历
public static void postOrder(TreeNode root) {
if (root != null) {
inOrder(root.leftNode);
inOrder(root.rightNode);
System.out.print(root.data + "\t");
}
}
//中序遍历——非递归方法
public static void inOrderNonRecursive(TreeNode root) {
Stack<TreeNode> stack = new Stack<>();
while (true) {
while (root != null) {
stack.push(root);
root = root.getLeftNode();
}
if (stack.isEmpty()) break;
root = stack.pop();
System.out.print(root.data + "\t");
root = root.getRightNode();
}
}
//层序遍历（逐层打印）：层序遍历用到了队列，而先、中、后序需要用到栈。
public static void levelOrder(TreeNode root) {
TreeNode temp;
Queue<TreeNode> queue = new LinkedList<>();
//offer方法和add方法都是往队列尾部插入元素，但当超出队列界限时，offer方法返回false，add方法抛异常
queue.offer(root);
while (!queue.isEmpty()) {
temp = queue.poll();
System.out.print(temp.data + "\t");
if (temp.getLeftNode() != null) {
queue.offer(temp.getLeftNode());
}
if (temp.getRightNode() != null) {
queue.offer(temp.getRightNode());
}
}
}
public static void main(String[] args) {
TreeNode root = new TreeNode(57);
root.leftNode = new TreeNode(48);
root.leftNode.leftNode = new TreeNode(34);
root.leftNode.rightNode = new TreeNode(49);
root.rightNode = new TreeNode(77);
//先序遍历
System.out.println("先序遍历：");
preOrder(root);
System.out.println();
//先序遍历——非递归
preOrderNonRecursive(root);
System.out.println();
//层序遍历
System.out.println("层序遍历：");
levelOrder(root);
System.out.println();
//后序遍历
System.out.println("后序遍历：");
postOrder(root);
System.out.println();
}
}
2、链表的查询算法？
链表的经典算法题链接：[链表算法经典十题总结 - 辰砂tj - 博客园](https://gitee.com/vip204888)
3、限流算法？令牌桶的不足？
在大型电商等系统中,我们回努力提升API的吞吐量和QPS(Query Per Second 每秒查询量)，但总归有上限.为了应对巨大流量的瞬间提交，我们会做对应的限流处理。常见的限流算法有：计数器，漏桶，令牌桶。
* 计数器算法：一次访问设置一次计数，在系统内设置每秒的访问量，超过访问量的访问直接丢弃。弊端是在开始的时间，访问量被使用完后，1S内会有长时间的真空期是处于接口不可用的状态的。
* 漏斗算法：大批量访问进入时，漏斗有容量，不超过容量(容量的设计=固定处理的访问量\*可接受等待时长)的数据都可以排队等待处理，超过的才会丢弃。缺点无法应对短时间的突发流量。
* 令牌桶算法：按照一定的速率生成令牌放入令牌桶,访问要进入系统时,需要从令牌桶获取令牌,有令牌的可以进入,没有的被抛弃。由于令牌桶的令牌是源源不断生成的,当访问量小时,可以留存令牌达到令牌桶的上限,这样当短时间的突发访问量来时,积累的令牌数可以处理这个问题。当访问量持续大量流入时,由于生成令牌的速率是固定的,最后也就变成了类似漏斗算法的固定流量处理。
令牌桶的实现类似于漏斗，使用一个队列保存令牌，一个定时任务用等速率生成令牌放入队列，访问量进入系统时，从队列获取令牌再进入系统。
4、微博限定用户输入140字符，如果用户输入一个很长的字符串链接，怎么办？
**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！**
**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**
**[如果你需要这些资料，可以戳这里获取](https://gitee.com/vip204888)**
