Java数据结构与算法（三）：链表

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

1. 单链表介绍

链表是有序的列表，但是它在内存中是存储如下：
在这里插入图片描述

  • 链表是以节点的方式来存储，是链式存储；
  • 每个节点包含 data 域，next 域（指向下一个节点）；
  • 如上图：链表的各个节点不一定是连续存储；
  • 链表分 带头节点的链表 和没有头节点的链表，根据实际的需求来确定；
    • 单链表（带头节点）逻辑结构示意图如下：
      在这里插入图片描述

2. 单链表的应用实例

使用带头节点的单项链表实现 水浒英雄排行榜管理 完成对英雄人物的增删改查操作。

  • 第一种方法在添加英雄时，直接添加到链表的尾部：
    在这里插入图片描述

  • 第二种方式在添加英雄时，根据排名将英雄插入到指定位置（如果已有这个排名，则添加失败，并给出提示）
    在这里插入图片描述

  • 修改节点信息

  1. 先找到该节点，然后遍历；
  2. temp.name == newHeroNode; temp.nickName == newHeroNode.nickName;
  • 删除节点
    在这里插入图片描述
  • 代码实现
package com.lele.linkedlist;

/**
 * author: hwl
 * date: 2020/9/19 16:10
 * version: 1.0.0
 * modified by:
 * description:
 */
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);
//        singleLinkedList.list();

        // 按照编号顺序插入
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.list();

        // 测试修改节点
        HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
        singleLinkedList.update(newHeroNode);
        System.out.println("修改后的链表情况~~");
        singleLinkedList.list();

        // 测试查找节点
        System.out.println("测试查找");
        singleLinkedList.query(1);
        System.out.println(singleLinkedList.query(1));


        // 测试删除节点
        singleLinkedList.del(1);
        singleLinkedList.del(4);
        singleLinkedList.del(2);
        singleLinkedList.del(3);
        System.out.println("删除后的链表情况~~");
        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; // flag 标志添加的编号是否存在，默认为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 {
            // 插入到链表中，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    // 查找链表中是否存在某个节点,根据编号查找
    public HeroNode query(int no) {
        // 判断是否为空
        if (head.next == null) {
            System.out.println("链表为空~");
            return null;
        }
        HeroNode temp = head.next; // 定义一个辅助变量
        while(true) {
            if (temp == null) {
                System.out.println("链表没有该节点~~");
                return null;// 已经遍历完链表
            }
            if (temp.no == no) {
                return temp;
            }
            temp = temp.next;
        }
    }

    // 修改节点的信息，根据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 del (int 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; // temp后移，遍历
        }
        // 判断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 no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    // 重写toString
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

3. 单链表面试题

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个节点

  • 代码如下：
/**
 * 查找单链表中的倒数第k个节点
 * 思路：
 * 1.编写一个方法，接收head节点，同时接收一个index
 * 2.index表示是倒数第index个节点
 * 3.先把链表从头到尾遍历，得到链表的总长度getLength
 * 4.得到size后，我们从链表的第一个开始遍历（size-index）个，就可以得到
 * 5.如果找到了，则返回该节点，否则返回null
 * @param head
 * @param index
 * @return
 */
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;
}

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;
}

3. 单链表的反转
在这里插入图片描述
在这里插入图片描述

  • 代码实现
/**
 * 单链表反转
 * @param head 单链表头指针
 */
public static void reverseList(HeroNode head) {
    // 如果当前链表为空，或者只有一个节点，无需反转，直接返回
    if (head.next == null || head.next.next == null) {
        return;
    }

    // 定义一个辅助的指针（变量），帮助我们遍历原来的链表
    HeroNode cur = head.next;
    HeroNode next = null; // 指向当前节点[cur]的下一个节点
    HeroNode reverseHead = new HeroNode(0, "","");
    // 遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
    while(cur != null) {
        next = cur.next; // 先暂时保存当前节点的下一个节点，因为后面需要使用
        cur.next = reverseHead.next; // 将cur的下一个节点指向新的链表的最前端
        reverseHead.next = cur; // 将cur连接到新的链表上
        cur = next; // 让 cur 后移
    }
    // 将 head.next 指向 reverseHead.next，实现单链表的反转
    head.next = reverseHead.next;
}

4. 从尾到头打印单链表
在这里插入图片描述

  • 代码实现
/**
 * 单链表的逆序打印
 * 将单链表的各个节点压入栈中，利用栈的先进后出的特点，实现逆序打印的效果
 * @param head 头节点
 */
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; // 后移，继续压入下一个节点
    }
    while(stack.size() > 0) {
        System.out.println(stack.pop());  //出栈
    }
}

4 双向链表应用实例

双向链表的操作分析和实现
使用带Head头的双向链表实现 ——水浒英雄排行榜

单向链表的缺点分析：

  • 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找；
  • 单项链表不能自我删除，需要辅助节点，而双向链表，则可以自我删除；

在这里插入图片描述
上图说明：
分析 双向链表的遍历、添加、修改、删除的操作思路及代码实现

  • 遍历 和单链表一样，只是可以向前，也可以向后查找；
  • 添加（默认添加到双向链表的最后）
    • 先找到双向链表的最后这个节点
    • temp.next = newHeroNode
    • newHeroNode.pre = temp;
  • 修改 思路和单链表一样
  • 删除
    • 双向链表可以实现自我删除
    • temp.pre.next = temp.next
    • temp.next.pre = temp.pre

代码实现

package com.lele.linkedlist;

/**
 * author: hwl
 * date: 2020/9/23 6:56
 * version: 1.0.0
 * modified by:
 * description:
 */
public class DoubleLinkedListDemo {
    public static void main(String[] args) {
        // 测试
        System.out.println("双向链表的测试");
        //先创建节点
        HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨");
        HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟");
        HeroNode2 hero3 = new HeroNode2(3, "吴用", "智多星");
        HeroNode2 hero4 = new HeroNode2(4, "林冲", "豹子头");
        // 创建一个双向链表
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);

        doubleLinkedList.list();

        // 修改
        HeroNode2 heroNode2 = new HeroNode2(4, "公孙胜", "入云龙");
        doubleLinkedList.update(heroNode2);
        System.out.println("修改后的链表情况");
        doubleLinkedList.list();

        // 删除
        doubleLinkedList.del(3);
        System.out.println("删除后的链表情况");
        doubleLinkedList.list();
    }
}

class DoubleLinkedList{
    private HeroNode2 head = new HeroNode2(0, "", "");

    /**
     *
     * @return 返回头节点
     */
    public HeroNode2 getHead() {
        return head;
    }

    /**
     * 从双向链表中删除一个节点
     * 说明
     * 1. 对于双向链表，我们可以直接找到要删除的这个节点
     * 2. 找到后，自我删除即可
     * @param no
     */
    public void del (int no) {

        // 判断当前链表是否为空
        if (head.next == null) {
            System.out.println("链表为空，无法删除");
        }

        HeroNode2 temp = head.next;  // 辅助变量（指针）
        boolean flag = false; //标志是否找到待删除节点的
        while(true) {
            if (temp == null) {  // 已经到链表的最后
                break;
            }
            if (temp.no == no) {  // 找到待删除节点的前一个节点
                flag = true;
                break;
            }
            temp = temp.next; // temp后移，遍历
        }
        // 判断flag
        if (flag) { // 找到
            // 可以删除
//            temp.next = temp.next.next;  单项链表的删除方式
            temp.pre.next = temp.next;
            // 如果是最后一个节点，就不需要执行下面这句话，否则出现空指针异常
            if(temp.next != null) {
                temp.next.pre = temp.pre;
            }
        } else {
            System.out.printf("要删除的 %d 节点不存在\n", no);
        }
    }

    /**
     * 修改一个节点的内容，可以看到双向链表的节点内容修改和单链表一样
     * 只是 节点类型改成HeroNode2
     * @param newHeroNode
     */
    public void update(HeroNode2 newHeroNode) {
        // 判断是否为空
        if (head.next == null) {
            System.out.println("链表为空~");
            return;
        }
        // 找到需要修改的节点，根据no编号
        // 定义一个辅助变量
        HeroNode2 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);
        }
    }

    /**
     * 添加一个节点到双向链表的最后
     * @param heroNode
     */
    public void add(HeroNode2 heroNode) {
        // 因为head节点不能动，因此我们需要一个辅助变量 temp
        HeroNode2 temp = head;
        // 遍历链表，找到最后
        while(true) {
            // 找到链表的最后
            if(temp.next == null) {
                break;
            }
            // 如果没有找到最后，将temp后移
            temp = temp.next;
        }
        // 当退出while循环时，temp就指向了链表的最后
        // 形成一个双向链表
        temp.next = heroNode;
        heroNode.pre = temp;
    }

    /**
     * 显示链表（遍历）
     */
    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;
        }
    }
}

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 + '\'' +
                '}';
    }
}

5. Josephu 问题

在这里插入图片描述
Josephu问题：设编号为1,2,3,…n的n个人围坐一圈，约定编号为k（1<=k<n）的人从1开始报数，数到m的那个人出列，她的下一位又从1开始报数，数到m的那个人又出列，依此类推，直到所有人出列为止，由此产生一个出队编号的序列。

提示：用一个不带头节点的循环链表来处理Josephu问题，先构成一个有n个节点的单循环链表，然后由k节点起从1开始计数，计到m时，对应节点从链表删除，然后再从被删除节点的下一个节点又从1开始计数，直到最后一个节点从链表中删除，算法结束。
在这里插入图片描述
在这里插入图片描述
代码实现

package com.lele.linkedlist;

/**
 * author: hwl
 * date: 2020/9/25 7:23
 * version: 1.0.0
 * modified by:
 * description: 约瑟夫问题
 */
public class Josephu {
    public static void main(String[] args) {

        // 测试构建环形链表及遍历
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5); // 添加小孩节点
        circleSingleLinkedList.showBoy();

        // 测试 小孩出圈
        circleSingleLinkedList.countBoy(1,2,5); // 2,4,1,5,3

    }
}

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

    // 添加小孩节点，构建成一个环形链表
    public void addBoy(int nums) {
        // num 做一个数据校验
        if (nums < 1) {
            System.out.println("nums 的值不正确");
            return;
        }
        Boy curBoy = null; // 辅助指针，帮助构建环形链表
        // 使用for来创建我们的环形链表
        for (int i = 1; i <= nums; i++) {
            // 根据编号，创建小孩节点
            Boy boy = new Boy(i);
            if (i == 1) {
                first = boy;
                first.setNext(first); //构成环
                curBoy = first;// 让curBoy指向第一个小孩
            } else {
                curBoy.setNext(boy);
                boy.setNext(first);
                curBoy = boy;
            }
        }
    }

    // 遍历当前的环形链表
    public void showBoy() {
        // 判断链表是否为空
        if (first == null) {
            System.out.println("没有任何小孩~~");
            return;
        }
        // 因为first不能动，因此我们仍然使用一个辅助指针完成遍历
        Boy curBoy = first;
        while(true) {
            System.out.printf("小孩的编号 %d\n", curBoy.getNo());
            if (curBoy.getNext() == first) { // 说明已经遍历完毕
                break;
            }
            curBoy = curBoy.getNext();// curBoy 后移
        }
    }

    /**
     * 根据用户的输入，计算出小孩出圈的顺序
     * @param startNo  从第几个小孩开始数数
     * @param countNum  表示数几下
     * @param nums  表示最初由多少小孩在圈中
     */
    public void countBoy(int startNo, int countNum, int nums) {
        // 先对数据进行校验
        if (first == null || startNo < 1 || startNo > nums) {
            System.out.println("参数输入有误，请重新输入");
            return;
        }
        // 创建 辅助指针，帮助完成小孩出圈
        Boy helper = first;
        // 需求创建一个辅助指针（变量）helper,事先应该指向环形链表的最后这个节点
        while (true) {
            if (helper.getNext() == first) { // 说明helper指向最后小孩节点
                break;
            }
            helper = helper.getNext();
        }
        // 小孩报数前，先让 first 和 helper 移动 k-1 次
        for (int j = 0; j < startNo - 1; j++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        // 当小孩报数时，让 first 和helper 指针同时的移动 m-1 次，然后出圈
        // 这是一个循环操作，直到圈中只有一个节点
        while(true) {
            if (helper == first) { // 说明圈中只有一个节点
                break;
            }
            // 让 first 和 helper 指针同时移动 countNum-1
            for (int j = 0; j < countNum - 1; j++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            // 这时 first 指向的节点，就是要出圈的小孩节点
            System.out.printf("小孩 %d 出圈\n", first.getNo());
            // 这时将first指向的小孩节点出圈
            first = first.getNext();
            helper.setNext(first);
        }
        System.out.printf("最后留在圈中的小孩编号 %d\n", first.getNo());
    }
}

// 创建一个Boy类，表示一个节点
class Boy {
    private int no; // 编号
    private Boy next; // 指向下一个节点，默认null

    public Boy(int no) {
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Boy getNext() {
        return next;
    }

    public void setNext(Boy next) {
        this.next = next;
    }
}
红枫忆梦
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数据结构 双向链表
zy0303的博客
11-14 347
java数据结构 尚硅谷双向链表
R语言实现循环loop的函数解读（带练习）
Kidpea LAU ' BLOG
09-18 1万+
循环在处理数据的时候非常重要，但不得不说写function的时候还是得绕不少弯路，好在现在R语言有非常多函数可以直接使用，带来不少便利。在学习写looping function 的时候，可以先熟练掌握了以下向量化操作apply、tapply、lapply、sapply、mapply的函数，然后再自己尝试写自己的： lapply lapply(X,FUN,...) ,注意：若X不是列表，但会...
Java数据结构与算法------单链表
LanceHang的博客
07-04 173
相比于数组与队列，链表是一个非连续、非顺序的存储结构。 链表是以结点的方式来存储的（链式存储） 每个结点都包含存储数据元素的数据域（data域），存储下一个结点地址的指针域（next域） 链表的各个结点不一定是连续存储的 链表分为带头结点的链表与没有头结点的链表，一般根据实际情况决定 逻辑图如下： 好了，单链表的大概结构已经了解，接下来是代码实现，这里我们以 插入梁山英雄好汉到单链表 为例： 1.首先我们要创建结点 我们需要定义一个类，包含英雄的编号，名字，昵称，以及指向下一个结点的next c
在java中使用ListNode
热门推荐
SuperHero521的博客
08-02 5万+
ListNode是由自己定义的java中的链表对象 类结构如下 public class ListNode { int val; ListNode next; public ListNode(int x){ val=x; } } 初始化时必须传值 有一列  1.给出 Input: (2 -> 4 -> 3) + (5 -> 6
Java之单链表面试题
weixin_41347226的博客
08-06 231
面试题如下: 1、实现单链表反转 2、查找单链表中的倒数第k个节点 3、实现了逆序打印的效果 //定义HeroNode , 每个HeroNode 对象就是一个节点 public class HeroNode { public int no; public String name; public String nickname; public HeroNode next;//指向下一个节点 //构造器 public HeroNode(int hNo, String hName, String hNickna
java实现链表的增删改查
new_buff_007的博客
08-05 922
实现的代码如下： 节点的定义： public class HeroNode { public int no; public String name; public String nickname; public HeroNode next; public HeroNode(int no, String name, String nickname) ...
Java数据结构-单链表
aaa13250765414的博客
07-11 177
前言 本篇文章是Java数据结构与算法系列的第三篇文章，经过前面两篇关于队列的学习之后，我们现在开始学习链表。 个人博客网站：http://lzmweb.cn，欢迎大家前来观看！ 认识链表 链表是一种常用的数据结构，它是用于存储数据的。链表，顾名思义他就是一个表，而且数据是以链式存储的，通过各个节点连接起来，这样就成了一个链表。链表是一个有序的列表，一个链表中包含很多节点，每个节点都会有自己的数据域和next指针，next指针指向下一个节点。 链表的各个节点不一定是连续存储的，它是比较抽象的，通过next指
命令替换的两种方式$()和``
Hyacinth_Dy
06-15 2717
命令替换的含义 命令替换是指将命令的输出作为命令替换的位置的文本 命令替换的一般作用是抽取一个命令的输出, 然后使用=操作赋值到一个变量供以后使用。 命令替换的两种方式 1 . ``(反引号，电脑键盘Esc下面的那个键) 2 . $()命令 $()和``两种命令替换的异同以及优缺点 ``方式 对于类似上述简单的命令来说与$（）来说没有太大
Java数据结构之单链表——day03
qq_41956078的博客
04-10 321
使用Java实现了一个最简单的链表，并提供了增删改和遍历的基本功能
面试官：讲一讲你对数据结构——数组、链表、栈、队列的理解
Java____superman的博客
06-24 354
本文已收录GitHub，更有互联网大厂面试真题，面试攻略，高效学习资料等 一、解释定义 1. 数据结构： 数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。再简单描述一下：数据结构就是描述对象间逻辑关系的学科。 如果还是不太清楚下面会举例说明的。 2. 数据存储结构： 简单的讲就是数据在计算机中的存储方式。 常用的数据存储方式有两种：顺序存储，非顺序存储。顺序存储就是把数据存储在一块联系的存储介质（硬盘或内存等）中。反之就是非顺序存储咯。Java中的数组就是典型的顺序存储，链表就是非顺序存储。.
数据结构之链表操作（单链表，单向循环链表，双向循环链表）查找节点，插入节点，删除节点，更新节点，新建节点，遍历，清空，判断空链表等操作
qq_45698138的博客
05-16 2092
一、线性表 线性表结构的数据是依次排列（一对一） （1）顺序结构：数组，顺序栈，顺序队列（顺序表） （2）链式存储：链表，链式栈，链式队列（线性表） 二、链表 2.1、链表 ​ 链表是一种具体的数据结构 ​ 1、逻辑上：一对一的排列 ​ 2、存储上：非连续的 ​ 3、算法：查找节点，插入节点，删除节点，更新节点，新建节点，遍历，清空，判断空链表等等 ​ 4、链表分类 ​ 单向链表，双向链表，单向循环链表，双向循环链表 ​ 5、链式存储特点 ​ 不需要一块连续
(java)链表中单链表、双向链表、单向环形链表的原理及例子代码
fjswcjswzy的博客
10-19 266
文章目录1 链表介绍 1 链表介绍 链表是以节点的方式来存储的，是链式存储 每个节点包含data域，next域：指向下一个节点 如下图，发现链表的各个节点不一定是连续存储的 链表分带头节点的链表和没有头节点的链表，根据实际需求来确定 ...
【数据结构】—— 3、链表和递归
theScoreONE的博客
11-02 201
【数据结构】—— 3、链表
java数据类型
闲来之笔
05-01 976
 数据类型基本有八种，其中有四个整形和两个浮点型一个表示unicode的char型和一个boolean型。整形：用于表示没有小数部分的数值，它允许为负数。 类型 存储需求 取值范围 int
Java数据结构与算法
分外蓝
03-21 228
学习总结:尚硅谷2019java数据结构和算法 线性结构和非线性结构 线性结构 是一个有序数据元素的集合。 其中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。 常用的线性结构有：线性表，栈，队列，双队列，数组，串。 特点： 1．集合中必存在唯一的一个"第一个元素"； 2．集合中必存在唯一的一个"最后的元素"； 3．除最后元素之外，其它...
二叉树（Java实现）
JiaXingNashishua的博客
05-22 1万+
声明：本文部分文章取自于 Java中关于二叉树详解_来学习的小张的博客-CSDN博客_java 二叉树原理 更多关于二叉树详情可以点击上面链接 一：树形结构 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点； 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个
Java 设计一个Hero二叉树，HeroNode. 可以向这个英雄二叉树插入不同的Hero对象，并且按照Hero的血量升排序。 随机生成10个Hero对象，每个Hero对象都有不同的血量值，插
qq_37758122的博客
07-14 590
public class Hero implements { public String name ; public float hp; public Hero(){} public Hero(String name,float hp){ this.name = name; this.hp = hp; } public String toString(){ return "name:"+name+"\t"+"hp:"+ hp+"\n"; } } package col.
Hero Node（英雄节点）一个跨公链、跨平台的DAPP开发平台
跨链技术践行者
04-07 1万+
公共节点是必然的选择。应用开发者依赖公共节点相对于传统APP开发依赖云计算，云存储。DAPP依赖的就是区块链节点和IPFS节点，而开发者自己维护这些节点又难免有中心化之嫌。区块链运营者依赖公共节点，一个公共节点友好的新链诞生，更容易获得节点矿工的支持、拥有更多的全节点，应用开发者的应用也更容易上链。 Hero Node,就是希望通过去中心化和激励机制建立一个集合公链服务，IPFS存储，可信任...
Java数据结构与算法解析：轻松掌握实践技巧
"DATA STRUCTURES AND ALGORITHMS IN JAVA 数据结构与算法分析 java版" 本书是《DATA STRUCTURES AND ALGORITHMS IN JAVA》的Java版，作者是Robert Lafore，由Sams出版社于1998年出版，共617页，ISBN号为1571690956...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值