Stack is a LIFO (last in first out) data structure. The associated link to wikipedia contains detailed description and examples. Queue is a FIFO (first in first out) data structure. The associated link to wikipedia contains detailed description and examples.
List has the method add(int, E), so you can use: list.add(0, yourObject); Afterwards you can delete the last element with: if(list.size() > 10) list.remove(list.size() – 1); However, you might want to rethink your requirements or use a different data structure, like a Queue EDIT Maybe have a look at Apache’s CircularFifoQueue: CircularFifoQueue is a first-in … Read more
The order of local variable on the stack is unspecified. It may change between different compilers, different versions or different optimization options. It may even depend on the names of the variables or other seemingly unrelated things.
The x86-64 System V ABI has a 128-byte red zone below RSP that is safe from asynchronous clobbering, i.e. is “owned” by the function. It looks like you compiled int foo{ int x = 4; return 0; } with gcc -O0 (optimizations disabled), and gcc chose to keep x in the red-zone instead of adjusting … Read more
There are actually a few issues here. First, as NPE’s answer nicely explains, Python doesn’t eliminate tail calls, so many functions that would allow unlimited recursion in, say, Scheme are limited in Python. Second, as again as explained by NPE, calls that can’t be eliminated take up space on the call stack. And, even in … Read more
I hope this code can help: import java.util.Stack; public class BalancedParenthensies { public static void main(String args[]) { System.out.println(balancedParenthensies(“{(a,b)}”)); System.out.println(balancedParenthensies(“{(a},b)”)); System.out.println(balancedParenthensies(“{)(a,b}”)); } public static boolean balancedParenthensies(String s) { Stack<Character> stack = new Stack<Character>(); for(int i = 0; i < s.length(); i++) { char c = s.charAt(i); if(c == ‘[‘ || c == ‘(‘ || c … Read more
Nick’s answer is a good starting point, but incomplete, as you actually need to overload: private: void* operator new(size_t); // standard new void* operator new(size_t, void*); // placement new void* operator new[](size_t); // array new void* operator new[](size_t, void*); // placement array new (Good coding practice would suggest you should also overload the delete and … Read more
The typical solution to this is to write your own function to clone an object. If you are able to provide copy constructors and copy assignement operators, this may be as far as you need to go. class Foo { public: Foo(); Foo(const Foo& rhs) { /* copy construction from rhs*/ } Foo& operator=(const Foo& … Read more
The standard library containers separate top() and pop(): top() returns a reference to the top element, and pop() removes the top element. (And similarly for back()/pop_back() etc.). There’s a good reason for this separation, and not have pop remove the top element and return it: One guiding principle of C++ is that you don’t pay … Read more
This should be bitwise OR’d or you end up overwriting the earlier flag. intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); Like so: intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);