类名 | MyLinkedList |
---|---|
构造方法名 | public MyLinkedList() |
成员内部类 | public class Node;结点类 |
成员方法 | public void insert(T t) ;往线性表添加一个元素 public void insert(int i,T t);在指定位置添加一个元素 public void clear();清空整个线性表; public int length();获取线性表数据个数(长度) public T remove(int index);删除指定索引处元素,并将其返回 public int indexOf(T t);获取该元素第一次出现的位序号 public boolean isEmpty();判断线性表是否为空 public T get(int index);获取线性表中指定位序号处的值 |
成员变量 | private int size;记录当前线性表的元素个数 private Node head;;定义头结点 |
成员内部类变量 | private T item;用于存储数据 private Node next;用于存储下一个结点信息 |
代码如下
输出结果
闲言
csdn_闲言
鸡哥
鸡哥
闲言博客
记录成长,记录学习
记录成长,记录学习
====================
链表长度是:7
鸡哥第一次出现的位置是:2
记录成长,记录学习第一次出现的位置是:5
删除1处的元素是:csdn_闲言
删除2处的元素是:鸡哥
链表长度是:5
链表0处元素是:闲言
链表1处元素是:鸡哥
链表2处元素是:闲言博客
链表长度是:0
判断链表是否为空:true
测试类
public static void main(String[] args) {
MyLinkedList<String> list = new MyLinkedList<>();
list.insert("闲言");
list.insert("鸡哥");
list.insert("鸡哥");
list.insert("闲言博客");
list.insert("记录成长,记录学习");
list.insert("记录成长,记录学习");
//在指定位置添加元素
list.insert(1, "csdn_闲言");
Iterator<String> it = list.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
System.out.println("====================");
System.out.println("链表长度是:" + list.length());
System.out.println("鸡哥第一次出现的位置是:" + list.indexOf("鸡哥"));
System.out.println("记录成长,记录学习第一次出现的位置是:" + list.indexOf("记录成长,记录学习"));
//删除指定位置索引
System.out.println("删除1处的元素是:" + list.remove(1));
System.out.println("删除2处的元素是:" + list.remove(2));
System.out.println("链表长度是:" + list.length());
System.out.println("链表0处元素是:" + list.get(0));
System.out.println("链表1处元素是:" + list.get(1));
System.out.println("链表2处元素是:" + list.get(2));
//置空链表
list.clear();
System.out.println("链表长度是:" + list.length());
System.out.println("判断链表是否为空:" + list.isEmpty());
}
MyLinkedList类
package cn.bloghut.linear;
import java.util.Iterator;
/**
* @author by 闲言
* @classname MyLinkedList
* @description TODO
* @date 2021/7/16 10:36
*/
public class MyLinkedList<T> implements Iterable<T> {
//定义头结点
private Node head;
//存储线性表长度
private int size;
public class Node {
//用于存储数据
private T item;
//用于存储下一个结点信息
private Node next;
//初始化数据
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
}
//初始化数据
public MyLinkedList() {
//初始化头结点-头结点不是用来存储数据的,也还没有指向下一个结点
head = new Node(null, null);
//初始化元素个数
size = 0;
}
/**
* 清空线性表
*/
public void clear() {
//长度置为空
size = 0;
//头结点没有指向
head.next = null;
}
/**
* 判断是否为空
*
* @return
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 获取线性表中元素个数
*
* @return
*/
public int length() {
return size;
}
/**
* 返回指定索引处元素
*
* @param index
* @return
*/
public T get(int index) {
//记录头结点
Node node = head;
//通过循环从头结点开始往后找,依次找i次,就可以找到对应的元素
for (int i = 0; i <= index; i++) {
node = node.next;
}
return node.item;
}
/**
* 往线性表中添加元素
*
* @param t
*/
public void insert(T t) {
Node node = head;
//找到当前最后一个结点
while (node.next != null) {
//最后一个结点的next属性是为null的
node = node.next;
}
//创建新结点,保存元素
node.next = new Node(t, null);
//元素个数+1
size++;
}
/**
* 在i索引处添加t值
*
* @param i
* @param t
*/
public void insert(int i, T t) {
//创建新结点
Node newNode = new Node(t, null);
//找到i处的前一个结点
Node pre = head;
for (int index = 0; index < i; index++) {
pre = pre.next;
}
//找到i处的结点
Node oldNode = pre.next;
//让i处的前一个结点指向新的结点
pre.next = newNode;
//让新的结点指向旧i处的结点
newNode.next = oldNode;
//线性表个数自增1
size++;
}
/**
* 删除指定索引处元素
*
* @param i
* @return
*/
public T remove(int i) {
//从头结点开始找,找到i前一个结点
Node node = head;
for (int index = 0; index < i; index++) {
node = node.next;
}
//获取要删除的i位置的结点
Node temp = node.next;
//让i前一个结点指向 要删除结点的后一个结点
node.next = temp.next;
//链表长度减1
size--;
//将删除的元素返回
return temp.item;
}
/**
* 获取元素t 第一次出现的索引位置
* @param t
* @return
*/
public int indexOf(T 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 MyIterator();
}
/**
* 自定义迭代器
*/
public class MyIterator implements Iterator {
private Node n;
//初始化数据
public MyIterator() {
n = head;
}
@Override
public boolean hasNext() {
return n.next != null;
}
@Override
public Object next() {
//指针往后移动
n = n.next;
return n.item;
}
}
}