数据结构之双向链表（头插法建立）

package com.ws.链表.双向链表.插入到指定位置;

public class DoubleLinkeListTest {
    public static void main(String[] args) {
        //测试
        System.out.println("双向链表的测试");
        //创建节点
        Node node1=new Node(1,"王","小王");
        Node node2=new Node(4,"马","小马");
        Node node3=new Node(3,"刘","小刘");
        Node node4=new Node(2,"琳","小琳");

        //创建双向链表对象
        DoubleLinkeList doubleLinkeList=new DoubleLinkeList();

        //添加节点
        doubleLinkeList.addNode(node1);
        doubleLinkeList.addNode(node2);
        doubleLinkeList.addNode(node3);
        doubleLinkeList.addNode(node4);

        //显示链表
        System.out.println("---------------------------------");
        System.out.println("显示链表");
        doubleLinkeList.list();
        
    }
}


//创建一个双向链表的类，每个对象就是一个节点
class Node{
    public int paixu;
    public String name;
    public String nixkname;
    public Node next;//指向下一个节点  默认null
    public Node qian;//指向前一个节点   默认null

    //构造器
    public Node(int paixu,String name,String nixkname){
        this.paixu=paixu;
        this.name=name;
        this.nixkname=nixkname;
    }

    //显示方法

    @Override
    public String toString() {
        return "Node{" +
                "paixu=" + paixu +
                ", name='" + name + '\'' +
                ", nixkname='" + nixkname + '\'' +
                '}';
    }
}

//创建管理链表的类
class DoubleLinkeList{
    //初始化一个头结点，头结点不动，不存放具体数据
    private Node head=new Node(0,"","");

    //返回头结点
    public Node getHead(){
        return head;
    }

    //遍历双向链表
    public void list(){
        //判断链表是否为空
        if (head.next==null){
            System.out.println("链表为空");
            return;
        }

        //因为头结点不能动，所以需要一个副本
        //遍历指向第一个数据节点
        Node listnode=head.next;
        while (true){
            //判断是否到最后
            if (listnode==null){
                break;
            }
            //输出节点信息
            System.out.println(listnode);
            //后移，循环
            listnode=listnode.next;
        }
    }

    //添加节点（默认添加到尾）
    public void add(Node node){
        //头节点不能动，需要副本
        Node listnode=head;
        //遍历链表，找到最后
        while (true){
            //找到最后
            if (listnode.next==null){
                break;
            }
            //后移
            listnode=listnode.next;
        }
        //已经找到最后
        //当前节点下一个（next）指向新节点
        //新节点前一个(qian)指向当前节点
        listnode.next=node;
        node.qian=listnode;
    }

    //插入到指定位置
    public void addNode(Node node) {
        //因为头节点不能动，所以要有一个副本找节点
        //找的listNode是当前节点的下一个节点
        Node listNode = head;
        boolean flag = false;//标志,添加的编号是否已经存在，默认false   就是新节点编号是否已经存在
        while (true) {
            if (listNode.next == null) {
                //说明listNode已经在链表最后
                break;
            }
            //由小到大排序，后一个比前一个大就插入后一个的前面
            if (listNode.next.paixu > node.paixu) {//位置找到
                break;
            } else if (listNode.next.paixu == node.paixu) {
                //说明希望添加的序号已经存在
                flag = true;//编号已经存在
                break;
            }
            listNode = listNode.next;//后移，遍历链表
        }
        //判断编号是否已经存在
        if (flag) {//存在
            System.out.printf("添加编号【%d】已经存在，不能加入\n", listNode.next.paixu);
        } else {
            if (listNode.next!=null){//到尾，则不用连接后一个节点
                node.next=listNode.next;//新节点指向当前节点下一个节点
                listNode.next.qian=node;//当前节点的下一个节点指向新节点
            }
            listNode.next=node;//当前节点指向新节点
            node.qian=listNode;//新节点指向当前节点

        }
    }

    //修改一个节点的内容
    public void update(Node node){
        //判断为空
        if (head.next==null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，按照paixu找
        //头结点不能动，要一个副本
        //第一个数据节点
        Node listnode=head.next;
        boolean flag=false;//是否找到节点  默认flase
        while (true){
            //是否遍历完链表
            if (listnode==null){
                break;//遍历完链表
            }
            //找到
            if (listnode.paixu==node.paixu){
                flag=true;
                break;
            }
            listnode=listnode.next;//循环
        }
        if (flag){//找到节点
            listnode.name=node.name;
            listnode.nixkname=node.nixkname;
        }else {//没找到
            System.out.printf("没有找到编号【%d】的节点,不能修改\n",node.paixu);
        }
    }

    //删除节点
    //可直接找到要删除的节点
    public void delete(int paixu){
        //判断当前链表是否为空
        if (head.next==null){
            System.out.println("链表为空，不能删除");
            return;
        }

        //辅助变量
        //第一个数据节点
        Node listnode=head.next;
        boolean flag=false;//标志是否找到节点  默认false
        while (true){
            //是否到最后
            if (listnode==null){
                break;
            }
            if (listnode.paixu==paixu){
                //找到要删除的节点
                flag=true;
                break;
            }
            listnode=listnode.next;
        }
        //找到要删除的节点
        if (flag){
            //删除节点
            listnode.qian.next=listnode.next;//当前节点的前一个节点的后一个节点指向当前节点的下一个节点
            if (listnode.next!=null){//当前节点不是最后一个节点，如果要是最后一个节点，他的后一个的前一个就变成了空的前一个，有错误
                listnode.next.qian=listnode.qian;//当前节点的后一个的前一个指向当前节点的前一个
            }
        }else {
            System.out.printf("要删除的【%d】节点不存在\n",paixu);
        }
    }
}