为什么非回归方法比递归需要更多的时间

以快速排序为例，下面列出了递归和非回收方法。

我认为这两种方法实际上实现了相同的算法，因为stack用于模拟非回归方法的递归过程。

但是，我使用了递归方法的AC，但是时间限制超过了 通过85％的测试用例后，使用非回收法。

因此，我的非回归方法或两种方法之间存在时间复杂性差异吗？

thx！

// non-recursion
void sortIntegers(vector<int> &A) {
    if (A.empty()) {
        return;
    }
    stack<pair<int, int>> ranges;
    ranges.push(pair<int, int>(0, A.size() - 1));
    while (!ranges.empty()) {
        pair<int, int> r = ranges.top();
        ranges.pop();
        int mid = A[r.second],
            left = r.first,
            right = r.second - 1;
        if (r.first >= r.second) {
            continue;
        }
        while (left < right) {
            while (A[left] < mid && left < right) {
                left++;
            }
            while (A[right] >= mid && left < right) {
                right--;
            }
            swap(A[left], A[right]);
        }
        if (A[left] < A[r.second]) {
            left++;
        } else {
            swap(A[left], A[r.second]);
        }
        ranges.push(pair<int, int>(0, left - 1));
        ranges.push(pair<int, int>(left + 1, r.second));
    }
// recursion
void sortIntegers(vector<int> &A) {
    quick(A, 0, A.size() - 1);
}
void quick(vector<int> & A, int start, int end) {
    if (start >= end) {
        return;
    }
    int mid = A[end],  //5
        left = start,  // 0
        right = end - 1;  //3
    while (left < right) {
        while (A[left] < mid && left < right) {
            left++;
        }
        while (A[right] >= mid && left < right) {
            right--;
        }
        swap(A[left], A[right]);
    }
    if (A[left] >= A[end]) {
        swap(A[left], A[end]);
    }else {
        left++;
    }
    quick(A, start, left - 1);
    quick(A, left + 1, end);
}