【集合（容器）】LinkedList基础

最新推荐文章于 2021-06-25 17:24:12 发布
最新推荐文章于 2021-06-25 17:24:12 发布
阅读量100 收藏
点赞数
分类专栏： Java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/RSssr/article/details/109453604
版权

LinkedList

查询效率低，增删效率高，线程不安全，一般不常用

建立包LinkedList

Node（创建链表）

public class Node {

    Node previous; //上一个节点
    Node next;     //下一个节点
    Object element;//元素数据

    public Node(Node previous, Node next, Object element) {
        this.previous = previous;
        this.next = next;
        this.element = element;
    }

    public Node(Object element){
        super();
        this.element=element;
    }

}

TestLinkedList（自定义一个链表，使用get）

public class TestLinkedList {

    private Node first;
    private Node last;

    private int size;

    //[]
    //["a","b","c","d","e","f"]        2
    public Object get(int index){

        if(index<0||index>size-1){
            throw new RuntimeException("索引数字不合法："+index);
        }

        Node temp=null;

        if(index<(size>>1)){    //size>>1相当于除以2，从前往后找
            temp=first;
            for(int i=0;i<index;i++){
                temp=temp.next;
            }
        }else{      //从后往前找
            temp=last;
            for(int i=size-1;i>index;i--){
                temp=temp.previous;
            }
        }
        return temp.element;
    }


    public void add(Object obj){
        Node node=new Node(obj);

        if(first==null){

            first=node;
            last=node;
        }else{
            node.previous=last;
            node.next=null;

            last.next=node;
            last=node;
        }
        size++;
    }



    @Override
    public String toString() {
        //[a,b,c]  first=a  last=c
        //a,b,c
        StringBuilder sb=new StringBuilder("[");
        Node temp=first;
        while(temp!=null){
            sb.append(temp.element+",");
            temp=temp.next;
        }
        sb.setCharAt(sb.length()-1,']');
        return sb.toString();
    }

    public static void main(String[] args) {

        TestLinkedList list=new TestLinkedList();

        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        System.out.println(list);
        System.out.println(list.get(1)); 
    }
}

TestLinkedList02（增加remove）

public class TestLinkedList02 {

    private Node first;
    private Node last;
    private int size;

    public void remove(int index){
        Node temp=getNode(index);

        if(temp!=null){
            Node up=temp.previous;
            Node down=temp.next;

            if(up!=null){
                up.next=down;
            }

            if(down!=null) {
                down.previous = up;
            }

            //被删除的元素是第一个元素时
            if(index==0){
                first=down;
            }

            //被删除的元素最后一个元素时
            if(index==size-1){
                last=up;
            }
            size--;
        }
    }

    public Node getNode(int index){
        Node temp=null;

        if(index<(size>>1)){    //size>>1相当于除以2，从前往后找
            temp=first;
            for(int i=0;i<index;i++){
                temp=temp.next;
            }
        }else{      //从后往前找
            temp=last;
            for(int i=size-1;i>index;i--){
                temp=temp.previous;
            }
        }
        return temp;
    }

    //[]
    //["a","b","c","d","e","f"]        2
    public Object get(int index){

        if(index<0||index>size-1){
            throw new RuntimeException("索引数字不合法："+index);
        }

        Node temp=getNode(index);

        return temp!=null?temp.element:null;
    }


    public void add(Object obj){
        Node node=new Node(obj);

        if(first==null){

            first=node;
            last=node;
        }else{
            node.previous=last;
            node.next=null;

            last.next=node;
            last=node;
        }
        size++;
    }



    @Override
    public String toString() {
        //[a,b,c]  first=a  last=c
        //a,b,c
        StringBuilder sb=new StringBuilder("[");
        Node temp=first;
        while(temp!=null){
            sb.append(temp.element+",");
            temp=temp.next;
        }
        sb.setCharAt(sb.length()-1,']');
        return sb.toString();
    }

    public static void main(String[] args) {

        TestLinkedList02 list=new TestLinkedList02();

        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        System.out.println(list);
        System.out.println(list.get(1));
        list.remove(3);
        System.out.println(list);
        list.remove(0);
        System.out.println(list);
        System.out.println(list.get(1));
        list.remove(5);
        System.out.println(list);
        System.out.println(list.get(1));

    }
}

TestLinkedList03（插入节点）

public class TestLinkedList03 {

    private Node first;
    private Node last;
    private int size;

    public void add(int index,Object obj){

        Node newNode=new Node(obj);
        Node temp=getNode(index);

        if(temp!=null){
            Node up=temp.previous;

            up.next=newNode;
            newNode.previous=up;

            newNode.next=temp;
            temp.previous=newNode;
        }
    }

    public void remove(int index){
        Node temp=getNode(index);

        if(temp!=null){
            Node up=temp.previous;
            Node down=temp.next;

            if(up!=null){
                up.next=down;
            }

            if(down!=null) {
                down.previous = up;
            }

            //被删除的元素是第一个元素时
            if(index==0){
                first=down;
            }

            //被删除的元素最后一个元素时
            if(index==size-1){
                last=up;
            }
            size--;
        }
    }

    public Node getNode(int index){
        Node temp=null;

        if(index<(size>>1)){    //size>>1相当于除以2，从前往后找
            temp=first;
            for(int i=0;i<index;i++){
                temp=temp.next;
            }
        }else{      //从后往前找
            temp=last;
            for(int i=size-1;i>index;i--){
                temp=temp.previous;
            }
        }
        return temp;
    }

    //[]
    //["a","b","c","d","e","f"]        2
    public Object get(int index){

        if(index<0||index>size-1){
            throw new RuntimeException("索引数字不合法："+index);
        }

        Node temp=getNode(index);

        return temp!=null?temp.element:null;
    }


    public void add(Object obj){
        Node node=new Node(obj);

        if(first==null){

            first=node;
            last=node;
        }else{
            node.previous=last;
            node.next=null;

            last.next=node;
            last=node;
        }
        size++;
    }



    @Override
    public String toString() {
        //[a,b,c]  first=a  last=c
        //a,b,c
        StringBuilder sb=new StringBuilder("[");
        Node temp=first;
        while(temp!=null){
            sb.append(temp.element+",");
            temp=temp.next;
        }
        sb.setCharAt(sb.length()-1,']');
        return sb.toString();
    }

    public static void main(String[] args) {

        TestLinkedList03 list=new TestLinkedList03();

        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        System.out.println(list);
        list.add(3,"若颂");
        System.out.println(list);
    }
}

TestLinkedList04（增加小的封装、增加泛型）

public class TestLinkedList04<E> {

    private Node first;
    private Node last;
    private int size;

    public void add(int index,E element){

        checkRange(index);

        Node newNode=new Node(element);
        Node temp=getNode(index);

        if(temp!=null){
            Node up=temp.previous;

            up.next=newNode;
            newNode.previous=up;

            newNode.next=temp;
            temp.previous=newNode;
        }
    }

    public void remove(int index){

        checkRange(index);

        Node temp=getNode(index);

        if(temp!=null){
            Node up=temp.previous;
            Node down=temp.next;

            if(up!=null){
                up.next=down;
            }

            if(down!=null) {
                down.previous = up;
            }

            //被删除的元素是第一个元素时
            if(index==0){
                first=down;
            }

            //被删除的元素最后一个元素时
            if(index==size-1){
                last=up;
            }
            size--;
        }
    }

    private Node getNode(int index){

        checkRange(index);

        Node temp=null;

        if(index<(size>>1)){    //size>>1相当于除以2，从前往后找
            temp=first;
            for(int i=0;i<index;i++){
                temp=temp.next;
            }
        }else{      //从后往前找
            temp=last;
            for(int i=size-1;i>index;i--){
                temp=temp.previous;
            }
        }
        return temp;
    }

    //[]
    //["a","b","c","d","e","f"]        2
    public E get(int index){

        checkRange(index);

        Node temp=getNode(index);

        return temp!=null?(E)temp.element:null;
    }

    private void checkRange(int index){
        if(index<0||index>size-1){
            throw new RuntimeException("索引数字不合法："+index);
        }
    }

    public void add(E element){
        Node node=new Node(element);

        if(first==null){

            first=node;
            last=node;
        }else{
            node.previous=last;
            node.next=null;

            last.next=node;
            last=node;
        }
        size++;
    }



    @Override
    public String toString() {
        //[a,b,c]  first=a  last=c
        //a,b,c
        StringBuilder sb=new StringBuilder("[");
        Node temp=first;
        while(temp!=null){
            sb.append(temp.element+",");
            temp=temp.next;
        }
        sb.setCharAt(sb.length()-1,']');
        return sb.toString();
    }

    public static void main(String[] args) {

        TestLinkedList04<String> list=new TestLinkedList04<>();

        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        System.out.println(list);

        System.out.println(list.get(1));
    }
}
若颂颂颂颂
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
8.4.1 搭建自己的SSR
w1fl1w的博客
11-21 7111
本文为拉勾网大前端高薪训练营第一期笔记 心得体会 SSR是未来前端页面必不可少的一个组成成分，掌握了Vue SSR基本上其他框架都非常类似。 3-4-1 搭建自己的SSR Vue SSR 介绍 是什么 官方文档:https://ssr.vuejs.org/ Vue SSR(Vue.js Server-Side Rendering) 是 Vue.js 官方提供的一个服务端渲染(同构应用)解决方案 使用它可以构建同构应用 还是基于原有的 Vue.js 技术栈 官方文档的解释:Vue.js 是构建客户端应
SSR算法源代码
04-16
关于图像增强方面的最基础的经典算法之一，ssr单尺度Retinex算法的matlab版代码，亲测有效
SSR 服务端渲染与 CSR 客户端渲染
杏子
01-26 1090
本文要点： 1. 介绍 SSR 服务端渲染概念、优点、缺点及案例。 2. 介绍 CSR 服务端渲染概念、优点、缺点及常用框架。
honeyLambda：honeyλ-一个简单的无服务器应用程序，旨在在AWS Lambda和Amazon API Gateway之上自动创建和监视假HTTP终端节点（即URL honeytoken）。
02-01
无服务器陷阱 honeyλ-一个简单的无服务器应用程序，旨在在AWS Lambda和Amazon API Gateway之上创建和监视URL 松弛通知 电子邮件和短信提醒 从本地文件或Amazon S3加载配置 自定义每个令牌的HTTP响应 威胁情报报告（源IP查找） 使用Cymon API v2 基于无服务器框架 付你用什么 提供者不可知 描述 honeyλ允许您自动创建和监视伪造的HTTP端点。 然后，您可以将这些URL蜜令牌放在收件箱，文档，浏览器历史记录中，或将其作为{隐藏}链接嵌入到网页中（注意：可用于在系统中散布面包屑，以吸引攻击者进入陷阱） 。 根据实施honeytoken的方式和位置，您可能会检测到人类攻击者，恶意内部人员，内容抓取工具或不良机器人。 此应用程序基于，可以部署在不同的云提供商中，例如Amazon Web Services（AWS），Microsoft Azure，IBM OpenWhisk或Google Cloud（仅在AWS上经过测试；主要功能可能需要稍作更改才能支持其他提供商） 。 如果您的云提供商是AWS，它将使用Amazon API Gat
React SSR - 01 SSR 介绍 和 快速开始
皮蛋很白的博客
06-25 877
React SSR 介绍 什么是客户端渲染 CSR：Client Side Rendering 数据和 HTML 的拼接是在客户端（浏览器）使用 JavaScript 完成的，服务端只需要返回 JSON 数据即可。 使用 React 开发的项目是客户端渲染的单页应用（SPA）。 什么是服务器端渲染 SSR：Server Side Rendering 数据和 HTML 的拼接是在服务器端完成的，客户端向服务器端发送请求，服务器端返回拼接好的 HTML，客户端只需将其显示出来。 客户端渲染存在的问题 首屏等待
Java容器集合（equals 和 hashCode+基础数据结构+ArrayList+Vector和LinkedList）
最新发布
06-21
Java容器集合（equals和hashCode+基础数据结构+ArrayList+Vector和LinkedList） Java容器集合是Java中的一种基础数据结构，用于存储和管理数据。其中，equals和hashCode方法是Java容器集合中两个非常重要的方法，...
Java中集合LinkedList的原理与使用方法
08-25
LinkedList是Java集合框架中List接口的一个实现，它是一种基于链表结构的数据容器。本文将深入探讨LinkedList的原理和使用方法。 首先，LinkedList是一个双向链表，意味着每个元素（节点）都有指向前后元素的引用。...
Java集合容器集合框架Set集(与“集合”有关文档共23张).pptx
11-14
Java集合框架是Java编程语言中一个非常重要的组成部分，它提供了一组接口和类，使得开发者能够方便地管理和操作数据。本章重点讲述了Set接口及其相关的实现类，List接口及其实现类，以及Map接口及其实现类的使用。 ...
第8天（集合【LinkedList、HashSet、Collection集合体系】）v201703103
08-08
【Java集合框架】\n\n在Java编程语言中，集合框架是用于存储和操作对象的容器，它提供了灵活且高效的方式来处理数据。本篇将深入探讨List接口和Set集合，特别是LinkedList、HashSet以及Collection集合体系。\n\n1. *...
Java集合容器面试题（2020最新版）-重点.pdf
11-25
Java集合容器是Java编程中非常重要的一个概念，它主要用于存储和操作对象。集合框架是Java提供的一个标准体系结构，用于表示和操作数据集合。这个框架包括接口、接口的实现以及集合操作的算法。 1. 接口：集合框架...
Java Flow API 的实践（一）：基本使用
乐征skyline
01-29 6639
Java Flow API 的实践（一）：基本使用 概述 Flow API 是 Java 9 引入的响应式编程的接口，其中包含4个接口： Publisher：发布者，负责发布消息； Subscriber：订阅者，负责订阅处理消息； Subscription：订阅控制类，可用于发布者和订阅者之间通信； Processor：处理者，同时充当Publisher和Subscriber的角色。 JDK中...
单链表的创建、查找、排序、插入、删除、倒置和合并等操作
m198984的博客
12-09 641
单链表的创建、查找、排序、插入、删除、倒置和合并等操作 #ifndef __LINKLIST_H__ #define __LINKLIST_H__ #include <stdio.h> #include <stdlib.h> #include <stdbool.h> typedef int datatype; typedef struct linknode ...
vue2 + koa2 + webpack4 的SSR之旅
weixin_33922670的博客
03-25 208
前言 因为自己的博客完全的前后端分离写的，在 seo 这一块也没考虑过，于是乎，便开始了本次的SSR之旅 技术栈 vue2 + koa2 + webpack4 + mongodb 因为webpack也已经到了 4.1 的版本了，所以顺带把webpack3迁移到了webpack4。 服务端渲染（SSR） 大概意思就是在服务端生成html片段，然后返回给客户端 所以vue-ssr也可以理解为就是把我们...
链表的创建、查询、删除，插入；
ys的专栏
07-15 417
链表(LinkList）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer）。单链表数据结构 struct Node { int _data ; // 数据 struct Node* _next; // 指向下一个节点的指针 }Node, *PLinkList;//输出链
实测TCP BBR算法加速效果
weixin_34255793的博客
02-18 3046
作为一枚学生党，国内的云服务器价格和带宽太过昂贵，有提供学生优惠的云服务带宽也只有1M，而我想做的是在服务器上搭建一个同步云盘，当然这些都不是最重要的，最重要的是无法帮助我科学上网。 恰巧去年暑假的时候，Vultr搞活动注册了一个账号，现还有15美元，当时因为它们的网络对电信太不友好，速度慢丢包率高，用了一小段时间后就抛弃了，而后在去年...
SSR
haliofwu的专栏
10-25 1142
CSR: 客户端渲染：简而言之是在浏览器端渲染。先拿到dom,css,通过js（ajax）拿到后台数据挂载在dom上显示； 优点： 交互性好，可以最小单位的返回数据； 适宜使用在交互性强的软件中 缺点： seo 比较差；蜘蛛只能识别html，不能识别js中的文件; SSR: 服务端渲染： 后台直接生成含有完备数据的html返回给前端； 跟客户端相反； 适用于： 首屏渲染； 交互性小而展示...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值