算法与数据结构-链表

最新推荐文章于 2022-08-21 17:59:27 发布
最新推荐文章于 2022-08-21 17:59:27 发布
阅读量133 收藏 1
点赞数
分类专栏： 算法与数据结构 算法与数据结构-java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35578760/article/details/89703364
版权

链表

底层存储结构
数组需要一块连续的内存空间来存储，对内存的要求比较高。如果我们申请一个 100MB 大小的数组，当内存中没有连续
的、足够大的存储空间时，即便内存的剩余总可用空间大于 100MB，仍然会申请失败。而链表恰恰相反，它并不需要一块连续的内存空间，它通过“指针”将一组零散的内存块串联起来使用。
单链表
我们把内存块称为链表的“结点”。为了将所有的结点串起来，每个链表的结点除了存储数据之外，还需要
记录链上的下一个结点的地址。如图所示，我们把这个记录下个结点地址的指针叫作后继指针 next。
****
特点
我们习惯性地把第一个结点叫作头结点，把最后一个结点叫作尾结点。其中，头结点用来记录链表的基地址。有了它，我们就可以遍历得到整条链表。而尾结点特殊的地方是：指针不是指向下一个结点，而是指向一个空地址 NULL，表示这是
链表上最后一个结点。
插入、删除
在这里插入图片描述
循环链表
双向链表，顾名思义，它支持两个方向，每个结点不止有一个后继指针 next 指向后面的结点，还有一
个前驱指针 prev 指向前面的结点。
在这里插入图片描述
双向链表
在这里插入图片描述
写好链表得技巧

  1. 理解指针或引用的含义
    将某个变量赋值给指针，实际上就是将这个变量的地址赋值给指针，或者反过来说，指针 中存储了这个变量的内存地址，指向了这个变量，通过指针就能找到这个变量。

  2. 警惕指针丢失和内存泄漏

  3. 利用哨兵简化实现难度
    如果我们引入哨兵结点，在任何时候，不管链表是不是空，head 指针都会一直指向这个 哨兵结点。我们也把这种有哨兵结点的链表叫带头链表。相反，没有哨兵结点的链表就叫 作不带头链表。
    哨兵结点是不存储数据的。因为哨兵结点一直存在， 所以插入第一个结点和插入其他结点，删除最后一个结点和删除其他结点，都可以统一为 相同的代码实现逻辑了。

在这里插入图片描述

  1. 重点留意边界条件处理
  2. 举例画图，辅助思考
    单链表得demo
package com.wanda.list;
/**
 * 单链表的实现
 * @author tomcat
 *
 * @param <E>
 */
public class LinkedList<E>{
	private class Node{
		public E e;//数据域
		public Node next;//指向下一个节点的指针
		public Node(E e,Node next) {
			this.e=e;
			this.next=next;
		}
		public Node(E e) {
			this(e,null);
		}
		public Node() {
			this(null,null);
		}
		@Override
		public String toString() {
			return e.toString();
		}
	}
	//虚拟头节点，不存储任何数据
	private Node dummyHead;
	int size;
	public LinkedList() {
		dummyHead=new Node(null,null);
		size=0;
	}
	public int getSize(){
		return size;
		
	}
	public boolean isEmpty() {
		return size==0;
	}
	public void addFirst(E value) {
		/*Node node=new Node(value);
		node.next=head;
		head=node;*/
		add(0,value);
		size++;
	}
	//添加元素
	public void add(int index,E value) {
		if(index<0||index>size) {
			throw new IllegalArgumentException("add failed");
		}
	
			Node prev=dummyHead;
			for(int i=0;i<index;i++) {
				prev=prev.next;
			}
			Node node=new Node(value);
			node.next=prev.next;
			prev.next=node;
			//prev.next=new Node(value,prev.next);
			size++;
		}

	public void addLast(E value) {
		add(size,value);
	} 
	public E get(int index) {
		if(index<0||index>size)
			throw new IllegalArgumentException("get failed");
		Node cur=dummyHead.next;
		for(int i=0;i<index;i++) {
			cur=cur.next;
		}
		return cur.e;
	}
	public E getFirst() {
		return get(0);
	}
	public E getLast() {
		return get(size-1);
	}
	public void set(int index,E e) {
		if(index<0||index>=size) {
			throw new IllegalArgumentException("set failed");
		}
		Node cur=dummyHead.next;
		for(int i=0;i<index;i++) {
			cur=cur.next;
		}
		cur.e=e;
	}
	public boolean contains(E e) {
		Node cur=dummyHead.next;
		while(cur!=null) {
			if(cur.e.equals(e)) {
				return true;
			}
			cur=cur.next;
		}
		return false;
	}
	public E remove(int index) {
		if(index<0||index>=size) {
			throw new IllegalArgumentException("remove failed");
		}
		Node prev=dummyHead.next;
		for(int i=0;i<index-1;i++) {
			prev=prev.next;
		}
		Node retNode=prev.next;
		prev.next=retNode.next;
		retNode.next=null;
		size--;
		return retNode.e;
	}
	public E removeFirst() {
		return remove(0);
	}
	public E removeLast() {
		return remove(size-1);
	}
	public void removeElement(E e) {
		Node prev=dummyHead;
		while(prev.next!=null) {
			if(prev.next.e.equals(e))
				break;
			prev=prev.next;
		}
		if(prev.next!=null) {
			Node delNode=prev.next;
			prev.next=delNode.next;
			delNode.next=null;
		}
	}
	@Override
	public String toString() {
		StringBuilder res=new StringBuilder();
		Node cur=dummyHead.next;
		while(cur!=null) {
			res.append(cur+"->");
			cur=cur.next;	
		}
		res.append("Null");
		return res.toString();
			
	}
}

基于链表得队列

package com.wanda.list;

import com.wanda.interfaces.Queue;


public class LinkedListQueue<E> implements Queue<E> {
	private class Node{
		public E e;
		public Node next;
		public Node(E e,Node next) {
			this.e=e;
			this.next=next;
		}
		public Node(E e) {
			this(e,null);
		}
		public Node() {
			this(null,null);
		}
		@Override
		public String toString() {
			return e.toString();
		}
	}
	private Node head,tail;
	private int size;
	public LinkedListQueue() {
		// TODO Auto-generated constructor stub
		head=null;
		tail=null;
		size=0;
	}
	

	@Override
	public void enqueue(E value) {
		// TODO Auto-generated method stub
		if(tail==null) {
			tail=new Node(value);
			head=tail;
			}else {
				tail.next=new Node(value);
				tail=tail.next;
			}
		size++;
		
	}

	@Override
	public E dequeue() {
		// TODO Auto-generated method stub
		if(isEmpty()) {
			throw new IllegalArgumentException("can not dequeue from an empty queue");
		}
		Node retNode=head;
		head=head.next;
		retNode.next=null;
		if(head==null) {
			tail=null;
		}
		size--;
		return retNode.e;
	}

	@Override
	public E getFront() {
		// TODO Auto-generated method stub
		if(isEmpty()) {
			throw new IllegalArgumentException("can not dequeue from an empty queue");
		}
		return head.e;
	}

	@Override
	public int getSize() {
		// TODO Auto-generated method stub
		return size;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return size==0;
	}

	@Override
	public String toString() {
		StringBuilder res=new StringBuilder();
		res.append("Queue: front");
		Node cur=head;
		while(cur!=null) {
			res.append(cur+"->");
			cur=cur.next;
		}
		res.append("NULL tail");
		return res.toString();
	}

	public static void main(String[] args) {
		LinkedListQueue<Integer> queue=new LinkedListQueue<>();
		for(int i=0;i<10;i++) {
			queue.enqueue(i);
			System.out.println(queue);
		}
	}
}

链表的应用测试是否是回文数

package com.wanda.list;

import java.util.Scanner;
class Node{	//定义节点类
	  char data;
	  Node next;
	 public Node(char t){
		 this.data=t;
	 }	
	 
}
public class IsHuiWen {
	
	public static boolean IsHuiwen(Node head){
		Node n1=head;
		Node n2=head;
//		System.out.println(n2.next.next.data);
		while(n2.next!=null&&n2.next.next!=null){	
//这里有个很容易出错的地方是 如果while循环的循环条件没有加上n2.next!=null则会抱空指针异常，以为当n2已经是最后一个了 则不存在n2.next.next
			//快慢指针 n2前进2步 n1前进1步
			n1=n1.next;
			n2=n2.next.next;
		}//循环结束时n2指向最末尾节点，n1刚好指向中间节点
		
		n2=n1.next;
		Node pre=n1;
		Node next=null;
		while(n2!=null){
			//后半部分节点逆序指向
			next=n2.next;
			n2.next=pre;
			pre=n2;
			n2=next;
		}
		
		n1.next=null;
		n2=pre;
		n1=head;
		while(n1.next!=null&&n2.next!=null){
			//原单链表的前后节点 进行逐一比较 
			if(n1.data!=n2.data)
				return false;
			n1=n1.next;
			n2=n2.next;
		}
		return true;
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner in=new Scanner(System.in);
		String tmp=in.nextLine();
		char[] s=tmp.toCharArray();
		
		Node[] node=new Node[s.length];
		for(int i=0;i<s.length;i++){
			node[i]=new Node(s[i]);				
		}
		for(int i=0;i<s.length;i++){
			if(i==s.length-1){	//最后一个节点，指针指向空
				node[i].next=null;
			}
			else node[i].next=node[i+1];
		}
		boolean flag=IsHuiwen(node[0]);
		System.out.println("链表是回文吗？ "+flag);
	}

}
java小白～
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法 c语言 线性表-静态链表
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
算法与数据结构——链表
qq_47917118的博客
03-18 242
链表 存储结构 顺序存储:地址连续，用数组 链式存储:地址不连续，用指针(引用，面向对象) 链表 链表中的每一个元素称为“结点”，单链表中每个结点都应包括两个部分：一个是需要用到的实际数据data；另一个就是存储下一个结点地址的指针，即数据域和指针域；而双向链表中，每个结点包括存储其上一个结点地址的指针，用到的数据data和存储下一个结点的指针。数据结构中的每一个数据结点对应于一个存储单元，这种储存单元称为储存结点，也可简称结点。 ———————————————— data为实际存放的数据，next为存
数据结构与算法-单链表篇
热门推荐
kwenzh的博客
04-18 1万+
        在数据结构中，链表可能是程序员会建立的最简单的数据结构。也是非常基础的一种数据结构，往往简单的东西越需要扎实，大多数的情况是眼高手低觉得很简单差不多，一写代码就出错，一运行就崩溃，完成链表这一数据结构主要在于对指针的使用。         链表是一种线性的数据结构，相比静态申请数组空间必须要给定长度，链表更加长灵活，如果数据的个数会随着时间变化而增加或者减少，链表是一种很好的存储...
算法和数据结构之链表
fpcc的专栏
06-06 391
一、基础知识 继续造火箭。 什么是链表？顾名思义，链表就是链状的数据结构，可以想象成在日常生活中，一条铁链一环扣一环的链结在一起。每个环上存储了相关的数据。在数据结构中，组成链表的节点通常有两个以上的域，一个域用来存储数据，其它的域用来存储指向其它节点的方式（指针等）。这样通过每个节点的指向其它节点的方式形成一条数据链。 链表可以有头节点，也可以没有头节点，但一定会有尾节点（C/C++中，指向NULL的指针）。链表分为单向链表、双向链表和循环链表三类。这里以单向链表为例，双向链表和循环链表类似，只是多了一些
数据结构与算法——链表
耶律大石的博客
10-03 437
链表 定义 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多...
数据结构与算法（单链表）
王琨的博客
12-12 2711
回忆线性表的定义，它就是一些元素的序列，维持着元素之间的一种线性关系。实现线性表的基本需要是： 1、能够找到表中的首元素； 2、从表里的任一元素出发，可以找到它的下一个元素。 在上一篇中，把表元素保存在连续的存储区里（顺序表），自然可以满足这两点，其中元素间的顺序关联是隐含的。但是考虑到计算机内存的特点，为了满足以上两点，并不一定需要连续存储元素，基于对象之间的链接也可以看做一种顺序关联，基
数据结构-链表相关功能和算法
06-11
数据结构-链表相关功能和算法
【数据结构与算法 - 链表】
04-18
【数据结构与算法 - 链表】 C语言实现 实现模块化
算法与数据结构-综合提升C++版.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
基础算法与数据结构 -- Java 实现.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
算法与数据结构_数据结构与算法：链表
weixin_39911567的博客
10-22 59
链表的典型应用，LRU缓存淘汰算法。缓存是一种可以提高数据读取性能的技术，在硬件设计、软件开发中都有广泛的应用，如CPU缓存，数据库缓存、浏览器缓存。缓存有大小限制，所以需要缓存的清理机制，一般有以下三种策略：先进先出策略FIFO(First In，First Out)最少使用策略LFU(Least Frequently Used)最近最少使用策略LRU(Least Recently Used)实...
数据结构与算法之单向链表
皓晨的架构笔记
06-23 372
前言 链表是一中有序的线性列表，链表与数组不同的是，数组是一种连续存储的线性结构，而链表是以节点的形式来存储的。 链表有分为好几类，分别是： 单向链表：一个节点指向下一个节点 双向链表：一个节点有两个指针域，分别指向前一个节点和后一个节点 循环链表：能通过任何一个节点找到其他所有的节点，将两种(双向/单向)链表的最后一个结点指向第一个结点从而实现循环 此处先讲解单向链表，单向链表每个节点都包含...
数据结构与算法 -- 链表
u012967763的专栏
08-21 524
一点一滴学算法，算法从入门到放弃
04 链表
11-25 213
一、什么是链表 先从数据结构上看。数组需要一块连续的内存存储，但是，如果存储100M的数据，内存中没有连续的足够打的存储空间时，数组就不适合了。 链表正好相反，他不需要连续的内存空间，通过指针将零散的内存块串起来使用。 链表结构五花八门，我们只介绍最常用的三种。单链表、双向链表、循环连表。 二、单链表 刚刚说道，连表是通过指针将一组零散的内存串联在一起。我们把内存块称为链表的节点（node）。为了将节点串联起来，每个节点除了存储数据外，还要存储一个下一个节点的地址。我们把记录下个节点地址.
数据结构与算法：单链表（超详细实现）
重庆李四
02-05 4752
实现算法预览这次博主写的单链表主要实现了以下算法。所有功能可进行循环运行测试。欢迎各位指正。LinkList.h#pragma once #ifndef __LINKLIST_H__ #define __LINKLIST_H__ #define _CRT_SECURE_NO_WARNINGS typedef struct LinkNode LinkNode; typedef struct Link...
数据结构与算法---链表
weixin_55938630的博客
07-02 148
数据结构与算法--单链表
前18大旋转修整器企业占据全球87%的市场份额.docx
05-06
前18大旋转修整器企业占据全球87%的市场份额
Planet-SkySat-Imagery-Product-Specification-Jan2020.pdf
05-06
SKYSAT IMAGERY PRODUCT SPECIFICATION PLANET.COM VIDEO Full motion videos are collected between 30 and 120 seconds by a single camera from any of the active SkySats. Videos are collected using only the Panchromatic half of the camera, hence all videos are PAN only. Videos are packaged and delivered with a video mpeg-4 file, plus all image frames with accompanying video metadata and a frame index file (reference Product Types below)
Screenshot_20240506_133458_com.netease.yhtj.vivo.jpg
最新发布
05-06
Screenshot_20240506_133458_com.netease.yhtj.vivo.jpg
数据结构与算法 链表代码
06-09
好的，以下是一个简单的链表的实现代码，包括链表的创建、插入、删除和遍历等基本操作： ```python class Node: def __init__(self, data=None): self.data = data self.next = None class LinkedList: def __...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值