52.【Java 数据结构——线性表】(四)

简介: 52.【Java 数据结构——线性表】

9.双向链表:

9.1双向链表结点的定义:

private class Node1 {   //设置结点
    T item;    //数据域
    Node1 next;   //指针域Node1 prev;
        Node1 prev;
       public Node1(Node1 prev,T item, Node1 next) {
           this.item = item;
           this.next = next;
           this.prev=prev;
       }
   }//调用节点类

9.2双向链表添加末尾元素:

public void add(T t){
        //先把插入点的prev指针指向前一个last
        Node1 prev=last;
        //获取插入的元素
       Node1 node1=new Node1(prev,t,null);
       //然后把插入点前的next指针指向插入点的结点
        if(prev==null){   //假如说插入点的前一个点是null
            first=node1;
        }
        else {
            prev.next = node1;
        }
        //将last指向新插入的元素
        last=node1;
        //进行++操作
       this.size++;
    }

9.3获取双向链表的结点:

public Node1 getNode(int idex){
           int mid=size/2;  //获取中间值
           if(idex<mid){  //如果小于,那么就从第一个节点开始遍历
               Node1 x=first;
               for(int i=0;i<idex;i++){
                   x=x.next;
               }
               return x;
           }else{     //否则,那么就从最后i一个结点遍历
               Node1 x=last;
               for(int i=size-1;i>idex;i--){  //这里可不能少
                   x=x.prev;
               }
               return x;
           }
    }

9.4向指定位置添加元素

public void add(int idex,T t){
        if(idex==size){//假如说是最后一个位置
            add(t);
        }else{
        //获取需要插入元素的结点
        Node1 node1=new Node1(null,t,null);
        //获取被插入点的结点
        Node1 current=getNode(idex);
        if(current==null){
            first=node1;
        }else {
            //获取被插入点前的结点
            Node1 befor = current.prev;
            //插入点prev指向前结点
            node1.prev=befor;
            //插入点next指向后一个结点
            node1.next=current;
            //后一个结点prev指向插入点
            current.prev=node1;
            //假如说是第一个位置
            if(befor==null){
                first=node1; 
            }
            else {
                befor.next = node1;
            }
        }
            this.size++;
    }
    }

9.5删除元素

public void remove(int idex) {
        //设置删除点
        Node1 current = getNode(idex);
        //删除点前面
        Node1 before = current.prev;
        //删除点后面
        Node1 after = current.next;
        if(before==null){  //假如说删除头部
            first=after;
        }else{
        before.next = after;}
        if (after == null) {  //假如说删除末尾
            last = before;
        } else {
            after.prev = before;
        }
        this.size--;
}

9.双向链表的全部用法

类方法:

import org.jetbrains.annotations.NotNull;
public class LinkedList<T> {
    Node1 first;  //指向第一个结点
    Node1 last; //指向最后一个结点
    int size;   //链表长度
    public LinkedList() { //初始化链表
        this.size = 0;
    }
    //获取指定位置的结点
    public Node1 getNode(int idex) {
        int mid = size / 2;  //获取中间值
        if (idex < mid) {  //如果小于,那么就从第一个节点开始遍历
            Node1 x = first;
            for (int i = 0; i < idex; i++) {
                x = x.next;
            }
            return x;
        } else {     //否则,那么就从最后i一个结点遍历
            Node1 x = last;
            for (int i = size - 1; i > idex; i--) {  //这里可不能少
                x = x.prev;
            }
            return x;
        }
    }
    //在指定位置添加元素
     public void add(int idex,T t){
        if(idex==size){//假如说是最后一个位置
            add(t);
        }else{
        //获取需要插入元素的结点
        Node1 node1=new Node1(null,t,null);
        //获取被插入点的结点
        Node1 current=getNode(idex);
        if(current==null){
            first=node1;
        }else {
            //获取被插入点前的结点
            Node1 befor = current.prev;
            //插入点prev指向前结点
            node1.prev=befor;
            //插入点next指向后一个结点
            node1.next=current;
            //后一个结点prev指向插入点
            current.prev=node1;
            //假如说是第一个位置
            if(befor==null){
                first=node1; 
            }
            else {
                befor.next = node1;
            }
        }
            this.size++;
    }
    }
    //获取指定位置的元素
    public T get(int idex) {
        return getNode(idex).item;
    }
    //在末尾元素进行添加
    public void add(T t) {
        //先把插入点的prev指针指向前一个last
        Node1 prev = last;
        //获取插入的元素
        Node1 node1 = new Node1(prev, t, null);
        //然后把插入点前的next指针指向插入点的结点
        if (prev == null) {   //假如说插入点的前一个点是null
            first = node1;
        } else {
            prev.next = node1;
        }
        //将last指向新插入的元素
        last = node1;
        //进行++操作
        this.size++;
    }
    //在指定位置进行删除
    public void remove(int idex) {
        //设置删除点
        Node1 current = getNode(idex);
        //删除点前面
        Node1 before = current.prev;
        //删除点后面
        Node1 after = current.next;
        if(before==null){  //假如说删除头部
            first=after;
        }else{
        before.next = after;}
        if (after == null) {  //假如说删除末尾
            last = before;
        } else {
            after.prev = before;
        }
        this.size--;
}
    //获取当前链表的长度
    public int size(){
        return size;
    }
    private class Node1 {   //设置结点
    T item;    //数据域
    Node1 next;   //指针域Node1 prev;
        Node1 prev;
       public Node1(Node1 prev,T item, Node1 next) {
           this.item = item;
           this.next = next;
           this.prev=prev;
       }
   }//调用节点类
}

主方法:

import java.sql.SQLOutput;
import java.util.*;
import java.awt.*;
import java.lang.Math;
public class hello {
    public static void main(String []avgs) {
     LinkedList<String> s=new LinkedList<>();
        s.add("aa");
        s.add("bb");
        s.add("cc");
        s.add("dd");
       s.add("ee");
       s.remove(4);
        for(int i=0;i<s.size();i++){
            System.out.println(s.get(i));
        }
    }
}

相关文章
|
6月前
|
前端开发 Java
java实现队列数据结构代码详解
本文详细解析了Java中队列数据结构的实现,包括队列的基本概念、应用场景及代码实现。队列是一种遵循“先进先出”原则的线性结构,支持在队尾插入和队头删除操作。文章介绍了顺序队列与链式队列,并重点分析了循环队列的实现方式以解决溢出问题。通过具体代码示例(如`enqueue`入队和`dequeue`出队),展示了队列的操作逻辑,帮助读者深入理解其工作机制。
168 1
|
4月前
|
存储 安全 Java
Java 集合面试题从数据结构到 HashMap 源码剖析详解及长尾考点梳理
本文深入解析Java集合框架,涵盖基础概念、常见集合类型及HashMap的底层数据结构与源码实现。从Collection、Map到Iterator接口,逐一剖析其特性与应用场景。重点解读HashMap在JDK1.7与1.8中的数据结构演变,包括数组+链表+红黑树优化,以及put方法和扩容机制的实现细节。结合订单管理与用户权限管理等实际案例,展示集合框架的应用价值,助你全面掌握相关知识,轻松应对面试与开发需求。
200 3
|
12月前
|
存储 Java
Java中的HashMap和TreeMap,通过具体示例展示了它们在处理复杂数据结构问题时的应用。
【10月更文挑战第19天】本文详细介绍了Java中的HashMap和TreeMap,通过具体示例展示了它们在处理复杂数据结构问题时的应用。HashMap以其高效的插入、查找和删除操作著称,而TreeMap则擅长于保持元素的自然排序或自定义排序,两者各具优势,适用于不同的开发场景。
123 1
|
6月前
|
存储 Java 编译器
Java 中 .length 的使用方法:深入理解 Java 数据结构中的长度获取机制
本文深入解析了 Java 中 `.length` 的使用方法及其在不同数据结构中的应用。对于数组,通过 `.length` 属性获取元素数量;字符串则使用 `.length()` 方法计算字符数;集合类如 `ArrayList` 采用 `.size()` 方法统计元素个数。此外,基本数据类型和包装类不支持长度属性。掌握这些区别,有助于开发者避免常见错误,提升代码质量。
485 1
|
9月前
|
存储 算法 测试技术
【C++数据结构——线性表】求集合的并、交和差运算(头歌实践教学平台习题)【合集】
本任务要求编写程序求两个集合的并集、交集和差集。主要内容包括: 1. **单链表表示集合**:使用单链表存储集合元素,确保元素唯一且无序。 2. **求并集**:遍历两个集合,将所有不同元素加入新链表。 3. **求交集**:遍历集合A,检查元素是否在集合B中存在,若存在则加入结果链表。 4. **求差集**:遍历集合A,检查元素是否不在集合B中,若满足条件则加入结果链表。 通过C++代码实现上述操作,并提供测试用例验证结果。测试输入为两个集合的元素,输出为有序集合A、B,以及它们的并集、交集和差集。 示例测试输入: ``` a c e f a b d e h i ``` 预期输出:
236 7
|
9月前
|
机器学习/深度学习 存储 C++
【C++数据结构——线性表】单链表的基本运算(头歌实践教学平台习题)【合集】
本内容介绍了单链表的基本运算任务,涵盖线性表的基本概念、初始化、销毁、判定是否为空表、求长度、输出、求元素值、按元素值查找、插入和删除数据元素等操作。通过C++代码示例详细解释了顺序表和链表的实现方法,并提供了测试说明、通 - **任务描述**:实现单链表的基本运算。 - **相关知识**:包括线性表的概念、初始化、销毁、判断空表、求长度、输出、求元素值、查找、插入和删除等操作。 - **测试说明**:平台会对你编写的代码进行测试,提供测试输入和预期输出。 - **通关代码**:给出了完整的C++代码实现。 - **测试结果**:展示了测试通过后的预期输出结果。 开始你的任务吧,祝你成功!
360 5
|
9月前
|
机器学习/深度学习 存储 C++
【C++数据结构——线性表】顺序表的基本运算(头歌实践教学平台习题)【合集】
本文档介绍了线性表的基本运算任务,涵盖顺序表和链表的初始化、销毁、判定是否为空、求长度、输出、查找元素、插入和删除元素等内容。通过C++代码示例详细展示了每一步骤的具体实现方法,并提供了测试说明和通关代码。 主要内容包括: - **任务描述**:实现顺序表的基本运算。 - **相关知识**:介绍线性表的基本概念及操作,如初始化、销毁、判定是否为空表等。 - **具体操作**:详述顺序表和链表的初始化、求长度、输出、查找、插入和删除元素的方法,并附有代码示例。 - **测试说明**:提供测试输入和预期输出,确保代码正确性。 - **通关代码**:给出完整的C++代码实现,帮助完成任务。 文档
195 5
|
10月前
|
存储 缓存 安全
Java 集合江湖:底层数据结构的大揭秘!
小米是一位热爱技术分享的程序员,本文详细解析了Java面试中常见的List、Set、Map的区别。不仅介绍了它们的基本特性和实现类,还深入探讨了各自的使用场景和面试技巧,帮助读者更好地理解和应对相关问题。
147 5
|
11月前
|
缓存 算法 Java
本文聚焦于Java内存管理与调优,介绍Java内存模型、内存泄漏检测与预防、高效字符串拼接、数据结构优化及垃圾回收机制
在现代软件开发中,性能优化至关重要。本文聚焦于Java内存管理与调优,介绍Java内存模型、内存泄漏检测与预防、高效字符串拼接、数据结构优化及垃圾回收机制。通过调整垃圾回收器参数、优化堆大小与布局、使用对象池和缓存技术,开发者可显著提升应用性能和稳定性。
174 6
|
11月前
|
存储 Java 索引
Java中的数据结构:ArrayList和LinkedList的比较
【10月更文挑战第28天】在Java编程世界中,数据结构是构建复杂程序的基石。本文将深入探讨两种常用的数据结构:ArrayList和LinkedList,通过直观的比喻和实例分析,揭示它们各自的优势与局限,帮助你在面对不同的编程挑战时做出明智的选择。