java数据结构单链表的基本操作

最新推荐文章于 2024-04-30 17:28:01 发布
最新推荐文章于 2024-04-30 17:28:01 发布
阅读量1.5k 收藏 19
点赞数 11
分类专栏： 数据结构 文章标签： 链表 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43478315/article/details/103541422
版权

文中内容来源于《数据结构 --Java语言描述》（第二版） 刘小晶 杜选 主编
此系列文章作为学校实验记录，若文中内容有误，请大家指出，谢谢

实验目的

1、掌握线性链表的操作特点，即指针是逻辑关系的映像。
2、掌握动态产生单链表的方法。
3、熟练掌握单链表的插入、删除操作特点，即指针赋值的先后次序。
4、熟练掌握单链表的取元素操作

实验内容

1、定义单链表类型并动态创建单链表；
2、实现单链表的取元素操作、插入操作和删除操作；
3、实现输出单链表中各元素值的操作；
4、将单链表中的最小元素移到最前面。

实验步骤

1、定义单链表节点类；
2、定义单链表类，并实现单链表的创建、插入、删除、取元素操作和将单链表中的最小元素移到最前面的操作；
3、从键盘上依次输入21、75、30、18、42、56，顺序或逆序创建单链表，并输出单链表中的各元素值；
4、分别在单链表的第3个位置和第9个位置插入67和10，给出插入成功或失败的信息，并输出单链表中的各元素值；
5、删除单链表中的第4个数据元素和第8个数据元素，给出删除成功或失败的信息，并输出单链表中的各元素值；
6、取单链表中的第5个数据元素和第7个数据元素；
7、将单链表中的最小元素移到最前面，并输出单链表中的各元素以检查操作是否正确实现。

源代码

//Node.java
package sjjg_test1;

public class Node {
	public Object data;
	public Node next;
	
	public Node(Object data, Node next) {
		this.data = data;
		this.next = next;
	}
	
	public Node(Object data) {
		this(data,null);
	}
	
	public Node() {
		this(null, null);
	}
}

//LinkList.java
package sjjg_test1;
import java.util.Scanner;
public class LinkList {
	public Node head;
	
	public LinkList() {
		head = new Node();
	}
	
	public LinkList(int n,boolean Order) throws Exception {
		this();
		if(Order)
			create1(n);
		else
			create2(n);
	}
	
	public void create1(int n) throws Exception {
		Scanner sc = new Scanner(System.in);
		for(int j=0;j<n;j++)
			insert(length(), sc.nextInt());
	}
	
	public void create2(int n) throws Exception {
		Scanner sc = new Scanner(System.in);
		for(int j=0;j<n;j++)
			insert(0, sc.nextInt());
	}
	
	public void clear() {
		head.data = null;
		head.next = null;
		System.out.println("clear successfully");
	}
	
	public boolean isEmpty() {
		return head.next == null;
	}
	
	public int length() {
		Node p = head.next;
		int length = 0;
		while(p != null) {
			p = p.next;
			++length;
		}
		return length;
	}

	public Object get(int i) throws Exception {
		Node p = head.next;
		int j = 0;
		while(p != null && j<i) {
			p = p.next;
			++j;
		}
		if(j>i || p==null) {
			throw new Exception("第" + i + "个元素不存在");
		}
		System.out.println("get successfully");
		return p.data;
	}

	public void insert(int i, Object x) throws Exception {
		Node p = head;
		int j = -1;
		while(p != null && j< i-1) {
			p = p.next;
			++j;
		}
		if(j>i-1 || p==null)
			throw new Exception("插入位置不合法");
		Node s = new Node(x);
		s.next = p.next;
		p.next = s;
		System.out.println("insert successfully");
	}
	
	public void remove(int i) throws Exception {
		Node p = head;
		int j = -1;
		while(p.next != null && j<i-1) {
			p = p.next;
			++j;
		}
		if(j>i-1 || p.next==null)
			throw new Exception("删除位置不合法");
		p.next = p.next.next;
		System.out.println("remove successfully");
	}

	public int indexOf(Object x) {
		Node p = head.next;
		int j = 0;
		while(p != null && !p.data.equals(x)) {//here
			p = p.next;
			++j;
		}
		if(p != null)
			return j;
		else
			return -1;
	}
	
	public void display() {
		Node node = head.next;
		while(node != null) {
			System.out.print(node.data + " ");
			node = node.next;
		}
		System.out.println();
	}
	
	public void tip() {
		System.out.println("请输入以下选项对应的数字：");
		System.out.println("1：插入");
		System.out.println("2：删除");
		System.out.println("3：获取元素");
		System.out.println("4：将最小值所在节点移动到表头");
		System.out.println("5：清空链表");
		System.out.println("6：判断链表是否为空");
		System.out.println("7：获取列表长度");
		System.out.println("8：按值查找元素下标");
		System.out.println("9：结束本次操作");
	}
	
	public void moveMin(Node head) throws Exception {
        //寻找最小
        Node current = head.next;
        Object min = current.data;
        while (current != null) {
                if ((int)current.data < (int)min) {
                        min = (int)current.data;
                }
                current=current.next;
        }
        Node previous = head;
        Node s;
        current = head.next;
        //两层循环为了移动所有的最小节点
        while(current!=null){
        	if((int)current.data != (int)min) {
        		previous = current;
                current = current.next;
        	} else {
        		previous.next=current.next;
                s = current;
                current=previous.next;
                s.next = head.next;
                head.next = s;
        	}
        }
	}
}

//LinkListTest.java
package sjjg_test1;
import java.util.Scanner;
public class LinkListTest {
	public static void main(String[] args) throws Exception {
		System.out.println("how many nodes do you want to creat in this LinkList:");
		Scanner input = new Scanner(System.in);
		int LinkListNum = input.nextInt();
		System.out.println("please input "+LinkListNum+" numbers to creat a LinkList:"); 
		LinkList a = new LinkList(LinkListNum,true);
		System.out.println("the numbers of LinkList are following:");
		a.display();
		Object shuzi;
		int xiabiao,sum,pEnd;
		String judge;
		while(true) {
			a.tip();
			int choice = input.nextInt();
			switch (choice) {
				case 1://insert
					System.out.println("请输入插入元素个数");
					sum = input.nextInt();
					System.out.println("请输入要插入元素的位置和值");
					while(sum>0) {
						xiabiao = input.nextInt();
						shuzi = input.nextInt();
						try {
							a.insert(xiabiao, shuzi);
							a.display();
						} catch (Exception e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						sum--;
					}
					break;
				case 2://delete
					System.out.println("请输入删除个数");
					sum = input.nextInt();
					System.out.println("请输入删除元素位置");
					while(sum>0) {
						xiabiao = input.nextInt();
						try {
							a.remove(xiabiao);
							a.display();
						} catch (Exception e) {
							e.printStackTrace();
						}
						sum--;
					}
					break;
				case 3://get
					System.out.println("请输入所取元素个数");
					sum = input.nextInt();
					while(sum>0) {
						System.out.println("请输入所取元素位置");
						xiabiao = input.nextInt();
						try {
							System.out.println(a.get(xiabiao));
						} catch (Exception e) {
							e.printStackTrace();
						}
						sum--;
					}
					break;
				case 4://moveMin
					a.moveMin(a.head);
					a.display();
					break;
				case 5:
					a.clear();
					break;
				case 6:
					System.out.println(a.isEmpty());
					break;
				case 7:
					System.out.println("链表长度为："+a.length());
					break;
				case 8:
					System.out.println("请输入查找元素个数");
					sum = input.nextInt();
					while(sum>0) {
						System.out.println("请输入要查找元素");
						shuzi = input.nextInt();
						System.out.println(shuzi+"的下标为："+a.indexOf(shuzi));
						sum--;
					}
					break;
				case 9:
					break;
				default:
					System.out.println("输入有误");
					break;
			}
			pEnd = 1;
			while(pEnd>0) {
				System.out.println("是否要结束本条链表的操作?y/n");
				judge = input.next();
				if(judge.equals("y"))
					break;
				else if(judge.equals("n"))
					pEnd = -1;
				else
					System.out.println("输入有误");
			}
			if(pEnd==1) {
				break;
			}
		}
		input.close();
		System.out.println("end of program");	
	}
}

运行结果

how many nodes do you want to creat in this LinkList:
6
please input 6 numbers to creat a LinkList:
21 75 30 18 42 56
insert successfully
insert successfully
insert successfully
insert successfully
insert successfully
insert successfully
the numbers of LinkList are following:
21 75 30 18 42 56 
请输入以下选项对应的数字：
1：插入
2：删除
3：获取元素
4：将最小值所在节点移动到表头
5：清空链表
6：判断链表是否为空
7：获取列表长度
8：按值查找元素下标
9：结束本次操作
1
请输入插入元素个数
2
请输入要插入元素的位置和值
2 67
insert successfully
21 75 67 30 18 42 56 
8 10
java.lang.Exception: 插入位置不合法
是否要结束本条链表的操作?y/n
	at sjjg_test1.LinkList.insert(LinkList.java:76)
	at sjjg_test1.LinkListTest.main(LinkListTest.java:33)
n
请输入以下选项对应的数字：
1：插入
2：删除
3：获取元素
4：将最小值所在节点移动到表头
5：清空链表
6：判断链表是否为空
7：获取列表长度
8：按值查找元素下标
9：结束本次操作
2
请输入删除个数
2
请输入删除元素位置
3
remove successfully
21 75 67 18 42 56 
7
java.lang.Exception: 删除位置不合法
	at sjjg_test1.LinkList.remove(LinkList.java:91)
	at sjjg_test1.LinkListTest.main(LinkListTest.java:49)
是否要结束本条链表的操作?y/n
n
请输入以下选项对应的数字：
1：插入
2：删除
3：获取元素
4：将最小值所在节点移动到表头
5：清空链表
6：判断链表是否为空
7：获取列表长度
8：按值查找元素下标
9：结束本次操作
3
请输入所取元素个数
2
请输入所取元素位置
4
get successfully
42
请输入所取元素位置
6
java.lang.Exception: 第6个元素不存在
是否要结束本条链表的操作?y/n
	at sjjg_test1.LinkList.get(LinkList.java:60)
	at sjjg_test1.LinkListTest.main(LinkListTest.java:65)
n
请输入以下选项对应的数字：
1：插入
2：删除
3：获取元素
4：将最小值所在节点移动到表头
5：清空链表
6：判断链表是否为空
7：获取列表长度
8：按值查找元素下标
9：结束本次操作
4
18 21 75 67 42 56 
是否要结束本条链表的操作?y/n
y
end of program
sticker_start_tag
关注
  • 11
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java 数据结构单链表的实现
08-30
主要介绍了java 数据结构单链表的实现的相关资料,需要的朋友可以参考下
Java~单链表基本操作图文详解_清晰易懂（超详细，含完整代码）
Zebra的博客
10-28 2580
一.单链表的定义 1.结点的定义
算法通关村第一关—青铜挑战—用Java基本实现各种链表操作
itzzan的博客
11-29 256
算法链表是一种用于解决问题的数据结构，它包含了多个节点，每个节点都包含了一个值和一个指向下一个节点的指针。与数组不同，链表的节点在内存中不是连续存储的，而是通过指针链接在一起。 通过使用算法链表，可以实现各种常见的算法操作，如插入、删除、查找等。由于链表的特殊结构，插入和删除操作的时间复杂度为O(1)，而查找操作的时间复杂度则为O(n)。 链表还可以用来解决一些特殊的问题，比如反转链表、判断链表是否存在环以及找到链表的中间节点等。这些问题在实际开发中经常会遇到，并且链表的特性使得解决方案变得相对简单。
Java实现单链表及其基本操作
qq_58284486的博客
03-14 7507
目录 什么是单链表？ 带头结点的单链表 不带头结点的单链表 模拟实现不带头结点的单链表 定义结点类 初始化 头插法创建单链表 尾插法创建单链表 打印单链表 单链表的查找 获取单链表的长度 按位置寻找前驱结点 单链表的插入 修改指定位置的值 按值寻找前驱结点 删除第一次出现的key值 删除所有的key值 清空单链表 完整代码 什么是单链表？ 单链表是一种链式存取的数据结构，用一组任意的存储单元存放线性表中的数据元素。链表中的数据是以结点表示...
单链表的基本操作
m0_51697147的博客
11-12 1065
链表的存储结构在逻辑上、概念上的连续结构，但在实际的物理存储上是非连续、非顺序的。 它的存储单元以结点为单位，每一个结点由数据域和指针域两个域组成。数据域存储数据元素信息data，指针域存储直接后继存储位置next。 整个链表的存取必须从头指针开始进行，头指针指链表中第一个结点（即第一个数据元素的存储映像，也称首元结点）的存储位置。同时，由于最后一个数据元素没有直接后继，则单链表中最后一个结点的指针为空（null）。 头指针有两种情况： （1）为了方便处理，在单链表的第一个结点（首元结点）之前附
图解链表 —— JAVA中的单链表基本操作
AlinaQ05的博客
05-17 2110
文章目录1. 什么是链表2. 链表的种类3. 创建单链表3.1 创建 Node 类（车厢类）3.2 创建 MySingleList (火车类）4. 单链表的基本操作4.1 增加链表元素4.1.1 在链表头部添加元素4.1.2 在链表任意位置添加元素4.1.3 在链表尾部添加元素4.2 删除链表元素4.2.1 删除第一个节点元素4.2.2 删除任意位置 index 元素4.2.3 删除链表中指定元素的第一个节点4.2.4 删除链表的所有指定元素4.3 查找链表元素4.3.1 判断链表中是否包含元素 data4
基于JAVA的数据结构之单链表操作合
03-25
单链表 基于JAVA的数据结构之单链表操作合
Java单链表基本操作的实现
09-02
链表是一种数据结构，和数组同级。接下来通过本文给大家介绍Java单链表基本操作的实现，非常不错，具有参考借鉴价值，感兴趣的朋友一起看下吧
JAVA数据结构——单链表的操作.docx
07-11
JAVA数据结构——单链表的操作 单链表的操作 方法一： package ch02; (1)建立结点类Node.java public class Node { public Object data;//存放结点数据值 public Node next;//存放后继结点 //无参构造函数 public ...
java实现数据结构单链表示例(java单链表)
09-04
主要介绍了java数据结构实现单链表示例,需要的朋友可以参考下
Java实现单链表的基本操作
01-06
Java实现单链表的基本操作
数据结构之实现单链表(Java实现)
weixin_47851265的博客
12-22 3084
数据结构之单链表的实现
自己实现链表的基本操作方法（详细）（Java实现）
AwwzJ_0821的博客
10-19 2455
因为链表类也实现了线性表接口的方法，所以链表的基本操作方法和顺序表一样。这里我们定义链表中的元素类型为包装类（体现对象的形式而不是基本类型）这里提前定义了 MyNode 类，其中的属性为：Long val；三个属性，一个元素值 val ，一个指向前一个结点的引用 prev，一个指向后一个结点的引用 next。在 MyLinkedList 类（自定义链表类）中实现自定义基本方法，其中包括属性 MyNode head；int size；
Java实现单链表（步骤详解+源码）
GSCY
10-14 6408
Java实现单链表（步骤详解+源码） 欢迎大家提出问题，一起学习！
Day25-Java基础之常用类1
m0_46053885的博客
04-27 1115
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
最新发布
yajunjiao的专栏
04-30 486
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1075
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
java数据结构单链表adt
11-23
单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。单链表的优点是插入和删除操作的时间复杂度为O(1)，但是访问操作的时间复杂度为O(n)。下面是Java实现单链表...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值