[C language brush leetcode] 735. Planetary collision (m)

【

Given an array of integers asteroids, Represents planets on the same line .

For each element in the array , Its absolute value represents the size of the planet , Positive and negative indicate the direction of movement of the planet （ Positive means moving to the right , Negative means moving to the left ）. Every planet moves at the same speed .

Find all the planets left after the collision . Collision rules ： The two planets collide with each other , Smaller planets will explode . If two planets are the same size , Then both planets will explode . Two planets moving in the same direction , There will never be a collision .

Example 1：

Input ：asteroids = [5,10,-5]
Output ：[5,10]
explain ：10 and -5 After the collision, only 10 . 5 and 10 There will never be a collision .
Example 2：

Input ：asteroids = [8,-8]
Output ：[]
explain ：8 and -8 After the collision , Both exploded .
Example 3：

Input ：asteroids = [10,2,-5]
Output ：[10]
explain ：2 and -5 After the collision, there are -5 .10 and -5 After the collision, there are 10 .
 

Tips ：

2 <= asteroids.length <= 104
-1000 <= asteroids[i] <= 1000
asteroids[i] != 0

source ： Power button （LeetCode）
link ：https://leetcode.cn/problems/asteroid-collision
Copyright belongs to the network . For commercial reprint, please contact the official authority , Non-commercial reprint please indicate the source .

】

It's easy to think of monotonous stack from the meaning of the title , But I read the meaning of the title wrong twice , So read the meaning of the question three times before doing it , Have a good understanding of .

Because it either disappears or doesn't change its size when it collides , So the processing of elements in the stack idx Index carefully .

  The top element of the stack is right , The current left will collide . So judge the result after the collision , You can sum two elements .

int* asteroidCollision(int* asteroids, int asteroidsSize, int* returnSize){
    int *stack = NULL;
    int idx = -1; // idx  Point to the location where the element is stored 
    int i;
    int flag = 1; //  The direction of the previous element ,1: Right ;-1： Left 

    stack = (int *)malloc(sizeof(int) * asteroidsSize);
    memset(stack, 0, sizeof(int) * asteroidsSize);

    stack[++idx] = asteroids[0];

    for (i = 1; i < asteroidsSize; i++) {
        int comp = -1;

        //  The top element of the stack is right , The current left will collide 
        while (asteroids[i] < 0 && idx > -1 && stack[idx] > 0) {
            comp = stack[idx] + asteroids[i];  //  Compare positive and negative with the top element 
            if (comp < 0) {
                idx--; //  The top element of the stack exploded 
                continue;
            } else if (comp == 0) {
                idx--;
                break;
            } else {
                break;
            }
        }

        if (comp < 0) {
            stack[++idx] = asteroids[i]; //  Put the current element in 
        }
    }

    *returnSize = idx + 1;
    return stack;
}
/*
1.  I read the wrong title again , Smaller ones will explode , Not a big reduction , Some code will be readjusted 
2.  Understand the wrong meaning . Think the first left , The second right will also collide , I understand [-2,-1,1,2]  The return value of is null , The correct return value of the result is [-2,-1,1,2], Complicate the subject  
3. flag  Attention should be paid to when judging idx

 Don't take out the elements this time , Direct comparison 
*/