【自学笔记】尚硅谷数据结构与算法Chapter 3 链表

最新推荐文章于 2024-10-01 22:51:02 发布
最新推荐文章于 2024-10-01 22:51:02 发布
阅读量512 收藏 1
点赞数
分类专栏： 自学笔记 文章标签： 数据结构 链表 java 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/piaji_piapia/article/details/121714688
版权

Chapter 3 链表

文章目录

3.1 链表

3.1.1 链表介绍

  • 链表以结点方式存储，存储空间不一定连续
  • 每个结点包含数据域和指针域
  • 每个结点不一定是连续存储
  • 链表有带头结点和不带头结点的，根据需求确定使用哪一种

3.1.2 链表CRUD

1、按输入顺序建立一个学生链表

/**
 * The type Single linked list.
 * @author ybs
 */
public class SingleLinkedListTest {
    public static void main(String[] args) {
        StudentNode s1 = new StudentNode(1, "jack", "c1");
        StudentNode s2 = new StudentNode(2, "york", "c1");
        StudentNode s3 = new StudentNode(3, "peter", "c1");
        StudentNode s4 = new StudentNode(4, "marry", "c1");

        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addNode(s1);
        singleLinkedList.addNode(s2);
        singleLinkedList.addNode(s3);
        singleLinkedList.addNode(s4);

        singleLinkedList.listLinkedList();
    }
}

class SingleLinkedList{
    /**
     * head 头结点
     */
    public StudentNode head = new StudentNode(0, "", "");

    public void addNode(StudentNode student){

        StudentNode temp = head;
        //找到最后一个结点
        while(true){
            if(temp.next==null) {
                break;
            }
            temp = temp.next;
        }
        temp.next=student;
    }

    public void listLinkedList(){
        if(head.next==null){
            System.out.println("空链表");
            return;
        }

        StudentNode temp = head.next;
        while(true){
            if(temp==null){
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }

}

class StudentNode{
    public int stuNo;
    public String stuName;
    public String stuClass;
    public StudentNode next;

    public StudentNode(int stuNo, String stuName, String stuClass) {
        this.stuNo = stuNo;
        this.stuName = stuName;
        this.stuClass = stuClass;
    }

    @Override
    public String toString() {
        return "Student{" +
                "stuNo=" + stuNo +
                ", stuName='" + stuName + '\'' +
                ", stuClass='" + stuClass + '\'' +
                '}';
    }
}

2、按照编号顺序建立一个学生表

/**
 * The type Single linked list.
 * @author ybs
 */
public class SingleLinkedListTest {
    public static void main(String[] args) {
        StudentNode s1 = new StudentNode(1, "jack", "c1");
        StudentNode s2 = new StudentNode(2, "york", "c1");
        StudentNode s3 = new StudentNode(3, "peter", "c1");
        StudentNode s4 = new StudentNode(4, "marry", "c1");

        SingleLinkedList singleLinkedList = new SingleLinkedList();
/*        singleLinkedList.addNode(s1);
        singleLinkedList.addNode(s2);
        singleLinkedList.addNode(s3);
        singleLinkedList.addNode(s4);*/

        singleLinkedList.addNodeByOrder(s3);
        singleLinkedList.addNodeByOrder(s1);
        singleLinkedList.addNodeByOrder(s2);
        singleLinkedList.addNodeByOrder(s4);
        singleLinkedList.addNodeByOrder(s4);

        singleLinkedList.listLinkedList();
    }
}

class SingleLinkedList{
    /*其他同1*/

    //按照序号加入链表
    public void addNodeByOrder(StudentNode student){
        StudentNode temp = head;
        boolean flag = false;//判断是否有重复的序号
        //找到插入位置
        while(true){
            if(temp.next==null){
                break;
            }
            if(temp.next.stuNo > student.stuNo){
                break;
            }else if(temp.next.stuNo == student.stuNo){
                flag=true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            System.out.printf("重复序号%d,无法加入\n",student.stuNo);
        }else{
            student.next = temp.next;
            temp.next = student;
        }
    }

}

class StudentNode{
    /*同1*/
}

3、修改链表

/**
 * The type Single linked list.
 * @author ybs
 */
public class SingleLinkedListTest {
    public static void main(String[] args) {
        StudentNode s1 = new StudentNode(1, "jack", "c1");
        StudentNode s2 = new StudentNode(2, "york", "c1");
        StudentNode s3 = new StudentNode(3, "peter", "c1");
        StudentNode s4 = new StudentNode(4, "marry", "c1");

        SingleLinkedList singleLinkedList = new SingleLinkedList();
/*        singleLinkedList.addNode(s1);
        singleLinkedList.addNode(s2);
        singleLinkedList.addNode(s3);
        singleLinkedList.addNode(s4);*/

        singleLinkedList.addNodeByOrder(s3);
        singleLinkedList.addNodeByOrder(s1);
        singleLinkedList.addNodeByOrder(s2);
        singleLinkedList.addNodeByOrder(s4);
        singleLinkedList.addNodeByOrder(s4);
		singleLinkedList.listLinkedList();
        singleLinkedList.updateNode(new StudentNode(3, "sam", "c2"));
        singleLinkedList.listLinkedList();
    }
}

class SingleLinkedList{
    /*其他同1*/

    //修改结点
    //根据要修改的结点newStudent的stuNo编号查找修改
    public void updateNode(StudentNode newStudent){
        if(head.next==null){
            System.out.println("空链表");
            return;
        }
        StudentNode temp = head.next;
        boolean flag = false;//判断是否找到序号
        while(true){
            if(temp==null){
                break;
            }
            if(temp.stuNo== newStudent.stuNo){
                flag=true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.stuName = newStudent.stuName;
            temp.stuClass = newStudent.stuClass;
        }else{
            System.out.printf("未找到序号%d的学生",newStudent.stuNo);
        }
    }

}

class StudentNode{
    /*同1*/
}

3.1.3 单链表题目

1、求单链表的有效结点个数

//获取单链表的长度
public static int getLength(StudentNode head){
    if(head.next == null){
        return 0;
    }
    int length = 0;
    StudentNode temp = head.next;
    while(temp!=null){
        length++;
        temp=temp.next;
    }
    return length;
}

2、查找单链表倒数第k个结点

//获取单链表倒数第index个元素
//1.先得到单链表目前的长度size  2.从头遍历（size-index）个
public static StudentNode getLastIndexNode(StudentNode head, int index){
    if(head.next==null || index <= 0 || index > getLength(head)){
        return null;
    }
    int size = getLength(head);
    StudentNode temp = head.next;
    for(int i=0;i<(size-index);++i){
        temp = temp.next;
    }
    return temp;
}

3、单链表反转

//反转单链表
//1.设置一个新的头结点reverseHead    2.遍历链表，每次将结点放到reverseHead的最前端  3.将原来的头结点指向新的头结点的下一个结点
public static void reverseLinkedList(StudentNode head){
    //如果为空或者只有一个结点就直接返回
    if(head.next==null||head.next.next==null){
        return;
    }
    StudentNode temp = head.next;//循环指针
    StudentNode next = null;//指向当前循环下一个的指针
    StudentNode reverseHead = new StudentNode(0, "", "");//新的头结点
    while(temp!=null){
        next = temp.next;
        temp.next = reverseHead.next;
        reverseHead.next = temp;
        temp = next;
    }
    head.next = reverseHead.next;
}

4、从尾到头打印单链表

//从尾到头打印单链表
public void reverseListLinkedList(){
    if(head.next==null){
        return;
    }
    Stack<StudentNode> stack = new Stack<>();
    StudentNode temp = head.next;
    while(temp!=null){
        stack.push(temp);
        temp = temp.next;
    }
    while(stack.size()>0){
        System.out.println(stack.pop());
    }
}

5、合并两个有序单链表，合并之后依然有序

//合并两个有序单链表，合并依然有序
public static SingleLinkedList mergeLinkedList(SingleLinkedList sglList1, SingleLinkedList sglList2){
    SingleLinkedList singleLinkedList = new SingleLinkedList();
    StudentNode list1 = sglList1.head;
    StudentNode list2 = sglList2.head;
    StudentNode newList = new StudentNode(0, "", "");
    if(list1.next==null){
        newList.next = list2.next;
        singleLinkedList.head = newList;
        return singleLinkedList;
    }else if(list2.next==null){
        newList.next  = list1.next;
        singleLinkedList.head = newList;
        return singleLinkedList;
    }
    StudentNode temp1 = list1.next;
    StudentNode temp2 = list2.next;
    StudentNode tempNewList = newList;
    while (temp1!=null && temp2!=null){
        if(temp1.stuNo< temp2.stuNo){
            tempNewList.next=temp1;
            tempNewList = tempNewList.next;
            temp1 = temp1.next;
        }else{
            tempNewList.next=temp2;
            tempNewList = tempNewList.next;
            temp2 = temp2.next;
        }
    }
    if (temp1==null){
        tempNewList.next = temp2;
    }else{
        tempNewList.next = temp1;
    }
    singleLinkedList.head = newList;
    return singleLinkedList;
}

3.2 双向链表

3.2.1 双向链表介绍

  • 单链表只能往一个方向查找，双向链表可以向前向后查找
  • 单链表的结点不能自我删除，双链表的结点可以

3.2.2 双向链表CRUD

public class DoubleLinkedListTest {
    public static void main(String[] args) {
        StudentNode2 s1 = new StudentNode2(1, "jack", "c1");
        StudentNode2 s2 = new StudentNode2(2, "york", "c1");
        StudentNode2 s3 = new StudentNode2(3, "peter", "c1");
        StudentNode2 s4 = new StudentNode2(4, "marry", "c1");
        StudentNode2 s5 = new StudentNode2(5, "sam", "c2");

        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        doubleLinkedList.addNode(s1);
        doubleLinkedList.addNode(s2);
        doubleLinkedList.addNode(s3);
        doubleLinkedList.addNode(s4);
        doubleLinkedList.addNode(s5);

        //doubleLinkedList.updateNode(new StudentNode2(3, "peter", "c2"));
        //doubleLinkedList.deleteNode(3);
        doubleLinkedList.listLinkedList();

    }
}

class DoubleLinkedList{
    /**
     * head 头结点
     */
    public StudentNode2 head = new StudentNode2(0, "", "");

    public void addNode(StudentNode2 student){

        StudentNode2 temp = head;
        //找到最后一个结点
        while(true){
            if(temp.next==null) {
                break;
            }
            temp = temp.next;
        }
        temp.next=student;
        student.previou = temp;
    }

    public void listLinkedList(){
        if(head.next==null){
            System.out.println("空链表\n");
            return;
        }

        StudentNode2 temp = head.next;
        while(true){
            if(temp==null){
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }

    //删除结点
    //根据编号删除结点
    public void deleteNode(int stuNo){
        StudentNode2 temp = head.next;
        boolean flag = false;//判断是否找到该结点
        while(true){
            if(temp==null){
                break;
            }
            if(temp.stuNo==stuNo){
                flag=true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.next.previou = temp.previou;
            temp.previou.next = temp.next;
        }else{
            System.out.printf("未找到编号为%d的结点",stuNo);
        }
    }

    //修改结点
    //根据要修改的结点newStudent的stuNo编号查找修改
    public void updateNode(StudentNode2 newStudent){
        if(head.next==null){
            System.out.println("空链表");
            return;
        }
        StudentNode2 temp = head.next;
        boolean flag = false;//判断是否找到序号
        while(true){
            if(temp==null){
                break;
            }
            if(temp.stuNo== newStudent.stuNo){
                flag=true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.stuName = newStudent.stuName;
            temp.stuClass = newStudent.stuClass;
        }else{
            System.out.printf("未找到序号%d的学生",newStudent.stuNo);
        }
    }
}

class StudentNode2 {
    public int stuNo;
    public String stuName;
    public String stuClass;
    public StudentNode2 next;
    public StudentNode2 previou;

    public StudentNode2(int stuNo, String stuName, String stuClass) {
        this.stuNo = stuNo;
        this.stuName = stuName;
        this.stuClass = stuClass;
    }

    @Override
    public String toString() {
        return "Student{" +
                "stuNo=" + stuNo +
                ", stuName='" + stuName + '\'' +
                ", stuClass='" + stuClass + '\'' +
                '}';
    }
}

3.3 循环链表和约瑟夫问题

3.3.1 单向环形链表的应用场景

Josephu(约瑟夫、约瑟夫环)问题

image-20211203145828635

3.3.2 单向环形链表的构建与遍历

1、构建思路

先创建一个first结点，并形成环形，每增加一个新的结点，就把该结点加入已有的环形链表中

2、遍历思路

先让一个辅助指针cur指向first，然后通过while遍历环形链表，当cur.next=first时结束

3、实现

public class JosephuProblemTest {
    public static void main(String[] args) {
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addGirl(5);
        circleSingleLinkedList.listGirls();
    }
}

class CircleSingleLinkedList{
    public Girl first = null;

    public CircleSingleLinkedList(){}

    public void addGirl(int num){
        if (num<1){
            System.out.println("num不符合");
            return;
        }
        Girl curGirl = null;
        for(int i=1;i<=num;++i){
            Girl girl = new Girl(i);
            if (i==1){
                first = girl;
                curGirl = first;
                girl.setNext(first);
            }else{
                curGirl.setNext(girl);
                girl.setNext(first);
                curGirl = girl;
            }
        }
    }

    public void listGirls(){
        if (first==null){
            System.out.println("空表");
            return;
        }
        Girl curGirl = first;
        while(true){
            System.out.println("Girl "+curGirl.getId());
            if(curGirl.getNext()==first){
                break;
            }
            curGirl = curGirl.getNext();
        }
    }
}

class Girl{
    private int id;
    private Girl next;

    public Girl(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Girl getNext() {
        return next;
    }

    public void setNext(Girl next) {
        this.next = next;
    }
}

3.3.3 约瑟夫问题实现

思路：n 一共有几个人; k 表示从第k个人开始报数; m 表示每次数几个数

  1. 需要创建一个辅助指针helper，事先应该指向环形链表的最后一个结点
  2. 报数前，让 first 和 helper 同时移动 k-1 次
  3. 报数时，让 first 和 helper 同时移动 m-1 次
  4. 此时 first 指向的结点出圈
/**
     * 约瑟夫问题实现
     *
     * @param startId  表示从第几个开始数数
     * @param countNum 表示每次数到几出圈
     * @param sumNum   表示最初有多少小孩
     */
public void josephuCountGirl(int startId,int countNum,int sumNum){
    if (first==null || startId < 1 || startId > sumNum){
        System.out.println("链表或输入异常");
        return;
    }
    Girl helper = first;
    //将helper移动到最后一个结点
    while(true){
        if(helper.getNext()==first){
            break;
        }
        helper = helper.getNext();
    }
    //将first移动到起始结点，helper移动到first的前一个结点
    for(int i=0;i<startId-1;++i){
        first = first.getNext();
        helper = helper.getNext();
    }
    //数数，出圈
    while(true){
        //first==helper时，说明圈内只剩下一个结点，跳出
        if (first==helper){
            break;
        }
        //数数
        for (int i=0;i<countNum-1;++i){
            first = first.getNext();
            helper = helper.getNext();
        }
        System.out.printf("%d出圈\n",first.getId());
        first = first.getNext();//first移动到出圈结点的下一个结点
        helper.setNext(first);//helper.next指向first，出圈结点被移出链表
    }
    System.out.printf("最后剩下%d\n",first.getId());
}
piaji_piapia
关注
专栏目录
算法自学笔记：符号表（2）基础实现
Raine_Yang的博客
01-20 610
符号表有两个基础的实现方法，简单易行，但是性能较差 1 链表实现 以链表储存符号表，每一个链表储存一个键及对应值。 查找：从头遍历链表，直到找到目标键，读取对应值。时间复杂度O(N) 插入：从头找到末尾，插入新的键-值对。时间复杂度O(N) 2 数组实现 数组支持随机访问。因此如果数组各元素有序排布可以使用二分查找进行快速查找 该方法构建两个等大数组分别储存键与值，每一个键和其对应的值在数组里索引相同 查找：使用二分查找找出键对应索引，根据索引在值数组里查到目标值，时间复杂度O(logN) 插入：添加一个键
Teddy van Jerry 的导航页
Teddy van Jerry的博客
08-28 2336
C++ 的学习经历 C++ 的下载 下载 C++ (Visual Studio 2019) 的步骤 C++ Primer(5th Edition) 【C++ Primer(5th Edition) Exercise】练习程序 - Chapter1（第一章） 【C++ Primer(5th Edition) Exercise】练习程序 - Chapter2（第二章） 【C++ Primer(5th Edition) Exercise】练习程序 - Chapter3（第三章） 【C++ Primer(5th E
【自学笔记】尚硅谷数据结构与算法Chapter 1 数据结构与算法概述
piaji_piapia的博客
12-04 389
根据尚硅谷韩顺平老师的java数据结构与算法课程记录下来的自学笔记
【自学笔记】尚硅谷数据结构与算法Chapter 4 栈
piaji_piapia的博客
12-08 607
根据尚硅谷韩顺平老师的java数据结构与算法课程记录下来的自学笔记
【自学笔记】尚硅谷数据结构与算法Chapter 2 稀疏数组和队列
piaji_piapia的博客
12-04 708
根据尚硅谷韩顺平老师的java数据结构与算法课程记录下来的自学笔记
【JavaSE进阶(下)】自学笔记 记得收藏时时回顾
改变的博客
04-04 570
Java;JavaSE;JavaSE进阶;基础自学笔记;
Jupyter/IPython笔记本集合 !（附大量资源链接）-上篇
乐乐老师的博客
04-23 2605
针对某个主题的书籍或其他笔记本大集合 •入门教程 •编程与计算机科学 •统计学，机器学习和数据科学 •数学，物理，化学，生物学 •地球科学和地理空间数据 •语言学与文本挖掘 •信号处理 •工程教育 使用SciPy Stack进行科学计算和数据分析 •科学计算的一般主题 •社交数据 •心理学和神经科学 •机器学习，统计和概率 •物理，化学和生物学 •经济与金融 •地球科学和地理空间数据 •数...
我们为你精选了一份Jupyter/IPython笔记本集合 !（附大量资源链接）-上篇
THU数据派
04-23 2981
作者：Hans Fangohr翻译：顾宇华本文约12000字，建议阅读45+分钟。本文介绍了一些有趣的Jupyter/IPython笔记本。目录1.针对某个主题的书籍或...
Python自然语言处理学习笔记(2)：Preface 前言
weixin_33688840的博客
06-27 596
Updated 1st:2011/8/5 Updated 2nd:2012/5/14  中英对照完成     Preface 前言 This is a book about Natural Language Processing. By “natural language” we mean a language that is used for everyday communicatio...
尚硅谷老韩java版算法和数据结构讲解代码笔记整理.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。C语言因其高效、底层特性，常被用于实现数据结构和算法，使得程序更接近硬件，性能更优。本资源"数据结构与算法分析--C语言描述"是针对数据...
Java 数据结构与算法 （尚硅谷Java数据结构与算法）笔记目录
小白鼠丶
08-08 9810
红色的表示重要，绿色的表示暂时还不懂而且很重要 线性结构和非线性结构 队列 顺序队列 循环队列 链表 链表(Linked List)介绍 链表是有序的列表，但是它在内存中是存储如下 小结: 1) 链表是以节点的方式来存储,是链式存储 2)每个节点包含 data 域， next 域：指向下一个节点. 3)如图：发现链表的各个节点不一定是连续存储. 4)链表分带头节点...
【高阶数据结构】平衡二叉树(AVL)的删除和调整
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
09-26 977
平衡二叉树节点的删除方法详细讲解；平衡二叉树的删除代码实现(C++);
数据结构-3.8.栈在括号匹配中的应用
ADCvbV的博客
10-01 252
把左括号依次压入栈中，越往后压入栈的左括号越先被匹配即被弹出栈->先进后出，后进先出当遇到左括号就压入栈中，当遇到右括号就把栈顶的左括号弹出，检查该右括号和左括号是否匹配当遇到一个不匹配的就停止压入栈，因为之后的括号必定都不匹配。其中Y代表Yes，N代表No1.对于bracketCheck函数，形参str[]是传入的一个字符串，length是该字符串的长度；字符topElem代表栈顶元素；return StackEmpty(S)如果是return false说明栈不为空，则左括号单身；创建栈顶元素topEl
数据结构-3.10.队列的应用
最新发布
ADCvbV的博客
10-01 195
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
单链表的增删改查（数据结构）
m0_62048999的博客
09-29 1135
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
动态顺序表的增删改查（数据结构）
m0_62048999的博客
09-28 1191
顺序表是数据结构的基础知识，通过学习次内容，可以让我们了解顺序表中数据中是如何进行存储，删除，插入数据的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值