算法合集（五）

这一篇内容其实很久之前就已经开始动手了，但是由于这期间手上有一些项目需要忙，所以一直延误到现在，趁端午回家前赶紧写完。

三角形的最大周长

给定由一些正数（代表长度）组成的数组arr，返回由其中三个长度组成，面积不为0的三角形的最大周长。
如果不能形成任何面积不为0的三角形，则返回0。

实现

首先应该知道组成三角形的边长的条件，即任意两边之和必须大于第三边，任意两边之差必须小于第三边。在这里用到的是最长边一定大于其他两边的和。
思路：首先将数组进行排序，然后从最大的一位开始向前取三个数字来判断是否可以组成三角形，如果可以则直接返回三边之和。

package test;

import java.util.Arrays;

public class MaxPerimeter {
	
	public static int maxPerimeter(int[] arr) {
		//排序
		Arrays.sort(arr);
		//从后往前依次找，贪心
		for(int i = arr.length - 1; i >= 2; i--) {
			if(arr[i-1] + arr[i-2] > arr[i]) {
				return arr[i-1] + arr[i-2] + arr[i];
			}
		}
		return 0;

	}
	public static void main(String[] args) {
		int[] arr = new int[] {3,6,2,3};
		System.out.println(maxPerimeter(arr));
	}
}

二叉树遍历

关于前序、中序以及后序的算法思想不多赘述，懂的都懂。
另外，使用迭代的方式实现递归函数，与递归等价。

前序遍历

递归

package test;

public class BinaryTree {
	public static class TreeNode{
		int val;
		TreeNode left;
		TreeNode right;
		int deep;
		public TreeNode() {}
		public TreeNode(int val) {this.val=val;}
		public TreeNode(int val,TreeNode left,TreeNode right) {
			this.val = val;
			this.left = left;
			this.right = right;
		}
		
		
	}
	
	public static void main(String[] args) {
		TreeNode node7 = new TreeNode(7,null,null);
		TreeNode node6 = new TreeNode(6,null,null);
		TreeNode node5 = new TreeNode(5,node6,node7);
		TreeNode node4 = new TreeNode(4,null,null);
		TreeNode node3 = new TreeNode(3,null,null);
		TreeNode node2 = new TreeNode(2,node4,node5);
		TreeNode node1 = new TreeNode(1,node2,node3);
		preorder(node1);
	}
	
	public static void preorder(TreeNode root) {
		//如果为null则直接返回
		if(root == null) {
			return;
		}
		//将node1入栈并打印
		System.out.println(root.val);
		preorder(root.left);
		preorder(root.right);
	}
}

迭代

    //前序遍历 迭代
	public static void preorder2(TreeNode root) {
		if(root != null) {
			Stack<TreeNode> stack = new Stack<TreeNode>();
			stack.add(root);
			while(!stack.isEmpty()) {
				root = stack.pop();
				if(root != null) {
					System.out.println(root.val);
					//先入右节点再入左节点，后入先出
					stack.add(root.right);
					stack.add(root.left);
				}
				
			}
		}
	}

中序遍历

递归

    //中序遍历 第二次成为栈顶元素即打印
	public static void Inorder(TreeNode root) {
		//如果为null则直接返回
		if(root == null) {
			return;
		}
		Inorder(root.left);
		System.out.println(root.val);
		Inorder(root.right);
	}

迭代

    //中序遍历 递归
	public static void Inorder2(TreeNode root) {
		if(root != null) {
			Stack<TreeNode> stack = new Stack<TreeNode>();
			while(!stack.isEmpty()||root!=null) {
				if(root != null) {
					stack.push(root);
					root = root.left;
				}else {
					root = stack.pop();
					System.out.println(root.val);
					root = root.right;
				}
				
			}
		}
	}

后序遍历

递归

    //后序遍历 第三次成为栈顶元素即打印
	public static void Postorder(TreeNode root) {
		//如果为null则直接返回
		if(root == null) {
			return;
		}
		Postorder(root.left);
		Postorder(root.right);
		System.out.println(root.val);
	}

*迭代

    //后序遍历 迭代
	public static void Postorder2(TreeNode root) {
		if(root != null) {
			Stack<TreeNode> stack = new Stack<TreeNode>();
			TreeNode prev = null;
			while(!stack.isEmpty()||root!=null) {
				//找到最左边的子节点
				while(root != null) {
					stack.push(root);
					root = root.left;
				}
				root = stack.pop();
				if(root.right == null || root.right == prev) {
					System.out.println(root.val);
					prev = root;
					root = null;
				}else {
					stack.push(root);
					root = root.right;
				}
			}
		}
	}

层序遍历

递归

    //层序遍历
	public static void levelOrder(TreeNode root, int i,  ArrayList list) {
		if(root == null) {
			return;
		}
		//防止下标越界
		int length = list.size();
		if(length <= i) {
			for(int j = 0; j <= i - length; j++) {
				list.add(length + j, null);
			}
		}
		list.set(i, root.val);
		levelOrder(root.left,2*i,list);
		levelOrder(root.right,2*i+1,list);
	}

迭代

    //层序遍历 迭代
	public static void levelOrder2(TreeNode root) {
		Queue<TreeNode> q = new LinkedList<>();
		q.add(root);
		while(!q.isEmpty()) {
			TreeNode node = q.poll();
			if(node!=null) {
				System.out.println(node.val);
				q.add(node.left);
				q.add(node.right);
			}
		}
	}