精华内容
下载资源
问答
  • java创建空链表list
    2022-05-31 22:44:18

    Background

    最近在LeetCode上刷题时看到一道从尾到头打印链表的题,发现对链表的构建及遍历掌握不够,于是查找相关资料并对学习内容进行记录。

    链表的基本结构

    public class ListNode {
        int val;		//结点数据
        ListNode next;	//指向下一个结点对象
    }
    

    在当前结构中添加构造方法,便于对链表进行初始化。

    public class ListNode {
        int val;
        ListNode next;
    
        ListNode(int val){
            this.val = val;
        }
    }
    

    构建链表

    构建链表的方法与C相似,其基本思想是:

    • 创建头结点head并初始化(本次构建中head头结点也包含数据)
    • 创建一个新结点nextNode指向当前头结点
    • 循环遍历数据,每次循环创建一个结点接收当前数据,并使用nextNode.next指向当前新建结点,同时将nextNode结点指向像一个结点。
      具体代码如下:
        /**
         * 函数名称:createList
         * 函数功能:创建链表
         */
    //    @Test
        public ListNode createList(){
    
            ListNode head = new ListNode(0);     //创建头结点
            ListNode nextNode;
            nextNode = head;
    
            //循环遍历列表,并创建结点
            for (int i = 0;i < 5;i++) {
                ListNode node = new ListNode(i);
                nextNode.next = node;
                nextNode = nextNode.next;
            }
    
            return head;
        }
    

    遍历链表

    遍历链表方法其实很简单,就是从头结点出发开始遍历,当指向的结点为空时停止遍历,说明此时链表已经遍历完成。

        /**
         * 函数名称:print
         * 函数功能:打印链表
         * @param head
         */
        public void printLinkedList(ListNode head){
            while(head != null){
                System.out.print(head.val);
                head = head.next;
            }
            System.out.println();
        }
    
    更多相关内容
  • 链表及用java创建链表

    2021-12-03 14:06:39
    数组是连续的,而链表不是,链表是由值和地址指针组成的,如下...java文件编译成class文件是放入电脑内存中的,因为内存是用数组存储的,所以如果想用java实现链表存储我们需要写几个方法来让java完成链表 分别定义..

    数组是连续的,而链表不是,链表是由值和地址指针组成的,如下图:

     在电脑上内存一般是用数组存储的,数组索引较快。而磁盘是用链表存储的,那为什么数组索引快还在磁盘上用链式存储这种查找速度慢的,这是因为文件都存在磁盘上,如果删除文件后就会造成磁盘扇区碎片化,用链表存储可以合理运用碎片化的空间。磁盘存储如下图:

     这样大大提高了磁盘的利用率。

    java文件编译成class文件是放入电脑内存中的,因为内存是用数组存储的,所以如果想用java实现链表存储我们需要写几个方法来让java完成链表

    分别定义了Node、Linklist、Test三个类,看如下代码:

    Node代码:

    public class Node {
    	//定义链表的value,存放值
    	public int node;
    	//定义链表的指针,让它来指向下一个值的地址,使用Node类型就是因为值传递中要传递的是Node类型的数据
    	Node next;
    	//用构造器把值来存到堆中
    	public Node(int node) {
    		this.node=node;
    	}
    }

    Linklist代码: 

    //链表的管理类
    public class Linklist {
        //把链表放入堆中,方便管理
    	Node head=null;
    	public Linklist() {
    		// TODO Auto-generated constructor stub
    	}
    	public void add(int n) {
    		Node node=new Node(n);
    		//定义头指针来判断是否有元素
    		if(head==null) {
    			head=node;
    			return;
    		}
    		//定义游标tempNode,让它们指针连接起来
    		Node tempNode=head;
    		//如果游标的next不是null,让它遍历一遍,让游标指向倒数第二个元素
    		while (tempNode.next!=null) {
    			tempNode=tempNode.next;
    			
    		}
    		//如果游标的next是null,让它的下一个指最新数据
    		tempNode.next=node;
    	}
    	public void printLink() {
    		Node temp=head;
    		while (temp!=null) {
    			System.out.println(temp.node);
    			temp=temp.next;
    			
    		}
    		
    	}
    }

    Test代码: 

    public class Test {
    	public static void main(String[] args) {
    		Linklist linklist=new Linklist();
    		linklist.add(3);
    		linklist.add(5);
    		linklist.add(2);
    		linklist.add(9);
    		linklist.add(0);
    		linklist.printLink();
    	}
    }
    

    输出结果:

    展开全文
  • 设计一个Java程序,可以让用户输入数据来添加学生数据节点,以建立一个单向链表。 一共输入5位学生的成绩来建立好单向链表,然后遍历这个单向链表的每一个节点来打印输出学生的成绩。单向链表的遍历就是访问链表中的...

    设计一个Java程序,可以让用户输入数据来添加学生数据节点,以建立一个单向链表。
    一共输入5位学生的成绩来建立好单向链表,然后遍历这个单向链表的每一个节点来打印输出学生的成绩。单向链表的遍历就是访问链表中的每个节点。

    
    package LinkList;
    /*
     * 设计一个Java程序,可以让用户输入数据来添加学生数据节点,以建立一个单向链表。
     * 一共输入5位学生的成绩来建立好单向链表,然后遍历这个单向链表的每一个节点来打印输出学生的成绩。
     * 单向链表的遍历就是访问链表中的每个节点。
     */
    class Node{	
    	int data;
    	int np;
    	String name;
    	Node next;
    	public Node(int data,int np,String name) {
    		this.np=np;
    		this.data=data;
    		this.name=name;
    		this.next=null;
    	}
    	
    }
    public class LinkList {
    	private Node first;
    	private Node last;
    	public boolean isEmpty() {
    		return first==null;
    	}
    	public void print() {
    		Node current=first;
    		while(current!=null) {
    			System.out.println("["+current.data+" "+current.name+" "+current.np+"]");
    			current=current.next;
    		}
    		System.out.println();
    	}
    	public void insert(int data,int np,String names) {
    		Node newNode=new Node(data,np,names);
    		if(isEmpty()) {
    			first=newNode;
    			last=newNode;
    		}else {
    			last.next=newNode;
    			last=newNode;
    		}
    	}
    	
    	
    }
    package LinkList;
    import java.io.*;
    /*
     * 输入5位学生的成绩来建立好单向链表,然后遍历这个单向链表的每一个节点来打印输出学生的成绩
     */
    public class Grades {
    	public static void main(String args[])throws IOException{
    		BufferedReader buf;
    		buf=new BufferedReader(new InputStreamReader(System.in));
    		int num;
    		String name;
    		int score;
    		System.out.println("请输入5位学生的数据:");
    		LinkList list=new LinkList();
    		for(int i=1;i<6;i++) {
    			System.out.println("请输入学号:");
    			num=Integer.parseInt(buf.readLine());
    			System.out.println("请输入姓名:");
    			name=buf.readLine();
    			System.out.println("请输入成绩:");
    			score=Integer.parseInt(buf.readLine());
    			list.insert(num, score, name);
    			System.out.println("-------------");
    		}
    		System.out.println("学生成绩");
    		System.out.println("学号姓名成绩===");
    		list.print();
    		
    	}
    }
    
    
    展开全文
  • java实现单链表操作

    2021-03-10 05:18:07
    单链表的存储结构如图:每一个结点都分为数据域和指针域两部分,其中head为头结点,头结点的数据域可以不存放任何数据,而指针域存放的是指向链表第一个结点的地址。每一个结点的指针域都指向下一个结点的地址,最后...

    efcf0c5fff437668b8318a78fc743c59.png

    单链表的存储结构如图:每一个结点都分为数据域和指针域两部分,其中head为头结点,头结点的数据域可以不存放任何数据,而指针域存放的是指向链表第一个结点的地址。

    每一个结点的指针域都指向下一个结点的地址,最后一个结点的指针为null。

    关于头指针和头结点:

    ① 头结点是为了操作的统一和方便而设立的,放在第一个元素的结点之前(头结点并不是链表的必须要素)。

    ② 头指针是指向链表第一个结点的指针(若链表有头结点,当然是指向头结点),具有标识作用,无论链表是否为空,头指针均不为空,且不能随意改动(就像风筝断了线的话就找不回来了)。

    实现过程:

    1、创建一个类Node.java:

    package com.list.singlyLinkedList;

    public class Node {

    public Node next;

    public int value;

    public Node() {

    next = null;

    }

    public Node(int v) {

    value = v;

    }

    }

    2、新建接口ISinglyLinkedList.java并定义基本的方法:

    package com.list.singlyLinkedList;

    public interface ISinglyLinkedList {

    /**

    * 在链表前添加结点(头插法)

    * @param val

    */

    public void addPre(int val);

    /**

    * 链表尾部添加结点(尾插法)

    * @param val

    */

    public void append(int val);

    /**

    * 删除指定位置的结点

    * @param pos索引从0开始

    * @return

    */

    public Node deletepos(int pos);

    /**

    * 根据索引获取结点

    * @param pos

    * @return

    */

    public Node getElem(int pos);

    /**

    * 输出链表

    */

    public void print();

    }

    3、新建SinglyLinkedList类实现接口中的方法:

    package com.list.singlyLinkedList;

    public class SinglyLinkedList implements ISinglyLinkedList {

    private Node head;

    public SinglyLinkedList() {

    head = null;

    }

    @Override

    public void addPre(int val) {

    Node n = new Node(val);

    if (head == null) {

    head = n;

    } else {

    n.next = head;

    head = n;

    }

    }

    @Override

    public void append(int val) {

    Node n = new Node(val);

    Node current = head;

    if (current == null) {

    head = n;

    return;

    }

    while (current != null) {

    if (current.next == null) {

    current.next = n;

    return;

    }

    current = current.next;

    }

    }

    @Override

    public Node deletepos(int pos) {

    Node current = head;

    int counter = 0;

    if (pos == 0) {

    head = head.next;

    return current;

    }

    while (current != null) {

    if ((counter == (pos - 1)) && (current.next != null)) {

    Node temp = current.next;

    current.next = temp.next;

    return temp;

    }

    current = current.next;

    counter++;

    }

    return null;

    }

    @Override

    public Node getElem(int pos) {

    Node current = head;

    int counter = 0;

    if (pos == 0) {

    return current;

    }

    while (current != null) {

    if ((counter == (pos - 1)) && (current.next != null)) {

    Node temp = current.next;

    return temp;

    }

    if (current.next != null)

    current = current.next;

    else

    break;

    counter++;

    }

    return null;

    }

    @Override

    public void print() {

    Node current = head;

    while (current != null) {

    System.out.println(current.value);

    current = current.next;

    }

    }

    public static void main(String[] args) {

    SinglyLinkedList l = new SinglyLinkedList();

    //l.addpre(2);

    //l.addpre(1);

    l.append(5);

    l.append(6);

    l.deletepos(0);

    l.append(10);

    l.addPre(1);

    l.print();

    System.err.println("-----------");

    System.err.println(l.getElem(0));

    }

    }

    新手如有错误,请不吝指正,谢谢。

    展开全文
  • java链表创建和使用

    万次阅读 多人点赞 2019-06-10 12:25:34
    链表创建和使用 1,创建一个链表: a,定义一个class类 ListNode 如下: //创建一个链表的类 class ListNode{ int val; //数值 data ListNode next; // 结点 node ListNode(int x){ //可以定义一个有参构造...
  • Java链表的用法1.链表的概念2.链表的操作3.Java链表的使用
  • 主要给大家介绍了关于Java实现单向链表基本功能的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧。
  • java代码实现链表创建链表反转
  • Java实现单向链表

    千次阅读 多人点赞 2022-03-16 14:39:19
    Java实现单向链表
  • java创建链表

    千次阅读 2016-05-25 19:08:32
    这里采用头插法和尾插法两种方式来创建链表: 首先,创建一个类来保存数据元素和两个指针: public class DoubleLink { int data; DoubleLink prior; DoubleLink next; public DoubleLink(int data){ ...
  • 1.节点和单向链表的操作 public class LinkedList { private Node first;... * 首先判断链表是否为 * @return */ public boolean isEmpty(){ return first == null; } /** * 将当前链表的内容打印出.
  • JAVA实现链表面试题

    2020-09-03 09:40:49
    主要介绍了JAVA相关实现链表的面试题,代码实现非常详细,每一个方法讲解也很到位,特别适合参加Java面试的朋友阅读。
  • 一步步带你用Java实现双向链表(超详细)

    千次阅读 热门讨论 2022-04-21 10:44:53
    文章目录什么是双向链表属性及方法节点Nodesize数据插入头插法 addFirst(T value)尾插法 addLast(T value)插入到指定下标位置add(int index)数据删除(返回被删除节点存储的值)删除头结点 removeFirst删除尾结点 ...
  • 1.链表(Linked List)介绍链表是有序的列表,但是它在内存存储结构如下:2.特点:链表是以节点的方式来存储,是链式存储每个节点包含 data 域, next 域:指向下一个节点.链表的各个节点不一定是连续存储.链表分带头...
  • JAVA实现环形链表(详解)

    千次阅读 2020-09-22 22:50:10
    关于单链表和双向链表,在之前的LinkedList源码里我已经写过一次了。。。所以这次关于链表的分析就只剩环形链表了 ...那我们就开始写第一步,也就是最开始的一步,创建一个节点类。 public class Node { private
  • 队列是一种特殊的线性表,它只允许在表的前端(front)进行删除操作,只允许在表的后端(rear)进行插入操作,下面介绍一下java使用数组和链表实现队列的示例
  • java -新建list链表并赋值的方法总结

    千次阅读 2020-12-15 10:55:00
    java -新建list链表并赋值的方法总结1、直接初始化并赋值1.1 初始化的同时赋值1.2 先初始化后赋值2、将一个list赋值给另一个list2.1 对象引用的方式赋值2.2 非对象引用的方式赋值 1、直接初始化并赋值 1.1 初始化的...
  • ListNode list=new ListNode() 初始化一个节点,无值,不提倡此种写法。 ListNode list=new ListNode(0) 初始化一个节点值为0的节点,最常用最正规写法 ListNode list=null 为,什么都没有,一般不这么写; ...
  • Java实现双向链表

    千次阅读 2021-06-26 17:19:52
    1、双向链表 1.1 双向链表的每个节点组成包含节点数据,上一个节点(pre),下一个节点(next) 1.2 双向链表节点结构 class Node { //节点数据data int data; Node pre; Node next; public Node(int data)...
  • Java创建链表ListNode及遍历链表

    千次阅读 2020-11-29 10:46:07
    案例:本文主要描述Java创建链表ListNode及遍历链表 一、首先创建一个maven工程,配置依赖包 无特殊依赖 二、开始写入自动化测试代码 class ListNode { //类名 :Java类就是一种自定义的数据结构 int val; //数据 ...
  • 文章目录1. List简介2. LinkedList基础操作3. ArrayList基础操作 1. List简介 ListJava中的一种数据结构。 Collection的接口如下图所示。其中List的接口有ArrayList和LinkedList,分别表示顺序表和...创建链表 //
  • java实现链表_链表简介(Java实现)

    千次阅读 多人点赞 2020-07-15 16:54:52
    java实现链表A linked list is a linear data structure that contains a sequence of elements such that each element has reference to the next element in the sequence. 链表是一个线性数据结构,包含一个元素...
  • Java链表操作

    2022-03-14 10:14:48
    import java.util.LinkedList; public class LinkedListTest { ... // 创建一个链表 LinkedList<Integer> list = new LinkedList<>(); // 添加元素 // 时间复杂度:O(1) list.add(1);
  • 主要介绍了Java中双向链表详解及实例的相关资料,需要的朋友可以参考下
  • Java链表可直接赋值

    2021-12-08 16:21:54
    @Test ... List<String> list1 = new ArrayList<>(); list1.add("A"); list1.add("B"); List<String> list2 = new ArrayList<>(); list2.add("C"); list2.add("D"); .
  • java实现数据结构链表

    2022-04-05 14:16:21
    一、创建链表(以下采用球员信息为案例) 1. 定义FmNode,每个FmNode对象就是一个节点 class FmNode { public int no; public String name; public String club; public FmNode next;//定义该节点指向下一个节点 ...
  • 链表 java 实现

    2022-04-21 14:15:29
    } } // 打印链表 public void list() { // 先判断当前链表是否为 if (head == null) { System.out.println("当前链表,没有数据呐,兄弟"); return; } // 定义一个临时变量辅助遍历 ...
  • 利用java在eclipse中重写一个简单双向循环链表类,并实现创建、插入、删除、获取、输出等简单的操作。
  • 1. 移除链表元素⭐ 2. 翻转/逆置链表⭐ 2.1 头插法 2.2 三指针法 3. 链表的中间结点⭐ 4.链表中倒数第k个结点⭐ 5. 合并两个有序链表⭐ 6. 链表分割⭐ 7.删除链表中重复的结点⭐⭐⭐ 8. 链表的回文结构⭐⭐...
  • 1. 双向链表应用实例 双向链表的操作分析和实现 使用带 head 头的双向链表实现------水浒英雄排行榜 管理单向链表的缺点分析 单向链表,查找的方向只能是一个方向,而双向链表可以向前或者向后查找。 单向链表...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 103,341
精华内容 41,336
热门标签
关键字:

java创建空链表list