devbox
小舞很执着
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构——链表的实现（Java版）_java链表结构的实现

作者：小舞很执着 | 2024-07-01 18:45:56

赞

踩

java链表结构的实现

目录

一、链表

二、代码实现

1.创建结点

2.构造函数

3.链表的相关属性

4.添加虚拟节点

5.判断链表是否为空

6.添加方法

（1）在头部添加

（2）在尾部添加

（3）在索引位置添加

（4）对头插法和尾插法代码进行简化（调用任意位置添加的方法）

7.打印链表（遍历，重写toString方法）

8.获取链表元素个数（链表长度）

9.获取链表结点

（1）获取头结点

（2）获取尾结点

（3）获取指定位置结点

10.判断结点是否存在

11.删除结点

（1）删除头结点

（2）删除尾节点

（3）在指定位置删除结点

（4）删除元素

（5）不使用虚拟节点删除

一、链表

链表是真正的动态数据结构，也是最简单的动态数据结构。

动态数据结构还有：二叉树，trie等

优点：不需要处理固定容量的问题，真正的动态

缺点：丧失了随机访问的能力

学习链表有助于更深理解引用和递归

二、代码实现

1.创建结点

使用内部类来创建结点

  1. //使用内部类——创建结点
  2.     class Node<T>{
  3.         T data;//节点本身
  4.         Node next;//指向下个节点

2.构造函数

两个构造函数（传入的参数不同）

  1. public Node(T data){
  2.             this.data=data;
  3.             this.next=null;
  4.         }
  5.  
  6.         public Node(T data,Node next){
  7.             this.data=data;
  8.             this.next=null;
  9.         }
  10.  
  11.     }

3.链表的相关属性

头结点和结点个数（链表长度）

  1. private Node head;//头结点
  2.     private int size;//表示链表中有多少个结点

4.添加虚拟节点

  1. public SelfLinkedList(){
  2.         //创建一个虚拟头结点
  3.         Node dummyHead=new Node(Integer.MIN_VALUE);
  4.         this.head=dummyHead;
  5.         this.size=0;
  6.  
  7.         dummyHead.next=head;
  8.     }

5.判断链表是否为空

  1. public boolean isEmpty(){
  2.         return this.size==0;
  3.     }

6.添加方法

（1）在头部添加

  1. public void addHead(T data){
  2.         //创建一个节点
  3.         Node node= new Node(data);
  4.         //挂接
  5.         node.next=this.head;
  6.         this.head=node;
  7.         //更新size
  8.         this.size++;
  9.     }

（2）在尾部添加

  1. public void addTail(T data){
  2.         Node node=new Node(data);
  3.         //针对空链表做处理
  4.         if(this.head==null){
  5.             this.head=node;
  6.             this.size++;
  7.             return;
  8.         }
  9.         Node curNode=this.head;
  10.         while(curNode.next!=null){
  11.             curNode=curNode.next;
  12.         }
  13.         curNode.next=node;
  14.         this.size++;
  15.     }

（3）在索引位置添加

  1. //在任意位置添加
  2.     public void add(int index,T data){
  3.         //判断index是否有效
  4.         if(index<0||index>this.size){
  5.             throw new IllegalArgumentException("index is invalid");
  6.         }
  7.         //创建一个节点
  8.         Node node= new Node(data);
  9.         //特殊处理1：如果索引为0,
  10.         if(index==0){
  11.             this.head=new Node(data,this.head);
  12.             this.size++;
  13.             return;
  14.         }
  15.         //特殊处理2：链表为空（异常已抛出）
  16.         //找前驱结点，从头开始找，让索引移动index-1次
  17.         Node pre=this.head;
  18.         for(int i=1;i<=index;i++){
  19.             pre=pre.next;
  20.         }
  21.         //开始进行结点的挂接
  22.         node.next=pre.next;
  23.         pre.next=node;
  24.         this.size++;
  25.     }

（4）对头插法和尾插法代码进行简化（调用任意位置添加的方法）

  1. //在头部添加
  2.     public void addHead(T data){
  3.        
  4.         add(0,data);
  5.     }
  6.  
  7.     //在尾部添加
  8.     public void addTail(T data){
  9.         
  10.         add(this.size,data);
  11.     }

7.打印链表（遍历，重写toString方法）

  1. //打印整个链表
  2.     @Override
  3.     public String toString() {
  4.         //从this。head开始一直向后
  5.         Node curNode=this.head.next;
  6.         StringBuilder sb=new StringBuilder();
  7.         while(curNode!=null){
  8.             sb.append(curNode.data+"-->");
  9.             curNode=curNode.next;
  10.         }
  11.         sb.append("null");
  12.         return sb.toString();
  13.     }

8.获取链表元素个数（链表长度）

  1.  //获取链表中元素的个数
  2.     public int getSize(){
  3.         return this.size;
  4.     }

9.获取链表结点

（1）获取头结点

  1. //获取链表的头结点
  2.     public Optional getFirst(){
  3.         if(this.head.next==null){
  4.             return Optional.empty();
  5.         }
  6.         return Optional.ofNullable(this.head.next.data);
  7.     }

（2）获取尾结点

  1. //获取链表的尾结点
  2.     public Optional getLast(){
  3.         if(this.head.next==null){
  4.             return Optional.empty();
  5.         }
  6.         Node<T> curNode=this.head;
  7.         while(curNode.next!=null){
  8.             curNode=curNode.next;
  9.         }
  10.         return Optional.of(curNode.data);
  11.     }

（3）获取指定位置结点

  1.  //从链表中获取任意位置的结点
  2.     public T get(int index) {
  3.         if (index < 0 || index >= this.size) {
  4.             throw new IllegalArgumentException("index is invalid");
  5.         }
  6.         Node<T> curNode = this.head.next;
  7.         int i = 0;
  8.         while (i < index) {
  9.             curNode = curNode.next;
  10.             i++;
  11.         }
  12.         return curNode.data;
  13.     }

10.判断结点是否存在

  1.  //从链表中查找指定位置元素是否存在
  2.     public boolean contains(T data) {
  3.         Node curNode = this.head.next;
  4.         while (curNode != null) {
  5.             if (curNode.data.equals(data)) {
  6.                 return true;
  7.             }
  8.         }
  9.         return false;
  10.     }

11.删除结点

（1）删除头结点

  1.  //从链表的头部删除元素
  2.     public T removeHead() {
  3.         if (this.isEmpty()) {
  4.             return null;
  5.         }
  6.         Node<T> delNode = this.head.next;
  7.         this.head.next = delNode.next;
  8.         delNode.next = null;
  9.         //更新size;
  10.         this.size--;
  11.         return delNode.data;
  12.     }

（2）删除尾节点

  1. //链表的尾部删除元素
  2.     public T removeTail() {
  3.         if (this.isEmpty()) {
  4.             return null;
  5.         }
  6.         Node<T> pre = this.head;
  7.         while (pre.next.next != null) {
  8.             pre = pre.next;
  9.         }
  10.         Node<T> delNode = pre.next;
  11.         pre.next = delNode.next;
  12.         delNode.next = null;
  13.         //更新size;
  14.         this.size--;
  15.         return delNode.data;
  16.     }

（3）在指定位置删除结点

  1. //删除任意位置的结点
  2.     public T remove(int index){
  3.         if(index<0||index>=this.size){
  4.             throw new IllegalArgumentException("index is invalid");
  5.         }
  6.         //找删除结点的前驱
  7.         Node<T>pre=this.head;
  8.         int i=0;
  9.         while(i<index){
  10.             pre=pre.next;
  11.             i++;
  12.         }
  13.         Node<T>delNode=pre.next;
  14.         pre.next=delNode.next;
  15.         delNode.next=null;
  16.         this.size--;
  17.         return delNode.data;
  18.     }

（4）删除元素

  1. //根据值从链表中删除元素
  2.     public int removeByValue(T value){
  3.         int count=0;
  4.         //定义前驱结点
  5.         Node<T>pre=this.head;
  6.         while(pre.next!=null){
  7.             Node curNode=pre.next;
  8.             if(curNode.data.equals(value)){
  9.                 pre.next=pre.next.next;
  10.                 curNode.next=null;
  11.                 this.size--;
  12.                 count++;
  13.             }else{
  14.                 pre=pre.next;
  15.             }
  16.         }
  17.         return count;
  18.     }

（5）不使用虚拟节点删除

  1. //不使用虚拟头结点
  2.     public int removeByValue2(T val){
  3.         int count = 0;
  4.         Node<T> realHead = this .head.next;
  5.  
  6.         while(realHead!=null&&realHead.data.equals(val)){
  7.             realHead=realHead.next;
  8.             this.size--;
  9.             count++;
  10.         }
  11.  
  12.         //判断链表是否为空
  13.         if(realHead==null){
  14.             return count;
  15.         }
  16.  
  17.         //头结点不是删除的点
  18.         Node pre = realHead;
  19.         while(pre.next!=null){
  20.             Node<T> delNode = pre.next;
  21.             if(delNode.equals(val)){
  22.                 pre.next = delNode .next;
  23.                 delNode.next = null;
  24.                 this.size--;
  25.                 count++;
  26.             }else{
  27.                 pre = pre .next;
  28.             }
  29.         }
  30.         return count;
  31.     }

三、完整代码

  1. package com.algo.lesson.lesson03;
  2.  
  3. import java.util.Optional;
  4. import java.util.Random;
  5.  
  6. public class SelfLinkedList<T> {
  7.     //使用内部类——创建结点
  8.     class Node<T> {
  9.         T data;//节点本身
  10.         Node next;//指向下个节点
  11.  
  12.         public Node(T data) {
  13.             this.data = data;
  14.             this.next = null;
  15.         }
  16.  
  17.         public Node(T data, Node next) {
  18.             this.data = data;
  19.             this.next = null;
  20.         }
  21.  
  22.     }
  23.  
  24.     //链表相关的属性和方法
  25.     private Node head;//头结点
  26.     private int size;//表示链表中有多少个结点
  27.  
  28.     public SelfLinkedList() {
  29.         //创建一个虚拟头结点
  30.         Node dummyHead = new Node(Integer.MIN_VALUE);
  31.         this.head = dummyHead;
  32.         this.size = 0;
  33.  
  34.         dummyHead.next = head;
  35.     }
  36.  
  37.     //判断链表是否为空
  38.     public boolean isEmpty() {
  39.         return this.size == 0;
  40.     }
  41.  
  42.     //向链表中添加结点
  43.     //在头部添加
  44.     public void addHead(T data) {
  45.         /*//创建一个节点
  46.         Node node= new Node(data);
  47.         //挂接
  48.         node.next=this.head;
  49.         this.head=node;
  50.         //更新size
  51.         this.size++;*/
  52.         add(0, data);
  53.     }
  54.  
  55.     //在尾部添加
  56.     public void addTail(T data) {
  57.         /*Node node=new Node(data);
  58.         //针对空链表做处理
  59.         if(this.head==null){
  60.             this.head=node;
  61.             this.size++;
  62.             return;
  63.         }
  64.         Node curNode=this.head;
  65.         while(curNode.next!=null){
  66.             curNode=curNode.next;
  67.         }
  68.         curNode.next=node;
  69.         this.size++;*/
  70.         add(this.size, data);
  71.     }
  72.  
  73.     //在任意位置添加
  74.     public void add(int index, T data) {
  75.         //判断index是否有效
  76.         if (index < 0 || index > this.size) {
  77.             throw new IllegalArgumentException("index is invalid");
  78.         }
  79.         //创建一个节点
  80.         Node node = new Node(data);
  81.         //特殊处理1：如果索引为0,
  82.         if (index == 0) {
  83.             this.head = new Node(data, this.head);
  84.             this.size++;
  85.             return;
  86.         }
  87.         //特殊处理2：链表为空（异常已抛出）
  88.         //找前驱结点，从头开始找，让索引移动index-1次
  89.         Node pre = this.head;
  90.         for (int i = 1; i <= index; i++) {
  91.             pre = pre.next;
  92.         }
  93.         //开始进行结点的挂接
  94.         node.next = pre.next;
  95.         pre.next = node;
  96.         this.size++;
  97.     }
  98.  
  99.     //打印整个链表
  100.     @Override
  101.     public String toString() {
  102.         //从this。head开始一直向后
  103.         Node curNode = this.head.next;
  104.         StringBuilder sb = new StringBuilder();
  105.         while (curNode != null) {
  106.             sb.append(curNode.data + "-->");
  107.             curNode = curNode.next;
  108.         }
  109.         sb.append("null");
  110.         return sb.toString();
  111.     }
  112.  
  113.     //从链表中查找指定位置元素是否存在
  114.     public boolean contains(T data) {
  115.         Node curNode = this.head.next;
  116.         while (curNode != null) {
  117.             if (curNode.data.equals(data)) {
  118.                 return true;
  119.             }
  120.         }
  121.         return false;
  122.     }
  123.  
  124.     //获取链表中元素的个数
  125.     public int getSize() {
  126.         return this.size;
  127.     }
  128.  
  129.     //获取链表的头结点
  130.     public Optional getFirst() {
  131.         if (this.head.next == null) {
  132.             return Optional.empty();
  133.         }
  134.         return Optional.ofNullable(this.head.next.data);
  135.     }
  136.  
  137.     //获取链表的尾结点
  138.     public Optional getLast() {
  139.         if (this.head.next == null) {
  140.             return Optional.empty();
  141.         }
  142.         Node<T> curNode = this.head;
  143.         while (curNode.next != null) {
  144.             curNode = curNode.next;
  145.         }
  146.         return Optional.of(curNode.data);
  147.     }
  148.  
  149.     //从链表中获取任意位置的结点
  150.     public T get(int index) {
  151.         if (index < 0 || index >= this.size) {
  152.             throw new IllegalArgumentException("index is invalid");
  153.         }
  154.         Node<T> curNode = this.head.next;
  155.         int i = 0;
  156.         while (i < index) {
  157.             curNode = curNode.next;
  158.             i++;
  159.         }
  160.         return curNode.data;
  161.     }
  162.  
  163.     //从链表的头部删除元素
  164.     public T removeHead() {
  165.         if (this.isEmpty()) {
  166.             return null;
  167.         }
  168.         Node<T> delNode = this.head.next;
  169.         this.head.next = delNode.next;
  170.         delNode.next = null;
  171.         //更新size;
  172.         this.size--;
  173.         return delNode.data;
  174.     }
  175.  
  176.     //链表的尾部删除元素
  177.     public T removeTail() {
  178.         if (this.isEmpty()) {
  179.             return null;
  180.         }
  181.         Node<T> pre = this.head;
  182.         while (pre.next.next != null) {
  183.             pre = pre.next;
  184.         }
  185.         Node<T> delNode = pre.next;
  186.         pre.next = delNode.next;
  187.         delNode.next = null;
  188.         //更新size;
  189.         this.size--;
  190.         return delNode.data;
  191.     }
  192.  
  193.     //删除任意位置的结点
  194.     public T remove(int index){
  195.         if(index<0||index>=this.size){
  196.             throw new IllegalArgumentException("index is invalid");
  197.         }
  198.         //找删除结点的前驱
  199.         Node<T>pre=this.head;
  200.         int i=0;
  201.         while(i<index){
  202.             pre=pre.next;
  203.             i++;
  204.         }
  205.         Node<T>delNode=pre.next;
  206.         pre.next=delNode.next;
  207.         delNode.next=null;
  208.         this.size--;
  209.         return delNode.data;
  210.     }
  211.  
  212.     //根据值从链表中删除元素
  213.     public int removeByValue(T value){
  214.         int count=0;
  215.         //定义前驱结点
  216.         Node<T>pre=this.head;
  217.         while(pre.next!=null){
  218.             Node curNode=pre.next;
  219.             if(curNode.data.equals(value)){
  220.                 pre.next=pre.next.next;
  221.                 curNode.next=null;
  222.                 this.size--;
  223.                 count++;
  224.             }else{
  225.                 pre=pre.next;
  226.             }
  227.         }
  228.         return count;
  229.     }
  230.  
  231.     //不使用虚拟头结点
  232.     public int removeByValue2(T val){
  233.         int count = 0;
  234.         Node<T> realHead = this .head.next;
  235.  
  236.         while(realHead!=null&&realHead.data.equals(val)){
  237.             realHead=realHead.next;
  238.             this.size--;
  239.             count++;
  240.         }
  241.  
  242.         //判断链表是否为空
  243.         if(realHead==null){
  244.             return count;
  245.         }
  246.  
  247.         //头结点不是删除的点
  248.         Node pre = realHead;
  249.         while(pre.next!=null){
  250.             Node<T> delNode = pre.next;
  251.             if(delNode.equals(val)){
  252.                 pre.next = delNode .next;
  253.                 delNode.next = null;
  254.                 this.size--;
  255.                 count++;
  256.             }else{
  257.                 pre = pre .next;
  258.             }
  259.         }
  260.         return count;
  261.     }
  262.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小舞很执着/article/detail/777346
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号