Encuentre el primer nodo con un cierto valor en la lista vinculada, elimine el nodo e imprima la lista vinculada de principio a fin

1. Busque el primer nodo con un valor determinado en la lista vinculada y elimine el nodo

• Método 1: Análisis: Existe una práctica común para esta pregunta, que es atravesar los nodos uno por uno, y si el valor del nodo es igual al valor dado, elimine el nodo.

Pero para eliminar un nodo, para una lista enlazada ordinaria, si es el nodo principal, afortunadamente, head = head.next directamente, y luego recorre hacia atrás sucesivamente. Aquí hay una situación extrema: si el nodo principal siempre ha sido el nodo que debe eliminarse, esta eliminación también debe realizar un ciclo while.

Además, para la eliminación de nodos ordinarios, normalmente solo necesitamos apuntar el siguiente del nodo anterior del nodo actual al siguiente del nodo actual. Por lo tanto, necesitamos dos punteros durante el proceso transversal, uno al nodo actual y otro al siguiente. El nodo antes del nodo actual.

• Método 2: en lugar de operar directamente la lista vinculada para eliminar, hizo un truco. Usando la estructura de datos de la pila, los nodos de datos que no son iguales al valor especificado en la lista vinculada se insertan secuencialmente en la pila. Después del final, se construye el final al principio. Lista vinculada, regrese al nodo principal.

public static Node removeElement(Node head, int val) {
    
    
        //判断头节点是否是删除的元素
        while (head != null) {
    
    
            if ((int) head.date != val) {
    
    
                break;
            }
            head = head.next;
            return head;
        }

        Node cur = head;
        Node pre = head;
        while (cur != null) {
    
    
            //第一次循环后cur和pre相差一个指针节点。
            if ((int) cur.date == val) {
    
    
                pre.next = cur.next;
            } else pre = cur;
            cur = cur.next;
        }
        return head;
    }

 public static Node remove(Node head, int val) {
    
    
        Stack<Node> stack = new Stack<Node>();
        while (head != null) {
    
    
            if ((int) head.date != val) {
    
    
                stack.push(head);
            }
            head = head.next;
        }
        while (!stack.empty()) {
    
    
            stack.peek().next = head;
            head = stack.pop();
        }
        return head;
    }

1.1 La variante es eliminar los nodos duplicados, en lugar de eliminar todos los nodos duplicados, conserve el primer nodo, si se repite más tarde, elimínelo. El código también se proporciona aquí:

Declaración de derechos de autor: Este artículo es el artículo original del blogger y sigue el acuerdo de derechos de autor CC 4.0 BY-SA. Adjunte el enlace de la fuente original y esta declaración para reimprimir.
Enlace a este artículo: http://blog.csdn.net/feinifi/article/details/94460480

2. Imprima la lista vinculada de principio a fin

• Solución 1: en el típico primero en entrar, último en salir, podemos usar la pila para lograr esta secuencia. Cada vez que se pasa un nodo, el nodo se coloca en una pila. Después de recorrer toda la lista vinculada, los valores de los nodos se emiten uno por uno comenzando desde la parte superior de la pila. En este momento, los nodos de salida se han invertido.
• Solución 2: utilice salida inversa recursiva.

    public static void PrintListReversing(Node head) {
    
    
        Stack<Node> stack = new Stack<Node>();
        while (head != null) {
    
    
            stack.push(head);
            head = head.next;
        }
        while (!stack.isEmpty()) {
    
    
            head = (Node) stack.pop();
            System.out.println(head.date);
        }
    }   

public static void PrintListReversing2(Node head) {
    
    
        if (head != null) {
    
    
            if (head.next != null) {
    
    
                PrintListReversing2(head.next);
            }
        }
        System.out.println(head.date);
    }