Share linked list in java

[xuyenchi511]

## Danh sách được liên kết trong Java

Danh sách được liên kết là cấu trúc dữ liệu tuyến tính trong đó mỗi phần tử được kết nối với phần tử tiếp theo bằng một con trỏ.Danh sách được liên kết là một cấu trúc dữ liệu đa năng có thể được sử dụng để thực hiện nhiều cấu trúc dữ liệu khác nhau, chẳng hạn như hàng đợi, ngăn xếp và cây.

Danh sách được liên kết thường được sử dụng trong Java vì chúng dễ thực hiện và có thể được sử dụng để thể hiện nhiều cấu trúc dữ liệu khác nhau.Tuy nhiên, các danh sách được liên kết cũng có thể chậm hơn các cấu trúc dữ liệu khác, chẳng hạn như mảng, vì chúng yêu cầu nhiều bộ nhớ hơn và nhiều thời gian hơn để truy cập các yếu tố.

## Danh sách cơ bản được liên kết

Một danh sách được liên kết được tạo thành từ một loạt các nút, trong đó mỗi nút chứa hai phần thông tin:

* Dữ liệu được lưu trữ trong nút
* Một con trỏ đến nút tiếp theo trong danh sách

Nút đầu tiên trong danh sách được liên kết được gọi là nút đầu và nút cuối cùng được gọi là nút đuôi.

## Hoạt động danh sách được liên kết

Sau đây là một số hoạt động phổ biến nhất có thể được thực hiện trong danh sách được liên kết:

*** Chèn: ** Một nút mới có thể được chèn vào đầu danh sách, ở cuối danh sách hoặc tại bất kỳ vị trí nào khác trong danh sách.
*** Xóa: ** Một nút có thể bị xóa từ đầu danh sách, từ cuối danh sách hoặc từ bất kỳ vị trí nào khác trong danh sách.
*** Tìm kiếm: ** Một nút có thể được tìm kiếm theo giá trị dữ liệu của nó.
*** Traversal: ** Các nút trong danh sách được liên kết có thể được đi qua theo hướng tiến hoặc hướng về phía sau.

## Thực hiện danh sách được liên kết trong Java

Mã sau đây cho thấy cách triển khai danh sách được liên kết trong Java:

`` `java
Lớp công khai LinkedList <T> {

Nút riêng <T> đầu;
nút riêng <t> đuôi;

công khai linkedList () {
đầu = null;
đuôi = null;
}

công khai void add (t dữ liệu) {
Nút <t> newnode = node node <> (dữ liệu);

if (head == null) {
đầu = newNode;
đuôi = newnode;
} khác {
đuôi.next = newNode;
đuôi = newnode;
}
}

công khai void xóa (t dữ liệu) {
if (head == null) {
trở lại;
}

Nút <t> currentNode = head;
Nút <t> priendNode = null;

while (currentNode! = null &&! currentNode.data.equals (data)) {
trước đóNode = currentNode;
currentNode = currentNode.next;
}

if (currentNode == null) {
trở lại;
}

if (currentNode == head) {
đầu = currentNode.next;
} khác {
trước đónode.next = currentNode.next;
}

if (currentNode == đuôi) {
đuôi = trước đó
}
}

Tìm kiếm công khai (dữ liệu t) {
Nút <t> currentNode = head;

while (currentNode! = null &&! currentNode.data.equals (data)) {
currentNode = currentNode.next;
}

if (currentNode == null) {
trả lại null;
}

trả về currentNode.data;
}

công khai void Traverse () {
Nút <t> currentNode = head;

while (currentNode! = null) {
System.out.println (currentNode.data);
currentNode = currentNode.next;
}
}

Nút lớp tĩnh riêng <T> {

Dữ liệu t riêng tư;
Nút riêng <T> Tiếp theo;

nút công khai (t dữ liệu) {
this.data = dữ liệu;
this.next = null;
}
}
}
`` `

## hashtags

* #LinkedList
* #Java
* #cấu trúc dữ liệu
*
=======================================
## Linked List in Java

A linked list is a linear data structure in which each element is connected to the next element by a pointer. Linked lists are a versatile data structure that can be used to implement a variety of different data structures, such as queues, stacks, and trees.

Linked lists are often used in Java because they are easy to implement and can be used to represent a wide variety of data structures. However, linked lists can also be slower than other data structures, such as arrays, because they require more memory and more time to access elements.

## Linked List Basics

A linked list is made up of a series of nodes, where each node contains two pieces of information:

* The data stored in the node
* A pointer to the next node in the list

The first node in a linked list is called the head node, and the last node is called the tail node.

## Linked List Operations

The following are some of the most common operations that can be performed on a linked list:

* **Insertion:** A new node can be inserted at the beginning of the list, at the end of the list, or at any other location in the list.
* **Deletion:** A node can be deleted from the beginning of the list, from the end of the list, or from any other location in the list.
* **Searching:** A node can be searched for by its data value.
* **Traversal:** The nodes in a linked list can be traversed in either a forward or a backward direction.

## Linked List Implementation in Java

The following code shows how to implement a linked list in Java:

```java
public class LinkedList<T> {

private Node<T> head;
private Node<T> tail;

public LinkedList() {
head = null;
tail = null;
}

public void add(T data) {
Node<T> newNode = new Node<>(data);

if (head == null) {
head = newNode;
tail = newNode;
} else {
tail.next = newNode;
tail = newNode;
}
}

public void remove(T data) {
if (head == null) {
return;
}

Node<T> currentNode = head;
Node<T> previousNode = null;

while (currentNode != null && !currentNode.data.equals(data)) {
previousNode = currentNode;
currentNode = currentNode.next;
}

if (currentNode == null) {
return;
}

if (currentNode == head) {
head = currentNode.next;
} else {
previousNode.next = currentNode.next;
}

if (currentNode == tail) {
tail = previousNode;
}
}

public T search(T data) {
Node<T> currentNode = head;

while (currentNode != null && !currentNode.data.equals(data)) {
currentNode = currentNode.next;
}

if (currentNode == null) {
return null;
}

return currentNode.data;
}

public void traverse() {
Node<T> currentNode = head;

while (currentNode != null) {
System.out.println(currentNode.data);
currentNode = currentNode.next;
}
}

private static class Node<T> {

private T data;
private Node<T> next;

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

## Hashtags

* #LinkedList
* #Java
* #datastructures
*