Quick sort with middle element as pivot

Quick Sort Given an array of n elements (e.g., integers):
-If array only contains one element, return
-Else
  pick one element to use as pivot.
  Partition elements into two sub-arrays:
    Elements less than or equal to pivot
    Elements greater than pivot
  Quicksort two sub-arrays
  Return results

Let i and j are the left and right pivots, then code for one array will look like this:

1) While data[i] <= data[pivot]
    ++i
2) While data[j] > data[pivot]
    --j
3) If i < j
    swap data[i] and data[j]
4) While j > i, go to 1.
5) Swap data[j] and data[pivot_index]

Position of index j is where array is to-be partitioned in two half and then same steps are applied to them recursively.

At last you gets an sorted array.

There is no upfront division between the left and the right side. In particular, 6 is not the division. Instead, the division is the result of moving the left and right pointer closer to each other until they meet. The result might be that one side is considerably smaller than the other.

Your description of the algorithm is fine. Nowhere does it say you have to stop at the middle element. Just continue to execute it as given.

BTW.: The pivot element might be moved during the sorting. Just continue to compare against 6, even if it has been moved.

Update:

There are indeed a few minor problems in your description of the algorithm. One is that either step 3 or step 4 need to include elements that are equal to the pivot. Let's rewrite it like this:

My understanding of quick sort is

1. Choose a pivot value (in this case, choose the value of the middle element)
2. Initialize left and right pointers at extremes.
3. Starting at the left pointer and moving to the right, find the first element which is greater than or equal to the pivot value.
4. Similarly, starting at the right pointer and moving to the left, find the first element, which is smaller than pivot value
5. Swap elements found in 3 and 4.
6. Repeat 3,4,5 until left pointer is greater or equal to right pointer.
7. Repeat the whole thing for the two subarrays to the left and the right of the left pointer.

pivot value: 6, left pointer at 8, right pointer at 11
8,7,1,2,6,9,10,2,11 left pointer stays at 8, right pointer moves to 2
2,7,1,2,6,9,10,8,11 swapped 2 and 8, left pointer moves to 7, right pointer moves to 2
2,2,1,7,6,9,10,8,11 swapped 2 and 7, left pointer moves to 7, right pointer moves to 1
pointers have now met / crossed, subdivide between 1 and 7 and continue with two subarrays