概述

链表是有序列表
以节点方式链式存储, 也就是节点之间不一定是连续的地址
每个节点包含数据域和指向下一个节点的地址/引用
链表分带头节点的链表和不带头节点的链表

单链表(Single Linked List)


/** 定义链表节点类*/
class DataNode {
    /** 节点编号*/
    public int no;
    /** 节点标题*/
    public String title;
    /** 指向下一个节点, 如果是 null, 则当前节点为尾节点*/
    public DataNode next;

    public DataNode() {}

    public DataNode(int no, String title) {
        this.no = no;
        this.title = title;
    }

    @Override
    public String toString() {
        return "DataNode [no=" + no + ", title=" + title + "]";
    }
}

/** 定义单链表类*/
class SingleLinkedList {
    /** 初始化头节点, 此节点不设定数据*/
    private DataNode head = new DataNode();

    public DataNode getHead() {
        return head;
    }

    /**
     * 添加新节点:
     * 给尾部节点的 next指向新的节点引用
     * */
    public void add(DataNode DataNode) {
        /** 为了从头节点开始往后遍历找出尾部节点*/
        DataNode temp = head;
        /** 遍历找出尾部节点*/
        while(true) {
            /** 当前节点为尾部节点便停止循环*/
            if(temp.next == null) {
                break;
            }
            /** 如果当前节点不为尾部节点, 则再往后移*/
            temp = temp.next;
        }
        /** 将新的节点引用加到, 当前(尾部)节点的 next变量中*/
        temp.next = DataNode;
    }

    /** 遍历所有节点*/
    public void print() {
        if(head.next == null) {
            System.out.println("链表为空!");
            return;
        }
        /** 头节点不能被覆盖, 所有先使用辅助变量转移第一个(有效)节点*/
        DataNode temp = head.next;
        while(true) {
            /** 到了链表尾部时停止遍历*/
            if(temp == null) {
                break;
            }
            /** 输出当前节点的信息*/
            System.out.println(temp);
            /** 往后移一个节点, 继续遍历*/
            temp = temp.next;
        }
    }
}

public class SingleLinkedListApp {
    public static void main(String[] args) {
        /** 创建链表实例*/
        SingleLinkedList list = new SingleLinkedList();
        /** 添加节点*/
        list.add(new DataNode(4, "节点4"));
        list.add(new DataNode(2, "节点2"));
        list.add(new DataNode(1, "节点1"));
        list.add(new DataNode(3, "节点3"));
        /** 输出所有节点*/
        list.print();
    }
}
输出:
> DataNode [no=4, title=节点4]
> DataNode [no=2, title=节点2]
> DataNode [no=1, title=节点1]
> DataNode [no=3, title=节点3]

排序添加(添加时根据编号排序)

思路:

首先锁定将要插入的下一个(next)位置

DataNode.next = temp.next; temp.next = DataNode;


    /** 排序添加(添加时根据编号排序)*/
    public void addByOrder(DataNode DataNode) {
        DataNode temp = head;
        /** 标志: 是否重复*/
        boolean bRepeat = false;
        while(true) {
            /** 到了链表尾部时停止遍历*/
            if(temp.next == null) {
                break;
            }
            /** 找到了, 排序位*/
            if(temp.next.no > DataNode.no) {
                break;
            } else if (temp.next.no == DataNode.no) {
                /** 编号重复*/
                bRepeat = true;
                break;
            }
            /** 往后移一个节点, 继续遍历*/
            temp = temp.next;
        }
        /** 判断编号是否重复*/
        if(bRepeat) {
            System.out.printf("重复节点 %d, 不能添加\n", DataNode.no);
        } else {
            /** 将新节点插入到下一个(next)位置, 再把之前的 next引用地址指向新节点的下一个(next)*/
            DataNode.next = temp.next;
            temp.next = DataNode;
        }
    }

        /** 创建链表实例*/
        SingleLinkedList list = new SingleLinkedList();
        list.addByOrder(new DataNode(4, "节点4"));
        list.addByOrder(new DataNode(2, "节点2"));
        list.addByOrder(new DataNode(1, "节点1"));
        list.addByOrder(new DataNode(3, "节点3"));
        /** 输出所有节点*/
        list.print();

输出:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]

链表修改

思路:

修改指定节点信息, 根据编号(no)锁定节点, 即编号不能改

temp.title = newDataNode.title;


    /** 链表修改(修改指定节点信息, 根据编号(no)锁定节点)*/
    public void update(DataNode newDataNode) {
        if(head.next == null) {
            System.out.println("链表为空!");
            return;
        }
        /** 头节点不能被覆盖, 所有先使用辅助变量转移第一个(有效)节点*/
        DataNode temp = head.next;
        /** 标记: 是否找到指定节点*/
        boolean flag = false;
        while(true) {
            /** 到了链表尾部时停止遍历*/
            if (temp == null) {
                break;
            }
            if(temp.no == newDataNode.no) {
                /** 找到节点*/
                flag = true;
                break;
            }
            /** 往后移一个节点, 继续遍历*/
            temp = temp.next;
        }
        if(flag) {
            /** 修改属性*/
            temp.title = newDataNode.title;
        } else {
            System.out.printf("没有找到 编号 %d 的节点\n", newDataNode.no);
        }
    }

        /** 创建链表实例*/
        SingleLinkedList list = new SingleLinkedList();
        list.addByOrder(new DataNode(4, "节点4"));
        list.addByOrder(new DataNode(2, "节点2"));
        list.addByOrder(new DataNode(1, "节点1"));
        list.addByOrder(new DataNode(3, "节点3"));
        System.out.println("原链表:");
        list.print();

        DataNode newStu = new DataNode(3,"节点03");
        list.update(newStu);

        System.out.println("修改后的链表:");
        list.print();

输出:
> 原链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
> 修改后的链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点03]
> DataNode [no=4, title=节点4]

链表删除

思路:

我们先锁定要删除的节点的前一个节点

将下下一个节点的引用覆盖到下一个节点(要删除的节点)的 next. temp.next = temp.next.next;


    /** 链表删除*/
    public void del(int no) {
        DataNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if(temp.next.no == no) {
                flag=true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
        }else {
            System.out.printf("要删除的编号 %d 节点不存在", no);
        }
    }

        /** 创建链表实例*/
        SingleLinkedList list = new SingleLinkedList();
        list.addByOrder(new DataNode(4, "节点4"));
        list.addByOrder(new DataNode(2, "节点2"));
        list.addByOrder(new DataNode(1, "节点1"));
        list.addByOrder(new DataNode(3, "节点3"));
        System.out.println("原链表:");
        list.print();

        list.del(2);
        System.out.println("删除后的链表:");
        list.print();

输出:
> 原链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
> 删除后的链表:
> DataNode [no=1, title=节点1]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]

链表长度(有效节点的个数, 不统计头节点)


    /** 链表长度(有效节点的个数)*/
    public int getLength() {
        /** 空链表*/
        if(head.next == null) {
            return 0;
        }
        int length = 0;
        DataNode temp = head.next;
        while(temp != null) {
            length++;
            /** 往后移一个节点, 继续遍历*/
            temp = temp.next;
        }
        return length;
    }

        /** 创建链表实例*/
        SingleLinkedList list = new SingleLinkedList();
        list.addByOrder(new DataNode(4, "节点4"));
        list.addByOrder(new DataNode(2, "节点2"));
        list.addByOrder(new DataNode(1, "节点1"));
        list.addByOrder(new DataNode(3, "节点3"));
        System.out.println("原链表:");
        list.print();

        System.out.println("有效节点个数: "+ list.getLength());

输出:
> 原链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
> 有效节点个数: 4

获取倒数第几的节点

思路:

首先获取有效节点总长度-指定倒数第几=N. 然后遍历到 N次后返回


    /** 获取倒数第几的节点*/
    public DataNode findLastIndexNode(int index) {
        if(head.next == null) {
            return null;
        }
        /** 获取有效节点个数*/
        int size = getLength();
        if(index <=0 || index > size) {
            return null;
        }

        DataNode temp = head.next;
        /**
         * 例: size = 4; index = 1
         * size - index = 3
         * */
        int leftSize = size - index;
        for(int i =0; i< leftSize; i++) {
            temp = temp.next;
        }
        return temp;
    }

        /** 创建链表实例*/
        SingleLinkedList list = new SingleLinkedList();
        list.addByOrder(new DataNode(4, "节点4"));
        list.addByOrder(new DataNode(2, "节点2"));
        list.addByOrder(new DataNode(1, "节点1"));
        list.addByOrder(new DataNode(3, "节点3"));
        System.out.println("原链表:");
        list.print();

        int lastNo = 2;
        DataNode DataNode = list.findLastIndexNode(lastNo);
        System.out.printf("倒数第 %d 个节点: ", lastNo);
        System.out.println(DataNode);

输出:
> 原链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
> 倒数第 2 个节点: DataNode [no=3, title=节点3]

单链表的反转(实际节点调换)

思路:

定义新链表 DataNode reverseHead = new DataNode();

遍历原链表, 每遍历一个节点, 将其取出, 并加到 reverseHead的最前端


    /** 单链表的反转*/
    public void reversetList() {
        /** 必须有1个以上的有效节点*/
        if(head.next == null || head.next.next == null) {
            return ;
        }

        DataNode cur = head.next;
        /** 指向当前节点的下一个节点*/
        DataNode next;
        /** 全新链表*/
        DataNode reverseHead = new DataNode();
        /** 遍历原链表, 每遍历一个节点, 将其取出, 并加到 reverseHead的最前端*/
        while(cur != null) {
            /** 暂时保存当前节点的下一个节点*/
            next = cur.next;
            /** 将 cur的下一个节点指向新的链表的最前端*/
            cur.next = reverseHead.next;
            /** 将 cur连接到新的链表上*/
            reverseHead.next = cur;
            /** 将 cur后移*/
            cur = next;
        }
        /** 将 head.next指向 reverseHead.next*/
        head.next = reverseHead.next;
    }

        /** 创建链表实例*/
        SingleLinkedList list = new SingleLinkedList();
        list.addByOrder(new DataNode(4, "节点4"));
        list.addByOrder(new DataNode(2, "节点2"));
        list.addByOrder(new DataNode(1, "节点1"));
        list.addByOrder(new DataNode(3, "节点3"));
        System.out.println("原链表:");
        list.print();

        System.out.println("反转链表:");
        list.reversetList();
        list.print();

输出:
> 原链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
> 反转链表:
> DataNode [no=4, title=节点4]
> DataNode [no=3, title=节点3]
> DataNode [no=2, title=节点2]
> DataNode [no=1, title=节点1]

单链表的反转(只是反转输出, 实际节点未反转)

思路:

通过栈数据结构, 利用栈的先进后出的特点, 实现逆序输出的效果


    /**
     * 单链表的反转(只是反转输出, 实际节点未反转):
     * 通过栈数据结构, 利用栈的先进后出的特点, 实现逆序输出的效果
     * */
    public void reversePrint() {
        if(head.next == null) {
            return;
        }
        /** 创建一个栈*/
        Stack<DataNode> stack = new Stack<>();
        DataNode cur = head.next;
        while(cur != null) {
            /** 将链表的所有节点压入栈*/
            stack.push(cur);
            /** 将 cur后移*/
            cur = cur.next;
        }
        /** 将栈中的节点一一输出(出栈)*/
        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }
    }

        /** 创建链表实例*/
        SingleLinkedList list = new SingleLinkedList();
        list.addByOrder(new DataNode(4, "节点4"));
        list.addByOrder(new DataNode(2, "节点2"));
        list.addByOrder(new DataNode(1, "节点1"));
        list.addByOrder(new DataNode(3, "节点3"));
        System.out.println("原链表:");
        list.print();

        System.out.println("逆序打印单链表:");
        list.reversePrint();

输出:
> 原链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
> 逆序打印单链表:
> DataNode [no=4, title=节点4]
> DataNode [no=3, title=节点3]
> DataNode [no=2, title=节点2]
> DataNode [no=1, title=节点1]

双向链表(Double Linked List)

不同于单链表:

(1) 每个节点包含数据域, 指向下一个节点的 next(地址/引用)和多了一个上一个节点的 pre(地址/引用)
(2) 单向链表是只能单方向查找节点, 而双向链表可以向前或向后查找节点
(3) 单向链表不能自我删除, 而双向链表, 则可以自我删除节点
(4) 添加方法: 将新的节点引用加到, 当前(尾部)节点的 next变量中, 同时当前节点引用加到新节点的 pre变量中; temp.next = dataNode; dataNode.pre = temp;
(5) 找出要删除的节点(temp). temp.pre.next = temp.next; temp.next.pre = temp.pre;


/** 定义链表节点类*/
class DataNode {
    /** 节点编号*/
    public int no;
    /** 节点标题*/
    public String title;
    /** 指向下一个节点, 如果是 null, 则当前节点为尾节点*/
    public DataNode next;
    /** 指向上一个节点, 如果是 null, 则当前节点为头节点*/
    public DataNode pre;

    public DataNode() {}

    public DataNode(int no, String title) {
        this.no = no;
        this.title = title;
    }

    @Override
    public String toString() {
        return "DataNode [no=" + no + ", title=" + title + "]";
    }
}

/** 定义双向链表类*/
class DoubleLinkedList {
    /** 初始化头节点, 此节点不设定数据*/
    private DataNode head = new DataNode();

    /**
     * 添加新节点:
     * 给尾部节点的 next指向新的节点引用
     * */
    public void add(DataNode dataNode) {
        /** 为了从头节点开始往后遍历找出尾部节点*/
        DataNode temp = head;
        /** 遍历找出尾部节点*/
        while(true) {
            /** 当前节点为尾部节点便停止循环*/
            if(temp.next == null) {
                break;
            }
            /** 如果当前节点不为尾部节点, 则再往后移*/
            temp = temp.next;
        }
        /** 将新的节点引用加到, 当前(尾部)节点的 next变量中, 同时当前节点引用加到新节点的 pre变量中*/
        temp.next = dataNode;
        dataNode.pre = temp;
    }

    /** 遍历所有节点*/
    public void print() {
        if(head.next == null) {
            System.out.println("链表为空!");
            return;
        }
        /** 头节点不能被覆盖, 所有先使用辅助变量转移第一个(有效)节点*/
        DataNode temp = head.next;
        while(true) {
            /** 到了链表尾部时停止遍历*/
            if(temp == null) {
                break;
            }
            /** 输出当前节点的信息*/
            System.out.println(temp);
            /** 往后移一个节点, 继续遍历*/
            temp = temp.next;
        }
    }

    /** 排序添加(添加时根据编号排序)*/
    public void addByOrder(DataNode dataNode) {
        DataNode temp = head;
        /** 标记: 是否重复*/
        boolean bRepeat = false;
        while(true) {
            /** 到了链表尾部时停止遍历*/
            if(temp.next == null) {
                break;
            }
            /** 找到了, 排序位*/
            if(temp.next.no > dataNode.no) {
                break;
            } else if (temp.next.no == dataNode.no) {
                /** 编号重复*/
                bRepeat = true;
                break;
            }
            /** 往后移一个节点, 继续遍历*/
            temp = temp.next;
        }
        /** 判断编号是否重复*/
        if(bRepeat) {
            System.out.printf("重复节点 %d, 不能添加\n", dataNode.no);
        } else {
            dataNode.next = temp.next;
            if (temp.next != null) temp.next.pre = dataNode;
            temp.next = dataNode;
            dataNode.pre = temp;
        }
    }

    /** 链表删除*/
    public void del(int no) {
        if(head.next == null) {
            System.out.println("链表为空!");
            return;
        }
        DataNode temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp == null) {
                break;
            }
            if(temp.no == no) {
                flag=true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.pre.next = temp.next;
            if (temp.next != null) temp.next.pre = temp.pre;
        }else {
            System.out.printf("要删除的编号 %d 节点不存在", no);
        }
    }

}

public class DoubleLinkedListApp {
    public static void main(String[] args) {
//        /** 创建链表实例*/
//        DoubleLinkedList list = new DoubleLinkedList();
//        /** 添加节点*/
//        list.add(new DataNode(4, "节点4"));
//        list.add(new DataNode(2, "节点2"));
//        list.add(new DataNode(1, "节点1"));
//        list.add(new DataNode(3, "节点3"));
//        /** 输出所有节点*/
//        list.print();

        /** 创建链表实例*/
        DoubleLinkedList list = new DoubleLinkedList();
        list.addByOrder(new DataNode(4, "节点4"));
        list.addByOrder(new DataNode(2, "节点2"));
        list.addByOrder(new DataNode(1, "节点1"));
        list.addByOrder(new DataNode(3, "节点3"));
        System.out.println("原链表:");
        list.print();

        list.del(2);
        System.out.println("删除后的链表:");
        list.print();
    }
}

输出:
> 原链表:
> DataNode [no=1, title=节点1]
> DataNode [no=2, title=节点2]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]
> 删除后的链表:
> DataNode [no=1, title=节点1]
> DataNode [no=3, title=节点3]
> DataNode [no=4, title=节点4]

如果您觉得有帮助，欢迎点赞哦 ~ 谢谢!!

数据结构-单链表& 双向链表

Single Linked List& Double Linked List

概述

单链表(Single Linked List)

双向链表(Double Linked List)

猜你喜欢