02-数据结构与算法-单向链表

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

3、链表

3.1 概念介绍

​ 链表是一种有序的线性数据结构，其在内存中的存储不是连续的，存储结构如下：

在这里插入图片描述

  • 链表是以节点的方式来存储数据的，是一种线性的链式存储结构

  • 链表分为带头结点和不带头结点两种

  • 链表的每个节点包含一个data域和一个next域

    • data域用来存储数据
    • next用来存储下一个节点在内存中的位置

  • 单向带头结点的链表，头结点不存在数据，只有指向第一个元素的地址：

在这里插入图片描述

3.2 单向链表实例

​ 使用带头结点head的单向链表实现：英雄排行榜管理

英雄类包括属性编号(no)，姓名(name)，绰号(nickName)，完成对英雄的增删改查

  1. 英雄类：
package com.kevin.singleListDemo;

/**
 * @author : kevin ding
 * @date : 2022/2/14 22:27
 * @description : 定义一个类来管理英雄节点
 */
public class HeroNode {
    public int no;
    public String name;
    public String nickName;
    public HeroNode next;

    // 构造器
    public HeroNode(){

    }

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

链表增删改查的思路：

  1. 链表的添加操作(假定在链表的尾部添加数据)：

定义临时节点tempNode，初始化指向headNode，开始遍历链表,直到遍历到链表的末尾，将新的节点添加到末尾：tempNode.next=newHeroNode

  1. 根据编号进行添加（当需要插入的节点编号存在时，插入失败，并提示），最后使得整个链表的所有节点按编号有序：

    思路：首先找到新添加的节点的位置，使得tempNode指针，需要指向带插入位置的前一个；使得newHeroNode.next = tempNode.next,tempNode.next = newHeroNode

  2. 修改指定节点的内容，若无指定的节点编号，给出提示

首先tempNode节点指针找到指定的节点，随后，将该节点的属性值进行修改

  1. 删除指定节点：

需要定义临时节点指针tempNode指向找待删除节点的前一个节点，tempNode.next= tempNode.next.next

单向链表整体增删改查功能的代码：

package com.kevin.singleListDemo;
/**
 * @author : kevin ding
 * @date : 2022/2/14 22:04
 * @description : 单链表的类
 */
public class SingleLinkedList {
    // 首先给链表初始化一个头结点
    private HeroNode headNode = new HeroNode();

    // 方法 addNode 添加节点：(默认往队尾添加)
    // 对于给定的节点，找到链表的队尾，将给定的节点插入
    public void addNode(HeroNode heroNode){
        // 因为头结点headNode不能移动，需要一个辅助节点(默认初始指向头结点)进行移动，找到最后一个节点
        HeroNode tempNode = headNode;
        // 开始遍历链表找到链表的最后一个节点
        while (true){
            if(tempNode.next == null){
                break;
            }
            tempNode = tempNode.next;
        }
        // 退出循环时，tempNode指向最后一个节点.让其next指向新加的heroNode即可
        tempNode.next = heroNode;
    }

    // 方法 按照节点编号进行添加，当该节点存在时，提示添加失败
    public void addNodeByOrder(HeroNode heroNode){
        // 因为头结点不能动，所以需要定义临时节点变量，来移动
        HeroNode tempNode = headNode;
        // 定义一个标记变量，来判断当前节点的no是否存在于链表中，默认false。如果存在则添加失败
        boolean flag = false;
        // 开始进行遍历
        while (true){
            // 如果遍历到最后，则直接返回
            if(tempNode.next == null){
                break;
            }
            // 如果当前节点的下一个节点的no值大于待插入的节点，则找到了正确的位置
            if(tempNode.next.no > heroNode.no){
                break;
            }else if(tempNode.next.no == heroNode.no){
                // 如果相等，表示当前节点编号已经存在于链表中,将标记位置为true
                flag = true;
                break;
            }
            tempNode = tempNode.next;
        }
        // 循环结束，此时temp节点的下一个即为带插入的位置
        // 当flag为true时不能插入
        if(flag){
            System.out.println("当前节点"+ tempNode.no+ "已经存在，不能重复添加......");
        }else {
            // 插入到tempNode的后面即可
            heroNode.next = tempNode.next;
            tempNode.next = heroNode;
        }
    }


    // 遍历链表的所有节点：
    public void showAllNodes(){
        // 首先判断链表是否为空，如果为空直接返回
        if(headNode.next == null){
            System.out.println("链表为空......");
            return;
        }
        // 头结点不能动，需要指定一个辅助节点，因为已经判断过head。next不为空，则初始指向头结点的next，即第一个元素
        HeroNode tempNode = headNode.next;
        // 循环遍历所有节点，并显示即可
        while (true){
            // 每次针对当前节点判断其是否为空即可
            if(tempNode == null){
                break;
            }
            // 当前节点不为空，将其打印出来，并将指针后移
            System.out.println("当前节点的英雄为：" + tempNode);
            tempNode = tempNode.next;
        }
    }


    // 修改列表中指定节点的值
    public void  updateNode(HeroNode heroNode){
        // 首先判断链表是否为空
        if(headNode.next == null){
            System.out.println("链表为空......");
            return;
        }
        // 定义一个临时节点，指向第一个节点元素
        HeroNode tempNode = headNode.next;
        // 遍历找到节点
        boolean flag = false;
        while (true){
            if(tempNode == null){
                break;
            }
            if(tempNode.no == heroNode.no){
                flag = true;
                break;
            }
            // 千万不能忘记将节点后移
            tempNode = tempNode.next;
        }
        if(flag){
            // 表示找到了该节点，进行更新操作
            tempNode.name = heroNode.name;
            tempNode.nickName = heroNode.nickName;
        }else {
            // 链表中没有指定的节点
            System.out.println("链表中没有指定的节点：" + heroNode.no);

        }
    }

    // 删除指定编号的节点
    public void deleteNode(int no){
        // 首先判断节点是否为空
        if(headNode.next == null){
            System.out.println("链表为空......");
            return;
        }
        // 头结点不能动，需要定义临时节点，找到待删除节点的前一个节点
        HeroNode tempNode = headNode;
        boolean flag = false;
        while(true){
            if(tempNode.next == null){
                // 遍历到了链表我的最后一个位置
                break;
            }
            if(tempNode.next.no == no){
                // 找到了待删除的节点
                flag = true;
                break;
            }

            tempNode = tempNode.next;
        }

        // 退出循环后，判断是否找到
        if(flag){
            //进行删除操作
            tempNode.next = tempNode.next.next;
        }else {
            // 没有找到待删除的节点
            System.out.println("没有找到待删除的节点：" + no);
        }
    }



}

测试验证：

package com.kevin.singleListDemo;

/**
 * @author : kevin ding
 * @date : 2022/2/14 22:24
 * @description : 单向链表的测试类
 */
public class SingleLinkedListTestDemo {
    public static void main(String[] args) {
        // 首先创建一些节点：
        HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode heroNode2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode heroNode3 = new HeroNode(3, "吴用", "智多星");
        HeroNode heroNode4 = new HeroNode(4, "林冲", "豹子头");
        HeroNode heroNode5 = new HeroNode(5, "鲁智深", "花和尚");
        HeroNode heroNode6 = new HeroNode(4, "鲁智深2", "花和尚2");

        // 创建一个空的单链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addNodeByOrder(heroNode1);
        singleLinkedList.addNodeByOrder(heroNode5);
        singleLinkedList.addNodeByOrder(heroNode2);
        singleLinkedList.addNodeByOrder(heroNode4);
        singleLinkedList.addNodeByOrder(heroNode3);

        // 显示列表
        singleLinkedList.showAllNodes();

        singleLinkedList.addNodeByOrder(heroNode6);


        // 修改链表
        singleLinkedList.updateNode(new HeroNode(3, "吴用~", "智多星..." ));

        // 修改后链表的显示
        System.out.println("修改后链表的显示。。。。。。。。");
        singleLinkedList.showAllNodes();

        singleLinkedList.updateNode(new HeroNode(7, "...", "===="));

        // 删除指定的链表
        singleLinkedList.deleteNode(4);
        System.out.println("删除节点之后遍历================");
        singleLinkedList.showAllNodes();

        System.out.println("删除节点之后遍历================");
        singleLinkedList.deleteNode(5);
        singleLinkedList.showAllNodes();

        System.out.println("删除节点之后遍历================");
        singleLinkedList.deleteNode(1);
        singleLinkedList.showAllNodes();


    }
}

3.3 单向链表的常见面试题

3.3.1 求链表有效元素的个数

思路：给定链表，当链表为空时，直接返回0；否则指定一个临时节点tempNode指针（初始化为第一个节点），和一个计数变量（初始化为0）,若当前节点不为空，则技术变量+1，节点指向后移一位；

代码实现：

// 获取链表有效元素的个数
public int getValidNums(){
    // 当链表为空的时候，直接返回0
    if (headNode.next == null){
        System.out.println("链表为空....");
        return 0;
    }
    // 当链表不为空的时候，因为链表的头部不能动，指定一个临时节点变量，进行元素的遍历，
    // 定义计数变量
    int count = 0;
    HeroNode tempNode = headNode.next;
    while(tempNode != null){
        // 当前节点不为空，则count加1，tempNode后移
        count += 1;
        tempNode = tempNode.next;
    }

    // 当循环退出时，表明当前指向节点为null，遍历结束
    return count;
}
3.3.2 查找链表中的倒数第k个节点
  1. 思路1：
  • 首先求取链表的有效元素个数n，和k进行比较进行参数校验（0<k<=n）
  • 定义tempNode节点指向头结点后的第一个节点，使得tempNode向后移动n-k次，
  • 此时tempNode指向的节点即为倒数第k个节点

代码实现：

//获取倒数第k个节点
public HeroNode getLastKthNode(int k){
    // 如果链表为空;
    if (headNode.next == null){
        System.out.println("链表为空...");
        return null;
    }
    // 获取链表的有效元素个数
    int size = getValidNums();
    // 对输入参数进行校验：
    if( k <= 0 || k > size){
        System.out.println("输入参数k值有误...");
        return null;
    }
    // 临时节点，初始化指向第一个元素
    HeroNode tempNode = headNode.next;
    // 遍历size-k次，
    for (int i = 0; i < size - k; i++) {
        tempNode = tempNode.next;
    }
    // 当循环结束时，tempNode指向的即为倒数第k个节点
    return tempNode;
}
  1. 思路2：
  • 首先对k值进行校验，判断链表是否为空
  • 定义两个指针节点，初始化指向第一个节点，先让right节点走k-1步，若在此期间到达了末尾，则链表长度小于k
  • 走了k-1步之后，left指针和right同时移动，当right指向最后一个节点时，此时left指向了倒数第k个节点

代码实现：

// 获取倒数第k个节点的第二种解法
public HeroNode getLastKthNode2(int k){
    // 首先判空
    if (headNode.next == null){
        System.out.println("链表为空...");
        return null;
    }
    // 验证k的有效性
    if (k <= 0){
        System.out.println("输入参数k值有误...");
        return null;
    }
    // 定义两个临时节点leftNode 和rightNode 初始化均指向第一个节点位置
    // 让rightNode先走k-1步，（在此期间如果rightNode已经指向末尾，直接返回null，说明链表长度不够）
    HeroNode leftNode = headNode.next;
    HeroNode rightNode = headNode.next;

    for (int i = 0; i < k-1 ; i++) {
        if(rightNode.next == null){
            System.out.println( k + "大于了链表的长度，无效...");
            return null;
        }
        rightNode = rightNode.next;
    }
    // 随后 两个指针同时移动，当rightNode移动到末尾时，leftNode即为倒数第k个
    while (true){
        if(rightNode.next == null){
            // 当rightNode.next指向null时，说明此时rightNode已经位于最后一个
            break;
        }else {
            //否则 需要将left和right同时后移
            leftNode = leftNode.next;
            rightNode = rightNode.next;
        }
    }
    // 当循环退出之后，此时left已经指向倒数第k个
    return leftNode;
}
3.3.3 链表的反转

思路：

  • 首先如果链表为空或者只有一个节点，则无需翻转
  • 定义新的头结点，临时变量指向原链表的头结点，对原链表进行遍历，每次遍历到的值，插入到新链表的第一个节点位置；
  • 由于原链表的当前节点插入到新链表，又不能是原链表丢失，因此需要再定义一个节点指向原链表中当前节点的下一个
  • 遍历完成，全部添加到新的链表中之后，使得原链表头结点的下一个指向当前新链表的第一个节点。

代码实现：

// 链表的翻转
public void reverseLinkedList(){
    // 边界条件判断
    if(headNode.next == null || headNode.next.next == null){
        return;
    }
    // 定义新的链表头结点，临时节点、临时节点的下一个节点
    HeroNode reversedHeadNode = new HeroNode(0,"","");
    HeroNode tempNode = headNode.next;
    HeroNode nextNode = null;
    // 遍历原链表，当前节点若不为空，就将其加入到新链表头结点的第一个元素位置
    while(tempNode != null){
        // 首先需要给nextNode赋值，指向tempNode的下一个节点
        nextNode = tempNode.next;
        // 将tempNode插入到新链表头结点的第一个元素位置(插入元素的操作)
        tempNode.next = reversedHeadNode.next;
        reversedHeadNode.next = tempNode;
        // 将tempNode后移一位,直接等于nextNode即可
        tempNode = nextNode;

    }
    // 循环退出，则表示翻转完毕，将原链表的头结点的next指向新链表头结点的next
    headNode.next = reversedHeadNode.next;
}
3.3.4 从尾到头打印单链表的元素

思路1:使用翻转链表：先翻转，遍历打印，再反转回原来的样子

代码实现：

public void reversePrintAllNodes1(){
    // 通过翻转链表实现
    if(headNode.next == null){
        System.out.println("链表为空...");
        return;
    }
    // 翻转链表
    reverseLinkedList();
    // 遍历所有节点
    showAllNodes();
    // 再将链表翻转回原样
    reverseLinkedList();
}

思路2：使用栈先进后出的特性

  • 定义栈的数据结构，存储HeroNode类型数据

  • 定义临时节点指向第一个元素，开始遍历链表，每次将元素存储到栈中

  • 链表遍历完之后，将栈中所有的元素依次弹出，即可实现反向遍历

代码实现：

public void reversePrintAllNodes(){
    // 首先判断栈是否为空
    if(headNode.next == null){
        System.out.println("栈为空");
    }
    // 定义栈的数据结构，来存储每次遍历到的数据，利用栈先进后出的特点，实现反向遍历
    Stack<HeroNode> heroNodeStack = new Stack<>();
    HeroNode tempNode = headNode.next;
    while(tempNode != null){
        heroNodeStack.push(tempNode);
        tempNode = tempNode.next;
    }
    // 循环退出时，临时节点指针指向了末尾，随后开始将stack中的元素出栈，完成反向遍历
    while(heroNodeStack.size() > 0){
        HeroNode heroNode = heroNodeStack.pop();
        System.out.println(heroNode);
    }

}
3.3.5 将两个有序的链表成一个有序链表

思路分析：

  • 首先判断给定的两个链表是否为空，若链表1为空，则将链表2即为结果；若链表2为空则链表1为结果
  • 定义2个临时节点，分别指向链表1和链表2的第一个元素，在定义临时节点指向新链表的头结点
  • 循环遍历开始进行链表1和2元素值的比较，将较小的值追加到新链表的末尾，直到其中一个链表遍历结束
  • 最后将还没有遍历结束的链表所有节点追加到新链表的后面

代码实现：

package com.kevin.singleListDemo;

/**
 * @author : kevin ding
 * @date : 2022/2/24 20:42
 * @description :
 */
public class CombinedTwoOrderLinkedList {

    public HeroNode mergeTwoOrderLinkedListToOne(HeroNode headNode1, HeroNode headNode2){
        // 需要定义一个新的链表的头结点
        HeroNode newHeadNode = new HeroNode(0, "","");
        // 首先判断两个链表是否为空：
        if(headNode1.next == null){
            newHeadNode.next = headNode2.next;
            return newHeadNode;
        }
        if(headNode2.next == null){
            newHeadNode.next = headNode1.next;
            return newHeadNode;
        }

        // 如果两个链表都不为空，需要定义三个临时变量 ，分别指向三个头结点的下一个位置
        HeroNode tempNode1 = headNode1.next;
        HeroNode tempNode2 = headNode2.next;
        HeroNode newTempNode = newHeadNode;
        HeroNode nextNode1 = null;
        HeroNode nextNode2 = null;
        // 开始进行比较当前哪个节点我的值大，直到其中一个链表遍历到最后
        while (tempNode1 != null && tempNode2 != null){

            if(tempNode1.no <= tempNode2.no){
                nextNode1 = tempNode1.next;
                //将tempNode1的节点放到newTemNode的后面
                newTempNode.next = tempNode1;
                tempNode1 = nextNode1;
                // 随后将newTempNode后移
                newTempNode = newTempNode.next;

            }else{
                nextNode2 = tempNode2.next;
                //将tempNode2的节点放到newTemNode的后面
                newTempNode.next = tempNode2;
                tempNode2 = nextNode2;
                // 随后将newTempNode后移
                newTempNode = newTempNode.next;
            }
        }
        // 循环退出表示其中一个已经为空
        if(tempNode1 == null){
            // tempNode2后面所有的元素追加到newTempNode后面
            newTempNode.next = tempNode2;
        }
        if(tempNode2 == null){
            // 将tempNode1后面的所有元素追加到newTempNode后面
            newTempNode.next = tempNode1;
        }

        return newHeadNode;
    }

    // 给定一个头结点，开始遍历其中的所有元素
    public void printAllNodesByHeadNode(HeroNode node){
        if(node.next == null){
            System.out.println("链表为空......");
            return;
        }

        // 头结点不能动，需要指定一个辅助节点，因为已经判断过head。next不为空，则初始指向头结点的next，即第一个元素
        HeroNode tempNode = node.next;
        // 循环遍历所有节点，并显示即可
        while (true){
            // 每次针对当前节点判断其是否为空即可
            if(tempNode == null){
                break;
            }
            // 当前节点不为空，将其打印出来，并将指针后移
            System.out.println("当前节点的英雄为：" + tempNode);
            tempNode = tempNode.next;
        }
    }
}
Kevin-Ding
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单向链表算法
杨成勇
10-03 1149
java实现单链表的插入、删除、查找功能。
数据结构与算法:单向链表实现与封装
08-26
今天小编就为大家分享一篇关于数据结构与算法:单向链表实现与封装，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
一步一步写算法（之单向链表）
热门推荐
嵌入式-老费，一个分享专业嵌入式知识的blog
10-07 11万+
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】     有的时候，处于内存中的数据并不是连续的。那么这时候，我们就需要在数据结构中添加一个属性，这个属性会记录下面一个数据的地址。有了这个地址之后，所有的数据就像一
单向链表的算法实现
asdf7659458的博客
01-05 200
#include #include <Windows.h> using namespace std;## 单向链表的算法实现 //定义一个链表 typedef struct _Linknode { int data; //节点的数据域 struct _Linknode* next; //节点的指针域 } Linklist, Linknode;//1. 表示首节点 2.表示节...
单向链表及相关算法
qq_40212968的博客
05-15 254
链表 顺序表缺点：插入删除时需要移动大量元素，为此设计链表 链表：链表由结点组成，每个节点链接串联，分为单向链表，双向链表，循环链表等。 A→B→C→D→NULL B是C的前驱节点，是A的后继节点 单向链表为例： 1.节点结构体定义： struct ListNode{ int data; //数据域，这里定义类型为int ListNode *next; //指针域，指向后继结点地址 } 2.结点创建 3.链表创建 尾插法： > p:移动指针 > curr：新创结点 > head
数据结构基本算法：单向链表
daizhenbest的专栏
12-23 861
#include#includestruct LinkedList{    char data;    struct LinkedList *next;};struct LinkedList *LinkedList;//Gets the count the elements in the list.int GetLinkedListLength(){    int length=0;    str
西南交通大学数据结构实验之单向链表算法练习
02-01
本资源总结了西南交通大学数据结构实验报告的单向链表算法练习，涵盖了链表的基本操作、算法设计、输入/输出设计、编程语言说明等方面的知识点。 一、链表的基本操作 * 单向链表的插入操作：在链表的第 i 个元素...
【Java数据结构与算法】双向链表
12-21
单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面删除单向链表节点时，需要找到temp的下一个节点来删除 如若未了解单链表请参考–>单链表点这里 双向链表示意图如下： 分析双向链表的...
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
数据结构与算法（单向链表）
韦海涛的博客
03-26 1594
/* Name: 线性单向链表的操作 Copyright: Author:abit Date: 07/01/17 15:41 Description: 创建，打印，删除，添加，排序 ，查询 */ #include <stdio.h> #include <stdlib.h> #define N 10 #define ERROR 0 struct Node
数据结构与算法--单向链表
storyfull
11-01 369
文章主要从介绍链表的概念出发，深入理解链表的实现原理，用Python语言实现单向链表！
数据结构与算法学习笔记：单向链表
baidu_41388533的博客
07-16 294
写在前面：记录学习《恋上数据结构与算法》的过程。 课程链接地址：https://ke.qq.com/course/385223 目录 链表（Linked List） 链表的设计 接口设计 清空（clear） 添加元素 - add(int index , E element) 删除元素 remove(int index) 获取元素下标索引 重写toString 算法可视化网站 案例练习：删除节点 案例练习：反转一个链表 递归 非递归 ​案例练习：判断一个链表是否有环 虚拟头结点
用c语言写单链表的逆,怎么用C语言编从表尾到表头逆向建立单链表的源程序
weixin_29574585的博客
05-21 261
满意答案ctrw39802013.12.11采纳率：47%等级：12已帮助：10174人#include#include# define LEN sizeof(struct biao)struct biao{int num;char name[20];struct biao *next;};int n;struct biao *create(){struct biao *head,*p1,...
数据结构单链表简单实现
dongfengxueli的博客
07-30 243
单链表节点定义： typedef struct LNode{ ElemType data; //数据域 struct LNode *next; //指针域 }Lnode,*LinkList; 1 头插法建立单链表 采用头插法建立单链表，读入数据顺序与生成链表中的元素顺序是相反的，每个节点的插入时间是o（1），总的时间复杂度是o（...
数据结构之单链表的基本实现
h4329201的博客
10-07 436
在数据结构的学习中，链表可以说是我们最早接触到的一种数据结构了(字符串和数组除外)，在各大数据结构及算法书中，如CLRS，或者是清华大学版数据结构中，链表也是最早介绍的一种数据结构。它实现起来比较简单，同时能实现一些我们平时用数组难以实现的功能，很适合我们入手数据结构。下面我们简单来看看链表中最简单的一种，单链表的结构及其实现。链表是一种线性的数据结构，它由结点构成，每个结点由数据域和指针域组成。其
【考研】单链表相关算法（从基础到真题）
qq_34438969的博客
10-02 1511
本文主要为了掌握单链表基础操作所作的总结，习题部分含408真题或高校真题，以便考研复习。包括但不限于尾插法和前插法建立单链表、“就地逆置”、链式有序表的合并、注意：（1）除非特别说明，本文的单链表操作默认是带头结点的。（2）区分带头结点和不带头结点的单链表的博文，我写了一半，写完就放链接。（如果很久还没放链接，可能博主有事耽搁了，麻烦提醒一下）【考研】线性表的应用之有序表的合并_住在阳光的心里的博客-CSDN博客【考研】《数据结构》知识点总结.pdf_其它文档类资源-CSDN文库目录前言。
【线性表】链式存储结构之：单链表
小焕--的专栏
05-18 1552
链表 ，采用链式存储结构存储数据元素的线性表 链式存储方法 用一组任意的存储单元来存放线性表的数据元素（这组存储单元既可以是连续的，也可以是不连续的） 链表的逻辑关系 （1）为了能正确表示数据元素间的逻辑关系，对于每个数据元素来说，除了储存本身的信息外，还必须存储指示其后继结点的位置信息， 这两部分信息组成数据的一个结点。它包括两个域：数据域（data）和指针域（
数据结构与算法之单链表
Happy_Boy_z的博客
01-04 947
链表链表的介绍单链表(带头节点)添加（创建） 链表的介绍 链表是有序的列表，它在内存中的存储如下 链表是以节点的方式来存储，是链式存储 每个节点包含data域，next域：指向下一个节点 如图: 发现链表的个个节点不一定是连续存储 链表分带头节点的链表和没有头结点的链表，根据需求来确定 单链表(带头节点) 使用一个带head头的单向链表实现排行榜管理 完成对英雄人物的增删改查操作 ...
设单链表的表头指针为L,结点结构由data和next两个域构成，其中data域为字符型，试设计算法判断该链表的全部n个字符是否中心对称。
qq_44750091的博客
11-08 4685
算法设计： 设单链表的表头指针为L,结点结构由data和next两个域构成，其中data域为字符型，试设计算法判断该链表的全部n个字符是否中心对称。 算法思想： 使用栈来判断链表中的数据是否中心对称。判断n为奇数或偶数，若n为奇数，则有一个中心结点为n%2+1，让链表的前n%2个元素依次进栈，在处理链表的后面元素时，先跳过中心结点，（若n为偶数，则不用直接从n%2+1个元素开始）访问一个链表元素，就从栈中弹出一个元素，两个元素比较，若相等，则将链表中的下一个元素于栈中再弹出的元素比较。直到链表到尾。这时若站
数据结构与算法单向循环链表
最新发布
09-20
单向循环链表是一种特殊的链表，它与单链表相似，唯一的区别是最后一个节点指向链表的头节点，形成一个环。这种结构可以用来解决需要循环访问的问题，比如约瑟夫环问题。在单向循环链表中，每个节点除了保存数据元素...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值