快速排序（递归、非递归）（Java）

问题

当数据量较大时（数组长度1000000），快速排序递归算法栈溢出，且实际运行时间也比其他算法长，我猜测是由于大量的函数调用。有人能分析一下吗？如何改进？

递归

private void quick_sort_recursive(int head, int rear) {
        if (head > rear) return;
        int i = head;
        int j = rear;
        int tmp = array[head];
        while (i != j) {
            while (i < j && array[j] >= tmp) j--;
            while (i < j && array[i] <= tmp) i++;

            if (i < j) {
                array[i] = array[i] + array[j];
                array[j] = array[i] - array[j];
                array[i] = array[i] - array[j];
            }
        }
        array[head] = array[i];
        array[i] = tmp;

        quick_sort_recursive(head, i - 1);
        quick_sort_recursive(i + 1, rear);

    }

    public void quickSortRecursive() {
        quick_sort_recursive(0, len - 1);
    }

非递归

private void quick_sort_not_recursive(int head, int rear) {
        Stack<Integer> stack = new Stack<Integer>();
        stack.push(head);
        stack.push(rear);
        int i, j;
        while (!stack.empty()) {
            rear = stack.pop();
            head = stack.pop();
            i = head;
            j = rear;
            int key = array[head];

            while (i != j) {
                while (i < j && array[j] >= key) j--;
                while (i < j && array[i] <= key) i++;
                if (i < j) {
                    array[i] = array[i] + array[j];
                    array[j] = array[i] - array[j];
                    array[i] = array[i] - array[j];
                }


            }
            array[head] = array[i];
            array[i] = key;

            if (i - 1 > head) {
                stack.push(head);
                stack.push(i-1);
            }
            if (i + 1 < rear) {
                stack.push(i+1);
                stack.push(rear);
            }

        }
    }

    public void quickSortNotRecursive(){
        quick_sort_not_recursive(0,len-1);
    }