目录
data是数据域
next是指针域
头节点：不存储数据，是链表的入口
链表不是数组，所以没有索引
头节点不算链表长度，
也是从0开始计数，第0个节点就是头节点的下一个节点
或者也可以叫第1个节点
java实现定义节点类代码
package StructDate;
/**
* Created with IntelliJ IDEA.
*
* @Author: 从南到北
* @Date: 12/09/2021/15:39
* @Description:
* 泛型，数据结构，java实现链表
*/
public class Node<T> {
//存储元素
public T item;
//创建本类对象，用于指向下一个节点
public Node next;
public Node(T item,Node next){
this.item=item;
this.next=next;
}
public static void main(String[] args) {
//构建节点，设置每一个节点的后一个节点都是空
Node<Integer> a = new Node<>(11, null);
Node<Integer> b = new Node<>(12, null);
Node<Integer> c = new Node<>(13, null);
Node<Integer> d = new Node<>(14, null);
Node<Integer> e = new Node<>(15, null);
//生成链表,node也是数据结构的一种，当是int ，string其中的一种
a.next = b;
b.next = c;
c.next = d;
d.next = e;
}
}
这里只是成功编译运行了节点类，而不是链表，要把这些节点连接起来，才是链表
链表最重要的就是找到来时的路
java实现链表
- 定义节点类 【内部类】
- 初始化链表（头结点和链表长度）
- 清空链表
- 获取链表长度
- 判断链表是否为空
- 获取指定i处的元素
- 在链表中添加元素t
- 在链表指定位置i处添加元素t
- 删除指定位置i处的元素，并返回被删除的元素
- 查找元素t在链表中第一次出现的位置
package algorithm.linear;
import java.util.Iterator;
/**
* Created with IntelliJ IDEA.
*
* @Author: 从南到北
* @Date: 12/03/2021/20:03
* @Description: java链表的增删改查
*/
public class LinkList<T> implements Iterable<T> {
//记录头节点
private Node head;
//记录链表长度
private int N;
@Override
public Iterator<T> iterator() {
return null;
}
//定义一个内部类,作为节点类
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(){
head.next = null;
this.N=0;
}
//获取链表长度
public int length(){
//只需要返回节点个数即可
return N;
}
//判断链表是否为空
public boolean isEmpty(){
//只要节点个数为0即可
return N==0;
}
//获取指定位置i处的元素
//在数组中，直接根据索引即可返回，
//但是在链表中，就要顺序查找，从头结点开始查找
// 6. 获取指定i处的元素
public T get(int 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;
//在i处添加，而不是在第i个位置添加
for (int index=0;index<i;index++){
pre=pre.next;
}
//找到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;i++){
pre = pre.next;
}
//要找到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; //节点n为头结点
for (int i=0;n.next!=null;i++){
n=n.next;
if (n.item.equals(t)){
return i;
}
}
return -1;
}
}
测试
package algorithm.linear;
public class LinkListTest {
public static void main(String[] args) {
//创建单项链表对象
LinkList<String> SL = new LinkList<>();
//测试插入
SL.insert("姚明");
SL.insert("科比");
SL.insert("麦迪");
SL.insert(1,"詹姆斯");
for (String s:SL){
System.out.println(s);
}
System.out.println("-----------");
//测试获取
String getResuit = SL.get(1);
System.out.println("获取索引1处的结果为："+getResuit);
//测试删除
String removeResult = SL.remove(0);
System.out.println("删除元素是"+removeResult);
//测试清空
SL.clear();
System.out.println("清空后的线性表中的元素个数为："+SL.length());
}
}
迭代器，这个是用来遍历集合的
我在ArrayList中也找到了实现和重写的源码
