quicksort

My understanding of quick sort is Choose a pivot element (in this case I am choosing middle element as pivot) Initialize left and right pointers at extremes. Find the first element to the left of the pivot which is greater than pivot. Similarly find the first element to the right of the pivot which is smaller than pivot Swap elements found in 3 and 4. Repeat 3,4,5 unless left >= right. Repeat the whole thing for left and right subarray as pivot is now placed at its place. I am sure I am missing something here and being very stupid. But above does not seems to be working fot this array: 8,7,1,2

Basically, I have a Container class called "Employees" which has in it an ArrayList. This ArrayList contains "Employee" objects, which in turn contain "EmployeeData" objects which in turn contain String objects such as "first" or "last" (which are employee names). Here's a diagram of the ArrayList structure: ArrayList[Employee] emps ==> 1:Many ==> Employee emp Employee emp ==> 1:1 ==> EmployeeData data EmployeeData data ==> 1:2 ==> String last // A string that contains employee's last name. How in the world would I perform a quicksort on the ArrayList so that the "Employee" objects in it are

I have came up with several strategies, but I am not entirely sure how they affect the overall behavior. I know the average case is O(NlogN), so I would assume that would be in the answer somewhere. I want to just put NlogN+1 for if I just select the 1st item in the array as the the pivot for the quicksort, but I don't know whether that is either correct nor acceptable? If anyone could enlighten me on this subject that would be great. Thanks! Possible Strategies: a) Array is random: pick the first item since that is the most cost effective choice. b) Array is mostly sorted: pick middle item so

I was working on implementing a quicksort yesterday, and then I ran it, expecting a faster runtime than the Mergesort (which I had also implemented). I ran the two, and while the quicksort was faster for smaller data sets <100 elements (and I did verify that it works), the mergesort became the quicker algorithm fairly quickly. I had been taught that quicksort is almost always "quicker" than mergesort, and I understand that there is some debate on this topic, but I at least expected it to be closer than this. For data sets >10000 elements, the mergesort was over 4 times faster. Is this to be