java数据结构之链式线性表的实现

最新推荐文章于 2022-02-15 00:44:39 发布
最新推荐文章于 2022-02-15 00:44:39 发布
阅读量230 收藏 1
点赞数
分类专栏： Java基础-数据结构 文章标签： java 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hicodden/article/details/105919091
版权
这篇博客详细介绍了如何使用Java实现链式线性表，包括单向链表、双向链表和循环链表的节点定义与实现。线性表的特点是具有首尾元素，每个元素有唯一的前驱和后继。文章讨论了链表节点的结构，如数据域和指针域，并提供了不同链表类型的实现策略。
摘要由CSDN通过智能技术生成

目录

链式线性表

线性表的相关概念：
链式线性表的定义：用一组任意的存储单元存储线性表的数据元素，这里的存储单元可以是连续也可以是不连续的。

特点：

  1. 存在唯一的可以被称为“第一个”的数据元素
  2. 存在唯一的可以被称为“最后一个”的数据元素
  3. 除了第一个元素之外，每个元素都只有一个唯一的前驱
  4. 除了最后一个元素之外，每个元素都只有一个唯一的后继

线性表可以用数组和链表实现，笔记中主要记录如何用用链表区实现线性表的。
线性链表：是用链表实现的线性表，链表中的每一个存储单元称之为结点。每一个结点中只有一个指针域的结点的称之为单链表；在单链表中链表的尾部指向头部的称之为循环链表；每个结点中有两个指针域的称之为双链表。
结点：由数据域和指针域组成，数据域用于存放数据，指针域用于指向(前驱)后继的元素，即(上)下一个结点。

1、单向链表的实现

1.1、单链表的节点实现：

  • 定义一个数据域用于存放数据，在这里使用到了泛型
  • 定义一个指针域用于存放后继的结点位置

备注：这里可以使用 data 和 next 这两个成员属性定义为私有，即使用 private 修饰，提供相应的 get 和 set 方法。

 class SingleLinkNode<T> {
 	// 数据域:用于存放数据
	public T data;
	// 指针域：用于指向后继的元素，即下一个结点
	public SingleLinkNode next;
	// 构造方法
	pulbic SingleLinkNode(){
		super();
	}
	public SingleLinkNode(T t){
		this.data = t ;
		this.next= null;
	}
	
}

1.2、单链表的实现
本次实现中已将 SingleLinkNode 作为SingleLink内部类，所以无需再提供额外的 SingleLinkNode 类。

public class SingleLink<T>{
    // 创建一个头指针
    private SingleLinkNode head;
    public SingleLink(){
        head = new SingleLinkNode();
        this.head.data = null;
        this.head.next = null;
    }
    // 获取线性表的长度
    public int size(){
        SingleLinkNode temp = head;
        int size = 0 ;
        while(temp.next != null){
            temp = temp.next;
            size++;
        }
        return size;
    }
    // 清空线性表
    public void clear(){
        // 将链表的头指针置空即可
        this.head.next = null;
    }
    // 获取指定链表中的数据
    public Object get(int index){
        // 判断获取的位置是否合理
        int size = this.size();
        if(index < 0 || index >= size){
            throw new RuntimeException("获取的位置不合理！");
        }
        //创建临时变量
        //将index定位到指定元素第一次出现的位置
        SingleLinkNode temp = locateNode(index);
        //返回节点中的数据
        return temp.data;
    }
    // 定位到data第一次出现的位置
    public int locate(T data){
        int index = -1;
        int tempIndex = 0;
        SingleLinkNode temp = head.next;
        while(temp != null){

            if(data.equals(temp.data)){
                index = tempIndex;
                break;
            }
            temp = temp.next;
            tempIndex++;
        }
        // 如果返回的是-1，则代表没有找到
        return index;
    }

    //返回到data第一次出现的节点
    private SingleLinkNode locateNode(int index){
        SingleLinkNode temp = head;

        while(index >= 0){
            temp = temp.next;
            index--;
        }
        return temp;

    }

    // 添加数据，没有指定的位置的话，默认在队列的尾部插入
    public void add(T data){
        // 判断加入的数据是否为空
        if(data == null){
            throw new RuntimeException("插入的数据不能为空");
        }
        SingleLinkNode insertNode = new SingleLinkNode(data) ;
        SingleLinkNode temp = this.head;
        while(temp.next != null){
            temp = temp.next;
        }
        insertNode.next =null;
        temp.next = insertNode;
    }
    // 重载add方法，在index位置上插入的数据，index和数组索引一样从 0 开始
    public void add(int index,T data){
        // 判断插入的位置是否合理
        if(index <0 || index >this.size()){
            throw new RuntimeException("插入的位置不合理");
        }
        //判断插入的数据是否为空，
        if(data == null){
            throw new RuntimeException("插入的数据不能为空");
        }
        // 创建一个插入的节点
        SingleLinkNode insertNode  = new SingleLinkNode(data);

        SingleLinkNode temp = locateNode(index -1 );
        insertNode.next = temp.next;
        temp.next = insertNode;
    }
    //删除指定索引的元素
    public Object remove(int index){
        // 判断删除的位置是否合理
        if(index <0 || index >= this.size()){
            throw new RuntimeException("插入的位置不合理");
        }

        SingleLinkNode temp = locateNode(index -1 );
        SingleLinkNode delNode = temp.next;
        temp.next = delNode.next;
        return delNode.data;
    }
    // 删除链表中第一次出现的data数据返回，删除的data的索引
    public int  remove(T data){
    	//
        int index = -1;
        int tempIndex = 0;
        SingleLinkNode temp = head.next;
        // 这里要考虑在遍历的时候能否也将第一个和最后一个也进行数据的检查
        while(temp != null){
			//检查下一位的data是否与传入的数据相等
            if(data.equals(temp.next.data)){
            	// 有可能data数据刚好在最后一个，如果直接进行 temp.next = temp.next.next的，可能会出现空指针异常
				if(temp.next != null){
           			 temp.next = temp.next.next;
       			 }
                index = tempIndex;
                break; // 跳出循环
            }
            temp = temp.next;
            tempIndex++;
        ｝
        // 如果返回的是-1，则代表没有找到
        return index;
    }

    public void showLink(){
        SingleLinkNode temp = this.head;
        System.out.print("[");
        while(temp.next != null ){
            temp = temp.next;
            System.out.print(temp.data);
            if(temp.next != null){
                System.out.print(",");
            }
        }
        System.out.println("]");
    }

    public boolean isEmpty(){
        return this.head.next == null;
    }



    // 使用private 修饰符，将SingleLinkNode封装进入SingleLink中，不直接暴露外部
     private class SingleLinkNode<T> {
        public T data;
        public SingleLinkNode next;
        public  SingleLinkNode(){
            super();
        }
        public SingleLinkNode(T t){
            this.data = t ;
            this.next= null;
        }

         @Override
         public String toString() {
             return "SingleLinkNode{" +
                     "data=" + data +
                     '}';
         }
     }
}

2、双向链表

2.1、双链表结点的实现

class DoubleLinkNode<T>{
	public T data;
	// 前驱指针
	public DoubleLinkNode pre;
	// 后继指针
	public DoubleLinkNode next;
	
	//构造方法
	public DoubleLinkNode(){}
	
	public DoubleLinkNode(T data){
		this.data = data;
	}
}

2.2、双链表的实现

public class DoubleLink<T>{

    private DoubleLinkNode head;

    public DoubleLink(){
        this.head = new DoubleLinkNode();
        this.head.data = null;
        this.head.pre = null;
        this.head.next = null;
    }
    // 获取链表的长度
    public int size(){
        DoubleLinkNode temp = head.next;
        int size = 0 ;
        while(temp != null){
            temp = temp.next;
            size++;
        }
        return size;
    }
    // 清空线性表
    public void clear(){
        // 将链表的头指针置空即可
        this.head.next = null;
        }

    // 获取指定链表中的数据
    public Object get(int index){
        // 判断获取的位置是否合理
        int size = this.size();
        if(index < 0 || index >= size){
            throw new RuntimeException("获取的位置不合理！");
        }
        //创建临时变量
        //将index定位到指定元素第一次出现的位置
        DoubleLinkNode temp = locateNode(index);
        //返回节点中的数据
        return temp.data;
        }
    // 定位到data第一次出现的位置
    public int locate(T data){
        int index = -1;
        int tempIndex = 0;
        DoubleLinkNode temp = head.next;
        while(temp != null){
            if(data.equals(temp.data)){
                index = tempIndex;
                break;
             }
            temp = temp.next;
            tempIndex++;
        }
            // 如果返回的是-1，则代表没有找到
            return index;
        }

    //返回到data第一次出现的节点
    private DoubleLinkNode locateNode(int index){
        // 判断获取的位置是否合理
        int size = this.size();
        if(index < 0 || index >= size){
            throw new RuntimeException("获取的位置不合理！");
        }

        DoubleLinkNode temp = head;

        while(index >= 0){
            temp = temp.next;
            index--;
        }
        return temp;

        }

    // 添加数据，没有指定的位置的话，默认在队列的尾部插入
    public void add(T data){
        // 判断加入的数据是否为空
        if(data == null){
            throw new RuntimeException("插入的数据不能为空");
        }
        DoubleLinkNode insertNode = new DoubleLinkNode(data) ;
        DoubleLinkNode temp = this.head;
        while(temp.next != null){
            temp = temp.next;
        }

        temp.next = insertNode;
        insertNode.pre = temp;
        insertNode.next =null;
    }
    // 重载add方法，在index位置上插入的数据，index和数组索引一样从 0 开始
    public void add(int index,T data){
        // 判断插入的位置是否合理
        if(index <0 || index > this.size()){
            throw new RuntimeException("插入的位置不合理");
        }
        //判断插入的数据是否为空，
        if(data == null){
            throw new RuntimeException("插入的数据不能为空");
        }
        if (index == size()){
            this.add(data);
            return;
        }
        // 创建一个插入的节点
        DoubleLinkNode insertNode  = new DoubleLinkNode(data);

        DoubleLinkNode temp = locateNode(index);
        insertNode.pre = temp.pre;
        temp.pre.next = insertNode;
        insertNode.next = temp;
        temp.pre = insertNode;

    }
    //删除指定索引的元素
    public Object remove(int index){
        // 判断删除的位置是否合理
        if(index <0 || index >= this.size()){
            throw new RuntimeException("删除的位置不合理");
        }
        DoubleLinkNode delNode = locateNode(index);
        delNode.pre.next = delNode.next;
        // 如果del是最后一个元素，会出现空指针异常，进行判断避免空指针异常
        if( delNode.next != null ){
            delNode.next.pre = delNode.pre;
        }
        return delNode.data;
    }
    // 删除链表中第一次出现的data数据返回，删除的data的索引
    public int  remove(T data) {
        //
        int index = -1;
        int tempIndex = 0;
        DoubleLinkNode temp = head.next;
        // 这里要考虑在遍历的时候能否也将第一个和最后一个也进行数据的检查
        while (temp != null) {
            //检查下一位的data是否与传入的数据相等
            if (data.equals(temp.data)) {
                temp.pre.next = temp.next;
                // 有可能data数据刚好在最后一个，如果直接进行 temp.next = temp.next.next的，可能会出现空指针异常

                if (temp.next != null) {
                    temp.next.pre = temp.pre;
                }
                index = tempIndex;
                break; // 跳出循环
            }
            temp = temp.next;
            tempIndex++;
        }
        // 如果返回的是-1，则代表没有找到
        return index;
    }

    public void showLink () {
        DoubleLinkNode temp = this.head;
        System.out.print(" [");
        while (temp.next != null) {
            temp = temp.next;
            System.out.print(temp.data);
            if (temp.next != null) {
                System.out.print(",");
            }
        }
        System.out.println("]");
    }

    public boolean isEmpty() {
        return this.head.next == null;
    }

    private class DoubleLinkNode<T>{
        public T data;
        // 前驱指针
        public DoubleLinkNode pre;
        // 后继指针
        public DoubleLinkNode next;

        // 构造方法
        public DoubleLinkNode() {
        }
        // 构造方法
        public DoubleLinkNode(T data) {
            this.data = data;
        }
    }
    
}

3、循环链表的实现

3.1、循环链表节点的实现
循环链表的结点实现是单链表是一样

class CircleLinkNode<T>{
	public T data;
	public CircleLinkNode next;
	//提供构造方法
	public CircleLinkNode(){}
	public CircleLinkNode(T data){
		this.data = data;
	}
}

3.2 循环链表的实现

public class CircleLink{
	private CircleLinkNode head;
	
	public CircleLink(){
		this.head =  new  CircleLinkNode() ;
		haed.data = null;
		//在循环列表中，列表为空的时候，头指针指向自己
		head.next =head;
	}
	public int size(){
		int size = 0;
		if(head.date == null && head.next == head){
			return size;
		}
		size = 1 ;
		CircleLinkNode temp= head;
		while(temp.next != head){
			size++;
			temp = temp.next;
		}
		return size;
	}
	// 判断是否为空
	public boolean isEmpty(){
		if (head.data = null && head.next == head){
			return true;
		}
		return false;
	}
	// 定位到指定元素的缩影
	private CircleLinkNode locateNode(int index){
		if(isEmpty()){
			throw new RuntimeException("链表为空");
		}
		if(index < 0 || index >= size()){
			throw new RuntimeException("查找的位置不合理");
		}
		CircleLinkNode temp = head;
		
		while(index > 0){
			temp =temp.next;
			index--;
		}
		return temp;
	}
	// 返回index位置的数据域
	public Object locate(index){
		locateNode(index).data;
	}
	//是在链表的尾部添加
	public void add(T dada){
		if(data == null){
			throw new RuntimeException("插入的数据不能为空");
		}
		if(head.data = null){
			head.data =data;
		}else{
			CircleLinkNode insertNode = new CircleLinkNode(data);
			CircleLinkNode temp= head;
			while(temp.next != head){
				temp = temp.next;
			}
			insertNode.next =temp.next;
			temp.next = insertNode;
		}
	}
	//在指定的位置插入
	public  void add(int index,T data){
		//检查插入的数据
		if(data == null){
			throw new RuntimeException("插入的数据不能为空");
		}
		// 检查插入的位置是否合理
		if(index < 0 || index > size()){
			throw new RuntimeException("插入的位置不合理");
		}
		// 经过前面的检查就可以进行操作操作了
		CircleLinkNode insertNode = new CircleLinkNode(data);
		CircleLinkNode temp= head;
		// 判断是否插入到链表的头部
		if(index == 0 ){
			//定位到链表的尾部
			while(temp.next != head){
				temp = temp.next;
			}
			//直接插入到链表的尾部
			insertNode.next =temp.next;
			temp.next = insertNode;
			//最后直接将insertNode设置为head
			head = insertNode;
			return ;
		}
		// 定位到插入位置的前一个元素
		CircleLinkNode temp = locateNode(index-1);
		insertNode.next = temp.next;
		temp.next = insertNode;
	}
	// 删除链表中指定位置的元素
	public Object remove(int index){
		if(index < 0 || index >= size()){
			throw new RuntimeException("删除的位置不合理")
		}
		if(index == 0){
			data = head.data;
			CircleLinkNode temp = head;
			while(temp.next == head){
				temp = temp.next;
			}
			temp.next = head.next;
			head = head.next;
			return data;
		}
		//定位到index前一位，即index-1
		CircleLinkNode preNode = locateNode(index - 1 );
		Object data = preNode.next.data;
		preNode.next =preNode.next.next;
		return data;
		}
	}
}
库隐
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链式线性表实现
07-28
C++ 链式线性表实现
java实现线性链表结构
weixin_33861800的博客
10-02 69
package com.hephec.ds; public class LinkedList&lt;T&gt; { //定义一个内部类节点Node Node实例代表链表的节点 class Node{ //保存节点的数据 private T data; //保存下一个节点的引用 private Node next; //无參的构造方法 public Node(){ ...
线性表的链式实现-java
mkii_hong的博客
07-24 338
线性表的链式实现，只包含一些简单的操作，缺少严谨。 只做思路参考。 /** * 线性表的简单链式实现 * * @author mkii */ public class LinList { // 头结点 private Node nodes; /** * 结点实际的内容结构 * */ class Node { ...
链式线性表的java实现
小楼一夜听春雨
03-19 888
链式线性表将采用一组地址任意的存储单元存放线性表中的数据元素。链式结构的线性表不会按线性的逻辑顺序保存数据元素，它需要在每一个数据元素里保存一个指向下一个数据元素的引用。 链式结构克服了顺序结构需要预先知道数据大小的缺点，可以充分利用计算机的内存空间，实现内存的动态分配。在插入和删除操作上，比顺序结构简单，但是失去了顺序结构的随机存取特性，并且由于每个节点增加了一个引用，所以空间开销也比较大。
数据结构_线性表_链表(Java实现)
Fam044的博客
10-29 251
*文中内容来源于《数据结构 --Java语言描述》（第二版） 刘小晶 杜选 主编 *此系列文章作为学习记录，若文中内容有误，请大家指出，谢谢 链表 顺序存储的局限性： 若要为线性表扩充存储空间，则需重新创建一个地址连续的更大的存储空间，并把原有的数据元素都复制到新的存储空间中； 顺序存储要求逻辑上相邻的数据元素，在物理存储位置上也相邻，所以增删数据元素则会引起平均约一半的数据元素的移动。 对...
Java数据结构之线性表
08-31
Java中的线性表是一种基本的数据结构，它由一系列具有线性关系的元素构成，这些元素在逻辑上形成一个序列。线性表支持多种操作，包括获取元素、设置元素值、遍历、插入、删除、查找、替换和排序。线性表的存储方式有...
Java数据结构（线性表）详解
08-30
在Java中，线性表可以有多种实现方式，但本文主要讨论的是链式存储的实现，即单链表。 单链表是一种线性表的链式存储结构，它的每个节点包含两部分：数据域和指针域。数据域用于存储数据元素，而指针域则指向下一个...
数据结构实验线性表实验报告（代码是java编写的）
05-10
实验报告涉及的知识点主要集中在数据结构中的线性表，包括顺序表和循环链表的实现与操作。线性表是一种逻辑结构，其中的数据元素按照线性顺序排列，可以通过顺序存储或链式存储来实现。 1. **顺序表**：顺序表是用...
数据结构之线性表教程3.zip
最新发布
01-02
在这个“数据结构之线性表教程3.zip”压缩包中，很可能是对线性表的深入讲解和实践应用的资源集合。 线性表是一种一维数组结构，其中的元素按照特定顺序排列。每个元素都有一个唯一的索引，通常从0或1开始。线性表...
Java数据结构之查找
08-31
Java数据结构之查找 本文主要介绍了Java数据结构中查找的相关知识，具有很好的参考价值。下面我们来详细的解释查找的知识点。 1. 线性表查找 线性表查找是最基本的查找方法，主要分为顺序查找和链式查找。顺序表...
【数据结构】线性链表的Java实现
Microstrong
09-30 1082
public class LinkedList { public ListNode head; public ListNode current; class ListNode{ int val; //数据域 ListNode next = null; //指针域 public ListNode(int val) { this.val =val; ...
链式线性表--java实现
九术沫的博客
11-15 198
public class LinkList { private Node head;//链表头 private int size;//节点个数 /* * 构造一个节点 结构 * 这个节点类 有两个构造方法 * Node node1 = new Node(); * Node node2 = new Node(val); * 这个现象叫方法重载 * 一个节点有两个属性，节点值 val 和 节点后驱 next，两个属性都是 public * 所以除了通过构造方法初始化属性.
java实现线性表链式存储结构
m0_37860420的博客
11-08 380
定义结点 public class Node { private int data; private Node next; public Node() {} public Node(int data){ this.data= data; } public Node(int data,Node next) { this.data=data; this.n...
类实现线性链表
codeHappy'Blog
10-22 1119
LinkList.cpp:*********************************************************************************************************************#include#include"ListClass.h"void main(){    int insertPostion,insertN
java链式结构_线性表链式存储结构及Java语言实现
weixin_33509203的博客
02-15 689
文章导读【线性表还有另外一种存储结构，就是链式存储结构。链式存储结构对逻辑上相邻的线性表元素不要求物理位置也相邻，相邻元素之间通过指针链接。本文主要讨论线性表的链式存储结构及其运算】前面研究了线性表的顺序存储结构，它的特点是逻辑关系上相邻的两个元素在物理位置上也相邻，因此，可以随机存取表中的任一元素。然而，从另一方面来看，这个特点也造成了顺序存储结构的三个弱点：其一，线性表在作插入或删除元素时，需...
线性表的链式实现(C++)
weixin_30436101的博客
05-09 560
相关内容： 线性表的顺序实现 链式实现（C语言） （推荐在GitHub上查看，下面代码只是最初实现，后续如果有修改，由于太麻烦，不会再更改下文，仅仅更新Github上的代码文件） 结点以及链表类的定义： 1 #define ElemType int 2 3 class LNode { 4 public: 5 LNode(ElemType ele,...
Java 用链表实现线性表（LinkList）增、删、查、遍历等
qq_41025410的博客
02-15 995
Java 用链表实现线性表（LinkList）增、删、查、遍历等
实现一个链式存储的线性表
konnisan的博客
11-05 5027
实现一个链式存储的线性表任务描述相关知识编程要求测试说明代码实现 任务描述 本关任务：完成一个链接存储的线性表的小程序。 相关知识 线性表的存储也可以采用链接存储方式来实现。链接存储方式包括单链表、双链表和循环链表等形式。 下面描述了一种基于单链表的线性表实现方案： 为了讨论简单，假设数据元素的类型为整型： typedef int T; 在链表中，每个数据元素为一个链表结点，结点的具体定义为： struct LinkNode { T data; LinkNode* next; }; 如
数据结构链式表实验报告
u011788205的专栏
03-31 1318
#include #include #include #define MaxSize 100 typedef int ElemType; typedef struct LNode              //定义单链表节点类型 { ElemType data;          //存放元素值     struct LNode *next;  //指向后继节点
Java数据结构详解：线性表与顺序/链式存储
Java数据结构课程涵盖了丰富的线性表理论与实现。第2章主要介绍了线性表的基本概念和几种常见类型的线性表，包括顺序表、单链表、循环单链表和循环双向链表。 2.1 线性表是数据结构中的基础概念，它定义为一个数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值