2454. 下一个更大元素 IV

2454. 下一个更大元素 IV2454. 下一个更大元素 IV2454. 下一个更大元素 IV

给你一个下标从 0 开始的非负整数数组 nums 。对于 nums 中每一个整数，你必须找到对应元素的 第二大 整数。

如果 nums[j] 满足以下条件，那么我们称它为 nums[i] 的 第二大 整数：

• j > i
• nums[j] > nums[i]
• 恰好存在 一个 k 满足 i < k < j 且 nums[k] > nums[i] 。

如果不存在 nums[j] ，那么第二大整数为 -1 。

• 比方说，数组 [1, 2, 4, 3] 中，1 的第二大整数是 4 ，2 的第二大整数是 3 ，3 和 4 的第二大整数是 -1 。

请你返回一个整数数组 answer ，其中 answer[i]是 nums[i] 的第二大整数。

示例 1：

输入：nums = [2,4,0,9,6]
输出：[9,6,6,-1,-1]
解释：
下标为 0 处：2 的右边，4 是大于 2 的第一个整数，9 是第二个大于 2 的整数。
下标为 1 处：4 的右边，9 是大于 4 的第一个整数，6 是第二个大于 4 的整数。
下标为 2 处：0 的右边，9 是大于 0 的第一个整数，6 是第二个大于 0 的整数。
下标为 3 处：右边不存在大于 9 的整数，所以第二大整数为 -1 。
下标为 4 处：右边不存在大于 6 的整数，所以第二大整数为 -1 。
所以我们返回 [9,6,6,-1,-1] 。

/*

这道题主要是如何解决寻找数组中比当前元素大的第二个元素的问题，无非就是两种情况，

1.得到了第二个元素然后返回

2.没得到元素返回-1

但是我想不到用什么方法写

于是去看了题解

为了解决这一问题，我们可以利用「单调栈」算法。该算法的核心思想是利用一个栈来存储数组元素的下标。在遍历数组时，对于每个元素，执行以下操作：如果当前元素大于栈顶元素对应的值，说明找到了栈顶元素的下一个更大的数字，将栈顶元素出栈，并更新结果数组。如果当前元素小于等于栈顶元素对应的值，将当前元素的下标压入栈中，保持栈的单调递减性质。这样，最终结果数组中存储的就是每个数字的下一个比它大的数字（如果存在的话），如果没有更大的数字，则对应位置的值为-1，晚点去研究一下单调栈

*/

typedef struct {

    int first;

    int second;

} Node;

typedef bool (*cmp)(const void *, const void *);

typedef struct {

    Node *arr;

    int capacity;

    int queueSize;

    cmp compare;

} PriorityQueue;

Node *createNode(int x, int y) {

    Node *obj = (Node *)malloc(sizeof(Node));

    obj->first = x;

    obj->second = y;

    return obj;

}

PriorityQueue *createPriorityQueue(int size, cmp compare) {

    PriorityQueue *obj = (PriorityQueue *)malloc(sizeof(PriorityQueue));

    obj->arr = (Node *)malloc(sizeof(Node) * size);

    obj->queueSize = 0;

    obj->capacity = size;

    obj->compare = compare;

    return obj;

}

static bool compare(const void *a, const void *b) {

    Node *p1 = (Node *)a;

    Node *p2 = (Node *)b;

    if (p1->first == p2->first) {

        return p1->second < p2->second;

    }

    return p1->first > p2->first;

}

static void swap(Node *arr, int i, int j) {

    Node tmp;

    memcpy(&tmp, &arr[i], sizeof(Node));

    memcpy(&arr[i], &arr[j], sizeof(Node));

    memcpy(&arr[j], &tmp, sizeof(Node));

}

static void down(Node *arr, int size, int i, cmp compare) {

    for (int k = 2 * i + 1; k < size; k = 2 * k + 1) {

        // 父节点 (k - 1) / 2，左子节点 k，右子节点 k + 1

        if (k + 1 < size && compare(&arr[k], &arr[k + 1])) {

            k++;

        }

        if (compare(&arr[k], &arr[(k - 1) / 2])) {

            break;

        }

        swap(arr, k, (k - 1) / 2);

    }

}

void heapfiyQueue(PriorityQueue *obj) {

    for (int i = obj->queueSize / 2 - 1; i >= 0; i--) {

        down(obj->arr, obj->queueSize, i, obj->compare);

    }

}

void pushQueue(PriorityQueue *obj, Node *node) {

    memcpy(&obj->arr[obj->queueSize], node, sizeof(Node));

    for (int i = obj->queueSize; i > 0 && obj->compare(&obj->arr[(i - 1) / 2], &obj->arr[i]); i = (i - 1) / 2) {

        swap(obj->arr, i, (i - 1) / 2);

    }

    obj->queueSize++;

}

bool popQueue(PriorityQueue *obj) {

    assert(obj->queueSize != 0);

    swap(obj->arr, 0, obj->queueSize - 1);

    down(obj->arr, obj->queueSize - 1, 0, obj->compare);

    obj->queueSize--;

    return true;

}

bool isFull(PriorityQueue *obj) {

    return obj->queueSize == obj->capacity;

}

bool isEmpty(PriorityQueue *obj) {

    return obj->queueSize == 0;

}

Node* topQueue(PriorityQueue *obj) {

    assert(obj->queueSize != 0);

    if (obj->queueSize == 0) {

        return NULL;

    } else {

        return &obj->arr[0];

    }

}

void freeQueue(PriorityQueue *obj) {

    free(obj->arr);

    free(obj);

}

int* secondGreaterElement(int* nums, int numsSize, int* returnSize) {

    int *res = (int *)malloc(sizeof(int) * numsSize);

    memset(res, 0xff, sizeof(int) * numsSize);

    int stack[numsSize];

    int top = 0;

    PriorityQueue *q = createPriorityQueue(numsSize, compare);

    for (int i = 0; i < numsSize; ++i) {

        while (!isEmpty(q) && topQueue(q)->first < nums[i]) {

            res[topQueue(q)->second] = nums[i];

            popQueue(q);

        }

        while (top > 0 && nums[stack[top - 1]] < nums[i]) {

            Node node;

            node.first = nums[stack[top - 1]];

            node.second = stack[top - 1];

            pushQueue(q, &node);

            top--;

        }

        stack[top++] = i;

    }

    *returnSize = numsSize;

    freeQueue(q);

    return res;

}