뭐 검색하려고 했더라

오늘 아침부터 지금 두 문제 각 잡았다.

뭔가 둘 다 비슷해보여서 .. 이름도 비슷하고 ..

사실 지금 포스팅하는거는 며칠 전에 했는데 내 것으로 하기까지 시간이 걸렸다.

(어떤 분 것을 참고해 그냥 외웠다 .. 큰일이다 ..)

근데 만약 알고리즘 쉬면 못풀거같긴하다 ..

public List<TreeNode> generateTrees(int n) {
	return DFS(1, n);
}

public List<TreeNode> DFS(int start, int end) {
	List<TreeNode> answer = new ArrayList<>();
	if (start > end) {
		answer.add(null);
		return answer;
	}
	if (start == end) {
		answer.add(new TreeNode(start));
		return answer;
	}
	List<TreeNode> lt, rt;
	for (int i=start; i<=end; i++) {
		lt = DFS(start, i-1);
		rt = DFS(i+1, end);
		for (TreeNode x : lt) {
			for (TreeNode y : rt) {
				TreeNode tn = new TreeNode(i);
				tn.left = x;
				tn.right = y;
				answer.add(tn);
			}
		}
	}
	return answer;
}

이 문제는 인프런 선생님이 알려주신 문제 ...

혹시나 했는데 한방에 풀어서 다행이다.

===== 문제 =====

===== 답 =====

inorder traversal : 중위 순회

왼 -> root -> 오

import java.util.ArrayList;
import java.util.List;

static List<Integer> answer;
public List<Integer> inorderTraversal(TreeNode root) {
	answer = new ArrayList<>();
	DFS(root);
	return answer;
}
public void DFS(TreeNode root) {
	if (root == null) {
		return;
	} else {
		DFS(root.left);
		answer.add(root.val);
		DFS(root.right);
	}
}

끝 ..?

==========

마지막에 이렇게 하면 전위순회 (root -> 왼 -> 오)

answer.add(root.val);
DFS(root.left);
DFS(root.right);

이렇게 하면 후위순회 (왼 -> 오 -> root)

DFS(root.left);
DFS(root.right);
answer.add(root.val);

public int maxArea(int[] height) {
	int answer = 0;
	int start = 0, end = height.length-1;
	while (start < end) {
		answer = Math.max((end-start)*Math.min(height[start], height[end]), answer);
		if (height[start] < height[end]) {
			start++;
		} else {
			end--;
		}
	}
	return answer;
}

항상 목표는 시간이 얼마나 걸리더라도 스스로 푸는 것 ..

언젠가는 시간이 단축되게찌 .... ㅠㅠ

import java.util.Arrays;

public double findMedianSortedArrays(int[] nums1, int[] nums2) {
	double answer = 0L;
	int numsLen = nums1.length + nums2.length;
	int[] nums = new int[numsLen];
	System.arraycopy(nums1, 0, nums, 0, nums1.length);
	System.arraycopy(nums2, 0, nums, nums1.length, nums2.length);
	Arrays.sort(nums);
	if (numsLen%2 == 1) { // 홀수
		answer = nums[numsLen/2];
	} else { // 짝수
		double l = (nums[numsLen/2] + nums[numsLen/2 -1]);
		answer = l/2;
	}
	return answer;
}