Creación de una clase LinkedList desde cero

Question

Se nos ha encomendado la tarea de crear una LinkedList desde cero, y no hay absolutamente ninguna lectura para guiarnos en esta tarea que causa migrañas. Además, todo lo que se usa en línea parece usar solo Java's incorporado en los métodos LinkedList y demás. De todos modos, las listas vinculadas tienen mucho sentido cuando se usan las cosas predeterminadas de Java, pero crearlas desde cero no tiene ningún sentido en absoluto. Digamos que tengo

public class LinkedList { 
    private LinkedList next; 
    private final String word; 
    // constructor 
    public LinkedList(String word, LinkedList next) { 
    this.word = word; 
    this.next = next; 
    } 

Y así mágicamente tenemos una lista vinculada. Que esta pasando? ¿Cómo he creado una lista vinculada así? ¿Como funciona esto? Se supone que debo escribir un método de adición que agregue un parámetro dado String word al final de this lista enlazada. Traté de ver el método addLast incorporado en la clase incorporada de la lista de enlaces java, pero no me sirve de nada, ya que realmente no entiendo qué está pasando. Alguien me importa para ayudarme :)

Answer 1

Si está realmente construir un sistema real, entonces sí, habitualmente se acaba de utilizar el material en la biblioteca estándar si lo que necesita está disponible allí. Dicho esto, no pienses en esto como un ejercicio sin sentido. Es bueno entender cómo funcionan las cosas, y comprender las listas vinculadas es un paso importante hacia la comprensión de estructuras de datos más complejas, muchas de las cuales no existen en las bibliotecas estándar.

Existen algunas diferencias entre la forma en que está creando una lista vinculada y la forma en que lo hace la API de colecciones de Java. La API de colecciones intenta adherirse a una interfaz más complicada. La lista enlazada API Collections es también una lista doblemente enlazada, mientras construyes una lista vinculada individualmente. Lo que estás haciendo es más apropiado para una tarea de clase.

Con su clase LinkedList, una instancia siempre será una lista de al menos un elemento. Con este tipo de configuración, usaría null para cuando necesite una lista vacía.

Piense en next como "el resto de la lista". De hecho, muchas implementaciones similares usan el nombre "cola" en lugar de "siguiente".

Aquí es un diagrama de un LinkedList que contienen 3 elementos:

Tenga en cuenta que se trata de un objeto LinkedList apunta a una palabra ("Hola") y una lista de 2 elementos. La lista de 2 elementos tiene una palabra ("Pila") y una lista de 1 elemento. Esa lista de 1 elemento tiene una palabra ("Desbordamiento") y una lista vacía (null). De modo que puede tratar next como solo otra lista que resulta ser un elemento más corto.

Es posible que desee agregar otro constructor que solo tome un String, y se establece al lado de null. Esto sería para crear una lista de 1 elemento.Para agregar, marque si next es null. Si es así, cree una nueva lista de elementos y establezca next.

next = new LinkedList(word); 

Si a continuación no es null, tiene que poner a next lugar.

next.append(word); 

Este es el enfoque recursivo, que es la cantidad mínima de código. Puede convertir eso en una solución iterativa que sería más eficiente en Java ^*, y no arriesgaría un desbordamiento de la pila con listas muy largas, pero supongo que ese nivel de complejidad no es necesario para su asignación.

---

^{* Algunas lenguas tienen la cola eliminación llamada, que es una optimización que permite la implementación del lenguaje convertir "llamadas de cola" (una llamada a otra función que el último paso antes de regresar) en (efectivamente) un " ir". Esto hace que dicho código evite por completo el uso de la pila, lo que lo hace más seguro (no se puede desbordar la pila si no se utiliza la pila) y, por lo general, es más eficiente. Esquema es probablemente el ejemplo más conocido de un idioma con esta característica.}

Answer 2

¿Cómo he creado una lista de enlaces como esta. ¿Como funciona esto? Esto es todo lo que es una lista vinculada. Un elemento con un enlace al siguiente elemento de la lista. Siempre que mantenga una referencia al elemento al principio de la lista, puede recorrer todo usando cada referencia posterior al siguiente valor.

Para agregar, todo lo que necesita hacer es encontrar el final de la lista y convertir el siguiente elemento en el valor que desea adjuntar, por lo que si no tiene nulo, deberá llamar a append en el siguiente elemento hasta que encuentre el final de la lista.

this.next.Append(word); 

Answer 3

Claro, una lista vinculada es un poco confusa para la programación de n00bs, más o menos la tentación es verla como muñecas rusas, porque eso es lo que parece, un objeto LinkedList en un objeto LinkedList. Pero es un toque difícil de visualizar, en cambio, míralo como una computadora.

ListaEnlazada = datos + siguiente miembro

Dónde es el último miembro de la lista si el próximo es NULL

Así LinkedList 5 miembros sería:

LinkedList (Datos1, LinkedList (Datos2 LinkedList (Dato3, LinkedList (Data4, LinkedList (Dato5, NULL)))))

Pero se puede pensar que es simplemente:

Data1 -> Da ta2 -> Data3 -> Data4 -> Data5 -> NULL

Entonces, ¿cómo encontramos el final de esto? Bueno, sabemos que el NULL es el final para:

public void append(LinkedList myNextNode) { 
    LinkedList current = this; //Make a variable to store a pointer to this LinkedList 
    while (current.next != NULL) { //While we're not at the last node of the LinkedList 
    current = current.next; //Go further down the rabbit hole. 
    } 
    current.next = myNextNode; //Now we're at the end, so simply replace the NULL with another Linked List! 
    return; //and we're done! 
} 

Este es un código muy simple, por supuesto, y lo hará bucle infinito si se le da de comer una lista ligada circularmente! Pero eso es lo básico.

Answer 4

Lo que ha codificado no es un LinkedList, al menos no uno que yo reconozca. Para esta tarea, que desea crear dos clases:

LinkNode 
LinkedList 

Un LinkNode tiene un campo miembro por los datos que contiene, y una referencia a la siguiente LinkNodeLinkNode en el LinkedList. Sí, es una estructura de datos autorreferencial. A LinkedList solo tiene una referencia especial LinkNode que hace referencia al primer elemento de la lista.

Cuando agrega un artículo en el LinkedList, recorre todos los LinkNode's hasta llegar al último. Este LinkNode's siguiente debe ser nulo. A continuación, construya un nuevo LinkNode aquí, establezca su valor y agréguelo al LinkedList.

public class LinkNode { 

    String data; 
    LinkNode next; 

    public LinkNode(String item) { 

     data = item; 

    } 

} 

public class LinkedList { 

    LinkNode head; 

    public LinkedList(String item) { 

     head = new LinkNode(item); 

    } 

    public void add(String item) { 

     //pseudo code: while next isn't null, walk the list 
     //once you reach the end, create a new LinkNode and add the item to it. Then 
     //set the last LinkNode's next to this new LinkNode 

    } 


} 

Answer 5

Pista 1: leer la descripción de las listas enlazadas en http://en.wikipedia.org/wiki/Linked_list

Pista 2: la implementación en Java de LinkedList es una lista doblemente enlazada. La suya es una lista individualmente vinculada. Los algoritmos no se aplican directamente.

---

también:

... pero la creación de [una clase de lista enlazada] desde cero no tiene ningún sentido.

Depende de cuál es el resultado requerido del trabajo. Si el objetivo es producir código que cumpla con ciertos requisitos funcionales/no funcionales, entonces tiene razón. Si el objetivo real es para usted learn cómo programar/diseñar API/implementar estructuras de datos no triviales, entonces la utilidad del producto final es casi completamente irrelevante.

Y así mágicamente tenemos una lista enlazada

Lo que realmente tiene que hay un tipo de datos abierta, que podría ser utilizado para construir una lista (más o menos). Pero eso no es lo que tu maestro quiere. Y ciertamente no se consideraría una útil abstracción de la lista. Una abstracción útil incluiría:

• métodos para hacer las cosas que los programadores no quieren tener que repetir una y otra vez, y

• una capa de abstracción que para los programadores de "romper" la lista ; p.ej. al crear accidentalmente un ciclo o al coser accidentalmente una sublista en dos listas para crear un árbol invertido.

Answer 6

¿Qué tal una aplicación totalmente funcional de una lista enlazada no recursivo?

Creé esto para mi clase Algorithms I como un trampolín para obtener una mejor comprensión antes de pasar a escribir una clase de cola doblemente enlazada para una tarea.

Aquí está el código:

import java.util.Iterator; 
import java.util.NoSuchElementException; 

public class LinkedList<T> implements Iterable<T> { 
    private Node first; 
    private Node last; 
    private int N; 

    public LinkedList() { 
     first = null; 
     last = null; 
     N = 0; 
    } 

    public void add(T item) { 
     if (item == null) { throw new NullPointerException("The first argument for addLast() is null."); } 
     if (!isEmpty()) { 
      Node prev = last; 
      last = new Node(item, null); 
      prev.next = last; 
     } 
     else { 
      last = new Node(item, null); 
      first = last; 
     } 
     N++; 
    } 

    public boolean remove(T item) { 
     if (isEmpty()) { throw new IllegalStateException("Cannot remove() from and empty list."); } 
     boolean result = false; 
     Node prev = first; 
     Node curr = first; 
     while (curr.next != null || curr == last) { 
      if (curr.data.equals(item)) { 
       // remove the last remaining element 
       if (N == 1) { first = null; last = null; } 
       // remove first element 
       else if (curr.equals(first)) { first = first.next; } 
       // remove last element 
       else if (curr.equals(last)) { last = prev; last.next = null; } 
       // remove element 
       else { prev.next = curr.next; } 
       N--; 
       result = true; 
       break; 
      } 
      prev = curr; 
      curr = prev.next; 
     } 
     return result; 
    } 

    public int size() { 
     return N; 
    } 

    public boolean isEmpty() { 
     return N == 0; 
    } 

    private class Node { 
     private T data; 
     private Node next; 

     public Node(T data, Node next) { 
      this.data = data; 
      this.next = next; 
     } 
    } 

    public Iterator<T> iterator() { return new LinkedListIterator(); } 

    private class LinkedListIterator implements Iterator<T> { 
     private Node current = first; 

     public T next() { 
      if (!hasNext()) { throw new NoSuchElementException(); } 
      T item = current.data; 
      current = current.next; 
      return item; 
     } 

     public boolean hasNext() { return current != null; } 

     public void remove() { throw new UnsupportedOperationException(); } 
    } 

    @Override public String toString() { 
     StringBuilder s = new StringBuilder(); 
     for (T item : this) 
      s.append(item + " "); 
     return s.toString(); 
    } 

    public static void main(String[] args) { 
     LinkedList<String> list = new LinkedList<>(); 
     while(!StdIn.isEmpty()) { 
      String input = StdIn.readString(); 
      if (input.equals("print")) { StdOut.println(list.toString()); continue; } 
      if (input.charAt(0) == ('+')) { list.add(input.substring(1)); continue; } 
      if (input.charAt(0) == ('-')) { list.remove(input.substring(1)); continue; } 
      break; 
     } 
    } 
} 

Nota: Es una aplicación muy básica de una lista simplemente enlazada. El tipo 'T' es un marcador de posición de tipo genérico. Básicamente, esta lista vinculada debería funcionar con cualquier tipo que herede de Object. Si lo usa para tipos primitivos, asegúrese de usar los equivalentes de clase anulables (por ejemplo, 'Entero' para el tipo 'int'). La 'última' variable no es realmente necesaria, excepto que acorta las inserciones en O (1) tiempo.Las eliminaciones son lentas, ya que se ejecutan en tiempo O (N) pero le permite eliminar la primera aparición de un valor en la lista.

Si lo desea, también puede informarse sobre la implementación:

• addFirst() - añadir un nuevo elemento a la comienzo de la ListaEnlazada
• removeFirst() - eliminar el primer elemento de la Lista enlazada
• removeLast() - eliminar el último elemento de la lista enlazada
• addAll() - añadir una lista/conjunto de elementos a la lista enlazada
• removeAll() - eliminar una lista/conjunto de elemento s de la ListaEnlazada
• contains() - comprobar para ver si el ListaEnlazada contiene un elemento
• contains() - Borrar todos los artículos en la Lista enlazada

Honestamente, sólo se necesitan unas pocas líneas de código para hacer esto una lista doblemente vinculada. La principal diferencia entre esto y una lista doblemente enlazada es que las instancias de nodo de una lista doblemente enlazada requieren una referencia adicional que apunte al elemento anterior en la lista.

El beneficio de esto en una implementación recursiva es que es más rápido y no tiene que preocuparse por inundar la pila cuando recorre grandes listas.

Hay 3 órdenes para poner a prueba esta en el depurador/consola:

• prefijar un valor de un '+' se añadirá a la lista.
• Prefijo con un '-' eliminará la primera aparición de la lista.
• Al escribir 'imprimir' se imprimirá la lista con los valores separados por espacios.

Si nunca ha visto la parte interna de cómo uno de estos trabajos, propongo que el paso por el siguiente en el depurador:

• add() - tachuelas un nuevo nodo en el extremo o inicializa el primeros/últimos valores si la lista está vacía
• remove() - recorre la lista desde el comienzo hasta el final. Si encuentra una coincidencia, elimina ese elemento y conecta los enlaces rotos entre los enlaces anteriores y siguientes de la cadena. Se agregan excepciones especiales cuando no hay un enlace anterior o siguiente.
• toString(): utiliza el iterador foreach para simplemente recorrer la cadena de lista de principio a fin.

Si bien existen enfoques mejores y más eficientes para listas como listas de matrices, entender cómo atraviesa la aplicación a través de referencias/punteros es esencial para entender el funcionamiento de muchas estructuras de datos de alto nivel.

Answer 7

class Node 
{ 
    int data; 
    Node link; 

    public Node() 
    { 
     data=0; 
     link=null; 
     } 

    Node ptr,start,temp; 

    void create()throws IOException 
    { 
     int n; 
     BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); 
     System.out.println("Enter first data"); 
     this.data=Integer.parseInt(br.readLine()); 
     ptr=this; 
     start=ptr; 
     char ins ='y'; 
     do 
     { 
      System.out.println("Wanna Insert another node???"); 
      ins=(char)br.read(); 
      br.read(); 
      if(ins=='y') 
      { 
       temp=new Node(); 
       System.out.println("Enter next data"); 
       temp.data=Integer.parseInt(br.readLine()); 
       temp.link=null; 
       ptr.link=temp; 
       temp=null; 
       ptr=ptr.link; 
       } 
      }while(ins=='y'); 
     } 

public static void main(String args[])throws IOException 
    { 
     Node first= new Node(); 
     first.create(); 
} 
} 

Answer 8

Por favor, lea este artículo: How To Implement a LinkedList Class From Scratch In Java

package com.crunchify.tutorials; 

/** 
* @author Crunchify.com 
*/ 

public class CrunchifyLinkedListTest { 

    public static void main(String[] args) { 
     CrunchifyLinkedList lList = new CrunchifyLinkedList(); 

     // add elements to LinkedList 
     lList.add("1"); 
     lList.add("2"); 
     lList.add("3"); 
     lList.add("4"); 
     lList.add("5"); 

     /* 
     * Please note that primitive values can not be added into LinkedList 
     * directly. They must be converted to their corresponding wrapper 
     * class. 
     */ 

     System.out.println("lList - print linkedlist: " + lList); 
     System.out.println("lList.size() - print linkedlist size: " + lList.size()); 
     System.out.println("lList.get(3) - get 3rd element: " + lList.get(3)); 
     System.out.println("lList.remove(2) - remove 2nd element: " + lList.remove(2)); 
     System.out.println("lList.get(3) - get 3rd element: " + lList.get(3)); 
     System.out.println("lList.size() - print linkedlist size: " + lList.size()); 
     System.out.println("lList - print linkedlist: " + lList); 
    } 
} 

class CrunchifyLinkedList { 
    // reference to the head node. 
    private Node head; 
    private int listCount; 

    // LinkedList constructor 
    public CrunchifyLinkedList() { 
     // this is an empty list, so the reference to the head node 
     // is set to a new node with no data 
     head = new Node(null); 
     listCount = 0; 
    } 

    public void add(Object data) 
    // appends the specified element to the end of this list. 
    { 
     Node crunchifyTemp = new Node(data); 
     Node crunchifyCurrent = head; 
     // starting at the head node, crawl to the end of the list 
     while (crunchifyCurrent.getNext() != null) { 
      crunchifyCurrent = crunchifyCurrent.getNext(); 
     } 
     // the last node's "next" reference set to our new node 
     crunchifyCurrent.setNext(crunchifyTemp); 
     listCount++;// increment the number of elements variable 
    } 

    public void add(Object data, int index) 
    // inserts the specified element at the specified position in this list 
    { 
     Node crunchifyTemp = new Node(data); 
     Node crunchifyCurrent = head; 
     // crawl to the requested index or the last element in the list, 
     // whichever comes first 
     for (int i = 1; i < index && crunchifyCurrent.getNext() != null; i++) { 
      crunchifyCurrent = crunchifyCurrent.getNext(); 
     } 
     // set the new node's next-node reference to this node's next-node 
     // reference 
     crunchifyTemp.setNext(crunchifyCurrent.getNext()); 
     // now set this node's next-node reference to the new node 
     crunchifyCurrent.setNext(crunchifyTemp); 
     listCount++;// increment the number of elements variable 
    } 

    public Object get(int index) 
    // returns the element at the specified position in this list. 
    { 
     // index must be 1 or higher 
     if (index <= 0) 
      return null; 

     Node crunchifyCurrent = head.getNext(); 
     for (int i = 1; i < index; i++) { 
      if (crunchifyCurrent.getNext() == null) 
       return null; 

      crunchifyCurrent = crunchifyCurrent.getNext(); 
     } 
     return crunchifyCurrent.getData(); 
    } 

    public boolean remove(int index) 
    // removes the element at the specified position in this list. 
    { 
     // if the index is out of range, exit 
     if (index < 1 || index > size()) 
      return false; 

     Node crunchifyCurrent = head; 
     for (int i = 1; i < index; i++) { 
      if (crunchifyCurrent.getNext() == null) 
       return false; 

      crunchifyCurrent = crunchifyCurrent.getNext(); 
     } 
     crunchifyCurrent.setNext(crunchifyCurrent.getNext().getNext()); 
     listCount--; // decrement the number of elements variable 
     return true; 
    } 

    public int size() 
    // returns the number of elements in this list. 
    { 
     return listCount; 
    } 

    public String toString() { 
     Node crunchifyCurrent = head.getNext(); 
     String output = ""; 
     while (crunchifyCurrent != null) { 
      output += "[" + crunchifyCurrent.getData().toString() + "]"; 
      crunchifyCurrent = crunchifyCurrent.getNext(); 
     } 
     return output; 
    } 

    private class Node { 
     // reference to the next node in the chain, 
     // or null if there isn't one. 
     Node next; 
     // data carried by this node. 
     // could be of any type you need. 
     Object data; 

     // Node constructor 
     public Node(Object dataValue) { 
      next = null; 
      data = dataValue; 
     } 

     // another Node constructor if we want to 
     // specify the node to point to. 
     public Node(Object dataValue, Node nextValue) { 
      next = nextValue; 
      data = dataValue; 
     } 

     // these methods should be self-explanatory 
     public Object getData() { 
      return data; 
     } 

     public void setData(Object dataValue) { 
      data = dataValue; 
     } 

     public Node getNext() { 
      return next; 
     } 

     public void setNext(Node nextValue) { 
      next = nextValue; 
     } 
    } 
} 

salida

lList - print linkedlist: [1][2][3][4][5] 
lList.size() - print linkedlist size: 5 
lList.get(3) - get 3rd element: 3 
lList.remove(2) - remove 2nd element: true 
lList.get(3) - get 3rd element: 4 
lList.size() - print linkedlist size: 4 
lList - print linkedlist: [1][3][4][5] 

Answer 9

lista Vinculado para demostrar inserción frontal, Eliminar delantero, inserción posterior y borrar operaciones traseras en Java:

import java.io.DataInputStream; 
import java.io.IOException; 


public class LinkedListTest { 

public static void main(String[] args) { 
    // TODO Auto-generated method stub  
    Node root = null; 

    DataInputStream reader = new DataInputStream(System.in);   
    int op = 0; 
    while(op != 6){ 

     try { 
      System.out.println("Enter Option:\n1:Insert Front 2:Delete Front 3:Insert Rear 4:Delete Rear 5:Display List 6:Exit"); 
      //op = reader.nextInt(); 
      op = Integer.parseInt(reader.readLine()); 
      switch (op) { 
      case 1: 
       System.out.println("Enter Value: "); 
       int val = Integer.parseInt(reader.readLine()); 
       root = insertNodeFront(val,root); 
       display(root); 
       break; 
      case 2: 
       root=removeNodeFront(root); 
       display(root); 
       break; 
      case 3: 
       System.out.println("Enter Value: "); 
       val = Integer.parseInt(reader.readLine()); 
       root = insertNodeRear(val,root); 
       display(root); 
       break; 
      case 4: 
       root=removeNodeRear(root); 
       display(root); 
       break; 
      case 5: 
       display(root); 
       break; 
      default: 
       System.out.println("Invalid Option"); 
       break; 
      } 
     } catch (Exception e) { 
      // TODO Auto-generated catch block 
      e.printStackTrace(); 
     } 
    } 
    System.out.println("Exited!!!"); 
    try { 
     reader.close(); 
    } catch (IOException e) { 
     // TODO Auto-generated catch block 
     e.printStackTrace(); 
    }  
} 

static Node insertNodeFront(int value, Node root){ 
    Node temp = new Node(value); 
    if(root==null){ 
     return temp; // as root or first 
    } 
    else 
    { 
     temp.next = root; 
     return temp; 
    }    
} 

static Node removeNodeFront(Node root){ 
    if(root==null){ 
     System.out.println("List is Empty"); 
     return null; 
    } 
    if(root.next==null){ 
     return null; // remove root itself 
    } 
    else 
    { 
     root=root.next;// make next node as root 
     return root; 
    }    
} 

static Node insertNodeRear(int value, Node root){ 
    Node temp = new Node(value); 
    Node cur = root; 
    if(root==null){ 
     return temp; // as root or first 
    } 
    else 
    { 
     while(cur.next!=null) 
     { 
      cur = cur.next; 
     } 
     cur.next = temp; 
     return root; 
    }    
} 

static Node removeNodeRear(Node root){ 
    if(root==null){ 
     System.out.println("List is Empty"); 
     return null; 
    } 
    Node cur = root; 
    Node prev = null; 
    if(root.next==null){ 
     return null; // remove root itself 
    } 
    else 
    { 
     while(cur.next!=null) 
     { 
      prev = cur; 
      cur = cur.next; 
     } 
     prev.next=null;// remove last node 
     return root; 
    }    
} 

static void display(Node root){ 
    System.out.println("Current List:"); 
    if(root==null){ 
     System.out.println("List is Empty"); 
     return; 
    } 
    while (root!=null){ 
     System.out.print(root.val+"->"); 
     root=root.next; 
    } 
    System.out.println(); 
} 

static class Node{ 
    int val; 
    Node next; 
    public Node(int value) { 
     // TODO Auto-generated constructor stub 
     val = value; 
     next = null; 
    } 
} 
} 

Answer 10

Acabo de hacer una esencia en github implementando LinkedList from Scratch. Puede ayudar. Echale un vistazo.

https://gist.github.com/akshaynagpal/14ee8b54cd018bd05b2a3c2432c818dc

Answer 11

Vinculado con Programa Lista siguientes funcionalidades

1 Insert At Start 
2 Insert At End 
3 Insert At any Position 
4 Delete At any Position 
5 Display 
6 Get Size 
7 Empty Status 
8 Replace data at given postion 
9 Search Element by position 
10 Delete a Node by Given Data 
11 Search Element Iteratively 
12 Search Element Recursively 




package com.elegant.ds.linkedlist.practice; 

import java.util.Scanner; 

class Node { 

    Node link = null; 
    int data = 0; 

    public Node() { 
     link = null; 
     data = 0; 
    } 

    public Node(int data, Node link) { 
     this.data = data; 
     this.link = null; 
    } 

    public Node getLink() { 
     return link; 
    } 

    public void setLink(Node link) { 
     this.link = link; 
    } 

    public int getData() { 
     return data; 
    } 

    public void setData(int data) { 
     this.data = data; 
    } 

} 

class SinglyLinkedListImpl { 

    Node start = null; 
    Node end = null; 
    int size = 0; 

    public SinglyLinkedListImpl() { 
     start = null; 
     end = null; 
     size = 0; 
    } 

    public void insertAtStart(int data) { 
     Node nptr = new Node(data, null); 
     if (start == null) { 
      start = nptr; 
      end = start; 
     } else { 
      nptr.setLink(start); 
      start = nptr; 
     } 
     size++; 
    } 

    public void insertAtEnd(int data) { 
     Node nptr = new Node(data, null); 
     if (start == null) { 
      start = nptr; 
      end = nptr; 
     } else { 
      end.setLink(nptr); 
      end = nptr; 
     } 
     size++; 
    } 

    public void insertAtPosition(int position, int data) { 
     Node nptr = new Node(data, null); 
     Node ptr = start; 
     position = position - 1; 
     for (int i = 1; i < size; i++) { 
      if (i == position) { 
       Node temp = ptr.getLink(); 
       ptr.setLink(nptr); 
       nptr.setLink(temp); 
       break; 
      } 
      ptr = ptr.getLink(); 
     } 
     size++; 
    } 

    public void repleaceDataAtPosition(int position, int data) { 
     if (start == null) { 
      System.out.println("Empty!"); 
      return; 
     } 

     Node ptr = start; 
     for (int i = 1; i < size; i++) { 
      if (i == position) { 
       ptr.setData(data); 
      } 
      ptr = ptr.getLink(); 
     } 
    } 

    public void deleteAtPosition(int position) { 
     if (start == null) { 
      System.out.println("Empty!"); 
      return; 
     } 

     if (position == size) { 
      Node startPtr = start; 
      Node endPtr = start; 
      while (startPtr != null) { 
       endPtr = startPtr; 
       startPtr = startPtr.getLink(); 
      } 
      end = endPtr; 
      end.setLink(null); 
      size--; 
      return; 
     } 

     Node ptr = start; 
     position = position - 1; 
     for (int i = 1; i < size; i++) { 

      if (i == position) { 
       Node temp = ptr.getLink(); 
       temp = temp.getLink(); 
       ptr.setLink(temp); 
       break; 
      } 
      ptr = ptr.getLink(); 
     } 
     size--; 
    } 

    public void deleteNodeByGivenData(int data) { 
     if (start == null) { 
      System.out.println("Empty!"); 
      return; 
     } 

     if (start.getData() == data && start.getLink() == null) { 
      start = null; 
      end = null; 
      size--; 
      return; 
     } 

     if (start.getData() == data && start.getLink() != null) { 
      start = start.getLink(); 
      size--; 
      return; 
     } 

     if (end.getData() == data) { 
      Node startPtr = start; 
      Node endPtr = start; 

      startPtr = startPtr.getLink(); 
      while (startPtr.getLink() != null) { 
       endPtr = startPtr; 
       startPtr = startPtr.getLink(); 
      } 
      end = endPtr; 
      end.setLink(null); 
      size--; 
      return; 
     } 

     Node startPtr = start; 
     Node prevLink = startPtr; 
     startPtr = startPtr.getLink(); 
     while (startPtr.getData() != data && startPtr.getLink() != null) { 
      prevLink = startPtr; 
      startPtr = startPtr.getLink(); 
     } 
     if (startPtr.getData() == data) { 
      Node temp = prevLink.getLink(); 
      temp = temp.getLink(); 
      prevLink.setLink(temp); 
      size--; 
      return; 
     } 

     System.out.println(data + " not found!"); 
    } 

    public void disply() { 
     if (start == null) { 
      System.out.println("Empty!"); 
      return; 
     } 

     if (start.getLink() == null) { 
      System.out.println(start.getData()); 
      return; 
     } 

     Node ptr = start; 
     System.out.print(ptr.getData() + "->"); 
     ptr = start.getLink(); 
     while (ptr.getLink() != null) { 
      System.out.print(ptr.getData() + "->"); 
      ptr = ptr.getLink(); 
     } 
     System.out.println(ptr.getData() + "\n"); 
    } 

    public void searchElementByPosition(int position) { 
     if (position == 1) { 
      System.out.println("Element at " + position + " is : " + start.getData()); 
      return; 
     } 

     if (position == size) { 
      System.out.println("Element at " + position + " is : " + end.getData()); 
      return; 
     } 

     Node ptr = start; 
     for (int i = 1; i < size; i++) { 
      if (i == position) { 
       System.out.println("Element at " + position + " is : " + ptr.getData()); 
       break; 
      } 
      ptr = ptr.getLink(); 
     } 
    } 

    public void searchElementIteratively(int data) { 

     if (isEmpty()) { 
      System.out.println("Empty!"); 
      return; 
     } 

     if (start.getData() == data) { 
      System.out.println(data + " found at " + 1 + " position"); 
      return; 
     } 

     if (start.getLink() != null && end.getData() == data) { 
      System.out.println(data + " found at " + size + " position"); 
      return; 
     } 

     Node startPtr = start; 
     int position = 0; 
     while (startPtr.getLink() != null) { 
      ++position; 
      if (startPtr.getData() == data) { 
       break; 
      } 
      startPtr = startPtr.getLink(); 
     } 
     if (startPtr.getData() == data) { 
      System.out.println(data + " found at " + position); 
      return; 
     } 

     System.out.println(data + " No found!"); 
    } 

    public void searchElementRecursively(Node start, int data, int count) { 

     if (isEmpty()) { 
      System.out.println("Empty!"); 
      return; 
     } 
     if (start.getData() == data) { 
      System.out.println(data + " found at " + (++count)); 
      return; 
     } 
     if (start.getLink() == null) { 
      System.out.println(data + " not found!"); 
      return; 
     } 
     searchElementRecursively(start.getLink(), data, ++count); 
    } 

    public int getSize() { 
     return size; 
    } 

    public boolean isEmpty() { 
     return start == null; 
    } 
} 

public class SinglyLinkedList { 

    @SuppressWarnings("resource") 
    public static void main(String[] args) { 
     SinglyLinkedListImpl listImpl = new SinglyLinkedListImpl(); 
     System.out.println("Singly Linked list : "); 
     boolean yes = true; 
     do { 
      System.out.println("1 Insert At Start :"); 
      System.out.println("2 Insert At End :"); 
      System.out.println("3 Insert At any Position :"); 
      System.out.println("4 Delete At any Position :"); 
      System.out.println("5 Display :"); 
      System.out.println("6 Get Size"); 
      System.out.println("7 Empty Status"); 
      System.out.println("8 Replace data at given postion"); 
      System.out.println("9 Search Element by position "); 
      System.out.println("10 Delete a Node by Given Data"); 
      System.out.println("11 Search Element Iteratively"); 
      System.out.println("12 Search Element Recursively"); 
      System.out.println("13 Exit :"); 
      Scanner scanner = new Scanner(System.in); 
      int choice = scanner.nextInt(); 
      switch (choice) { 
      case 1: 
       listImpl.insertAtStart(scanner.nextInt()); 
       break; 

      case 2: 
       listImpl.insertAtEnd(scanner.nextInt()); 
       break; 

      case 3: 
       int position = scanner.nextInt(); 
       if (position <= 1 || position > listImpl.getSize()) { 
        System.out.println("invalid position!"); 
       } else { 
        listImpl.insertAtPosition(position, scanner.nextInt()); 
       } 
       break; 

      case 4: 
       int deletePosition = scanner.nextInt(); 
       if (deletePosition <= 1 || deletePosition > listImpl.getSize()) { 
        System.out.println("invalid position!"); 
       } else { 
        listImpl.deleteAtPosition(deletePosition); 
       } 
       break; 

      case 5: 
       listImpl.disply(); 
       break; 

      case 6: 
       System.out.println(listImpl.getSize()); 
       break; 

      case 7: 
       System.out.println(listImpl.isEmpty()); 
       break; 

      case 8: 
       int replacePosition = scanner.nextInt(); 
       if (replacePosition < 1 || replacePosition > listImpl.getSize()) { 
        System.out.println("Invalid position!"); 
       } else { 
        listImpl.repleaceDataAtPosition(replacePosition, scanner.nextInt()); 
       } 
       break; 

      case 9: 
       int searchPosition = scanner.nextInt(); 
       if (searchPosition < 1 || searchPosition > listImpl.getSize()) { 
        System.out.println("Invalid position!"); 
       } else { 
        listImpl.searchElementByPosition(searchPosition); 
       } 
       break; 

      case 10: 
       listImpl.deleteNodeByGivenData(scanner.nextInt()); 
       break; 

      case 11: 
       listImpl.searchElementIteratively(scanner.nextInt()); 
       break; 

      case 12: 
       listImpl.searchElementRecursively(listImpl.start, scanner.nextInt(), 0); 
       break; 

      default: 
       System.out.println("invalid choice"); 
       break; 
      } 
     } while (yes); 
    } 
} 

Se le ayudarán en la lista enlazada.