非递归 快速排序

非递归快速排序的实现思路：

将递归过程中的函数调用转换为栈操作。

每次从栈中取出区间，进行分区操作，并将分区后的子区间压入栈中（如果需要）。

重复上述过程，直到栈为空，即所有区间都已处理完毕。

C先手搓一个栈

Stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int StackDataType;
typedef struct Stack
{
    StackDataType* _a;
    int _size;
    int _capacity;
}Stack;

void StackInit(Stack* pst);
void StackDestory(Stack* pst);
void StackPush(Stack* pst,StackDataType x);
void StackPop(Stack* pst);
int StackSize(Stack* pst);
int StackEmpty(Stack* pst);//判断是否为空 返回1为空，返回0为非空
StackDataType StackTop(Stack* pst);

Stack.c

#include"Stack.h"
void StackInit(Stack* pst)
{
    assert(pst);
    pst->_a = (StackDataType*)malloc(sizeof(StackDataType)*4);
    pst->_size = 0;
    pst->_capacity = 4;
}

void StackDestory(Stack* pst)
{
    assert(pst);
    free(pst->_a);
    pst->_a = NULL;
    pst->_size = pst->_capacity = 0;
}

void StackPush(Stack* pst,StackDataType x)
{
    assert(pst);
    if (pst->_size >= pst->_capacity)
    {
        pst->_capacity = pst->_capacity * 2;
        StackDataType* tmp = (StackDataType * )realloc(pst->_a, sizeof
        (StackDataType)*pst->_capacity);
        if (tmp == NULL)
        {
            printf("内存不足");
            exit(-1);
        }
        else
        {
            pst->_a = tmp;
        }
    }
    pst->_a[pst->_size] = x;
    pst->_size++;
}

void StackPop(Stack* pst)
{
    assert(pst);
    assert(pst->_size > 0);
    --pst->_size;

}

int StackSize(Stack* pst)
{
    assert(pst);
    return pst->_size;
}

int StackEmpty(Stack* pst)//返回1为空，返回0为非空
{
    assert(pst);
    return pst->_size == 0 ? 1 : 0;
    //return !pst->_size;
}

StackDataType StackTop(Stack* pst)
{
    assert(pst);
    assert(pst->_size > 0);

    return pst->_a[pst->_size-1];
}
 

sort.c

void QuickSortNonR(int* a, int left, int right)
{
    Stack st;
    StackInit(&st);

    StackPush(&st, right);
    StackPush(&st, left);

    while (!StackEmpty(&st))
    {
        int begin = StackTop(&st);
        StackPop(&st);
        int end = StackTop(&st);
        StackPop(&st);

        int div = PartSort(a, begin, end);//可参照本人上一篇文章，快速排序的三种方式任选一种
        if (div + 1 < end)
        {
            StackPush(&st, end);
            StackPush(&st, div + 1);
        }
        if (begin < div - 1)
        {
            StackPush(&st, div - 1);
            StackPush(&st, begin);
        }
    }

}