03-16_链表

Posted 徐伟的博客

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了03-16_链表相关的知识,希望对你有一定的参考价值。

链表

链表是一种根据元素节点逻辑关系排列起来的一种数据结构。利用链表可以保存多个数据,这一点类似于数组的概念,但是数组本身有一个缺点 —— 数组的长度固定,不可改变,在长度固定的情况下首选的肯定是数组,但是在现实的开发之中往往要保存的内容长度是不确定的,那么此时就可以利用链表这样的结构来代替数组的使用。

链表的基本形式

链表是一种最为简单的数据结构,它的主要目的是依靠引用关系来实现多个数据的保存,那么下面假设现在要保存的数据是字符串(引用类型),则可以按照图所示的关系进行保存。

Node类

所有要保存的数据都会被包装到一个节点对象之中,之所以会引用一个节类,是因为只依靠保存的数据无法区分出先后顺序,而引入了Node类可以包装数据以及指向下一个节点,所以在Node类的设计中主要保存两个属性:数据(data)与下一个节点引用(next)

范例:定义一个Node类

class Node { 			// 每一个链表实际上就是由多个节点所组成的
	private String data; 		// 要保存的数据
	private Node next; 		// 要保存的下一个节点
	/**
	 * 每一个Node类对象都必须保存有相应的数据
	 * @param data 要通过节点包装的数据
	 */
	public Node(String data) { 	// 必须有数据才有Node
		this.data = data;
	}
	//setter、getter略
}

链表数据取出

在进行链表操作的时候,首先需要的是一个根节点(第一个节点即为根节点),之后每一个节点的引用都保存在上一节点的next属性之中,而在进行输出的时候也应该按照节点的先后顺序,一个一个取得每一个节点所包装的数据

范例:手工配置节点关系,并使用while循环输出全部节点数据

public class LinkDemo {
	public static void main(String args[]) {
		// 第一步:定义要操作的节点以及设置好包装的字符串数据
		Node root = new Node("火车头") ;// 定义节点,同时包装数据
		Node n1 = new Node("车厢A") ;	// 定义节点,同时包装数据
		Node n2 = new Node("车厢B") ;	// 定义节点,同时包装数据
		root.setNext(n1) ;	// 设置节点关系
		n1.setNext(n2) ;	// 设置节点关系
		// 第二步:根据节点关系取出所有数据
		Node currentNode = root ;	// 当前从根节点开始读取
		while (currentNode != null) {	// 当前节点存在有数据
			System.out.println(currentNode.getData()) ;
			currentNode = currentNode.getNext() ;// 将下一个节点设置为当前节点
		}
	}
}
程序执行结果:
火车头
车厢A
车厢B

程序执行步骤

本程序一共分为了三个操作步骤进行:

  • 第1步:定义各个独立的节点,同时封装要保存的字符串数据;
  • 第2步:配置不同节点彼此之间的操作关系;
  • 第3步:由于现在不清楚要输出的节点个数,只知道输出的结束条件(没有节点就不输出了,curentNode == null)所以使用while循环,依次取得每一个节点,并输出里面包装的数据。

范例:手工配置节点关系,通过递归输出全部节点数据

public class LinkDemo {
	public static void main(String args[]) {
		// 第一步:定义要操作的节点以及设置好包装的字符串数据
		Node root = new Node("火车头") ;	// 定义节点,同时包装数据
		Node n1 = new Node("车厢A") ;	// 定义节点,同时包装数据
		Node n2 = new Node("车厢B") ;	// 定义节点,同时包装数据
		root.setNext(n1) ;		// 设置节点关系
		n1.setNext(n2) ;	// 设置节点关系
		print(root) ;		// 由根节点开始输出
	}
	/**
	 * 利用递归方式输出所有的节点数据
	 * @param current
	 */
	public static void print(Node current) {// 第二步:根据节点关系取出所有数据
		if (current == null) { // 递归结束条件
			return; // 结束方法
		}
		System.out.println(current.getData());// 输出节点包含的数据
		print(current.getNext());	// 递归操作
	}
}
程序执行结果:
火车头  车厢A   车厢B

链表的基本雏形

通过之前的分析,可以发现链表实现之中最为重要的类就是Node,而以上程序都是由用户自己去使用Node类封装要操作的数据,同时由用户自己去匹配节点关系,很明显,这样会给用户操作带来更多的复杂性,而用户实际上只关心链表之中保存的数据有那些,至于说数据是如何保存的,节点间的关系是如何分配的,用户完全不需要知道,所以此时应该定义一个专门负责这个节点操作的类,而这个类可以称为链表操作类 —— Link,专门负责处理节点关系,用户不需要关心节点问题,只需要关心Link的处理操作即可。

链表操作步骤

链表的基础功能

范例:链表的基本开发结构

class Link { 				// 链表类,外部能够看见的只有这一个类
	private class Node { 			// 定义的内部节点类
		private String data; 		// 要保存的数据
		private Node next; 		// 下一个节点引用
		public Node(String data) {	// 每一个Node类对象都必须保存有相应的数据
			this.data = data;
		}
	}
	// ===================== 以上为内部类 ===================
	private Node root; 			// 根节点定义
}

在本结构中将Node定义为了Link的私有内部类,这样做有两个好处:

  • Node类只会为Link类服务,并且可以利用Node类匹配节点关系;
  • 外部类与内部类之间方便进行私有属性的直接访问,所以不需要在Node类中定义setter、getter方法。

数据增加:public void add(数据类型 变量)

class Link { 				// 链表类,外部能够看见的只有这一个类
	private class Node { 			// 定义的内部节点类
		private String data; 		// 要保存的数据
		private Node next; 		// 下一个节点引用
		public Node(String data) {	// 每一个Node类对象都必须保存有相应的数据
			this.data = data;
		}
		/**
		 * 设置新节点的保存,所有的新节点保存在最后一个节点之后
		 * @param newNode 新节点对象
		 */
		public void addNode(Node newNode) {
			if (this.next == null) {		// 当前的下一个节点为null
				this.next = newNode ;	// 保存节点
			} else {		// 向后继续保存
				this.next.addNode(newNode) ;
			}
		}
	}
	
	

数据增加:public void add(数据类型 变量)

	// ===================== 以上为内部类 ===================
	private Node root; 			// 根节点定义
	/**
	 * 用户向链表增加新的数据,在增加时要将数据封装为Node类,这样才可以匹配节点顺序
	 * @param data 要保存的数据
	 */
	public void add(String data) { 		// 假设不允许有null
		if (data == null) {		// 判断数据是否为空
			return;			// 结束方法调用
		}
		Node newNode = new Node(data); 	// 要保存的数据
		if (this.root == null) { 		// 当前没有根节点
			this.root = newNode; 	// 保存根节点
		} else { 		// 根节点存在
			this.root.addNode(newNode);	// 交给Node类处理节点的保存
		}
	}
}

取得保存元素个数:public int size()

private int count = 0 ;	// 保存元素的个数
	/**
	 * 用户向链表增加新的数据,在增加时要将数据封装为Node类,这样才可以匹配节点顺序
	 * @param data 要保存的数据
	 */
	public void add(String data) { 		// 假设不允许有null
		if (data == null) {		// 判断数据是否为空
			return;		// 结束方法调用
		}
		Node newNode = new Node(data); 	// 要保存的数据
		if (this.root == null) { 		// 当前没有根节点
			this.root = newNode; 	// 保存根节点
		} else { 				// 根节点存在
			this.root.addNode(newNode);	// 交给Node类处理节点的保存
		}
		this.count ++ ;		// 数据保存成功后保存个数加一
	}
public int size() { 				// 取得保存的数据量
		return this.count;
	}

判断是否是空链表:public boolean isEmpty()

所谓的空链表(不是null)指的是链表之中不保存任何的数据,空链表判断实际上可以通过两种方式完成:
第一种:判断root有对象(是否为null);
第二种:判断保存的数据量(count)。

	/**
	 * 判断是否是空链表,表示长度为0,不是null
	 * @return 如果链表中没有保存任何的数据则返回true,否则返回false
	 */
	public boolean isEmpty() {
		return this.count == 0;
	}

数据查询:public boolean contains(数据类型 变量)

在链表之中一定会保存有多个数据,那么基本的判断数据是否存在的方式。以:String为例(equals()方法判断),在判断一个字符串是否存在时需要循环链表中的全部内容,并且与要查询的数据进行匹配,如果查找到了则返回true,否则返回false

范例:在Node类增加方法

		/**
		 * 数据检索操作,判断指定数据是否存在
		 * 第一次调用(Link):this = Link.root
		 * 第二次调用(Node):this = Link.root.next
		 * @param data 要查询的数据
		 * @return 如果数据存在返回true,否则返回false
		 */
		public boolean containsNode(String data) {
			if (data.equals(this.data)) { 	// 当前节点数据为要查询的数据
				return true; 		// 后面不再查询了
			} else { 		// 当前节点数据不满足查询要求
				if (this.next != null) { 	// 有后续节点
					return this.next.containsNode(data);// 递归调用继续查询
				} else { 		// 没有后续节点
					return false; 	// 没有查询到返回false
				}
			}
		}

	/**
	 * 数据查询操作,判断指定数据是否存在,如果链表没有数据直接返回false
	 * @param data 要判断的数据
	 * @return 数据存在返回true,否则返回false
	 */
	public boolean contains(String data) {
		if (data == null || this.root == null) {	// 现在没有要查询的数据,根节点也不保存数据
			return false ;		// 没有查询结果
		}
		return this.root.containsNode(data) ;	// 交由Node类查询
	}

根据索引取得数据:public 数据类型 get(int index)

链表本身就属于一种动态的对象数组,与普通的对象数组相比最大的优势就在于没有长度限制。那么既然链表属于动态对象数组,也就应该具备像数组那样可以根据索引取得元素的功能,自然也就能根据指定索引取得指定节点数据的操作

范例:在Link类添加处理程序

范例:在Link类里面增加一个foot的属性,表示每一个Node元素的编号

private int foot = 0 ;	// 节点索引

范例:在每一次查询的时候(一个链表可能查询多次),那么foot应该在每一次查询时都从头开始计算(foot设为0);

/**
	 * 根据索引取得保存的节点数据
	 * @param index 索引数据
	 * @return 如果要取得的索引内容不存在或者大于保存个数返回null,反之返回数据
	 */
	public String get(int index) {
		if (index > this.count) {	// 超过了查询范围
			return null ;	// 没有数据
		}
		this.foot = 0 ;		// 表示从前向后查询
		return this.root.getNode(index) ;	// 查询过程交给Node类
	}

范例:在Node类里面实现getNode()方法

		/**
		 * 根据索引取出数据,此时该索引一定是存在的
		 * @param index 要取得数据的索引编号
		 * @return 返回指定索引节点包含的数据
		 */
		public String getNode(int index) {
		// 使用当前的foot内容与要查询的索引进行比较,随后将foot的内容自增,目的是为了下次查询方便
			if (Link.this.foot++ == index) {	// 当前为要查询的索引
				return this.data; // 返回当前节点数据
			} else { 			// 继续向后查询
				return this.next.getNode(index);	// 进行下一个节点的判断
			}
		}

修改指定索引内容:public void set(int index,数据类型 变量)


		/**
		 * 修改指定索引节点包含的数据
		 * @param index 要修改的索引编号
		 * @param data 新数据
		 */
		public void setNode(int index, String data) {
			// 使用当前的foot内容与要查询的索引进行比较,随后将foot的内容自增,目的是为了下次查询方便
			if (Link.this.foot++ == index) {	// 当前为要修改的索引
				this.data = data; 	// 进行内容的修改
			} else {
			this.next.setNode(index, data);// 继续下一个节点的索引判断
			}
		}

范例:在Link类里面增加set()方法

	/**
	 * 根据索引修改数据
	 * @param index 要修改数据的索引编号
	 * @param data 新的数据内容
	 */
	public void set(int index, String data) {
		if (index > this.count) {		// 判断是否超过了保存范围
			return; 		// 结束方法调用
		}
		this.foot = 0; 	// 重新设置foot属性的内容,作为索引出现
		this.root.setNode(index, data); 	// 交给Node类设置数据内容
	}

数据删除:public void remove(数据类型 变量)

对于链表之中的内容,之前完成的是增加操作和查询操作,但是从链表之中也会存在删除数据的操作,可是删除数据的操作需要分两种情况讨论。

情况一:

要删除的数据是根节点,则root应该变为“根节点.next”(根节点的下一个节点为新的根节点),并且由于根节点需要被Link类所,所以此种情况要在Link类中进行处理

情况二:

要删除的不是根节点,而是其它的普通节点,这个时候删除节点的操作应该放在Node类里处理,并且由于Link类已经判断过根节点,所以此处应该从第二个节点开始判断的

范例:在Node类里面增加一个removeNode()方法
	/**
	 * 节点的删除操作,匹配每一个节点的数据,如果当前节点数据符合删除数据,
	 * 则使用“当前节点上一节点.next = 当前节点.next”方式空出当前节点
	 * 第一次调用(Link),previous = Link.root、this = Link.root.next
	 * 第二次调用(Node),previous = Link.root.next、this = Link.root.next.next
	 * @param previous 当前节点的上一个节点
	 * @param data 要删除的数据
	 */
	public void removeNode(Node previous, String data) {
		if (data.equals(this.data)) { 	// 当前节点为要删除节点
			previous.next = this.next; 	// 空出当前节点
		} else { 			// 应该向后继续查询
			this.next.removeNode(this, data);	// 继续下一个判断
			}
		}

范例:在Link类里面增加根节点的判断
	/**
	 * 链表数据的删除操作,在删除前要先使用contains()判断链表中是否存在有指定数据
	 * 如果要删除的数据存在则首先判断根节点的数据是否为要删除数据
	 * 如果是则将根节点的下一个节点作为新的根节点
	 * 如果要删除的数据不是根节点数据,则将删除操作交由Node类的removeNode()方法完成
	 * @param data 要删除的数据
	 */
	public void remove(String data) {
		if (this.contains(data)) { 	// 主要功能是判断数据是否存在
			// 要删除数据是否是根节点数据,root是Node类的对象,此处直接访问了内部类的私有操作
			if (data.equals(this.root.data)) { 	// 根节点数据为要删除数据
				this.root = this.root.next; 	// 空出当前根节点
			} else { 		// 根节点数据不是要删除数据
				// 此时根元素已经判断过了,从第二个元素开始判断,即第二个元素的上一个元素为根节点
				this.root.next.removeNode(this.root, data);
			}
			this.count--; 	// 删除成功后个数要减少
		}
	}

将链表变为对象数组:public 数据类型 [] toArray()

对于链表的这种数据结构,在实际的开发之中,最为关键的是两个操作:增加数据、取得全部数据,而链表本身属于一种动态的对象数组,所以在链表输出时,最好的做法是将链表中所保存的数据以对象数组的方式返回,而这个返回的对象数组长度也应该是根据保存数据的个数来决定的

范例:修改Link类的定义

增加一个返回的数组属性内容,之所以将其定义为属性,是因为内部类和外部类都可以访问;

private String [] retArray ;	// 返回的数组

增加toArray()方法。

	/**
	 * 将链表中的数据转换为对象数组输出
	 * @return 如果链表没有数据返回null,如果有数据则将数据变为对象数组后返回
	 */
	public String[] toArray() {
		if (this.root == null) {	// 判断链表是否有数据
			return null;	// 没有数据返回null
		}
		this.foot = 0; // 脚标清零操作
		this.retArray = new String[this.count];	// 根据保存内容开辟数组
		this.root.toArrayNode(); // 交给Node类处理
		return this.retArray;	// 返回数组对象
	}

范例:在Node类里面处理数组数据的保存
		/**
		 * 将节点中保存的内容转化为对象数组
		 * 第一次调用(Link):this = Link.root;
		 * 第二次调用(Node):this = Link.root.next;
		 */
		public void toArrayNode() {
			Link.this.retArray[Link.this.foot++] = this.data;	// 取出数据并保存在数组之中
			if (this.next != null) { 	// 有后续元素
				this.next.toArrayNode();	// 继续下一个数据的取得
			}
		}

清空链表:public void clear()
	public void clear() {
		this.root = null;		// 清空链表
		this.count = 0;		// 元素个数为0
	}

以上是关于03-16_链表的主要内容,如果未能解决你的问题,请参考以下文章

这些 C++ 代码片段有啥作用?

[AndroidStudio]_[初级]_[配置自动完成的代码片段]

C语言反转单向链表的代码

VSCode 配置 用户自定义代码片段 自定义自动代码补充

JavaScript笔试题(js高级代码片段)

[AndroidStudio]_[初级]_[配置自动完成的代码片段]