Java数据结构和算法三 链表

最新推荐文章于 2023-09-23 20:18:55 发布
最新推荐文章于 2023-09-23 20:18:55 发布
阅读量165 收藏
点赞数
分类专栏： Java数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lshwjw/article/details/99707273
版权

1 链表简介

链表是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针。使用链表结构可以克服数组需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。链表一般分为单链表、双端链表、双向链表、有序链表、单向循环链表等。

2 单链表

单链表的节点分为两个部分，第一个部分保存或者显示关于节点的信息，另一个部分存储下一个节点的地址。最后一个节点存储地址的部分指向空值。单向链表只可向一个方向遍历，一般查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。

2.1 代码示例
package com.example.array;

/**
 * 单向链表
 */
public class SingleLinkedList {

    /**
     * 元素个数
     */
    private int size;
    /**
     * 头节点
     */
    private Node head;

    private class Node {

        /**
         * 数据
         */
        private int data;
        /**
         * 下一个节点
         */
        private Node next;

        public Node(int data) {
            this.data = data;
        }
    }

    /**
     * 添加头节点
     * @param data
     * @return
     */
    public boolean addHead(int data) {
        Node newNode = new Node(data);
        if (isEmpty()) {
            head = newNode;
        } else {
            newNode.next = head;
            head = newNode;
        }
        size++;
        return true;
    }

    /**
     * 添加尾节点
     * @param data
     * @return
     */
    public boolean addTail(int data) {
        Node newNode = new Node(data);
        if (isEmpty()) {
            head = newNode;
        } else {
            Node current = head;
            while (true) {
                if (current.next == null) {
                    current.next = newNode;
                    break;
                }
                current = current.next;
            }
        }
        size++;
        return true;
    }

    /**
     * 删除头节点
     * @return
     */
    public boolean deleteHead() {
        if (isEmpty()) {
            System.out.println("链表为空，无法删除头节点！");
            return false;
        }
        head = head.next;
        size--;
        return true;
    }

    /**
     * 根据data值删除节点
     * @param data
     * @return
     */
    public boolean delete(int data) {
        if (isEmpty()) {
            System.out.println("链表为空，无法根据data值删除节点！");
            return false;
        }
        Node current = head;
        Node previous = head;
        while (current.data != data) {
            if (current.next == null) {
                System.out.println("根据data值未找到节点，无法根据data值删除节点！");
                return false;
            } else {
                previous = current;
                current = current.next;
            }
        }
        if (current == head) {
            head = current.next;
            current.next = null;
        } else {
            previous.next = current.next;
        }
        size--;
        return true;
    }

    /**
     * 根据data值查找节点
     * @param data
     * @return
     */
    public boolean find(int data) {
        if (isEmpty()) {
            System.out.println("链表为空，无法根据data值查找节点！");
            return false;
        }
        Node current = head;
        int tempSise = size;
        while (tempSise > 0) {
            if (data == current.data) {
                return true;
            } else {
                current = current.next;
            }
            tempSise--;
        }
        return false;
    }

    /**
     * 判断链表是否为空
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 获取链表元素个数
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 遍历链表
     */
    public void display() {
        if (isEmpty()) {
            System.out.println("遍历结果：链表为空！");
            return;
        }
        if (size == 1) {
            System.out.println("遍历结果：" + head.data);
            return;
        }
        Node node = head;
        int tempSize = size;
        System.out.print("遍历结果：");
        while (tempSize > 0) {
            System.out.print(node.data + "\t");
            node = node.next;
            tempSize--;
        }
        System.out.println();
    }

}
2.2 测试
package com.example.array;

import org.junit.Test;

/**
 * 测试单向链表
 */
public class TestSingleLinkedList {

    /**
     * 测试添加头节点
     */
    @Test
    public void testAddHead() {
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addHead(1);
        singleLinkedList.display();
        singleLinkedList.addHead(2);
        singleLinkedList.display();
    }

    /**
     * 测试添加尾节点
     */
    @Test
    public void testAddTail() {
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addTail(1);
        singleLinkedList.display();
        singleLinkedList.addTail(2);
        singleLinkedList.display();
    }

    /**
     * 测试删除头节点
     */
    @Test
    public void testDeleteHead() {
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.deleteHead();
        singleLinkedList.addTail(1);
        singleLinkedList.addTail(2);
        singleLinkedList.addTail(3);
        singleLinkedList.display();
        singleLinkedList.deleteHead();
        singleLinkedList.display();
        singleLinkedList.deleteHead();
        singleLinkedList.display();
        singleLinkedList.deleteHead();
        singleLinkedList.display();
    }

    /**
     * 测试根据data值删除节点
     */
    @Test
    public void testDelete() {
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.delete(2);
        singleLinkedList.addTail(1);
        singleLinkedList.addTail(2);
        singleLinkedList.addTail(3);
        singleLinkedList.display();
        singleLinkedList.delete(2);
        singleLinkedList.display();
        singleLinkedList.delete(10);
        singleLinkedList.display();
    }

    /**
     * 测试根据data值查找节点
     */
    @Test
    public void testFind() {
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.find(3);
        singleLinkedList.addTail(1);
        singleLinkedList.addTail(2);
        singleLinkedList.addTail(3);
        singleLinkedList.display();
        boolean flag = singleLinkedList.find(3);
        System.out.println(flag);
        flag = singleLinkedList.find(5);
        System.out.println(flag);
    }
}

3 双端链表

单链表如果想在尾部添加一个节点，那么必须从头部一直遍历到尾部，找到尾节点，然后在尾节点后面插入一个节点。如果我们在设计链表的时候多个对尾节点的引用，那么会简单很多。

3.1 代码示例
package com.example.array;

/**
 * 双端链表
 */
public class DoublePointLinkedList {

    /**
     * 元素个数
     */
    private int size;
    /**
     * 头节点
     */
    private Node head;
    /**
     * 尾节点
     */
    private Node tail;

    private class Node {

        /**
         * 数据
         */
        private int data;
        /**
         * 下一个节点
         */
        private Node next;

        public Node(int data) {
            this.data = data;
        }
    }

    /**
     * 添加头节点
     * @param data
     * @return
     */
    public boolean addHead(int data) {
        Node newNode = new Node(data);
        if (isEmpty()) {
            head = newNode;
            tail = newNode;
        } else {
            newNode.next = head;
            head = newNode;
        }
        size++;
        return true;
    }

    /**
     * 添加尾节点
     * @param data
     * @return
     */
    public boolean addTail(int data) {
        Node newNode = new Node(data);
        if (isEmpty()) {
            head = newNode;
            tail = newNode;
        } else {
            tail.next = newNode;
            tail = newNode;
        }
        size++;
        return true;
    }

    /**
     * 删除头节点
     * @return
     */
    public boolean deleteHead() {
        if (isEmpty()) {
            System.out.println("链表为空，无法删除头节点！");
            return false;
        }
        if (head.next == null) {
            head = null;
            tail = null;
        } else {
            head = head.next;
        }
        size--;
        return true;
    }

    /**
     * 根据data值删除节点
     * @param data
     * @return
     */
    public boolean delete(int data) {
        if (isEmpty()) {
            System.out.println("链表为空，无法根据data值删除节点！");
            return false;
        }
        if (head.next == null) {
            head = null;
            tail = null;
        } else {
            Node current = head;
            Node previous = head;
            while (current.data != data) {
                if (current.next == null) {
                    System.out.println("根据data值未找到节点，无法根据data值删除节点！");
                    return false;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head) {
                head = current.next;
                current.next = null;
            } else if (current == tail) {
                tail = previous;
                previous.next = null;
            } else {
                previous.next = current.next;
            }
        }
        size--;
        return true;
    }

    /**
     * 根据data值查找节点
     * @param data
     * @return
     */
    public boolean find(int data) {
        if (isEmpty()) {
            System.out.println("链表为空，无法根据data值查找节点！");
            return false;
        }
        Node current = head;
        int tempSise = size;
        while (tempSise > 0) {
            if (data == current.data) {
                return true;
            } else {
                current = current.next;
            }
            tempSise--;
        }
        return false;
    }

    /**
     * 判断链表是否为空
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 获取链表元素个数
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 遍历链表
     */
    public void display() {
        if (isEmpty()) {
            System.out.println("遍历结果：链表为空！");
            return;
        }
        if (size == 1) {
            System.out.println("遍历结果：" + head.data);
            return;
        }
        Node node = head;
        int tempSize = size;
        System.out.print("遍历结果：");
        while (tempSize > 0) {
            System.out.print(node.data + "\t");
            node = node.next;
            tempSize--;
        }
        System.out.println();
    }
}
3.2 测试
package com.example.array;

import org.junit.Test;

/**
 * 测试双端链表
 */
public class TestDoublePointLinkedList {

    /**
     * 测试添加头节点
     */
    @Test
    public void testAddHead() {
        DoublePointLinkedList doublePointLinkedList = new DoublePointLinkedList();
        doublePointLinkedList.addHead(1);
        doublePointLinkedList.display();
        doublePointLinkedList.addHead(2);
        doublePointLinkedList.display();
    }

    /**
     * 测试添加尾节点
     */
    @Test
    public void testAddTail() {
        DoublePointLinkedList doublePointLinkedList = new DoublePointLinkedList();
        doublePointLinkedList.addTail(1);
        doublePointLinkedList.display();
        doublePointLinkedList.addTail(2);
        doublePointLinkedList.display();
    }

    /**
     * 测试删除头节点
     */
    @Test
    public void testDeleteHead() {
        DoublePointLinkedList doublePointLinkedList = new DoublePointLinkedList();
        doublePointLinkedList.deleteHead();
        doublePointLinkedList.addTail(1);
        doublePointLinkedList.addTail(2);
        doublePointLinkedList.addTail(3);
        doublePointLinkedList.display();
        doublePointLinkedList.deleteHead();
        doublePointLinkedList.display();
        doublePointLinkedList.deleteHead();
        doublePointLinkedList.display();
        doublePointLinkedList.deleteHead();
        doublePointLinkedList.display();
    }

    /**
     * 测试根据data值删除节点
     */
    @Test
    public void testDelete() {
        DoublePointLinkedList doublePointLinkedList = new DoublePointLinkedList();
        doublePointLinkedList.delete(2);
        doublePointLinkedList.addTail(1);
        doublePointLinkedList.addTail(2);
        doublePointLinkedList.addTail(3);
        doublePointLinkedList.display();
        doublePointLinkedList.delete(2);
        doublePointLinkedList.display();
        doublePointLinkedList.delete(10);
        doublePointLinkedList.display();
        doublePointLinkedList.delete(1);
        doublePointLinkedList.display();
        doublePointLinkedList.delete(3);
        doublePointLinkedList.display();
    }

    /**
     * 测试根据data值查找节点
     */
    @Test
    public void testFind() {
        DoublePointLinkedList doublePointLinkedList = new DoublePointLinkedList();
        doublePointLinkedList.find(3);
        doublePointLinkedList.addTail(1);
        doublePointLinkedList.addTail(2);
        doublePointLinkedList.addTail(3);
        doublePointLinkedList.display();
        boolean flag = doublePointLinkedList.find(3);
        System.out.println(flag);
        flag = doublePointLinkedList.find(5);
        System.out.println(flag);
    }
}

4 双向链表

单链表只能从一个方向遍历，双向链表可以从两个方向遍历。

4.1 代码示例
package com.example.array;

/**
 * 双向链表
 */
public class TwoWayLinkedList {

    /**
     * 元素个数
     */
    private int size;
    /**
     * 头节点
     */
    private Node head;
    /**
     * 尾节点
     */
    private Node tail;

    private class Node {

        /**
         * 数据
         */
        private int data;
        /**
         * 下一个节点
         */
        private Node next;
        /**
         * 上一个节点
         */
        private Node prev;

        public Node(int data) {
            this.data = data;
        }
    }

    /**
     * 添加头节点
     * @param data
     * @return
     */
    public boolean addHead(int data) {
        Node newNode = new Node(data);
        if (isEmpty()) {
            head = newNode;
            tail = newNode;
        } else {
            head.prev = newNode;
            newNode.next = head;
            head = newNode;
        }
        size++;
        return true;
    }

    /**
     * 添加尾节点
     * @param data
     * @return
     */
    public boolean addTail(int data) {
        Node newNode = new Node(data);
        if (isEmpty()) {
            head = newNode;
            tail = newNode;
        } else {
            newNode.prev = tail;
            tail.next = newNode;
            tail = newNode;
        }
        size++;
        return true;
    }

    /**
     * 删除头节点
     * @return
     */
    public boolean deleteHead() {
        if (isEmpty()) {
            System.out.println("链表为空，无法删除头节点！");
            return false;
        }
        if (head.next == null) {
            head = null;
            tail = null;
        } else {
            head = head.next;
            head.prev = null;
        }
        size--;
        return true;
    }

    /**
     * 删除尾节点
     * @return
     */
    public boolean deleteTail() {
        if (isEmpty()) {
            System.out.println("链表为空，无法删除尾节点！");
            return false;
        }
        if (head.next == null) {
            head = null;
            tail = null;
        } else {
            tail = tail.prev;
            tail.next = null;
        }
        size--;
        return true;
    }

    /**
     * 根据data值删除节点
     * @param data
     * @return
     */
    public boolean delete(int data) {
        if (isEmpty()) {
            System.out.println("链表为空，无法根据data值删除节点！");
            return false;
        }
        if (head.next == null) {
            head = null;
            tail = null;
        } else {
            Node current = head;
            Node previous = head;
            while (current.data != data) {
                if (current.next == null) {
                    System.out.println("根据data值未找到节点，无法根据data值删除节点！");
                    return false;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head) {
                head = current.next;
                current.next = null;
            } else if (current == tail) {
                tail = previous;
                previous.next = null;
            } else {
                current.next.prev = previous;
                previous.next = current.next;
            }
        }
        size--;
        return true;
    }

    /**
     * 根据data值查找节点
     * @param data
     * @return
     */
    public boolean find(int data) {
        if (isEmpty()) {
            System.out.println("链表为空，无法根据data值查找节点！");
            return false;
        }
        Node current = head;
        int tempSise = size;
        while (tempSise > 0) {
            if (data == current.data) {
                return true;
            } else {
                current = current.next;
            }
            tempSise--;
        }
        return false;
    }

    /**
     * 判断链表是否为空
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 获取链表元素个数
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 遍历链表
     */
    public void display() {
        if (isEmpty()) {
            System.out.println("遍历结果：链表为空！");
            return;
        }
        if (size == 1) {
            System.out.println("遍历结果：" + head.data);
            return;
        }
        Node node = head;
        int tempSize = size;
        System.out.print("遍历结果：");
        while (tempSize > 0) {
            System.out.print(node.data + "\t");
            node = node.next;
            tempSize--;
        }
        System.out.println();
    }
}
4.2 测试
package com.example.array;

import org.junit.Test;

/**
 * 测试双向链表
 */
public class TestTwoWayLinkedList {

    /**
     * 测试添加头节点
     */
    @Test
    public void testAddHead() {
        TwoWayLinkedList twoWayLinkedList = new TwoWayLinkedList();
        twoWayLinkedList.addHead(1);
        twoWayLinkedList.display();
        twoWayLinkedList.addHead(2);
        twoWayLinkedList.display();
    }

    /**
     * 测试添加尾节点
     */
    @Test
    public void testAddTail() {
        TwoWayLinkedList twoWayLinkedList = new TwoWayLinkedList();
        twoWayLinkedList.addTail(1);
        twoWayLinkedList.display();
        twoWayLinkedList.addTail(2);
        twoWayLinkedList.display();
    }

    /**
     * 测试删除头节点
     */
    @Test
    public void testDeleteHead() {
        TwoWayLinkedList twoWayLinkedList = new TwoWayLinkedList();
        twoWayLinkedList.deleteHead();
        twoWayLinkedList.addTail(1);
        twoWayLinkedList.addTail(2);
        twoWayLinkedList.addTail(3);
        twoWayLinkedList.display();
        twoWayLinkedList.deleteHead();
        twoWayLinkedList.display();
        twoWayLinkedList.deleteHead();
        twoWayLinkedList.display();
        twoWayLinkedList.deleteHead();
        twoWayLinkedList.display();
    }

    /**
     * 测试删除头节点
     */
    @Test
    public void testDeleteTail() {
        TwoWayLinkedList twoWayLinkedList = new TwoWayLinkedList();
        twoWayLinkedList.deleteHead();
        twoWayLinkedList.addTail(1);
        twoWayLinkedList.addTail(2);
        twoWayLinkedList.addTail(3);
        twoWayLinkedList.display();
        twoWayLinkedList.deleteTail();
        twoWayLinkedList.display();
        twoWayLinkedList.deleteTail();
        twoWayLinkedList.display();
        twoWayLinkedList.deleteTail();
        twoWayLinkedList.display();
    }

    /**
     * 测试根据data值删除节点
     */
    @Test
    public void testDelete() {
        TwoWayLinkedList twoWayLinkedList = new TwoWayLinkedList();
        twoWayLinkedList.delete(2);
        twoWayLinkedList.addTail(1);
        twoWayLinkedList.addTail(2);
        twoWayLinkedList.addTail(3);
        twoWayLinkedList.display();
        twoWayLinkedList.delete(2);
        twoWayLinkedList.display();
        twoWayLinkedList.delete(10);
        twoWayLinkedList.display();
        twoWayLinkedList.delete(1);
        twoWayLinkedList.display();
        twoWayLinkedList.delete(3);
        twoWayLinkedList.display();
    }

    /**
     * 测试根据data值查找节点
     */
    @Test
    public void testFind() {
        TwoWayLinkedList twoWayLinkedList = new TwoWayLinkedList();
        twoWayLinkedList.find(3);
        twoWayLinkedList.addTail(1);
        twoWayLinkedList.addTail(2);
        twoWayLinkedList.addTail(3);
        twoWayLinkedList.display();
        boolean flag = twoWayLinkedList.find(3);
        System.out.println(flag);
        flag = twoWayLinkedList.find(5);
        System.out.println(flag);
    }
}

5 有序链表

有序链表数据是按照关键值有序排列的。一般在大多数需要使用有序数组的场合也可以使用有序链表。有序链表优于有序数组的地方是插入的速度（因为元素不需要移动），另外链表可以扩展到全部有效的使用内存，而数组只能局限于一个固定的大小中。

5.1 代码示例
package com.example.array;

/**
 * 有序链表
 */
public class OrderLinkedList {

    /**
     * 元素个数
     */
    private int size;
    /**
     * 头节点
     */
    private Node head;

    private class Node {

        /**
         * 数据
         */
        private int data;
        /**
         * 下一个节点
         */
        private Node next;

        public Node(int data) {
            this.data = data;
        }
    }

    /**
     * 有序添加节点
     * @param data
     */
    public boolean insert(int data) {
        Node newNode = new Node(data);
        Node pre = null;
        Node current = head;
        while (current != null && data > current.data) {
            pre = current;
            current = current.next;
        }
        if (pre == null) {
            head = newNode;
            head.next = current;
        } else {
            pre.next = newNode;
            newNode.next = current;
        }
        size++;
        return true;
    }

    /**
     * 删除头节点
     * @return
     */
    public boolean deleteHead() {
        if (isEmpty()) {
            System.out.println("链表为空，无法删除头节点！");
            return false;
        }
        head = head.next;
        size--;
        return true;
    }

    /**
     * 根据data值删除节点
     * @param data
     * @return
     */
    public boolean delete(int data) {
        if (isEmpty()) {
            System.out.println("链表为空，无法根据data值删除节点！");
            return false;
        }
        Node current = head;
        Node previous = head;
        while (current.data != data) {
            if (current.next == null) {
                System.out.println("根据data值未找到节点，无法根据data值删除节点！");
                return false;
            } else {
                previous = current;
                current = current.next;
            }
        }
        if (current == head) {
            head = current.next;
            current.next = null;
        } else {
            previous.next = current.next;
        }
        size--;
        return true;
    }

    /**
     * 根据data值查找节点
     * @param data
     * @return
     */
    public boolean find(int data) {
        if (isEmpty()) {
            System.out.println("链表为空，无法根据data值查找节点！");
            return false;
        }
        Node current = head;
        int tempSise = size;
        while (tempSise > 0) {
            if (data == current.data) {
                return true;
            } else {
                current = current.next;
            }
            tempSise--;
        }
        return false;
    }

    /**
     * 判断链表是否为空
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 获取链表元素个数
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 遍历链表
     */
    public void display() {
        if (isEmpty()) {
            System.out.println("遍历结果：链表为空！");
            return;
        }
        if (size == 1) {
            System.out.println("遍历结果：" + head.data);
            return;
        }
        Node node = head;
        int tempSize = size;
        System.out.print("遍历结果：");
        while (tempSize > 0) {
            System.out.print(node.data + "\t");
            node = node.next;
            tempSize--;
        }
        System.out.println();
    }
}
5.2 测试
package com.example.array;

import org.junit.Test;

/**
 * 测试有序链表
 */
public class TestOrderLinkedList {

    /**
     * 测试有序添加节点
     */
    @Test
    public void testInsert() {
        OrderLinkedList orderLinkedList = new OrderLinkedList();
        orderLinkedList.insert(1);
        orderLinkedList.display();
        orderLinkedList.insert(2);
        orderLinkedList.display();
    }

    /**
     * 测试删除头节点
     */
    @Test
    public void testDeleteHead() {
        OrderLinkedList orderLinkedList = new OrderLinkedList();
        orderLinkedList.deleteHead();
        orderLinkedList.insert(1);
        orderLinkedList.insert(2);
        orderLinkedList.insert(3);
        orderLinkedList.display();
        orderLinkedList.deleteHead();
        orderLinkedList.display();
        orderLinkedList.deleteHead();
        orderLinkedList.display();
        orderLinkedList.deleteHead();
        orderLinkedList.display();
    }

    /**
     * 测试根据data值删除节点
     */
    @Test
    public void testDelete() {
        OrderLinkedList orderLinkedList = new OrderLinkedList();
        orderLinkedList.delete(2);
        orderLinkedList.insert(1);
        orderLinkedList.insert(2);
        orderLinkedList.insert(3);
        orderLinkedList.display();
        orderLinkedList.delete(2);
        orderLinkedList.display();
        orderLinkedList.delete(10);
        orderLinkedList.display();
    }

    /**
     * 测试根据data值查找节点
     */
    @Test
    public void testFind() {
        OrderLinkedList orderLinkedList = new OrderLinkedList();
        orderLinkedList.find(3);
        orderLinkedList.insert(1);
        orderLinkedList.insert(2);
        orderLinkedList.insert(3);
        orderLinkedList.display();
        boolean flag = orderLinkedList.find(3);
        System.out.println(flag);
        flag = orderLinkedList.find(5);
        System.out.println(flag);
    }
}

6 单向循环链表

单链表是不闭合的，单向循环链表尾节点的next指针指向头节点，形成闭环。

6.1 代码示例
package com.example.array;

/**
 * 单向循环链表
 */
public class CircleLinkedList {

    /**
     * 元素个数
     */
    private int size;
    /**
     * 头节点
     */
    private Node head;

    private class Node {

        /**
         * 数据
         */
        private int data;
        /**
         * 下一个节点
         */
        private Node next;

        public Node(int data) {
            this.data = data;
        }
    }

    /**
     * 添加节点
     * @param data
     * @return
     */
    public boolean insert(int data) {
        Node newNode = new Node(data);
        if (isEmpty()) {
            newNode.next = newNode;
            head = newNode;
        } else {
            Node current = head;
            while (true) {
                if (current.next == head) {
                    newNode.next = head;
                    current.next = newNode;
                    break;
                }
                current = current.next;
            }
        }
        size++;
        return true;
    }

    /**
     * 根据data值删除节点
     * @param data
     * @return
     */
    public boolean delete(int data) {
        if (isEmpty()) {
            System.out.println("链表为空，无法根据data值删除节点！");
            return false;
        }
        if (head.next == head) {
            head = null;
        } else {
            Node current = head;
            Node previous = head;
            while (true) {
                if (current.next == head) {
                    previous = current;
                    current = head;
                    break;
                }
                current = current.next;
            }
            while (current.data != data) {
                if (current.next == head) {
                    System.out.println("根据data值未找到节点，无法根据data值删除节点！");
                    return false;
                } else {
                    previous = current;
                    current = current.next;
                }
            }
            if (current == head) {
                head = current.next;
                current.next = null;
                previous.next = head;
            } else if (current.next == head) {
                current.next = null;
                previous.next = head;
            } else {
                previous.next = current.next;
                current.next = null;
            }
        }
        size--;
        return true;
    }

    /**
     * 根据data值查找节点
     * @param data
     * @return
     */
    public boolean find(int data) {
        if (isEmpty()) {
            System.out.println("链表为空，无法根据data值查找节点！");
            return false;
        }
        Node current = head;
        int tempSise = size;
        while (tempSise > 0) {
            if (data == current.data) {
                return true;
            } else {
                current = current.next;
            }
            tempSise--;
        }
        return false;
    }

    /**
     * 判断链表是否为空
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 获取链表元素个数
     * @return
     */
    public int getSize() {
        return size;
    }

    /**
     * 遍历链表
     */
    public void display() {
        if (isEmpty()) {
            System.out.println("遍历结果：链表为空！");
            return;
        }
        if (size == 1) {
            System.out.println("遍历结果：" + head.data);
            return;
        }
        Node node = head;
        int tempSize = size;
        System.out.print("遍历结果：");
        while (tempSize > 0) {
            System.out.print(node.data + "\t");
            node = node.next;
            tempSize--;
        }
        System.out.println();
    }
}
6.2 测试
package com.example.array;

import org.junit.Test;

/**
 * 测试单向链表
 */
public class TestCircleLinkedList {

    /**
     * 测试添加节点
     */
    @Test
    public void testInsert() {
        CircleLinkedList circleLinkedList = new CircleLinkedList();
        circleLinkedList.insert(1);
        circleLinkedList.display();
        circleLinkedList.insert(2);
        circleLinkedList.display();
    }

    /**
     * 测试根据data值删除节点
     */
    @Test
    public void testDelete() {
        CircleLinkedList circleLinkedList = new CircleLinkedList();
        circleLinkedList.delete(2);
        circleLinkedList.insert(1);
        circleLinkedList.insert(2);
        circleLinkedList.insert(3);
        circleLinkedList.display();
        circleLinkedList.delete(2);
        circleLinkedList.display();
        circleLinkedList.delete(10);
        circleLinkedList.display();
        circleLinkedList.delete(3);
        circleLinkedList.display();
        circleLinkedList.delete(1);
        circleLinkedList.display();
    }

    /**
     * 测试根据data值查找节点
     */
    @Test
    public void testFind() {
        CircleLinkedList circleLinkedList = new CircleLinkedList();
        circleLinkedList.find(3);
        circleLinkedList.insert(1);
        circleLinkedList.insert(2);
        circleLinkedList.insert(3);
        circleLinkedList.display();
        boolean flag = circleLinkedList.find(3);
        System.out.println(flag);
        flag = circleLinkedList.find(5);
        System.out.println(flag);
    }
}
lshwjw
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java数据结构和算法实践
03-18
数据结构和算法是计算机科学的核心基础,对于编程开发人员来说,掌握它们至关重要。以下是关于Java数据结构和算法的一些介绍: Java作为一种流行的编程语言,在数据结构和算法的实现方面有着广泛的应用。数据结构指的是在计算机中组织和存储数据的方式,算法则是明确定义的解决特定问题的规则和步骤。数据结构和算法彼此密切相关,良好的数据结构设计可以更高效地实现算法,而算法的设计也需要考虑数据的组织方式。 Java提供了丰富的数据结构,包括数组、链表、栈、队列、树、图等。掌握这些数据结构的特点、优缺点以及适用场景,对于编写高质量的代码至关重要。例如,当需要快速插入和删除操作时,链表比数组更加高效;当需要快速随机访问时,数组比链表更加高效。树和图这样的数据结构在处理层次数据和网络数据时非常有用。 算法则是解决特定问题的步骤和方法。常见的算法包括排序算法(如冒泡排序、快速排序)、搜索算法(如二分查找)、图算法(如最短路径算法)等。掌握这些算法的思想和实现方式,可以提高代码的效率和性能。此外,算法设计中的一些基本思想,如递归、动态规划、贪心算法等,也是值得深入学习的。
java用三叉链表构建二叉树,二叉树的三叉链表存储及其Java实现
weixin_39620845的博客
03-16 349
三叉链表存储的思想是让每个节点持有三个引用parent、left、right，分别指向其父节点、左子节点和右子节点。如下图所示： 因此，三叉链表存储的节点大致如：class Node{T data;Node parent;Node left;Node right;}Java实现代码：package com.liuhao.DataStructures;import com.liuhao.DataSt...
三个链表有序求交java_Java实现--有序链表
weixin_30242527的博客
02-23 81
《Java数据结构和算法》有感而出，最好自己先尝试实现一遍。代码中有详细的注释：/*** 定义一个结点类* @author Administrator**/public class Link {public int data;//数据域public Link next;//指向下一个结点public Link(int data) {super();this.data = data;}//打印结点的...
求三链表公共元素
相似的人适合一起打闹
02-24 263
求链表 A B C 共有元素 本题要求找到公有元素后将三个链表中 所有非公有元素都删除 #include<bits/stdc++.h> using namespace std; struct LNode { int data; struct LNode *next; }; void creathead(LNode *&L,int a[],int n)///尾插...
java创建三叉链表_Java【集合系列】3. LinkedList源码解析和使用示例
weixin_32286189的博客
01-14 157
前面，我们已经学习了ArrayList，并了解了fail-fast机制。这一章我们接着学习List的实现类——LinkedList。和学习ArrayList一样，接下来呢，我们先对LinkedList有个整体认识，然后再学习它的源码；最后再通过实例来学会使用LinkedList。内容包括：目录第1部分 LinkedList介绍第2部分 LinkedList数据结构第3部分 LinkedL...
Java数据结构篇之链表
MasterJundarj的博客
09-23 1378
/头插法//尾插法//任意位置插入,第一个数据节点为0号下标//查找是否包含关键字key是否在单链表当中//删除第一次出现关键字为key的节点//删除所有值为key的节点//得到单链表的长度int size();@Override@Override【解释】
三个单链表交集（O（m+n+p））
Ben的专栏
01-22 2903
题目： 已知三个带头结点的线性链表A、B和C中的结点均依元素值自小至大非递减排列（可能存在两个以上值相同的结点）。 编写算法对A表进行如下操作： 使操作后的链表A中仅留下三个表中均包含的数据元素的结点，且没有值相同的结点，并释放所有无用结点。限定算法的时间复杂度为O（m+n+p），其中m、n和p分别为三个表的长度。 看代码：由于我将方法都封装到了类里面，所以第一个链表的头结点就在类
java数据结构与算法.pdf
01-04
包含了各种数据结构和算法（java）的实现方式和详解（图解），包括单双链表、环形链表（约瑟夫问题）、栈、后缀表达式、中缀表达式转后缀表达式、迷宫问题、八大排序算法、多种查找算法、哈希表、二叉树实现以及操作...
Java数据结构和算法学习.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
java数据结构和算法实现.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
java数据结构和算法总结.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
java用三叉链表构建二叉树_三叉链表实现二叉树的基本操作
weixin_42244017的博客
02-27 1140
三叉链表存储表示改进于二叉链表，增加指向父节点的指针，能更好地实现结点间的访问。存储结构/* 二叉树的三叉链表存储表示 */typedef struct BiTPNode{TElemType data;struct BiTPNode *parent,*lchild,*rchild; /* 双亲、左右孩子指针 */}BiTPNode,*BiPTree;下面给出二叉树采用三叉链表，实现了二叉树的构造、...
java用三叉链表构造二叉树_Java基础 - 二叉树的三叉链表存储
weixin_39889487的博客
02-26 367
package com.yc.tree;/*** @author WB* @param ** 三叉链表存储的思想是让每个节点不仅“记住”它的左、右两个子节点，还要“记住”它的父节点，因此需要为每个节点增加left、right和parent* 三个指针，分别引用该节点的左、右两个子节点和父节点。因此，三叉链表的每个节点有如下图所示的结构。* ↑parent* _│_______________...
超爽的抽屉效果.zip
04-19
android 源码学习. 资料部分来源于合法的互联网渠道收集和整理，供大家学习参考与交流。本人不对所涉及的版权问题或内容负法律责任。如有侵权，请通知本人删除。感谢CSDN官方提供大家交流的平台
关于学习C语言时写的代码.zip
04-19
C语言诞生于美国的贝尔实验室，由丹尼斯·里奇（Dennis MacAlistair Ritchie）以肯尼斯·蓝·汤普森（Kenneth Lane Thompson）设计的B语言为基础发展而来，在它的主体设计完成后，汤普森和里奇用它完全重写了UNIX，且随着UNIX的发展，c语言也得到了不断的完善。为了利于C语言的全面推广，许多专家学者和硬件厂商联合组成了C语言标准委员会，并在之后的1989年，诞生了第一个完备的C标准，简称“C89”，也就是“ANSI C”，截至2020年，最新的C语言标准为2018年6月发布的“C18”。 [5] C语言之所以命名为C，是因为C语言源自Ken Thompson发明的B语言，而B语言则源自BCPL语言。 1967年，剑桥大学的Martin Richards对CPL语言进行了简化，于是产生了BCPL（Basic Combined Programming Language）语言。
机械臂论文.doc
最新发布
04-19
机械臂论文.doc
S7200 and WINCC flexible.doc
04-19
S7200 and WINCC flexible.doc
27.大学生体质测试管理系统的设计与实现-Springboot+ Mysql+Java+ B/S结构(可运行源码+数据库+设计文
04-19
27.大学生体质测试管理系统的设计与实现|Springboot+ Mysql+Java+ B/S结构(可运行源码（含数据库脚本）+开发文档+lw（高分毕设项目） 详细设计文档介绍链接：http://t.csdnimg.cn/jtyYh 内容概要： 系统主要分为系统管理员、教师和用户三个部分，系统管理员主要功能包括首页、个人中心、用户管理、教师管理、体质测试管理、测试报告管理、测试成绩管理、留言板、系统管理；基本上实现了整个大学生体质测试管理系统信息管理的过程。 全套项目源码+详尽文档，一站式解决您的学习与项目需求。 适用人群： 计算机、通信、人工智能、自动化等专业的学生、老师及从业者。 使用场景及目标： 无论是毕设、期末大作业还是课程设计，一键下载，轻松部署，助您轻松完成项目。 项目代码经过调试测试，确保直接运行，节省您的时间和精力。 其他说明： 项目整体具有较高的学习借鉴价值，基础能力强的可以在此基础上修改调整，以实现不同的功能。
c语言-c语言编程基础之leetcode题解第24题两两交换链表中的节点.zip
04-19
c语言 c语言_c语言编程基础之leetcode题解第24题两两交换链表中的节点
java数据结构和算法 pdf
01-14
《Java数据结构和算法》（Java Data Structures and Algorithms）是一本介绍Java编程语言中常用的数据结构和算法的书籍。该书按照数据结构和算法的相关性进行组织，方便读者理解和学习。 该书介绍了Java中常用的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值