三十.链表的定义与使用

最新推荐文章于 2022-09-30 17:10:26 发布
最新推荐文章于 2022-09-30 17:10:26 发布
阅读量251 收藏 1
点赞数
分类专栏： Java面向对象 文章标签： 链表 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hai__zi/article/details/117668065
版权

链表实现简介

链表是一种非顺序的动态的对象数组，它可以实现若干个对象的储存。
数据之间的逻辑顺序是靠链表中的指针来实现的。而链表本身由结点组成、结点可以在运动时动态生成；

链表的存储结构

一般的对象数组是通过下标来进行控制的，这样也就有一个缺点，那就是长度是固定的。这样的话就会有个限制，而我们使用数组不能超过这个限制。那么要实现数据的动态维护，难度太高了。所以现在对于一成不变的数据就用对象数组，对于可能随时变化的数据就必须实现一个可以动态扩充的对象数组我们就使用链表。

所谓的链表实质性的本质是利用引用的逻辑关系来实现类似于数组的数据处理操作，以一种保存“多”方数据的形式，实现数组类似的功能。

如果要实现链表的处理，那么需要有一个公共的结构，这个结构可以实现数据的保存以及下一个连接的指向。为了描述这样的逻辑，可以把每一个存储理解为一个节点，所以此时应该准备出一个节点类，这个节点类里面可以保存各种数据类型的数据。
在这里插入图片描述

public class Node<E> {
	
	private E data;				//存储数据
	private Node next;			//存储下一个节点
	
	//设置数据与节点
	public Node(E data){
		this.data = data;
	}
	
	public void setNode(Node next){
		this.next = next;
	}
	
	//返回数据与节点
	public E getData(){
		return this.data;
	}
	
	public Node getNode(){
		return this.next;
	}


}

//测试类
public class Test{
	public static void main(String[] args) 
	{
		Node<String> n1 = new Node<String>("火车头");
		Node<String> n2 = new Node<String>("车厢一");
		Node<String> n3 = new Node<String>("车厢二");
		Node<String> n4 = new Node<String>("车厢三");
		Node<String> n5 = new Node<String>("车厢四");
		//设置下一个节点next
		n1.setNode(n2);
		n2.setNode(n3);
		n3.setNode(n4);
		n4.setNode(n5);
 
		//调用print方法
		print(n1);
	}
 
	public static void print(Node<?> node){
		if(node != null){	//有节点
			System.out.println(node.getData());
			print(node.getNode());//递归调用
		}
	}
}

输出结果：

火车头
车厢一
车厢二
车厢三
车厢四

基本结构

@SuppressWarnings("all")
public class LinkList<E> implements ILink<E> {
    
	private class Node<E>{
		private E data; 		//存储的数据
		private Node next;		//下一个节点
		
		public Node(E data){	//构造方法,在实例化的时候存储数据
			this.data = data;
		}
	}
	
	private Node root;			//作为链表的头

	
	//-----------------以下是ILink方法---------------------

	//遍历
	@Override
	public void printList() {
		Node<E> next = this.root;		//获取第一个数据
		
		while (true) {					//无限循环
			if (next == null) {			//为null
				break;					//跳出循环
			}
			
			System.out.println(next.data);	//输出数据
			next = next.next;			//获取下一个节点
		}
	}
}

interface ILink<E>{
	public void printList();		//遍历
}

数据增加

这里面为了避免数据问题就使用了泛型，同时也设计了一个标准的链表接口

package amazon;

@SuppressWarnings("all")
public class LinkList<E> implements ILink<E> {
    
	private class Node<E>{
		private E data; 		//存储的数据
		private Node next;		//下一个节点
		
		public Node(E data){	//构造方法,在实例化的时候存储数据
			this.data = data;
		}
		
		public void addNode(Node next){	//保存新的数据
			if (this.next == null) {	//如果是节点
				this.next = next;		//则添加进去
			}else{	//如果有了节点
				this.next.addNode(next);//继续往下查空节点
			}
		}
	}
	
	private Node root;			//作为链表的头

	
	//-----------------以下是ILink方法---------------------
	//添加
	@Override
	public void add(E data) {
		if (data == null) {		//保存数据为null
			return;				//结束方法直接返回
		}
		
		Node<E> next = new Node<E>(data);		//创建一个新的节点
		if (this.root == null) {		//没有根节点
			this.root = next;			//第一个节点做为根节点
		}else{	//根节点存在
			this.root.addNode(next);	//当有了根节点，就往下一个节点添加
		}
		
	}

	
	//遍历
	@Override
	public void printList() {
		Node<E> next = this.root;		//获取第一个数据
		
		while (true) {					//无限循环
			if (next == null) {			//为null
				break;					//跳出循环
			}
			
			System.out.println(next.data);	//输出数据
			next = next.next;			//获取下一个节点
		}
	}
}

interface ILink<E>{
	
	public void add(E data);		//添加
	
	public void printList();		//遍历
}

public static void main(String[] args) {
		
		ILink<String> all = new LinkList<String>();
		all.add("Hello");
		all.add("World");
		all.add("ddddd");
		
		all.printList();
		
	}

输出结果：

Hello
World
ddddd

获取集合个数

统计链表的数量，只需要在LinkList中创建一个私有的方法用来保存个数就行了，在添加和删除的方法里面分别用++和–在进行记录。

package amazon;

@SuppressWarnings("all")
public class LinkList<E> implements ILink<E> {
    
	private class Node<E>{
		private E data; 		//存储的数据
		private Node next;		//下一个节点
		
		public Node(E data){	//构造方法,在实例化的时候存储数据
			this.data = data;
		}
		
		public void addNode(Node next){	//保存新的数据
			if (this.next == null) {
				this.next = next;
			}else{
				this.next.addNode(next);
			}
		}
	}
	//-----------------以下是LinkList的成员属性--------------
	private Node root;			//作为链表的根节点
	private int count;			//作为链表的长度/数量
	
	//-----------------以下是ILink方法---------------------
	//添加
	@Override
	public void add(E data) {
		if (data == null) {		//保存数据为null
			return;				//结束方法直接返回
		}
		
		Node<E> next = new Node<E>(data);		//创建一个新的节点
		if (this.root == null) {		//没有根节点
			this.root = next;			//第一个节点做为根节点
		}else{	//根节点存在
			this.root.addNode(next);	//当有了根节点，就往下一个节点添加
		}
		
		this.count++;		//每添加一个对象都会加一
	}
	
	@Override
	public int size(){
		return this.count;
	}
	
	//遍历
	@Override
	public void printList() {
		Node<E> next = this.root;		//获取第一个数据
		
		while (true) {					//无限循环
			if (next == null) {			//为null
				break;					//跳出循环
			}
			
			System.out.println(next.data);	//输出数据
			next = next.next;			//获取下一个节点
		}
	}
}

interface ILink<E>{
	
	public void add(E data);		//添加
	public int size();				//长度
	
	public void printList();		//遍历
}

public static void main(String[] args) {
		
		ILink<String> all = new LinkList<String>();
		all.add("Hello");
		all.add("World");
		all.add("ddddd");
		
		System.out.println(all.size());
		
	}

输出结果：

3

空集合判断

链表里面可以保存有若干个数据，如果现在链表还没有保存数据，则就表示是一个空集合，应该提供有一个空的判断

package amazon;

@SuppressWarnings("all")
public class LinkList<E> implements ILink<E> {
    
	private class Node<E>{
		private E data; 		//存储的数据
		private Node next;		//下一个节点
		
		public Node(E data){	//构造方法,在实例化的时候存储数据
			this.data = data;
		}
		
		public void addNode(Node next){	//保存新的数据
			if (this.next == null) {
				this.next = next;
			}else{
				this.next.addNode(next);
			}
		}
	}
	//-----------------以下是LinkList的成员属性--------------
	private Node root;			//作为链表的根节点
	private int count;			//作为链表的长度/数量
	
	//-----------------以下是ILink方法---------------------
	//添加
	@Override
	public void add(E data) {
		if (data == null) {		//保存数据为null
			return;				//结束方法直接返回
		}
		
		Node<E> next = new Node<E>(data);		//创建一个新的节点
		if (this.root == null) {		//没有根节点
			this.root = next;			//第一个节点做为根节点
		}else{	//根节点存在
			this.root.addNode(next);	//当有了根节点，就往下一个节点添加
		}
		
		this.count++;		//每添加一个对象都会加一
	}
	
	//长度
	@Override
	public int size(){
		return this.count;
	}
	
	//判断是否为空
	@Override
	public boolean isEmpty() {
		return this.count == 0;		//true为空，false非空
	}
	
	//遍历
	@Override
	public void printList() {
		Node<E> next = this.root;		//获取第一个数据
		
		while (true) {					//无限循环
			if (next == null) {			//为null
				break;					//跳出循环
			}
			
			System.out.println(next.data);	//输出数据
			next = next.next;			//获取下一个节点
		}
	}

}

interface ILink<E>{
	
	public void add(E data);		//添加
	public int size();				//长度
	public boolean isEmpty();		//判断链表是否为空
	
	public void printList();		//遍历
}

public static void main(String[] args) {
		
		ILink<String> all = new LinkList<String>();
		all.add("Hello");
		all.add("World");
		
		System.out.println(all.isEmpty());
		
	}

输出结果：

false

返回集合数据

链表本身就属于一个动态对象数组，那么既然是一个对象数组，就应该可以把所有的数据以数组的形式返回来，这时可以定义一个toArray()方法，但是这个时候只能返回Object型的数组。

package amazon;

@SuppressWarnings("all")
public class LinkList<E> implements ILink<E> {
    
	private class Node<E>{
		private E data; 		//存储的数据
		private Node next;		//下一个节点
		
		public Node(E data){	//构造方法,在实例化的时候存储数据
			this.data = data;
		}
		
		public void addNode(Node next){	//保存新的数据
			if (this.next == null) {
				this.next = next;
			}else{
				this.next.addNode(next);
			}
		}
		
		public void toArrayNode(){
			//从内部类获取外部类的私有成员
			LinkList.this.returnData[LinkList.this.foot++] = this.data;	
			if (this.next != null) {//如果还有下一个节点  继续调用这个方法
				next.toArrayNode();
			}
		}
	}
	//-----------------以下是LinkList的成员属性--------------
	private Node root;			//作为链表的根节点
	private int count;			//作为链表的长度/数量
	private int foot = 0;			//数组下标
	private Object[] returnData;	//返回的数组
	
	//-----------------以下是ILink方法---------------------
	//添加
	@Override
	public void add(E data) {
		if (data == null) {		//保存数据为null
			return;				//结束方法直接返回
		}
		
		Node<E> next = new Node<E>(data);		//创建一个新的节点
		if (this.root == null) {		//没有根节点
			this.root = next;			//第一个节点做为根节点
		}else{	//根节点存在
			this.root.addNode(next);	//当有了根节点，就往下一个节点添加
		}
		
		this.count++;		//每添加一个对象都会加一
	}
	
	//长度
	@Override
	public int size(){
		return this.count;
	}
	
	//判断是否为空
	@Override
	public boolean isEmpty() {
		return this.count == 0;		//true为空，false非空
	}
	
	//数据集合
	@Override
	public Object[] toArray() {
		if (this.isEmpty()) {		//判断谁为空
			return null;			//直接返回
		}
		
		this.foot = 0;				//下标归零
		this.returnData = new Object[this.count];	//因为记录了长度 直接用就行了
		this.root.toArrayNode();	//利用Node进行递归数据获取
		//因为数组是引用类型  所以在上面这个方法获取就行了
		return this.returnData;
	}
	
	//遍历
	@Override
	public void printList() {
		Node<E> next = this.root;		//获取第一个数据
		
		while (true) {					//无限循环
			if (next == null) {			//为null
				break;					//跳出循环
			}
			
			System.out.println(next.data);	//输出数据
			next = next.next;			//获取下一个节点
		}
	}

}

interface ILink<E>{
	
	public void add(E data);		//添加
	public int size();				//长度
	public boolean isEmpty();		//判断链表是否为空
	public Object[] toArray();		//数据集合
	
	public void printList();		//遍历
}


public static void main(String[] args) {
		
		ILink<String> all = new LinkList<String>();
		all.add("Hello");
		all.add("World");
		
		Object[] result = all.toArray();
		for(Object x : result){
			System.out.println(x);
		}
		
	}

输出结果：

Hello
World

根据索引取得数据

链表可以像数组一样进行处理，所以也应该可以像数组一样进行索引数据取得，在这样的情况下就可以继续利用递归的形式来完成。

package amazon;

@SuppressWarnings("all")
public class LinkList<E> implements ILink<E> {
    
	private class Node<E>{
		private E data; 		//存储的数据
		private Node next;		//下一个节点
		
		public Node(E data){	//构造方法,在实例化的时候存储数据
			this.data = data;
		}
		
		public void addNode(Node next){	//保存新的数据
			if (this.next == null) {
				this.next = next;
			}else{
				this.next.addNode(next);
			}
		}
		
		public void toArrayNode(){
			//从内部类获取外部类的私有成员
			
			LinkList.this.returnData[LinkList.this.foot++] = this.data;	
			if (this.next != null) {//如果还有下一个节点  继续调这个方法
				this.next.toArrayNode();
			}
		}
		
		public E getNode(int index){
			if(LinkList.this.foot++ == index){	//索引相同
				return this.data;	//返回当前数据
			}else{
				return (E) this.next.getNode(index);	//递归调用
			}
		}
	}
	//-----------------以下是LinkList的成员属性--------------
	private Node root;			//作为链表的根节点
	private int count;			//作为链表的长度/数量
	private int foot;			//数组下标
	private Object[] returnData;	//返回的数组
	
	//-----------------以下是ILink方法---------------------
	//添加
	@Override
	public void add(E data) {
		if (data == null) {		//保存数据为null
			return;				//结束方法直接返回
		}
		
		Node<E> next = new Node<E>(data);		//创建一个新的节点
		if (this.root == null) {		//没有根节点
			this.root = next;			//第一个节点做为根节点
		}else{	//根节点存在
			this.root.addNode(next);	//当有了根节点，就往下一个节点添加
		}
		
		this.count++;		//每添加一个对象都会加一
	}
	
	//长度
	@Override
	public int size(){
		return this.count;
	}
	
	//判断是否为空
	@Override
	public boolean isEmpty() {
		return this.count == 0;		//true为空，false非空
	}
	
	//数据集合
	@Override
	public Object[] toArray() {
		if (this.isEmpty()) {		//判断谁为空
			return null;			//直接返回
		}
		
		this.foot = 0;				//下标归零
		this.returnData = new Object[this.count];	//因为记录了长度 直接用就行了
		this.root.toArrayNode();	//利用Node进行递归数据获取
		//因为数组是引用类型  所以在上面这个方法获取就行了
		return this.returnData;
	}
	
	//遍历
	@Override
	public void printList() {
		Node<E> next = this.root;		//获取第一个数据
		
		while (true) {					//无限循环
			if (next == null) {			//为null
				break;					//跳出循环
			}
			
			System.out.println(next.data);	//输出数据
			next = next.next;			//获取下一个节点
		}
	}
	
	//根据下标获取数据
	@Override
	public E get(int index){
		if(index >= this.count){	//索引应该在指定范围之内
			return null;
		}
		//索引数据的获取应该有Node类完成 
		this.foot = 0;//重置索引的下标
		return (E) this.root.getNode(index);
	}


}

interface ILink<E>{
	
	public void add(E data);		//添加
	public int size();				//长度
	public boolean isEmpty();		//判断链表是否为空
	public Object[] toArray();		//数据集合
	public E get(int index);		//根据索引取得数据
	
	public void printList();		//遍历
}

public static void main(String[] args) {
		
		ILink<String> all = new LinkList<String>();
		all.add("Hello1");
		all.add("World2");
		all.add("World3");
		
		Object[] result = all.toArray();
		for(Object x : result){
			System.out.println(x);
		}
		System.out.println("-------------------------------");
		System.out.println(all.get(1));
		
	}

输出结果：

Hello1
World2
World3
-------------------------------
World2

修改链表数据

现在可以根据索引来获取指定的数据了，但是既然可以获取数据，也就可以进行数据的修改。

package amazon;

@SuppressWarnings("all")
public class LinkList<E> implements ILink<E> {
    
	private class Node<E>{
		private E data; 		//存储的数据
		private Node next;		//下一个节点
		
		public Node(E data){	//构造方法,在实例化的时候存储数据
			this.data = data;
		}
		
		public void addNode(Node next){	//保存新的数据
			if (this.next == null) {
				this.next = next;
			}else{
				this.next.addNode(next);
			}
		}
		
		public void toArrayNode(){
			//从内部类获取外部类的私有成员 没次加一保证下一次拿到的是加一的foot
			LinkList.this.returnData[LinkList.this.foot++] = this.data;	
			if (this.next != null) {//如果还有下一个节点  继续调这个方法
				this.next.toArrayNode();
			}
		}
		
		public E getNode(int index){
			//从内部类获取外部类的私有成员 没次加一保证下一次拿到的是加一的foot
			if(LinkList.this.foot++ == index){	//索引相同
				return this.data;	//返回当前数据
			}else{
				return (E) this.next.getNode(index);	//递归调用
			}
		}
		
		public void setNode(int index,E data){
			//从内部类获取外部类的私有成员 没次加一保证下一次拿到的是加一的foot
			if(LinkList.this.foot++ == index){	//索引相同
				this.data = data;
			}else{
				this.next.setNode(index, data);
			}
		}
	}
	//-----------------以下是LinkList的成员属性--------------
	private Node root;			//作为链表的根节点
	private int count;			//作为链表的长度/数量
	private int foot;			//数组下标
	private Object[] returnData;	//返回的数组
	
	//-----------------以下是ILink方法---------------------
	//添加
	@Override
	public void add(E data) {
		if (data == null) {		//保存数据为null
			return;				//结束方法直接返回
		}
		
		Node<E> next = new Node<E>(data);		//创建一个新的节点
		if (this.root == null) {		//没有根节点
			this.root = next;			//第一个节点做为根节点
		}else{	//根节点存在
			this.root.addNode(next);	//当有了根节点，就往下一个节点添加
		}
		
		this.count++;		//每添加一个对象都会加一
	}
	
	//长度
	@Override
	public int size(){
		return this.count;
	}
	
	//判断是否为空
	@Override
	public boolean isEmpty() {
		return this.count == 0;		//true为空，false非空
	}
	
	//数据集合
	@Override
	public Object[] toArray() {
		if (this.isEmpty()) {		//判断谁为空
			return null;			//直接返回
		}
		
		this.foot = 0;				//下标归零
		this.returnData = new Object[this.count];	//因为记录了长度 直接用就行了
		this.root.toArrayNode();	//利用Node进行递归数据获取
		//因为数组是引用类型  所以在上面这个方法获取就行了
		return this.returnData;
	}
	
	//遍历
	@Override
	public void printList() {
		Node<E> next = this.root;		//获取第一个数据
		
		while (true) {					//无限循环
			if (next == null) {			//为null
				break;					//跳出循环
			}
			
			System.out.println(next.data);	//输出数据
			next = next.next;			//获取下一个节点
		}
	}
	
	//根据下标获取数据
	@Override
	public E get(int index){
		if(index >= this.count){	//索引应该在指定范围之内
			return null;
		}
		//索引数据的获取应该有Node类完成 
		this.foot = 0;//重置索引的下标
		return (E) this.root.getNode(index);
	}
	
	//根据下标修改数据
	@Override
	public void set(int index, E data) {
		if(index >= this.count){	//索引应该在指定范围之内
			return;
		}
		//索引数据的获取应该有Node类完成 
		this.foot = 0;//重置索引的下标
		this.root.setNode(index, data);
	}
}

interface ILink<E>{
	
	public void add(E data);		//添加
	public int size();				//长度
	public boolean isEmpty();		//判断链表是否为空
	public Object[] toArray();		//数据集合
	public E get(int index);		//根据索引取得数据
	public void set(int index,E data);	//根据索引修改数据
	
	public void printList();		//遍历
}

public static void main(String[] args) {
		
		ILink<String> all = new LinkList<String>();
		all.add("Hello1");
		all.add("World2");
		all.add("World3");
		
		Object[] result = all.toArray();
		for(Object x : result){
			System.out.println(x);
		}
		System.out.println("----------------1---------------");
		System.out.println(all.get(1));
		all.set(1, "萝莉");
		System.out.println("----------------2---------------");
		System.out.println(all.get(1));
	}

输出结果：

Hello1
World2
World3
----------------1---------------
World2
----------------2---------------
萝莉

数据内容查询

在一个集合里面往往需要保存有大量的数据，有些时候需要判断某个数据是否存在，这个时候通过对象比较的模式（eauals()）来完成。

package amazon;

@SuppressWarnings("all")
public class LinkList<E> implements ILink<E> {
    
	private class Node<E>{
		private E data; 		//存储的数据
		private Node next;		//下一个节点
		
		public Node(E data){	//构造方法,在实例化的时候存储数据
			this.data = data;
		}
		
		//添加数据
		public void addNode(Node next){	//保存新的数据
			if (this.next == null) {
				this.next = next;
			}else{
				this.next.addNode(next);
			}
		}
		
		//设置成数组
		public void toArrayNode(){
			//从内部类获取外部类的私有成员 没次加一保证下一次拿到的是加一的foot
			LinkList.this.returnData[LinkList.this.foot++] = this.data;	
			if (this.next != null) {//如果还有下一个节点  继续调这个方法
				this.next.toArrayNode();
			}
		}
		
		//根据索引查询数据
		public E getNode(int index){
			//从内部类获取外部类的私有成员 没次加一保证下一次拿到的是加一的foot
			if(LinkList.this.foot++ == index){	//索引相同
				return this.data;	//返回当前数据
			}else{
				return (E) this.next.getNode(index);	//递归调用
			}
		}
		
		//根据索引修改数据
		public void setNode(int index,E data){
			//从内部类获取外部类的私有成员 没次加一保证下一次拿到的是加一的foot
			if(LinkList.this.foot++ == index){	//索引相同
				this.data = data;
			}else{
				this.next.setNode(index, data);//递归调用
			}
		}
		
		//判断数据是否存在
		public boolean containsNode(E data){
			if (this.data.equals(data)) {	//判断数据是否相等
				return true;		//返回true
			}else{	
				if (this.next == null) {	//判断是否还有下一个节点
					return false;	//返回false
				}
			}
			return this.next.containsNode(data);	//递归调用
		}
	}
	//-----------------以下是LinkList的成员属性--------------
	private Node root;			//作为链表的根节点
	private int count;			//作为链表的长度/数量
	private int foot;			//数组下标
	private Object[] returnData;	//返回的数组
	
	//-----------------以下是ILink方法---------------------
	//添加
	@Override
	public void add(E data) {
		if (data == null) {		//保存数据为null
			return;				//结束方法直接返回
		}
		
		Node<E> next = new Node<E>(data);		//创建一个新的节点
		if (this.root == null) {		//没有根节点
			this.root = next;			//第一个节点做为根节点
		}else{	//根节点存在
			this.root.addNode(next);	//当有了根节点，就往下一个节点添加
		}
		
		this.count++;		//每添加一个对象都会加一
	}
	
	//长度
	@Override
	public int size(){
		return this.count;
	}
	
	//判断是否为空
	@Override
	public boolean isEmpty() {
		return this.count == 0;		//true为空，false非空
	}
	
	//数据集合
	@Override
	public Object[] toArray() {
		if (this.isEmpty()) {		//判断谁为空
			return null;			//直接返回
		}
		
		this.foot = 0;				//下标归零
		this.returnData = new Object[this.count];	//因为记录了长度 直接用就行了
		this.root.toArrayNode();	//利用Node进行递归数据获取
		//因为数组是引用类型  所以在上面这个方法获取就行了
		return this.returnData;
	}
	
	//遍历
	@Override
	public void printList() {
		Node<E> next = this.root;		//获取第一个数据
		
		while (true) {					//无限循环
			if (next == null) {			//为null
				break;					//跳出循环
			}
			
			System.out.println(next.data);	//输出数据
			next = next.next;			//获取下一个节点
		}
	}
	
	//根据下标获取数据
	@Override
	public E get(int index){
		if(index >= this.count){	//索引应该在指定范围之内
			return null;
		}
		//索引数据的获取应该有Node类完成 
		this.foot = 0;//重置索引的下标
		return (E) this.root.getNode(index);
	}
	
	//根据下标修改数据
	@Override
	public void set(int index, E data) {
		if(index >= this.count){	//索引应该在指定范围之内
			return;
		}
		//索引数据的获取应该有Node类完成 
		this.foot = 0;//重置索引的下标
		this.root.setNode(index, data);
	}
	
	//判断数据是否存在
	@Override
	public boolean contains(E data) {
		if (data == null) {		//为null返回false
			return false;
		}
		return this.root.containsNode(data);	
	}
}

interface ILink<E>{
	
	public void add(E data);		//添加
	public int size();				//长度
	public boolean isEmpty();		//判断链表是否为空
	public Object[] toArray();		//数据集合
	public E get(int index);		//根据索引取得数据
	public void set(int index,E data);	//根据索引修改数据
	public boolean contains(E data);	//判断数据是否存在
	
	public void printList();		//遍历
}

public static void main(String[] args) {
		
		ILink<String> all = new LinkList<String>();
		all.add("Hello1");
		all.add("World2");
		all.add("World3");
		
		Object[] result = all.toArray();
		for(Object x : result){
			System.out.println(x);
		}
		System.out.println("----------------1---------------");
		System.out.println(all.get(1));
		all.set(1, "萝莉");
		System.out.println("----------------2---------------");
		System.out.println(all.get(1));
		System.out.println("---------------cont------------");
		System.out.println(all.contains("萝莉"));
	}

输出结果：

Hello1
World2
World3
----------------1---------------
World2
----------------2---------------
萝莉
---------------cont------------
true

删除链表数据

数据的删除指的是可以从集合里面删除掉指定的一个数据内容，要实现这个功能依然需要数据比较的支持

package amazon;

@SuppressWarnings("all")
public class LinkList<E> implements ILink<E> {
    
	private class Node<E>{
		private E data; 		//存储的数据
		private Node next;		//下一个节点
		
		public Node(E data){	//构造方法,在实例化的时候存储数据
			this.data = data;
		}
		
		//添加数据
		public void addNode(Node next){	//保存新的数据
			if (this.next == null) {
				this.next = next;
			}else{
				this.next.addNode(next);
			}
		}
		
		//设置成数组
		public void toArrayNode(){
			//从内部类获取外部类的私有成员 没次加一保证下一次拿到的是加一的foot
			LinkList.this.returnData[LinkList.this.foot++] = this.data;	
			if (this.next != null) {//如果还有下一个节点  继续调这个方法
				this.next.toArrayNode();
			}
		}
		
		//根据索引查询数据
		public E getNode(int index){
			//从内部类获取外部类的私有成员 没次加一保证下一次拿到的是加一的foot
			if(LinkList.this.foot++ == index){	//索引相同
				return this.data;	//返回当前数据
			}else{
				return (E) this.next.getNode(index);	//递归调用
			}
		}
		
		//根据索引修改数据
		public void setNode(int index,E data){
			//从内部类获取外部类的私有成员 没次加一保证下一次拿到的是加一的foot
			if(LinkList.this.foot++ == index){	//索引相同
				this.data = data;
			}else{
				this.next.setNode(index, data);//递归调用
			}
		}
		
		//判断数据是否存在
		public boolean containsNode(E data){
			if (this.data.equals(data)) {	//判断数据是否相等
				return true;		//返回true
			}else{	
				if (this.next == null) {	//判断是否还有下一个节点
					return false;	//返回false
				}
			}
			return this.next.containsNode(data);	//递归调用
		}
		
		//删除节点
		public void removeNode(Node previous,E data){
			if (this.data.equals(data)) {
				previous.next = this.next;	//上一个节点的下一个节点变成要删除节点的下一个
			}else{
				if (this.next != null) {	//有后续节点
					this.next.removeNode(this, data);	//向后继续寻找data数据相等的节点
				}
			}
		}
	}
	//-----------------以下是LinkList的成员属性--------------
	private Node root;			//作为链表的根节点
	private int count;			//作为链表的长度/数量
	private int foot;			//数组下标
	private Object[] returnData;	//返回的数组
	
	//-----------------以下是ILink方法---------------------
	//添加
	@Override
	public void add(E data) {
		if (data == null) {		//保存数据为null
			return;				//结束方法直接返回
		}
		
		Node<E> next = new Node<E>(data);		//创建一个新的节点
		if (this.root == null) {		//没有根节点
			this.root = next;			//第一个节点做为根节点
		}else{	//根节点存在
			this.root.addNode(next);	//当有了根节点，就往下一个节点添加
		}
		
		this.count++;		//每添加一个对象都会加一
	}
	
	//长度
	@Override
	public int size(){
		return this.count;
	}
	
	//判断是否为空
	@Override
	public boolean isEmpty() {
		return this.count == 0;		//true为空，false非空
	}
	
	//数据集合
	@Override
	public Object[] toArray() {
		if (this.isEmpty()) {		//判断谁为空
			return null;			//直接返回
		}
		
		this.foot = 0;				//下标归零
		this.returnData = new Object[this.count];	//因为记录了长度 直接用就行了
		this.root.toArrayNode();	//利用Node进行递归数据获取
		//因为数组是引用类型  所以在上面这个方法获取就行了
		return this.returnData;
	}
	
	//遍历
	@Override
	public void printList() {
		Node<E> next = this.root;		//获取第一个数据
		
		while (true) {					//无限循环
			if (next == null) {			//为null
				break;					//跳出循环
			}
			
			System.out.println(next.data);	//输出数据
			next = next.next;			//获取下一个节点
		}
	}
	
	//根据下标获取数据
	@Override
	public E get(int index){
		if(index >= this.count){	//索引应该在指定范围之内
			return null;
		}
		//索引数据的获取应该有Node类完成 
		this.foot = 0;//重置索引的下标
		return (E) this.root.getNode(index);
	}
	
	//根据下标修改数据
	@Override
	public void set(int index, E data) {
		if(index >= this.count){	//索引应该在指定范围之内
			return;
		}
		//索引数据的获取应该有Node类完成 
		this.foot = 0;//重置索引的下标
		this.root.setNode(index, data);
	}
	
	//判断数据是否存在
	@Override
	public boolean contains(E data) {
		if (data == null) {		//为null返回false
			return false;
		}
		return this.root.containsNode(data);	
	}
	
	//删除数据
	@Override
	public void remove(E data) {
		if (this.contains(data)) {		//判断是否存在
			if (this.root.data.equals(data)) {		//根节点处理
				this.root = this.root.next;			//根引用根的下一个节点
			}else{					//如果不是根节点
				this.root.removeNode(this.root, data);
			}
		}
	}
	
	//清空
	@Override
	public void clean() {
		this.root =null;	//后续的节点都没了
		this.count = 0;		//数组长度清零
	}
}

interface ILink<E>{
	
	public void add(E data);		//添加
	public int size();				//长度
	public boolean isEmpty();		//判断链表是否为空
	public Object[] toArray();		//数据集合
	public E get(int index);		//根据索引取得数据
	public void set(int index,E data);	//根据索引修改数据
	public boolean contains(E data);	//判断数据是否存在
	public void remove(E data);		//删除数据
	public void clean();			//清空
	
	public void printList();		//遍历
}

public static void main(String[] args) {
		
		ILink<String> all = new LinkList<String>();
		all.add("萝莉1");
		all.add("萝莉2");
		all.add("萝莉3");
		
		all.printList();
		System.out.println("------------------***------------------");
		all.remove("萝莉1");
		
		all.printList();
	}

输出结果：

萝莉1
萝莉2
萝莉3
------------------***------------------
萝莉2
萝莉3

综合实战：宠物商店

有空写

综合实战：超市购物车

有空写

Fatsugar-Java后端工程师
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表的定义与使用
铁塔
03-22 1682
链表实现简介 链表的本质是一个动态的对象数组，它可以实现若干个对象的存储。 链表的基本定义： 在实际的开发之中对象数组是一项非常实用的技术，并且利用其可以描述出“多”方的概念，例如：一个人有多本书，则在人的类里面一定要提供有一个对象数组保存书的信息，但是传统的对象数组依赖于数组的概念，所以数组里面最大的缺点在于：长度是固定的，正是因为如此所以在实际的开发之中，传统的数组应用是非常有限的（数组的接收...
链表的定义和使用
meini32的博客
08-09 1258
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。//通俗的说：链表就是由一个个节点组成，这些节点逻辑上连续，物理上不连续）每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。每一个节点由两部分组成，一个是数据域一个是指针域；...
JavaScript 链表定义与使用方法示例
11-21
JavaScript中的链表是一种重要的数据结构，它不同于数组，数组中的元素在内存中是连续存储的，而链表的每个元素（或称为节点）通过指针（在JavaScript中通常使用`next`属性）连接，形成一个逻辑上的线性序列。...
java 中链表的定义与使用方法
08-31
Java 中链表的定义与使用方法 Java 中链表的定义与使用方法是 Java 语言中一种常用的数据结构，链表是一种动态分配内存的数据结构，链表的每个元素都是一个独立的对象，每个元素都包含一个数据域和一个指针域，指针...
JavaScript数据结构之双向链表定义与使用方法示例
01-19
本文实例讲述了JavaScript数据结构之双向链表定义与使用方法。分享给大家供大家参考，具体如下： 双向链表和普通链表的区别在于，在链表中，一个节点只有链向下一个节点的链接，而在双向链表中，链接是双向的：一个...
lianbiao.rar_定义链表_链表
09-24
可以使用以下函数创建空链表： ```c Node* createList() { Node* head = (Node*)malloc(sizeof(Node)); // 分配内存给头节点 if (head == NULL) { // 检查内存分配是否成功 printf("Memory allocation failed.\n...
链表的基本定义与使用方法总结
longshaonihaoa的博客
06-18 3030
自己救自己系列， 找工作刷题做点总结。明明还只是个学生，但我的头发就以为自己是长在了程序猿头上，自觉地脱落了。 链表那真是重要的不能再重要了，多刷多刷多掌握。 详细讲的内容那真是太多了，参考这篇吧。http://c.biancheng.net/view/1570.html 链表题目别的先不弄，先设置一个头链表再说 ...
29-链表的定义与使用
MARVEL_3000的博客
12-21 189
链表的定义与使用 链表的本质是一个动态的对象数组，实现若干对象的存储。 链表实现简介 实际开发中对象数组是一项非常实用的技术，利用其描述“多”方的概念。但传统的对象数组依赖于数组的概念，所以数组里面最大的缺点在于长度是固定的，所以实际开发中，传统的数组应用是有限的（数组的接收和循环处理）。 想要进行灵活的数据保存，就要自己实现结构。传统对象数组的开发操作依赖于索引的控制，想要实现内容的动态维护，难度太高复杂度攀升，所以现在可以发现对于随时变化的数据必须实现一个可以动态扩充的对象数组。 所谓的链表实质性的本质
C语言学习笔记——链表
weixin_51215586的博客
10-10 531
链表 链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。 与数组不同，链表很灵活。数组是在连续的空间里面存放元素的地址，因此很难实现数据的增删。 而链表只需修改指针的指向就能实现。 链表有一个 头指针 变量，它存放一个地址，该地址指向一个元素，链表中每一个元素称为 结点，每个结点都应包括两个部分，一为用户需要用的实际数据，二为下一个结点的地址。可以看出，头指针 head 指向第一个元素，第一个元素又指向第二个元素，。。。。直到最后一个元素，该元素不再指向其他元素，它称为 表尾，它的地
C/C++学习——自定义数据类型——链表
cbb8234078009的博客
06-15 2128
链表的概念 一、链表的概念 1、链表是一种存储空间能动态进行增长或缩小的数据结构。 2、链表主要用于： （1）建立不定长度的数组。 （2）可以在不重新安排整个存储结构的情况下，方便且迅速地插入和删除数据元素。 3、链表广泛应用于数据管理中。 二、结点 struct NODE{//结点数据类型 ElemType data;//数据域 NODE *link;//指针域 }; 1、ElemType 可以是简单的内置数据类型，也可以是复杂的数据类型， typedef struct t
数据结构与算法知识点汇总
IST-CTO
01-07 2178
系统性的学习了数据结构之后，对知识框架进行一个梳理，附上很多实例来加深记忆
C语言抽象数据类型(ADT：abstract data type)之链表节点定义及有序链表插入新节点
wcm_lucky的博客
04-03 1289
链表：包含一些数据的独立的数据结构（通常称为节点）的集合。 单链表 根指针记录链表的起始位置，根指针指向链表的第一个节点，注意根指针只是一个指针，它不包含任何数据 最后一个节点的指针字段值为NULL,提示链表后面不再有任何节点。 用结构体创建一个简单的节点数据结构Node typedef struct NODE { struct NODE *link; ...
”链表“类型和结点类型的区别
i_will_的博客
01-13 3609
链表是结点的集合，0个或多个结点组成一个链表。 节点的结构：数据域（记录数据），指针域（指向下一个结点） 链表的结构：类型1：若干结点依次相连； 类型2：有头指针，指向链表中的第一个结点。初始情况下头指针为NULL； 类型3：有头结点。头结点是只有指针域的特殊结点，指针域存放指向第一个结点的指
【数据结构】链表
鑫仔的记忆
09-30 2110
链表
1.(菜单)主程序；2.链表的建立；3.链表的数据节点插入；4.链表的数据节点删除；5.链表的节点数据输出使用C语言
最新发布
05-18
1. (菜单)主程序是指一个程序的主入口，通常包含用户与程序进行交互的菜单功能，用户可以通过菜单选择所需的操作。 2. 链表的建立是指创建一个链表的过程，可以使用结构体和指针来实现。首先需要定义一个结构体来表示链表的节点，然后使用指针来指向节点之间的关系，最后通过遍历链表来实现各种操作。 3. 链表的数据节点插入是指在链表中添加一个新节点并将其插入到指定位置。可以通过遍历链表找到要插入的位置，然后将新节点插入到该位置即可。 4. 链表的数据节点删除是指在链表中删除指定节点。可以通过遍历链表找到要删除的节点，然后将其从链表中删除即可。 5. 链表的节点数据输出可以使用循环遍历链表，并将每个节点的数据打印出来。可以使用 printf 函数实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值