Java 实现链表结点插入

PS:链表是一种数据结构,而数据结构就是一种存放数据的方式。

为什么需要链表?

我们知道,数组也可以存储数据,那么为什么还需要链表呢?接下来,我们来看看数组 和链表的区别:

1、数组就像身上编了号站成一排的人,要找第10个人很容易,根据人身上的编号很快就能找到。但插入、删除慢,要往某个位置插入或删除一个人时,后面的人身上的编号都要变。当然,加入或删除的人始终末尾的也快。

2、链表就像手牵着手站成一圈的人,要找第10个人不容易,必须从第一个人一个个数过去。但插入、删除快。插入时只要解开两个人的手,并重新牵上新加进来的人的手就可以。删除一样的道理。

链表示意图

链表的建立

class TestLink{//创建一个外部类
	private Entry head;//指向头结点的引用
	public TestLink(){
		head = new Entry();//用结点类 new 一个头结点
	}

	class Entry{//Entry 创建一个结点内部类
		int data;//定义数据块
		Entry next;//定义地址块

		public Entry(){//构造方法1
			data = -1;//对结点数据块初始化
			next = null;//对地址初始化
		}
		public Entry(int val){//构造方法2
			data = val;//对数据块赋值
			next = null;
		}
	}
}
public class TestDemo2 {
			public static void main(String[] args) {
				TestLink testlink = new TestLink();
				//创建一个 链表外部类 对象
  }
}

头插法:从头插入

public void insertHead(int val){
  //有这么一个结点
  Entry cur = new Entry(val);
  cur.next = head.next;
  head.next = cur;
  }

头插法示意图:

尾插法:从尾插入

public void insertTail(int val){
				//找到尾巴
				Entry cur = head;
				while(cur.next != null){//遍历结点
					cur = cur.next;
				}
				Entry entry = new Entry(val);//得到的结点
				cur.next = entry;
			}

尾插法示意图:

从任意结点插入

public boolean insertPos(int val,int pos){
  //1、判断pos的合法性
  if(pos < 0 || pos >= getLength()+1){
   return false;
  }
  Entry cur = head;
  for(int i = 0;i <= pos-1;i++){
   cur = cur.next;
  }
  //cur  pos的前一个
  Entry entry = new Entry(val);
  entry.next = cur.next;
  cur.next = entry;
  return true;
  }

示意图:

完整代码:

package LianBiao;
class TestLink1{
	private Entry head;//指向头结点的引用
	public TestLink1(){
		head = new Entry();
	}

	class Entry{//Entry Node
		int data;
		Entry next;
		public Entry(){
			data = -1;
			next = null;
		}

		public Entry(int val){
			data = val;
			next = null;
		}
	}	

	public void insertHead(int val){
		//有这么一个结点
		Entry cur = new Entry(val);
		cur.next = head.next;
		head.next = cur;
		/*head.next = cur;
		cur.next = head.next;*/
	}

	public void insertTail(int val){
		//找到尾巴
		Entry cur = head;
		while(cur.next != null){
			cur = cur.next;
		}
		Entry entry = new Entry(val);//得到的结点
		cur.next = entry;
	}
	//得到单链表的长度:
	public int getLength(){
		int len = 0;
		Entry cur = head.next;
		while(cur != null){
			len++;
			cur = cur.next;
		}
		return len;
	}
	//将数据插入到指定位置
	public boolean insertPos(int val,int pos){
		//1、判断pos的合法性
		if(pos < 0 || pos >= getLength()+1){
			return false;
		}
		Entry cur = head;
		for(int i = 0;i <= pos-1;i++){
			cur = cur.next;
		}
		//cur  pos的前一个
		Entry entry = new Entry(val);
		entry.next = cur.next;
		cur.next = entry;
		return true;
	}
	//

	//show()
	public void show(){
		/*Entry cur = head;
		while(cur.next != null){
			System.out.println("data:"+cur.next.data);
			cur = cur.next;
		}*/
		Entry cur = head.next;
		while(cur != null){
			System.out.println("data:"+cur.data);
			cur = cur.next;
		}
	}

}
public class LianBiao1 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
				TestLink1 testlink = new TestLink1();

				testlink.insertTail(1330);
				testlink.insertTail(110);
				//1330 110
				testlink.insertPos(10,0);
				//10 1330 110

				if(testlink.insertPos(32,10000)){
					System.out.println("插入成功");
				}else{
					System.out.println("插入失败");
				}

				//10 32 1330 110

				testlink.show();
				System.out.println(testlink.getLength());
			}
		}

输出结果:

补充:java中创建链表,实现链表的尾部插入

我就废话不多说了,大家还是直接看代码吧~

package test;
//目标:创建链表,实现链表结点的尾部插入
class Node_5{
  private String data;
  public Node_5 nextNode;
  public void setData(String indata){
    this.data=indata;
  }
  public String getData(){
    return this.data;
  }
  public void setNextNode(Node_5 newNode){
    this.nextNode=newNode;
  }
  public Node_5 getNextNode(){
    return this.nextNode;
  }
  public void addData(String indata){
    setData(indata);
    Node_5 node_5=new Node_5();
    Node_5 head=node_5;
    if(node_5.getData()==null){
      node_5.setData(indata);
      System.out.println(node_5.getData());
    }
    else{
      node_5.setNextNode(node_5);
      node_5.setData(indata);
      System.out.println(node_5.getData());
    }
  }
}

public class T_5 {
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    Node_5 node_5=new Node_5();
    for(int i=1;i<=3;i++){
      node_5.addData("第"+i+"结点");
    }
  }
}

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。如有错误或未考虑完全的地方,望不吝赐教。

(0)

相关推荐

  • Java单链表的简单操作实现教程

    前言 用Java实现单链表的简单操作,阅读本文和上一篇文章体会Java中类与C++中结构体指针的区别 提示:以下是本篇文章正文内容,下面案例可供参考 一.基本实现思路 构造结点类 构造链表类 具体测试实现 二.代码实现 1.定义结点类 package list.test01; /* *定义结点类 */ public class Node { private int data; public Node next; public Node(int data) { this.data = data;

  • Java实现带头结点的单链表

    链表的特点 1,以节点方式存储,是链式结构. 2,每个节点包含data域,next域:指向下一个节点. 3,链表的各个节点不一定是连续存储. 4,链表分为带头节点和不带头节点两种类型的链表. 实现原理 添加节点:如下图所示,首先遍历原有链表,找到最后一个节点,将要增加的节点添加到该节点的后面.下面介绍如何找到最后一个节点. 思路是这样的,先遍历整个链表,定义一个辅助变量temp,用于暂时存储遍历出来的各个节点.首先将head头节点赋给temp(从头节点开始遍历),通过一个死循环不断的遍历节点的n

  • Java双向链表按照顺序添加节点的方法实例

    分析过程: 首先需要比较待添加的节点编号与已有的节点编号的大小,若待添加的节点编号已经存在,则不能加入.为防止出现空指针的情况,需要对节点的位置进行判断. 示例代码: package linkedlist; public class DoubleLinkedListDemo { public static void main(String[] args) { // 测试 System.out.println("双向链表的测试"); // 创建节点 Node node1 = new No

  • 用JAVA实现单链表,检测字符串是否是回文串

    一.需求 使用JAVA实现单链表,使用单链表检测字符串是否是回文串 二.需求分析 回文串最重要的就是对称,那么最重要的问题就是找到那个中心,用快指针每步走两格,当他到达链表末端的时候,慢指针刚好到达中心,慢指针在遍历过程中(快指针到达末端时)把走过的节点进行反向操作,此时从中位点分为前后两部分,此时前半部分的指针开始往回指(取next的时候,取的是前一个节点),而慢指针继续向前,跟前半部分的数据依次进行比对,当慢指针扫完整个链表,就可以判断这是回文串,否则就提前退出,同时在前半部分往回遍历的过程

  • Java 8实现任意参数的单链表

    本文实例为大家分享了Java 8实现任意参数的单链表,供大家参考,具体内容如下 1.实现功能 1)add():链表末尾添加元素: 2)pop():移除链表尾部元素: 3)insert():指定索引处添加元素: 4)delete():指定索引处删除元素: 5)getSize():获取链表当前长度: 6)display():展示链表当前元素. 2.代码 package DataStructure; /** * @author: Inki * @email: inki.yinji@qq.com * @

  • Java实现双向循环链表

    双向循环链表定义 相比于单链表,有两个指针,next指针指向下一个结点,prior指针指向上一个结点,最后一个结点的next指针指向头结点,头结点的prior指针指向最后一个结点 代码实现: 我们对单链表的实现加以修改 package algorithm.datastructure.doublelinkedlist; import java.util.NoSuchElementException; /* * 双向循环链表 * 两个指针,next指针指向下一个结点,prior指针指向上一个结点,最

  • Java 单链表数据结构的增删改查教程

    我就废话不多说了,大家还是直接看代码吧~ package 链表; /** * *1)单链表的插入.删除.查找操作: * 2)链表中存储的是int类型的数据: **/ public class SinglyLinkedList { private Node head = null; //查找操作 public Node findByValue(int value){ Node p = head; //从链表头部开始查找 while(p.next != null && p.data != va

  • Java 实现链表结点插入

    PS:链表是一种数据结构,而数据结构就是一种存放数据的方式. 为什么需要链表? 我们知道,数组也可以存储数据,那么为什么还需要链表呢?接下来,我们来看看数组 和链表的区别: 1.数组就像身上编了号站成一排的人,要找第10个人很容易,根据人身上的编号很快就能找到.但插入.删除慢,要往某个位置插入或删除一个人时,后面的人身上的编号都要变.当然,加入或删除的人始终末尾的也快. 2.链表就像手牵着手站成一圈的人,要找第10个人不容易,必须从第一个人一个个数过去.但插入.删除快.插入时只要解开两个人的手,

  • 如何利用Java输出链表中倒数第k个结点

    目录 前言 问题描述 方法一 方法描述 动画演示 代码如下 方法二 方法描述 动画演示 代码如下 总结 前言 链表是一种数据结构,和数组同级.比如,Java中我们使用的ArrayList,其实现原理是数组.而LinkedList的实现原理就是链表了.链表在进行循环遍历时效率不高,但是插入和删除时优势明显 本文主要介绍的是输出链表中倒数第k个结点,下面来一起看看详细的介绍吧 问题描述 给你一个单链表,输出倒数第k个结点,如下图链表中,输出倒数第k个结点,比如 k = 2,输出5这个结点. 方法一

  • Java 反转带头结点的单链表并显示输出的实现过程

    注意:要保证已经有Node类和单链表的初始化,这样才能调用反转方法并显示结果. 方法如下: //Node<T>指泛型结点类 public void reverse2(Node<T> head){ Node<T> p=head.next; Node<T> q=head.next.next; head.next=null; p.next=null; while(q!=null){ Node<T> temp=q.next; q.next=p; p=q;

  • Java单链表的实现代码

    下面是小编给大家分享的一个使用java写单链表,有问题欢迎给我留言哦. 首先定义一个Node类 public class Node { protected Node next; //指针域 public int data;//数据域 public Node( int data) { this. data = data; } //显示此节点 public void display() { System. out.print( data + " "); } } 接下来定义一个单链表,并实现

  • Java单链表基本操作的实现

    最近被问到链表,是一个朋友和我讨论Java的时候说的.说实话,我学习编程的近一年时间里,学到的东西还是挺少的.语言是学了Java和C#,关于Web的学了一点Html+css+javascript.因为比较偏好,学习WinForm时比较认真,数据库操作也自己有所研究.但链表这个东西我还真没有学习和研究过,加上最近自己在看WPF,而课程也到了JSP了,比较紧. 但是我还是抽了一个晚上加半天的时间看了一下单向链表.并且使用Java试着写了一个实例出来.没有接触过链表的朋友可以作为参考,希望大家多提宝贵

  • Java实现链表的常见操作算法详解

    链表分为单链表,双向链表和循环链表,是一种链式存储结构,由一个个结点链式构成,结点包含数据域和指针域,其中单链表是只有一个指向后驱结点的指针,双向链表除头结点和尾结点外,每个结点都有一个前驱指针和一个后继指针,循环链表的尾结点的指针指向头结点. 相比数组而言,链表的插入和删除比较快,查询慢. 本文主要以单链表为例,介绍下链表的常用算法操作. 单链表的结构: 在java语言中,链表的每个结点用Node类来表示: package com.linkedlist; public class Node {

  • Java实现链表数据结构的方法

    什么是链表? 链表是一种物理存储单元上非连续.非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针连接次序实现的.每一个链表都包含多个节点,节点又包含两个部分,一个是数据域(储存节点含有的信息),一个是引用域(储存下一个节点或者上一个节点的地址). 链表的理解示意图: 链表的特点是什么? 获取数据麻烦,需要遍历查找,比数组慢方便插入.删除 简单的链表的实现原理 创建一个节点类,其中节点类包含两个部分,第一个是数据域(你到时候要往节点里面储存的信息),第二个是引用域(相当于指针,单向链表有一个指

  • Java单链表的增删改查与面试题详解

    目录 一.单链表的增删改查 1.创建结点 2.单链表的添加操作 3.单链表的删除操作 4.单链表的有效结点的个数 二.大厂面试题 一.单链表的增删改查 1.创建结点 单链表是由结点连接而成,所以我们首先要创建结点类,用于对结点进行操作.定义data属性 表示序号,定义name属性表示结点存放的数据信息,定义next属性表示指向下一个结点.构造器只需要放入data属性和name属性,重写toString方法方便打印结点信息. public class Node { public int data;

  • Java输出链表倒数第k个节点

    问题描述 输入一个链表,输出该链表中倒数第k个结点.(尾结点是倒数第一个) 结点定义如下: public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } } 思路1: 先遍历链表,计算其长度length; 然后计算出倒数第k个结点就是正数第length - k + 1. 最后再遍历链表,找到所求结点 时间复杂度O(2n),需要遍历两次链表 代码如下: public List

随机推荐