창고 --- 행성 충돌

4. 567917. 문 제 는 하나의 정수 배열 asteroids 를 정 하여 같은 줄 에 있 는 행성 을 나타 낸다.배열 의 모든 요소 에 대해 절대적 인 수 치 는 행성 의 크기 를 나타 내 고 플러스 와 마이너스 는 행성 의 이동 방향 을 나타 낸다 (오른쪽 으로 이동 하고 마이너스 는 왼쪽으로 이동 하 는 것 을 나타 낸다).모든 행성 은 같은 속도 로 이동한다.충돌 후 남 은 모든 행성 을 찾 아 라.충돌 규칙: 두 행성 이 서로 충돌 하면 작은 행성 이 폭발한다.만약 두 행성 의 크기 가 같다 면, 두 행성 은 모두 폭발 할 것 이다.이동 방향 이 같은 두 행성 은 영원히 충돌 하지 않 을 것 이다
예시

  : 
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 을 넘 지 않 습 니 다.모든 행성 의 크기 는 0 정수 가 아니 고 범 위 는 [- 1000, 1000] 이다.3. 코드 는 데이터 구 조 를 실현 합 니 다. 두 개의 스 택, 왼쪽으로 이동 하 는 행성 은 왼쪽 스 택 에 들 어가 고 오른쪽으로 이동 하 는 행성 은 오른쪽 스 택 에 들 어 갑 니 다.오른쪽으로 이동 하 는 행성 은 직접 창고 에 들 어 갈 수 있다.왼쪽으로 이동 하 는 행성 은 오른쪽으로 이동 하 는 모든 행성 을 처치 해 야 창고 에 들 어 갈 수 있다.

import java.util.Stack;

public class Solution {
    public int[] asteroidCollision(int[] asteroids) {
        //         
        Stack leftStack = new Stack<>();
        //         
        Stack 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;
    }
}