数据结构与算法学习三：单链表的增加（添加到链尾，按顺序添加）、删除、查询、修改。

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

文章目录

前言

一、单链表（Linked List）介绍

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

  1. 链表是以节点的方式来存储，是链式存储
  2. 每个节点包含 data 域， next 域：指向下一个节点。
  3. 如图：发现链表的各个节点不一定是连续存储。
  4. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。
  5. 链表head节点不存放数据，最后一个节点的 next域 为null。
  6. 单链表（带头结点）逻辑结构示意图如下：
    在这里插入图片描述

二、应用实例

使用带head头的 单向链表 实现 –水浒英雄排行榜管理

  1. 完成对英雄人物的增删改查操作.
  2. 添加英雄的第一种方法，直接添加到链表的尾部
  3. 添加英雄的第二种方法，根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示)

2.1 第一种添加思路

  • 添加思路：
  1. 先创建一个head 头节点， 作用就是表示单链表的头
  2. 后面我们每添加一个节点，就直接加入到 链表的最后
  • 遍历思路：
  1. 通过一个辅助变量遍历，帮助遍历整个链表

  • 代码是 SingleLinkedList 类 的 addLinked(HeroNode newNode) 方法。

  • 图解如下：
    在这里插入图片描述

2.2 第二种添加思路

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

  • 添加思路

需要按照编号的顺序添加

  1. 首先找到新添加的节点的位置, 是通过辅助变量(指针), 通过遍历来搞定
  2. 新的节点 next = temp.next
  3. 将temp.next = 新的节点

  • 代码是 SingleLinkedList 类 的 addLinkedByOrder(HeroNode newNode) 方法。

  • 思路的分析示意图：
    在这里插入图片描述

2.3 修改节点

  • 思路
  1. 通过遍历，先找到该节点temp.no == newNode.no，辅助节点 temp 就是该节点。
  2. temp .name = newNode.name;
    temp .nickname =newNode.nickname
  • 代码是 SingleLinkedList 类 的 updateNode(HeroNode newNode)方法。

2.4 删除节点

  • 删除节点思路：
  1. 我们 先找到 需要删除的这个节点的 前一个节点 temp
  2. temp.next = temp.next.next
  3. 被删除的节点，将不会有其它引用指向，会被垃圾回收机制回收

  • 代码是 SingleLinkedList 类 的 deleteNode(int no)方法。

  • 思路分析的示意图：
    在这里插入图片描述

三、代码实现

3.1 项目结构

HeroNode：定义的节点类。
SingerLinkedList: 单链表方法。
SingleLinkedListMain: 测试 Main 方法。
TestStack: 测试栈 这个数据结构。
在这里插入图片描述

3.2 HeroNode.java 单链表节点

package com.feng.ch03_singlelinkedlist;

/*
* 定义 HeroNode ，每个 HeroNode 对象就是一个节点, 就是一个 Javabean
* */
public class HeroNode {
    // data域 ：数据
    public int no;
    public String name;
    public String nickname;
    // next域 ：指向下一个节点
    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 + '\'' +
                '}';
    }
}

3.3 SingleLinkedList.java 单链表

package com.feng.ch03_singlelinkedlist;

/*
 * 定义 SingleLinkedList ，管理英雄
 * */
public class SingleLinkedList {

    // 初始化一个头结点，头结点不要动, 不存放具体的数据
    private HeroNode head = new HeroNode(0, "", "");

    public HeroNode getHead() {
        return head;
    }

    // 添加节点到单向链表
    /*
     * 第一种添加方式：直接在链表最后添加
     * 思路： 当不考虑编号顺序时，1、找到当前链表的最后节点  2、将新节点挂载到最后节点上-》将最后这个节点的next 指向 新的节点
     * */
    public void addLinked(HeroNode newNode) {
        // 因为头结点不能动，因此需要一个辅助节点 temp 来进行遍历
        HeroNode temp = head;
        // 遍历链表，找到最后
        while (true) {
            if (temp.next == null) {
                break;
            }
            temp = temp.next;
        }
        // 当退出 循环时，temp就指向了链表的最后
        // 将最后这个节点的next 指向新的节点
        temp.next = newNode;
    }

    /*
     *
     * 第二种方式在添加节点时（英雄），根据顺序（排名）将英雄插入到指定位置
     * （如果有这个排名，则添加失败，并给出提示）
     *  重点：newNode.next = temp.next;  temp.next = newNode;  这两句顺序不能颠倒
     * */
    public void addLinkedByOrder(HeroNode newNode) {
        // 因为头结点不能动，因此需要一个辅助节点 temp 来帮助找到添加的位置
        // 因为 单链表，我们找的 temp 是位于添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no > newNode.no) {
                break;
            } else if (temp.next.no == newNode.no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.printf("准备插入的英雄的编号 %d 已经存在了，不能加入\n", head.no);
        } else {
            // 先挂载后面，在挂载前面
            newNode.next = temp.next;
            temp.next = newNode;
        }
    }

    public void updateNode(HeroNode newNode){
        //
        if (head.next == null){
            System.out.println("链表为空~");
            return;
        }
        // 定义辅助变量
        HeroNode temp = head.next;
        boolean flag = false;
        while (true){
            if (temp == null){
                break; // 已经遍历完链表
            }
            if (temp.no == newNode.no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.name = newNode.name;
            temp.nickname = newNode.nickname;
        }else{
            System.out.println("链表中没有该英雄~");
        }
    }

    /*
    * 删除节点
    * 思路：
    * 1、head 不能动，因此 需要一个 temp 辅助节点找到待删除节点的前一个节点
    * 2、说明 我们在比较时， 是 temp.next.no 和 需要删除的节点的 No 比较
    * */
    public void deleteNode(int no){
        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 == no){
                flag = true;
                break;
            }
            temp = temp.next; // temp 后移一位， 遍历
        }
        if (flag){ // 找到
            temp.next = temp.next.next;
        }else{ // 没找到
            System.out.printf("要删除的节点 %d 节点不存在", no);
        }
    }

    //显示链表【遍历】
    public void list() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 因为头结点不能动， 因此需要一个辅助节点 temp 来遍历
        HeroNode temp = head.next;
        while (true) {
            if (temp == null) {
                return;
            }
            // 输出节点信息
            System.out.println(temp);
            temp = temp.next;
        }
    }
}

3.4 SingleLinkedListMain.java 测试

package com.feng.ch03_singlelinkedlist;

import java.util.Stack;

/*
* 单链表
*
* 单链表的 添加、按顺序添加、删除、修改、遍历 功能
*
* 单链表的面试题：
* 2、 将单链表反转 【腾讯面试题】  ** 有难度，需要思考
* 3、实现单链表的逆序打印【百度面试题】
*   3.1 方式1：先反转，在打印。
*   3.2 方式2：利用栈 这个数据结构，将各个节点压入栈中，然后利用栈的先进先出的特点，实现逆序打印的效果
* */
public class SingleLinkedListMain {
    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.addLinked(hero1);
//        singleLinkedList.addLinked(hero2);
//        singleLinkedList.addLinked(hero4);
//        singleLinkedList.addLinked(hero3);

        // 添加节点 按顺序
        singleLinkedList.addLinkedByOrder(hero1);
        singleLinkedList.addLinkedByOrder(hero2);
        singleLinkedList.addLinkedByOrder(hero4);
        singleLinkedList.addLinkedByOrder(hero3);

        // 显示节点
        System.out.println("显示初始添加后的节点~");
        singleLinkedList.list();

        // 测试修改
        System.out.println();
        System.out.println("测试修改后的结果");
        HeroNode updateNode = new HeroNode(2, "小卢", "玉麒麟");
        singleLinkedList.updateNode(updateNode);
        singleLinkedList.list();

        // 测试删除
        System.out.println();
        System.out.println("测试删除后的结果");
        singleLinkedList.deleteNode(2);
        singleLinkedList.deleteNode(3);
        singleLinkedList.list();

        // 测试返回单链表有效个数
        System.out.println();
        System.out.println("单链表有效个数=" + getLength(singleLinkedList.getHead()));

        // 测试 查看倒数第 K 个节点的 数据
        System.out.println();
        HeroNode lastIndexNode = findLastIndexNode(singleLinkedList.getHead(), 1);
        System.out.println("倒数第 K 个节点的 res=" + lastIndexNode);

        // 测试单链表的反转
        System.out.println();
        System.out.println("测试反转后的链表");
        reverseList(singleLinkedList.getHead());
        singleLinkedList.list();

        // 测试单链表的逆序打印
        System.out.println();
        System.out.println("测试单链表的逆序打印");
        reversePrint(singleLinkedList.getHead());
    }

    /*
     * 方法：实现单链表的逆序打印【百度面试题】
     * 方式1：先反转，在打印。
     * 方式2：利用栈 这个数据结构，将各个节点压入栈中，然后利用栈的先进先出的特点，实现逆序打印的效果
     * */
    public static 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());
        }
    }

    /*
     * 将单链表反转 【腾讯面试题】
     * */
    public static void reverseList(HeroNode head) {
        //如果当前链表为空，或者只有一个节点，无需反转，直接返回
        if (head.next == null || head.next.next == null) {
            return;
        }

        //定义一个辅助的指针(变量)，帮助我们遍历原来的链表
        HeroNode temp = head.next;
        HeroNode next = null;
        HeroNode reverseHead = new HeroNode(0, "", "");

        /*
         * 遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端
         * 动脑筋
         * */
        while (temp != null) {
            next = temp.next;//先暂时保存当前节点的下一个节点，因为后面需要使用， 此时，temp 为独立的一个节点
            temp.next = reverseHead.next;//将cur的下一个节点指向新的链表的最前端，将反转链表的后面 挂载到 temp 上。
            reverseHead.next = temp;//将cur 连接到新的链表上， 将 temp 挂载到 反转链表的后面，就完成了。
            temp = next;//让cur后移，
        }
        //将head.next 指向 reverseHead.next , 实现单链表的反转
        head.next = reverseHead.next;
    }


    /*
     * 方法：查找单链表中的倒数第k个结点 【新浪面试题】
     * 思路：
     * 1. 编写一个方法，接收head节点，同时接收一个index
     * 2. index 表示是倒数第index个节点
     * 3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
     * 4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到
     * 5. 如果找到了，则返回该节点，否则返回 null
     * */
    public static HeroNode findLastIndexNode(HeroNode head, int index) {
        //判断如果链表为空，返回null
        if (head.next == null) {
            return null;
        }
        //第一次遍历得到链表的长度(节点个数)
        int size = getLength(head);
        //先做一个index的校验
        if (index < 0 || index > size) {
            return null;
        }
        //第二次遍历  size-index 位置，就是我们倒数的第K个节点
        //定义给辅助变量， for 循环定位到倒数的index
        HeroNode temp = head.next;
        for (int i = 0; i < size - index; i++) {
            temp = temp.next;
        }
        return temp;
    }

    /*
     * 方法：获取单链表的有效节点个数（如果是带头结点的链表，需要不统计头结点）
     * @param head 链表的头节点
     * @return 返回的就是有效节点的个数
     * */
    public static int getLength(HeroNode head) {
        if (head.next == null) {
            return 0;
        }
        HeroNode temp = head.next;
        int count = 0;
        /*while (true){
            if (temp== null){
                break;
            }
            count++;
            temp = temp.next;
        }*/
        while (temp != null) {
            count++;
            temp = temp.next;
        }
        return count;
    }


}

四、单向环形链表应用场景

4.1 osephu(约瑟夫、约瑟夫环) 问题

Josephu 问题为：设编号为1，2，… n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

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

4.2 单向环形链表介绍

在这里插入图片描述

五、Josephu(约瑟夫)问题

5.1Josephu 问题的示意图

在这里插入图片描述

  • Josephu问题
    Josephu 问题为：设编号为1，2，… n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

  • 提示
    用一个不带头结点的循环链表来处理Josephu 问题：先构成一个有n个结点的单循环链表，然后由k结点起从1开始计数，计到m时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从1开始计数，直到最后一个结点从链表中删除算法结束。

  • 约瑟夫问题-创建环形链表的思路图解
    在这里插入图片描述

  • 约瑟夫问题-小孩出圈的思路分析图
    在这里插入图片描述

  • 约瑟夫问题-创建环形链表的思路图解
    在这里插入图片描述

  • 约瑟夫问题-小孩出圈的思路分析图
    在这里插入图片描述

5.2 代码实现

package com.feng.ch03_linkedlist;

public class Josephu {
	public static void main(String[] args) {
		// 测试一把看看构建环形链表，和遍历是否ok
		CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
		circleSingleLinkedList.addBoy(5);// 加入5个小孩节点
		circleSingleLinkedList.showBoy();

		// 测试一把小孩出圈是否正确
		circleSingleLinkedList.countBoy(1, 2, 5); // 2->4->1->5->3
		// String str = "7*2*2-5+1-5+3-3";
	}
}

class CircleSingleLinkedList {
	// 创建一个 first 节点,。当前没有编号， 这个就是第一个节点
	private Boy first = null;

	/**
	 * 添加小孩节点，构建成一个环形的链表
	 * 
	 * @param nums
	 */
	public void addBoy(int nums) {
		// nums 做一个数据校验
		if (nums < 1) {
			System.out.println("没有小孩");
			return;
		}
		// 辅助指针，帮助构建环形链表
		Boy curBoy = null;
		// 使用for来创建我们的环形链表
		for (int i = 1; i <= nums; i++) {
			// 根据编号，创建小孩节点
			Boy boy = new Boy(i);
			// 如果是第一个小孩
			if (i == 1) {
				first = boy; // 生成的第一个节点 赋给原先设定好的 first
				first.setNext(first); // 构建环形链表
				curBoy = first; // 让curBoy指向第一个小孩
			} else {
				curBoy.setNext(boy); // 在后面添加
				boy.setNext(first); // 环形链表
				curBoy = boy; // 将最后一个 赋给 辅助指针。
			}
		}

	}

	/**
	 * 遍历当前的环形链表
	 */
	public void showBoy() {
		// 判断链表是否为空
		if (null == first) {
			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 (first == helper.getNext()) {
				break;
			}
			helper = helper.getNext();
		}

		// 小孩报数前，先让 first 和 helper 移动 k - 1次
		for (int i = 0; i < startNo - 1; i++) {
			first = first.getNext();
			helper = helper.getNext();
		}
		// 当小孩报数时，让first 和 helper 指针同时 的移动 m - 1 次, 然后出圈
		// 这里是一个循环操作，知道圈中只有一个节点
		while (true) {
			if (first == helper) {
				break;
			}
			for (int i = 0; i < countNum - 1; i++) {
				first = first.getNext();
				helper = helper.getNext();
			}
			// 这时first指向的节点，就是要出圈的小孩节点
			System.out.printf("小孩%d出圈\n", first.getNo());

			// 这时将first指向的小孩节点出圈
			first = first.getNext(); // 改变 first 的值，为原来first 的下一个值
			helper.setNext(first); //
		}
		System.out.printf("最后留在圈中的小孩编号%d \n", first.getNo());
	}
}

/**
 * 创建一个 Boy 类，表示一个节点
 */
class Boy {
	private int no; // 编号 数据域简单点
	private Boy next; //

	public Boy(int no) {
		super();
		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;
	}

}
  • 日志分析
    在这里插入图片描述
java冯坚持
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
单链表的头部插入和尾部插入
03-06
单链表的头部插入和尾部插入新节点代码，备注详细，结构简明。
单链表的增加---无头结点
何新生(Daniel) 勇敢坚毅真正之才智乃刚毅之志向。 —— 拿破仑
01-26 373
单链表的增加---无头结点 本文展示单链表的增加 1.从头部添加 2. 从尾部添加 /** * 初始化单链表 */ typedef struct ListNode { ElemType data; struct ListNode *next; } ListNode; typedef ListNode *List; /** * 头结点为空的初始化 * @param head */ void InitList(Li...
数据结构——单链表的增加、删除、查找、修改，详细解析
热门推荐
昵称就是昵称吧的博客
04-07 1万+
链表的概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 单链表是链表很重要的一种，如果理解了它，那么对于其他链表的理解，就会事半功倍。 目录 一、单链表的处理 1、节点的设置 2、节点(结构体)内存空间的开辟 二、单链表功能的实现 1、整体框架 2、主菜单 3、功能的实现 3.1 打印单链表数据功能的实现 3.2 从单链表尾部插入节点功能的实现 3.3从单链表头部插入节点功能的实现 3.4从单...
单链表的实现---增加可选功能
apple_50916469的博客
03-30 335
之前上传了一个单链表的博文，但是在实现上交互性较差，而且在给结点分配空间的时候是使用的malloc函数实现的，今天我们就使用c++中的new关键字来给结点分配内存空间。 话不多说，下面就是关于单链表操作的各个功能的函数。 一、用结构体创建一个结点数据类型 为了能够实现单链表的操作，结点里面主要有两部分，一部分是数据域，存放结点的数据值，另一个是指针域，存放下一个结点的地址。 typedef struct LNode{ int data; struct LNode *next; }LNode, *
单链表的新增
wying_t的博客
06-21 285
实现单链表的新增操作 链表作为最基本的数据结构，存储特点如下:可以用任意一组存储单元来存储单链表中的数据元素且存储单元可以不是连续的。N个节点连接在一起被称之为链表。当节点只包含其后继节点的信息的链表我们称之为单链表，在内存中存储的方式如下图: 定义链表 class Node { Node node = null; int data; public Node (int data){ this.data = data; } } 链表最重要的操作是向...
数据结构和算法必知必会的50个代码实现
06-26
## 链表* 实现单链表、循环链表、双向链表，支持增删操作* 实现单链表反转* 实现两个有序的链表合并为一个有序链表* 实现求链表的中间结点 ## 栈* 用数组实现一个顺序栈* 用链表实现一个链式栈* 编程模拟实现一个...
50个必会的数据结构及算法实现源码
12-14
数组 问题：实现一个支持动态扩容的数组 问题：实现一个大小固定的有序数组，支持动态增删改操作 问题：实现两个有序数组合并为一个有序数组 ...资源中包括常用语言：c、java、python、go等实现源码，方便参考学习。
数据结构顺序表+单链表+二叉树+图等等各实验总汇.rar
07-10
因为实在有用所以分数较高，只是用于计算机专业
DSALGO-VISUALIZER:通过动画学习数据结构和算法
05-05
注意：货币工作DS算法 :high_voltage: 器专为希望通过动画学习数据结构和算法的学生而设计。 该项目包括被广泛使用的所有重要数据结构。数据结构链表二进制搜索树图形细绳不相交集哈希表阵列算法卡达内斯前缀总和...
leetcode2-DataStructureDemo:数据结构学习。1、啊哈算法
06-29
数据结构 + 算法练习。 1、啊哈 算法。 2、剑指Offer 3、LeetCode代码练习 github传送门 github传送门 gitee传送门 啊哈 算法 剑指Offer LeetCode 一、链表 1、Java实现单链表，支持增删改查。 2、单向链表反转 3、...
单链表的基本功能（增 ，删，改，查，求长度，排序）
weixin_63032791的博客
11-28 402
首先进行链表的初始化 struct Node { int data; struct Node *next; }; 若进行学生成绩的链表操作，可以使用结构体嵌套功能 struct student { char name[20]; int num; int Chi; //语文 int math; int English; }; //链表初始化 struct Node { struct student data; //数据域 struct Node *next;
单链表的增加---有头结点
何新生(Daniel) 勇敢坚毅真正之才智乃刚毅之志向。 —— 拿破仑
01-26 523
单链表的增加---有头结点 1.从头部添加 2.从尾部添加 /** * 初始化单链表 */ typedef struct ListNode { ElemType data; struct ListNode *next; } ListNode; typedef ListNode *List; /** * 初始化单链表,头结点不为空 * @param head */ void InitListHeadNoNull(List *head) { ...
单链表尾部插入算法
小灰灰的博客
04-08 4579
#include&lt;stdio.h&gt; #include&lt;strings.h&gt; #include&lt;stdlib.h&gt; //目的 从链表尾部插入新节点 struct node { int data; //有效数据 struct node *pNext; //指向下一个节点的指针 }; void insert_tail(struct node ...
单链表插入数据和遍历学习小结
要吃鱼的小虾米的博客
04-08 232
1、创建链表节点类 public static class ListNode { int val; ListNode next; ListNode() {} ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } } 创建一个节点类，类中定义两个属性，一个属性(
数据结构与算法之单链表(增{包含增序增加}、删、改、查、链表反转、有序链表合并{包含递归和非递归两种方式})
qq_35671159的博客
05-29 224
直接上代码吧，后面再总结一下： public class SinglyLinkedList { // 头节点 private final Node headNode = new Node(0, "", ""); /** * 添加节点 * * @param newNode 新节点 */ public void add(Node newNode) { Node temp = headNode; whi
单链表的增加修改删除
qq_32301729的博客
10-17 153
#include <iostream> #include<queue> #include<vector> #include<string> #include<algorithm> using namespace std; class Node { public: int x; int site; Node* next; Node(int y) { this->x = y; this->next = NULL; } }
链表学习记录1两种添加方式
Carry_bluebuff的博客
06-14 189
<textarea readonly="readonly" name="code" class="Java"> package com.atguigu.linkedlist; /** * @author wststart * @create 2019-06-14 19:02 */ public class SingleLinkedListDemo { public st...
单链表的创建、取数据、数据添加、数据插入、数据删除
11-27 770
#define _CRT_SECURE_NO_WARNINGS #include #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 using namespace std; typedef int ElemType; typedef struct Node { ElemType data
单链表（增、删、查、改）的详细介绍 必看！！！
weixin_62976968的博客
05-13 816
对单链表的基本操作（增、删、查、改）有简单明了的介绍，对于单链表的学习帮助巨大。
c语言数据结构与算法将数据导入单链表
最新发布
05-30
好的，我可以帮你解决这个问题。首先，我们需要定义一个单链表结构体，如下所示： ```c typedef struct ListNode { int val; struct ListNode *next; } ListNode; ``` 其中 `val` 表示节点的值，`next` 表示指向下一个节点的指针。 接下来，我们可以编写一个函数来将数据导入单链表，具体实现如下： ```c ListNode* createList(int arr[], int n) { ListNode *head, *p, *q; head = (ListNode *)malloc(sizeof(ListNode)); head->next = NULL; p = head; for (int i = 0; i < n; i++) { q = (ListNode *)malloc(sizeof(ListNode)); q->val = arr[i]; q->next = NULL; p->next = q; p = q; } return head->next; } ``` 这个函数的作用是将长度为 `n` 的数组 `arr` 中的数据导入到单链表中，并返回该单链表的头节点指针。具体实现步骤如下： 1. 定义头节点 `head`，并将其指向的下一个节点指针 `next` 初始化为 `NULL`。 2. 定义指针 `p`，指向头节点。 3. 遍历数组 `arr`，对于每个元素，创建一个新的节点 `q`，将其值设置为当前元素的值，将其指向下一个节点的指针 `next` 初始化为 `NULL`。 4. 将新节点 `q` 插入到链表的末尾，即将指针 `p` 的下一个节点指针 `next` 指向新节点 `q`，然后将指针 `p` 指向新节点 `q`。 5. 返回链表的头节点指针 `head->next`，即去掉头节点后的第一个节点。 希望这个函数能够帮助你解决导入数据到单链表的问题！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

java冯坚持

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

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

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

打赏作者

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

抵扣说明：

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

余额充值