精华内容
下载资源
问答
  • java单向链表

    2020-09-14 06:06:27
    Java的单向列表单向链表如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能,丰富你...

    Java的单向链表

    java中常用的结构是数组,它的优点是存储速度快,但是你得知道他的长度,而且插入和删除元素很慢。所以有时口你可以选择用链表,它的优点是空间没有限制而且插入删除速度很快。
    链表有单向链表,双向链表和循环链表。

    单向链表 由很多和Node组成,每个Node里面有数据域和Next指针。 在这里插入图片描述
    我们先定义一个Node类:

    public class Node {
        private Node next;
        private int data;
        public Node() {
        }
    }
    

    Mac上用command+N,自动生成get,set方法以及全参的构造方法

    public class Node {
        private Node next;
        private int data;
    
        public int getData() {
            return data;
        }
        public void setData(int data) {
            this.data = data;
        }
        public Node(int data) {
            this.data = data;
        }
        public Node() {
        }
    }
    

    我们创建一个新的类MyList,设置第一个节点为head = null当我们打算增加一个节点,命名为addNode

    class MyList {
        Node head = null;
    
        public void addNode(int n){
            // 根据传入的数据n,生成一个新的节点newNode
            Node newNode = new Node(n);
            // 如果这个链表是空,那么第一个节点就是head
            if (head == null){
                head = newNode;
                return;
            }
            
            Node temp = head;
            // 如果下一个节点存在,接着往下走,直到最后一个节点
            while(temp != null){
                System.out.println("this is "+temp.getData());
                temp = temp.next;
            }
            // 设置最后一个节点的下一个节点为空节点
            temp.next = newNode;
    
    }
    

    通过值来删掉一个Node

    public boolean deleteByValue(int data){
            Node temp1 = head;
            Node temp2 = temp1.next;
            // 这两个值一次移动,制动找到目标。
            while(temp2 != null){
                temp1 = temp1.next;
                temp2 = temp1.next;
                // 找到目标的时候,temp2向后移动一个,在连接上temp1
                if (temp2.getData() == data){
                    temp2 = temp2.next;
                    temp1.next = temp2;
                    return true;
                }
            }
            return false;
    }
    

    通过索引来删掉一个Node

    public void deleteByIndex(int index){
            if (index<0 || index>length()){
                System.out.println("Please input the correct index!");
            }
            int idx = 1;
            Node temp1 = head;
            Node temp2 = temp1.next;
            while(temp2 != null){
                temp1 = temp1.next;
                temp2 = temp1.next;
                idx++;
                if(idx == index){
                    break;
                }
            }
            temp2 = temp2.next;
            temp1.next = temp2;
        }
    

    获知整个列表的长度

    public int length(){
            int len = 0;
            Node temp = head;
            // 循环整个列表,每到一个Node就len++
            while(temp != null){
                len++;
                temp = temp.next;
            }
            return len;
        }
    

    如果是打印出整个链表

    public void printLinkedList(){
            Node temp = head;
            // 循环整个列表
            while (temp != null){
                System.out.print(" "+temp.getData());
                temp = temp.next;
            }
        }
    

    进行一下测试

    public class Test {
        public static void main(String[] args) {
            MyList t = new MyList();
            t.addNode(2);
            t.addNode(3);
            t.addNode(8);
            t.addNode(31);
            t.addNode(18);
            // 打印出此时的链表及长度
            t.printLinkedList();
            System.out.println();
            System.out.println("length: "+t.length());
            // 删除值为31的Node
            int num = 31;
            t.deleteByValue(num);
            // 打印出此时的链表及长度
            System.out.print("After deleted "+num+" it is :");
            t.printLinkedList();
            System.out.println();
            // 删除链表的第2个Node
            int index = 2;
            t.deleteByIndex(index);
            // 打印此时的链表
            System.out.print("After deleted the index of Node " + index+ " it is :");
            t.printLinkedList();
        }
    }
    

    输出的结果是:

     2 3 8 31 18
    length: 5
    After deleted 31 it is : 2 3 8 18
    After deleted the index of Node 2 it is : 2 3 18
    Process finished with exit code 0
    
    展开全文
  • java实现单向链表

    2020-07-14 17:15:38
    java实现单向链表 链表的介绍: 链表是以节点的方式来存储,是链式存储 每个节点包含data域,next域:指向下一个节点 链表的各个节点不一定是连续存储的 链表分为带头节点的链表和没有头节点的链表,根据实际的需求...

    java实现单向链表——添加到链表最后

    链表的介绍:

    1. 链表是以节点的方式来存储,是链式存储
    2. 每个节点包含data域,next域:指向下一个节点
    3. 链表的各个节点不一定是连续存储的
    4. 链表分为带头节点的链表和没有头节点的链表,根据实际的需求来确定
      每次将元素存进链表的最后
      相关思路:
      在这里插入图片描述代码实现:
    /*
     * 将元素添加进链表的尾部
     * 并遍历链表
     */
    public class SingleLinkedListDemo {
    
    	public static void main(String[] args) {
    		//创建英雄人物
    		HeroNode h = new HeroNode(1,"宋江","及时雨");
    		HeroNode h1 = new HeroNode(2,"卢俊义","玉麒麟");
    		HeroNode h2 = new HeroNode(3,"吴用","智多星");
    		HeroNode h3 = new HeroNode(4,"林冲","豹子头");
    		//创建链表
    		SingleLinkedList s = new SingleLinkedList();
    		//将英雄添加进链表
    		s.add(h);
    		s.add(h1);
    		s.add(h2);
    		s.add(h3);
    		//遍历链表
    		s.show();
    	}
    	 
    }
    //定义一个链表类(单向链表)
    class SingleLinkedList{
    	//链表的头部,不存放值
    	private HeroNode head = new HeroNode(0,"","");
    	
    	//将元素添加进链表的尾部
    	public void add(HeroNode heroNode) {
    		//应用传地址,相当于指针了,但不是指针(由于头部节点不能动,所以要用辅助变量temp)
    		HeroNode temp = head;
    		while(true) {
    			//temp.next == null时,说明找到最后的位置了
    			if(temp.next == null) {
    				//将英雄添加到链表的尾端
    				temp.next = heroNode;
    				break;
    			}
    			//将指针往后移动一个(直到找到最后的位置)
    			temp = temp.next;
    		}
    	}
    	
    //	遍历整个链表
    	public void show() {
    		//当链表为空时不进行遍历,直接结束
    		if(head.next == null) {
    			System.out.println("链表为空");
    			return;
    		}
    		//遍历链表时同样需要辅助变量,因为head节点不能移动,不就找不到该链表了
    		HeroNode temp = head;
    		while(true) {
    			//当链表为空时,不进行遍历,直接结束循环
    			if(temp.next == null) {
    				break;
    			}
    			//直接输出链表节点存的数据
    			System.out.println(temp.next);
    			//将指针往后移动一个,如果不移动会陷入死循环,要小心
    			temp = temp.next;
    		}
    	}
    }
    
    //记录的是每一个节点
    class HeroNode {
    	//英雄的编号
    	public int no;
    	//英雄的名字
    	public String name;
    	//英雄的昵称
    	public String nickName;
    	//指向下一个节点
    	public HeroNode next;
    	
    	//构造器,用来对英雄初始化
    	public HeroNode(int no,String name,String nickName) {
    		this.no = no;
    		this.name = name;
    		this.nickName = nickName;
    	}
    //重写toString()方法,方便输出
    	@Override
    	public String toString() {
    		return "HeroNode [no=" + no + ", name=" + name + ", nickName=" + nickName + "]";
    	}
    }
    
    展开全文
  • java实现单向链表--创建、遍历

    千次阅读 2017-04-12 22:56:46
    自己练习,简陋的Java实现的单向链表

    链表是非常常用的数据结构,数据结构是不分语言的,在此我只是通过Java语言实现了一个极其简陋的单向链表,后续还好实现双向链表,双向循环链表等。

    /**

     * java实现单向链表
     * Title: QueueTest.java
     * Copyright: Copyright (c) 2007
     * Company: LTGames
     * @author author
     * @date 2017年4月12日 下午10:30:13
     * @version 1.0
     */
    public class QueueTest {


    private Entrys entrys; //当前节点
    private Entrys head; //头结点

    class Entrys{
    public Object object;
    public Entrys next;

    public Entrys(Object object, Entrys next){
    this.object = object;
    this.next = next;
    }
    }

    /**
    * 添加节点
    * @param obj
    */
    public void add(Object obj){
    Entrys entrysNew = new Entrys(obj,null);
    if(head == null){
    head = entrysNew;
    entrys = entrysNew;
    } else {
    entrys.next = entrysNew; //当前节点指向新的节点
    entrys = entrysNew; //当前节点向后移动
    }
    }

    /**
    * 遍历节点
    * @param entrys
    */
    public void findQueue(Entrys entrys){
    while(entrys != null){
    System.out.println(entrys.object);
    entrys = entrys.next;
    }
    }

    public static void main(String[] args){
        QueueTest test = new QueueTest();
        test.add("a");
        test.add("b");
        test.add("c");
        test.add("d");
        test.add("e");
        test.findQueue(test.head);
      }
    }
    展开全文
  • Java实现单向链表

    2019-10-09 00:16:12
    本篇介绍Java实现单向链表的peak(获取第一个节点对象)、removeFirst(删除第一个节点)、find(查找指定节点)、remove(移除链表中指定节点对象)等方法。 一、创建节点类 package linkedList; /** * 节点类...

            本篇介绍Java实现单向链表的peak(获取第一个节点对象)、removeFirst(删除第一个节点)、find(查找指定节点)、remove(移除链表中指定节点对象)等方法。

    一、创建节点类

    package linkedList;
    
    /**
     * 节点类
     * 数据有id、nextNode
     * nextNode用于指向下一个节点对象
     */
    public class LinkNode {
        private int id;
        private LinkNode nextNode;
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public LinkNode getNextNode() {
            return nextNode;
        }
    
        public void setNextNode(LinkNode nextNode) {
            this.nextNode = nextNode;
        }
    
        public LinkNode(int id) {
            this.id = id;
        }
    
        public void printLink() {
            String s = "(id = " + id;
            if (nextNode != null) {
                s += ", nextData = " + this.nextNode.getId();
            }
            s += ")";
            System.out.println(s);
        }
    }
    

    二、实现单向链表

    package linkedList;
    
    public class SingleLinkList {
        private LinkNode firstNode;
    
        /**
         * 从顶部添加节点
         * 顶部添加节点:需要将新的Node对象的nextNode对象指向当前链表的第一个节点对象,即firstNode,
         * 然后firstNode引用指向新的Node对象
         * @param id
         */
        public void insertFirst(int id) {
            LinkNode newLinkNode = new LinkNode(id);
            newLinkNode.setNextNode(firstNode);
            firstNode = newLinkNode;
        }
    
        /**
         * 获取第一个节点对象
         * @return
         */
        public LinkNode peak() {
            return firstNode;
        }
    
        /**
         * 删除第一个节点
         * 只要将firstNode引用指向当前链表的第一个节点的nextNode对象
         * @return 删除的节点
         */
        public LinkNode removeFirst() {
            LinkNode tempNode = firstNode;
    
            firstNode = firstNode.getNextNode();
    
            return tempNode;
        }
    
        /**
         * 查找指定节点
         * 遍历链表的所有节点,直至找到指定id的节点对象
         * @param id
         * @return 返回找到的节点对象
         */
        public LinkNode find(int id) {
            LinkNode node = firstNode;
    
            while (node.getId() != id) {
                if (node.getNextNode() == null) {
                    break;
                } else {
                    node = node.getNextNode();
                }
            }
    
            return node;
        }
    
        /**
         * 移除链表中指定节点对象
         * 有两种情况:①移除的对象为第一个节点;②移除的对象为其他节点
         * @param id
         * @return 返回被移除的节点对象
         */
        public LinkNode remove(int id) {
            LinkNode needDelNode = firstNode;
            LinkNode previousNode = firstNode;
    
            while (needDelNode.getId() != id) {
                if (needDelNode.getNextNode() == null) {
                    return null;
                } else {
                    previousNode = needDelNode;
                    needDelNode = needDelNode.getNextNode();
                }
            }
    
            if (needDelNode.equals(firstNode)) {
                firstNode = firstNode.getNextNode();
            }else {
                previousNode.setNextNode(needDelNode.getNextNode());
            }
            return needDelNode;
        }
    
        /**
         * 遍历链表
         */
        public void displayList() {
            //如果不使用temp临时节点,直接用firstNode,则后面操作会使得firstNode的指向改变,会影响其他方法使用firstNode
            LinkNode temp = firstNode;
            StringBuffer stringBuffer = new StringBuffer();
            while (temp != null) {
                temp.printLink();
                temp = temp.getNextNode();
            }
        }
    }
    

     

    展开全文
  • Java单向链表

    2020-08-29 10:36:08
    单向链表中的节点是链表的基本单元,每个节点都有两个属性:1、存储的数据 2、下一个节点的地址 链表优点:随机增删元素效率较高,因为增删元素不涉及大量元素的位移 链表缺点:查询效率低,每一次查找某个元素...
  • Java无头单向链表

    2019-09-28 22:59:02
    链表: 是一种物理存储结构上非连续存储结构,数据元素的逻辑顺序是通过链表中的引用链接次序实现的 ...我们今天实现的是 无头单向链表 ```java // 1、无头单向非循环链表实现 public class SingleLinkedList { ...
  • Java实现单向链表和双向链表

    千次阅读 2017-03-10 11:41:39
    1、单向链表 单向链表的特点是链表的链接方向是单向的,对链表的访问要通过顺序读取从头部开始;链表是使用指针进行构造的列表;又称为结点列表,因为链表是由一个个结点组装起来的;其中每个结点都有指针成员变量...
  • Java编写单向链表

    2021-01-22 17:36:15
    链表(Linked List)介绍 1)链表是以节点的方式来存储数据,是链式存储。 2)每个节点包含data域及next域。...1.先创建一个head头节点(不存放具体的数据),作用是表示单链表的头(head.next)。 2.后面每添加一个节
  • Java实现单向链表功能

    千次阅读 2018-09-01 11:51:07
    前言 HaspMap的使用频率非常高,相信在每一个Java项目都能见到HashMap的身影。...想要弄清楚HashMap,首先数组和链表有一定的了解,相信大家都十分了解数组,那么下面重点实现一下单向链表的...
  • * discirption: 运用java实现单向链表创建、遍历打印、插入元素、删除元素。 */ public class myLinkedList { static class Node{//内部类,构成链表最基本的单元 int data;//单元携带的信息(在这里是int整型...
  •  在讲解完了单向链表了以后,单向循环链表就非常简单了,单向循环链表的特点是最后一个节点的指针域为head,所以在一些判断的过程中就需要把null该为head就可以了。一起来看看有什么变化 节点类的数据结构是相同...
  • package node; import ... import java.util.Stack; public class model { private node head=new node(1,“aa”); public StacknodeStack=new Stack<>(); //添加...
  • Java实现单向链表就必须要先有一个节点,该节点用来存放数据和下一个节点的地址! 但是前提是必须得有一个头节点,头节点里不放任何的数据的,只是用来 用来存放这个链表中的头位置! 所以实现的整个效果,大家先...
  • java实现单向链表——按顺序添加 链表的介绍: 链表是以节点的方式来存储,是链式存储 每个节点包含data域,next域:指向下一个节点 链表的各个节点不一定是连续存储的 链表分为带头节点的链表和没有头节点的链表,...
  • JAVA 实现带头结点的链表根据节点大小按顺序新增、修改、删除节点该文章已实现单向链表创建及遍历等操作。 那么在此基础上,如何实现单向链表的反转呢? 实现思路: 1. 先定义一个节点 reverseHead = new ...
  • package ... /** * @Author zmz * @Class_Name:LinkNode * @Create_Date:2019/6/26 * @Des: 自定义单向链表结构 */ public class LinkNode { //根节点 private Node mNode; //链表大小 ...
  • 一、链表介绍 ...使用带head头的单向链表实现输入学生信息,查询时根据学生id顺序显示 添加节点:根据学生id将学生信息插入到指定位置(若id存在则提醒添加失败) 添加(创建) 1.创建一个head头节点,...
  • 初学者用Java实现单向链表增、删、查功能 前言: 自学动力节点的Java视频,作业是用Java模拟单向链表的增、删、查功能; package Day01.Collection; /* 用Java语言模拟单向链表 */ public class Linked { // 节点 ...
  • 前面我们已经实现了一个简单的单向链表,虽然从功能上来说,它可以满足一个单向链表的基本需求,但如果放在整个Java体系中,这样的链表是无法融入的。在Java体系中,链表属于Collection集合体系下的集合容器(并且...
  • java实现单向链表——修改和删除节点 删除节点示意图: 相关代码 /* * 按顺序将元素添加进节点,修改和删除节点 * 并遍历链表 */ public class SingleLinkedListDemo { public static void main(String[] args)...
  • 一、前言 最近在回顾数据结构与算法,有部分的算法题用到了栈的思想,说起栈又不得不说链表了。数组和链表都是线性存储结构的基础,栈和队列都是线性存储结构的应用~ ...数组我们无论是C、Java都会学过: 数...
  • 数据结构与算法——Java实现单向链表的增删改查 单向链表增删改查,通过no进行插入排序 //定义SingleLinkedList管理单链表 class SingleLinkedList { //先初始化一个头节点,头节点不要随意修改 private ...
  • 使用Java建立单向链表

    2019-04-15 12:46:49
    以下使用Java代码实现了包括添加、删除和插入在内的基本操作。 /** * 自定义整型链表,包括了添加、删除和插入等操作。 * @author Wei HAO * Date: 2019/04/15 * */ public class IntegerList { public stati...
  • 文章目录前言一、pandas是什么?二、使用步骤1....示例:pandas 是基于NumPy 的一种工具,该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下(示例): import numpy as np import
  • 概述:众所周知,数据对于数据的存储时连续的,也就是说在计算机的内存中是一个整体的、连续的、不间断的ADT数据结构。...1 单向链表的定义链表主要用来存储引用类型的数据。其结构可以由下图清楚的表示: 链表
  • Java实现单向链表。 实现链表创建、添加节点、删除节点、显示链表、修改节点值、有序插入节点、获取节点个数、单链表反转、逆序打印、合并链表功能。 import java.util.Stack; public class SingleLInkedList { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,143
精华内容 8,857
关键字:

java创建单向链表

java 订阅