Asteroid Collision

We are given an array asteroids of integers representing asteroids in a row.

For each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning right, negative meaning left). Each asteroid moves at the same speed.

Find out the state of the asteroids after all collisions. If two asteroids meet, the smaller one will explode. If both are the same size, both will explode. Two asteroids moving in the same direction will never meet.

LeetCode Problem - 735

class Solution {

    // Method to simulate asteroid collisions and return the final state of the asteroids
    public int[] asteroidCollision(int[] asteroids) {
        Stack<Integer> stack = new Stack<>();  // Stack to keep track of surviving asteroids

        // Iterate through each asteroid in the array
        for (int asteroid : asteroids) {
            boolean destroyed = false;  // Flag to track if the current asteroid is destroyed

            // Handle the case where there is a potential collision: 
            // The current asteroid is moving left (asteroid < 0), and the top of the stack is moving right (stack.peek() > 0)
            while (!stack.isEmpty() && asteroid < 0 && stack.peek() > 0) {

                // If the absolute value of the current asteroid is greater, it destroys the top of the stack
                if (stack.peek() < -asteroid) {
                    stack.pop();  // Pop the top of the stack (right-moving asteroid is destroyed)

                // If the absolute values of the asteroids are equal, both are destroyed
                } else if (stack.peek() == -asteroid) {
                    stack.pop();  // Pop the top of the stack (both are destroyed)
                    destroyed = true;  // Mark the current asteroid as destroyed
                    break;  // Exit the loop as no further collisions can happen

                // If the right-moving asteroid is larger, the current asteroid is destroyed
                } else {
                    destroyed = true;  // Mark the current asteroid as destroyed
                    break;  // Exit the loop as no further collisions can happen
                }
            }

            // If the current asteroid was not destroyed, push it onto the stack
            if (!destroyed) {
                stack.push(asteroid);
            }
        }

        // Convert the stack of surviving asteroids to an array and return the result
        return convertListToArray(stack);
    }

    // Helper method to convert a stack of asteroids to an array
    public int[] convertListToArray(Stack<Integer> arrList) {
        int[] result = new int[arrList.size()];  // Create an array with the size of the stack
        for (int i = arrList.size() - 1; i >= 0; i--) {
            result[i] = arrList.pop();  // Pop each element from the stack into the array
        }
        return result;  // Return the array of surviving asteroids
    }
}