malloc | Simple memory allocation utilities , based on dlmalloc

You're supposed to free memory right after the last time it will be used. In your program, after the while loop in recursion, Energy isn't used again, so you should free it right after that (i.e., right before return event_counter;).

If the problem did end up being from heap overuse (from strncat), then you could try out this implementation that uses the return from sprintf to append to the string as your building it.

I'm trying to parallelize a merge-sort algorithm. What I'm doing is dividing the input array for each thread, then merging the threads results.

Ok, but yours is an unnecessarily difficult approach. At each step of the merge process, you want half of your threads to wait for the other half to finish, and the most natural way for one thread to wait for another to finish is to use pthread_join(). If you wanted all of your threads to continue with more work after synchronizing then that would be different, but in this case, those that are not responsible for any more merges have nothing at all left to do.

This is what I've tried:

You have to assign the number of elements of the array to return (2 in this case) to what the argument returnSize points at (*returnSize) to tell the judge system how large the array you returned is.

Because once all command are executed, the terminal close itself.

Ok, the signature container is embedded correctly.

But there are issues with the signature container itself:

• Both in the SignedData.digestAlgorithms collection and in the SignerInfo.digestAlgorithm value you have used the OID of SHA1withRSA, but that is a full signature algorithm, not the mere digest algorithm SHA1 expected there.

• Then the SHA1 hash of the signed bytes is BB78A402F7A537A34D6892B83881266501A691A8 but the hash you signed is 90E28B8A0D8E48691DAFE2BA10A4761FFFDCCD3D. This might be because you hash buffer2 and

  buffer2 has empty contents data (/Contents <>)

  The hex string delimiters '<' and '>' also belong to the contents value and, therefore, must also be removed in buffer2.

Furthermore, your signature is very weak:

• It uses SHA1 as hash algorithm. SHA1 meanwhile has been recognized as too weak a hash algorithm for document signatures.
• It doesn't use signed attributes, neither the ESS signing certificate nor the algorithm identifier protection attribute. Many validation policies require such special attributes.

It would have half of previous time complexity i guess.

O(0.5 * n^2) is still O(n^2). A good qsort() is expected O(n* ln(n)).

Is this efficient enough or should I stick with selection sort and qsort.

Tough to beat decades of many programmers experience.

Keep in mind qsort() does not have to use the quick sort algorithm. A good qsort() may use a combination of algorithms.

When you find the new place where to insert the new dog, you walk the list if there is a next dog and if the new dog's grade is below the current dog's grade. (I've renamed the two iterators curr and prev for clarity.)

When you insert the new dog, p, the next dog is the current dog, p->next = curr. If the current dog's grade is the smallest of if the list was empty, curr is NULL, which is fine. You don't need to treat an empty list as special case.

Now, if prev == NULL, your new dog ist the current best. There is no previous node, so update the head pointer via *fitBarkList. Otherwise, update the next field of the previous node: