Java实现带有头结点的单链表的增删改查！

最新推荐文章于 2022-01-17 15:18:59 发布
最新推荐文章于 2022-01-17 15:18:59 发布
阅读量590 收藏 3
点赞数 2
分类专栏： Java 文章标签： java 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45058254/article/details/104483840
版权

Java实现带有头结点的单链表的增删改查！

在这里就不解释了，代码里有注释很容易看懂的！

package List;
/**
 * @author ganxiang
 * @IDE IntelliJ IDEA
 * @project_name JavaDemo
 * @filename SingalList
 * @date 2020/02/24
 */

public class SignalList {
	class  DefineNode{//创建带头结点的链表，head->data1->data2->data3
		int data;
		DefineNode next;
		public DefineNode(int d){
			this.data=d;
		}
	}
	DefineNode head;
	public  void insret_one(int dex){//插入一个节点
		if(head==null){
			head =new DefineNode(dex);
			System.out.println(head.data);
		}

	}
	DefineNode temp ;
	public DefineNode insert_many(){//插入多个节点,这里插入6个
		for (int i=10;i<=15;i++){
			if (temp==null) {
				temp = new DefineNode(i);
			}
			else {
				DefineNode node =temp;
				while (node.next!=null){
					node=node.next;//找到尾结点 将值赋给尾结点
				}
				node.next=new DefineNode(i);
			}
		}
		return temp;
	}

	public int getSize(DefineNode t) {//计算链表的长度
		int size=0;
		while(t!=null){
			size++;
			t=t.next;
		}
		return size;
	}
	public int printList(DefineNode t){//打印链表
		while (t!=null){
			System.out.println(t.data);
			t=t.next;
		}
		return 0;
	}
	public DefineNode addFirst(int data,DefineNode t){//插入链表中的第一个节点(头结点)
		DefineNode node = new DefineNode(data);
		if (t ==null){
			t=node;
		}
		else{
			node.next =t;
			t =node;
//			printList(t);

		}
		return t;

	}
	public  void addLast(int data){//插入链表中的最后一个节点(尾节点)
		DefineNode node =new DefineNode(data);
		DefineNode t=temp;
		if (t ==null){
			t=node;
		}
		else{
			while (t.next!=null){
//				System.out.println(t.data);
				t =t.next;
			}
			t.next =node;
		}
	}

	public  DefineNode inset_index(DefineNode t, int k,int data){//指定索引插入节点
		int size =getSize(t);
		if (k<1||k>size)System.out.println("无法插入数据!");
		else{
			if (k==1)return addFirst(data,t);
			else {
//				if(t==null){
//					t =new DefineNode(data);
//				}
				if (k ==size){
					addLast(data);
				}
				else {
					int count =1;
					DefineNode tt=t;//保证头结点不变
					while(tt!=null&&count<k-1){
						count++;
						tt=tt.next;
					}
					DefineNode a ;//将a节点等于插入索引位置前一个节点
					a = new DefineNode(data);//给a节点插入数据
					a.next = tt.next;
					tt.next = a;
//					printList(a);

				}
			}
		}

		return t;
	}
	public DefineNode delFirst(DefineNode t){//删除头结点
		DefineNode a;
		if (t==null)System.out.println("无法操作链表，链表为空！");
		else{
			a = t.next;
			t=a;
		}
		return t;

	}
	public DefineNode delLast(DefineNode t){//删除尾节点
		DefineNode a =t;
		if (t==null)System.out.println("无法操作链表，链表为空！");
		else{
			while (a.next.next!=null){
				a = a.next;
			}
			a.next =null;
		}
		return t;
	}
	public DefineNode del_index(int k,DefineNode t){//根据索引删除节点
		DefineNode a=t;
		int count =1;
		if (k<1||k>getSize(a))System.out.println("不符合链表的操作范围！");
		else {
			if (k==1)return delFirst(a);
			else if (k==getSize(a))return delLast(a);
			else {
				while (a != null && count <k - 1) {
					a = a.next;
					count++;
//					System.out.println(count);
				}
				DefineNode s = a;
				s.next = s.next.next;
				a=s;
//				printList(a);

			}
		}
		return t;
	}
	public DefineNode upsataFirst(int data,DefineNode t){//修改第一个节点
		DefineNode a =t;
		if (a==null){
			a = new DefineNode(data);
			t=a;
		}
		else {
			a =new DefineNode(data);
			a.next=t.next;
			t=a;
		}
		return t;
	}
	public DefineNode updataLast(int data,DefineNode t){//修改最后一个节点
		DefineNode a=t;
		if (a==null)System.out.println("空链表无法操作！");
		else {
			while(a.next.next!=null){
				a=a.next;
			}
//			printList(a);
			DefineNode s =new DefineNode(data);
			a.next =s;
		}
		return t;
	}
	public DefineNode updata_index(int data,DefineNode t,int k){//根据索引来修改节点
		DefineNode a =t;
		if (k<1||k>getSize(a))System.out.println("不在操作范围！");
		else
		{
			if (k==1)return upsataFirst(data,a);
			else if (k==getSize(a))return updataLast(data,a);
			else {
				int count =1;
				DefineNode s =new DefineNode(data);
				while (a.next!=null&&count<k-1){
					count++;
					a=a.next;
				}
//				printList(a);
				s.next=a.next.next;
//				printList(s);
				a.next=s;
//				printList(a);
			}
		}
		return t;
	}
	public static void main(String[] args) {
		SignalList signal =new SignalList();
//		signal.insret_one(6);
		signal.insert_many();//增加节点
		int size = signal.getSize(signal.temp);
		System.out.println("insert_many()中链表temp的长度为："+size);
		System.out.println("没指定索引修改时链表为：");
		signal.printList(signal.temp);

		//增加 add or insert
//		DefineNode inset_index =signal.inset_index(signal.temp,3,20);
//		System.out.println("指定索引插入后链表为：");
//		signal.printList(inset_index);
//		System.out.println("指定索引插入后链表长度为："+signal.getSize(inset_index));


//		//删除delete
//		DefineNode delFirst = signal.delFirst(signal.temp);//测试删除头结点
//		System.out.println("删除头结点的链表为：");
//		signal.printList(delFirst);
//		DefineNode delLast =signal.delLast(signal.temp);//测试删除尾节点
//		System.out.println("删除为结点的链表为：");
//		signal.printList(delLast);
//		DefineNode del_index = signal.del_index(3,signal.temp);//指定位置删除节点
//		System.out.println("删除指定结点的链表为：");
//		signal.printList(del_index);

		//修改update
//		DefineNode updataFirst=signal.upsataFirst(100,signal.temp);
//		System.out.println("修改好头结点的链表为：");
//		signal.printList(updataFirst);
//		DefineNode updataLast =signal.updataLast(120,signal.temp);
//		System.out.println("修改好尾结点的链表为：");
//		signal.printList(updataLast);
		DefineNode updata_index =signal.updata_index(200,signal.temp,5);
		System.out.println("修改好指定结点的链表为：");
		signal.printList(updata_index);




	}


}

运行展示
指定修改第5个节点的值为200.
在这里插入图片描述
这里只展示了一个运行的结果，你们可以多调试看看，我运行都没错误的，若有错误之处恳请各位大佬多多指点。

爱吃虾的鱼
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实现带头结点(head)的单向链表
《落程魄序》作者“落魄哥”的博客
12-31 2072
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。今天我在这里给大家分享一下，java如何实现一个链表类呢？？？其实很简单，具体的图解在百度上有很多，我就不一一解释了。直接上代码 package com.zp; /** * @author zhaopeng ...
数据结构之——单链表（带头节点）（Java描述）
m0_52261881的博客
02-27 238
文章目录前言一、链表相关操作1.增加元素2.修改元素3.查询元素4.删除元素总结 前言 一、链表相关操作 1.增加元素 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnings warnings.filterwarnings('ignore') import ssl ssl._create_default_https_con
学习java带有头结点的单链表结构
YuenBin128的博客
05-05 1838
[java] view plain copy//10-14 数据结构中带有头结点的单链表结构,用java语言简单实现  [java] view plain copy  [java] view plain copypublic class LineListNodeHead {            public static void main(String[] args) {          L...
java实现---删除一个无头单链表的非尾节点（不能遍历链表）
_Unique_
11-26 299
可以利用伪删除法 把pos.next的值覆给pos pos的next指向pos.next的next 删除pos.next class ListNode{ int data; ListNode next; } public class Link{ public static void DeleteListNotTail(ListNode pos) { ...
java实现单链表的增删改査
qq_34746239的博客
03-04 206
一、创建节点类 package linklist; public class LNode{ private int data; private LNode next; public int getData() { return data; } public void setData(int data) { ...
Java单链表增删改查的实现
08-15
下面我们将详细探讨如何在Java中实现单链表的增、删、改、查功能，以及如何进行选择排序、冒泡排序和反转排序。 1. **单链表的定义**： - 单链表的每个节点通常包括两部分：数据域（存储元素）和指针域（存储下一...
java实现单链表增删改查的实例代码详解
10-16
在本篇文章里小编给大家整理了关于java实现单链表增删改查的实例内容，需要的朋友们可以参考下。
Java实现带头结点的单链表
08-25
Java实现带头结点的单链表 Java实现带头结点的单链表是一种链式数据结构，链表的特点是以节点方式存储，是链式结构。每个节点包含data域，next域：指向下一个节点。链表的各个节点不一定是连续存储。链表分为带头...
Java描述数据结构学习之链表的增删改查详解
08-27
Java链表数据结构学习之增删改查详解 本文将从链表的基本概念、链表的定义、链表的增删改查操作等方面对Java描述数据结构学习之链表的增删改查进行详细的解释。 链表是一种常见的基础数据结构，它是一种线性表，但...
不带头节点的单链表删除 java_不带头结点的单链表递归删除元素为X的结点
weixin_42545664的博客
02-28 339
#include using namespace std;struct Node{Node *next;int elem;};void creatList(Node* &head){head = new Node;int elem;cin>>elem;head->elem = elem;Node *p = head;while(cin>>elem&&a...
Java实现单链表，包含增删改查以及排序等功能
qingxixiansheng的博客
08-15 2213
单链表的Java类结构如下： 下面上源码： 1.定义链表结点类，每一个结点包含数据data和下一个结点的引用。 package singlelinkedlist; /** * @date on 16:08 2018/8/14 * @describe 模拟单链表的节点信息，这里将属性设为public不用设置get和set方法。 */ public class Node { ...
java写一个链表(练习)
u014577469的博客
01-11 662
class Link{ private class Node{ private String data; private Node next; public Node (String data) { this.data=data; } public void addNode(Node newNode) { if(this.next==null) { th...
Java中链表的头节点
热门推荐
sofuzi的博客
04-12 1万+
一个链表头节点为headhead     1     2     3     4     5     6head叫做链表的头节点1所在的节点叫做链表的首节点（不知叫法是否准确）从定义上严格来说头节点head本身并没有值，它只是一个指向首节点1的指针。也就是说head.val为空，head.next.val=1。即head的下一个节点才是1的节点。那上述的链表就有7个节点（包含头节点head）。 但...
java中链表的头结点_有头结点的单链表（java实现）
weixin_31476341的博客
02-28 470
class Node { int data; Node next; Node(){ next = null; } Node(int data) { this.data = data; next = null; } } class List { Node head = new Node(); List(int n){ Random rand = new Ran...
java实现的单链表增删操作
We.Spring的博客
08-13 624
链表不按照线性的顺序存储数据，而是由若干同一个结构类型的“结点”依次串接而成的，结点由数据部分和下一个结点的地址部分组成。当结点只包含其后继结点的信息的链表称做单链表，如下图所示，head存放链表首结点的地址，rear指向链表表尾。 class Node<T> { public Node<T> next = null; public T data; ...
Java单链表头插法和尾插法以及增删改查方法
weixin_38568503的博客
01-17 1936
一、单链表的头插法： 头插法原理图： 代码演示头插法： package com.fan.linkedlist; public class SingleLInkedListDemo3 { public static void main(String[] args) { SingleLInkedList3 singlelist3 = new SingleLInkedList3(); System.out.println(singlelist3.headInsert(1)
有头结点的单链表（java实现）
huxing0501的专栏
09-01 1058
class Node { int data; Node next; Node(){ next = null; } Node(int data) { this.data = data; next = null; } } class List { Node head = new Node(); List(int n){ Random rand = new R
java单链表学生系统增删改查
最新发布
06-09
好的，我可以为您提供Java单链表学生系统的增删改查操作的示例代码。首先，我们需要定义一个学生类，包含学生的姓名、年龄、学号等信息。如下所示： ```java public class Student { private String name; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值