精华内容
下载资源
问答
  • Java单向链表实现

    2020-08-16 17:32:04
    Java单向链表实现 >1. 创建一个Node类: package com.shengsiyuan; public class Node { String data; //存放节点数据本身 Node next; //存放指向下一个节点的引用 public Node(String data) { this....

    Java单向链表实现

    >1. 创建一个Node类:

    package com.shengsiyuan;
    
    public class Node
    {
       String data; //存放节点数据本身
       
       Node next; //存放指向下一个节点的引用
       public Node(String data)
       {
    	   this.data = data;
       }
    }
    

    > 2.创建NodeTest来实现单向链表:

    package com.shengsiyuan;
    
    public class NodeTest
    {
       public static void main(String[] args)
       {
    	      Node node1 = new Node("node1");
    	      Node node2 = new Node("node2");
    	      Node node3 = new Node("node3");
    	      Node node4 = new Node("node4");
    	      
    	      node1.next = node2;
    	      node2.next = node3;
    	      
    	      System.out.println(node1.next.next.data);
    	      System.out.println("--------------------");
    	      
    	      node1.next = node4;
    	      node4.next = node2;
    	      node2.next = node3;
    	      
    	      System.out.println(node1.next.next.next.data
    	    		  );
    	      
    	      System.out.println("-----------------------");
    	      
    	      node1.next = node2;
    	      node4 = null;
    	      
    	      System.out.println(node1.next.next.data);
    	      
       }
    }
    

    > 3.代码运行结果如下:
    在这里插入图片描述

    展开全文
  • JAVA单向链表实现

    2019-02-25 20:56:00
    JAVA单向链表实现 单向链表 链表和数组一样是一种最常用的线性数据结构,两者各有优缺点。数组我们知道是在内存上的一块连续的空间构成,所以其元素访问可以通过下标进行,随机访问速度很快,但数组也有其缺点,...

    JAVA单向链表实现

    单向链表

    链表和数组一样是一种最常用的线性数据结构,两者各有优缺点。数组我们知道是在内存上的一块连续的空间构成,所以其元素访问可以通过下标进行,随机访问速度很快,但数组也有其缺点,由于数组的内存是一次性申请的,就像基本数据类型一样,一次性申请所需的空间,在数据量变动很大的时候就容易导致预先申请的内存不够或内存浪费。在者就是在存的是有序数列时进行数据插入会比较麻烦,所以链表就是为了弥补数组的不足的一种数据结构。相反的,链表对于变动很大的数据有很大的适应性,而且其对于数据插入和删除很方便。而链表的缺点就是对于内存的浪费,链表除了存储需要的数据还要存储额外的指针。链表的节点示意图如下:

     

    看到指针你可能会想:“我们这不是java语言吗?没有指针啊!”,没错!在我对java了解不是很深的时候我也这么想,但是我要说的是java虽然不允许程序员像c/c++那样使用指针,但java语言本身的实现还是离不开指针的(变量名其实就是指向jvm中一块内存的指针,我就不详述)。请看以下节点的代码:

    //节点数据结构
    private class Node{
    private Object data=null;//数据域
    private Node next=null;//下一个节点
    private Node(Object data) {
    this.data=data;
    }
    }

    这里的节点class我是写成inner class的形式,后面有完整代码。还有一点就是这里object类型,这里也可以使用泛型

    //链表数据结构
    public class SingleLinkList {
    int size=0;//链表长度,可有可无,有的话很容易实现很多链表的特殊操作
    Node head=null;//头节点
    public SingleLinkList() {
    this.size=0;this.head=null;
    }
    }

    有了这两个类,然后再来实现链表的一些基本操作:插入头节点,删除头节点,删除指定节点,查找指定节点。直接看完整源代码。

    package singleLinkList;

    public class SingleLinkList {

    int size=0;//链表长度
    Node head=null;

    public SingleLinkList() {
    this.size=0;this.head=null;
    }

    //节点数据结构
    private class Node{
    private Object data=null;//数据域
    private Node next=null;//下一个节点
    private Node(Object data) {
    this.data=data;
    }
    }

    //表头添加元素
    public Object addHead(Object data) {
    Node newHead=new Node(data);
    if(size==0) {
    this.head=newHead;
    }
    else {
    newHead.next=this.head;
    this.head=newHead;
    }
    size++;
    return data;
    }

    //删除表头元素
    public Object deleteHead() {
    if(size>0) {
    Node node=this.head;
    this.head=this.head.next;
    size--;
    }
    return null;
    }

    //查找指定元素
    public Node findData(Object data) {
    if(size==0)return null;
    Node cur=this.head;

    转载于:https://www.cnblogs.com/Davidhwj/p/10433387.html

    展开全文
  • java 单向链表实现

    2016-03-04 14:17:25
    链表是一种常用的数据结构,理解了链表的结构和原理,我们也可以使用java实现一个简易的链表,麻雀虽小五脏俱全,o(^▽^)opackage com.basic.alogrithm;public class BasicLink { public static void main(String...

    链表是一种常用的数据结构,理解了链表的结构和原理,我们也可以使用java来实现一个简易的链表,麻雀虽小五脏俱全,o(^▽^)o

    package com.basic.alogrithm;
    
    public class BasicLink {
        public static void main(String[] args) {
            Link<Integer> tests = new Link<Integer>();
            tests.add(4);
            tests.add(3);
            tests.add(5);
            tests.add(4);
            tests.add(6);
            tests.add(4);
            // tests.add(null); // 异常
            System.out.println(tests.size);
            // System.out.println(tests.get(tests.size)); // 异常
            tests.remove(4);
            System.out.println(tests.size);
            System.out.println(tests.get(0));
            System.out.println(tests.get(1));
            System.out.println(tests.get(2));
        }
    }
    
    class Link<E> {
        static class Node<E> {
            private E value;
            private Node<E> next;
    
            public Node(E e) {
                this.value = e;
                this.next = null;
            }
        }
        int size = 0;
        Node<E> header = new Node<E>(null);
    
        void add(E e) {
            if (e == null) {
                throw new NullPointerException("e == null");
            }
            Node<E> node = new Node<E>(e);
            node.next = header.next;
            header.next = node;
            size++;
        }
    
        void remove(E e) {
            Node<E> prev = header;
            Node<E> node = header.next;
            while (node != null) {
                if (node.value.equals(e)) {
                    Node<E> tmp = node;
                    prev.next = node.next;
                    node = prev.next;
                    tmp.next = null; // for gc
                    size--;
                } else {
                    prev = node;
                    node = node.next;
                }
            }
        }
    
        E get(int index) {
            if (index < 0 || index >= size) {
                throw new IndexOutOfBoundsException("index < 0 || index >= size");
            }
            int i = 0;
            Node<E> n = header.next;
            for (;n != null; ) {
                if (i == index) {
                    return n.value;
                }
                n=n.next;
                i++;
            }
            return null;
        }
    
        int size() {
            return size;
        }
    }
    展开全文
  • java单向链表实现实例。需要的朋友可以过来参考下,希望对大家有所帮助
  • Java单向链表实现

    2021-03-03 08:01:44
    Java单向链表实现 链表节点的定义 可以根据情况自行修改,这里number从小到大递增; class PersonNode { // number是值,从小到大;可以根据需要调节 public int number; public String name; public String ...

    Java单向链表的实现

    链表节点的定义

    可以根据情况自行修改,这里number从小到大递增;

    class PersonNode {
        // number是值,从小到大;可以根据需要调节
        public int number;
        public String name;
        public String nickName;
        public PersonNode next;
    
        /**
         * 构造函数
         * @param number
         * @param name
         * @param nickName
         */
        public PersonNode(int number, String name, String nickName) {
            this.number = number;
            this.name = name;
            this.nickName = nickName;
        }
    
    
        @Override
        public String toString() {
            return "PersonNode{" +
                    "number=" + number +
                    ", name='" + name + '\'' +
                    ", nickName='" + nickName + '\'' +
                    '}';
        }
    }
    

    链表的基本结构

    在这里插入图片描述

    节点的增加

    节点的增加分两种,一种是尾部的增加,一种是从中间插入

    /**
         * 在链表的尾部插入
         * @param personNode
         */
        public void addNode(PersonNode personNode) {
            // 首先遍历
            PersonNode tmp = headNode;
            while (true) {
                if (tmp.next == null) {
                    break;
                }
                tmp = tmp.next;
            }
            // 将personNode添加到尾部
            tmp.next = personNode;
        }
    
    

    从中间插入的核心就是找到tmp的next节点的位置是要插入的,那么就让personNode.next = tmp.next; 然后tmp.next = personNode

    /**
         * 在链表按number顺序插入
         * @param personNode
         */
        public void addByOrder(PersonNode personNode) {
            // 定义插入标识符
            boolean flag = false;
            PersonNode tmp = headNode;
            while (true) {
                // 边界条件
                if (tmp.next == null) {
                    break;
                }
                if (tmp.next.number > personNode.number) {
                    break;
                } else if (tmp.next.number == personNode.number) {
                    flag = true;
                    break;
                }
                tmp = tmp.next;
            }
            if (flag) {
                System.out.println("已经存在节点");
            } else {
                // 核心代码
                personNode.next = tmp.next;
                tmp.next = personNode;
            }
        }
    
    

    节点的删除

    /**
         * 删除某一个节点:先根据number查找,在删除
         * @param personNode
         */
        public void delete(PersonNode personNode) {
            // 定义删除标识符
            boolean flag = false;
            PersonNode tmp = headNode;
            while (true) {
                // 边界条件
                if (tmp.next == null) {
                    break;
                }
                // 遍历到要删除节点位置的上一个位置
                if (tmp.next.number == personNode.number) {
                    flag = true;
                    break;
                }
                tmp = tmp.next;
            }
            if (flag) {
                tmp.next = tmp.next.next;
    
            } else {
                System.out.println("没有对应可以删除节点");
            }
        }
    
    

    节点的修改

    /**
         * 修改节点信息
         * @param personNode
         */
        public void update(PersonNode personNode) {
            // 定义插入标识符
            boolean flag = false;
            PersonNode tmp = headNode;
            while (true) {
                // 边界条件
                if (tmp.next == null) {
                    break;
                }
                if (tmp.next.number > personNode.number) {
                    break;
                } else if (tmp.next.number == personNode.number) {
                    flag = true;
                    break;
                }
                tmp = tmp.next;
            }
            if (flag) {
                // 修改相关信息
                tmp.next.nickName = personNode.nickName;
                tmp.next.name = personNode.name;
            } else {
                System.out.println("找不到节点");
            }
        }
    
    

    链表的遍历

    可以根据条件输出需要的节点的信息

    /**
         * 显示链表中的有效节点,遍历链表
         * @param personNode
         */
        public void show(PersonNode personNode) {
            // 注意,此时的personNode是链表
            if (personNode.next == null) {
                System.out.println("该链表是空的");
            }
            PersonNode tmp = personNode;
            while (true) {
                if (tmp.next == null) {
                    break;
                }
                tmp = tmp.next;
                System.out.println(tmp.toString());
            }
        }
    

    下一期 双向链表的实现

    展开全文
  • 单向链表跟单向循环链表的差别就是:单向链表是有结束位的,指向null的时候,就到结尾了,但是单向循环链表,他就是一个圈,要是不设置指定位置,他是会一直转下去的,转着转着就会出现OOM异常了,也就是内存溢出啦...
  • java单向链表实现

    2019-07-31 20:41:40
    一:单向链表基本介绍 链表是一种数据结构,和数组同级。比如,Java中我们使用的ArrayList,其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高,但是插入和删除时优势明显。下面对...
  • java单向链表基本操作简单实现
  • Java实现单向链表反转

    2020-08-27 21:30:19
    主要为大家详细介绍了Java实现单向链表反转,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • javaJava实现单向链表反转.pdf
  • java逆序单向链表实现

    2019-04-28 10:48:14
    假设有一个单向链表,若要将其逆序 ABCDNULL 第一次循环 ANULLBCD 第二次循环 ANULLBCD 第三次循环 ANULLBCD 第四次循环 ANULLBCD java代码如下: public class ReverseChain { private static Node chain; static...
  • [Java]单向链表实现

    2016-04-09 15:31:26
    链表是在数据结构经常见到的一种形式,Java中可以通过引用传递的方式进行实现。...单向链表只能从前向后找。废话少说,上代码。 class Link{ //链表类 class Node{ //节点类定义为内部类 private String
  • Java实现单向链表

    2020-08-12 22:35:01
    Java实现单向链表类Node类SingleLink类Test类类中的方法Node类Single类代码 链表基本的单元是节点Node。 单向链表中每个节点都由两部分组成:存储的数据和下一个节点的内存地址Node。 双向链表则在单向链表的基础上...
  • 单向链表实现以及常见的面试题收录(java代码) Java代码 package com.bingym.linkedlist; import java.util.Stack; public class SingleLinkedListByOrder { //实现单向链表功能:链表的添加add(可以按照编号...
  • java单向链表~其实和c的链表思想差不多package com.oracle.test;import java.util.Iterator;public class SingleLink implements Iterable{ private int size; private Node first;//首节点 /** *
  • Java 单向链表与双向链表之间的区别 https://www.jianshu.com/p/e1f93a66a084
  • Java实现单向链表

    2017-03-16 23:05:45
    Java实现单向链表说明 实现的链表为最简单的单向链表,只作为复习链表的知识 链表的存储的数据为String类型,同时也可以修改为其它类型或自定义类型,但是自定义要实现 compare()方法,用来链表实现类里面的...
  • java实现单向链表

    2019-03-07 23:54:01
    引言 这是我的第一篇博客,本人现在大三,目前学习了javaSE,现在正在学习数据...为了实现单向链表,得实现三个类: 1.结点类:ListNode类 2.单向链表类:SingleLinkList类 3.测试类:testmain类 代码 ListNode类 ...
  • java 单向链表

    2015-04-24 10:44:46
    简单单向链表 [java] view plaincopyprint? class Node{   private String data; //存储当前节点内容   private Node next=null; //存储下一下节点   public Node...
  • java 单向链表实现

    2009-07-26 01:56:00
    public class MyLinkedList { private Node head; //整个链表的头结点 private int listSize; public MyLinkedList() { head = new Node(0); head.next = null; } //内部类,来表示节点 private static class

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,643
精华内容 13,457
关键字:

java单向链表实现

java 订阅