Thank you Chris. The author of the article is looking into this problem. Thanks for the suggestions. And of course for the code.

This fixes both of your problems, I think:

    public int Partition(int[] array, int leftIndex, int rightIndex)
    {
      var pivot = array[leftIndex];
      var start = leftIndex;

      while (true)
      {
        while (array[leftIndex] < pivot)
        {
          leftIndex++;
        }
        while (rightIndex > start && array[rightIndex] >= pivot)
        {
          rightIndex--;
        }
        if (leftIndex < rightIndex)
        {
          var tempVar = array[rightIndex];
          array[rightIndex] = array[leftIndex];
          array[leftIndex] = tempVar;
        }
        else
        {
          return rightIndex;
        }
      }
    }

    public void SortArray(int[] array, int leftIndex, int rightIndex, string arrayName)
    {
      if (leftIndex >= rightIndex) return;

      Stack<Tuple<int, int>> stack = new Stack<Tuple<int, int>>();
      int pivot;

      while (true)
      {
        if (leftIndex < rightIndex)
        {
          pivot = Partition(array, leftIndex, rightIndex);
          stack.Push(new Tuple<int, int>(pivot + 1, rightIndex));
          rightIndex = pivot;
        }
        else if (stack.Any())
        {
          var tuple = stack.Pop();
          leftIndex = tuple.Item1;
          rightIndex = tuple.Item2;
        }
        else
          break;
      }
    }

You also get a StackOverflowException if you run it on a sorted list containing 20,000 items.

new QuickSortMethods().SortArray(GenerateSortedNumber(20000), 0, 19999, "sortedTest");

My mistake. The second “problem” isn’t a problem. After the swap, that expression can be true.

but it still fails if the values are not unique.

The algorithm gets caught in an infinite loop if there are duplicate items in the array. Test case:

int[] intTest = { 73, 57, 49, 99, 133, 20, 1, 73, 99, 20, 73, 1 };

It gets caught when it hits the second 73.

Second, there’s a clear problem here in your code:

 var pivot = array[leftIndex]; 
 while (true)    
 {        
   while (array[leftIndex] < pivot)
   {
            leftIndex++;        
   }

Well, that's never going to be true, is it? if pivot = array[leftIndex], then array[leftIndex] will never be < pivot.