space-complexity

I am implementing a LinkedList in python(3.7.4) and the code of the module is below :- LinkedList.py class Node: def __init__(self,value): self.value = value self.ref = None class LinkedList(Node): def __init__(self): self.__head = None self.__cur = None self.__count = 0 def add(self,value): if self.__head is None: self.__cur = Node(value) self.__head = self.__cur else: self.__cur.ref = Node(value) self.__cur = self.__cur.ref self.__count += 1 def getList(self): temp = self.__head while temp!=None: yield temp.value temp = temp.ref def delete(self,value): temp = self.__head while temp!=None: if

The algo I have in mind is keep an MaxHeap of size K insert each element drop out smaller value if heap is full In the end, Kth max is the smaller of MaxHeap That will give me O(NlogK). Is there a better algorithm? I can't do quick selection, because the array can't be stored in memory. Depending on your memory restrictions, you can use a modified version of the median-of-medians algorithm to solve the problem in O(n) time and O(k) space. The idea is as follows. Maintain an array of size 2k in memory. Fill this buffer with the first 2k elements from the array, then run the median-of-medians

There is a singly connected linked list and a block size is given.For eg if my linked list is 1->2->3->4->5->6->7->8-NULL and my block size is 4 then reverse the first 4 elements and then the second 4 elements.The output of the problem should be 4->3->2->1->8->7->6->5-NULL I was thinking of dividing the linked list into segments of size 4 and then reversing it. But that way I am forced to use a lot of extra nodes which is not desired at all. The space complexity should be kept to a minimum. It will be highly appreciable if someone can come with a better solution where the usage of extra nodes

I've been reading on in place sorting algorithm to sort linked lists. As per Wikipedia Merge sort is often the best choice for sorting a linked list: in this situation it is relatively easy to implement a merge sort in such a way that it requires only Θ(1) extra space, and the slow random-access performance of a linked list makes some other algorithms (such as quicksort) perform poorly, and others (such as heapsort) completely impossible. To my knowledge, the merge sort algorithm is not an in place sorting algorithm, and has a worst case space complexity of O(n) auxiliary. Now, with this taken

Mathematica' CylindricalDecomposition implements an algorithm known as Cylindrical Algebraic Decomposition. Wolfram MathWorld's article on Cylindrical Algebraic Decomposition says that this algorithm "becomes computationally infeasible for complicated inequalities." Can this statement be made more precise? Specifically, how does the time and space relate to the degree and number of variables of the multivariate polynomials? Does the time and space depend on other parameters? Tarski showed that for every formula including quantifiers there is always an equivalent quantifier free formula.

I'm trying to implement in C a data structure that would allow me to manipulate efficiently a**binary** matrix (containing only 1 or 0). I'll explain what operations I have to apply to this matrix, and would like to know what's the best possible data structure to use ? The operations are done in the field F_2 (which means 1+1 = 0 the other operations remain unchanged). I have one k * n matrix ( k < n ) called H . At most, k = 2325 and n = 3009. The operations that I will have to do over this matrix are : I will partially diagonalize it using only row swap and row additions . Once it is done, I

I've been googling for the past 2 hours, and I cannot find a list of php built in functions time and space complexity. I have the isAnagramOfPalindrome problem to solve with the following maximum allowed complexity: expected worst-case time complexity is O(N) expected worst-case space complexity is O(1) (not counting the storage required for input arguments). where N is the input string length. Here is my simplest solution, but I don't know if it is within the complexity limits. class Solution { // Function to determine if the input string can make a palindrome by rearranging it static public

Using Bloom filter, we will be getting space optimization. The cassandra framework also has an implementation of Bloom Filter. But in detail, how is this space optimization achieved? A bloom filter isn't a "framework". It's really more like simply an algorithm. The implementation ain't very long. Here's one in Java I've tried ( .jar , source code and JavaDoc being all available): "Stand alone Java implementations of Cuckoo Hashing and Bloom Filters" (you may want to Google for this in case the following link ain't working anymore): http://lmonson.com/blog/?page_id=99 You can understand how it