10分钟学会链表！

最新推荐文章于 2022-05-07 20:15:22 发布

原创最新推荐文章于 2022-05-07 20:15:22 发布 · 391 阅读

3 ·

CC 4.0 BY-SA版权

javaSE 同时被 2 个专栏收录

85 篇文章

订阅专栏

数据结构

50 篇文章

订阅专栏

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。
链表分为是否带头节点，是否带环，是单向还是双向
不带头，不带环的单向链表：笔试面试中出场率最高

不带头节点，与带头节点，我画了张图说明
在这里插入图片描述
傀儡结点存在的意义是让代码编写起来更方便。
关于无环链表和双向链表

关于链表大致要实现一下几个功能（无头单向非循环）

// 1、无头单向非循环链表实现
public class SingleLinkedList {
     //头插法
     public void addFirst(int data);
     //尾插法
     public void addLast(int data);
     //任意位置插入,第一个数据节点为0号下标
     public boolean addIndex(int index,int data);
     //查找是否包含关键字key是否在单链表当中
     public boolean contains(int key);
     //删除第一次出现关键字为key的节点
     public void remove(int key);
     //删除所有值为key的节点
     public void removeAllKey(int key);
     //得到单链表的长度
     public int size();
     public void display();
     public void clear();
 }

首先我们需要用一个类来表示结点，这个结点包含两部分，一部分是存储的数据和方法，还有一部分是指向下一个结点的引用

class LinkNode{
    public int date;
    public LinkNode next = null;

    public LinkNode(int date){
        this.date = date;
    }
}

1.首先是头插法

我们需要判断两种情况，
1，如果链表是空链表，此时head指向的是null
2，如果当前链表不为空，head此时不为null

如果是第一种情况，只需要将head引用指向新插入的Node
如果是第二种情况，则需要考虑如下操作
在这里插入图片描述

	private LinkNode head = null;//创建一个头结点，有了这个头结点，就可以把剩下元素的next都获取到

    public void addFirst(int elem){
        LinkNode node = new LinkNode(elem);
        if(this.head == null){
            //空链表的情况
            this.head = node;
            return;
        }
        node.next = this.head;
        this.head = node;
        return;
    }

2.将链表打印出来，以便测试

打印链表的所有元素：

    public void display(){
        System.out.print("[");
        for(LinkNode node = this.head; node != null; node = node.next){
            System.out.print(node.date);
            if(node.next!= null){
                System.out.print(",");
            }
        }
        System.out.println("]");
    }

3.尾插

1.如果链表是空链表，那么直接将结点插入即可
2.如果不为空，需要找到最后一个结点，将最后一个结点的next引用指向node

在这里插入图片描述

    public void addLast(int elem){
        LinkNode node = new LinkNode(elem);
        if(this.head == null){
            this.head = node;
            return;
        }
        LinkNode cur = this.head;
        while (cur.next != null){
            cur = cur.next;
        }
        cur.next = node;
    }

4.得到单链表的长度

    public int size(){
        int size = 0;
        for(LinkNode node = this.head;
            node != null;node = node.next){
            size++;
        }
        return size;
    }

任意位置插入,第一个数据节点为0号下标

5.1合法性校验，index<0或者大于len时为不合法的
分为头插尾插，中间插三种情况
中间插分析如下，要想插入index，就需要找到index-1；
在这里插入图片描述

	public void addIndex(int index , int elem){
        LinkNode node = new LinkNode(elem);
        int len = size();
        if(index < 0 || index > len){
            //不合法
            return;
        }
        //头插
        if(index == 0){
            addFirst(elem);
            return;
        }
        //尾插
        if(index == len){
            addLast(elem);
            return;
        }
        LinkNode prev = getIndexPos(index - 1);
        node.next = prev.next;
        prev.next = node;
    }

getIndexPos

public LinkNode getIndexPos(int index){
        LinkNode cur = this.head;
        for (int i = 0;i < index;i++){
            cur = cur.next;
        }
        return cur;
    }

6.查找是否包含关键字key是否在单链表当中

    public boolean contains(int toFind) {
        // 直接遍历链表, 依次比较每个元素就行了
        for (LinkedNode cur = this.head;
                cur != null; cur = cur.next) {
            if (cur.data == toFind) {
                return true;
            }
        }
        return false;
    }

7.删除第一次出现关键字为key的节点

有三种情况需要考虑
1.空链表的情况
2.删除的时头结点
在这里插入图片描述
3.删除中间结点（重要是找到前一个结点）

    public void romove(int toremove){
        //空链表
        if (this.head == null) {
            return;
        }
        //删除头结点
        if(this.head.date == toremove){
            this.head = this.head.next;
            return;
        }
        //中间删除
        LinkNode prev = searchPrev(toremove);
        prev.next = prev.next.next;
    }
    public LinkNode searchPrev(int toremove){
        //找到删除元素的前一个位置
        for(LinkNode cur = this.head; cur != null;cur = cur.next){
            if(cur.next.date == toremove){
                return cur;
            }
        }
        return null;
    }

删除所有的key

public void romoveAllKey(int toremove){
        if(this.head == null){
            return;
        }
        for(LinkNode cur = this.head;cur != null;
            cur = cur.next){
            if(cur.date == toremove){
                romove(toremove);
            }
        }
    }

测试代码

public class Test {
    public static void main(String[] args){
        testAddFirst();
        testAddLast();
        testAddIndex();
        testremove();
        testRemoveAllKey();
    }
    public static void testAddFirst(){
        System.out.println("测试addfirst方法");
        LinkedList linkedList = new LinkedList();
        linkedList.addFirst(1);
        linkedList.addFirst(2);
        linkedList.addFirst(3);
        linkedList.addFirst(4);
        linkedList.display();
    }
    public static void testAddLast(){
        System.out.println("测试addLast方法");
        LinkedList linkedList = new LinkedList();
        linkedList.addLast(1);
        linkedList.addLast(2);
        linkedList.addLast(3);
        linkedList.display();
    }
    public static void testAddIndex(){
        System.out.println("测试addIndex方法");
        LinkedList linkedList = new LinkedList();
        linkedList.addFirst(1);
        linkedList.addFirst(2);
        linkedList.addLast(2);
        linkedList.addLast(3);
        linkedList.addIndex(4,5);
        linkedList.display();
        System.out.println(linkedList.contains(10));
    }
    public static void testremove(){
        System.out.println("测试remove");
        LinkedList linkedList = new LinkedList();
        linkedList.addFirst(1);
        linkedList.addFirst(2);
        linkedList.addLast(2);
        linkedList.addLast(3);
        linkedList.addIndex(2,5);
        linkedList.romove(5);
        linkedList.display();
    }
    public static void testRemoveAllKey(){
        System.out.println("测试removeallKesy");
        LinkedList linkedList = new LinkedList();
        linkedList.addFirst(1);
        linkedList.addFirst(1);
        linkedList.addLast(1);
        linkedList.addLast(1);
        linkedList.addIndex(2,1);
        linkedList.display();
        linkedList.romoveAllKey(1);
        linkedList.display();
    }
}

链表类的代码

class LinkNode{
    public int date;
    public LinkNode next = null;

    public LinkNode(int date){
        this.date = date;
    }
}
public class LinkedList{
    private LinkNode head = null;//创建一个头结点，有了这个头结点，就可以把剩下元素的next都获取到

    public void addFirst(int elem){
        LinkNode node = new LinkNode(elem);
        if(this.head == null){
            //空链表的情况
            this.head = node;
            return;
        }
        node.next = this.head;
        this.head = node;
        return;
    }
    public void addLast(int elem){
        LinkNode node = new LinkNode(elem);
        if(this.head == null){
            this.head = node;
            return;
        }
        LinkNode cur = this.head;
        while (cur.next != null){
            cur = cur.next;
        }
        cur.next = node;
    }
    public void display(){
        System.out.print("[");
        for(LinkNode node = this.head; node != null; node = node.next){
            System.out.print(node.date);
            if(node.next!= null){
                System.out.print(",");
            }
        }
        System.out.println("]");
    }
    public void addIndex(int index , int elem){
        LinkNode node = new LinkNode(elem);
        int len = size();
        if(index < 0 || index > len){
            //不合法
            return;
        }
        //头插
        if(index == 0){
            addFirst(elem);
            return;
        }
        //尾插
        if(index == len){
            addLast(elem);
            return;
        }
        LinkNode prev = getIndexPos(index - 1);
        node.next = prev.next;
        prev.next = node;
    }
    public LinkNode getIndexPos(int index){
        LinkNode cur = this.head;
        for (int i = 0;i < index;i++){
            cur = cur.next;
        }
        return cur;
    }
    public int size(){
        int size = 0;
        for(LinkNode node = this.head;
            node != null;node = node.next){
            size++;
        }
        return size;
    }
    public boolean contains(int key){
        for(LinkNode cur = this.head; cur != null;
            cur = cur.next){
            if(cur.date == key){
                return true;
            }
        }
        return false;
    }
    public void romove(int toremove){
        //空链表
        if (this.head == null) {
            return;
        }
        //删除头结点
        if(this.head.date == toremove){
            this.head = this.head.next;
            return;
        }
        //中间删除
        LinkNode prev = searchPrev(toremove);
//        prev.next = prev.next.next;
        LinkNode nodeToremove = prev.next;
        prev.next = nodeToremove.next;
    }
    public LinkNode searchPrev(int toremove){
        //找到删除元素的前一个位置
        for(LinkNode cur = this.head; cur != null;cur = cur.next){
            if(cur.next.date == toremove){
                return cur;
            }
        }
        return null;
    }
    public void romoveAllKey(int toremove){
        if(this.head == null){
            return;
        }
        for(LinkNode cur = this.head;cur != null;
            cur = cur.next){
            if(cur.date == toremove){
                romove(toremove);
            }
        }
    }
}