complexity-theory

Welcome mon amie , In some homework of mine, I feel the need to use the Graph ADT. However, I'd like to have it, how do I say, generic . That is to say, I want to store in it whatever I fancy. The issue I'm facing, has to do with complexity. What data structure should I use to represent the set of nodes? I forgot to say that I already decided to use the Adjacency list technic . Generally, textbooks mention a linked list, but, it is to my understanding that whenever a linked list is useful and we need to perform searches, a tree is better . But then again, what we need is to associate a node

In our discrete mathematics course in my university, the teacher shows his students the Ackermann function and assign the student to develop the function on paper. Beside being a benchmark for recursion optimisation, does the Ackermann function has any real uses ? Yes. The (inverse) Ackermann function appears in complexity analysis of algorithms. When it does, it means you can almost ignore that term since it grows so slowly (a lot like log(log ... log(n)...)) i.e. lg*(n). For example: Minimum Spanning Trees (also here ) and Disjoint Set forest construction. Also: Davenport-Scinzel sequences

Recently, I've been surprised by the fact that some Java collections don't have constant time operation of method size(). While I learned that concurrent implementations of collections made some compromises as a tradeoff for gain in concurrency (size being O(n) in ConcurrentLinkedQueue, ConcurrentSkipListSet, LinkedTransferQueue, etc.) good news is that this is properly documented in API documentation. What concerned me is the performance of method size on views returned by some collections' methods. For example, TreeSet.tailSet returns a view of the portion of backing set whose elements are

Cyclomatic Complexity will be high for methods with a high number of decision statements including if/while/for statements. So how do we improve on it? I am handling a big project where I am supposed to reduced the CC for methods that have CC > 10. And there are many methods with this problem. Below I will list down some eg of code patterns (not the actual code) with the problems I have encountered. Is it possible that they can be simplified? Example of cases resulting in many decision statements: Case 1) if(objectA != null) //objectA is a pass in as a parameter { objectB = doThisMethod(); if

I'm currently working on an embedded device project where I'm running into performance problems. Profiling has located an O(N) operation that I'd like to eliminate. I basically have two arrays int A[N] and short B[N] . Entries in A are unique and ordered by external constraints. The most common operation is to check if a particular value a appears in A[] . Less frequently, but still common is a change to an element of A[] . The new value is unrelated to the previous value. Since the most common operation is the find, that's where B[] comes in. It's a sorted array of indices in A[] , such that