Свързан списък в Java - Приложение за свързан списък и примери за Java

linked list java linked list implementation java examples

Опитайте Нашия Инструмент За Премахване На Проблемите

Изберете Операционната Система Изберете Програма За Проекция (По Желание)

Опишете Проблема Си

Този урок обяснява какво представлява структурата на данните от свързан списък в Java и как да създадете, инициализирате, внедрите, прехвърлите, обърнете и сортирате свързан списък на Java:

В Java LinkedList е структура от данни, която съхранява елементи на непрекъснато местоположение. Това е линейна структура от данни.

Всеки елемент от данни се нарича „възел“ и всеки възел има част от данни и част за адрес. Адресната част съхранява връзката към следващия възел в LinkedList.

=> Посетете тук, за да видите серията за обучение за Java за всички.

Свързан списък в Java

Какво ще научите:

LinkedList в Java
Заключение
- Препоръчително четене

LinkedList в Java

По-долу е дадено общото оформление на LinkedList:

общо оформление на LinkedList

Както е показано в горното представяне на LinkedList, всеки елемент в LinkedList е „Възелът“. Всеки възел има две части, първата част съхранява данните, а втората част има препратка или указател или адрес на следващия възел в LinkedList.

видове тестови случаи при тестване на софтуер

Тази подредба е необходима, тъй като данните в LinkedList се съхраняват на несвързани места, за разлика от Arrays.

„Главата“ на LinkedList е указател, който съдържа адреса на първия елемент в LinkedList. Последният възел в LinkedList е опашката. Както е показано на фигурата по-горе, адресната част на последния възел в LinkedList е настроена на ‘Null’, указваща края на LinkedList.

Горната диаграма представлява „ Единично свързан списък ”, Който съхранява адреса само на следващия възел в LinkedList.

Има и друга версия, известна като „ Двойно свързан списък ”, Чийто възел има три части:

Адрес или препратка или указател към предишния елемент в LinkedList.
Част от данни
Адрес или препратка или указател към следващия елемент в LinkedList.

Предишният адрес на първия елемент в LinkedList ще бъде зададен на Null, докато следващият указател на Last element в LinkedList е зададен на Null.

Представяне на двойно свързан списък:

двойно свързан списък

Както е показано в горното представяне, всеки възел в двойно свързания списък има указатели към своя предишен и следващ възел (по този начин представен без стрелки). Предишният указател на първия възел сочи към нула, докато следващият указател на последния възел сочи към нула.

В този урок LinkedList ще се занимаваме най-вече със списъка с единични връзки. Ще обсъдим двойно свързания списък в следващия урок.

Клас на Java LinkedList

В Java свързаният списък се изпълнява от „ LinkedList ”Клас. Този клас принадлежи към „ java.util ' пакет. Класът LinkedList реализира интерфейсите List и Deque и наследява класа AbstractList.

По-долу е дадена йерархията на класа на класа LinkedList.

йерархия на класа на класа LinkedList

Горната диаграма показва йерархията на класа LinkedList. Както е показано, класът LinkedList реализира интерфейсите List и Deque.

Както вече споменахме, класът LinkedList е част от „ java.util ' пакет. Следователно би трябвало да можете да използвате класа LinkedList във вашата програма, като включите един от следните изявления във вашата програма.

import java.util.*;

Или

import java.util.LinkedList;

Така че въз основа на горната йерархия, типична дефиниция на клас LinkedList е, както следва:

public class LinkedList extends AbstractSequentialList implements List, Deque, Cloneable, Serializable

По-долу са изброени някои от характеристиките на класа LinkedList, които трябва да запомните:

Този клас не е синхронизиран.
Той позволява дублирани стойности.
Запазва реда за вмъкване.
Тъй като не се изисква да се преместват елементи по време на движение, манипулирането на елементи в него е по-бързо.
Този клас може да се използва за реализиране на стек, опашка и списък.

Как да създам свързан списък в Java

Преди да преминем към създаването на свързан списък в Java, нека първо обсъдим възел със свързан списък в Java.

Както вече беше обсъдено, свързаният списък се състои от възли. По този начин в Java можем да представим LinkedList като клас с неговия Node като отделен клас. Следователно този клас ще има препратка към типа Node.

Това е показано по-долу:

class LinkedList { Node head; // list head //node - linkedlist class Node { int data; Node next; Node(int d) { data = d; } //constructor to create a new node } }

За да създадете обект от тип LinkedList, има два основни конструктора, както следва:

# 1) LinkedList ()

Общият синтаксис за този конструктор е:

LinkedList linkedList = new LinkedList();

Горното изявление създава празен LinkedList.

Например,

LinkedList l_list = new LinkedList();

Това ще създаде празен свързан списък с име l_list.

# 2) LinkedList (Колекция c)

Общият синтаксис е:

LinkedList linkedList = new LinkedList (Collection c);

Горното изявление създава LinkedList с елементи от колекцията c като негови начални елементи.

Подобно на други структури от данни на списъка, които вече сме виждали, свързаният списък също може да бъде инициализиран с помощта на метода add, метода Arrays.asList () или с помощта на конструктора с колекцията като аргумент.

Внедряване на свързан списък в Java

По-долу е даден прост пример за структура на данни от LinkedList в Java. В този пример за изпълнение ще използваме метода add и asList, за да инициализираме обектите LinkedList.

import java.util.*; public class Main{ public static void main(String() args) { //create a LinkedList object and initialize it with Array elements converted to list LinkedList  intList = new LinkedList<>(Arrays.asList(10,20,30,40,50)); //print the LinkedList just created System.out.println('Contents of first LinkedList: ' + intList); //create an empty list LinkedList colorsList = new LinkedList<>(); //add elements to the linkedList using add method. colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Cyan'); colorsList.add('Magenta'); // print the LinkedList System.out.println('
Contents of second LinkedList: ' + colorsList); } }

Изход:

Съдържание на първия LinkedList: (10, 20, 30, 40, 50)
Съдържание на втория LinkedList: (Червено, Зелено, Синьо, Синьо, Пурпурно)

изпълнение на списък, свързан с изхода

Горната програма показва създаването и инициализирането на LinkedList. Първо, ние създаваме LinkedList от тип Integer и предоставяме масив от Integers, преобразувани в списък, използвайки метода asList като начални стойности за LinkedList.

След това създаваме празен LinkedList от тип String и след това, използвайки метода add, добавяме стойности към LinkedList.

Накрая показваме и обектите LinkedList като низ.

Преминаване / печат на свързан списък в Java

За да отпечатате съдържанието или да извършите някакви операции с елементите на LinkedList, трябва да преминете през неговите елементи. Вече видяхме тези методи в предишните ни уроци. В този раздел ще обсъдим примерите за всеки по отношение на LinkedList.

Използване на цикъл for

import java.util.LinkedList; class Main { public static void main(String() args) { // Create a LinkedList and initialize it LinkedList colorList = new LinkedList<>(); colorList.add('Red'); colorList.add('Green'); colorList.add('Blue'); // Using for loop,print the contents of the LinkedList System.out.println('LinkedList elements using for loop:'); for(int i=0; i  Изход: 
 LinkedList елементи, използващи за цикъл: 
Червено Зелено Синьо
  
 Използване на forEach Loop
import java.util.LinkedList; class Main { public static void main(String() args) { // Create a LinkedList and initialize it LinkedList colorList = new LinkedList<>(); colorList.add('Red'); colorList.add('Green'); colorList.add('Blue'); // Using forEach loop,print the contents of the LinkedList System.out.println('LinkedList elements using forEach loop:'); for(String color:colorList) { System.out.print(color + ' '); } } }  Изход: 
 LinkedList елементи, използващи forEach цикъл: 
Червено Зелено Синьо
  
 Използване на Iterator
import java.util.*; public class Main{ public static void main(String args()){ //declare a LinkedList object LinkedList l_list=new LinkedList(); //Add elements to LinkedList l_list.add('Red'); l_list.add('Green'); l_list.add('Blue'); l_list.add('Yellow'); //declare an iterator for the LinkedList Iterator itr=l_list.iterator(); System.out.println('The contents of Linked List:'); //Iterate through the LinkedList using Iterator and print its elements while(itr.hasNext()){ System.out.print(itr.next() + ' '); } } }  Изход: 
 Съдържанието на свързания списък: 
Червено Зелено Синьо Жълто
коя операционна система е най-подходяща за лаптоп
  
 Методи на LinkedList
 Класът LinkedList предоставя API, който поддържа различни методи за манипулиране на свързания списък. Табулизирали сме методите в API на LinkedList по-долу.
  Ще обсъдим основните операции / методи в следващия раздел. 
   Метод Прототип Описание  
 
  Ясно празно ясно () Изтрива всички елементи от списъка.  
 Добавяне булево добавяне (E e) Добавете определен елемент към LinkedList  
  void add (int index, E element) Добавете елемент в дадения индекс в LinkedList  
  Добави Всички boolean addAll (Колекция c) Добавя елементите на дадена колекция c в края на LinkedList.  
  boolean addAll (индекс int, колекция c) Добавя елементите на дадена колекция c при посочения индекс в LinkedList  
  addFirst void addFirst (E e) Добавете дадения елемент като първи елемент към LinkedList.  
  addLast void addLast (E e) Добавете дадения елемент в края на списъка.  
   Клониране Клон на обект () Прави плитко копие на LinkedList  
  Съдържа Булево съдържа (Обект o) Проверява дали списъкът съдържа определени елементи; ако да, връща true.  
  низходящIterator Итератор низходящ Итератор () Връща итератор с обратен ред за LinkedList.  
  Елемент E element () Връща елемента в началото на списъка.  
  Вземете E get (индекс int) Получава елемента в посочения индекс.  
  getFirst E getFirst () Извлича първия елемент в LinkedList.  
  getLast E getLast () Извлича последния елемент в LinkedList.  
  индекс на Int indexOf (Обект o) Намерете индекса на първото появяване на дадените елементи в списъка и върнете индекса. -1, ако елементът не е намерен.  
  lastIndexOf Int lastIndexOf (Обект o) Връща позицията на последното появяване на дадения елемент в LinkedList; -1, ако даден елемент не присъства  
  listIterator ListIterator listIterator (int index) Връща listIterator от посочения индекс в свързания списък.  
  Оферта булево предложение (E e) Добавя дадения елемент като последен елемент (опашка) в LinkedList.  
  офертаПърво Булева оферта Първа (E e) Добавя дадения елемент като първи елемент в LinkedList.  
  offerLast Булева оферта Последно (E e) Добавете даден елемент e в края на LinkedList.  
  Надникнете E peek () Връща главата на списъка, без да го премахва.  
  надникнете Първо E peekFirst () Връща първия елемент в списъка. връща null, ако списъкът е празен.  
  поглед Последно E peekLast () Връща последния елемент или null, ако списъкът е празен. Той не изтрива елемента.  
  Анкета E poll () Връща главата на LinkedList и също го премахва.  
  анкета Първо E pollFirst () Връща и изтрива първия елемент в списъка; връща null, ако списъкът е празен.  
  анкета Последно E анкета Последно () Връща и изтрива последния елемент в списъка; връща null, ако списъкът е празен.  
  Поп E поп () Изскача елемента от стековото представяне на LinkedList.  
  Натиснете Пусто пуш (E e) Избутва или вмъква елемент в стековото представяне на LinkedList.  
  Премахване E премахване () Премахва и връща главата на LinkedList.  
  E премахване (индекс int) Изтрива елемента в дадения индекс от LinkedList.  
  булево премахване (обект o) Изтрива първото появяване на дадения елемент от LinkedList.  
  премахнете Първо E removeFirst () Връща и изтрива първия елемент от списъка.  
  removeFirstOccurence boolean removeFirstOccurrence (Обект o) Изтрива първото появяване на дадения елемент от списъка, когато списъкът се обхожда от главата до опашката.  
  removeLast E removeLast () Връща последния елемент в LinkedList и също го изтрива.  
  removeLastOccurence boolean removeLastOccurrence (Обект o) Премахва последното появяване на дадения елемент от LinkedList при преминаване от главата до опашката  
  Комплект E набор (индекс int, Е елемент) Задава дадения елемент на дадения индекс. Заменя текущия елемент с нов.  
  Размер Int размер () Връща размера или броя на елементите в LinkedList  
  toArray Обект () към масив () Преобразува LinkedList в масив, съдържащ всички елементи от списъка в правилна последователност  
  T () доArray (T () a) Преобразува LinkedList в масив с тип на изпълнение, същия като аргумент a.  
 
 
  Долната програма Java демонстрира различните методи, които изброихме по-горе. 
import java.util.*; public class Main { public static void main(String args()) { //create a linked list LinkedList l_list = new LinkedList(); // Add elements to linkedList using various add methods l_list.add('B'); l_list.add('C'); l_list.addLast('G'); l_list.addFirst('A'); l_list.add(3, 'D'); l_list.add('E'); l_list.add('F'); //print the linkedList System.out.println('Linked list : ' + l_list); //Create and initialize an ArrayList ArrayList aList = new ArrayList<>(); aList.add('H'); aList.add('I'); //add the ArrayList to linkedList using addAll method l_list.addAll(aList); //print the linkedList System.out.println('Linked list after adding ArrayList contents: ' + l_list); // use various remove methods to remove elements from linkedList l_list.remove('B'); l_list.remove(3); l_list.removeFirst(); l_list.removeLast(); //print the altered list System.out.println('Linked list after deletion: ' + l_list); // use contains method to check for an element in the linkedList boolean ret_value = l_list.contains('G'); //print the results of contains method if(ret_value) System.out.println('List contains the element 'G' '); else System.out.println('List doesn't contain the element 'G''); // use size methods to return Number of elements in the linked list int size = l_list.size(); System.out.println('Size of linked list = ' + size); // Get and set elements from linked list Object element = l_list.get(3); System.out.println('Element returned by get() : ' + element); l_list.set(3, 'J'); System.out.println('Linked list after change : ' + l_list); //convert linkedList to Array using toArray methods String () list_array = l_list.toArray(new String(l_list.size())); System.out.println('Array obtained from linked List:' + Arrays.toString(list_array)); } } Изход: 
 Свързан списък: (A, B, C, D, G, E, F) 
Свързан списък след добавяне на съдържание на ArrayList: (A, B, C, D, G, E, F, H, I) 
Свързан списък след изтриване: (C, D, E, F, H) 
Списъкът не съдържа елемента „G“ 
Размер на свързания списък = 5 
Елементът е върнат от get (): F 
Свързан списък след промяна: (C, D, E, J, H) 
Масив, получен от свързан списък: (C, D, E, J, H)
  
 Горната програма демонстрира различни методи на клас LinkedList. Първо декларираме LinkedList от тип String. След това използваме различни версии на метода на добавяне като add, andFirst, addLast, addAll и др., За да попълним LinkedList със стойности.
 Тук можем да добавим елемента директно в края на списъка или да добавим елемента на определена позиция в списъка.
 Също така използваме метода addFirst за добавяне на елемент в началото на списъка и addLast за добавяне на елемент в края на списъка. След това извършваме операции по премахване на LinkedList като премахване, премахване на Първо, премахване на Последно и т.н.
 За метод за премахване можем да посочим елемента, който трябва да бъде премахнат, или да посочим индекса или позицията в LinkedList, при която елементът трябва да бъде премахнат. Методите removeFirst и removeLast премахват съответно първия и последния елемент в списъка.
 След това търсим в списъка за определен елемент, използвайки метода contains. След това използваме метода size (), за да извлечем размера или дължината на LinkedList. След това използваме методите get / set, за да извлечем стойността при определен индекс в списъка и след това да заменим стойност на определена позиция в списъка.
  И накрая, ние преобразуваме LinkedList в масив, използвайки метода toArray. 
 Обратен свързан списък в Java
 За да обърнем свързан списък в Java, използваме метода “descendingIterator ()”, който връща обратен итератор за списъка. След това можем да използваме този итератор, за да преминем през елементите от списъка и дисплея.
  Програмата по-долу обръща свързания списък, използвайки метода descendingIterator (). 
import java.util.*; public class Main{ public static void main(String args()){ //create a LinkedList object LinkedList l_list=new LinkedList(); l_list.add('Pune'); l_list.add('Mumbai'); l_list.add('Nagpur'); System.out.println('Linked List : ' + l_list); System.out.println('Linked List in reverse order:'); //use descendingIterator method to get a reverse iterator Iterator iter=l_list.descendingIterator(); //traverse the list using iterator and print the elements. while(iter.hasNext()) { System.out.print(iter.next() + ' '); } } }  Изход: 
 Свързан списък: (Пуна, Мумбай, Нагпур) 
Свързан списък в обратен ред: 
Нагпур Мумбай Пуна
  
 В горната програма декларираме свързан списък и след това го отпечатваме. След това получаваме обратен итератор и след това преминаваме през списъка с него и показваме всеки елемент. Резултатът показва свързаното съдържание на списъка, първо в реда на добавяне на елементите и след това изхода показва съдържанието в обратен ред.
 Сортиране на свързан списък в Java
 Обектите на класа LinkedList могат да бъдат сортирани чрез метода Collections.sort (). Този метод предоставя две версии със или без използване на компаратор. Когато методът Collections.sort () се извика без сравнител, колекцията се сортира в естествения ред.
 Когато компаратор се използва с този метод, ние можем да дефинираме нашите собствени критерии за сортиране, като заменим метода compareTo.
  Долната програма Java сортира LinkedList с помощта на Collections.sort (). Тук сортираме масиви, като използваме естествено подреждане, както и с помощта на сравнител. 
import java.util.*; public class Main{ public static void main(String args()) { // create and initialize the LinkedList object LinkedList l_list = new LinkedList<>(); l_list.add('Jan'); l_list.add('Feb'); l_list.add('Mar'); l_list.add('Apr'); l_list.add('May'); l_list.add('Jun'); //print original unsorted linkedlist System.out.println('Original LinkedList (unsorted): ' + l_list); // sort LinkedList with Collecitons.sort() method in natural order Collections.sort(l_list); System.out.println('
LinkedList (sorted in natural order): ' + l_list); // sort LinkedList using Collection.sort() and Comparator in Java Collections.sort(l_list, new Comparator() { @Override public int compare(String s1, String s2) { return s1.length() - s2.length(); } } ); System.out.println('LinkedList (sorted using Comparator): ' + l_list); } } Изход: 
най-добрият безплатен инструмент за ремонт на Windows 7 -
 Оригинален LinkedList (несортиран): (януари, февруари, март, април, май, юни) 
LinkedList (сортирано в естествен ред): (април, февруари, януари, юни, март, май) 
LinkedList (сортирано с помощта на Comparator): (април, февруари, януари, юни, март, май)
  
 Премахване на дубликати
 За да премахнете дубликати, трябва да прекосите всеки възел и да го сравните със следващия възел. Ако и двата възела са еднакви, тогава пропускаме един възел и преминаваме към следващия.
 По този начин, след обхождане на всеки възел и премахване на дублиращи се възли, ще получим резултантния списък, който няма дублиращи се елементи.
  По-долу е дадена Java програма за премахване на дубликати. 
class LinkedList_Duplicate { //A class to represent node in linkedlist class Node{ int data; Node next; public Node(int data) { this.data = data; this.next = null; } } //Initially the head and tail of the linked list set to null public Node head = null; public Node tail = null; //add a new node to the linkedlist public void addNode(int data) { //Create new node Node newNode = new Node(data); //If list is empty set head and tail to new node if(head == null) { head = newNode; tail = newNode; } else { // add newNode after the tail tail.next = newNode; //newNode is now the tail or last element tail = newNode; } } //scans the linkedlist and removes duplicate nodes public void removeDuplicateNodes() { //Head is the current node Node current = head, index = null, temp = null; //head = null means list is empty if(head == null) { return; } //traverse through the list else { while(current != null){ //temp node points to previous node to index. temp = current; //Index will point to node next to current index = current.next; while(index != null) { //Check if current node's data is equal to index node's data if(current.data == index.data) { //since node is duplicate skip index and point to next node temp.next = index.next; } else { //Temp will point to previous node of index. temp = index; } index = index.next; } current = current.next; } } } //print the linked list public void print() { //Node current will point to head Node current = head; if(head == null) { System.out.println('List is empty'); return; } while(current != null) { //Print each node by incrementing pointer System.out.print(current.data + ' '); current = current.next; } System.out.println(); } }class Main{ public static void main(String() args) { LinkedList_Duplicate l_List = new LinkedList_Duplicate(); //Add data to the list l_List.addNode(1); l_List.addNode(1); l_List.addNode(2); l_List.addNode(3); l_List.addNode(5); l_List.addNode(2); l_List.addNode(1); l_List.addNode(1); //print the original list System.out.println('Original Linkedlist: '); l_List.print(); //Removes duplicate nodes l_List.removeDuplicateNodes(); //print the altered list without duplicates System.out.println('LinkedList after removing duplicates: '); l_List.print(); } }  Изход: 
 Оригинален свързан списък: 
1 1 2 3 5 2 1 1 
LinkedList след премахване на дубликати: 
1 2 3 5
  
 В горната програма имаме свързан списъчен клас, създаден за премахване на дубликати. Имаме и клас за дефиниране на всеки възел. С други думи, възлите в списъка са обектите на този възел на класа. Имаме метод за добавяне на възела към свързан списък.
 След това в метода removeDuplicate преминаваме през всеки възел в свързания списък, започвайки от главата и сравняваме всеки следващ възел за дубликата. Ако се намери дубликат, пропускаме този възел и продължаваме към следващия възел.
 По този начин ist се изгражда чрез пропускане на дублиращите се възли и промененият списък се отпечатва чрез метода print ().
 Кръгово свързан списък в Java
 Кръгово свързан списък е списък, чиято опашка или последен възел са свързани обратно към главата или първия възел.
  Диаграмата по-долу показва списъка с кръгови връзки в Java. 
  
 Както е показано на горната диаграма, адресната част на последния възел или опашка на свързания списък не е зададена като нула. Вместо това той сочи обратно към първия възел или глава на списъка, като по този начин образува кръгово свързан списък.
  Програмата по-долу реализира кръгъл свързан списък, в който трябва да манипулираме отделни възли на свързания списък. 
 class CircularLinkedList { //Node definition for circular linked list public class Node{ int data; Node next; public Node(int data) { this.data = data; } } //Initially head and tail pointers point to null public Node head = null; public Node tail = null; //add new node to the circular linked list public void add(int data){ //Create new node Node newNode = new Node(data); //check if list is empty if(head == null) { //head and tail point to same node if list is empty head = newNode; tail = newNode; newNode.next = head; } else { //tail points to new node if list is not empty tail.next = newNode; //New node becomes new tail. tail = newNode; //tail points back to head tail.next = head; } } //Display the nodes in circular linked list public void displayList() { Node current = head; if(head == null) { System.out.println('The List is empty'); } else { System.out.println('Circular linked list nodes: '); do{ //Print each node of the linked list System.out.print(current.data + ' '); current = current.next; }while(current != head); System.out.println(); } } } class Main{ public static void main(String() args) { //create a CircularLinkedList object CircularLinkedList c_list = new CircularLinkedList(); //Add data to the list c_list.add(10); c_list.add(20); c_list.add(30); c_list.add(40); //Display the nodes in circular linked list c_list.displayList(); } }  Изход: 
 Кръгови свързани списъчни възли: 
10 20 30 40
  
 Java 8 LinkedList
 Въпреки че няма повече функции, добавени специално към класа LinkedList в Java 8, той все още въведе потоци за манипулиране на данни.
  Програмата по-долу показва използването на Java 8 поток за показване на LinkedList. 
import java.util.LinkedList; import java.util.List; public class Main { public static void main(String() args) { //create a LinkedList and initialize it to values List colorsList = new LinkedList<>(); colorsList.add('Red'); colorsList.add('Green'); colorsList.add('Blue'); colorsList.add('Cyan'); colorsList.add('Magenta'); //convert List to stream & print it System.out.println('The contents of LinkedList:'); colorsList.stream().forEach(System.out::println); } } Изход: 
 Съдържанието на LinkedList: 
Нето 
Зелено 
Син 
Циан 
Пурпурен
  
 често задавани въпроси
  В # 1) Кога Свързаният списък се използва в Java? 
  Отговор: Тъй като е по-бърз от колекции като ArrayList при операции за модификация, той трябва да се използва в приложения, които изискват чести операции за добавяне / изтриване. За приложения, които имат предимно данни само за четене, могат да се използват ArrayList или подобни колекции.
  Q # 2)  Какво е ListNode? 
  Отговор: ListNode е основен клас, свързан със свързан списък в Java и представлява информация, свързана с един елемент или възел. Всеки ListNode се състои от данни и указател или препратка към следващия елемент.
  Q # 3)  Свързаният списък разрешава ли нулеви стойности? 
  Отговор: Да, свързаният списък позволява произволен брой нулеви стойности.
  Q # 4)  Какви са предимствата на свързания списък? 
  Отговор: Някои от предимствата са: 
  Манипулационните операции като добавяне, изтриване са по-бързи в него.
 Не е необходимо да се разпределя предварително памет за свързан списък и по този начин това води до ефективно използване на паметта.
 Той осигурява по-бързо време за достъп и без допълнителни режийни разходи за памет и може да се разширява за постоянно време.
 Това е динамична структура на данните
 Расте и се свива по време на изпълнение в зависимост от добавените или изтритите стойности.
 
  Q # 5)  Какво е приложението на свързания списък? 
  Отговор: Използва се най-вече в следните приложения: 
  За внедряване на функцията за „отмяна“ в софтуер като MS-Word, Photoshop и др.
 За внедряване на структури от данни като стек и опашка.
 Също така можем да внедрим графики, използвайки свързан списък.
 За хеширане на сегменти, всеки сегмент може да бъде реализиран като свързан списък.
 
  Q # 6)  Какви са ограниченията на свързан списък? 
  Отговор: Някои от ограниченията са: 
  С допълнителен указател, който да съдържа препратката към следващия елемент във всеки възел, използваната памет е много повече от масиви.
 Това е строго последователно достъпна структура от данни, поради което възлите на свързания списък трябва винаги да се четат от самото начало.
 Трудно е да се прехвърли назад, особено еднопосочно свързаните списъци.
 Тъй като възлите се съхраняват на непрекъснати места, времето, необходимо за достъп, може да бъде голямо.
 
 Заключение
 В този урок научихме основната структура на данните от свързания списък. След това преминахме към клас java.util.LinkedList, предоставен в Java. Обсъдихме подробно този клас, включително неговите конструктори, методи и т.н.
 Също така обсъдихме някои специални операции, свързани със свързани списъци, като сортиране, обръщане на списък, премахване на дубликати, кръгов свързан списък и т.н.
   В следващия урок ще обсъдим специфични характеристики на двойно свързания списък.  
  => Вижте Пълното ръководство за обучение по Java тук.  
  Препоръчително четене
    Двойно свързан списък в Java - Примери за внедряване и код  
  Списък на Java - Как да създадете, инициализирате и използвате списък в Java  
  Методи на Java List - Сортиране на списък, Съдържа, Добавяне на списък, Премахване на списък  
  Алгоритъм на двоично търсене в Java - Внедряване и примери  
  Сортиране при вмъкване в Java - Алгоритъм за сортиране при вмъкване и примери  
  Урок за интерфейс на Java и абстрактен клас с примери  
  Свързана списъчна структура на данните в C ++ с илюстрация  
  Скрит списък за масив и други колекции в Java