@Test
public void Deque_addLast_AddsTwo() {
deque.addLast("firstString");
deque.addLast("secondString");
assertFalse(deque.isEmpty());
assertEquals(deque.size(), 2);
}
/**
* @param instanceFrame instance frame
* @return iterable over instance members of the frame, including those nested in namespaces
*/
public static Iterable<? extends INamedElement> instanceMembers(
final IInstanceFrame instanceFrame) {
final List<INamedElement> members = new ArrayList<>();
// Iterate over the member functions of the frame, including those nested in namespaces.
final Deque<INamedElement> queue = new LinkedList<>();
queue.addLast(instanceFrame);
while (!queue.isEmpty()) {
final INamedElement cur = queue.getFirst();
queue.removeFirst();
final INamedElementContainer contCur = (INamedElementContainer) cur;
for (final INamedElement member : contCur.members())
if (Ast.membership(member)
== (contCur == instanceFrame
? ScopeMembership.InstanceMember
: ScopeMembership.StaticMember)) {
members.add(member);
if (member instanceof INamedElementContainer) {
// Tail-recursively treat this nested namespace.
queue.addLast(member);
}
}
}
return members;
}
// Method 2: BFS Solution
public boolean validTreeII(int n, int[][] edges) {
int[] visited = new int[n];
List<List<Integer>> adjList = new ArrayList<>();
for (int i = 0; i < n; ++i) {
adjList.add(new ArrayList<Integer>());
}
for (int[] edge : edges) {
adjList.get(edge[0]).add(edge[1]);
adjList.get(edge[1]).add(edge[0]);
}
Deque<Integer> q = new LinkedList<Integer>();
q.addLast(0);
visited[0] = 1; // vertex 0 is in the queue, being visited
while (!q.isEmpty()) {
Integer cur = q.removeFirst();
for (Integer succ : adjList.get(cur)) {
if (visited[succ] == 1) {
return false;
} // loop detected
if (visited[succ] == 0) {
q.addLast(succ);
visited[succ] = 1;
}
}
visited[cur] = 2; // visit completed
}
for (int v : visited) {
if (v == 0) {
return false;
}
} // # of connected components is not 1
return true;
}
public static void main(String[] args) {
Deque<Integer> ints = new Deque<Integer>();
assert ints.size() == 0;
assert ints.isEmpty();
ints.addFirst(1);
assert ints.size() == 1;
assert !ints.isEmpty();
int val = ints.removeFirst();
assert val == 1;
assert ints.size() == 0;
assert ints.isEmpty();
ints.addFirst(2);
assert ints.size() == 1;
assert !ints.isEmpty();
val = ints.removeLast();
assert val == 2;
assert ints.size() == 0;
assert ints.isEmpty();
ints.addFirst(3);
ints.addFirst(2);
ints.addFirst(1);
ints.addLast(4);
ints.addLast(5);
ints.addLast(6);
assert ints.size() == 6;
assert !ints.isEmpty();
for (int value : ints) {
StdOut.print(value + " ");
}
StdOut.println();
while (!ints.isEmpty()) {
StdOut.println(ints.removeLast());
}
assert ints.size() == 0;
assert ints.isEmpty();
for (int i = 0; i < 10; ++i) {
ints.addFirst(i);
}
for (int i = 0; i < 10; ++i) {
assert ints.size() == 10 - i;
ints.removeLast();
}
assert ints.size() == 0;
}
public static boolean bfsIterative(TreeNode root, int val) {
Deque<TreeNode> s = new LinkedList<>();
s.push(root);
while (!s.isEmpty()) {
TreeNode curr = s.removeFirst();
if (curr.left != null) s.addLast(curr.left);
if (curr.right != null) s.addLast(curr.right);
if (curr.value == val) return true;
}
return false;
}
@Test
public void testAddLastAndRemoveLastAll() {
deque.addLast("1");
deque.addLast("2");
deque.addLast("3");
deque.addLast("4");
assertEquals(deque.removeLast(), "4");
assertEquals(deque.removeLast(), "3");
assertEquals(deque.removeLast(), "2");
assertEquals(deque.removeLast(), "1");
}
@Test
public void Deque_addLast_removeLast_AddsRemovesTwo() {
deque.addLast("firstString");
deque.addLast("secondString");
assertFalse(deque.isEmpty());
assertEquals(deque.size(), 2);
String returnedString = deque.removeLast();
assertEquals(returnedString, "secondString");
assertFalse(deque.isEmpty());
assertEquals(deque.size(), 1);
returnedString = deque.removeLast();
assertEquals(returnedString, "firstString");
assertTrue(deque.isEmpty());
assertEquals(deque.size(), 0);
}
private List<List<Integer>> help1(TreeNode root) {
List<List<Integer>> res = new ArrayList<List<Integer>>();
if (root == null) {
return res;
}
Deque<TreeNode> current = new LinkedList<>();
Deque<TreeNode> next = new LinkedList<>();
boolean isOdd = true;
current.add(root);
while (!current.isEmpty()) {
int size = current.size();
List<Integer> level = new LinkedList<Integer>();
if (isOdd) {
for (int i = 0; i < size; i++) {
TreeNode top = current.removeFirst();
level.add(top.val);
if (top.left != null) {
next.addLast(top.left);
}
if (top.right != null) {
next.addLast(top.right);
}
}
} else {
for (int i = 0; i < size; i++) {
TreeNode top = current.removeLast();
level.add(top.val);
if (top.right != null) {
next.addFirst(top.right);
}
if (top.left != null) {
next.addFirst(top.left);
}
}
}
isOdd = !isOdd;
current = next;
res.add(level);
}
return res;
}
@Test
public void testIsEmpty() {
Deque<String> deque = new Deque<String>();
assertTrue(deque.isEmpty());
deque.addFirst(new String("test first"));
deque.addLast(new String("test last"));
deque.addLast(new String("test last"));
deque.addFirst(new String("test first"));
deque.addLast(new String("test last"));
assertFalse(deque.isEmpty());
deque.removeFirst();
deque.removeFirst();
deque.removeFirst();
deque.removeLast();
deque.removeLast();
assertTrue(deque.isEmpty());
}
@Test
public void testOneEmptyOne() {
deque.addFirst("1");
assertEquals(deque.removeFirst(), "1");
deque.addLast("2");
}
public List<String> removeInvalidParentheses(String s) {
// 由于是去掉最少的括号,所以以去掉括号的个数为BFS的层数.通过记录的方式减少不必要的访问(重复的访问子树),缩短时间的关键是备忘memorized
// 标记在某一level是否已经找到一个合法的string,且其值表示在哪一level找到
int flag = -1;
// 全局hashset,用作去重
Set<String> gset = new HashSet<String>();
Set<String> output = new HashSet<String>();
// 初始化BFS的队列Q
Deque<Node> q = new ArrayDeque<Node>();
Node root = new Node(s, 0);
q.addLast(root);
while (!q.isEmpty()) {
Node u = q.removeFirst();
String subs = u.s;
// 说明已经找到全部,返回结果即可,这里很巧妙
if ((u.depth == (flag + 1)) && flag != -1) {
break;
}
if (checkValid(subs) == 0) {
// 说明合法,结束本次循环,并不检测深一层的子树,但要检测完同一level的所有节点
if (flag == -1) flag = u.depth;
output.add(subs);
continue;
} else {
// u.s无效,分两种情况讨论:a.flag==-1,说明还没找到合适的,所以要将子树都填加 b.flag!=-1,说明在该level已经找到,不必再添加子树
if (flag != -1) {
continue;
} else {
for (int i = 0; i < subs.length(); i++) {
StringBuilder sb = new StringBuilder(subs);
sb.deleteCharAt(i);
String ssubs = sb.toString();
if (!gset.contains(ssubs)) {
gset.add(ssubs);
Node n = new Node(ssubs, u.depth + 1);
q.addLast(n);
}
}
}
}
}
return new ArrayList<String>(output);
}
/**
* @param fn function
* @return eventual overrides of the function, unifying those differing only in generic derivation
*/
public static Iterable<? extends IFunction> eventualOverrides(final IFunction fn) {
// Iterate over the eventually overridden functions,
// unifying those differing only through generic derivation.
final Set<IFunction> processedEO = new LinkedHashSet<>();
final Deque<IFunction> queueEO = new LinkedList<>();
queueEO.addLast(fn);
while (!queueEO.isEmpty()) {
final IFunction fnEO = queueEO.getFirst();
queueEO.removeFirst();
if (!processedEO.contains(fnEO)) {
processedEO.add(fnEO);
// Tail-recurse on the function's direct overrides.
for (final ResolvedName directOverride : fnEO.directOverrides())
queueEO.addLast((IFunction) directOverride.namedElement());
}
}
return processedEO;
}
@Test
public void testAddition() {
Deque<String> deque = new Deque<String>();
deque.addFirst(new String("test"));
assertFalse(deque.isEmpty());
deque.addFirst(new String("test first"));
deque.addLast(new String("test last"));
assertEquals(deque.size(), 3);
}
@Test
public void testAddLastAndAddFirstWithRemoveLast() {
deque.addLast("4");
deque.addLast("5");
deque.addLast("6");
deque.addLast("7");
deque.addFirst("3");
deque.addFirst("2");
deque.addFirst("1");
assertEquals(deque.removeLast(), "7");
assertEquals(deque.removeLast(), "6");
assertEquals(deque.removeLast(), "5");
assertEquals(deque.removeLast(), "4");
assertEquals(deque.removeLast(), "3");
assertEquals(deque.removeLast(), "2");
assertEquals(deque.removeLast(), "1");
}
@Test(expected = UnsupportedOperationException.class)
public void testRemoveFromIterator() {
Deque<String> deque = new Deque<String>();
deque.addFirst("middle");
deque.addLast("last");
deque.addFirst("first");
Iterator<String> i = deque.iterator();
i.next();
i.remove(); // should throw exception
}
@Test(expected = NoSuchElementException.class)
public void testNextFromEmptyIterator() {
Deque<String> deque = new Deque<String>();
deque.addLast("last");
deque.addFirst("first");
Iterator<String> i = deque.iterator();
i.next();
i.next();
i.next(); // should throw exception
}
@Test
public void testAdditionReverseOrdered() {
Deque<Integer> deque = new Deque<Integer>();
for (int i = 0; i < 10; i++) {
deque.addLast(i);
}
for (int i = 0; i < 10; i++) {
assertEquals(deque.removeFirst(), new Integer(i));
}
}
@Test
public void Deque_iterator_iterates() {
deque.addFirst("firstString");
deque.addFirst("secondString");
deque.addLast("thirdString");
Iterator<String> dequeIterator = deque.iterator();
assertEquals(dequeIterator.next(), "secondString");
assertEquals(dequeIterator.next(), "firstString");
assertEquals(dequeIterator.next(), "thirdString");
}
public boolean getNextBlock() throws IOException {
if (curRangeIndex < 0 || curRangeIndex >= indexes.size()) return false;
/* seek to the correct offset to the data, and calculate the data size */
IndexHelper.IndexInfo curColPosition = indexes.get(curRangeIndex);
/* see if this read is really necessary. */
if (reversed) {
if ((finishColumn.length > 0
&& comparator.compare(finishColumn, curColPosition.lastName) > 0)
|| (startColumn.length > 0
&& comparator.compare(startColumn, curColPosition.firstName) < 0)) return false;
} else {
if ((startColumn.length > 0 && comparator.compare(startColumn, curColPosition.lastName) > 0)
|| (finishColumn.length > 0
&& comparator.compare(finishColumn, curColPosition.firstName) < 0)) return false;
}
boolean outOfBounds = false;
// seek to current block
// curIndexInfo.offset is the relative offset from the first block
file.seek(firstBlockPos + curColPosition.offset);
// read all columns of current block into memory!
DataInputStream blockIn =
ColumnFamily.serializer()
.getBlockInputStream(file, curColPosition.sizeOnDisk, compressContext);
try {
int size = 0;
while ((size < curColPosition.width) && !outOfBounds) {
IColumn column = emptyColumnFamily.getColumnSerializer().deserialize(blockIn);
size += column.serializedSize();
if (reversed) blockColumns.addFirst(column);
else blockColumns.addLast(column);
/* see if we can stop seeking. */
if (!reversed && finishColumn.length > 0)
outOfBounds = comparator.compare(column.name(), finishColumn) >= 0;
else if (reversed && startColumn.length > 0)
outOfBounds = comparator.compare(column.name(), startColumn) >= 0;
if (outOfBounds) break;
}
} catch (IOException e) {
logger.error(e.toString());
throw e;
} finally {
ColumnFamily.serializer().releaseBlockInputStream(blockIn, compressContext);
}
if (reversed) curRangeIndex--;
else curRangeIndex++;
return true;
}
@Test(expected = NoSuchElementException.class)
public void testRemoveLastFromEmptyDeque() {
Deque<Integer> deque = new Deque<Integer>();
int count = 10;
for (int i = 0; i < count; i++) {
deque.addLast(i);
}
for (int i = 0; i < count; i++) {
deque.removeLast();
}
deque.removeLast(); // should throw
}
@Test
public void testRemove() {
Deque<String> deque = new Deque<String>();
deque.addFirst(new String("test"));
deque.addFirst(new String("test first"));
deque.addLast(new String("test last"));
deque.removeLast();
deque.removeFirst();
assertTrue(deque.size() == 1);
deque.removeLast();
assertTrue(deque.size() == 0);
}
public static void main(String[] args) {
Deque<String> myDeque = new Deque<String>();
String[] str = new String[] {"Jrui", "Long", "Jason"};
myDeque.addFirst(str[0]);
myDeque.addLast(str[2]);
myDeque.addFirst(str[1]);
Iterator<String> test = myDeque.iterator();
while (test.hasNext()) {
String s = test.next();
StdOut.println(s);
}
}
public int[] maxSlidingWindow(int[] nums, int k) {
if (nums == null || nums.length == 0) return new int[0];
int[] result = new int[nums.length + 1 - k];
Deque<Integer> dq = new LinkedList<Integer>();
for (int i = 0, j = 1 - k; i < nums.length; i++, j++) {
if (!dq.isEmpty() && dq.peekFirst() <= i - k) dq.removeFirst();
while (!dq.isEmpty() && nums[dq.peekLast()] <= nums[i]) dq.removeLast();
dq.addLast(i);
if (j >= 0) result[j] = nums[dq.peekFirst()];
}
return result;
}
public static void main(String[] args) {
Deque<String> d = new Deque<String>();
d.addFirst("1");
d.addFirst("2");
d.addFirst("3");
d.addLast("7");
d.removeFirst();
d.removeFirst();
for (String s : d) {
System.out.println(s);
}
}
public static void main(String[] args) { // unit testing
Deque<String> d = new Deque<String>();
d.addFirst("sant");
d.addLast("prakash");
d.addFirst("sid");
for (String s : d) StdOut.println(s);
StdOut.println("removing last");
StdOut.println(d.removeLast());
StdOut.println("resulting list");
for (String s : d) StdOut.println(s);
StdOut.println("removing fist");
StdOut.println(d.removeFirst());
StdOut.println("resulting list");
for (String s : d) StdOut.println(s);
}
@Test
public void test10() {
deque = new Deque<String>();
deque.addFirst("1");
deque.addFirst("2");
deque.addFirst("3");
deque.addFirst("4");
assertEquals(deque.removeLast(), "1");
assertEquals(deque.removeFirst(), "4");
deque.addLast("7");
assertEquals(deque.removeLast(), "7");
assertEquals(deque.removeLast(), "2");
assertEquals(deque.removeLast(), "3");
assertEquals(deque.size(), 0);
}
public boolean getNextBlock() throws IOException {
if (curRangeIndex < 0 || curRangeIndex >= indexes.size()) return false;
/* seek to the correct offset to the data, and calculate the data size */
IndexHelper.IndexInfo curColPosition = indexes.get(curRangeIndex);
/* see if this read is really necessary. */
if (reversed) {
if ((finishColumn.length > 0
&& comparator.compare(finishColumn, curColPosition.lastName) > 0)
|| (startColumn.length > 0
&& comparator.compare(startColumn, curColPosition.firstName) < 0)) return false;
} else {
if ((startColumn.length > 0 && comparator.compare(startColumn, curColPosition.lastName) > 0)
|| (finishColumn.length > 0
&& comparator.compare(finishColumn, curColPosition.firstName) < 0)) return false;
}
boolean outOfBounds = false;
file.reset();
long curOffset = file.skipBytes((int) curColPosition.offset);
assert curOffset == curColPosition.offset;
while (file.bytesPastMark() < curColPosition.offset + curColPosition.width && !outOfBounds) {
IColumn column = emptyColumnFamily.getColumnSerializer().deserialize(file);
if (reversed) blockColumns.addFirst(column);
else blockColumns.addLast(column);
/* see if we can stop seeking. */
if (!reversed && finishColumn.length > 0)
outOfBounds = comparator.compare(column.name(), finishColumn) >= 0;
else if (reversed && startColumn.length > 0)
outOfBounds = comparator.compare(column.name(), startColumn) >= 0;
if (outOfBounds) break;
}
if (reversed) curRangeIndex--;
else curRangeIndex++;
return true;
}
@Test
public void Deque_addLast_AddsOne() {
deque.addLast("firstString");
assertFalse(deque.isEmpty());
assertEquals(deque.size(), 1);
}
@Test(expected = NullPointerException.class)
public void testAddNullLastNullPointerException() {
Deque<String> deque = new Deque<String>();
deque.addLast(null);
}
static void fillTest(Deque<Integer> deque) {
for (int i = 20; i < 27; i++) deque.addFirst(i);
for (int i = 50; i < 55; i++) deque.addLast(i);
}
