Java数据结构系列之单向链表

这篇博客介绍了如何使用Java实现单向链表,包括创建Node节点类,定义有序链表类LinkedList,实现链表的添加、修改、删除、遍历、查找倒数第K个元素、反转和反向打印等操作。示例代码详细展示了每个方法的实现过程。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Java数据结构系列之单向链表

/**
 * @description Node结点类
 * @author HAHACHEN
 * @date 2020/9/24
 */
class Node {
    
    protected Integer orderNo;

    protected String data;

    protected Node next;

    public Node(Integer orderNo, String data, Node next) {
        this.orderNo = orderNo;
        this.data = data;
        this.next = next;
    }

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

    public Node () {
    }

    @Override
    public String toString() {
        return "Node{" +
                "orderNo=" + orderNo +
                ", data='" + data + '\'' +
                '}';
    }
}
/**
 * @description 有序链表
 * @author HAHACHEN
 * @date 2020/9/24
 */
class LinkedList {

    /**
     * 链表头结点
     */
    private Node head = new Node(0, null, null);


    /**
     * @description 直接追加到尾部
     * @author HAHACHEN
     * @date 2020/9/22
     * @param newNode
     * @return void
     */
    public void addData(Node newNode) {
        Node temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        temp.next = newNode;
    }


    /**
     * @description 根据编号插入
     * @author HAHACHEN
     * @date 2020/9/22
     * @param newNode
     * @return void
     */
    public void addDataByOrder(Node newNode) {
        Node temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (newNode.orderNo < temp.next.orderNo) {
                break;
            }
            temp = temp.next;
        }

        newNode.next = temp.next;
        temp.next = newNode;
    }


    /**
     * @description 修改链表
     * @author HAHACHEN
     * @date 2020/9/23
     * @param node
     * @return void
     */
    public void updateData(Node node) {
        if (head.next == null) {
            return;
        }
        Node temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.orderNo.equals(node.orderNo)) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next.data = node.data;
        }
    }


    /**
     * @description 删除链表
     * @author HAHACHEN
     * @date 2020/9/23
     * @param node
     * @return void
     */
    public void deleteData(Node node) {
        if (head.next == null) {
            return;
        }
        Node temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.orderNo.equals(node.orderNo)) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.println("delete finished");
        }
    }


    /**
     * @description 遍历
     * @author HAHACHEN
     * @date 2020/9/22
     * @param
     * @return void
     */
    public void showLinkedList() {
        if (head.next == null) {
            System.out.println("end >>>>>>>>>>>>>>>>>>>>");
        }

        Node temp = head;
        while (true) {
            System.out.println(temp);
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        System.out.println("end >>>>>>>>>>>>>>>>>>>>");
    }


    /**
     * @description 链表中有效个数
     * @author HAHACHEN
     * @date 2020/9/23
     * @param
     * @return java.lang.Long
     */
    public Long dataSize() {
        Node temp = head;
        long count = 0;
        while (temp.next != null) {
            count++;
            temp = temp.next;
        }
        return count;
    }


    /**
     * @description 返回倒数第K个元素
     * @author HAHACHEN
     * @date 2020/9/23
     * @param index
     * @return com.lytech.test.linkedlist.Node
     */
    public Node indexCountBackwards(long index) {
        if (head.next == null) {
            return null;
        }

        Long dataSize = dataSize();
        if (index > dataSize || index < 0) {
            return null;
        }

        Node temp = head.next;
        for (int i = 0; i < dataSize; i++) {
            if (i == (dataSize - index)) {
                return temp;
            }
            temp = temp.next;
        }
        return null;
    }


    /**
     * @description 反转单链表生成一个新的链表
     * @author HAHACHEN
     * @date 2020/9/23
     * @param
     * @return com.lytech.test.linkedlist.LinkedList
     */
    public LinkedList reverse() {
        if (head.next == null) {
            return new LinkedList();
        }
        LinkedList linkedList = new LinkedList();
        Node newHead = linkedList.head;
        Node temp = head.next;
        while (temp != null) {
            Node newNode = new Node(temp.orderNo, temp.data);
            newNode.next = newHead.next;
            newHead.next = newNode;
            temp = temp.next;
        }
        return linkedList;
    }


    /**
     * @description 反转单链表
     * @author HAHACHEN
     * @date 2020/9/24
     * @param oldNode
     * @return void
     */
    public void reverse(Node oldNode) {
        if (oldNode.next == null || oldNode.next.next == null) {
            return;
        }
        Node current = head.next;
        Node next;
        Node newNode = new Node(0, "");
        while (current != null) {
            next = current.next;
            current.next = newNode.next;
            newNode.next = current;
            current = next;
        }
        head.next = newNode.next;
    }


    /**
     * @description 反向打印
     * @author HAHACHEN
     * @date 2020/9/24
     * @param
     * @return void
     */
    public void reversePrinting() {
        Stack<Node> nodes = new Stack<>();
        Node node = head.next;
        while (node != null) {
            nodes.push(node);
            node = node.next;
        }

        while (!nodes.empty()) {
            System.out.println(nodes.pop());
        }
    }

    /**
     * @description 获取头结点
     * @author HAHACHEN
     * @date 2020/9/24
     * @param
     * @return com.lytech.test.linkedlist.Node
     */
    public Node getHead() {
        return head;
    }
}
import java.util.Stack;

/**
 * @author HAHACHEN
 * @description 链表测试Demo
 * @date 2020/9/22
 */
public class LinkedListDemo {
    public static void main(String[] args) {
        // 定义结点
        Node node1 = new Node(1, "This");
        Node node2 = new Node(2, "is");
        Node node3 = new Node(3, "a");
        Node node4 = new Node(4, "test");
        Node node5 = new Node(5, "demo");

        // 加入链表(直接插入链表尾部)
        LinkedList linkedList = new LinkedList();
        linkedList.addData(node1);
        linkedList.addData(node2);
        linkedList.addData(node3);
        linkedList.addData(node4);
        linkedList.addData(node5);
        linkedList.showLinkedList();

        Node node = new Node(3, "another");
        // 修改链表结点
        linkedList.updateData(node);
        linkedList.showLinkedList();

        // 删除链表结点
        linkedList.deleteData(node);
        linkedList.showLinkedList();

        // 加入链表(有序插入)
        LinkedList orderedLinkedList = new LinkedList();
        orderedLinkedList.addDataByOrder(node1);
        orderedLinkedList.addDataByOrder(node4);
        orderedLinkedList.addDataByOrder(node3);
        orderedLinkedList.addDataByOrder(node5);
        orderedLinkedList.addDataByOrder(node2);
        orderedLinkedList.showLinkedList();

        LinkedList oldLinkedList = new LinkedList();
        Node nodeA = new Node(1, "AAA", null);
        Node nodeB = new Node(2, "BBB", null);
        Node nodeC = new Node(3, "CCC", null);
        Node nodeD = new Node(4, "DDD", null);
        Node nodeE = new Node(5, "EEE", null);
        oldLinkedList.addData(nodeA);
        oldLinkedList.addData(nodeB);
        oldLinkedList.addData(nodeC);
        oldLinkedList.addData(nodeD);
        oldLinkedList.addData(nodeE);
        oldLinkedList.showLinkedList();
        System.out.println("------------------------------");

        // 链表反转
        oldLinkedList.reverse(oldLinkedList.getHead());
        oldLinkedList.showLinkedList();

        // 链表反向打印
        oldLinkedList.reversePrinting();
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值