java版的单向链表的基本操作

首先定义链表节点的结构:

package com.moluo.linklist;
/**
 *
 * @author 行者摩罗
 *
 */
public class Node {
	private int data;
	private Node next;

	public int getData() {
		return data;
	}

	public void setData(int data) {
		this.data = data;
	}

	public Node getNext() {
		return next;
	}

	public void setNext(Node next) {
		this.next = next;
	}
}
package com.moluo.linklist;

import java.util.Scanner;
/**
 *
 * @author 行者摩罗
 * 单向链表的基本操作
 */
public class LinkList {
	public Node head;// 定义一个头结点

	public void createLinkList(int[] x) { // 使用尾插法创建一个链表
		Node pnew; // 定义一个新插入的结点
		Node ptail = new Node(); // 定义一个尾结点并初始化为空
		head = ptail; // 使头结点指向尾结点
		for (int i = 0; i < x.length; i++) {
			pnew = new Node();
			pnew.setData(x[i]); // 创建一个值为x[i]的结点
			ptail.setNext(pnew);
			ptail = pnew; // 将尾结点后移
		}
	}

	public void searchLinkList(int value) { // 查找链表中是否存在值为value的项
		Node p = head.getNext();
		while (p != null) {
			if (p.getData() == value) {
				System.out.println("链表中存在值为:" + value + "的项");
				break;
			} else {
				p = p.getNext();
			}
		}
		if (p == null) {
			System.out.println("链表中不存在值为:" + value + "的项");
		}
	}

	public void deleteLinkList(int value) { // 删除值为value的项
		Node p;
		Node pre = head; // 定义两个结点:pre,p;其中pre是p的前驱
		p = head.getNext();
		while (p != null) {
			if (p.getData() == value) {
				pre.setNext(p.getNext()); // 删除
				System.out.println("删除结点成功");
				break;
			} else {
				pre = p;
				p = p.getNext(); // 将p和pre分别后移一项
			}
		}
		if (p == null) {
			System.out.println("链表中不存在值为:" + value + "的项");
		}
	}

	public void addLinkList(int pos, int value) { // 在链表中指为pos的后面插入一个值为value的项
		Node pre = head;
		;
		Node p = head.getNext();
		while (p != null) {
			if (p.getData() == pos) {
				Node node = new Node();
				node.setData(value);
				node.setNext(p.getNext());
				p.setNext(node);
				System.out.println("添加成功");
				break;
			} else {
				pre = p;
				p = p.getNext();
			}
		}
		if (p == null) {
			System.out.println("添加失败");
		}
	}

	public void displayLinkList() {
		Node node = head.getNext();
		while (node != null) {
			System.out.print(node.getData() + "--->");
			node = node.getNext();
		}
		System.out.println("null"); // 在最后添加上null作为结束标志
	}

	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入链表的结点数:");
		int n = input.nextInt();
		int[] x = new int[n];
		for (int i = 0; i < n; i++) {
			x[i] = i;
		}
		LinkList linkList = new LinkList();
		linkList.createLinkList(x);
		linkList.displayLinkList();
		linkList.addLinkList(6, 18);
		linkList.displayLinkList();
		linkList.deleteLinkList(18);
		linkList.displayLinkList();
		linkList.searchLinkList(9);
	}
}

运行结果:

请输入链表的结点数:
10
0--->1--->2--->3--->4--->5--->6--->7--->8--->9--->null
添加成功
0--->1--->2--->3--->4--->5--->6--->18--->7--->8--->9--->null
删除结点成功
0--->1--->2--->3--->4--->5--->6--->7--->8--->9--->null
链表中存在值为:9的项

尊重版权,转载请注明本文链接

  欢迎关注行者摩罗微信公众号(xingzhemoluo),共同交流编程经验,扫描下方二维码即可;            

时间: 2024-08-26 01:35:50

java版的单向链表的基本操作的相关文章

java版的单向链表的逆序输出

将单向链表逆序输出,方法有三种: a.遍历链表,将每个节点的内容存入一个数组中,然后逆序输出数组(最简单的做法) b.使用栈来逆序输出 c.直接将链表逆序然后输出(本文采用的方法) 先介绍算法: 1). 若链表为空或只有一个元素,则直接返回: 2). 设置两个前后相邻的指针p,q. 将p所指向的节点作为q指向节点的后继: 3). 重复2),直到q为空 4). 调整链表头和链表尾 示例:以逆序A->B->C->D为例,图示如下 package com.moluo.shujujiegou;

链表(二)——单向链表的基本操作(创建、删除、打印、结点个数统计)

1.指针的联动 通过两个指针分别指向前驱和后继结点,并在单向链表上进行移动,当指针指向待处理的结点时,该结点的前驱也有指针指向. 2.设有一个无序单向链表,且数据域的值均不相同,使指针pmin指向最小值结点,并使指针prem指向最小值结点的前驱结点: 代码片段: for(p = head; p; q = p, p = p->next) { if(pmin->data > p->data) { pmin = p; prem = q; } } 3.单向链表的删除算法 注:使用mallo

剑指Offer面试题15(Java版):链表中倒数第K个结点

题目: 输入一个链表,输出该链表中倒数第k哥结点. 为了符合大多数人的习惯,本题从1开始计数,即链表的尾结点是倒数第1个结点. 例如一个链表有6个结点,从头结点开始它们的值依次是1,2,3,4,5,6.这个链表的倒数第3个结点是值为4的结点 为了得到第K个结点,很自然的想法是先走到链表的尾端,再从尾端回溯K步.可是我们从链表结点的定义可疑看出本题中的链表 是单向链表,单向链表的结点只有从前往后的指针而没有从后往前的指针,因此这种思路行不通. 既然不能从尾节点开始遍历这个链表,我们还是把思路回到头

数据结构学习之单向链表的基本操作(非递归实现)

[摘要]本文讨论的均为带头结点的线性链表的基本操作,包括创建.删除.插入.打印等等,欢迎大家批评指正错误. (1)单链表存储结构 typedef struct LNode { int data; struct LNode *next; }LinkList; (2)创建链表 /* 功能:构建一个空的带头节点的单链表*/ Status InitList (struct LNode **L) { (*L) = (struct LNode *)malloc(sizeof(struct LNode));

线性表之单向链表的基本操作实现

这篇文章用来回顾单向链表的相关知识并实现如下几个操作: 初始化 插入 删除 逆置 销毁 且实现的链表为带头节点的单线非循环链表.由于链表在尾插入时需要遍历到链表的最后一个位置,所以我需要记住最后一个节点的位置,为此,本文会简单的实现一个单向链表的类. 0.链表的定义与类中提供的API 1 typedef int ELEMENT; 2 3 struct Node_s { 4 Node_s():data(),NEXT(nullptr){} 5 ELEMENT data; 6 Node_s * NEX

I学霸官方免费教程三十七:Java数据结构之单向链表结构

数据结构之单向链表 例如:现有双向链表OneWayLinked中存储着1,2,3,4四个元素,那么集合对象中会有4个节点A.B.C.D,由上述结构可以知道,节点A中存储着元素1和节点B:节点B中存储着元素2和节点C,节点C中存储着元素3和节点D,节点D中存储着元素4和null.如果现在要在元素2和3中间插入一个元素5:过程如下:1.创建节点E,E中存储元素52.将B中的下一个节点修改为节点E3.将E中的下一个节点赋值为节点C从上述过程看,插入时没有节点位置移动的操作,所以效率比较高:删除的过程和

使用java的循环单向链表解决约瑟夫问题

什么是约瑟夫问题 据说著名犹太历史学家 Josephus有过以下的故事:在罗马人占领乔塔帕特后,39 个犹太人与Josephus及他的朋友躲到一个洞中,39个犹太人决定宁愿死也不要被敌人抓到,于是决定了一个自杀方式,41个人排成一个圆圈,由第1个人开始报数,每报数到第3人该人就必须自杀,然后再由下一个重新报数,直到所有人都自杀身亡为止.然而Josephus 和他的朋友并不想遵从.首先从一个人开始,越过k-2个人(因为第一个人已经被越过),并杀掉第k个人.接着,再越过k-1个人,并杀掉第k个人.这

自己用20分钟java实现的单向链表(含有增删改查操作)

package test1; // 建立一个链表结构 public class SingleList { //定义头结点指针 Node head = null; //定义链表的节点数据结构 class Node{ int val; Node next; public Node(int val){ this.val = val; next = null; } } //在链表的尾部增加一个节点 public void add(int num){ Node node = new Node(num);

单向链表的基本操作-创建、插入、删除

一.链表的基本概念 单链表 :  n个结点链接成一个链式线性表的结构叫做链表,当每个结点中只包含一个指针域时,叫做单链表 表头结点:链表中的第一个结点,包含指向第一个数据元素的指针以及链表自身的一些信息 如长度等 ??数据结点:链表中代表数据元素的结点,包含指向下一个数据元素的指 ??尾结点:   链表中的最后一个数据结点,其下一元素指针为空,表示无后继  二.链表的定义 由于带头的链表操作比较方便,下文介绍的所有操作都是基于都头结点的单链表, 1.链表的定义 1 /* 链表节点的定义 */ 2