线性表的接口定义
/**
* 线性表(列表)的接口定义
*/
public interface MyList {
/**
* 新增一个元素
*
* @param element 要新增的那个元素
*/
public void add(Object element);
/**
* 删除相同元素
*
* @param element 要删除的那个元素
*/
void delete(Object element);
/**
* 根据索引删除元素
*
* @param index 要删除元素的索引
*/
void delete(int index);
/**
* 将指定索引位置的元素替换成新元素
*
* @param index 被替换元素的索引
* @param newElement 替换成的新元素
*/
void update(int index, Object newElement);
/**
* 当前列表中是否含有target这个元素
*
* @param target 要查找的元素
* @return 返回是否含有这个元素
*/
boolean contains(Object target);
/**
* 返回指定索引处的元素
*
* @param index 要返回元素的索引
* @return 返回这个元素对象
*/
Object elementAt(int index);
/**
* 查找element所在的索引,如果没有返回-1
* @param element 要查找的元素
* @return 返回元素索引
*/
int indexOf(Object element);
}
单链表的节点定义
public class ListNode {
Object data;
ListNode next;
public ListNode(Object data) {
this.data = data;
}
}
单链表的实现类
public class SingleLinkedList implements MyList {
private ListNode first;
private ListNode last;
private int size;
/**
* 新增一个元素
*
* @param element 要新增的那个元素
*/
@Override
public void add(Object element) {
if (first == null) {
first = new ListNode(element);
last = first;
} else {
last.next = new ListNode(element);
last = last.next;
}
++size;
}
/**
* 删除相同元素
*
* @param element 要删除的那个元素
*/
@Override
public void delete(Object element) {
ListNode p = first;
ListNode pre = null;
while (p != null) {
if (p.data.equals(element)) {
//如果要删除头结点,因为此时头结点的前驱节点为空,
//所以可直接用头结点的下一个节点作为新的头结点
if (p == first) {
first = first.next;
} else {
pre.next = p.next;
}
--size;
break;
}
pre = p;
p = p.next;
}
}
/**
* 根据索引删除元素
*
* @param index 要删除元素的索引
*/
@Override
public void delete(int index) {
if (index < 0 || index >= size) {
//下标越界,啥也不干
return;
}
//指针指向的节点索引
int i = 0;
ListNode p = first;
ListNode pre = null;
while (p != null) {
if (i == index) {
//删除p结点
if (p == first) {
first = first.next;
} else {
pre.next = p.next;
}
--size;
break;
}
pre = p;
p = p.next;
++i;
}
}
/**
* 将指定索引位置的元素替换成新元素
*
* @param index 被替换元素的索引
* @param newElement 替换成的新元素
*/
@Override
public void update(int index, Object newElement) {
if (index < 0 || index >= size) {
//下标越界,啥也不干
return;
}
//指针指向的节点索引
int i = 0;
ListNode p = first;
while (p != null) {
if (i == index) {
p.data = newElement;
break;
}
p = p.next;
++i;
}
}
/**
* 当前列表中是否含有target这个元素
*
* @param target 要查找的元素
* @return 返回是否含有这个元素
*/
@Override
public boolean contains(Object target) {
ListNode p = first;
while (p != null) {
if (p.data.equals(target)) {
return true;
}
p = p.next;
}
return false;
}
/**
* 返回指定索引处的元素
*
* @param index 要返回元素的索引
* @return 返回这个元素对象
*/
@Override
public Object elementAt(int index) {
if (index < 0 || index >= size) {
//下标越界,啥也不干
return null;
}
//指针指向的节点索引
int i = 0;
ListNode p = first;
while (p != null) {
if (i == index) {
return p.data;
}
p = p.next;
++i;
}
return null;
}
/**
* 查找element所在的索引,如果没有返回-1
*
* @param element 要查找的元素
* @return 返回元素索引
*/
@Override
public int indexOf(Object element) {
//指针指向的节点索引
int i = 0;
ListNode p = first;
while (p != null) {
if (p.data.equals(element)) {
return i;
}
p = p.next;
++i;
}
return -1;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder("[");
ListNode p = first;
while (p != null) {
sb.append(p.data);
if (p.next != null) {
sb.append(", ");
}
p = p.next;
}
sb.append("]");
return sb.toString();
}
}
测试演示
import org.junit.jupiter.api.Test;
class SingleLinkedListTest {
@Test
void delete() {
SingleLinkedList list = new SingleLinkedList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
//删除操作之前输出链表元素
System.out.println("删除操作之前输出链表元素: " + list);
list.delete("b");
//删除元素"b"之后输出链表元素
System.out.println("删除元素\"b\"之后输出链表元素: " + list);
//删除下标为0的元素之后输出链表元素
list.delete(0);
System.out.println("删除下标为0的元素之后输出链表元素: " + list);
}
}