数据结构—双向链表

小结：

相比单向链表，每个节点多了一个 pre 属性，指向前一个节点，

 节点类：

class node{
    node pre;
    int data;
    String data1;
    node next;

    public  node(int data, String data1) {
        this.data = data;
        this.data1 = data1;
    }

    @Override
    public String toString() {
        return "node{" +
                "data=" + data +
                ", data1='" + data1 + '\'' +
                '}';
    }
}

双向链表类：

// 双向链表类
class doubleLinkedList{
    // 初始化头节点
    node head = new node(0,"");

    // add 方法
    public void add(node node) {
        // 辅助指针 & 布尔标记
        node assist = head;
        boolean f = false;

        while (true) {
            // 指针移动到最尾
            if (assist.next == null) {
                break;
            }
            // 找到了 add 的位置，即 assist.next
            if (assist.next.data > node.data) {
                break;
            } else if (assist.next.data == node.data) { // 重复，不可继续添加
                f = true;
                break;
            }
            // 指针后移一位
            assist = assist.next;
        }

        if (f) {
            System.out.printf("已经有同样编号 %d 的元素\n", node.data);
        } else {
            if (assist.next != null) { // node 添加在 assist 之后
                assist.next.pre = node; // assist的下一个节点的 pre 指向 新节点
                node.next = assist.next; // 新节点的 next 指向 assist的下一个节点
            }
            assist.next = node;// assist的 next 指向 新节点
            node.pre = assist;// 新节点的 pre 指向 assist
        }

    }

    // upData
    public void upData(node upNode) {
        // 判断是否为空链表
        if (head.next == null) {
            System.out.println("空链表");
            return;
        }

        // 辅助指针 & 布尔标记
        node assist = head;
        boolean f = false;

        while (true) {
            // 遍历完毕，退出循环
            if (assist.next == null) {
                break;
            }
            // 找到了需要修改的元素，修改布尔标记，退出循环
            if (assist.next.data == upNode.data) {
                f = true;
                break;
            }
            // 指针后移一位
            assist = assist.next;
        }

        if (f) { // 修改
            assist.next.data = upNode.data;
            assist.next.data1 = upNode.data1;
        } else {
            System.out.printf("找不编号为：%d 的节点进行修改", upNode.data);
        }
    }

    // delete
    public void delete(int num) {
        // 判断是否为空链表
        if (head.next == null) {
            System.out.println("空链表");
            return;
        }

        // 辅助指针 & 布尔标记
        node assist = head;
        boolean f = false;

        while (true) {
            // 遍历完毕，退出循环
            if (assist.next == null) {
                break;
            }
            // 找到了需要删除的节点，即 assist.next
            if (assist.next.data == num) {
                f = true;
                break;
            }
            // 指针后移一位
            assist = assist.next;
        }

        if (f) {
            if (assist.next.next != null) {
                assist.next.next.pre = assist;
                assist.next = assist.next.next;
                return;
            }
            assist.next = null;
        } else {
            System.out.printf("待删除的：%d 号节点不存在\n", num);
        }

    }

    // show方法
    public void show() {
        // 判断是否为空链表
        if (head.next == null) {
            System.out.println("空链表");
            return;
        }

        // 辅助指针
        node assist = head.next;
        System.out.println("遍历得到：");
        while (true) {
            System.out.println(assist);
            // 判断是否遍历完毕
            if (assist.next == null) {
                break;
            }
            // 指针后移一位
            assist = assist.next;
        }
    }

}

测试：

public class doubleLinkedListDome {
    public static void main(String[] args) {
        doubleLinkedList doubleLinkedList = new doubleLinkedList();

        node one = new node(1,"一");
        node two = new node(2,"二");
        node three = new node(3,"三");
        node four = new node(4,"四");
        node fakeOne = new node(1,"假一");

        // add
        doubleLinkedList.add(fakeOne);
        doubleLinkedList.add(four);
        doubleLinkedList.add(three);
        doubleLinkedList.add(two);
        doubleLinkedList.show();

        // upData
        doubleLinkedList.upData(one);
        doubleLinkedList.show();

        // delete
        doubleLinkedList.delete(1);
        doubleLinkedList.delete(4);
        doubleLinkedList.delete(2);
        doubleLinkedList.show();




    }
}

结构如下：

遍历得到：
node{data=1, data1='假一'}
node{data=2, data1='二'}
node{data=3, data1='三'}
node{data=4, data1='四'}
遍历得到：
node{data=1, data1='一'}
node{data=2, data1='二'}
node{data=3, data1='三'}
node{data=4, data1='四'}
遍历得到：
node{data=3, data1='三'}

进程已结束,退出代码0