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

最新推荐文章于 2022-12-07 18:33:23 发布
最新推荐文章于 2022-12-07 18:33:23 发布
阅读量286 收藏
点赞数
分类专栏： 算法、数据结构 Java 文章标签： Java 单向链表 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39651356/article/details/103400700
版权

文章目录

概念

逻辑有序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lJYPDvRF-1575514873229)(en-resource://database/11501:1)]

 

内存上节点间无序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U1VjWdrj-1575514873233)(en-resource://database/11503:1)]

  • 特点
    1. 由节点组成，是逻辑上有序的、内存上无序
    2. 每个节点由 数据（data）、以及指向下一个节点的指针（next） 组成
    3. next=null：说明链表已经遍历完节点
    4. head指针( 头节点不存数据 )：指向第一个节点的位置

 

单链表 - 新元素直接添加到尾部

代码实现

  通用的简单单向链表 - 泛型

class  SingleLinkedList<T> {
	
	// 头节点
	Node<T> head = new Node<T>(null);
	
    // 添加元素
	public void add(T a) {
		
		// 将添加的元素 封装成为 一个新的节点
		Node<T> newNode = new Node<T>(a);
		
		// 用来存储当前遍历到的节点引用
		Node<T> temp_Node = head;
		
		while(true) {
			
			// 如果节点中含有 next=null 说明则是尾节点，停止遍历
			if(temp_Node.next == null) {
				break;
			}
			temp_Node = temp_Node.next;
		}
		
		// 尾节点的next= 新节点的引用
		temp_Node.next = newNode;
	}
	
	
	// 将链表以字符串的形式输出、故重载 toString() 方法
	@Override
	public String toString() {
		
		// 存储当前遍历到的节点的引用
		Node<T> temp_Node = head;
		
		// 使用 StringBuilder处理字符串更加的快
		StringBuilder sb = new StringBuilder();
		
		// 只有到了 尾节点，节点遍历才停止
		while(temp_Node.next != null) {
			
			temp_Node = temp_Node.next;
			sb.append(temp_Node.data + "\n");
		}
		
		sb.delete(sb.lastIndexOf("\n"), sb.length());
		
		return sb.toString();
	}
	
	
	// 1. 内部节点类无需显示地定义在列表的外面，单纯私有内部类就可以了
	@SuppressWarnings({ "unused", "hiding" })
	private class Node<T> {
		T data;    // 存储T类型的真实数据
		Node<T> next;   // 指向下一个节点
		Node(T data) {
			this.data = data;
			next = null;
		}
		
		@Override
		public String toString() {
			return data.toString();
		}
		
	}
	
}

 

测试
class Student {
	String name;
	int year;
	public Student(String name, int year) {
		this.name = name;
		this.year = year;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", year=" + year + "]";
	}
	
	@Override  // 方便后面测试
	public int hashCode() {
		return year;
	}
    
    
    public boolean equals(Object o) {
		
		if(! (o instanceof Student) ) { return false; }
		
		if(name.equals( ((Student)o).name )  && year == ((Student)o).year) {
			return true;
		}
		return false;
		
	}

    
}


// 测试代码
public static void main(String[] args) {		
		Student stu1 = new Student("lrc", 22);
		Student stu2 = new Student("glw", 27);
		Student stu3 = new Student("yxe", 25);
		
		SingleLinkedList<Student> sll = new SingleLinkedList<Student>();
		
		sll.add(stu1);
		sll.add(stu2);
		sll.add(stu3);
		
		System.out.println(sll);
}

 

  运行结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YMblbQfe-1575514873244)(en-resource://database/11507:1)]

 

单链表 - 新元素动态添加到链表

按hashCode()的大小动态插入，链表越后面的元素其hashCode()越大

代码实现

  在上面的通用简单链表添加一个成员方法

public void addOrder(T a) {

    // 1. 需要添加的新元素节点
    Node<T> newNode = new Node<T>(a);

    // 2. 找到新元素插入该临时节点的后面
    Node<T> temp_Node = headNode;


    // 3. 遍历链表
    while(temp_Node.next != null) {
        // 如果找到临时节点的后一个节点比新节点大，则直接停止循环
        if(temp_Node.next.data.hashCode() > a.hashCode()) {
            break;
        }

        temp_Node = temp_Node.next;
    }

    // 4. 插入节点步骤
    newNode.next = temp_Node.next;
    temp_Node.next = newNode;

}

 

测试代码
public static void main(String[] args) {

    Student stu1 = new Student("lrc", 22);
    Student stu2 = new Student("glw", 27);
    Student stu3 = new Student("yxe", 25);

    SingleLinkedList<Student> sll = new SingleLinkedList<Student>();

    sll.addOrder(stu1);
    sll.addOrder(stu2);
    sll.addOrder(stu3);

    System.out.println(sll);

}

 
  运行结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g52SeMIY-1575514873248)(en-resource://database/11509:1)]

 

单链表 - 链表元素删除

代码实现
public boolean delete(T a) {
    Node<T> temp = headNode;

    // 遍历完、或者 找到被删元素的前一个节点则停止遍历
    while(temp.next != null) {

        // 被删元素的前一个节点
        if(temp.next.data.equals(a)) {
            break;
        }
        temp = temp.next;
    }

    // 如果是链表最后一个节点、所以链表没有符合实参的节点
    if(temp.next == null) {
        return false;
    }else {

        // 该为被删的节点
        Node deletingNode = temp.next;

        // 被删节点后面没有元素
        if(deletingNode.next == null) {
            temp.next = null;
        // 被删节点后面有元素
        }else {
            temp.next = deletingNode.next;
        }
        return true;
    }

}

 

单链表 - 获取链表有效节点的个数

代码实现
// 统计有效节点的个数 --  不算头指针（即头节点）
public int length() {
    Node<T> temp = headNode;
    int length = 0;
    while(temp.next != null) {
        temp = temp.next;
        length++;
    }

    return length;
}

 

单链表 - 获取倒数第n个节点的数据

代码实现
public T lastElement(int n) {

    if(length() < n) {
        throw new RuntimeException("超出界限，链表无这元素");
    }else {

        // 用来保存查找到的元素
        Node<T> temp2 = null;

        // n有几次，就遍历几次
        for(int i = 0; i < n; i++) {

            // 每遍历一次就从头开始
            Node<T> temp1 = headNode;
            while(temp1.next != temp2) {
                temp1 = temp1.next;
            }

            // 将查找到元素放置在temp2
            temp2 =temp1;
        }

        return temp2.data;
    }

}

 

单链表 - 节点反转

代码实现
public void reverse() {
    if(length() == 0) {
        return;
    }else {

        // 创建反转节点链的头指针
        Node<T> reverHead = new Node<T>(null);

        // 遍历从第一个有效节点开始，而不是头指针 ---  这部非常重要
        Node<T> validNode = headNode.next;  

        // 用来存储当前有效节点的下一个节点
        Node<T> next = null;  


        while(validNode != null) {
            // 1. 存储下一个节点的位置信息
            next = validNode.next;

            // 2. 当前节点的next指针指向  reverHead头指针指向的节点
            validNode.next = reverHead.next;

            // 3. reverHead指针指向当前节点
            reverHead.next = validNode;

            // 4. 指向下一个节点
            validNode = next;
        }

        headNode = reverHead;
    }

}

 

单链表 - 从尾开始打印节点

代码实现1 - 改变链表结构
// 从尾到头打印节点  ---  消耗太多性能，因为改变了两次链表结构
public void reversePrint1() {
    // 1. 先反转链表结构
    reverse();
    // 2.打印
    System.out.println(this);
    // 2.在反转回原来链表结构
    reverse();
}

 

代码实现2 – 利用堆栈存储节点
public void reversePrint2() {
  
  // 1. 存储节点
    Stack<Node<T>> stack = new Stack<Node<T>>();

    // 2. 上一个真实节点的指针
    Node<T> temp = headNode;

    while(true) {

        // 3. 待添加的节点
        Node<T> addingNode = temp.next; 

        // 4. 如果待添加的节点为空，则退出循环
        if(addingNode == null) {
            break;
        }

        // 5. 将待添加的节点 加入堆栈
        stack.push(addingNode);

        // 6. 移动遍历的指针
        temp = addingNode;
    }

    // 7. 利用堆栈先进后出的属性 从尾到头打印节点
    while(!stack.empty()) {
        System.out.println(stack.pop());
    }

}

 

单链表 - 合并两个有序的链表

代码实现
public void mergeOrder(SingleLinkedList<T> sll) {

    // 注意这里是从头指针开始  -- 进行遍历操作-- 记录当前遍历的位置
    Node<T> Node_link1 = this.headNode;

    // 这里是从第一个有效节点开始-- 进行遍历操作 -- 记录当前遍历的位置
    Node<T> Node_link2 = sll.headNode.next; 

    // 如果实参无有效节点，直接结束方法
    if(Node_link2 == null) {
        return;
    }

    // 表示当前节点的状态值，如果为null，说明已经遍历完毕
    while(Node_link1 != null) {

        // 存储 当前节点的下一个节点位置
        Node<T> next_Node_link1 = Node_link1.next;

        // 如果本地链表已经遍历完毕，则直接将剩下的实参节点拼接即可 - 退出方法
        if(next_Node_link1 == null ) {
            Node_link1.next = Node_link2;
            return;
        }

        // 我们需要找出原链表插入节点的前一个节点
        if(next_Node_link1 != null) {

            // 原果原链表的下一个节点 大于  实参的当前有效节点 ，则直接插入到原链表
            if( Node_link1.next.data.hashCode() > Node_link2.data.hashCode() ) {

                // 存储实参链表的下一个节点
                Node<T> next_Node_link2 = Node_link2.next;
                // 进行实参当前节点在原链表的插入操作
                Node_link2.next = next_Node_link1;
                Node_link1.next = Node_link2;
                // 因为插入了新节点，则原来的新节点下一个元素应指向插入节点
                next_Node_link1 = Node_link2;
                // 转到下一个节点
                Node_link2 = next_Node_link2;
            }
        }

        // 原链表转到下一个节点
        Node_link1 = next_Node_link1;
    }
}

 

测试代码
public static void main(String[] args) {

    // 1. 打印有序链表1
    Student stu1 = new Student("lrc", 22);
    Student stu2 = new Student("glw", 27);
    Student stu3 = new Student("yxe", 25);
    SingleLinkedList<Student> sll = new SingleLinkedList<Student>();
    sll.addOrder(stu1);
    sll.addOrder(stu2);
    sll.addOrder(stu3);
    System.out.println(sll);


    System.out.println("\n---------------------------\n");

    // 2. 打印有序链表2
    Student stu4 = new Student("lrc", 21);
    Student stu5 = new Student("glw", 250);
    Student stu6 = new Student("yxe", 28);
    SingleLinkedList<Student> sll2 = new SingleLinkedList<Student>();
    sll2.addOrder(stu4);
    sll2.addOrder(stu5);
    sll2.addOrder(stu6);
    System.out.println(sll2);


    System.out.println("\n---------------------------\n");

    // 3. 将有序链表2 合并到 有序链表1 ，并将其打印
    sll.mergeOrder(sll2);
    System.out.println(sll);

}

 
  运行结果
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YVmwOdCw-1575514873255)(en-resource://database/11511:0)]

嗯嗯**
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python数据结构-实验1 顺序表的基本操作
LiAnG12366的博客
05-11 4316
python数据结构-实验1 顺序表的基本操作 创建一个名为 ex020501_01.py 的文件，在其中编写一个顺序表的类，该类必须包含顺序表的定义及基本操作，并通过以下步骤测试基本操作的实现是否正确。 实验代码
数据结构与算法——单链表
笑着的程序员的博客
03-29 246
关于单链表的一个简单的题目 以下程序输入一个整数n，再输入n个整数，以此按数据大小建立一个链表，再输出该链表所有节点的数据，然后删除整个链表。如输入5 33 88 55 77 11，则输出11 33 55 77 88。 #include <stdio.h> #include <stdlib.h> typedef struct LNode { int...
基于Python的数据结构实验——顺序表与单链表建立与操作（附详细代码和注释）
为人民服务
10-17 5574
2、创建名为 prac02_02.py 的文件，在其中编写一个结点类，该类中必须包含结点的定 义及初始化操作，再编写一个单链表类，该类中包含单链表的定义及基本操作。1、创建一个名为 prac02_01.py 的文件，在其中编写一个顺序表的类，该类必须包含顺 序表的定义及基本操作，并通过以下步骤测试基本操作的实现是否正确，给出运行结果。(3)将值为 33，24，231，3，11 的结点依次链入 SLL 中。(3)将元素 2，5，16，55，8 依次存入 SL 中。(7)删除 SLL 中第 4 个位置的结点。
2022-10-03 线性表
qq_64265991的博客
10-03 412
2022-10-03 线性表
C语言数据结构（1）——顺序表
qq_43041053的博客
10-16 273
C语言数据结构（1）——顺序表1.顺序表基本数据类型2.顺序表的初始化3.检查容量4.尾插元素5.尾删元素6.头插元素7.头删元素8.查找元素返回下标9.删除指定位置的元素10.在指定位置插入元素11.销毁顺序表 1.顺序表基本数据类型 typedef int SLDataType;//将元素类型名统一，方便以后修改 typedef struct SeqList { SLDataType *a;//存放指针，用于于开辟空间 int size;//表示数组中当前存储了多少个有效数据 int capa
【尚硅谷】Java数据结构与算法笔记03 - 链表
知不足而奋进，望远山而前行
12-07 1万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
java数据结构与算法.pdf
01-04
Java作为广泛应用的编程语言，其在实现数据结构和算法时有着丰富的库支持和优秀的可读性。下面将对标题和描述中提到的一些关键知识点进行详细解释。 1. **数据结构**： - **稀疏数组**：当大量数据中大部分为零或...
数据结构与算法-顺序表（链表篇）
09-09
在IT领域，数据结构与算法是计算机科学的基础，它们直接影响到程序的效率和设计。本资源专注于"顺序表"中的"链表"部分，这是一组相关数据元素的集合，其内部组织方式不同于传统的数组。链表不依赖于内存中的连续空间...
【Java数据结构与算法】双向链表
12-21
本文主要讨论的是双向链表，这是一种重要的线性数据结构，它弥补了单向链表的一些缺点。 双向链表是一种链式存储结构，每个节点包含两个指针，一个指向前一个节点（pre指针），另一个指向后一个节点（next指针）。...
数据结构与算法 实战代码
最新发布
03-13
在Java编程中，理解和熟练运用数据结构与算法能够显著提高程序的效率和可维护性。以下是对这些核心概念的详细阐述。 1. 数据结构 数据结构是组织、管理和存储数据的方式，以便于高效地访问和修改。常见的数据结构...
数据结构与算法(java版) 第一季 - 03 单向链表
m0_47489229的博客
07-13 258
基于java的数据结构与算法笔记整理.
数据结构之链表（一）——单链表实现
CDCSPR的博客
09-15 455
在数据结构中，链表是基本一个的数据结构，所以我们要能够实现一个简单的单链表以及对链表的基本操作要十分熟悉，才能在笔试或者面试的时候更有把握！ 如上图所示的是一个单链表的存储原理图，head为头节点。而每个节点中都有一个next引用，指向下一个节点，就这样一节一节往下面记录，直到最后一个节点，最后一个节点的next指向null。而我们学习数据结构的链表时，使用的是如下图所示的虚拟头结点（he...
数据库经典基础试题总结
热门推荐
sophia_wjy的专栏
11-13 5万+
第一章  1. 单个用户使用的数据视图的描述称为（）(2001年10月全国卷)  a. 外模式 b. 概念模式 c. 内模式 d. 存储模式  2. 子模式ddl用来描述（）(2001年10月全国卷)  a. 数据库的总体逻辑结构 b. 数据库的局部逻辑结构 c. 数据库的物理存储结构 d. 数据库的概念结构  3. 在dbs中，dbms和os之间的关系是（）(2001年10月全国卷)
Java基础 - XML解析转成Bean以及Bean转成XML（附带案例）
weixin_39651356的博客
12-20 5094
文章目录1. JAXB - Java Architecturefor XML Binding - 面向XML绑定的Java体系结构1.1 注解1.2 使用**测试1 - 反序列化xml文件成JavaBean对象****测试2 - 序列化普通JavaBean对象****测试3 - 序列化JavaBean对象字段中含有容器Collection -> xml字符串****测试4 - 序列化容器对象**测试5 - 复杂报文解析 1. JAXB - Java Architecturefor XML Bindin
HtmlUnit（Java） - 快速入门学习 - 无界面浏览器
weixin_39651356的博客
02-10 4524
文章目录1. 概述2. 注意2.0 js解析问题2.1 关闭HtmlUnit日志3. 使用3.1 抓取IT之家周榜内容 - 单页面3.2 抓取IT之家周榜第九篇文章的内容 - 双页面3.3 模拟用户操作 - （这个功能个人感觉非常非常的鸡肋，只能用于非常简单的JS，但是一般网站的动作触发都会进行一系列复杂的JS操作，所以想爬虫还是推荐Selenium）3.4 文件下载3.5 弹框处理 注意： 对于百度翻译、百度搜索、腾讯翻译等页面依然抓取不了结果，对于加密的JS文件解析基本不生效 — 推荐使用Seleni
过滤器Filter讲解-以及两种配置方式
weixin_39651356的博客
11-06 4231
文章目录1. 担任的角色2. 运行的流程3. 生命周期4. 三大过滤器核心接口4.1 Filter接口4.2 FilterConfig接口4.3 FilterChain接口5. 过滤器的使用5.1 代码实现5.2 声明配置5.2.1 注解@WebFilter5.2.2 配置文件web.xml 1. 担任的角色 拦截请求、响应的作用 — 像小区的保安   2. 运行的流程 请求的预处理： ...
SpringBoot - 集成Swagger、Knif4j接口文档以及文档添加账号密码登录
weixin_39651356的博客
11-28 3290
集成Swagger、Knif4j接口文档以及文档添加账号密码登录
Selenium（Java）快速入门 - 配简单的Demo演示
weixin_39651356的博客
02-08 3010
文章目录0. 概述1. 爬虫使用1.1 测试浏览器的版本1.2 下载驱动以及依赖1.3 代码2 案例2.1 爬豆瓣阅读小说-堕三都3. 其他使用3.1 监听弹框（alert、confirm、prompt）3.2 模拟百度搜索-并打印出结果3.3 等待 - 某些节点需特定条件才会显示出来（需等待时间）3.3.1 硬性等待 - 等待指定秒数 - Thread.sleep - 不灵活3.3.2 隐式等待（最多检索某秒数，直到找到为止，超时仍未找到则报错） - 一旦设置，所有节点的查找都会有隐式等待的时间3.3.
Java数据结构与算法实战：从基础到进阶
"数据结构与算法的全面讲解，主要针对Java语言进行阐述，涵盖了算法的基础概念、数据结构的种类以及相关的编程练习。" 在计算机科学中，数据结构与算法是两个核心概念。数据结构指的是组织和存储数据的方式，而算...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值