数据结构《链表》

阿七想学习2024-11-13 9:13

文章目录

  • 前言
  • 一、什么是链表？
  • 二、单向链表
    • [2.1 单向链表的个人实现](#2.1 单向链表的个人实现)
    • [2.2 单向链表的例题](#2.2 单向链表的例题)
  • 三、双向链表
    • [3.1 双向链表的个人实现](#3.1 双向链表的个人实现)
    • [3.2 关于真正的java中提供的链表的使用](#3.2 关于真正的java中提供的链表的使用)
  • 总结

前言

提示：概念来源于：>>LinkedList<<

一、什么是链表？

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。

链表可分为单向链表和双向链表。

一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。

一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。

二、单向链表

一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接。

2.1 单向链表的个人实现

先定义一个接口，让个人实现的单向链表实现这个接口中的方法，感兴趣可以直接复制这段代码，然后自己试试实现。

java 复制代码 
public interface ILinkedList {
    //头插法
    public void addFirst(int data);
    //尾插法
    public void addLast(int data);
    //任意位置插入,第一个数据节点为0号下标
    public void 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();
}

display() --- 显示链表中所有内容

java 复制代码 
//显示链表中所有内容
	public void display() {
        ListNode cur = head;
        while (cur != null){
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
    }

size() --- 得到单链表的长度

java 复制代码 
//得到单链表的长度
    public int size() {
        ListNode cur = head;
        int size = 0;
        while (cur != null){
            size++;
            cur = cur.next;
        }
        return size;
    }

和上面的显示链表相似，就是遍历链表

定义一个私有方法，专门用来判断是不是空链表

java 复制代码 
	private boolean isEmpty(MySingleLinkedList mySingleLinkedList){
        return 0 == mySingleLinkedList.size();
    }

addFirst() --- 头插法

java 复制代码 
//头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        node.next = head;
        head = node;
    }

addLast(int data) --- 尾插法

java 复制代码 
//尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (isEmpty(this)){
            head = node;
            return;   //要记得加
        }
        ListNode cur = head;
        while (null != cur.next){
            cur = cur.next;
        }
        cur.next = node;
    }

contains() --- 查找是否包含关键字key

java 复制代码 
//查找是否包含关键字key是否在单链表当中
 public boolean contains(int key) {
        ListNode cur = head;
        while (cur != null){
            if(key == cur.val){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

同样是遍历链表，查找到就返回true，找不到就返回false

addIndex() --- 任意位置插入

java 复制代码 
//任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index, int data) {
        int len = size();
        if(index < 0 || index > len){
            System.out.println("输入错误");
            return;
        }
        ListNode node = new ListNode(data);
        if(0 == index){
            addFirst(data);
            return;
        }
        if (len - 1 == index){
            addLast(data);
            return;
        }
        ListNode cur = head;
        while (0 != index - 1){
            cur = cur.next;
            index--;
        }
        node.next = cur.next;
        cur.next = node;
    }

这里分了三种情况，当插入位置是0，既是头插，当插入位置为节点的长度-1时，则是尾插，其余部分是中间插入，头插和尾插直接调用上面的方法即可，这里介绍中间插入。

remove() --- 删除第一次出现关键字为key的节点

java 复制代码 
//删除第一次出现关键字为key的节点
    public void remove(int key) {
        if(isEmpty(this)){
            System.out.println("空链表无法使用");
        }
        if(key == head.val){
            head = head.next;
            return;
        }
        ListNode cur = head;
        while (null != cur.next){
            if(key != cur.next.val){
                cur = cur.next;
            }else {
                ListNode del = cur.next;
                if (null != del.next) {
                    cur.next = del.next;
                }else {
                    cur.next = null;
                }
                return;
            }
        }
        System.out.println("没有要删除的选项");
    }

删除也分为三个可能，头删，中间删，尾删，因为我们val里放的是一个基本变量，不用担心空间的释放，因为没有引用变量来引用这个对象，比如如果我们放的是一个自己定义的学生对象，我们就需要将val置为空，而这里我们只需要让被删除的节点不被前后节点指向就是删除了。

头删很简单，直接让头节点指向头节点的下一个节点即可。

接下来我们主要考虑，中间的删除和尾删。

中间删除

尾删除

这个很简单，在中间删除进行判断中，如果del的next为空，说明我们要删除最后一个节点，直接将cur.next置为空即可

removeAllKey() --- 删除所有值为key的节点

java 复制代码 
 //删除所有值为key的节点
    public void removeAllKey(int key) {
        ListNode cur = head;
        if(head == null){
            return;
        }
        while (head !=null && key == head.val){
            head = head.next;
        }
        ListNode del = cur;
        while (null != cur.next){
            if(key == cur.next.val){
                del = cur.next;
                cur.next = del.next;
            }else {
                cur = cur.next;
            }
        }
    }

这里和上面的删除第一个值为key的节点很相似，只是把原来在遇到后删除直接返回，变成了遍历整个链表，反复执行删除操作，上面的代码理解了，可以很容易看懂，这里不多赘述了。

clear() --- 清空链表

java 复制代码 
//清空链表
public void clear() {
        ListNode cur;
        while (null != head.next){
            cur = head;
            head = head.next;
            cur.next = null;
        }
        head = null;
    }

这个就简单了，这里也可以将value置为空，因为我们是整数类型，不用担心内存浪费的问题，直接将head一直往后置空就好，就相当于在删除了。

最后是整个自定义单向无头链表的实现代码整合

java 复制代码 
public class MySingleLinkedList implements ILinkedList{
    static class ListNode{
        public int val;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }
    public ListNode head;
    @Override
    public void display() {
        ListNode cur = head;
        while (cur != null){
            System.out.print(cur.val+" ");
            cur = cur.next;
        }
    }

    @Override
    //得到单链表的长度
    public int size() {
        ListNode cur = head;
        int size = 0;
        while (cur != null){
            size++;
            cur = cur.next;
        }
        return size;
    }

    @Override
    查找是否包含关键字key是否在单链表当中
    public boolean contains(int key) {
        ListNode cur = head;
        while (cur != null){
            if(key == cur.val){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    private boolean isEmpty(MySingleLinkedList mySingleLinkedList){
        return 0 == mySingleLinkedList.size();
    }

    @Override
    //头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        node.next = head;
        head = node;
    }

    @Override
    //尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (isEmpty(this)){
            head = node;
            return;   //要记得加
        }
        ListNode cur = head;
        while (null != cur.next){
            cur = cur.next;
        }
        cur.next = node;
    }

    @Override
    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index, int data) {
        int len = size();
        if(index < 0 || index > len){
            System.out.println("输入错误");
            return;
        }
        ListNode node = new ListNode(data);
        if(0 == index){
            addFirst(data);
            return;
        }
        if (len - 1 == index){
            addLast(data);
            return;
        }
        ListNode cur = head;
        while (0 != index - 1){
            cur = cur.next;
            index--;
        }
        node.next = cur.next;
        cur.next = node;
    }


    @Override
    //删除第一次出现关键字为key的节点
    public void remove(int key) {
        if(isEmpty(this)){
            System.out.println("空链表无法使用");
        }
        if(key == head.val){
            head = head.next;
            return;
        }
        ListNode cur = head;
        while (null != cur.next){
            if(key != cur.next.val){
                cur = cur.next;
            }else {
                ListNode del = cur.next;
                if (null != del.next) {
                    cur.next = del.next;
                }else {
                    cur.next = null;
                }
                return;
            }
        }
        System.out.println("没有要删除的选项");
    }

    @Override
    //删除所有值为key的节点
    public void removeAllKey(int key) {
        ListNode cur = head;
        if(head == null){
            return;
        }
        while (head !=null && key == head.val){
            head = head.next;
        }
        ListNode del = cur;
        while (null != cur.next){
            if(key == cur.next.val){
                del = cur.next;
                cur.next = del.next;
            }else {
                cur = cur.next;
            }
        }
    }

    @Override
    public void clear() {
        ListNode cur;
        while (null != head.next){
            cur = head;
            head = head.next;
            cur.next = null;
        }
        head = null;
    }
   
}

2.2 单向链表的例题

例题1.反转链表

java 复制代码 
public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null){
            ListNode newNode = cur.next;
            cur.next = pre;
            pre = cur;
            cur = newNode;
        }
    return pre;
    }

例题2. 链表的中间节点

快慢指针

java 复制代码 
public ListNode middleNode(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }

例题3. 合并两个有序链表

java 复制代码 
public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if(list1 == null){
            return list2;
        }
        if(list2 == null){
            return list1;
        }
        ListNode head = new ListNode();
        ListNode cur = head;
        while(list1 != null && list2 != null){
            if(list1.val <= list2.val){
                cur.next = list1;
                list1 = list1.next;
            }else{
                cur.next = list2;
                list2 = list2.next;
            }
            cur = cur.next;
        }
        if(list1 != null){
            cur.next = list1;
        }
        if(list2 != null){
            cur.next = list2;
        }
        return head.next;
    }

例题4. 链表分割

java 复制代码 
public ListNode partition(ListNode pHead, int x) {
        // write code here
        ListNode lb = null;
        ListNode le = null;
        ListNode bb = null;
        ListNode be = null;

        ListNode cur = pHead;
        if(cur == null){
            return pHead;
        }
        while(cur != null){
            if(cur.val < x){
                if(lb == null){
                    lb = cur;
                    le = cur;
                }else{
                    le.next = cur;
                    le = cur;
                }
            }else{
                if(bb == null){
                    bb = cur;
                    be = cur;
                }else{
                    be.next = cur;
                    be = cur;
                }
            }
            cur = cur.next;
        }
        if(lb != null){
            le.next = bb;
        }else{
            return bb;
        }
        if(bb != null){
            be.next = null;
        }
        return lb;

    }

例题5. 链表的回文结构

java 复制代码 
public boolean chkPalindrome(ListNode A) {
        // write code here
        if (A == null) {
            return false;
        }
        ListNode head = A;
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        ListNode cur = slow.next;

        while (cur != null) {
            ListNode curN = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curN;
        }
        while (head != slow) {
            if (head.next == slow) {
                return head.val == slow.val;
            }
            if (head.val != slow.val) {
                return false;
            } else {
                head = head.next;
                slow = slow.next;
            }
        }
        while (head != slow) {
            if (head.next == slow) {
                return head.val == slow.val;
            }
            if (head.val != slow.val) {
                return false;
            } else {
                head = head.next;
                slow = slow.next;
            }
        }
        return true;
    }

例题6. 相交链表

java 复制代码 
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode cur1 = headA;
        ListNode cur2 = headB;
        int count1 = 0;
        int count2 = 0;
        while(cur1 != null){
            count1++;
            cur1 = cur1.next;
        }
        while(cur2 != null){
            count2++;
            cur2 = cur2.next;
        }
        cur1 = headA;
        cur2 = headB;
        if(count1 < count2){
            int m = count2 - count1;
            while(m != 0){
                cur2 = cur2.next;
                m--;
            }
        }else{
            int m = count1 - count2;
            while(m != 0){
                cur1 = cur1.next;
                m--;
            }
        }
        
        while(cur1 != null){
            if(cur1 == cur2){
                return cur1;
            }else{
                cur1 = cur1.next;
                cur2 = cur2.next;
            }
        }
        return null;
    }

例题7. 环形链表

java 复制代码 
public boolean hasCycle(ListNode head) {
        if(head == null || head.next == null){
            return false;
        }
        ListNode slow = head;
        ListNode fast = head.next;
        while(fast != slow){
            if(fast == null || fast.next == null){
                return false;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        return true;
    }

三、双向链表

一个双向链表有三个整数值: 数值、向后的节点链接、向前的节点链接。

与单向链表不同的是，我们需要两个域来分别记录前一个节点的位置和后一个节点的位置。

3.1 双向链表的个人实现

双向链表的实现和单向链表的实现其实并不会差很多，只是我们要考虑一个节点的关于前后节点的引用。所以解析会相对简单。

同样的，通过接口来规范化我们定义的双向链表

java 复制代码 
public interface ILinkedList {
        //头插法
        public void addFirst(int data);
        //尾插法
        public void addLast(int data);
        //任意位置插入,第一个数据节点为0号下标
        public void 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();

}

display() --- 展示链表内容

java 复制代码 
public void display() {
        ListNode cur = head;
        while (null != cur){
            System.out.print(cur.val+" ");
            cur = cur.next;
        }

    }

size() --- 链表长度

java 复制代码 
public int size() {
        int size = 0;
        ListNode cur = head;
        while (null != cur){
            size++;
            cur = cur.next;
        }
        return size;
    }

addFirst() --- 头插法

java 复制代码 
public void addFirst(int data) {
        ListNode first = new ListNode(data);
        if(null == this.head){
            this.head = first;
            this.last = first;
        }else {
            first.next = this.head;
            this.head.pre = first;
            this.head = first;
        }
    }

addLast() --- 尾插法

java 复制代码 
public void addLast(int data) {
        ListNode nlast = new ListNode(data);
        if(null == this.head){
            this.head = nlast;
            this.last = nlast;
        }else {
            this.last.next = nlast;
            nlast.pre = this.last;
            this.last = nlast;
        }
    }

因为我们有一个last引用专门用来指向尾节点，所以，我们直接可以用last来插入即可。

addIndex() --- 按位置插入

java 复制代码 
public void addIndex(int index, int data) {
        try {
            if(index < 0 || index > size()){
                throw new ErrorIndexException("错误的位置！！");//这是自定义的异常
            }
            if(0 == index){
                addFirst(data);
                return;
            }//头插法
            if (size() == index){
                addLast(data);
                return;
            }//尾插法
            ListNode cur = head;
            while (index - 1 != 0){
                cur = cur.next;
                index--;
            }
            ListNode node = new ListNode(data);
            node.next = cur.next;
            node.pre = cur.next.pre;
            cur.next.pre = node;
            cur.next = node;
        }catch (ErrorIndexException e){
            e.printStackTrace();
        }

    }

contains() --- 是否包含某个数

java 复制代码 
public boolean contains(int key) {
        ListNode cur = head;

        while (null != cur){
            if (key == cur.val){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

remove() --- 删除某数

java 复制代码 
public void remove(int key) {
        ListNode cur = head;
        while (null != cur){
            if(key == cur.val){
                if(cur == head){
                    head = head.next;
                    head.pre = null;
                    return;
                }
                if(cur == last){
                    last = last.pre;
                    last.next = null;
                    return;
                }
                cur.next.pre = cur.pre;
                cur.pre.next = cur.next;
                return;
            }
            cur = cur.next;
        }
        System.out.println("没有所要删除的数字");
    }

我们分为三种情况，删除的为头节点，尾节点，和中间的。

removeAllKey() --- 删除所有的数为目标数的节点

java 复制代码 
public void removeAllKey(int key) {
        ListNode cur = head;
        while (null != cur){
            if(key == cur.val){
                if(cur == head){
                    head = head.next;
                    cur = head;
                    continue;
                }
                if(cur == last){
                    last = last.pre;
                    last.next = null;
                    cur = last;
                    continue;
                }
                if(cur.next != null && cur.pre != null){
                    ListNode curN = cur;
                    curN.next.pre = curN.pre;
                    curN.pre.next = curN.next;
                    cur = curN.next;
                    continue;
                }
            }
            cur = cur.next;
        }
    }

与上面的删除某个节点不同的是我们需要记录被删除的点(用curN记录)，便于我们可以继续遍历链表。

clear() --- 清空链表

java 复制代码 
public void clear() {
        while (null != head){
            ListNode headN = head;
            head = head.next;
            headN = null;
        }
        head = null;
    }

最后是整个个人实现链表的代码整合

java 复制代码 
public class MyLinkedList implements ILinkedList{
    static class ListNode{
        private final int val;
        private ListNode pre;
        private ListNode next;
        public ListNode(int val) {
            this.val = val;
        }
    }
    private ListNode head;
    private ListNode last;

    @Override
    public void addFirst(int data) {
        ListNode first = new ListNode(data);
        if(null == this.head){
            this.head = first;
            this.last = first;
        }else {
            first.next = this.head;
            this.head.pre = first;
            this.head = first;
        }
    }

    @Override
    public void addLast(int data) {
        ListNode nlast = new ListNode(data);
        if(null == this.head){
            this.head = nlast;
            this.last = nlast;
        }else {
            this.last.next = nlast;
            nlast.pre = this.last;
            this.last = nlast;
        }
    }

    @Override
    public void addIndex(int index, int data) {
        try {
            if(index < 0 || index > size()){
                throw new ErrorIndexException("错误的位置！！");
            }
            if(0 == index){
                addFirst(data);
                return;
            }
            if (size() == index){
                addLast(data);
                return;
            }
            ListNode cur = head;
            while (index - 1 != 0){
                cur = cur.next;
                index--;
            }
            ListNode node = new ListNode(data);
            node.next = cur.next;
            node.pre = cur.next.pre;
            cur.next.pre = node;
            cur.next = node;
        }catch (ErrorIndexException e){
            e.printStackTrace();
        }

    }

    @Override
    public boolean contains(int key) {
        ListNode cur = head;

        while (null != cur){
            if (key == cur.val){
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    @Override
    public void remove(int key) {
        ListNode cur = head;
        while (null != cur){
            if(key == cur.val){
                if(cur == head){
                    head = head.next;
                    head.pre = null;
                    return;
                }
                if(cur == last){
                    last = last.pre;
                    last.next = null;
                    return;
                }
                cur.next.pre = cur.pre;
                cur.pre.next = cur.next;
                return;
            }
            cur = cur.next;
        }
        System.out.println("没有所要删除的数字");
    }

    @Override
    public void removeAllKey(int key) {
        ListNode cur = head;
        while (null != cur){
            if(key == cur.val){
                if(cur == head){
                    head = head.next;
                    cur = head;
                    continue;
                }
                if(cur == last){
                    last = last.pre;
                    last.next = null;
                    cur = last;
                    continue;
                }
                if(cur.next != null && cur.pre != null){
                    ListNode curN = cur;
                    curN.next.pre = curN.pre;
                    curN.pre.next = curN.next;
                    cur = curN.next;
                    continue;
                }
            }
            cur = cur.next;
        }
    }

    @Override
    public int size() {
        int size = 0;
        ListNode cur = head;
        while (null != cur){
            size++;
            cur = cur.next;
        }
        return size;
    }

    @Override
    public void display() {
        ListNode cur = head;
        while (null != cur){
            System.out.print(cur.val+" ");
            cur = cur.next;
        }

    }

    @Override
    public void clear() {
        while (null != head){
            ListNode headN = head;
            head = head.next;
            headN = null;
        }
        head = null;
    }
}

3.2 关于真正的java中提供的链表的使用

java 复制代码 
// 引入 LinkedList 类
import java.util.LinkedList; 

LinkedList<E> list = new LinkedList<E>();   // 普通创建方法
或者
LinkedList<E> list = new LinkedList(Collection<? extends E> c); // 使用集合创建链表
java 复制代码 
LinkedList<Integer> linkedList = new LinkedList<>();//链表的实例化
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        linkedList.add(4);
        linkedList.add(5);
        linkedList.add(6);
        linkedList.add(7);
        //foreach遍历
        for (int e:
             linkedList) {
            System.out.println(e);
        }
        //迭代器正向遍历
        ListIterator<Integer> iterator = linkedList.listIterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next() + " ");
        }
        //反向迭代器反向遍历
        while (iterator.hasPrevious()){
            System.out.println(iterator.previous() + " ");
        }

关于双向链表的例题很多都要涉及后面诸如栈队列的内容，所以先不提供了，同时我们也可以发现，同样的题，双向链表要比单向链表要容易解决，因为它可以记录前后两个节点。

总结

本篇文章介绍了有关数据结构中链表的相关内容，如单向链表，双向链表，如果有什么不正确的、不严谨的地方，还望指正，谢谢大家！

相关推荐
蜜桃小阿雯1 分钟前
JAVA开源项目 微服务在线教育系统 计算机毕业设计
java·开发语言·spring boot·微服务·java-ee·开源·maven
花下的晚风1 分钟前
单元测试时报错找不到@SpringBootConfiguration
java·开发语言·单元测试
王夏奇3 分钟前
C代码—单元测试中的覆盖率—学习笔记
笔记·学习·单元测试
雷神乐乐10 分钟前
Flume学习
hadoop·学习·flume
爱编程— 的小李10 分钟前
结构体（c语言）
c语言·开发语言
向上的车轮15 分钟前
ODOO学习笔记（8）：模块化架构的优势
笔记·python·学习·架构
卓越小Y16 分钟前
配置jellyfin docker 硬件加速
java·spring cloud·docker
白萝卜弟弟19 分钟前
【JAVA】正则表达式中的捕获组和非捕获组
java·正则表达式
fathing23 分钟前
c# 调用c++ 的dll 出现找不到函数入口点
开发语言·c++·c#
袁庭新39 分钟前
LuaRocks如何安装数据库驱动？
java·数据库·redis·lua·luarocks·袁庭新
热门推荐
01软件工程从理论到实践客观题汇总(头歌第一章至第八章)02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04VSCode插件 —— Cody AI （免费AI助手！）05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06Windows10安装PCL1.14.0及点云配准07Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO08文件或文件夹名称中有空格如何批量去除09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10【QuikGraph】C#调用第三方库实现迪杰斯特拉(Dijkstra)算法功能