Создание класса LinkedList с нуля

Question

Нам было дано задание создать LinkedList с нуля, и мы не получили никаких чтений, которые бы помогли нам в этой задаче, вызывающей мигранты.Кроме того, все в Интернете, похоже, просто использует встроенные в Java методы LinkedList и прочее.В любом случае, связанные списки имеют смысл при использовании Java-материалов по умолчанию, но создавать их с нуля не имеет никакого смысла.Допустим, у меня есть

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

И, таким образом, волшебным образом у нас есть связанный список.Что здесь происходит?Как я создал связанный список, как это?Как это работает?Я должен написать метод добавления, который добавляет заданный параметр String word в конец списка ссылок this.Я попытался взглянуть на встроенный метод addLast для встроенного в java связного класса, но это мне не помогло, так как я действительно не понимаю, что происходит.Кто-нибудь хочет помочь мне:)

Answer 1

Если вы на самом деле строите реальную систему, тогда да, вы обычно просто используете материал из стандартной библиотеки, если там есть то, что вам нужно. Тем не менее, не думайте об этом как бессмысленное упражнение. Хорошо понимать, как все работает, и понимание связанных списков является важным шагом к пониманию более сложных структур данных, многих из которых нет в стандартных библиотеках.

Существуют некоторые различия между способом создания связанного списка и способом, которым это делает API коллекций Java. API коллекций пытается придерживаться более сложного интерфейса. Связанный список API коллекций также является двусвязным списком, пока вы создаете односвязный список. То, что вы делаете, больше подходит для назначения класса.

С вашим классом LinkedList экземпляр всегда будет списком хотя бы из одного элемента. При такой настройке вы будете использовать null, когда вам нужен пустой список.

Думайте о next как о «остальной части списка». На самом деле, многие подобные реализации используют имя «tail» вместо «next».

Вот схема LinkedList, содержащая 3 элемента:

Обратите внимание, что это LinkedList объект, указывающий на слово («Hello») и список из 2 элементов. Список из 2 элементов имеет слово («стек») и список из 1 элемента. Этот список из 1 элемента имеет слово («Переполнение») и пустой список (null). Таким образом, вы можете рассматривать next как еще один список, который оказывается на один элемент короче.

Возможно, вы захотите добавить другой конструктор, который просто берет строку и устанавливает рядом с null. Это будет для создания списка из 1 элемента.

Чтобы добавить, вы проверяете, является ли next null. Если это так, создайте новый список из одного элемента и задайте для него next.

next = new LinkedList(word);

Если следующий не null, тогда добавьте next.

next.append(word);

Это рекурсивный подход, который является наименьшим количеством кода. Вы можете превратить это в итеративное решение, которое было бы более эффективным в Java ^* и не рисковало бы переполнением стека с очень длинными списками, но я предполагаю, что уровень сложности не нужен для Ваше назначение.

---

^{* В некоторых языках есть устранение хвостовых вызовов, что является оптимизацией, которая позволяет языковой реализации преобразовывать «хвостовые вызовы» (вызов другой функции как самый последний шаг перед возвратом) в (эффективно) «переход» , Это делает такой код полностью избегающим использования стека, что делает его более безопасным (вы не можете переполнить стек, если не используете его) и, как правило, более эффективно. Схема, пожалуй, самый известный пример языка с этой функцией.}

Answer 2

То, что вы кодировали, не является LinkedList , по крайней мере, не тем, которое я узнаю.Для этого назначения вы хотите создать два класса:

LinkNode
LinkedList

A LinkNode имеет одно поле-член для содержащихся в нем данных и ссылку LinkNode на следующие LinkNode в LinkedList.Да, это самостоятельная структура данных.LinkedList просто имеет специальную ссылку LinkNode, которая относится к первому элементу в списке.

Когда вы добавляете элемент в LinkedList, вы пересекаете все LinkNode's, пока не достигнете последнего.Этот LinkNode's следующий должен быть нулевым.Затем вы создаете новый LinkNode здесь, устанавливаете его значение и добавляете его к 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 3

Как насчет полнофункциональной реализации нерекурсивного связанного списка?

Я создал это для своего Алгоритма, который я классифицирую, как ступеньку для лучшего понимания, прежде чем перейти к написанию двусвязанного класса очереди для назначения.

Вот код:

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;
        }
    }
}

Примечание. Это довольно простая реализация односвязного списка. Тип 'T' является заполнителем универсального типа. По сути, этот связанный список должен работать с любым типом, который наследуется от Object. Если вы используете его для примитивных типов, обязательно используйте обнуляемые эквиваленты классов (например, «Integer» для типа «int»). Переменная 'last' на самом деле не нужна, за исключением того, что она сокращает вставки до O (1) времени. Удаление выполняется медленно, так как оно выполняется за время O (N), но позволяет удалить первое вхождение значения в списке.

Если вы хотите, вы также можете посмотреть на реализацию:

• addFirst () - добавить новый элемент в начало LinkedList
• removeFirst () - удалить первый элемент из LinkedList
• removeLast () - удалить последний элемент из LinkedList
• addAll () - добавить список / массив элементов в LinkedList
• removeAll () - удалить список / массив элементов из LinkedList
• contains () - проверить, содержит ли LinkedList элемент
• содержит () - очистить все элементы в LinkedList

Честно говоря, требуется всего несколько строк кода, чтобы создать этот двусвязный список. Основное различие между этим списком и двусвязным списком состоит в том, что экземпляры Node двусвязного списка требуют дополнительной ссылки, которая указывает на предыдущий элемент в списке.

Преимущество этого по сравнению с рекурсивной реализацией состоит в том, что это быстрее, и вам не нужно беспокоиться о переполнении стека при обходе больших списков.

В отладчике / консоли есть 3 команды для проверки:

• Добавление префикса к значению «+» добавит его в список.
• Префикс «-» удалит первое вхождение из списка.
• Если вы напечатаете «print», список будет распечатан со значениями, разделенными пробелами.

Если вы никогда не видели внутренностей того, как работает одно из этих явлений, я предлагаю вам в отладчике выполнить следующие действия:

• add () - привязывает новый узел к концу или инициализирует первое / последнее значения, если список пуст
• remove () - просмотр списка от начала до конца. Если он находит совпадение, он удаляет этот элемент и соединяет разорванные ссылки между предыдущими и следующими ссылками в цепочке. Особые исключения добавляются, когда нет предыдущей или следующей ссылки.
• toString () - использует итератор foreach для простого обхода цепочки списков от начала до конца.

Несмотря на то, что существуют лучшие и более эффективные подходы к спискам, таким как списки массивов, понимание того, как приложение перемещается по ссылкам / указателям, является неотъемлемой частью понимания того, сколько структур данных верхнего уровня работает.

Answer 4

Подсказка 1: прочитайте описание связанных списков на http://en.wikipedia.org/wiki/Linked_list

Подсказка 2: Java-реализация LinkedList представляет собой двусвязный список. Ваш односвязный список. Алгоритмы не применяются напрямую.

---

Также:

... но создание [класса связанного списка] с нуля не имеет никакого смысла.

Это зависит от того, каков будет требуемый результат работы. Если целью является создание кода, который соответствует определенным функциональным / нефункциональным требованиям, то вы правы. Если цель real состоит в том, чтобы узнать , как программировать / проектировать API / реализовывать нетривиальные структуры данных, то полезность конечного продукта практически не имеет значения.

И, таким образом, волшебным образом у нас есть связанный список

На самом деле у вас есть открытый тип данных, который можно использовать для создания (своего рода) списка. Но это не то, что хочет ваш учитель. И это, конечно, не будет считаться полезной абстракцией списка. Полезная абстракция будет включать в себя:

• методы, которые программисты не хотят повторять снова и снова, и

• уровень абстракции, который мешает программистам «ломать» список; например путем случайного создания цикла или случайного объединения подсписка в два списка для создания перевернутого дерева.

Answer 5

Конечно, связанный список немного запутывает программирование n00bs, почти искушение смотреть на него как на Русские куклы, потому что это похоже на объект LinkedList в объекте LinkedList.Но это прикосновение трудно визуализировать, вместо этого смотрите на него как на компьютер.

LinkedList = Data + Next Member

Где последний элемент списка, если следующим является NULL

Таким образом, LinkedList из 5 членов будет:

LinkedList (Data1, LinkedList (Data2, LinkedList (Data3, LinkedList (Data4, LinkedList (Data5, NULL)))))))

Но выможно думать об этом просто:

Данные1 -> Данные2 -> Данные3 -> Данные4 -> Данные5 -> NULL

Итак, как нам найти конец этому?Что ж, мы знаем, что NULL - это конец, поэтому:

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!
}

Конечно, это очень простой код, и он будет бесконечно зацикливаться, если вы передадите ему список по кругу!Но это основы.

Answer 6

Программа со связанным списком со следующими функциями

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);
    }
}

Это поможет вам в связанном списке.

Answer 7

Связанный список для демонстрации операций вставки спереди, удаления спереди, вставки сзади и удаления сзади в 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 8

Как я создал подобный список ссылок.Как это работает? Это все связанный список.Элемент со ссылкой на следующий элемент в списке.Пока вы сохраняете ссылку на элемент в начале списка, вы можете обойти всю вещь, используя каждую последующую ссылку на следующее значение.

Чтобы добавить, все, что вам нужно сделать, это найти конециз списка, и сделайте следующий элемент значением, которое вы хотите добавить, так что если он имеет значение, отличное от NULL, вам придется вызывать append для следующего элемента, пока вы не найдете конец списка.

this.next.Append(word);

Answer 9

Просьба найти ниже Программа

class Node {
    int data;
    Node next;

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

public class LinkedListManual {

    Node node;

    public void pushElement(int next_node) {
        Node nd = new Node(next_node);
        nd.next = node;
        node = nd;
    }

    public int getSize() {
        Node temp = node;
        int count = 0;
        while (temp != null) {
            count++;
            temp = temp.next;
        }
        return count;
    }

    public void getElement() {
        Node temp = node;
        while (temp != null) {
            System.out.println(temp.data);
            temp = temp.next;
        }
    }

    public static void main(String[] args) {
        LinkedListManual obj = new LinkedListManual();
        obj.pushElement(1);
        obj.pushElement(2);
        obj.pushElement(3);
        obj.getElement(); //get element
        System.out.println(obj.getSize());  //get size of link list
    }

}

Answer 10

Пожалуйста, прочитайте эту статью: Как реализовать класс LinkedList с нуля в 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;
        }
    }
}

выход

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]