java封装数组链表

已于 2023-10-04 20:45:34 修改
阅读量71 收藏
点赞数
分类专栏： leetcode刷题 文章标签： java 链表 开发语言
于 2023-10-04 18:59:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42954389/article/details/133559614
版权

数组MyArrayList

import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;

public class MyArrayList<E> implements Iterable<E> {
    private int size=0;
    private static final int INIT_CAP=1;
    private E[] data;
    private boolean isElementIndex(int index){
        return index>=0 && index<size;
    }
    private boolean isPositionIndex(int index){
        return index>=0 && index<=size;
    }
    private void checkElementIndex(int index){
        if(!isElementIndex(index))
            throw new IndexOutOfBoundsException("Index:"+index+" ,Size:"+size);

    }
    private void checkPositionIndex(int index){
        if(!isPositionIndex(index))
            throw new IndexOutOfBoundsException("Index:"+index+" ,Size:"+size);
    }
    private void resize(int newCap){
        if(size>newCap)
            return;
        else{
            E[] temp=(E[])new Object[newCap];
            for(int i=0;i<size;i++){
                temp[i]=data[i];
            }
//            System.arraycopy(data,0,temp,0,size);
            data=temp;
        }
    }
    public int size(){
        return size;
    }
    public boolean isEmepty(){
        return size==0;
    }
    public E get(int index){
        checkElementIndex(index);
        return data[index];
    }
    public E set(E newVal,int index){
        checkElementIndex(index);
        E oldVal=data[index];
        data[index]=newVal;
        return oldVal;
    }
    public void addLast(E e){
        int cap=data.length;
        if(cap==size){
            resize(2*cap);
        }
        data[size]=e;
        size++;
    }
    public void add(E e,int index){
        checkPositionIndex(index);
        int cap=data.length;
        if(cap==size){
            resize(cap*2);
        }
        System.arraycopy(data,index,data,index+1,size-index);
        data[index]=e;
        size++;
    }
    public void addFirst(E e){
        add(e,0);
    }
    public E removeLast(){
        if(size==0)
            throw new NoSuchElementException();
        int cap=data.length;
        if(size==cap/4){
            resize(cap/2);
        }
        E deletedVal=data[size];
        data[size-1]=null;
        size--;
        return deletedVal;
    }
    public E remove(int index){
        checkElementIndex(index);
        int cap=data.length;
        if(size==cap/4){
            resize(cap/2);
        }
        E deletedVal=data[index];
        System.arraycopy(data,index+1,data,index,size-index-1);
        data[size-1]=null;
        size--;
        return deletedVal;
    }
    public void removeFirst(){
        remove(0);
    }
    public MyArrayList(){
        this(INIT_CAP);
    }
    public MyArrayList(int capacity){
        data=(E[]) new Object[capacity];
    }
    private void display(){
        System.out.println("size:"+size+" ,capacity:"+data.length);
        System.out.println(Arrays.toString(data));
    }
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            private int p=0;
            @Override
            public boolean hasNext() {
                return p!=size;
            }

            @Override
            public E next() {
                return data[p++];
            }
        };
    }
    public static void main(String[] args) {
        MyArrayList<Integer> arr=new MyArrayList<>(4);
        System.out.println(arr.isEmepty());
        for(int i=0;i< 5;i++){
            arr.addLast(i+1);
        }
        arr.display();
        arr.add(43,3);
        arr.display();
        arr.addFirst(100);
        arr.display();
        arr.removeLast();
        arr.display();
        arr.remove(2);
        arr.display();
        arr.removeFirst();
        arr.display();
        System.out.println(arr.isEmepty());
        System.out.println(arr.size());
        System.out.println(arr.get(2));
        System.out.println(arr.set(13,1));
        arr.display();
        Iterator <Integer> iterator=arr.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }


}

双链表MyLinkedList

import java.util.Iterator;
import java.util.NoSuchElementException;

public class MyLinkedList<E> implements Iterable<E> {
    public MyLinkedList() {
        head=new Node<>(null);
        tail=new Node<>(null);
        head.next=tail;
        tail.prev=head;
        size=0;
    }
    public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size==0;
    }
    private boolean isElementIndex(int index){
        return index>=0 && index<size;
    }
    private boolean isPositionIndex(int index){
        return index>=0 && index<=size;
    }
    private void checkElementIndex(int index){
        if(!isElementIndex(index))
            throw new IndexOutOfBoundsException("Index:"+index+" ,Size:"+size);
    }
    private void checkPositionIndex(int index){
        if(!isPositionIndex(index)){
            throw new IndexOutOfBoundsException("Index:"+index+" ,Size:"+size);
        }
    }
    public void display(){
        System.out.println("Size:"+size);
        for(Node<E>p=head.next;p!=tail;p=p.next){
            System.out.print(p.val+"->");
        }
        System.out.println("null");
        System.out.println();
    }
    public void addLast(E e){
        Node<E> x=new Node<>(e);
        Node<E> temp=tail.prev;
        x.next=tail;
        x.prev=temp;
        temp.next=x;
        tail.prev=x;
        size++;
    }
    public void addFirst(E e){
        Node<E> x=new Node<>(e);
        Node<E> temp=head.next;
        x.next=temp;
        x.prev=head;
        head.next=x;
        temp.prev=x;
        size++;
    }
    public void add(E e,int index){
        checkPositionIndex(index);
        if(size==index){
            addLast(e);
            return;
        }
        Node<E> x=new Node<>(e);
        Node<E> temp=getNode(index);
        Node<E> prevNode=temp.prev;
        x.prev=prevNode;
        x.next=temp;
        prevNode.next=x;
        temp.prev=x;
        size++;
    }
    public E removeLast(){
        if(size==0)
            throw new NoSuchElementException();
        Node<E> x=tail.prev;
        Node<E> temp=x.prev;
        temp.next=tail;
        tail.prev=temp;
        x.next=x.prev=null;
        size--;
        return x.val;
    }
    public E removeFirst(){
        if(size==0)
            throw new NoSuchElementException();
        Node<E> x=head.next;
        Node<E> temp=x.next;
        head.next=temp;
        temp.prev=head;
        x.prev=x.next=null;
        size--;
        return x.val;
    }
    public E remove(int index){
        checkElementIndex(index);
        Node<E> x=getNode(index);
        Node<E> prevNode=x.prev;
        Node<E> nextNode=x.next;
        prevNode.next=nextNode;
        nextNode.prev=prevNode;
        x.prev=x.next=null;
        size--;
        return x.val;
    }
    public E getFirst(){
        if(isEmpty())
            throw new NoSuchElementException();
        return head.next.val;
    }
    public E getLast(){
        if(isEmpty())
            throw new NoSuchElementException();
        return tail.prev.val;
    }
    public E get(int index){
        checkElementIndex(index);
        Node<E>p=getNode(index);
        return p.val;
    }
    public E setFirst(E e){
        if(size==0)
            throw new NoSuchElementException();
        E oldVal=head.next.val;
        head.next.val=e;
        return oldVal;
    }

    public E setLast(E e){
        if(size==0)
            throw new NoSuchElementException();
        E oldVal=tail.prev.val;
        tail.prev.val=e;
        return oldVal;
    }
    public E set(E e,int index){
        checkElementIndex(index);
        Node<E> p=getNode(index);
        E oldVal=p.val;
        p.val=e;
        return oldVal;
    }
    private Node<E> getNode(int index){
        checkElementIndex(index);
        Node<E> p;
        if(index<(size>>2)){
            p=head.next;
            for(int i=0;i<index;i++){
                p=p.next;
            }
        }else{
            p=tail.prev;
            for(int i=size-1;i>index;i--){
                p=p.prev;
            }
        }
        return p;
    }

    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            private Node<E>p=head.next;
            @Override
            public boolean hasNext() {
                return p!=tail;
            }

            @Override
            public E next() {
                E val=p.val;
                p=p.next;
                return val;
            }
        };
    }

    private static class Node<E>{
        Node<E> prev,next;
        E val;
        Node(E val){
            this.val=val;

        }
    }
    private final Node<E> head,tail;
    private int size;

    public static void main(String[] args) {
        MyLinkedList<Integer>arr=new MyLinkedList<>();
        arr.addLast(12);
        arr.addLast(32);
        arr.addLast(-10);
        arr.addLast(19);
        arr.addLast(-40);
        arr.addLast(29);
        arr.addLast(-70);
        arr.addLast(98);
        arr.addLast(-170);
        arr.addLast(928);
        arr.display();
        arr.remove(5);
        arr.display();

//        System.out.println(arr.getFirst()+", "+ arr.getLast()+" ,"+ arr.get(2));
//
//        arr.addFirst(21);
//        arr.addFirst(100);
//        arr.display();
//        arr.add(11,6);
//        arr.display();
//
//        System.out.println(arr.setFirst(102)+", "+arr.setLast(31)+", "+arr.set(44,5));
//        arr.display();
//
//        System.out.println(arr.removeLast());
//        arr.display();
//        System.out.println(arr.removeFirst());
//        arr.display();
//        System.out.println(arr.remove(1));
//        arr.display();
//        System.out.println(arr.remove(0));
//        arr.display();
//        System.out.println(arr.remove(2));
//        arr.display();
//        Iterator<Integer> iterator=arr.iterator();
//        while (iterator.hasNext()){
//            System.out.println(iterator.next());
//        }

    }

}

单链表MySingleLinkedList

import java.util.Iterator;
import java.util.NoSuchElementException;

public class MySingleLinkedList<E> implements Iterable<E>{
    @Override
    public Iterator<E> iterator() {
        return new Iterator<E>() {
            private Node<E>p=head.next;
            @Override
            public boolean hasNext() {
                return p!=null;
            }

            @Override
            public E next() {
                E val=p.val;
                p=p.next;
                return val;
            }
        };
    }

    private static class Node<E>{
        Node<E> next;
        E val;
        Node(E val){
            this.val=val;
            this.next=null;
        }
    }
    private final Node<E> head;

    private int size;
    public MySingleLinkedList(){
         head=new Node<>(null);
         size=0;
     }
     public int size(){
        return size;
     }

     public boolean isEmepty(){
        return size==0;
     }
     private boolean isElementIndex(int index){
        return index>=0 && index<size;
     }
    private boolean isPositionIndex(int index){
        return index>=0 && index<=size;
    }
    private void checkElementIndex(int index){
        if(!isElementIndex(index))
            throw new IndexOutOfBoundsException("Size:"+size+" ,Index:"+index);
    }
    private void checkPositionIndex(int index){
        if(!isPositionIndex(index)){
            throw new IndexOutOfBoundsException("Size:"+size+" ,Index:"+index);
        }
    }
    public void addLast(E e){
        Node<E> x=new Node<>(e);
        if(size!=0){
            Node<E>p=getNode(size-1);
            p.next=x;
        }else{
            head.next=x;
        }
        size++;
    }
    public void addFirst(E e){
        Node<E>x=new Node<>(e);
        x.next=head.next;
        head.next=x;
        size++;
    }
    public void add(E e,int index){
        checkPositionIndex(index);
        if(size==index){
            addLast(e);
            return;
        }
        Node<E>x=new Node<>(e);
        Node<E>p=getNode(index);
        E pval=p.val;
        p.val=x.val;
        x.val=pval;
        x.next=p.next;
        p.next=x;
        size++;
    }
    public E removeFirst(){
        if(size==0)
            throw new NoSuchElementException();
        Node<E>p=head.next;
        head.next=p.next;
        p.next=null;
        E deletedVal=p.val;
        size--;
        return deletedVal;
    }
    public E removeLast(){
        if(size==0)
            throw new NoSuchElementException();
        if(size==1){
            return removeFirst();
        }
        Node<E>p=getNode(size-2);
        E deletedVal=p.next.val;
        p.next=null;
        size--;
        return deletedVal;
    }
    public E remove(int index){
        checkElementIndex(index);
        if(index==0)
            return removeFirst();
        else if (index==size-1) {
            return removeLast();
        }else {
            Node<E>p=getNode(index-1);
            E deletedVal=p.next.val;
            p.next=p.next.next;
            size--;
            return deletedVal;
        }
    }
    public E getFisrt(){
        if(isEmepty())
            throw new NoSuchElementException();
        return head.next.val;
    }
    public E getLast(){
        if(isEmepty())
            throw new NoSuchElementException();
        Node<E>p=getNode(size-1);
        return p.val;
    }
    public E get(int index){
        checkElementIndex(index);
        Node<E>p=getNode(index);
        return p.val;
    }

    public E setFisrt(E e){
        if(isEmepty())
            throw new NoSuchElementException();
        E oldVal=head.next.val;
        head.next.val=e;
        return oldVal;
    }

    public E setLast(E e){
        if(isEmepty())
            throw new NoSuchElementException();
        E oldVal=getLast();
        Node<E>p=getNode(size-1);
        p.val=e;
        return oldVal;
    }

    public E set(E e,int index){
        checkElementIndex(index);
        Node<E>p=getNode(index);
        E oldVal=p.val;
        p.val=e;
        return oldVal;
    }

    public Node<E> getNode(int index){
        checkElementIndex(index);
        Node<E> p=head.next;
        for(int i=0;i<index;i++){
            p=p.next;
        }
        return p;
    }
    public void display(){
        if(size!=0){
            Node<E>p=head.next;
            System.out.println("Size:"+size);
            while (p!=null){
                System.out.print(p.val+"->");
                p=p.next;
            }
        }
        System.out.println("null");
        System.out.println();

    }

    public static void main(String[] args) {
        MySingleLinkedList<Integer>arr=new MySingleLinkedList<>();
        arr.addLast(12);
        arr.display();
        System.out.println(arr.removeLast());
        arr.display();
        arr.addLast(13);
        arr.display();
        arr.addFirst(-9);
        arr.addFirst(32);
        arr.display();
        arr.add(42,2);
        arr.display();
        arr.add(37,0);
        arr.display();
        arr.add(89,5);
        arr.display();
        System.out.println(arr.removeFirst());
        arr.display();
        System.out.println(arr.removeLast());
        arr.display();
        System.out.println(arr.remove(2));
        arr.display();
        arr.addFirst(15);
        arr.addFirst(24);
        arr.display();
        System.out.println(arr.getFisrt()+" ,"+arr.getLast()+" ,"+arr.get(2));
        System.out.println(arr.setFisrt(22)+" ,"+arr.setLast(-199)+" ,"+arr.set(29,3));
        arr.display();
        Iterator<Integer> iterator=arr.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}
无助的哈基米
关注
专栏目录
java数组转换成单链表_【转】单向链表（单链表）的Java实现
weixin_35924765的博客
02-25 1840
最近被问到链表，是一个朋友和我讨论Java的时候说的。说实话，我学习编程的近一年时间里，学到的东西还是挺少的。语言是学了Java和C#，关 于Web的学了一点Html+css+javascript。因为比较偏好，学习WinForm时比较认真，数据库操作也自己有所研究。但链表这个东西我 还真没有学习和研究过，加上最近自己在看WPF，而课程也到了JSP了，比较紧。但是我还是抽了一个晚上加半天的时间看了...
Java数组和封装
Zzq_zzq_的博客
10-16 478
数组就是能存储一组数组的数据类型。
Java数据结构——数组、链表
guochaoHNU的博客
08-08 839
目录数据的存储物理结构和逻辑结构数组 数据的存储物理结构和逻辑结构 按物理结构： ①：连续的存储空间：数组 元素相邻，在内存中开辟连续的存储空间 缺点：内存吃紧，给数组开辟一整块空间时比较难找。 优点：访问速度相对较快，因为有了首地址，根据下标，直接就可以找到对应的元素。 ②：非连续的存储空间：链式 元素不一定相邻，在内存中不需要开辟连续的存储空间。 缺点：访问速度相对数组较慢，要从头开始遍历。 优点：不需要空间连续，可以插空存储。、 按逻辑结构： ①：线性：数组、链表、队列(数组或链表）、栈(数组或链表)
java-数组与链表0518
zjusteel的博客
05-18 752
链表和数组
Java 中对数组进行封装
Java 之 道
03-09 2085
package test2; //import java.util.*; public class Test { private int array[]; private int nElements; public Test(int max){ array = new int[max]; nElements = 0; } public boolean insert(int va
【数据结构与算法】数组与链表
dadongwudi的博客
08-03 499
数组的定义和特性 数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。 线性表（Linear List）：数组、链表、队列、栈 非线性表：树 图 连续的内存空间和相同类型的数据 性能 低效“插入”和“删除” 警惕 数组越界 数组和链表的区别 “链表适合插入、删除，时间复杂度 O(1)；数组适合查找，数组支持随机访问，根据下标随机访问的时间复杂度为 O(1)”。 （数组是适合查找操作，但是查找的时间复杂度并不为 O(1)。即便是排好序的数组，你
数组和链表和集合的区别和应用场景以及堆和栈的区别 数组和链表.pdf
04-18
2. 堆内存：堆内存存储的是数组和对象（其实数组就是对象），凡是new建立的都是在堆中，堆中存放的都是实体（对象），实体用于封装数据，而且是封装多个（实体的多个属性），如果一个数据消失，这个实体也没有消失，...
java 环形链表的示例
孤舟残月梦还长存的专栏
10-15 645
环形链表是解决像约瑟夫环问题的类似问题的求解。
java详解 --- 集合之数组实现和链表实现
月牙湾的博客
12-18 1084
一.List 在说数组实现和链表实现之前,先说说它们的”父亲” — List List是可以有重复的数据存储的,按照顺序存储的,有下标. List的特有方法: 1.添加 – add(int num,Object obj) 2.替换 – set(int num,Object obj) 3.获取 – get(int num) 4.删除 – remove(int num)
Java企业面试题3
最新发布
m0_74972727的博客
09-15 317
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
上传文件到钉盘流程详解
jspyth的博客
09-14 570
本文详解如何通过钉钉的API实现上传文件到钉盘目录，代码通过JAVA实现。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1090
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 132
");
笔记：Centos Jdk Nginx 安装包安装命令
贰十六的博客
09-12 588
进入到usr中的src，把刚才下载的安装包拉进去。# ./configure 报错。# 将下面填写到配置最下方。# JDK 解压版 配置。# 进入环境变量配置。
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 886
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 322
spirng security中的几大组件的差异和执行顺序
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1148
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息
Dynadot_tech的博客
09-12 1044
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。
服装|基于Java+vue的服装定制系统(源码+数据库+文档)
weixin_66413741的博客
09-10 714
服装定制将是广大用户们不可忽视的一块。但是管理好服装定制又面临很多麻烦需要解决,我们可以发现服装定制方面的系统并不是相当普及,在服装定制方面的可以有许多改进。即服装定制系统慢慢的被人们关注。服装定制管理方面的任务繁琐,以至于每年都在服装定制管理这方面投入较多的精力却效果甚微,
Java实现栈的数组与链表方法详解
本文档详细介绍了Java中栈的实现，主要关注于使用数组和链表这两种数据结构来构建栈的数据结构。栈是一种基本的线性数据结构，具有后进先出（LIFO）特性，它在编程中扮演着重要角色，尤其是在函数调用堆栈、表达式求...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值