栈---行星碰撞

1. 题目
   给定一个整数数组 asteroids，表示在同一行的行星。
   对于数组中的每一个元素，其绝对值表示行星的大小，正负表示行星的移动方向（正表示向右移动，负表示向左移动）。每一颗行星以相同的速度移动。
   找出碰撞后剩下的所有行星。碰撞规则：两个行星相互碰撞，较小的行星会爆炸。如果两颗行星大小相同，则两颗行星都会爆炸。两颗移动方向相同的行星，永远不会发生碰撞。
2. 示例

输入: 
asteroids = [5, 10, -5]
输出: [5, 10]
解释: 
10 和 -5 碰撞后只剩下 10。 5 和 10 永远不会发生碰撞。

输入: 
asteroids = [8, -8]
输出: []
解释: 
8 和 -8 碰撞后，两者都发生爆炸。

输入: 
asteroids = [10, 2, -5]
输出: [10]
解释: 
2 和 -5 发生碰撞后剩下 -5。10 和 -5 发生碰撞后剩下 10。

输入: 
asteroids = [-2, -1, 1, 2]
输出: [-2, -1, 1, 2]
解释: 
-2 和 -1 向左移动，而 1 和 2 向右移动。
由于移动方向相同的行星不会发生碰撞，所以最终没有行星发生碰撞。

说明：
数组 asteroids 的长度不超过 10000。
每一颗行星的大小都是非零整数，范围是 [-1000, 1000] 。
3. 代码实现
数据结构：两个栈，往左移动的行星入左栈，往右移动的行星入右栈。
往右移动的行星可直接入栈；
往左移动的行星，需要消灭往右移动的所有行星才能入栈。

import java.util.Stack;

public class Solution {
    public int[] asteroidCollision(int[] asteroids) {
        //记录往左移动的行星
        Stack<Integer> leftStack = new Stack<>();
        //记录往右移动的行星
        Stack<Integer> rightStack = new Stack<>();
        for (int i = 0; i < asteroids.length; i++) {
            if (asteroids[i] > 0) {
                //往右移动直接入栈
                rightStack.push(asteroids[i]);
            } else {
                //往左移动的行星只有比在他之前往右移动的所有行星都大才能入栈
                int absoulteVal = Math.abs(asteroids[i]);
                //往左移动的行星更大，往右移动的行星爆炸
                while (!rightStack.empty()&&absoulteVal>rightStack.peek()) {
                    rightStack.pop();
                }
                //往右移动的行星不存在或往左移动的行星消灭了往右移动的所有行星
                if(rightStack.empty()){
                    leftStack.push(asteroids[i]);
                }else{
                    //大小相等同时爆炸
                    if(rightStack.peek()==absoulteVal){
                        rightStack.pop();
                    }
                }
            }
        }
        //注意：先保存栈中元素数量，因为在元素出栈时，栈中元素数量动态变化
        int leftLen = leftStack.size();
        int rightLen = rightStack.size();
        int result[] = new int[leftLen + rightLen];
        //根据前面的判断逻辑，若往左移动的行星存在，而且右栈不为空，
        // 可判断往左移动的行星必定在数组的前面，如果不在前面，它需要消灭往右移动所有行星才有机会入栈
        if (!leftStack.empty() && !rightStack.empty()) {
            //从后往前存
            for (int i = leftLen - 1; i >= 0; i--) {
                result[i] = leftStack.pop();
            }
            for (int i = result.length - 1; i >= leftLen; i--) {
                result[i] = rightStack.pop();
            }
        } else if (!leftStack.empty()) {
            for (int i = leftLen - 1; i >= 0; i--) {
                result[i] = leftStack.pop();
            }
        } else if (!rightStack.empty()) {
            for (int i = rightLen - 1; i >= 0; i--) {
                result[i] = rightStack.pop();
            }
        }
        return result;
    }
}