Java--不带头节点的单链表、循环单链表

博客内容提及不带头节点的单链表和不带头节点的循环单链表,聚焦于这两种链表类型,属于信息技术领域的数据结构相关内容。

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

①不带头节点的单链表

public class Link<T> {
    private class Entry<E>{
        private E value;
        private Entry<E> next;
        public Entry(E value){
            this.value = value;
        }
    }

    private Entry<T> headEntry;
    private Entry<T> tailEntry;
    public Link(){
    }
    //头插
    public void addHead(T value){
        Entry<T> newEntry = new Entry<>(value);
        if(headEntry == null){
            headEntry = newEntry;
            tailEntry = newEntry;
        }else{
            newEntry.next = headEntry;
            headEntry = newEntry;//新头
        }
    }
    //尾插
    public void addTail(T value){
        Entry<T> newEntry = new Entry<>(value);
        if(headEntry == null){
            headEntry = newEntry;
            tailEntry = newEntry;
        }else{
            tailEntry.next = newEntry; 
            tailEntry = newEntry;//更新新尾
        }
    }
    //头删
    public void deleteHead(){
        if(headEntry == null){
            headEntry = null;
            tailEntry = null;
        }
        Entry<T> p = headEntry;
        headEntry = headEntry.next;
        p.value = null;
        p.next = null;
    }
    //尾删
    public void deleteTail() {
        Entry<T> pre = searchPre();
        if (pre == null) {
            return;
        }
        if (headEntry.next == null) {
            headEntry.value = null;
            headEntry = null;
            tailEntry = null;
        } else {
            pre.next = null;
            tailEntry.value = null;
            tailEntry = pre;
        }
    }
    //用来寻找尾巴前驱
     private Entry<T> searchPre(){
        for(Entry<T> p = headEntry;p!=null;p=p.next){
            if(p.next == tailEntry){
                return p;
            }
        }
        return null;
    }
    public void show() {
        for(Entry<T> p = headEntry;p!=null;p=p.next){
            System.out.print(p.value +" ");
        }
        System.out.println();
    }
    //测试
    public static void main(String[] args) {
        Link<Integer> link=new Link<>();
        link.addHead(1);
        link.addHead(2);
        link.addHead(3);
        link.addTail(4);
        link.addTail(5);
        link.deleteHead();
        link.deleteTail();
        link.show();
    }
}

在这里插入图片描述
②不带头节点的循环单链表

public class SingleList<T> {
    private static class Entry<E>{
        private Entry<E> next;
        private E value;
        public Entry(E value){
            this.value = value;
            next = this; //循环
        }
    }
    private Entry<T> headEntry;
    private Entry<T> tailEntry;
    public SingleList(){
    }
    public void addHead(T value){
        Entry<T> newEntry = new Entry<>(value);
        if(headEntry == null){
            headEntry = newEntry;
            tailEntry = newEntry;
        }else{
            //插入的这个元素后一个即原来的头
            newEntry.next = headEntry;
            //更新头
            headEntry = newEntry;
            //尾部下一个指向现在的头
            tailEntry.next = headEntry;
        }
    }
    public void addTail(T value){
        Entry<T> newEntry = new Entry<>(value);
        if(headEntry == null){
            headEntry = newEntry;
            tailEntry = newEntry;
        }else {
            tailEntry.next = newEntry;
            newEntry.next = headEntry;
            tailEntry = newEntry;
        }
    }
    public void deleteHead(){
        if(headEntry == null) //空链表
            return;
        headEntry.value = null;
        if(headEntry.next == headEntry){  //只有一个节点
            headEntry = null;
            tailEntry = null;
        }else {
            tailEntry.next = headEntry.next;
            headEntry = headEntry.next; //更新头
        }
    }
    private Entry<T> searchPre(){
        Entry<T> p = headEntry;
        do{
            if(p.next == tailEntry){
                return p;
            }
            p=p.next;
        }while(p!=headEntry); //此处使用do while比较简单,for循环条件出错容易陷入死循环

        return null;
    }
    public void deleteTail(){
        if(headEntry == null){
            return;
        }
        if(headEntry.next == headEntry){
            headEntry = null;
            tailEntry = null;
        }else {
            Entry<T> pre = searchPre();
            pre.next = tailEntry.next;
            tailEntry.value = null;
            tailEntry = pre;//更新尾
        }
    }

    public void show(){
        if(headEntry == null){
            return;
        }
        Entry<T> p = headEntry;
        do{
            System.out.print(p.value+" ");
            p=p.next;
        }while(p!=headEntry);
    }
    public static void main(String[] args) {
            SingleList<Integer> singleList = new SingleList<>();
            singleList.addHead(1);
            singleList.addHead(2);
            singleList.addHead(3);
            singleList.addTail(4);
            singleList.addTail(5);
            singleList.deleteHead();
            singleList.deleteTail();
            singleList.show();
        }
}
<think>好的,我现在需要详细解释带头结点单链表结构。首先,得明确单链表的基本概念,然后区分带头结点带头结点的区别。 单链表是由节点构成的线性结构,每个节点包含数据域和指向下一个节点的指针。带头结点意味着链表的第一个节点就是数据节点,没有额外的头结点。这样,插入和删除操作在链表头部时处理方式会同,因为需要直接修改头指针的指向。 接下来,要思考带头结点单链表的特点。比如,头指针直接指向第一个节点,空链表时头指针为null。插入第一个节点时需要改变头指针,而带头结点的话头指针始终指向一个存数据的节点,操作可能更统一。 然后考虑基本操作,如创建、插入、删除、遍历等。每个操作在带头结点的情况下如何实现。例如,插入到头部时,新节点的next指向原头节点,然后头指针指向新节点。而如果链表为空,直接让头指针指向新节点。删除操作同样需要注意处理头节点的情况。 可能还需要比较带头结点的情况,说明两者的优缺点。比如,带头结点的链表在操作头部时需要特殊处理,而带头结点可以统一操作,但增加了一个额外节点。 最后,用Java代码实现带头结点单链表,展示结构定义和基本操作,比如插入、删除、遍历等。需要注意处理空链表的情况,比如在插入第一个节点时头指针的变化,或者在删除时链表变为空的情况。 在代码示例中,定义节点类,包含数据和next指针。然后创建链表类,包含头指针。实现方法如insertAtHead、insertAtTail、delete等。每个方法需要处理头指针是否为null的情况,确保逻辑正确。 可能出现的问题包括头指针未正确更新,导致节点丢失或循环引用。例如,在头部插入时,如果先让新节点指向头指针,再更新头指针,顺序正确,否则会导致问题。 总结时,强调带头结点链表的特点和操作时的注意事项,以及代码实现中的关键点。之后,根据这些内容提出相关问题,涉及结构、操作、优缺点等。</think><< 带头结点单链表是一种链式存储结构,其特点是链表的第一个节点直接存储数据,没有额外附加的“头结点”。以下是其核心实现和特点: ### 1. **结构定义** 每个节点包含两个部分: - **数据域**:存储具体数据。 - **指针域**:指向下一个节点的引用(或地址)。 ```java class ListNode { int val; ListNode next; ListNode(int val) { this.val = val; this.next = null; } } ``` ### 2. **关键特点** - **头指针直接指向第一个节点**:如果链表为空,头指针为`null`。 - **插入/删除头部需特殊处理**:因为需要直接修改头指针的指向。 - **空链表判断简单**:头指针为`null`即表示链表为空。 ### 3. **基本操作示例** #### (1) **头部插入节点** ```java public class LinkedList { private ListNode head; // 头指针直接指向第一个节点 // 头部插入 public void insertAtHead(int val) { ListNode newNode = new ListNode(val); newNode.next = head; // 新节点指向原头节点 head = newNode; // 头指针更新为新节点 } } ``` #### (2) **尾部插入节点** ```java public void insertAtTail(int val) { ListNode newNode = new ListNode(val); if (head == null) { head = newNode; // 空链表时直接赋值 return; } ListNode current = head; while (current.next != null) { current = current.next; } current.next = newNode; } ``` #### (3) **删除节点** ```java public void delete(int val) { if (head == null) return; if (head.val == val) { head = head.next; // 直接跳过被删除节点 return; } ListNode prev = head; while (prev.next != null && prev.next.val != val) { prev = prev.next; } if (prev.next != null) { prev.next = prev.next.next; } } ``` ### 4. **与带头结点的区别** | 特性 | 带头结点 | 带头结点 | |--------------------|----------------------------|----------------------------| | 头指针初始值 | `null` | 指向一个空节点 | | 插入首节点逻辑 | 需修改头指针 | 统一通过头结点的`next`操作 | | 空链表判断 | `head == null` | `head.next == null` | ### 5. **典型问题** - **头部操作需特判**:例如删除第一个节点时,必须直接修改`head`。 - **遍历需判空**:例如遍历链表时需先检查`head != null`。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值