精华内容
下载资源
问答
  • <p style="text-align:center"><img alt="" src=...为什么我把链表lk赋值给链表ll后,对ll进行排序,也会影响到lk?怎么做才能不影响呢?....... 谢谢!</p>
  • 错误见下面注释处“temp” public class HaTest{ ... ****** //这个地方用node.next赋值明显是对的,但换成temp进行赋值为什么出错 //wrong: temp=new Node(t);****** node.next=new Node(t); } } }
  • java -新建list链表赋值的方法总结

    千次阅读 2020-12-15 10:55:00
    java -新建list链表并赋值的方法总结1、直接初始化并赋值1.1 初始化的同时赋值1.2 先初始化后赋值2、将一个list赋值给另一个list2.1 对象引用的方式赋值2.2 非对象引用的方式赋值 1、直接初始化并赋值 1.1 初始化的...

    1、直接初始化并赋值

    1.1 初始化的同时赋值

    List<String> a = new ArrayList<String>() {//这个大括号 就相当于new 接口
                    {//这个大括号 --就是 构造代码块 会在构造函数前 调用
                        this.add("test1");
                        this.add("test2");
                        this.add("test3");
                    }
                };
    

    1.2 先初始化后赋值

    List<String> a = new ArrayList<String>();
    //通过add函数赋值
    a.add("test1");
    a.add("test2");
    a.add("test3");
    

    2、将一个list赋值给另一个list

    2.1 对象引用的方式赋值

    //将A的值赋给链表B
    List<String> A= new ArrayList<String>();  
    A.add("1");  
    A.add("2");  
    List<String> B = A; 
    

    注:此时B对象相当与A对象的引用,而并不是将A对象的值单纯的传递给B对象。即:B对象的操作将直接改变A对象。如B.add(“3”);结果A中也包含了“3”;

    2.2 非对象引用的方式赋值

    单纯的把值赋予另一个list的方式有多种。如下:
    (假设list A已初始化并赋值)

    1. 方式一:
    ArrayList B = new ArrayList<> (A);  
    
    1. 方式二:
    ArrayList B = A.clone();  
    
    1. 方式三:
    ArrayList B = new ArrayList<String>();
    B.addAll(A);
    
    1. 方式四:
    for(String s: A)  {
           B.add(s);  
     }
    
    展开全文
  • 链表一、链表的原理二、深入理解引用赋值2.读入数据总结 一、链表的原理 元素(element):真实存于线性表中的内容 结点(node):为了组织链表而引入的一个结构,除了保存我们的元素之外,还保存指向下一个结点的...


    一、链表的原理

    在这里插入图片描述
    元素(element):真实存于线性表中的内容
    结点(node):为了组织链表而引入的一个结构,除了保存我们的元素之外,还保存指向下一个结点的引用

    class Node {
    	int val;	//保存元素
    	Node next;	//保存指向下一个结点的引用;尾结点的 next == null
    }
    

    在这里插入图片描述
    当前结点(current / cur):表示链表中某个结点
    前驱结点(previous / prev):表示链表中某个结点的前一个结点;头结点没有前驱结点
    后继结点(next):表示链表中某个结点的后一个结点;尾结点没有后继结点

    二、深入理解引用赋值

    Node p = ...;	//已知 p 是一条链表中的某个结点
    Node q = ...;	//已知 q 是一条链表中的某个结点
    

    在这里插入图片描述
    画图表示以下代码执行后的结果:

    1. p = q

    让 p 指向 q 目前指向的结点:

    在这里插入图片描述

    2. p = q.next

    让 p 指向 q 当前指向的结点的后继结点:

    在这里插入图片描述

    3. p.next = q

    让 p 指向的结点中保存的指向下一个结点的引用指向 q 当前指向的对象:

    在这里插入图片描述

    4. p.next = q.next

    让 p 指向的结点中保存的指向下一个结点的引用指向 q 当前指向的结点的后继结点:

    在这里插入图片描述

    展开全文
  • 使用java实现动态链表

    2020-03-04 10:07:08
    //从链表中删除index(0-based)个位置的元素,并返回删除的元素 public E remove ( int index ) { if ( index < 0 || index >= size ) throw new IllegalArgumentException ( "Remove ...
    public class LinkedList<E> {
        public 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;}
    
        //在链表头添加新的元素e
        public void addFirst(E e){
            add(0,e);
        }
    
        //在链表的index(0-based)位置添加新的元素e
        public void add(int index ,E e){
            if(index < 0 || index > size)
                throw new IllegalArgumentException("Add failed . Illegal index.");
    
                Node prev = dummyHead;
                for(int i = 0 ; i < index ; i ++)
                    prev = prev.next;
    //            Node node = new Node(e);
    //            node.next = prev.next;
    //            prev.next = node;
                prev.next = new Node(e,prev.next);
                size ++;
    
        }
    
        //在链表末尾添加新的元素e
        public void addLast(E e){
            add(size , e);
        }
    
        //获得链表的第index(0-based)个位置的元素
        public E get(int index){
            if(index < 0 || index >=size)
                throw new IllegalArgumentException("Get failed. Illegal index");
            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(){
            return get(size - 1);
        }
    
        //更新链表的第index(0-based)个位置的元素
        public void set(int index , E e){
            if(index < 0 || index >= size)
                throw new IllegalArgumentException("Set failed . Illegal index");
            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;
        }
    
        //从链表中删除index(0-based)个位置的元素,并返回删除的元素
        public E remove(int index){
            if (index < 0 || index >= size)
                throw new IllegalArgumentException("Remove failed.Index is illegal.");
            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 removeFirst(){
            return remove(0);
        }
        //丛链表中删除最后一个元素,返回删除的元素
        public E removeLast(){
            return remove(size - 1);
        }
        @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();
    
        }
    }
    
    展开全文
  • 文章目录前言一、双向链表是什么?二、案例1.节点类Node实现2.双向链表类DoubleLinkedLinst3.获取链表头,尾节点方法4.无脑增加方法add5.两个遍历方法(从头遍历和从尾遍历)6.修改节点upDate方法7删除方法delete()8....


    前言

    双向链表的增删改查,其中难点在于按顺序增加,如何保持节点中指向上一个节点的pre也能被修改成功


    提示:以下是本篇文章正文内容,下面案例可供参考

    一、双向链表是什么?

    在这里插入图片描述

    双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点和后继结点

    二、案例

    使用带 head 头的双向链表实现 –水浒英雄排行榜

    1.节点类Node实现

    代码如下(示例):

    
    
    /**
     * 节点类 data域 next域 pre域
     */
    public class Node {
        String name;//名字
        String nikeName;//昵称
        Integer no;//排序
        Node next;//下一个节点的内存地址
        Node pre;//上一个节点的内存地址
    
        public Node(String name, String nikeName, Integer no) {
            this.name = name;
            this.nikeName = nikeName;
            this.no = no;
        }
    	//重写了toString方便遍历后输出节点的详细信息
        @Override
        public String toString() {
            return "Node{" +
                    "name='" + name + '\'' +
                    ", nikeName='" + nikeName + '\'' +
                    ", no=" + no +
                    '}';
        }
    }
    
    

    2.双向链表类DoubleLinkedLinst

    代码如下(示例):
    包含头结点 以及无参数构造方法,在创建双向链表对象的时候自动创建data为空的头节点

    public class DoubleLinkedList {
        Node head;//双向链表中的头结点
    
        public DoubleLinkedList() {
            //双向链表无参构造,构造头结点
            this.head = new Node(null, null, 0);
        }
    }
    

    3.获取链表头,尾节点方法

    1. 获取头
     //获取链表头
        public Node getHead(){
            return head;
        }
    
    1. 获取链表尾部

    通过遍历获取链表的最后一个节点

     //获取双向链表的尾节点
        public Node getLastNode() {
            Node lastNode = null;
            if (head.next == null) {
                System.out.println("链表为空");
            }
            Node temp = head.next;
            //遍历链表
            while (true) {
                if (temp == null) {
                    break;
                }
                lastNode = temp;
                temp = temp.next;
            }
            return lastNode;
        }
    

    这两个方法作用是为了后文两种遍历方法(从头遍历和从尾遍历)做铺垫

    4.无脑增加方法add

    找到链表的最后节点,在他后面加上新节点

    /无脑添加方法add
        public void add(Node newNode) {
            /**
             * 思路
             * 找到链表的最后有效节点让其next属性等于newNode
             * 让newNode的pre属性等于最后的有效节点
             */
            Node temp = head;//创建辅助节点
            while (true) {
                if (temp.next == null) {
                    break;
                }
                temp = temp.next;
            }
            temp.next = newNode;
            newNode.pre = temp;
        }
    

    5.两个遍历方法(从头遍历和从尾遍历)

    1. 从头遍历show()
     //遍历链表
        public void show() {
            if (head.next == null) {
                System.out.println("链表为空");
                return;
            }
    //        Node temp = head;//创建辅助节点
    //        while (true) {
    //            if (temp.next == null) {
    //                break;
    //            }
    //            temp = temp.next;
    //            System.out.println(temp);
    //        }//两种循环方式均可以
            Node temp = head.next;
            while (true) {
                if (temp == null) {
                    break;
                }
                System.out.println(temp);
                temp = temp.next;
            }
        }
    
    1. 从尾部遍历
      //遍历链表根据pre
        public void showByPre() {
            Node lastNode = getLastNode();//获取链表尾部节点
            while (true) {
                if (lastNode == null | lastNode.no == 0) {
                    break;
                }
                System.out.println(lastNode);
                lastNode = lastNode.pre;
            }
        }
    

    以上的遍历方法是为了更好地检验我们顺序添加的方法addByNo是否在添加完成节点后的next和pre都赋值正确

    6.修改节点upDate方法

     public void upDate(Node node) {
            if (head.next == null) {
                System.out.println("链表为空,没有能被修改的数据");
                return;
            }
    //        Node temp=head.next;
    //        boolean flag=false;//标记
    //        //通过遍历找到被修改的节点
    //        while (true){
    //            if (temp==null){
    //                break;
    //            }
    //            if (temp.no==node.no){
    //                flag=true;
    //                break;
    //            }
    //            temp=temp.next;
    //        }
            Node temp = head;//创建辅助节点
            boolean flag = false;
            while (true) {
                if (temp.next == null) {
                    break;
                }
                if (temp.next.no == node.no) {
                    flag = true;
                    break;
                }
                temp = temp.next;
            }
            if (flag) {
                temp.next.name = node.name;
                temp.next.nikeName = node.nikeName;
            } else {
                System.out.println("没找到对应点no");
            }
        }
    

    两种遍历方式分别找到被修改节点和被修改节点的前一个节点

    7删除方法delete()

    public void delete(int no) {
            if (head.next == null) {
                System.out.println("链表为空");
                return;
            }
            /**
             * 双向链表的删除分为三步 举例 连续节点1 2 3
             * 第一步,如果要删除中间节点2,找到节点2
             * 第二步 让2.next.pre=2.pre 让节点3的pre指向1
             * 第二步 让2.pre.next=2.next; 让1的next指向3
             */
            Node temp = head.next;//创建辅助节点
            boolean flag = false;//常见标记如果flag为false 就是没找到
            while (true) {
                if (temp == null) {
                    break;
                }
                if (temp.no == no) {
                    flag = true;
                    break;
                }
                temp = temp.next;
            }
            if (flag) {
                temp.pre.next = temp.next;
                temp.next.pre = temp.pre;
            } else {
                System.out.println("链表中没有这个no");
            }
        }
    

    通过遍历找到被删除节点,将其前后两个节点的next和pre修改,让两者跳过被删除节点

    8.[重点菜]按顺序添加

     //根据编号添加
        public void addByNo(Node node) {
            /**
             * 思路
             * 遍历数组找到node.no的后一个位置temp.next,再将node加到temp其后面,亦可以说成将node添加到temp.next前面都一样
             */
            Node temp = head;//创建辅助节点
            boolean flag = false;//创建标记
            while (true) {
                if (temp.next == null) {
                    break;//说明找到最后,直接就加在链表尾部了
                }
                if (temp.next.no > node.no) {//找到添加位置
                    break;
                }
                if (temp.next.no == node.no) {
                    flag = true;//说明找到node.no已经存在不能重复
                    break;
                }
                temp = temp.next;
            }
            if (flag) {
                System.out.println("链表中已存在节点");
            } else {
                node.next = temp.next;
                node.pre = temp;
                temp.next = node;
                if (node.next != null) {
                   node.next.pre = node;//此处为了避免temp指向
                  //head时,链表中没有数据时候会出现的空指针异常
                }
            }
        }
    

    为了保证我们添加后的next和pre都要指向正确的位置所以必须做出判断
    情况1当我们的双向链表没有有效节点时,我们添加节点 ,
    这时我们只需要改动三个属性,新节点后并没有其他节点,所以后面节点的pre不需要修改,强行执行代码会出现空指针异常
    在这里插入图片描述
    情况2当 链表中有节点,同时我们的新节点要添加在head节点之后,这时必须执行第四行代码,让新节点后一个节点的pre正常赋值

    在这里插入图片描述

    测试

    public class Test {
        public static void main(String[] args) {
            DoubleLinkedList doubleLinkedList=new DoubleLinkedList();
            Node n1=new Node("1","1",1);
            Node n2=new Node("2","2",2);
            Node n3=new Node("3","3",3);
            Node n4=new Node("4","4",4);
    
            doubleLinkedList.addByNo(n2);
            doubleLinkedList.addByNo(n4);
            doubleLinkedList.addByNo(n3);
            doubleLinkedList.addByNo(n1);
    
            doubleLinkedList.show();
            System.out.println("通过pre遍历后");
            doubleLinkedList.showByPre();
        }
    }
    

    在这里插入图片描述
    这里可以看出通过next属性或者pre属性 都可以正常遍历链表


    总结

    如有问题或建议,欢迎留言

    展开全文
  • 复杂链表的复制(java)

    2019-08-20 12:51:13
    输入一个复杂链表(每个节点中有节点值,以及两个指针,一个指向下一个节点,另一个特殊指针指向任意一个节点),返回结果为复制后复杂链表的head。(注意,输出结果中请不要返回参数中的节点引用,否则判题程序会...
  • * 自定义双向链表 * * @author 冯赵杨 * @date 2018年4月10日 */ public class DoubleLink&amp;amp;lt;E&amp;amp;gt; { private int n; private Node first; private Node last; private class ...
  • java 链表基础详解

    千次阅读 2020-02-09 20:05:58
    链表是基础的数据结构之一,和数组一样基础,提到链表我们总会联想到数组结构,最顺嘴的一句话便是数组适合查询,链表适合插入,但是这句话其实说的太过于简单,以至于就不是那么准确了,我们来细细分析下这句话。...
  • 链表是一种简单的数据结构。由两部分构成,数值部分和指针部分。 前一部分用来存储数据,后一部分用于指向下一个数据。形成一个链状的结构。 ​​​​​​​ ...
  • 双向链表: 就是有双向指针 即 双向的链域 链结点的结构: ┌────┬────┬────────┐ │data│next│previous│ └────┴────┴────────┘ 双向链表不必是双端链表(持有对最后一个...
  • 删除链表的倒数第N个节点 删除链表中的节点 题目描述: 237.删除链表中的节点 请编写一个函数,使其可以删除某个链表中给定的(非末尾)节点,你将只被给定要求被删除的节点。 现有一个链表 -- head = [4,5,1,9],...
  • 目录链表介绍Java->链表APIJava->链表代码使用链表示例 链表介绍 链表属于线性表的一种 如果想了解Java实现的顺序表,请戳这里:【数据结构】使用Java实现顺序表类 SeqList Java->链表API 在看代码之前,...
  • 这道题我用到了反转链表的函数,原本是想试试看直接在原链表上修改结构,结果发现在函数中修改完结构,函数外的链表与函数里的链表已经不是指同一个对象了。具体代码如下: class Solution3 { public ArrayList<...
  • Java链表与数组间的相互转换

    千次阅读 2020-11-09 15:18:43
    自定义链表ListNode类 public class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } 将链表转换成数组 //将链表转换成数组 public class Test1 { public static void main(String...
  • Java---链表的遍历

    2021-03-04 16:03:00
    创建一个链表 //创建一个链表 public static Node createList(){ //创建四个Node实例,再定义四个引用来分别指向这四个实例 //随着方法的结束,a,b,c,d也随之销毁 Node a=new Node(1);... //引用进行赋值 /.
  • 有个小需求要求实现一个双向链表的反转于是就有了下边代码: 链表元素结构定义: package com.util; public class LinkedNode&lt;T&gt;{ private T value; private LinkedNode&lt;T&gt; ...
  • Amazon 面试题,如何用O(N)实现在链表中找出 是否出现循环(Loop),算法也可以用在其他语言(C,C++等)
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别? JDK:Java ...
  • 数据结构之实现链表 之前一直使用的是c语言学习数据结构,但是总体理解度不高,实在是难以理解,于是开始尝试利用java学习数据结构,理解程度不高,有错误可以指出(谢谢大佬~) 进入正题: 使用c语言学数据结构的...
  • Java创建链表ListNode

    千次阅读 2020-11-29 11:17:14
    案例:本文主要描述Java创建链表ListNode 一、首先创建一个maven工程,配置依赖包 无特殊依赖 二、开始写入自动化测试代码 class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } public ...
  • Java 链表结点插入

    千次阅读 2018-05-01 15:18:48
    PS:链表是一种数据结构,而数据结构就是一种存放数据的方式。 为什么需要链表? 我们知道,数组也可以存储数据,那么为什么还需要链表呢?接下来,我们来看看数组 和链表的区别: 1、数组就像身上编了号站...
  • Java泛型链表实现

    2018-04-24 21:58:36
    链表简介 代码实现 package com.chenxixuexi; /** * 泛型链表 * 单链表逆置数据--节点 * 求单链表倒数第K节点 * 求两个单链表 是否相交 相交交点 * 判断单链表是否有环?有求出环的入口点 求环的长度? ...
  • JAVA语言创建链表的方法

    万次阅读 2018-03-28 11:08:54
    链表刚学习时是用c来学习的,那时候对于结构体,指针这些东西实现链表觉得很合适,但想要应用到java上还是有些不同的 这里,我学习下用java来使用链表的方法: 首先,定义节点类 //链表节点 class Node{ ...
  • JAVA实现单链表

    2016-06-30 12:55:52
    解释透明,代码通过亲测没毛病,可直接赋值粘贴运行^_^定义节点类:package 链表;public class Node { public int Element; public Node next; public Node(int Element,Node next){ this.Element=Element; this...
  • Java实现静态链表

    2018-09-01 21:14:43
    ## Java实现静态链表 ## 初学数据结构,花了一天理解了如何用Java写静态链表,可以实现插入和删除操作,关键点代码里已经都注释了。然后经过格式化输出,展示了游标、数据和数组下标的变化。由于Java里没有结构体,...
  • Java使用链表实现栈

    2017-09-28 18:44:29
    大话数据结构中,这一块其实对于初学的还是挺难的,我看了小半天,最后才...因此每次插入一个,都需要将插入前的栈顶结点赋值给新节点的next结点属性; 每次弹栈,都需要将top的next指向元素置为top元素; 下面上
  • java实现单向链表的删除

    千次阅读 2019-03-25 21:10:59
    定单向链表的头指针和一个节点指针,定义在一个函数在O(1)时间内删除该节点。 public class ListNode { ListNode next; int value; public ListNode(int value){ this.value = value; } } 测试类如下...
  • 链表是一种重要的数据结构,在程序设计中占有很重要的地位。C语言和C++语言中是用指针...//指向下一个结点 } 将数据域定义成Object类是因为Object类是广义超类,任何类对象都可以赋值,增加了代码的通用性。为了
  • 什么是链表Java)(2020)

    千次阅读 2020-03-23 22:27:24
    都2020年了,到底什么是链表? 前言 (本文适合没有基础的小白,或者想了解学习方法的入门者食用 ps:本文所指的是单向链表) 还记得上《数据结构与算法》这门课的时候,老师在前面讲:链表有一个数值域,一个指针域...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,536
精华内容 23,814
关键字:

java给链表赋值

java 订阅