java数据结构4：链表

最新推荐文章于 2023-08-08 15:19:15 发布
最新推荐文章于 2023-08-08 15:19:15 发布
阅读量146 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 单链表 链表 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43349162/article/details/114572003
版权

第4章：链表

1、单向链表

image-20201106212040897

image-20201106212046711

节点类

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

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}
添加节点到链表尾部

image-20201106212156969

按顺序添加节点到链表

image-20201106212348814

删除节点

image-20201106212940348

//链表操作
public class SingleLinkedList {
    private HeroNode head = new HeroNode(0, "", "");	//头节点，不存放数据

    //在尾部添加节点
    public void add(HeroNode heroNode) {
        HeroNode temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            //找到最后一个节点
            temp = temp.next;
        }
        temp.next = heroNode;
    }

    //按顺序添加节点
    public void addByOrder(HeroNode heroNode) {
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > heroNode.no) {
                break;
            } else if (temp.next.no == heroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.println("编号" + heroNode.no + "已存在");
        } else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //修改节点信息
    public void update(HeroNode heroNode) {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == heroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next.name = heroNode.name;
            temp.next.nickname = heroNode.nickname;

        } else {
            System.out.println("没有找到呢");
        }
    }

    //删除节点
    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;
        }
        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.println("不存在");
        }
    }

    //遍历
    public void list() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        HeroNode temp=head;
        while (true){
            if (temp.next==null){
                break;
            }
            System.out.println(temp.next);
            temp=temp.next;
        }
    }
}

2、单链表面试题

1. 求单链表中有效节点的个数
public int getLength(HeroNode heroNode){
    if (head.next==null){
        return 0;
    }
    int length=0;
    HeroNode temp=head;
    while (temp.next!=null){
        length++;
        temp=temp.next;
    }
    return length;
}
2. 查找单链表中的倒数第k个结点【新浪面试题】
  1. 方法传入参数head节点，倒数第index个节点
  2. getLength()获取链表总长度size
  3. 从头开始遍历size-index个
public HeroNode findLastIndexNode(HeroNode head,int index){
    if (head.next==null){
        return null;
    }
    int size=getLength(head);
    
    if (index<=0||index>size){
        System.out.println("输入错误");
    }

    HeroNode temp=head.next;
    //遍历size-index个
    for (int i = 0; i < size-index; i++) {
        temp=temp.next;
    }
    return temp;
}

当size=5，index=2（倒数第二个）时，size-index=3

3. 单链表的反转【腾讯面试题】
  1. 新建一个头节点，即新链表
  2. 遍历旧链表，每遍历到一个就放在新链表的最前面，紧跟新链表头节点后面
  3. 最后旧链表头节点指向新链表头节点.next

image-20201106213442769

image-20201106213841773

public void reverseList(HeroNode head){
    //没有节点或只有一个节点
    if (head.next==null||head.next.next==null){
        return;
    }
    HeroNode temp=head.next;
    HeroNode tempNext=null;
    HeroNode reverseHead=new HeroNode(0,"","");
    
    while (temp!=null){
        tempNext=temp.next; //保存temp的下一个节点
        temp.next=reverseHead.next; //放到最前边
        
        reverseHead.next=temp;  
        temp=tempNext;  //后移
    }
    head.next= reverseHead.next;
}
4. 从尾到头打印单链表 【百度，要求方式1：反向遍历 。 方式2：Stack栈】

image-20201106213935573

使用栈

public void reversePrint(HeroNode head){
    if (head.next==null){
        return;
    }
    Stack<HeroNode> stack = new Stack<>();
    HeroNode temp=head.next;
    
    while (temp!=null){
        stack.push(temp);
        temp=temp.next;
    }
    while (stack.size()>0){
        System.out.println(stack.pop());
    }
}
5. 合并两个有序的单链表，合并之后的链表依然有序

image-20201106214047773

public HeroNode merge(HeroNode head1,HeroNode head2){
    HeroNode heroNode=new HeroNode(0,"","");
    HeroNode temp=heroNode;

    while (head1!=null&&head2!=null) {
        if (head1.no > head2.no) {
            heroNode.next = head2;		//添加小的
            heroNode = head2;			//后移
            head2 = head2.next;			//head2也后移
        } else {
            heroNode.next = head1;
            heroNode = head1;
            head1 = head1.next;
        }
    }

        if (head1!=null){
            heroNode.next=head1;
        }
        if (head2!=null){
            heroNode.next=head2;
        }
        return temp.next;
}

3、双向链表

  1. 可以双向查找
  2. 可以自主删除节点

image-20201106214534164

双向链表

  1. 遍历：和单链表一样，可以向前，也可以向后

  2. 添加：默认添加到最后

    1. 1 找到最后的节点temp

    2. 2 temp.next=newHeroNode

    3. 3 newHeroNode.pre=temp

  3. 修改：和单链表一样

  4. 删除：找到要删除节点temp

    1. 1 temp.pre.next=temp.next

    2. 2 temp.next.pre=temp.pre

删除

image-20201106214627163

//节点类
public 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;
    }

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

//双向链表
public class DoubleLinkedList {
    private HeroNode2 head = new HeroNode2(0, "", "");

    public HeroNode2 getHead() {
        return head;
    }

    //添加
    public void add(HeroNode2 heroNode) {
        HeroNode2 temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        temp.next = heroNode;
        heroNode.pre=temp;
    }

    //按顺序添加
    public void addByOrder(HeroNode2 heroNode) {
        HeroNode2 temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > heroNode.no) {
                break;
            } else if (temp.next.no == heroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.println("编号" + heroNode.no + "已存在");
        } else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //修改
    public void update(HeroNode2 heroNode) {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        HeroNode2 temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp == null) {
                break;
            }
            if (temp.no == heroNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {     //找到了
            temp.name = heroNode.name;
            temp.nickname = heroNode.nickname;

        } else {
            System.out.println("没找到呢");
        }
    }

    //删除
    public void del(int no) {

        if (head.next==null){
            System.out.println("空");
            return;
        }

        HeroNode2 temp = head.next;
        boolean flag = false;

        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.no == no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
            if (temp.next!=null){   //不是最后一个节点时执行
                temp.next.pre=temp.pre;

            }
        } else {
            System.out.println(no+"不存在");
        }
    }

    //遍历
    public void list() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        HeroNode2 temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            System.out.println(temp.next);
            temp = temp.next;
        }
    }


}

4、单向环形链表

约瑟夫问题：数到的那个人出队列

image-20201106220727142

创建环形链表思路

image-20201106220916899

添加小孩

image-20201106221051938

出队列思路

image-20201106221011970

出队列

image-20201106221104999

节点类

public class Boy {
    private int no;
    private Boy next;

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

public class CircleSingleLinkedList {
    private Boy first=null;

    //添加nums:一共多少个boy
    public void addBoy(int nums){

        if (nums<1){
            System.out.println("小孩个数不能小于1");
            return;
        }
        Boy temp=null;
        for (int i = 1; i <= nums; i++) {
            Boy boy=new Boy(i);

            if (i==1){
                first=boy;
                first.setNext(first);   //形成环
                temp=first;
            }else {
                temp.setNext(boy);
                boy.setNext(first);
                temp=boy;
            }
        }
    }
    
	 //遍历
    public void showBoy(){ 
        if (first==null){
            System.out.println("空");
            return;
        }
        Boy temp=first;
        while (true){
            System.out.println("小孩："+temp.getNo());
            if (temp.getNext()==first){
                break;
            }
            temp=temp.getNext();
        }
    }

    //出圈(开始位置，数几下，多少个小孩)
    public void countBoy(int startNo,int countNum,int nums){
        if (first==null||startNo<1||startNo>nums){
            System.out.println("参数错误");
            return;
        }
        Boy temp=first;
        while (true){   //让temp指向最后一个节点，即first的后面
            if (temp.getNext()==first){
                break;
            }
            temp=temp.getNext();
        }

        for (int i = 0; i < startNo-1; i++) {   //定位到开始计数的位置
            first=first.getNext();
            temp=temp.getNext();

        }

        while (true){
            if (temp==first){   //只一个
                break;
            }

            for (int i = 0; i < countNum-1; i++) {
                first=first.getNext();
                temp=temp.getNext();
            }
            System.out.println("出圈小孩："+first.getNo());
            first=first.getNext();     //当前first为要出圈的孩子，移动后直接让temp的next指向它
            temp.setNext(first);
        }
        System.out.println(first.getNo()+"为最后一个");
    }
}

        for (int i = 0; i < startNo-1; i++) {   //定位到开始计数的位置
            first=first.getNext();
            temp=temp.getNext();

        }

        while (true){
            if (temp==first){   //只一个
                break;
            }

            for (int i = 0; i < countNum-1; i++) {
                first=first.getNext();
                temp=temp.getNext();
            }
            System.out.println("出圈小孩："+first.getNo());
            first=first.getNext();     //当前first为要出圈的孩子，移动后直接让temp的next指向它
            temp.setNext(first);
        }
        System.out.println(first.getNo()+"为最后一个");
    }
}
植树chen
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java数据结构之简单链表的定义与实现方法示例
08-29
主要介绍了Java数据结构之简单链表的定义与实现方法,简单描述了链接的概念、原理,并结合实例形式分析了java定义与使用链表的相关步骤与操作技巧,需要的朋友可以参考下
Java数据结构-链表(LinkedList)(四)
weixin_45987961的博客
10-28 337
方式三、 什么是链表 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）； 顺序表的构建需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁，所以使用起来并不是很灵活； 链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。 1. 单向链表 单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元
java链表实现三维数组_java – 多维四向链表
weixin_39772651的博客
02-25 634
好的..所以我决定尝试使用Java中的链表,而不是通常用于引用指针的C语言.遍历可以是中心节点的向上,向下,向左,向右.对于角落中的节点,它们只移动两个方向,边缘上的节点可以移动3个方向.所有其他方向可以移动4个.问题：当我的程序离开构造函数时,我的节点以某种方式被删除：S当我使用get / set时,它不能遍历链接,因为它们是null.除了第一个节点.我的节点是：package linkedli...
java链表的结构_四种常见链表结构的Java实现
weixin_39725154的博客
02-12 440
之前有的细节没写好，重新调整下。1.单链表：当前结点只存储了后续结点引用，相对双向链表而言，空间复杂的较好。/*** 单向链表* @author RippleChan* @date 2018/3/28*/public class Linked {private static class Node{private E item;private Node next;Node(E data, Node ...
java数据结构 二(单链表)
u011153869的专栏
04-30 548
package com; import java.util.HashMap; /** 单链表 * 插入删除快,读取慢， * 让每个元素知道下个元素位置（内存地址） */ public class LinearTable { Entry table; public LinearTable(){ table =new Entry(); } class Entry{
Java数据结构和算法(二)之链表
weixin_44916936的博客
05-31 182
文章目录四、链表（Linked List）4.1 单链表4.1.1 不考虑排名，直接添加到最后4.1.2 考虑排名添加英雄4.1.3 单向链表的修改4.1.4 单向链表的删除4.1.5 单链表面试题4.2 双向链表4.3 单向环形链表 四、链表（Linked List） 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 4.1 单链表 使用带head头的单向链
Java数据结构篇-链表与数组实现栈.pptx.pptx
12-19
数据结构的定义 数据结构是计算机存储、组织数据的方式，用于高效地访问和修改数据。...Java提供了丰富的数据结构库，包括数组、链表、栈、队列等，这些数据结构为程序员提供了处理各种问题的工具和方法。
Java数据结构之双端链表原理与实现方法
08-29
主要介绍了Java数据结构之双端链表原理与实现方法,简单描述了双端链表的概念、原理并结合实例形式分析了java实现双端链表的相关操作技巧,需要的朋友可以参考下
Java-数据结构课设-链表实现通讯录管理系统
10-07

　第四个模块——Create()的功能是：创建新的数据记录。 
　第五个模块——Add()的功能是：增加新的数据记录，并返回选单。 
　第六个模块——Find()的功能是：按要求查询相关的信息，如果找到了，则显示该信息...
java链表是一种数据结构.docx
最新发布
03-13
链表
JAVA中用代码实现一个链表结构
步城曦
04-05 741
首先我们简单的解释一下这个链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一...
Java单链表的反转
Jecretariat的博客
07-25 121
节点的定义 class Node { private int Data;// 数据域 private Node Next;// 指针域 public Node(int Data) { // super(); this.Data = Data; } public int getData() { return Data; } public void setData(int Data) { this.Data = Data; } public Node getNext() {
java单链表反转
github_38395241的博客
06-17 573
java 单链表反转因为面试考到了一些算法，也都忘的差不多了，学习了单链表之后，想把内容下来。这篇文章主要介绍什么是单链表以及单链表的反转方式：链表定义：链表是一种递归的数据结构，它或者为空(null)，或者是指向一个结点(node)的引用，该结点含有一个泛型的元素和一个指向另一条链表的引用。我的理解就是：链表是由一个一个的结点组成，结点呢，是由一个元素和一个指向另一个结点的引用组成。举个例子，火车
java 单链表反转
gkmmg的博客
02-15 216
将单向链表发转方向，头变尾，尾变头，将链表调个个儿。 思路：定义三个引用，pre为上一结点，cur为当前节点，nex为下一结点。 把cur的下一节点暂存到nex中，然后将cur的下一节点指向pre，再将pre指向cur，cur指向nex。只要cur不为空，就一直如此循环。直到cur为空，即最后一个节点的next结点为空。最后再把原链表的头节点变成了尾节点，所以要把它的next节点设置为null。...
Java单链表反转
心要是孤单了，到了那里都是流浪~~~
03-09 110
data域：存储数据元素信息的域称为数据域；　next域：存储直接后继位置的域称为指针域，它是存放结点的直接后继的地址（位置）的指针域（链域）。data域+ next域：组成数据ai的存储映射，称为结点； Java代码如下 class Node{ private int data; private Node next; public Node(int data){ this.data = data; } public Node(int da
Java实现单链表反转
weixin_53390884的博客
08-08 265
使用Java将链表从 a->b->c 的状态转移为 c->b>a 并且返回新链表的头结点。
单链表反转（Java实现）
regens的博客
03-21 1554
链表反转
java实现单链表反转
是夜色太荒芜的专栏
07-25 455
实现单链表反转应该有两种思路，第一种是从首节点开始反转，一直到尾节点结束，一种是从尾节点开始反转，一直到首节点结束。 一、由首节点开始 如上图所示，首先节点1与节点2发生发反转，也就是节点2的next指向节点1，节点1因为最终会变为尾节点，所以其next置换为null，此时节点3赋值于临时变量。然后节点2与存储了节点3的临时变量发生反转。然后节点3与储存了节点4的临时变量发生发转。实现代码如
java数据结构家族族谱_java数据结构41:家谱处理
08-22
Java数据结构家族族谱中的家谱处理指的是对家谱信息进行管理和处理的操作。在家谱中，每个人都有自己的父亲和子女，因此可以通过建立家族树的方式来表示家族关系。 在Java中，我们可以使用树的数据结构来表示家族树...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值