pilha de cenários de aplicação java pilha

Stack apresenta: último a sair 

1. cadeia simples, um inverso do número de K

public class MyNode {
    public Integer value;
    public MyNode next;
    public MyNode(Integer value) {
        this.value = value;
    }
    @Override
    public String toString() {
        return "MyNode{" +
                "value=" + value +
                ", next=" + next +
                '}';
    }
}

 MyNode node=new MyNode(1);
        MyNode temp=node;
        for(int i=2;i<11;i++){
            MyNode nodeNext=new MyNode(i);
            temp.next=nodeNext;
            temp=nodeNext;
        }
       int val= getSingleListLastKNum(node,4);
        System.out.println(val);

 public static int getSingleListLastKNum(MyNode node,int k){
        Stack<MyNode> stacks=new Stack<>();
        while(node!=null){
            stacks.push(node);
            node=node.next;
        }
        MyNode target=null;
        int size=stacks.size();
        while(stacks.size()>0){
            target=stacks.pop();
            int subSize=stacks.size();
            if(size-subSize==k){
                break;
            }
        }
       return target.value;
    }

A ideia é a pilha para a lista e, em seguida, removida da pilha de elementos de K de K, que é o inverso do número.

Esta é a melhor solução para a questão do ponteiro duplo, link aqui: https://www.cnblogs.com/edisonchou/p/4769164.html

2. A lista única, determinar se ele é um palíndromo

 MyNode node=new MyNode(1);
        MyNode temp=node;
        int j=1;
        for(int i=2;i<10;i++){
            int val=i;
            if(i>5){
                val=i-2*j;
                j++;
            }
            MyNode nodeNext=new MyNode(val);
            temp.next=nodeNext;
            temp=nodeNext;
        }
        System.out.println(node);
     boolean flag=isPalindromeNum(node);
        System.out.println(flag);

 public static boolean isPalindromeNum(MyNode node){
        boolean flag=true;
        MyNode originalNode=node;
        Stack<MyNode> stacks=new Stack<>();
        while(node!=null){
            stacks.push(node);
            node=node.next;
        }
        while(stacks.size()>0){
           Integer value=stacks.pop().value;
           Integer oriVal=originalNode.value;
           if(value!=oriVal){
               flag=false;
               break;
           }
           originalNode=originalNode.next;
        }
        return flag;
    }

A ideia é a pilha para a lista e, em seguida, removidos a partir dos elementos da pilha sequencialmente em comparação com o valor do nó na lista ligada, se um número não é igual para fora directamente, não descrito número paldroma, de outro modo palindrome.

Este problema da solução ideal é a velocidade do ponteiro, link aqui:  https://blog.csdn.net/whm114336793/article/details/79996943

 

resumo:

     De acordo com as características da pilha, avançaram depois achamos avaliação ou julgamento conveniente após uma característica comum destas duas questões é necessária para reverter uma lista ligada. Portanto, a pilha é a necessidade de dados uso de objetos ou arbitrárias cena depois de descer como um tipo de processamento lógico, por exemplo: a saída inversa, por isso são o verificador gramatical XML se encontram neste cenário