Java学习第十四天 链表 Linked List

最新推荐文章于 2022-01-19 23:34:13 发布
最新推荐文章于 2022-01-19 23:34:13 发布
阅读量131 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58070636/article/details/117482415
版权

链表与线性数据结构

链表：

  1. 最简单的动态数据结构

  2. 更深入的理解引用（或指针）

  3. 更深入的理解递归

  4. 辅助组成其他数据结构

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

缺点：丧失了自由访问的能力

 

数组和链表的对比

链表的头：head 指向第一个节点

package com.dataStructrue;

public class LinkedList <E>{

    private class Node{
        public E e;
        public Node next;

        public Node(E e,Node next){
            this.e=e;
            this.next=next;
        }

        public Node(E e){
            this(e,null);
        }

        public Node(){
            this(null,null);
        }

        @Override
        public String toString(){
            return e.toString();
        }
    }

    private Node head;
    private int size;

    public LinkedList(){
        head=null;
        size=0;
    }
    //获取链表中元素个数
    public int getSize(){
        return size;
    }

    //
    public boolean isEmpty(){
        return size==0;
    }

    //链表头添加新的元素e
    public void addFirst(E e){
//        Node node=new Node(e);
//        node.next=head;
//        head=node;

        head=new Node(e,head);
        size++;
    }

    //链表中间第index（0-based)个位置添加新的元素e
    //在实际中不常用这个操作，做练习题用
    public void add(int index,E e){

        if (index<0||index>size)
        throw new IllegalArgumentException("位置异常");

        if (index==0)
            addFirst(e);
        else {
            Node prev=head;
            for (int i = 0; i < index - 1; i++) {
                prev=prev.next;
            }

//                Node node=new Node(e);
//                node.next=prev.next;
//                prev.next=node;

                prev.next=new Node(e,prev);
                size++;
        }
    }

    //在链表末尾添加新的元素e
    public void addLast(E e){
        add(size,e);
    }

}

为链表设立虚拟头节点

package com.dataStructrue;

public class LinkedList <E>{

    private class Node{
        public E e;
        public Node next;

        public Node(E e,Node next){
            this.e=e;
            this.next=next;
        }

        public Node(E e){
            this(e,null);
        }

        public Node(){
            this(null,null);
        }

        @Override
        public String toString(){
            return e.toString();
        }
    }

    private Node dummyHead;
    private int size;

    public LinkedList(){
        dummyHead=new Node(null,null);
        size=0;
    }
    //获取链表中元素个数
    public int getSize(){
        return size;
    }

    //
    public boolean isEmpty(){
        return size==0;
    }

   

    //链表中间第index（0-based)个位置添加新的元素e
    public void add(int index,E e){

        if (index<0||index>size)
        throw new IllegalArgumentException("位置异常");
        
            Node prev=dummyHead;
            for (int i = 0; i < index; i++) {
                prev=prev.next;
            }

                prev.next=new Node(e,prev);
                size++;

    }
    //链表头添加新的元素e
    public void addFirst(E e){
        add(0,e);
    }
    //在链表末尾添加新的元素e
    public void addLast(E e){
        add(size,e);
    }

}

 

 从链表中删除元素

调用toString时，由于定义了虚拟头部，导致e值为null，无法输出

错误示范

package com.dataStructrue;

public class LinkedList <E>{

    private class Node{
        public E e;
        public Node next;

        public Node(E e,Node next){
            this.e=e;
            this.next=next;
        }

        public Node(E e){
            this(e,null);
        }

        public Node(){
            this(null,null);
        }

        @Override
        public String toString(){

                return e.toString();

        }
    }

    private Node dummyHead;
    private int size;

    public LinkedList(){
        dummyHead=new Node(null,null);
        size=0;
    }
    //获取链表中元素个数
    public int getSize(){
        return size;
    }

    //
    public boolean isEmpty(){
        return size==0;
    }



    //链表中间第index（0-based)个位置添加新的元素e
    public void add(int index,E e){

        if (index<0||index>size)
        throw new IllegalArgumentException("位置异常");

            Node prev=dummyHead;
            for (int i = 0; i < index; i++) {
                prev=prev.next;
            }

                prev.next=new Node(e,prev);
                size++;

    }
    //链表头添加新的元素e
    public void addFirst(E e){
        add(0,e);
    }
    //在链表末尾添加新的元素e
    public void addLast(E e){
        add(size,e);
    }

    //获得链表中第index个位置元素
    //练习用
    public E get(int index){
        if(index<0||index>=size)
            throw new IllegalArgumentException("位置异常");

        Node cur=dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur=cur.next;
        }
        return cur.e;
    }

    //获得链表的第一个元素
    public E getFirst(int index){
        return get(0);
    }
    //获得链表的最后一个元素
    public E getLast(int index){
        return get(size-1);
    }

    //修改第index位置元素为e
    public void set(int index,E e){

        if(index<0||index>=size)
            throw new IllegalArgumentException("位置异常");

        Node cur=dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur=cur.next;
        }
        cur.e=e;
    }

    //查找链表中是否存在元素e
    public boolean contains(E e){
        Node cur=dummyHead.next;
        while (cur!=null){
            if (cur.e.equals(e))
                return true;
            cur=cur.next;
        }
        return false;
    }

    @Override
    public String toString(){
        StringBuilder res=new StringBuilder();

//        Node cur=dummyHead.next;
//        while (cur!=null){
//            res.append(cur+"->");
//            cur=cur.next;
//        }

        for(Node cur=dummyHead.next;cur!=null;cur=cur.next)
            res.append(cur+"->");

        res.append("NULL");

        return res.toString()+"";
    }
}

package com.dataStructrue;

public class M {
    public static void main(String[] args){

        LinkedList<Integer>linkedList=new LinkedList<>();
        for (int i = 0; i < 5; i++) {
            linkedList.addFirst(i);
            System.out.println(linkedList);
        }
        linkedList.add(2,666);
        System.out.println(linkedList);
    }
}

预计输出结果：

实际输出结果：

由于25行toString中出现空指针而报错。

add方法里面，prev.next=new Node(e,prev.next);

漏掉了.next,   prev.next=new Node(e,prev);导致进入了无限套娃

时间复杂度分析

 

增、删、改、查的时间复杂度都是O(n)

此时与数组一样，但是由于是动态的，所以不会浪费大量内存

使用链表实现栈

package com.dataStructrue;

public class LinkedList <E>{


    private class Node{
        public E e;
        public Node next;

        public Node(E e,Node next){
            this.e=e;
            this.next=next;
        }

        public Node(E e){
            this(e,null);
        }

        public Node(){
            this(null,null);
        }

        @Override
        public String toString()throws IllegalArgumentException{
                if(e==null)
                    throw new IllegalArgumentException("KONG");

                return e.toString();

        }
    }

    private Node dummyHead;
    private int size;

    public LinkedList(){
        dummyHead=new Node(null,null);
        size=0;
    }
    //获取链表中元素个数
    public int getSize(){
        return size;
    }

    //
    public boolean isEmpty(){
        return size==0;
    }



    //链表中间第index（0-based)个位置添加新的元素e
    public void add(int index,E e){

        if (index<0||index>size)
        throw new IllegalArgumentException("位置异常");

            Node prev=dummyHead;
            for (int i = 0; i < index; i++) {
                prev=prev.next;
            }

                prev.next=new Node(e,prev.next);
                size++;

    }
    //链表头添加新的元素e
    public void addFirst(E e){
        add(0,e);
    }
    //在链表末尾添加新的元素e
    public void addLast(E e){
        add(size,e);
    }

    //获得链表中第index个位置元素
    //练习用
    public E get(int index){
        if(index<0||index>=size)
            throw new IllegalArgumentException("位置异常");

        Node cur=dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur=cur.next;
        }
        return cur.e;
    }

    //获得链表的第一个元素
    public E getFirst(){
        return get(0);
    }
    //获得链表的最后一个元素
    public E getLast(int index){
        return get(size-1);
    }


    //修改第index位置元素为e
    public void set(int index,E e){

        if(index<0||index>=size)
            throw new IllegalArgumentException("位置异常");

        Node cur=dummyHead.next;
        for (int i = 0; i < index; i++) {
            cur=cur.next;
        }
        cur.e=e;
    }

    //查找链表中是否存在元素e
    public boolean contains(E e){
        Node cur=dummyHead.next;
        while (cur!=null){
            if (cur.e.equals(e))
                return true;
            cur=cur.next;
        }
        return false;
    }

    @Override
    public String toString(){
        StringBuilder res=new StringBuilder();

//        Node cur=dummyHead.next;
//        while (cur!=null){
//            res.append(cur+"->");
//            cur=cur.next;
//        }

        for(Node cur=dummyHead.next;cur!=null;cur=cur.next)
            res.append(cur+"->");
        res.append("NULL");

        return res.toString();
    }
//从链表中删除index位置的元素
    public E remove(int index){
        if(index<0||index>=size)
            throw new IllegalArgumentException("位置异常");

        Node prev=dummyHead;
        for (int i = 0; i < index; i++) {
            prev=prev.next;
        }
        Node retNode=prev.next;
        prev.next=retNode.next;
        retNode.next=null;
        size--;
        return retNode.e;
    }
//从链表中删除最后一个元素，返回删除的元素
public E removeLast(){
        return remove(size-1);
}

    public E removeFirst(){
        return remove(0);
    }
}

package com.dataStructrue;

import javax.annotation.Resource;

public class LinkedListStack<E> implements Stack<E>{

//    private LinkedList<E> list;
//
//    public LinkedListStack(){
//        list=new LinkedList<>();
//    }
   private LinkedList<E> list=new LinkedList<E>();

    @Override
    public int getSize(){
        return list.getSize();
    }

    @Override
    public boolean isEmpty(){
        return list.isEmpty();
    }

    @Override
    public void push(E e){
        list.addFirst(e);
    }


    @Override
    public E peak(){ return list.getFirst(); }

    @Override
    public E pop(){
        return list.removeFirst();
    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append("Stack:top");
        res.append(list);
        return res.toString();
    }

    public static void main(String[] args){

        LinkedListStack<Integer>stack=new LinkedListStack<>();
        for (int i = 0; i < 5; i++) {
            stack.push(i);
            System.out.println(stack);;
    }
            stack.pop();
            System.out.println(stack);


        }
}

使用链表实现队列

由于没有dummyHead，需要注意链表为空的问题

package com.dataStructrue;

public class LinkedListQueue<E> implements Queue<E> {

    private class Node{
        public E e;
        public Node next;

        public Node(E e, Node next){
            this.e=e;
            this.next=next;
        }

        public Node(E e){
            this(e,null);
        }

        public Node(){
            this(null,null);
        }

        @Override
        public String toString(){
            return e.toString();
        }
    }

    private Node head,tail;//定义头节点和尾节点
    private int size;//定义整型记录长度

    public LinkedListQueue(){//与不写构造函数，默认的构造函数是一样的
        head=null;
        tail=null;
        size=0;
    }

    @Override
    public int getSize(){
        return size;
    }
    @Override
    public boolean isEmpty(){
        return size==0;
    }
    @Override//入队操作
    public void enqueue(E e){
        if(tail==null){
            tail=new Node(e);
            head=tail;
        }else {
            tail.next=new Node(e);
            tail=tail.next;
        }
        size++;
    }
    @Override//出队操作
    public E dequeue(){
        if (isEmpty())
            throw new IllegalArgumentException("不能出空");

        Node retNode=head;
        head=head.next;
        retNode.next=null;
        if (head==null)
            tail=null;//链表只有一个元素时，首尾是一样的
        size--;
        return retNode.e;
    }
    @Override
    public E getFront(){
        if (isEmpty())
            throw new IllegalArgumentException("不能为空");
        return head.e;
    }
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
           res.append("Queue:front");

           Node cur=head;
           while (cur!=null){
               res.append(cur+"->");
               cur=cur.next;
           }
           res.append("NULL tail");
           return res.toString();
    }
    public static void main(String[] args) {
        LinkedListQueue<Integer>queue=new LinkedListQueue<>();
        for (int i = 0; i < 10; i++) {
            queue.enqueue(i);
            System.out.println(queue);

            if (i%3==2){
                queue.dequeue();
                System.out.println(queue);

            }
        }
    }
}

/*结果
Stack:top0->NULL
Stack:top1->0->NULL
Stack:top2->1->0->NULL
Stack:top3->2->1->0->NULL
Stack:top4->3->2->1->0->NULL
Stack:top3->2->1->0->NULL
*/

 

从零开始的码农生活01
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
链表LinkedList实现栈(Java)
悦悦的狗子
01-20 379
链表LinkedList实现栈 LinkedList.java（链表）详细请看链表LinkedList(Java) public class LinkedList<E> { private class Node {// 内部类将节点设为私有 隐藏实现细节 public E e;// 元素 public Node next;// next指针 public Node(E ...
Java LinkedList基本用法
十四不是八的博客
02-26 1730
}   2、获取链表元素   [java] view plaincopy for (String str: lList) {         System.out.println(str);       }   3、从链表生成子表 [java] view plaincopy
LinkedList总结＋数组栈Stack
weixin_34358092的博客
03-20 143
2019独角兽企业重金招聘Python工程师标准>>> ...
剑指 Offer 30. 包含min函数的栈+linkedlist的使用
m0_56033865的博客
10-05 107
定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。 最普通的方法 public class MinStack { int[] arr; int flag; public MinStack(){ arr=new int[100]; flag=0; } public void push(int x) { if(flag==arr
约瑟夫出圈代码，轻松解决 使用LinkedList<Integer>
11-28
解决约瑟夫出圈问题的实现代码，大家共享 如果你有更好的资源，请给我来一份 package maicle; import java.util.LinkedList; public class Linklist { static int M=5;//选择第几个人出圈 static int N=10;//人数 public static void main(String []args){ LinkedList<Integer> ab=new LinkedList(); for(int i=0;i<N;i++) ab.add(i+1); for(;;){ if(ab.size()==0)break;//结束条件 int i=1; while(i!=M){ ab.add(ab.remove());//如果没有报到M这个数字的人将其从表头插到表尾 i++; } int a=ab.remove(); System.out.println(a); } } }
Java_数组练习题目1
08-08
14. 数组在Java中的存储位置：数组储存在堆（Heap）中，而不是栈（Stack）、队列（Queue）或链表（Linked List）。 15. 创建数组的正确语句： - A. 正确。 - B. 错误，缺少第二维长度。 - C. 错误，缺少第一维...
JAVA版数据结构[归类].pdf
10-12
18. **Scanning a Linked List**：在第10章的“Scanning a Linked List”部分，讨论了链表遍历的方法，这对于理解数据结构中的链表至关重要。 这些内容涵盖了Java编程、数据结构、算法、类设计、异常处理和泛型等多...
Java数据结构和算法.pdf
05-21
**链表**(Linked List)是一种动态数据结构，其元素不是存储在连续的内存地址中，而是通过指针连接在一起。链表分为单链表、双链表和循环链表等多种类型。 - 单链表: 每个节点包含数据和指向下一个节点的指针。 - 双...
Java数据结构和算法
12-08
**链表**(Linked List)是一种线性数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的链接。链表包括单向链表、双向链表和循环链表，具有灵活的插入和删除操作。 #### 四、递归 **递归**(Recursion)...
Java_数组练习题目.pdf
11-26
9. **数组的存储位置**：在Java中，数组储存在堆（Heap）中，而不是栈（Stack）、队列（Queue）或链表（Linked List）。 10. **数组长度的获取**：`numbers.length`会返回数组的长度，即使之后改变`numbers`引用的...
Java学习笔记之LinkedList基本用法
贱贱的梦想
05-28 3万+
更多信息可参考我的个人博客：贱贱的梦想 LinkedList简介 LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。 LinkedList 实现 List 接口，能进行队列操作。 LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。 ArrayList底层是由数组支持，而Lin
ArrayList<Integer> lt = new ArrayList<>(); // List<Integer> lt = new LinkedList<>();
sinat_32176267的博客
03-03 2073
1.新建一个数组 //元素类型 [] 数组名 = new 元素类型[元素个数或数组长度]； int[] arr = new int[4]; //以下是两种声明数组 int[] arr = new int[]{3,5,6,7}; int[] arr = {3,5,6}; 赋值是 ：arr[0]=89; 读取的时候是arr[0] 关于这两个的区别：
LinkedList的基本使用
码农小战士的博客
09-09 409
LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用. LinkedList的构造函数如下 1. public LinkedList(): ——生成空的链表 2. public LinkedList(Collection col): 复制构造函数 1、获取链表的第一个和最后一个元素 [java] view plaincopy import java.
List lt=new LinkedList() 和 LinkedList lt=new LinkedList() 的区别
qq_36249824的博客
03-23 1737
List names=new LinkedList(); List是个接口，LinkedList()是实现类。是多态的写法 LinkedList lt=new LinkedList() 就是普通的对一个类进行实例化得到对象 LinkedList<String> lt=new LinkedList<String>() 这里采用了泛型类，预先给链表对象的数据类型规定为字符串类型 这三个的区别和联系。？ ...
简谈LinkedList特有的方法
Star_RainSea的博客
01-19 3272
一、什么是LinkedList集合 二、LinkedList集合特有的方法
数据结构基础----链表（Linked List）
mingyuli的博客
09-05 1159
原文： https://loubobooo.com/2018/09/16/%E5%88%9D%E5%AD%A6%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84-%E9%93%BE%E8%A1%A8/ 1、链表的概括 虽然动态数组靠resize方法解决静态数组固定容量的问题，但依旧摆脱不了仍是静态数组的事实，而链表则与上述线性数据结构都不同，是一种真正的动态数据结构。 ...
LinkedList基本用法
热门推荐
i_lovefish的专栏
10-06 21万+
LinkedList类是双向列表,列表中的每个节点都包含了对前一个和后一个元素的引用. LinkedList的构造函数如下 1. public LinkedList():  ——生成空的链表 2. public LinkedList(Collection col):  复制构造函数 1、获取链表的第一个和最后一个元素 [java] view plaincopy
Java中的栈Stack、Deque、ArrayDeque、LinkedList
编程架构三分天下：分层、分治、分时序。
10-12 1万+
文章目录先来说说Java中的Stack类不用Stack至少有以下两点原因该用ArrayDeque还是LinkedList？结论 先来说说Java中的Stack类 Java中Stack类从Vector类继承，底层是用数组实现的线程安全的栈。栈是一种后进先出(LIFO)的容器，常用的操作push/pop/peek。 不过Java中用来表达栈的功能（push/pop/peek），更适用的是适用双端队列接口Deque，并用ArrayDeque/LinkedList来进行初始化。 Deque<Integer&g
c语言起初,请问c 语言的单链表 index是从零开始，还是一开始？
weixin_35682327的博客
05-19 1036
慕斯709654＃include＂stdafx．h＂＃include＜stdlib．h＞／／创建一个节点，data为value，指向NULLNode＊Create(intvalue)｛Node＊head＝(Node＊)malloc(sizeof(Node))；head－＞data＝value；head－＞next＝NULL；returnhead；｝／／销毁链表boolDestroy＿List(No...
Java代码实现声明双链表类DoublyLinkedList，实现public boolean remove(E element)方法
最新发布
05-04
好的，我理解您的问题是要求我用Java代码实现一个双链表类DoublyLinkedList，并实现public boolean remove(E element)方法。以下是实现的代码： ```java public class DoublyLinkedList<E> { private Node<E> ...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值