1.定义接口
public interface SeqList<E>{
//默认尾插
void add(E element);
// 在线性表中插入新元素，插入后的元素下标为index
void add(int index,E element);
//头插
public void addFirst(E val);
// 删除当前线性表中索引为index的元素，返回删除的元素值
E removeByIndex(int index);
// 删除当前线性表中第一个值为element的元素
void removeByValue(E element);
// 删除当前线性表中所有值为element的元素
void removeAllValue(E element);
// 将当前线性表中index位置的元素替换为element，返回替换前的元素值
E set(int index,E element);
//返回索引位index的元素
E get(int index);
//查询是否包含element元素
boolean contains(E element);
}
2.无头单链表实现接口
链表类和节点类的定义：
public class SingleLinkedList<E> implements SeqList<E>{
private Node head ;//第一节车厢的地址
private int size;//车厢节点的个数，保存的元素个数
//定义一个车厢类，车厢作为火车的私有内部类，对外部完全隐藏
private class Node{
E val;//保存的元素
Node next;//下一节车厢的地址
//构造方法
Node(E val){
this.val=val;
}
}
}
2.1 头插addFirst
public void addFirst(E val){
Node node=new Node(val);
node.next=head;
node=head;
size++;
}
图解：
2.2 尾插add
从中间位置插入：
@Override
public void add(int index, E element) {
if(index<0||index>size){
throw new IllegalArgumentException("add index ILLegal");
}
//判断没有前驱的情况
if(index==0){
addFirst(element);
return;
}
//中间位置插入
Node prey=head;
for(int i=0;i<index-1;i++){
prey=prey.next;
}
Node node=new Node(element);
node.next=prey.next;
prey.next=node;
size++;
}
图解：假定index=2
尾插：
@Override
public void add(E element) {
add(size,element);
}
2.3 删除元素remove
删除当前线性表中索引为index的元素，返回删除的元素值：
@Override
public E removeByIndex(int index) {
if(rangeCheck(index)){
throw new IllegalArgumentException("remove index Illegal");
}
//头节点的删除
if(index==0){
Node node=head;
head=head.next;
node.next=null;
size--;
return node.val;
}
//中间位置删除
Node prey=head;
for(int i=0;i<index-1;i++){
prey=prey.next;
}
Node node=prey.next;
prey.next=node.next;
node.next=null;
size--;
return node.val;
}
图解：
删除当前线性表中第一个值为element的元素：
@Override
public void removeByValue(E element) {
//1.base case
if(head==null){
return;
}
//2.判断头节点恰好是待删除的节点
if(head.val.equals(element)){
head=head.next;
size--;
return;
}
//3.此时头节点不为空其一定不是待删除的节点
Node prey=head;
while(prey.next!=null){
if(prey.next.equals(element)){
prey.next=prey.next.next;
size--;
return;
}
prey=prey.next;
}
//4.当前链表不存在值为element的元素
System.out.println("当前链表不存在值为"+element+"的元素");
}
删除当前线性表中所有值为element的元素：
@Override
public void removeAllValue(E element) {
//1.base case
if(head==null){
return;
}
//2.若头节点就是待删除的节点且出现连续的待删除的节点
while(head!=null && head.val.equals(element)){
head=head.next;
size--;
}
//整个链表已经删完了
if(head==null){
return;
}
//3.头节点一定不是待删除的元素且链表不为空
Node prey=head;
while(prey.next!=null){
if(prey.next.val.equals(element)){
prey.next=prey.next.next;
size--;
}else{
//只有后继节点不是待删除的节点才能移动Prey的引用
prey=prey.next;
}
}
}
2.4 修改元素set
将当前线性表中index位置的元素替换为element，返回替换前的元素值：
// 将当前线性表中index位置的元素替换为element，返回替换前的元素值
@Override
public E set(int index, E element) {
if(!rangeCheck(index)){
throw new IllegalArgumentException("set index illegal");
}
Node x=head;
//遍历，走到index对应的元素
for (int i = 0; i < index; i++) {
x=x.next;
}
E oldVal=x.val;
x.val=element;
return oldVal;
}
//合法性校验
private boolean rangeCheck(int index){
if(index<0||index>=size){
return false;
}
return true;
}
2.5 获取元素get
返回索引为index的元素：
@Override
public E get(int index) {
if(!rangeCheck(index)){
throw new IllegalArgumentException("get index illegal");
}
Node x=head;
for(int i=0;i<index;i++){
x=x.next;
}
return x.val;
}
3.带头单链表实现接口
由于单链表中都需要额外处理头结点的情况，引入一个虚拟头结点，这个节点不存在具体的值，就作为链表的头来使用，使每个有值的节点都有一个前驱。（所有操作都统一了，无论是插入还是删除，都可以看作是中间位置的插入和删除）
链表类和节点类的定义：
public class SingleLinkedListWithHead <E> implements SeqList<E>{
//当前链表一定存在火车头且不存储任何元素
private Node dummyHead=new Node(null);
//具体的元素个数
private int size;
private class Node{
E val;
Node next;
Node(E val){
this.val=val;
}
}
}
3.1 头插addFirst
public void addFirst(E val){
Node node=new Node(val);
node.next=dummyHead.next;
dummyHead.next=node;
size++;
}
图解：文章来源：https://www.toymoban.com/news/detail-628706.html
文章来源地址https://www.toymoban.com/news/detail-628706.html
3.2 尾插add
@Override
public void add(E element) {
add(size,element);
return;
}
@Override
public void add(int index, E element) {
if(index<0||index>size){
throw new IllegalArgumentException("Remove index illegal");
}
Node prey=dummyHead;
for(int i=0;i<index;i++){
prey=prey.next;
}
Node node=new Node(element);
node.next=prey.next;
prey.next=node;
size++;
}
3.3 删除元素remove
@Override
public void removeAllValue(E element) {
//prey一定指向不是待删除的节点
Node prev=dummyHead;
while(prev.next!=null){
if(prev.next.val==element){
prev.next=prev.next.next;
size--;
}else{
prev=prev.next;
}
}
}
3.4 判断是否包含元素element
@Override
public boolean contains(E element) {
while(dummyHead.next!=null){
if(dummyHead.next.val.equals(element)){
return true;
}
dummyHead.next=dummyHead.next.next;
}
return false;
}
到了这里，关于【数据结构】实现单链表的增删查的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
