【leetcode-字符串编码】

给定一个经过编码的字符串，返回它解码后的字符串。

编码规则为: k[encoded_string]，表示其中方括号内部的 encoded_string 正好重复 k 次。注意 k 保证为正整数。

你可以认为输入字符串总是有效的；输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。

此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数 k ，例如不会出现像 3a 或 2[4] 的输入。

示例:

s = "3[a]2[bc]", 返回 "aaabcbc".
s = "3[a2[c]]", 返回 "accaccacc".
s = "2[abc]3[cd]ef", 返回 "abcabccdcdcdef".

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/decode-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

#define ARRAY_STATCK 1
#ifdef ARRAY_STATCK
/* 数据域结构 */
typedef struct _StackNode {
    int multi; /* 倍数 */
    char str[10000]; /* 字符串 */
} StackNode;

typedef struct {
    int top; /* 栈顶位置 */
    int maxSize; /* 栈中最多存放的元素 */
    StackNode *arrayStack; /* 栈元素数组 */
} ArrayStack;

typedef ArrayStack Stack;

/***********栈的操作*************/
void StackInit(Stack *stack, unsigned int size); /* 初始化一个栈 */
bool StackPush(Stack *stack, const StackNode *data); /* 元素压栈 */
bool StackPop(Stack *stack, StackNode *stackNode); /* 删除栈顶元素 */
StackNode *StackTop(Stack *stack); /* 返回栈顶元素 */
void StackFree(Stack *stack); /* 清空栈 */

/* 初始化一个栈 */
void StackInit(Stack *stack, unsigned int size)
{
    stack->maxSize = size;
    stack->top = -1;
    if (size != 0) {
        stack->arrayStack = (StackNode *)malloc(sizeof(StackNode) * size);
        if (stack->arrayStack == NULL) {
            printf("stack malloc error");
            return;
        }
        memset(stack->arrayStack, 0, sizeof(StackNode) * size);
    }
    return;
}

/* 释放栈 */
void StackFree(Stack *stack)
{
    if (stack != NULL) {
        free(stack->arrayStack);
    }
    return;
}

/* 判断栈是否为空 */
bool StackIsEmpty(Stack *stack)
{
    if (stack == NULL || stack->top < 0) {
        return true;
    }
    return false;
}

#define ADD_CAPA 10
/* 栈空间动态扩展 */
static bool StackMallocNew(Stack *stack)
{
    StackNode *newStack = NULL;

    newStack = (StackNode *)malloc(sizeof(StackNode) * (stack->maxSize + ADD_CAPA));
    if (newStack == NULL) {
        return false;
    }
    memset(newStack, 0, sizeof(StackNode) * (stack->maxSize + ADD_CAPA));
    memcmp(newStack, stack->arrayStack, sizeof(StackNode) * stack->maxSize);
    free(stack->arrayStack);
    stack->arrayStack = newStack;
    stack->maxSize = stack->maxSize + 10;

    return true;
}

/* 元素压栈 */
bool StackPush(Stack *stack, const StackNode *data)
{
    if (stack == NULL || data == NULL) {
        return false;
    }
    if (stack->top == stack->maxSize - 1) {
        printf("is full stack,alloc new");
        /* 可以动态扩充栈的大小 */
        if (StackMallocNew(stack) != true) {
            return false;
        }
    }
    stack->top++;
    stack->arrayStack[stack->top].multi = data->multi;
    snprintf(stack->arrayStack[stack->top].str, sizeof(stack->arrayStack[stack->top].str), "%s", data->str);

    return true;
}

/* 删除栈顶元素 */
bool StackPop(Stack *stack, StackNode *stackNode)
{
    StackNode *result = NULL;
    
    if (stack == NULL || stackNode == NULL) {
        return false;
    }
    /* 空栈 */
    if (StackIsEmpty(stack) == true) {
        return false;
    }
    stackNode->multi = stack->arrayStack[stack->top].multi;
    snprintf(stackNode->str, sizeof(stackNode->str), "%s", stack->arrayStack[stack->top].str);
    stack->top--;

    return true;
}
#endif

#define MAX_DECODE_LEN 10000

char *decodeString(char * s)
{
    int i,j;
    int len = 0;
    int multi = 0;
    char *res = NULL;
    Stack stack;
    StackNode stackNode;
    StackNode popStackNode;
    int tempMulti = 0; /* 存储出栈结果 */
    char tempres[10000] = {0}; /* 存储出栈结果 */

    if (s == NULL) {
        return NULL;
    }
    len = strlen(s);

    res = (char *)malloc(sizeof(char) * MAX_DECODE_LEN);
    if (res == NULL) {
        return NULL;
    }
    memset(res, 0, sizeof(char) * MAX_DECODE_LEN);

    StackInit(&stack, 100);

    for (i = 0; i < len; i++) {
        if (s[i] >= '0' && s[i] <= '9') {
            multi = multi * 10 + s[i] - '0';
        } else if (s[i] =='[') {
            memset(&stackNode, 0, sizeof(stackNode));
            stackNode.multi = multi;
            snprintf(stackNode.str, sizeof(stackNode.str), "%s", res);
            StackPush(&stack, &stackNode);
            multi = 0;
            memset(res, 0, MAX_DECODE_LEN); /* 清空结果集 */
        } else if (s[i] == ']') {
            memset(&popStackNode, 0, sizeof(popStackNode));
            StackPop(&stack, &popStackNode);
            tempMulti = popStackNode.multi;
            memset(tempres, 0, sizeof(tempres));
            for (j = 0; j < tempMulti; j++) {
                strcat(tempres, res);
            }
            memset(res, 0, MAX_DECODE_LEN); /* 清空结果集 */
            strcat(res, popStackNode.str);
            strcat(res, tempres);
        } else {
            snprintf(res + strlen(res), MAX_DECODE_LEN - strlen(res), "%c", s[i]);
        }
    }
    StackFree(&stack);
    return res;
}