数据结构与算法——链表（LinkedList）

最新推荐文章于 2024-04-22 10:55:12 发布
最新推荐文章于 2024-04-22 10:55:12 发布
阅读量214 收藏 1
点赞数 1
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crisp077/article/details/125254204
版权

链表( Linked List )

1 单链表

  • 链表是以节点的方式来存储的，是链式存储
  • 每个节点包含data域，next域：指向下一个节点
  • 链表的各个节点不一定是连续存储的
  • 链表分带头结点的链表和没有头节点的链表，根据实际需求来确定
1.1 添加节点
  • 第一种方式：在添加英雄时直接添加到链表的尾部
    1. 先创建一个head头节点，作用解释表示单链表的头
    2. 后面我们每添加一个节点，就直接加入到链表的最后
    3. 通过一个辅助变量，遍历整个链表
  • 第二种方式：在添加英雄时，根据排名将英雄插入到指定位置
    1. 首先找到新添加的节点的位置，是通过辅助变量(指针)
    2. 新的节点.next = temp.next
    3. 将temp.next = 新的节点
1.2 修改节点
  1. 先找到该节点，通过遍历
  2. 然后依次将新节点的内容替换到辅助节点上
1.3 删除节点
  1. 我们先找到需要删除的这个节点的前一个节点temp
  2. temp.next = temp.next.next
  3. 被删除的节点，将不会有其他引用指向，会被垃圾回收机制回收
1.4 示例代码
package com.crisp.LinkedList;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //进行测试
        //先创建节点
        HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3 = new HeroNode(3,"鲁智深","花和尚");
        HeroNode hero4 = new HeroNode(4,"林冲","豹子头");

        //创建要给链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
/*        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);
        System.out.println();*/
        //排序后输出
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero2);
        //singleLinkedList.addByOrder(hero3);//测试重复添加英雄
        //显示
        singleLinkedList.list();
        System.out.println();
        //测试修改节点的代码
        System.out.println("更改3号节点：");
        HeroNode hero5 = new HeroNode(3,"吴用","智多星");
        singleLinkedList.update(hero5);
        singleLinkedList.list();
        System.out.println();
        //测试删除一个节点
        System.out.println("删除1号节点");
        singleLinkedList.delete(1);
        singleLinkedList.list();
    }
}

//定义SingleLinkedList 管理英雄
class SingleLinkedList {
    //先初始化一个头节点，头节点不要动,不存放具体的数据
    private HeroNode head = new HeroNode(0,"","");

    //添加节点到单向链表
    //思路，当不考虑编号顺序时
    //1、找到当前链表的最后节点
    //2、将最后这个节点的next 指向 新的节点
    public void add(HeroNode heroNode){
        //因为head 节点不能动，因此我们需要一个辅助变量temp
        HeroNode temp = head;
        //遍历链表，找到最后
        while(true){
            if(temp.next == null){
                break;
            }
            //如果没有找到最后,就将temp 后移
            temp = temp.next;
        }
        //当退出while 循环时，temp 就指向了链表的最后
        //将最后这个节点的next 指向 新的节点
        temp.next = heroNode;
    }

    //第二种方式在添加英雄时，根据排名将英雄插入到指定位置（如果有这个排名做，则添加失败，并给出提示）
    public void addByOrder(HeroNode heroNode) {
        //因为头节点不能动，因此通过辅助指针来找添加的位置
        //因为是单链表，因此temp 是位于添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false;//标志添加的编号是否存在，默认为false
        while(true){
            if(temp.next == null){//说明temp 已经在链表的最后
                break;
            }
            if(temp.next.no > heroNode.no){//位置找到，就在temp 后面添加
                break;
            } else if(temp.next.no == heroNode.no){//说明希望添加的heroNode 的编号已存在
                flag = true;
                break;
            }
            temp = temp.next;//后移 遍历当前链表
        }
        //判断flag 的值
        if(flag){//不能添加，说明编号存在
            System.out.printf("准备插入的英雄的编号 %d 已经存在，不能添加\n",heroNode.no);
        }else{
            //插入到链表中
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //修改节点的信息，根据no 编号来修改，即no编号不能改
    //说明：
    //1、根据newHeroNode的no来编写
    public void update(HeroNode newHeroNode){
        //判断是否空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据no编号
        //定义一个辅助变量
        HeroNode temp = head.next;
        boolean flag = false;
        while(true){
            if(temp == null){
                break;//已经遍历完链表
            }
            if(temp.no == newHeroNode.no){
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag 判断是否找到要修改的节点
        if(flag){
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        }else{//没有找到
            System.out.printf("没有找到编号为 %d 的节点，不能更改\n",newHeroNode.no);
        }
    }
    //删除节点
    //思路：
    //1、head 不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    //2、说明我们在比较时，是temp.next.no 和 需要删除的节点的no比较
    public void delete(int no){
        //找到需要修改的节点，根据no编号
        //定义一个辅助变量
        HeroNode temp = head;
        boolean flag = false;
        while(true) {
            if (temp.next == null) {
                break;//已经遍历完链表
            }
            if (temp.next.no == no) {
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag 判断是否找到要删除的节点
        if(flag){
            temp.next = temp.next.next;
        }else{//没有找到
            System.out.printf("没有找到编号为 %d 的节点，无法删除\n",no);
        }
    }



    //显示链表[遍历]
    public void list(){
        //先判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while(true){
            //判断是否到链表最后
            if(temp == null){
                break;
            }
            //输出节点的信息
            System.out.println(temp);
            //将temp 后移
            temp = temp.next;
        }
    }
}



//定义一个HeroNode，每个HeroNode对象就是一个节点
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点
    //构造器
    public HeroNode(int hNo,String hName,String hNickname){
        this.no = hNo;
        this.name = hName;
        this.nickname = hNickname;
    }

    //为了显示方便，我们重写toString()
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}
1.5 单链表面试题

单链表常见的面试题有如下：

（1）求单链表中有效节点的个数
 /**
     *
     * @param head 链表的头节点
     * @return 返回的就是有效节点的个数
     */
    public static int getLength(HeroNode head){
        if(head.next == null){
            return 0;
        }
        int length = 0;
        //定义一个辅助的变量，没有统计头节点
        HeroNode cur = head.next;
        while(cur != null){
            length++;
            cur = cur.next;
        }
        return length;
    }
}
（2）查找单链表中的倒数第k 个节点（新浪）

​ 思路：

  1. 编写一个方法，接收head节点，同时接收一个index
  2. index 表示倒数第index个
  3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
  4. 得到size 之后我们从链表的第一个开始遍历 (size - index)个，就可以得到
//思路：
    //1、编写一个方法，接收head节点，同时接收一个index
    //2、index 表示倒数第index个
    //3、先把链表从头到尾遍历，得到链表的总的长度 getLength
    //4、得到size 之后我们从链表的第一个开始遍历 (size - index)个，就可以得到
    public static HeroNode FindLastIndexNode(HeroNode head,int index){
        //判断如果链表为空，返回null
        if(head.next == null){
            return null;
        }
        //第一次遍历得到链表的长度（节点个数）
        int size = getLength(head);
        //第二次遍历 size - index 位置，就是我们倒数的第k个节点
        //先做一个index校验
        if(index <= 0 || index > size){
            return null;
        }
        //定义一个辅助变量,for 循环定位到倒数的index
        HeroNode cur = head.next;
        for(int i = 0; i < size - index; i++){
            cur = cur.next;
        }
        return cur;
    }
（3）单链表的反转（腾讯）

​ 思路：

  1. 先定义一个节点 reverseHead = new HeroNode();
  2. 从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
  3. 原来的链表的head.next = reverseHead.next
//单链表的反转（腾讯）
    public static void ReverseList(HeroNode head){
        //判断链表为空，返回null
        if(head.next == null || head.next.next == null){
            return;
        }
        //定义一个辅助的指针，帮助我们比哪里原来的链表
        HeroNode cur = head.next;
        HeroNode next = null;
        //定义反转节点
        HeroNode reverseHead = new HeroNode(0,"","");
        //遍历原来的链表，每遍历一个节点，就将其取出，并放在新链表reverseList的最前端
        while(cur != null){
            next = cur.next;
            cur.next = reverseHead.next;
            reverseHead.next = cur;
            cur = next;
        }
        head.next = reverseHead.next;
    }
（4）从尾到头打印单链表（百度，要求方式1：反向遍历。方式2：Stack 栈）

​ 思路：

  1. 此题的要求就是逆序打印单链表
  2. 方式1：先将单链表进行反转操作，然后再遍历即可，这样做的问题是会破环原来的的单链表的结构，不建议
  3. 方式2：可以利用栈这个数据结构，将各个节点压入栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果
	//方式2：
    //利用栈实现逆序打印
    public static void reversePrint(HeroNode head){
        if(head.next == null){
            return;//空链表无法打印
        }
        //创建一个栈，将各个节点压入栈中
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode cur = head.next;
        //将链表的所有节点压入栈
        while(cur != null){
            stack.push(cur);
            cur = cur.next;//cur 后移，压入下一个节点
        }
        //将栈中的节点打印
        while(stack.size() > 0){
            System.out.println(stack.pop());//stack的特点是先进后出
        }
    }

2 双链表

管理单向列表的缺点分析：

  1. 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找
  2. 单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除。所以前面我们删除单链表的节点时，总是找到temp 的下一个节点来删除

分析双向链表的增删改查：

  • 遍历方式和单链表一样，只是可以向前，也可以向后查找
  • 添加（默认添加到双向链表的最后节点）
    1. 先找到双向链表的最后这个节点
    2. temp.next = newHeroNode
    3. newHeroNode.pre = temp
  • 修改 的思路和原理和单向链表一样
  • 删除
    1. 因为是双向链表，因此，我们可以实现自我删除某个节点
    2. 直接找到要删除的这个节点，例如temp
    3. temp.pre.next = temp.next
    4. temp.next.pre = temp.pre
示例代码：
package com.crisp.LinkedList;

import org.w3c.dom.Node;

public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        //进行测试
        //先创建节点
        HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨");
        HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟");
        HeroNode2 hero3 = new HeroNode2(3, "鲁智深", "花和尚");
        HeroNode2 hero4 = new HeroNode2(4, "林冲", "豹子头");

        //添加节点
//        System.out.println("原始链表如下：");
//        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
//        doubleLinkedList.add(hero1);
//        doubleLinkedList.add(hero2);
//        doubleLinkedList.add(hero3);
//        doubleLinkedList.add(hero4);
//        doubleLinkedList.list();

        //按顺序添加节点
        System.out.println("按顺序添加链表如下：");
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.addByOrder(hero4);
        doubleLinkedList.addByOrder(hero3);
        doubleLinkedList.addByOrder(hero2);
        doubleLinkedList.addByOrder(hero1);
        doubleLinkedList.list();


        //修改一个节点
        System.out.println("修改后的链表如下：");
        HeroNode2 hero5 = new HeroNode2(3, "吴用", "智多星");
        doubleLinkedList.update(hero5);
        doubleLinkedList.list();

        //删除一个节点
        System.out.println("删除4号节点后的链表：");
        doubleLinkedList.delete(4);
        doubleLinkedList.list();
    }
}


//创建一个双向链表类
class DoubleLinkedList{
    //初始化头节点
    private HeroNode2 head = new HeroNode2(0,"","");
    //返回头节点
    public HeroNode2 getHead() {
        return head;
    }

    //添加节点到双向链表(默认添加到最后)
    public void add(HeroNode2 newNode){
        //利用辅助函数遍历
        HeroNode2 temp = head;
        while(true){
            if(temp.next == null){
                break;
            }
            temp = temp.next;
        }
        temp.next = newNode;
        newNode.pre = temp;
    }

    //第二种添加方式，按编号顺序来添加好汉
    public void addByOrder(HeroNode2 newNode){
        //利用辅助函数来遍历
        HeroNode2 temp = head;
        while(true){
            if(temp.next == null){
                newNode.next = temp.next;
                temp.next = newNode;
                newNode.pre = temp;
                break;
            }
            if(temp.next.no > newNode.no) {
                newNode.next = temp.next;
                temp.next = newNode;
                newNode.pre = temp;
                break;
            }else if(temp.next.no == newNode.no){
                System.out.println("编号已经存在，无法添加~");
                break;
            }
            temp = temp.next;
        }
    }

    //修改节点的信息
    public void update(HeroNode2 newNode){
        //判断链表是否为空
        if(head.next == null){
            return;
        }
        //遍历节点，找到需要修改的节点
        HeroNode2 temp = head;
        while(true){
            if(temp == null){
                System.out.printf("没有找到编号为 %d 的好汉\n",newNode.no);
                break;
            }
            if(temp.no == newNode.no){
                temp.name = newNode.name;
                temp.nickname = newNode.nickname;
                break;
            }
            temp = temp.next;
        }
    }

    //删除一个节点
    public void delete(int Delno){
        //判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空~无法删除");
        }
        //遍历链表，找到需要删除的节点
        HeroNode2 temp = head.next;
        while(true){
            if(temp == null){
                System.out.printf("没有找到编号为 %d 的好汉\n",Delno);
                break;
            }
            if(temp.no == Delno){
                temp.pre.next = temp.next;
                if(temp.next != null){
                    temp.next.pre = temp.pre;
                }
                break;
            }
            temp = temp.next;
        }
    }


    //显示链表[遍历]
    public void list(){
        //先判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，因此我们需要一个辅助变量来遍历
        HeroNode2 temp = head.next;
        while(true){
            //判断是否到链表最后
            if(temp == null){
                break;
            }
            //输出节点的信息
            System.out.println(temp);
            //将temp 后移
            temp = temp.next;
        }
    }
}

//定义一个HeroNode2 ，其中多了pre 向前节点
class HeroNode2{
    public int no;
    public String name;
    public String nickname;
    public HeroNode2 next;//指向后一个节点
    public HeroNode2 pre;//指向前一个节点
    //构造器
    public HeroNode2(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }
    //重写toString
    @Override
    public String toString() {
        return "HeroNode2{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

3 环形链表

3.1 单向环形链表应用场景
  • Josephu 问题
    • 设编号为1，2，…，n的n个人围坐一圈，约定编号为k(1<=k<=n)的人从1开始报数，数到m的那个人出列，他的下一位又从1开始数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列
  • 提示
    • 用一个不带头节点的循环链表来处理Josephu 问题：先构成一个又n个节点的单循环链表，然后由k节点起从1开始计数，计到m时，对应节点从链表中删除，然后再从被删除的节点的下一个节点又开始从1开始计数，直到最后一个节点从链表中删除，算法结束
  • 构建一个单向环形链表思路
    1. 先创建第一个节点，让first 指向该节点，并形成环形
    2. 后面当我们每创建一个新的节点，就把该节点加入到已有的环形链表中即可
  • 遍历环形链表
    1. 先让一个辅助指针cur，指向first节点
    2. 然后通过一个while 循环遍历该环形链表即可。cur.next == first结束
  • 两种方式实现出圈功能：
    • 方法1：创建一个辅助节点temp，初始化在first 指针后面，每次让first 指在需要出圈的节点，然后进行操作
    • 方法2：只用一个first 指针，使其每次指在需要出圈节点的前一个节点，然后进行操作
3.2 Josephu问题实现代码
package com.crisp.LinkedList;

public class Josephu {
    public static void main(String[] args) {
        /*//测试环形链表
        CircleSingleLinkedList josephu = new CircleSingleLinkedList();
        //测试环形链表增加功能
        josephu.addBoy(5);
        josephu.showCircle();
        //测试环形链表删除功能
        josephu.delete(5);
        josephu.showCircle();
        //测试环形链表查找功能
        Boy res = josephu.find(5);
        System.out.println(res);*/
        //测试约瑟夫环
        JosephuRing(10,5,2);
    }

    /**
     * 约瑟夫问题
     * @param sum 游戏总人数
     * @param k 由第k个人开始
     * @param m 每次数m个数
     */
    public static void JosephuRing(int sum,int k,int m){
        //k,sum和m取值校验
        //即k的值小于等于sum且大于0
        //m的值大于1，虽然理论上可以取1，但我们认为这是毫无意义的，就相当于将first放在k上依次遍历
        if(k > sum || k <= 0 || m <= 1){
            System.out.println("~~~数据输入有误，请输入正确的数据!!!~~~");
            return;
        }
        CircleSingleLinkedList josephu = new CircleSingleLinkedList();
        josephu.addBoy(sum);

        //将孩子出圈的顺序存入数组中
        int[] arr = new int[sum];

        //根据需求，环形链表中的first节点对于本问题无影响
        //首先将first指针指向第k个人
        josephu.setFirst(josephu.find(k));
        System.out.printf("移动到第 %d 个人的位置：",k);
        josephu.showCircle();
        Boy temp = josephu.getFirst();

        //从第k个人开始数（m-1）个数
        //由于sum个人，所以一共只需要循环sum次
        for(int i = 0; i < sum; i++){
            for(int j = 2; j < m; j++){
                //将first节点向后移动一位，直到移动在数(m - 1)个数的时候
                josephu.setFirst(josephu.getFirst().getNext());
            }
            if(josephu.getFirst().getNext() == josephu.getFirst()){
                arr[i] = josephu.getFirst().getNo();
                josephu.setFirst(null);
                System.out.printf("~第 %d 次后，所有人都已经出圈~\n",i + 1);
                //输出孩子出约瑟夫环顺序
                System.out.println("孩子们的出圈顺序为：");
                for(int count = 0; count < arr.length; count ++){
                    System.out.printf(" => %d",arr[count]);
                }
                return;
            }
            arr[i] = josephu.getFirst().getNext().getNo();
            //要出圈的人就是first节点的下一个节点
            josephu.getFirst().setNext(josephu.getFirst().getNext().getNext());
            josephu.setFirst(josephu.getFirst().getNext());
            //输出每次出圈后的情况
            System.out.printf("第 %d 次出圈后顺序：",i+1);
            josephu.showCircle();
        }
    }
}

//创建一个环形的单向链表
class CircleSingleLinkedList{
    //创建一个first节点，当前无编号
    private Boy first = null;

    //获取头节点
    public Boy getFirst() {
        return first;
    }

    //设置头节点位置
    public void setFirst(Boy first) {
        this.first = first;
    }

    //添加节点，构建成一个环形的链表
    //直接输入参与游戏的人数
    public void addBoy(int sum){
        //对sum做一个数据校验
        if(sum < 1){
            System.out.println("游戏人数不正确~");
            return;
        }
        //创建一个辅助指针，帮助创建变量
        Boy cur = null;
        //使用for循环创建环形链表
        for(int i = 1; i <= sum; i++){
            //根据编号创建节点
            Boy boy = new Boy(i);
            //如果是第一个小孩
            if(i == 1){
                first = boy;
                first.setNext(first);//构成环
                cur = first;//让cur指向第一个节点
            }else{
                cur.setNext(boy);
                boy.setNext(first);
                cur = boy;
            }
        }
    }

    //删除节点
    public void delete(int delnum){
        //判断链表是否为空
        if(first == null){
            System.out.println("~~~链表为空！！！~~~");
            return;
        }
        //创建两个辅助节点
        //一个跟在另一个的后面
        //由前一个cur1发现需要删除的节点
        //后面的cur2指向发现节点的下一个节点
        Boy cur1 = first.getNext();
        Boy cur2 = first;
        //遍历链表找到需要删除的节点
        while(true){
            //System.out.println(cur1.getNo());
            //System.out.println(cur2.getNo());
            if(cur1.getNo() == delnum){
                 cur2.setNext(cur1.getNext());
                if(cur1.getNo() == first.getNo()){
                    first = cur2.getNext();
                }
                 return;
            }
            if(cur1.getNo() == first.getNo()){
                System.out.println("~没有发现所要删除的节点~");
                return;
            }
            //两个节点均向后移位
            cur1 = cur1.getNext();
            cur2 = cur2.getNext();
        }
    }

    //查找节点
    //由于是一个环形节点
    //所以输入值应该为从头节点开始的第num个数，而不是编号值
    //注意：first节点应该算作第一个数
    public Boy find(int num){
        //定义辅助指针，用来在链表中移动
        Boy temp = first;
        for(int i = num; i > 1; i--){
            temp = temp.getNext();
        }
        return temp;
    }

    //遍历当前环形链表
    public void showCircle(){
        //判断是否为空
        if(first == null){
            System.out.println("链表为空~");
            return;
        }
        //first不可移动，因此使用辅助指针
        Boy temp = first;
        while(true){
            System.out.printf("=> %d ",temp.getNo());
            if(temp.getNext() == first){
                //最后一个节点
                System.out.println();
                return;
            }
            temp = temp.getNext();
        }
    }
}


//创建一个Boy类，表示一个节点
class Boy{
    private int no;//编号
    private Boy next;//指向下一个节点
    //构造器
    public Boy(int no) {
        this.no = no;
    }
    //set方法
    public void setNo(int no) {
        this.no = no;
    }
    public void setNext(Boy next) {
        this.next = next;
    }
    //get方法
    public int getNo() {
        return no;
    }
    public Boy getNext() {
        return next;
    }

    //重写toString，方便查看
    @Override
    public String toString() {
        return "Boy{" +
                "no=" + no +
                '}';
    }
}
三月江东
关注
专栏目录
【笔记】数据结构与算法——链表
Gu_jiaguaren的博客
08-11 216
Ø链表(LinkedList) 链接方式存储的线性表简称为链表 链表的具体存储表示为： 用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的） 链表中结点的逻辑次序和物理次序不一定相同 链表是以结点的方式来存储的： data域：存放结点值的数据域 next域：存放结点的直接后继的地址的指针域 链表分为带头结点的链表和不带头结点的链表，根据实际的需求来确定 链表建立的过程是申请空间、得到数据、建立链接的循环处理过程 （一）单链表 单链表的建立 1）头插法 将链
JAVA数据结构与算法基础——链表(LinkedList)【云图智联】
06-18 286
在本节中，我们将看到一种新的数据存储结构，它可以解决上面的一些问题。这种数据存储结构就是链表。链表可能是继数组之后第二种使用最广泛的通用存储结构。 在本章中，我们将学习： 单链表 双端链表 有序链表 双向列表 有迭代器的列表 链表与数组一样，都作为数据的基本存储结构，但是在存储原理上二者是不同的。在数组中，数据是存储在一段连续的内存空间中，我们可以通过下标来访问数组中的元素；而在链表中，元素是存储在不同...
数据结构与算法--链表（Linked list）
weixin_42028840的博客
07-11 178
  “数据结构与算法”不管是在Java还是在任何语言中都是核心基础知识，就像是盖楼的地基一样，它被广泛的应用于架构的最底层，对于这部分知识的掌握程度能够决定读者以后的高度。    出于这个初衷开更本系列文章，希望能对读者有所帮助。   读者的收获1、了解链表的底层结构2、常用的链表类型3、链表的特性4、链表的优缺点链表的底层结构     相较于上一篇的数组，由于链表在内存中的分布是不连续的，所以每一个内存块除了存数据之
[算法专题] LinkedList
diaolun4894的博客
08-17 130
前段时间在看一本01年出的旧书《effective Tcp/Ip programming》，这个算法专题中断了几天，现在继续写下去。 Introduction 对于单向链表(singly linked list)，每个节点有⼀个next指针指向后一个节点，还有一个成员变量用以储存数值；对于双向链表(Doubly LinkedList)，还有一个prev指针指向前一个节点。与数组类似，...
链表(LinkedList)--算法
故事凌
03-10 198
单链表: 链表中的每个元素实际上是一个单独的对象, 而所有对象都通过每个元素中的引用字段链接在一起双向链表: 与单链表不同的是, 双链表的每个节点中都包含有两个引用字段1. 链表的优点:...
数据结构与算法(三)-链表(LinkedList)
老男孩的博客
01-06 6669
链表结构 一、介绍 链表和数组一样，可以用于存储一系列的元素，但是链表和数组的实现机制完全不同。链表又可以分作单向链表和双向链表。 链表的每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（有的语言称为指针或连接）组成。类似于火车头，一节车厢载着乘客（数据），通过节点连接另一节车厢。如下图所示 链表的火车结构 链表的数据结构 ​ head 属性指向链表的第一个节点。 ​ 链表中的最后一个节点指向 null。 ​ 当链表中一个节点也没有的时候，head 直接指向 null。 给火车加上数
【java数据结构与算法学习】LinkedList的实现
Zer01ne的博客
02-26 293
LinkedList是一个双向链表，是链表的一种特殊情况。链表有单链表、静态链表、双向链表、循环链表。单链表节点有一个数据域，一个指针域，其中指针域指向下一个节点。静态链表底层是一个数组和游标组成。数组中的第一个元素为空，第一个游标是数组中第一个为空的元素的下标；数组中最后一个元素也为空，最后一个游标是数组中第一个不为空元素的下标；游标为0的元素是静态链表最后一个元素。根据最后一个游标找到静态链表...
Python数据结构实战——链表(LinkedList)
12-21
链表是一种动态数据结构，与数组不同，它允许在不相邻的位置进行插入和删除操作，这得益于每个元素（称为节点）都包含指向下一个元素的引用。 1. 定义结点类 在Python中，链表的每个元素由一个结点（Node）对象表示...
数据结构与算法——链表(Java)
PiedPiper's Blog
05-16 136
链表定义 class LinkedList<T> { private Node head; private int N; public class Node { T item; Node next; public Node() { } public Node(T item, Node next) { this.item = item; th
Python实现数据结构与算法——设计链表
Mantana的博客
03-21 704
题目描述： 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引无效，...
数据结构和算法（五）LinkedList的底层实现
jwang的博客
07-31 745
前言 本章讲解顺序存储结构ArrayList的底层实现 方法 1.概念 我们知道，线性表的链式存储结构的实现在Java中是以LinkedList来实现的。那么我们用了这么久的LinkedList，如果不知道LinkedList的底层实现岂不是十分的滑稽，让我们来揭开它神秘的面纱。 2.实现思路 1）构建我们自己的List接口 我们可以尝试写出最基本的抽象方法。比如求集合中元...
数据结构与算法之LinkedList源码分析
chenliguan的博客
12-07 698
1 LinkedList的基本结构　　链表就和链子一样，每一环都要连接着后边的一环和前边的一环，这样，当我们需要找这根链子的某一环的时候，只要我们能找到链子的任意一环，都可以找到我们需要的那一环。如下图： 　　LinkedList在jdk1.6中的结构： 　　LinkedList在jdk1.7中的结构： 图片来源于：Java进阶之—-LinkedList源码分析 　　对比一下，知道区
LinkedList
diaog的博客
10-02 191
LinkedList结构 LinkedList是一个实现了List接口和Deque接口的双向链表。 LinkedList底层的链表结构使它支持高效的插入和删除操作，另外它实现了Deque接口，使得LinkedList类也具有队列的特性; 另外LinkedList实现了Cloneable接口和Serializable接口。 public class LinkedList<E> ...
详解链表相关算法
LynnWonder
02-02 467
链表（linked list）是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。[算法导论链表相关的题解](https://walkccc.me/CLRS/Chap10/10.2/)。本文将从概念，基础算法，常见题目等方面进行陈述。
LinkedList 方法大全（栈、队列）
赶路人儿
01-12 8049
LinkedList类是双向列表（底层使用链表结构），列表中的每个节点都包含了对前一个和后一个元素的引用。LinkedList有很多方法，通过这些方法可以很容易将其用作队列、栈等数据结构。   1、常用方法： 1）获取第一、最后一个元素： LinkedListlist = new LinkedList();   System.out.println("链表的第一个元素是: " + li
数据结构与算法 - 基础：LinkedList
最新发布
qq_33240556的博客
04-22 417
插入和删除操作的时间复杂度通常为 O(1)（在已知节点的情况下），但是在链表的特定位置（如未知位置或中间位置）插入或删除元素时，需要从头或指定位置开始遍历，时间复杂度为 O(n)。是一种线性数据结构，不同于数组，它采用链式存储方式，由一系列节点（Node）组成，每个节点包含数据部分（data）和指向下一个节点的指针（next pointer）。：每个节点包含两个指针，一个指向前一个节点（previous pointer），一个指向后一个节点（next pointer）。这使得双向链表可以在两个方向上遍历。
LinkedList基本使用方法
博爷的博客
11-15 1万+
1.获取链表的第一个和最后一个元素import java.util.LinkedList; public class LinkedListTest{ public static void main(String[] args) { LinkedList<String> lList = new LinkedList<String>(); lList.add("1");
【数据结构】LinkedList原理及实现学习总结
热门推荐
简约人生的博客
04-20 2万+
LinkedList 和 ArrayList 一样，都实现了 List 接口，但其内部的数据结构有本质的不同。LinkedList 是基于链表实现的（通过名字也能区分开来），所以它的插入和删除操作比 ArrayList 更加高效。但也是由于其为基于链表的，所以随机访问的效率要比 ArrayList 差。二、ListedList类定义public class Lin
LinkedList 的创建与使用
weixin_56162501的博客
04-16 1337
1.LinkedList 的创建 //创建一个 LinkedList 链表结构 LinkedList list = new LinkedList(); 2.LinkedList 的添加操作 //追加尾部 list.add("java01"); //添加到头部 list.addFirst("java02"); //添加到尾部 list.addLast("java03"); //添加到指定下标 list.add(2,19); 3.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

三月江东

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值