## LeetCode 155. Min Stack (Java)

Source Url: https://leetcode-cn.com/problems/min-stack/

Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.

• push(x) — Push element x onto stack.
• pop() — Removes the element on top of the stack.
• top() — Get the top element.
• getMin() — Retrieve the minimum element in the stack.

## LeetCode 71. Simplify Path (Java)

Given an absolute path for a file (Unix-style), simplify it. Or in other words, convert it to the canonical path.

In a UNIX-style file system, a period `.` refers to the current directory. Furthermore, a double period `..` moves the directory up a level. For more information, see: Absolute path vs relative path in Linux/Unix

Note that the returned canonical path must always begin with a slash `/`, and there must be only a single slash `/` between two directory names. The last directory name (if it exists) must not end with a trailing `/`. Also, the canonical path must be the shortest string representing the absolute path.

## LeetCode 20. Valid Parentheses[stack] Java

Given a string containing just the characters `'('``')'``'{'``'}'``'['`and `']'`, determine if the input string is valid.

An input string is valid if:

1. Open brackets must be closed by the same type of brackets.
2. Open brackets must be closed in the correct order.

Note that an empty string is also considered valid.

## Stack and Queue Data Structure (Java code and Leetcode problems)

Stack and queue are dynamic data structures, both support delete operation.

## LeetCode 1122 Relative Sort Array [sort] java

Given two arrays `arr1` and `arr2`, the elements of `arr2` are distinct, and all elements in `arr2` are also in `arr1`.

Sort the elements of `arr1` such that the relative ordering of items in `arr1` are the same as in `arr2`.  Elements that don’t appear in `arr2`should be placed at the end of `arr1` in ascending order.

Example 1:

```Input: arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
Output: [2,2,2,1,4,3,3,9,6,7,19]
```

Constraints:

• `arr1.length, arr2.length <= 1000`
• `0 <= arr1[i], arr2[i] <= 1000`
• Each `arr2[i]` is distinct.
• Each `arr2[i]` is in `arr1`.

## LeetCode 973 K Closest Points to Origin [sort] java

We have a list of `points` on the plane.  Find the `K` closest points to the origin `(0, 0)`.

(Here, the distance between two points on a plane is the Euclidean distance.)

You may return the answer in any order.  The answer is guaranteed to be unique (except for the order that it is in.)

Example 1:

```Input: points = [[1,3],[-2,2]], K = 1
Output: [[-2,2]]
Explanation:
The distance between (1, 3) and the origin is sqrt(10).
The distance between (-2, 2) and the origin is sqrt(8).
Since sqrt(8) < sqrt(10), (-2, 2) is closer to the origin.
We only want the closest K = 1 points from the origin, so the answer is just [[-2,2]].
```

Example 2:

```Input: points = [[3,3],[5,-1],[-2,4]], K = 2
Output: [[3,3],[-2,4]]
(The answer [[-2,4],[3,3]] would also be accepted.)
```

Note:

1. `1 <= K <= points.length <= 10000`
2. `-10000 < points[i][0] < 10000`
3. `-10000 < points[i][1] < 10000`

## LeetCode 922 Sort Array By Parity II [sort] java

Given an array `A` of non-negative integers, half of the integers in A are odd, and half of the integers are even.

Sort the array so that whenever `A[i]` is odd, `i` is odd; and whenever `A[i]` is even, `i` is even.

You may return any answer array that satisfies this condition.

Example 1:

```Input: [4,2,5,7]
Output: [4,5,2,7]
Explanation: [4,7,2,5], [2,5,4,7], [2,7,4,5] would also have been accepted.```

## LeetCode 350 Intersection of Two Arrays II [sort] java

Given two arrays, write a function to compute their intersection.

Example 1:

```Input: nums1 = [1,2,2,1], nums2 = [2,2]
Output: [2,2]```

Example 2:

```Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
Output: [4,9]```

Note:

• Each element in the result should appear as many times as it shows in both arrays.
• The result can be in any order.

• What if the given array is already sorted? How would you optimize your algorithm?
• What if nums1‘s size is small compared to nums2‘s size? Which algorithm is better?
• What if elements of nums2 are stored on disk, and the memory is limited such that you cannot load all elements into the memory at once?

## LeetCode 349 Intersection of Two Arrays [sort] java

Given two arrays, write a function to compute their intersection.

Example 1:

```Input: nums1 = [1,2,2,1], nums2 = [2,2]
Output: [2]```

Example 2:

```Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
Output: [9,4]```

Note:

• Each element in the result must be unique.
• The result can be in any order.

## LeetCode 242 Valid Anagram [sort] java

Source URL: https://leetcode.com/problems/valid-anagram/

Given two strings s and , write a function to determine if t is an anagram of s.

Example 1:

```Input: s = "anagram", t = "nagaram"
Output: true
```

Example 2:

```Input: s = "rat", t = "car"
Output: false
```

Note:
You may assume the string contains only lowercase alphabets.