Determine if a string of characters are unique using quicksort
Complexity

If the intent was to meet an \$O(N log N)\$ requirement, you've technically failed--quicksort has an expected complexity proportional to N log N, but big-O deals strictly with the worst-case complexity--and worst-case complexity of quicksort is \$O(N^2)\$.

Class Design

One of the old basic ideas of how to do object-oriented design is to start by writing down a one-page (or less) description of what the program is supposed to do. You then pick out the nouns that form the major themes in that description. Those are your classes.

The point of that is to note that most classes should normally represent nouns1. Things that exist. Objects. In a typical case they should not represent verbs.

In this case, however, you have one primary class--and its name is a verb, not a noun. This leads to a lot of question over whether it makes sense for this class to be a class, or whether we have kind of a conglomeration of "stuff" thrown together into something that says it's a class, but isn't doesn't form a particularly coherent...thing.

Standard Containers

Good uses for C style arrays in C++ are quite rare. Your arr doesn't strike me as one of them. If you really need a fixed-size array, you should probably use std::array instead. Otherwise, you're probably best off using std::vector.

Standard Algorithms

The standard library already has algorithms to handle the job at hand. Most code should just use st::sort followed by std::unique, rather than attempting to craft the same on your own.

Self-defeating design

Right now, you've limited the collection size to only 15 elements. For such a small size, a simpler sorting algorithm (e.g., insertion sort) will almost always be at least a little faster than a quicksort. In short, combining the elements you have in the way you have just doesn't make sense.

Use of strlen

If you insist on using strlen at all, you shouldn't call it in the condition of a for loop, like:

for (int i=0; i&lt;strlen(foo); i++)


A few compilers know how to optimize this by hoisting the call to strlen out of the loop, but most don't. With those compilers, this loop will have \$O(N^2)\$ complexity instead of the O(N) you probably want/expect.

Note that if you used std::vector or std::string for your storage, this wouldn't be a problem. Unlike strlen, both these guarantee that you can find the size with \$O(1)\$ complexity instead of \$O(N)\$.

Side Effect-ridden code

Most of your functions implicitly modify FindUniqueCharInString::arr. It's generally much better to avoid this when possible--and it's pretty trivial in most of these cases. Just for a trivial example, right now your swap is passed to integers, i and j, and it swaps arr[i] with arr[j]. It would be much better to pass (for example) pointers or references to the contents, so the modifications are explicit:

swap(i, j); // ambiguous, implicit side effects on `arr`

swap(arr[i], arr[j]); // clear, effect on `arr` is obvious.


Summary

At least in my opinion, the other issues pale compared to just making good use of the standard library. 

std::string arr {"SOMESTRING"};
std::sort(arr.begin(), arr.end());
auto end = std::unique(arr.begin(), arr.end());

// show the unique characters    
std::copy(arr.begin(), end, std::ostream_iterator&lt;char&gt;(std::cout, "\n"));





1. The primary exception to this is function objects--i.e., classes that act mostly like a function, including overloading operator() to do whatever it is they do