1.Java自带链表类
LinkedList 类位于 java.util 包中，使用前需要引入它，语法格式如下：
// 引入 LinkedList 类
import java.util.LinkedList;
LinkedList<E> list = new LinkedList<E>(); // 普通创建方法
或者
LinkedList<E> list = new LinkedList(Collection<? extends E> c); // 使用集合创建链表创建一个简单的链表实例：
// 引入 LinkedList 类
实例
import java.util.LinkedList;
public class RunoobTest {
public static void main(String[] args) {
LinkedList<String> sites = new LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
System.out.println(sites);
}
}
[Google, Runoob, Taobao, Weibo]更多的情况下我们使用 ArrayList 访问列表中的随机元素更加高效，但以下几种情况 LinkedList 提供了更高效的方法
// 使用 addFirst() 在头部添加元素
// 使用 addLast() 在尾部添加元素
// 使用 removeFirst() 移除头部元素
// 使用 removeLast() 移除尾部元素
// 使用 getFirst() 获取头部元素
// 使用 getLast() 获取尾部元素迭代元素
我们可以使用 for 配合 size() 方法来迭代列表中的元素：
实例
// 引入 LinkedList 类
import java.util.LinkedList;
public class RunoobTest {
public static void main(String[] args) {
LinkedList<String> sites = new LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
for (int size = sites.size(), i = 0; i < size; i++) {
System.out.println(sites.get(i));
}
}
}size() 方法用于计算链表的大小。
以上实例，执行输出结果为：
Google
Runoob
Taobao
Weibo也可以使用 for-each 来迭代元素：
实例：
// 引入 LinkedList 类
import java.util.LinkedList;
public class RunoobTest {
public static void main(String[] args) {
LinkedList<String> sites = new LinkedList<String>();
sites.add("Google");
sites.add("Runoob");
sites.add("Taobao");
sites.add("Weibo");
for (String i : sites) {
System.out.println(i);
}
}
}
Google
Runoob
Taobao
Weibo
2.java代码实现链表
package algorithm.linear;
import algorithm.sort.Node;
import java.security.DrbgParameters;
import java.util.Iterator;
public class LinkList <T> implements Iterable<T>{
//记录头结点
private Node head;
//记录链表的长度
private int N;
//链表内部结点类
private class Node{
//存储数据
T item;
//下一个结点
Node next;
public Node(T item, Node next){
this.item = item;
this.next = next;
}
}
public LinkList(){
//初始化头结点
this.head = new Node(null, null);
//初始化元素个数
this.N = 0;
}
//清空链表
public void clear(){
//清空只需让头结点不指向下一个元素，然后元素个数设为0就可以了
head.next = null;
this.N = 0;
}
//获取链表的长度
public int length(){
return N;
}
//判断链表是否为空
public boolean isEmpty(){
return N==0;
}
//获取指定位置i处的元素
public T get(int i){
//以头结点为起点，通过for循环i次就能找到对应结点
//通过循环，从头结点开始往后找，依次找i次，就可以找到对应的元素
Node n = head.next;
for (int index = 0; index < i; index++){
n = n.next;
}
return n.item;
}
//向链表中添加元素t
public void insert(T t){
//找到当前最后一个结点
Node n = head;
while (n.next != null){
n = n.next;
}
//循环结束后，n记录的就是最后一个结点
//创建新结点，保存元素t
Node newNode = new Node(t, null);
//让当前最后一个结点指向新结点
n.next = newNode;
//元素的个数+1
N++;
}
//向指定位置i处，添加元素t
public void insert(int i, T t){
//找到i位置前一个结点
Node pre = head;
for (int index = 0; index <= i - 1; index++){
pre = pre.next;
}
//循环到 i-1 ，pre记录的是i前一个结点
//找到i位置的结点
Node curr = pre.next;
//创建新结点，并且新结点需要指向原来i位置的结点
Node newNode = new Node(t, curr);
//原来i位置的前一个结点指向新结点即可
pre.next = newNode;
//元素的个数+1
N++;
}
//删除指定位置i处的元素，并返回被删除的元素
public T remove(int i){
//找到i位置的前一个结点
Node pre = head;
for (int index = 0; index <= i - 1; i++){
pre = pre.next;
}
//循环到 i-1 ，pre记录的是i前一个结点
//要找到i位置的结点
Node curr = pre.next;
//找到i位置的下一个结点
Node nextNode = curr.next;
//前一个结点指向下一个结点
pre.next = nextNode;
//元素个数 -1
N--;
//返回被删除的元素
return curr.item;
}
//查找元素t在链表中第一次出现的位置
public int indexOf(T t){
//从头结点开始，依次找到每一个结点，取出item，和t比较，如果相同，就找到了
Node n = head;
for (int i = 0; n.next !=null; i++){
n = n.next;
if (n.item.equals(t)){
return i;
}
}
return -1;
}
@Override
public Iterator<T> iterator() {
return new LIterator();
}
private class LIterator implements Iterator{
private LinkList.Node n;
public LIterator(){
this.n = head;
}
@Override
public boolean hasNext() {
return n.next != null;
}
@Override
public Object next() {
n = n.next;
return n.item;
}
}
//用来反转整个链表
public void reverse(){
//判断当前链表是否为空链表，如果是空链表，则结束运行，如果不是，则调用重载的reverse方法完成反转
if (isEmpty()){
return;
}
reverse(head.next);
}
//反转指定的curr，并把反转后的结点返回
public Node reverse(Node curr){
if (curr.next == null){
head.next = curr;
return curr;
}
//如果不是最后一个结点
//递归的反转当前结点curr的下一个结点；返回值就是链表反转后，当前结点的上一个结点
Node pre = reverse(curr.next);
//让返回的结点的下一个结点变为当前结点curr
pre.next = curr;
//把当前结点的下一个节点变为null
curr.next = null;
//返回反转后的结点
return curr;
}
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
