java快速排序引起的StackOverflowError异常

写在前面：这篇随笔主要记录一下递归调用引起的虚拟机栈溢出的情况以及通过参数配置了虚拟机栈大小来使递归调用可以顺利执行。并没有对涉及到的一些概念进行详细的解释（因为我自己目前对这些概念并不是特别清楚），可以用于参考的关键字：

关键字：java虚拟机栈，栈溢出，栈帧

---

今天在对比快速排序与冒泡排序时，通过代码分别实现了最简单的快速排序与冒泡排序（从小到大排序），代码如下：

 /**
  * 冒泡排序
  */

 public class BubbleSortDemo {
     public static void main(String[] args) {
         int[] nums = new int[100000];
         for (int i = nums.length - 1, j = 0; i >= 0; i--, j++) {
             nums[j] = i;
         }
         long start = System.currentTimeMillis();
         bubbleSort(nums);
         long end = System.currentTimeMillis();
         System.out.println((end - start) + "ms");
     }

     public static void bubbleSort(int[] nums) {
         int swapCount = -1;
         while (swapCount != 0) {
             swapCount = 0;
             for (int i = 0; i < nums.length - 1; i++) {
                 int iItem = nums[i];
                 int jItem = nums[i + 1];
                 if (iItem > jItem) {
                     swap(nums, i, i + 1);
                     swapCount++;
                 }
             }
         }
     }

     /**
      * 交换数组nums[]中i和j位置的两个元素
      */
     public static void swap(int[] nums, int i, int j) {
         int temp = nums[i];
         nums[i] = nums[j];
         nums[j] = temp;
     }
 }

 /**
  * 快速排序
  */

 public class QuickSortDemo {
     public static void quickSort(int[] nums, int leftIndex, int rightIndex) {
         if (nums.length <= 1 || leftIndex >= rightIndex) {
             return;
         }

         int pivot = nums[leftIndex];
         int left = leftIndex;
         int right = rightIndex;

         while (left < right) {
             while (left < right && nums[right] >= pivot) {
                 right --;
             }
             if (left < right) {
                 nums[left] = nums[right];
                 left ++;
             }
             while (left < right && nums[left] <= pivot) {
                 left ++;
             }
             if (left < right) {
                 nums[right] = nums[left];
                 right --;
             }
         }
         nums[left] = pivot;
         quickSort(nums, leftIndex, left - 1);
         quickSort(nums, left + 1, rightIndex);
     }

     public static void quickSort(int[] nums) {
         if (nums != null) {
             quickSort(nums, 0, nums.length - 1);
         }
     }

     public static void main(String[] args) {
         int[] nums = new int[100000];
         for (int i = nums.length - 1, j = 0; i >= 0; i--, j++) {
             nums[j] = i;
         }
         long start = System.currentTimeMillis();
         quickSort(nums);
         long end = System.currentTimeMillis();
         System.out.println((end - start) + "ms");
     }

 }

在它们的main函数中，我生成了length=100000的从大到小排列的有序数组对两个排序算法进行测试，观察它们的执行时间。

对于冒泡排序，对100000个有序数组进行排序，花费了12833ms。

对于快速排序，对100000个有序数组进行排序，因为快速排序采用了递归来实现，程序抛出了StackOverflowError异常，本来以为是哪个地方陷入了死循环导致的，后来经过排查，其实是因为虚拟机栈溢出，函数调用的太深了。通过设置虚拟机参数-Xss10m，为虚拟机栈分配了10M的内存，使这个算法可以正常执行。最后，快速排序花费了4830ms。