es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

  • es.davy.ai/
  • Programación /
  • ¿Cómo puedo verificar si 2 pilas dadas tienen los mismos valores? (No necesariamente en el mismo orden)

¿Cómo puedo verificar si 2 pilas dadas tienen los mismos valores? (No necesariamente en el mismo orden)

31 Jul, 2023 Programación

¡Hola a todos!
¿Cómo puedo verificar si dos pilas tienen los mismos valores?

Por ejemplo, en la pila1 tengo [1,3,4,5] y en la pila2 tengo [4,3,1,5], por lo tanto, las pilas tienen los mismos valores y el método debe devolver true.

Además, las pilas deben mantenerse (al final) tal como fueron dadas (con los valores originales y en el mismo orden).

He comenzado a trabajar en ello, pero desafortunadamente no está funcionando bien:

import java.util.Stack;

public class StackMain {
    public static void main(String[] args) {

        Stack<integer> st1 = new Stack<integer>();
        st1.push(2);
        st1.push(643);
        st1.push(254);
        st1.push(13);
        st1.push(74);
        st1.push(6);
        st1.push(5);
        st1.push(99);

        Stack<integer> st2 = new Stack<integer>();
        st2.push(643);
        st2.push(2);
        st2.push(254);
        st2.push(13);
        st2.push(99);
        st2.push(5);
        st2.push(6);
        st2.push(74);
        System.out.println(isSameStacks(st1,st2));
    }

    public static boolean isSameStacks(Stack st1, Stack st2) {
        Stack st1Reverse = new Stack();
        Stack st2Reverse = new Stack();
        boolean isExist = false;

        while(!st1.isEmpty()) {
            isExist = false;
            st1Reverse.push(st1.pop());

            while(!st2.isEmpty()) {
                st2Reverse.push(st2.pop());

                if(st1Reverse.peek() == st2Reverse.peek()) {
                    isExist = true;
                }
            }

            while(!st2Reverse.isEmpty()) {
                st2.push(st2Reverse.pop());
            }

            if(!isExist) {
                while(!st1Reverse.isEmpty()) {
                    st1.push(st1Reverse.pop());
                }

                return false;
            }
        }

        while(!st1Reverse.isEmpty()) {
            st1.push(st1Reverse.pop());
        }

        return true;
    }
}

Gracias de antemano.

Tags:  ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Una solución para verificar si dos pilas tienen los mismos valores y mantienen su orden original es:

    1. Verificar si los tamaños de ambas pilas son iguales. Si no lo son, retornar falso.

    2. Iterar a través de ambas pilas simultáneamente, comparando los valores de cada elemento de ambas pilas. Si se encuentra alguna discrepancia en algún punto, retornar falso.

    3. Si la iteración se completa sin ninguna discrepancia, retornar verdadero.

    Aquí hay una implementación de la solución anterior en Java:

    public static boolean isSameStacks(Stack<integer> st1, Stack<integer> st2) {
    // verificar tamaños
    if (st1.size() != st2.size()) {
        return false;
    }
    // iterar a través de ambas pilas simultáneamente
    Iterator<integer> iter1 = st1.iterator();
    Iterator<integer> iter2 = st2.iterator();
    while (iter1.hasNext() && iter2.hasNext()) {
        Integer val1 = iter1.next();
        Integer val2 = iter2.next();
        // comparar valores
        if (!val1.equals(val2)) {
            return false;
        }
    }
    // verificar si la iteración se completó sin discrepancias
    return (!iter1.hasNext() && !iter2.hasNext());
}

    Puedes probar este método utilizando el siguiente código:

    Stack<integer> st1 = new Stack<>();
st1.push(1);
st1.push(3);
st1.push(4);
st1.push(5);
Stack<integer> st2 = new Stack<>();
st2.push(4);
st2.push(3);
st2.push(1);
st2.push(5);
System.out.println(isSameStacks(st1, st2)); // true

    En este ejemplo, las dos pilas tienen los mismos valores y el mismo orden, por lo que el método retorna verdadero.

Comments are closed.