精华内容
下载资源
问答
  • 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单向链表

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

    • 链表优点:随机增删元素效率较高,因为增删元素不涉及大量元素的位移

    • 链表缺点:查询效率低,每一次查找某个元素的时候都要从头节点往下遍历
      在这里插入图片描述

    • 以demo为例解释什么是链表

    1. 首先我们定义一个链表类,其中包含添加、删除、修改、查找等方法。并且定义了头节点header属性和size属性
    package collection;
    
    public class Link {
        //头节点
        Node header = null;
        int size = 0;
    
        public int size(){
            return size;
        }
    
    
        //向链表中添加元素的方法
        public void add(Object data){
            //创建一个新的节点对象
            //让之前单链表的莫为节点的next指向新节点对象
            if (header == null){
                //说明还没有节点
                //创建一个头节点
                header = new Node(data,null);
            }else{
                //说明已经有节点了,就找到末尾节点,在其后添加元素
                Node currentLastNode = findLast(header);
                currentLastNode.next = new Node(data,null);
            }
            size ++;
        }
    
        /**
         * 专门查找末尾节点的方法
         * @param node
         * @return
         */
        private Node findLast(Node node) {
            if (node.next == null){
                return node;
            }
            return findLast(node.next);
        }
    
    
        //向链表中删除元素的方法
        public void remove(Object obj){
        }
    
        //向链表中修改元素的方法
        public void modify(Object obj){
        }
    
        //在链表中查找元素的方法
        public void find(Object obj){
        }
    }
    
    1. 我们需要定义Node类用来定义节点信息,其中包含有参构造和无参构造,并且有两个重要属性:数据内容和下一个节点的地址
    package collection;
    
    public class Node {
        //存储的数据
        Object element;
        //下一个节点的内存
        Node next;
    
        //无参构造
        public Node(){
    
        }
        //有参构造
        public Node(Object element, Node next){
            this.element = element;
            this.next = next;
        }
    }
    
    1. 写一个test类进行简单的测试
    package collection;
    
    public class LinkTest {
        public static void main(String[] args) {
            Link link = new Link();
    
            link.add(1);
            link.add(2);
            link.add(3);
            link.add(4);
            link.add(5);
    
            System.out.println(link.size);//5
    
    
    
    
        }
    }
    
    
    展开全文
  • Java 泛型单向链表

    2021-08-05 11:30:05
    Java哒 单项链表是也 用了泛型的
    // MyList.java in the package
    public interface MyList<T> {
    
     	void push(T element); //向链表中添加元素 @param element 待添加的元素
     
     	boolean contains(T element); //链表中是否存在指定元素
     
     	boolean pop(T element); //删除指定元素 @param element 待删除待元素 
    						 //@return 删除是否成功,如果元素不在链表中,返回 false
     	int size(); //返回链表⻓度
    
    	void reverse(); //反转链表,如 1->2->3->4 反转后是 4->3->2->1
    	
    	//void sort(Comparator<? super T> comparator);  选做,链表排序
    }
    
    public class Main<T> implements MyList<T>{
    
        private static class Node<T> {
            private T data;
            private Node<T> next;
    
            public Node(T data) { this.data = data; }
            public Node<T> getNext() { return next; }
            public void setNext(Node<T> next) { this.next = next; }
            public T getData() { return data; }
            public void setData(T data) { this.data = data; }
        }
    
        private int size;  // 链表长度
        private Node<T> head;  // 头节点
    
        Main() { size = 0;  head = null; }
        
        @Override
        //向链表中添加元素,element为待添加的元素
        public void push(T element) {
            Node<T> newNode = new Node<>(element);
            if(head == null) {
                head = newNode;
            } else {
                Node<T> temp = head;
                while(temp.next != null) {
                    temp = temp.next;
                }
                temp.next = newNode;
            }
            ++size; //链表长度加1
        }
    
        @Override
        //查找链表中是否存在指定元素
        public boolean contains(T element) {
            Node<T> p = head; // 定义链表查找指针
            while(p != null) {
                if (p.data == element) {
                    return true; // 成功找到该元素,返回true
                } else {
                    p = p.next;
                }
            }
            return false;
        }
    
        @Override
        // 删除指定的元素;删除成功返回true,没找到元素返回false
        public boolean pop(T element) {
            if(head.data == element) { // 如果待删除元素在头节点中
                head = head.next; // 让头节点的下一个节点做头节点(删除头节点)
                --size;
                return true;
            } else { // 如果待删除元素不在头节点中
                Node<T> p = head; // 定义链表查找指针
                while (p.next != null) {
                    if (p.next.data == element) {
                        p.next = p.next.next;
                        --size;
                        return true;
                    } else {
                        p = p.next;
                    }
                }
                return false;
            }
        }
    
        @Override
        public int size() {
            return size;
        }
    
        @Override
        public void reverse() {
            if(head == null || head.getNext() == null)
                return ;  //return head;
            Node<T> pre = head;
            Node<T> cur = head.getNext();
            Node<T> tmp;
            while(cur != null) {
                tmp = cur.getNext();
                cur.setNext(pre);
                pre = cur;
                cur = tmp;
            }
            head.setNext(null);
            head = pre;
        }
    
        // 测试int型数据的main函数
        public static void main(String[] args) {
            Main<Integer> a = new Main<>();
            Node<Integer> p = null;
    
            System.out.println("\t测试size()方法");
            System.out.println("Size = " + a.size());
    
            System.out.println("\t测试push()方法");
            a.push(1);  a.push(2);  a.push(3);  a.push(4);  a.push(5);
            System.out.println("Size = " + a.size());
            p = a.head;
            while(p != null) {
                System.out.print(p.getData() + "\t");
                p = p.next;
            }
    
            System.out.println("\n\t测试contains()方法");
            if(a.contains(3)) System.out.println("链表中存在元素3");
            else System.out.println("链表中不存在元素3");
            if(a.contains(8)) System.out.println("链表中存在元素8");
            else System.out.println("链表中不存在元素8");
    
            System.out.println("\t测试pop()方法");
            if(a.pop(6)) System.out.println("链表删除了元素6");
            else System.out.println("链表中不含有元素6,删除失败(待删除元素不在链表中)");
            System.out.println("Size = " + a.size());
            if(a.pop(1)) System.out.println("链表删除了元素1(待删除元素在头节点)");
            else System.out.println("链表中不含有元素1");
            System.out.println("Size = " + a.size());
            if(a.pop(4)) System.out.println("链表删除了元素4(待删除元素不在头节点)");
            else System.out.println("链表中不含有元素4");
            System.out.println("Size = " + a.size());
            p = a.head;
            while(p != null) {
                System.out.print(p.getData() + "\t");
                p = p.next;
            }
    
            System.out.println("\n\t测试reverse()方法");
            a.reverse(); // 反转链表
            p = a.head;
            while(p != null) {
                System.out.print(p.getData() + "\t");
                p = p.next;
            }
        }
    }
    
    运行结果:
    	测试size()方法
    Size = 0
    	测试push()方法
    Size = 5
    1	2	3	4	5	
    	测试contains()方法
    链表中存在元素3
    链表中不存在元素8
    	测试pop()方法
    链表中不含有元素6,删除失败(待删除元素不在链表中)
    Size = 5
    链表删除了元素1(待删除元素在头节点)
    Size = 4
    链表删除了元素4(待删除元素不在头节点)
    Size = 3
    2	3	5	
    	测试reverse()方法
    5	3	2
    
    • 对于reverse()方法,还可以用递归实现:
    public Node<T> reverse(Node<T> head) {
        if(head == null || head.getNext() == null) {
            return ; //空链表或者单个节点的链表则直接返回
        }
        // 递归反转 空间复杂度较大
        Node<T> rev = reverse(head.getNext()); //找到链表的最后一个节点,此时head为原链表倒数第二个节点,rev为原链表最后一个节点
        head.getNext().setNext(head); // 1->2->3->4->5 变为 5->4和1->2->3->4
        head.setNext(null);
        return rev;
    }
    在方法外用: head = reserve(head); 即可实现链表的反转
    当链表长度较长时,递归反转链表的内存空间占用率过高,可能会导致程序崩溃,因此未选择该种方法
    
    展开全文
  • Java实现单向链表操作 定义结点 public class Node { Object data; Node next; } 定义链表 public class Linked { Node head; //头 Node tail; //尾 //构造方法 public Linked() { head = new Node()...
  • JAVA实现单向链表

    2020-05-16 17:40:44
    最近在学习LinkedList的相关知识,中间有用到链表,在看了JAVA3y大哥的文章后收到启发,也想自己实现一下,中间为了 简单起见用int变量来表示数据。 自定义了一个类用来表示链表的节点 public class Node { ...
  • Java实现单向链表功能

    千次阅读 2018-09-01 11:51:07
    前言 HaspMap的使用频率非常高,相信在每一个Java项目都能见到HashMap的身影。...想要弄清楚HashMap,首先数组和链表有一定的了解,相信大家都十分了解数组,那么下面重点实现一下单向链表的...
  • 单向链表定义 我们可以定义一个类,ListNode,属性next(下一节点的引用),value(存储当前节点的值)单链表定义如下: class ListNode { int val; ListNode next;//引用指向下一节点 Li...
  •  在讲解完了单向链表了以后,单向循环链表就非常简单了,单向循环链表的特点是最后一个节点的指针域为head,所以在一些判断的过程中就需要把null该为head就可以了。一起来看看有什么变化 节点类的数据结构是相同...
  • java实现单向链表——按顺序添加 链表的介绍: 链表是以节点的方式来存储,是链式存储 每个节点包含data域,next域:指向下一个节点 链表的各个节点不一定是连续存储的 链表分为带头节点的链表和没有头节点的链表,...
  • JAVA 实现带头结点的链表根据节点大小按顺序新增、修改、删除节点该文章已实现单向链表的创建及遍历等操作。 那么在此基础上,如何实现单向链表的反转呢? 实现思路: 1. 先定义一个节点 reverseHead = new ...
  • Java 实现单向链表

    2015-09-27 17:04:12
    Java 类库中其实是提供了链表的实现类的,但是如果自己来实现会不会很有成就感呢? 我们知道,Java 官方是没有指针的概念的,当然我们可以把对象的引用理解为指针,虽然与 C 或 C++ 中的指针概念不尽相同。既然如此...
  • Java 手写单向链表

    2021-04-26 14:54:40
    public class ... //定义一个头节点 Node head; //链表的长度 int size; class Node { //真实数据 int data; //next指针,指向下一个节点对象 Node next; //构造函数 public Node(int data) {
  • 数据结构与算法——Java实现单向链表的增删改查 单向链表增删改查,通过no进行插入排序 //定义SingleLinkedList管理单链表 class SingleLinkedList { //先初始化一个头节点,头节点不要随意修改 private ...
  • 使用Java实现单向链表,并完成链表反转。 算法和数据结构是程序员逃不过的一个坎,所以趁着闲余时间,开始学习基础的算法和数据结构。这里记录下自己实现简单的单项链表的过程,如有错误,敬请指正。 明确需求 在...
  • [Java]单向链表实现

    2016-04-09 15:31:26
    链表是在数据结构经常见到的一种形式,Java中可以通过引用传递的方式进行实现。...单向链表只能从前向后找。废话少说,上代码。 class Link{ //链表类 class Node{ //节点类定义为内部类 private String
  • 前面我们已经实现了一个简单的单向链表,虽然从功能上来说,它可以满足一个单向链表的基本需求,但如果放在整个Java体系中,这样的链表是无法融入的。在Java体系中,链表属于Collection集合体系下的集合容器(并且...
  • 一、前言 最近在回顾数据结构与算法,有部分的算法题用到了栈的思想,说起栈又不得不说链表了。数组和链表都是线性存储结构的基础,栈和队列都是线性存储结构的应用~ ...数组我们无论是C、Java都会学过: 数...
  • 准备复习数据结构,从链表开始,想着csdn看看别人是咋写的,一搜一大堆...一、单向链表 1、定义链表节点 public class Node { public int data;//数据域 public Node next;//指针域 public Node(int data){ ...
  • java实现单向链表——修改和删除节点 删除节点示意图: 相关代码 /* * 按顺序将元素添加进节点,修改和删除节点 * 并遍历链表 */ public class SingleLinkedListDemo { public static void main(String[] args)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,808
精华内容 7,523
关键字:

java定义单向链表

java 订阅