数据结构第三天--双向链表的增删改查

双向链表的增删操作思路如上所示，其中有序增加少写了一种情况，当然具体情况和你定义的临时节点有关系，我这里以我的情况说明：

首先我定义的临时节点是这样的StuNode temp = head;

1）链表为空，则插入的节点需要与头节点相连

即temp.next = newNode,newNode.pre = temp

2)链表不为空，插入节点的位置在最后一个节点，则进行的操作为

temp.next.next = newNode,newNode.pre = temp.next

3)链表不为空，插入位置在中间，则插入节点的前趋指向temp,temp的后继指向插入节点，

temp的下一个节点的前驱指向插入节点，插入节点的后继指向temp的后一个节点

即newNode.pre = temp.next

StuNode curnext = temp.next.next

temp.next.next = newNode

newNode.next = curnext

curnext.pre = newNode

完整代码如下

/**
 * 双向链表的实现
 * @author blackCat
 * @create 2022-07-29 18:35
 */
public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        StuNode node1 = new StuNode(1,"张三");
        StuNode node2 = new StuNode(2,"李四");
        StuNode node3 = new StuNode(3,"王五");
        StuNode node4 = new StuNode(4,"赵六");
        DoubleLinkedList list = new DoubleLinkedList();
        list.addByOrder(node1);
        list.addByOrder(node4);
        list.addByOrder(node3);
        list.addByOrder(node2);
        list.showList();
//        list.del(3);
//        System.out.println("被删除后的链表情况");
//        list.showList();
//        list.del(4);
//        System.out.println("被删除后的链表情况");
//        list.showList();
//        StuNode node5 = new StuNode(3,"张无忌");
//        StuNode node6 = new StuNode(4,"周芷若");
//        StuNode node7 = new StuNode(5,"谢逊");
//        list.update(node5);
//        System.out.println("修改后的链表情况~~");
//        list.showList();
//        list.update(node6);
//        System.out.println("修改后的链表情况~~");
//        list.showList();
//        list.update(node7);
//        System.out.println("修改后的链表情况~~");
//        list.showList();
    }
}


class DoubleLinkedList{
    //初始化头节点，只起到指向作用
    private StuNode head = new StuNode(0,"");

    public StuNode getHead() {
        return head;
    }

    //按id顺序添加节点
    public void addByOrder(StuNode newNode){
        StuNode temp = head;
        boolean flag = false;
        while (true){
            if (temp.next == null){
                break;
            }
            if (temp.next.id<newNode.id){
                break;
            }
            temp = temp.next;
        }
        if (temp.next==null){
            //即链表为空
            newNode.pre = temp;
            temp.next = newNode;
        }else if (temp.next.next == null){
            //链表有元素，但是插入的节点在末尾插入
            temp.next.next = newNode;
            newNode.pre = temp.next;
        }else {
            //节点插入的位置在中间
            newNode.pre = temp.next;
            StuNode curnext = temp.next.next;
            temp.next.next = newNode;
            newNode.next = curnext;
            curnext.pre = newNode;
        }
    }
    //修改数据
    public void update(StuNode stuNode){
        StuNode temp = head.next;
        if (temp == null){
            System.out.println("链表为空");
            return;
        }
        boolean flag = false;
        while (true){
            if (temp==null){
                break;
            }
            if (temp.id == stuNode.id){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            //找到了则进行修改信息
            temp.name = stuNode.name;
        }else {
            System.out.println("没有找到该节点");
        }
    }
    //删除数据
    public void del(int uid){
        boolean flag = false;
        StuNode temp = head.next;
        while (true){
            if (temp == null){
                System.out.println("链表为空");
                break;
            }
            if (temp.id==uid){
                //找到了
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.pre.next = temp.next;
            if (temp.next!=null){
                temp.next.pre = temp.pre;//①
            }
            //若被删除的节点为最后一个节点则无需执行①中的操作，否则会出现空指针
        }
    }

    //添加数据
    public void add(StuNode newNode){//不考虑顺序
        //定义一个临时节点，用于寻找最后节点的位置
        StuNode temp = head;
        while (true){
            if (temp.next==null){
                break;
            }
            temp = temp.next;
        }
        //找到最后一个节点
        temp.next = newNode;
        newNode.pre = temp;

    }
    //遍历链表
    public void showList(){
        //定义一个临时变量
        StuNode temp = head.next;
        while (true){
            if (temp==null){
                //走到链表的尾部
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }
}
//学生节点
class StuNode{
    public int id;//学号
    public String name;//姓名
    public StuNode next;//后继，指向下一个节点
    public StuNode pre;//前驱,指向前一个节点

    public StuNode() {
    }

    public StuNode(int id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "StuNode{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}