精华内容
下载资源
问答
  • 双向链表 ...下面完成双向链表中完成num的顺序调价元素的方法。 我用学生节点做例子: 学生类: package doubleLinkedList; public class Student { public int num; public String name; Student

    双向链表
    双向链表和单链表的区别:
    单链表只有一个指向下一个元素的引用next,而双向链表还多一个指向前一个元素的引用pre。在单链表中如果想操作下一个元素必须都得找到下一个元素的上一个元素,用上一个元素来操作。而双链表则不需要。
    下面完成双向链表中完成按num的顺序调价元素的方法。
    我用学生节点做例子:
    学生类:

    package doubleLinkedList;
    
    public class Student {
    	public int num;
    	public String name;
    	Student next ;//指向下一个元素、
    	Student pre;//指向上一个元素
    	
    	public Student(int num,String name){
    		this.num = num;
    		this.name = name;
    	}
    	public Student(){}
    	
    	@Override
    	public String toString() {
    		return "[num=" + num + ", name=" + name + "]";
    	}
    	
    }
    
    
    

    双链表类:

    package doubleLinkedList;
    public class DoubleLinkedStudent {
    	Student head = new Student(0, " ");
    	// 在双链表中按照num顺序添加一个元素
    	public void add(Student s) {
    		Student temp = head;
    		boolean flag = false;
    		boolean flag1 = false;
    		while (true) {
    			if (temp.num > s.num) {
    				break;
    			}//:注意这个判断一定要写在第三个判断前面
    			if (temp.next == null) {
    				flag1 = true;
    				break;
    			}
    			if (temp.num == s.num) {
    				flag = true;
    			}			
    			temp = temp.next;
    		}
    		if (flag) {
    			System.out.println(s.num + "这个编号已经存在");
    		} else if (flag1) {
    			temp.next = s;
    			s.pre = temp;
    		} else {
    			s.next = temp;
    			temp.pre.next = s;
    			s.pre = temp.pre;
    			temp.pre = s;
    			
    		}
    	}
    
    	// 遍历双链表
    	public void see() {
    		Student temp = head.next;
    		while (true) {
    			if (temp == null) {
    				break;
    			}
    			System.out.println(temp);
    			temp = temp.next;
    		}
    	}
    }
    

    测试类:

    package doubleLinkedList;
    public class Demo {
    	public static void main(String[] args) {
    		Student st1 = new Student(1,"坤坤");
    		Student st2 = new Student(2,"昊奇");
    		Student st3 = new Student(3,"思路");
    		Student st4 = new Student(5,"赵稳");
    		Student st5 = new Student(4,"正旺");
    		Student st6 = new Student(4,"文涛");
    		DoubleLinkedStudent l = new DoubleLinkedStudent();
    		l.add(st1);
    		l.add(st2);
    		l.add(st6);
    		l.add(st4);
    		l.add(st3);
    		l.add(st5);
    		l.see();
    		
    	}
    
    
    }
    
    

    结果:
    在这里插入图片描述

    思路
    先遍历原双向链表,如果找到链表中有元素的num比要插入元素的num大着停止然后将该要插入的元素放到链表中,
    或者是找到的同样的num值那么就输出提示信息
    或者链表为空、链表遍历完也没有在链表中找到比要插入的元素还大的元素则把要插入的元素放到链表的最后

    展开全文
  • } if (flag) {// 不能添加,说明编号存在 System.out.printf("准备插入的英雄的编号%d已经存在了,不能加入\n", heroNode.no); } else { if(temp.next == null){ temp.next = heroNode; ...

    代码如下

    public void addByOrder(HeroNode2 heroNode) {
    
    		HeroNode2 temp = head;
    		boolean flag = false;
    
    		while (true) {
    			if (temp.next == null) {
    				break;
    			}
    			if (temp.next.no > heroNode.no) {
    				break;
    			} else if (temp.next.no == heroNode.no) {
    				flag = true;
    				break;
    			}
    			temp = temp.next;
    		}
    
    		if (flag) {// 不能添加,说明编号存在
    			System.out.printf("准备插入的英雄的编号%d已经存在了,不能加入\n", heroNode.no);
    		} else {
    			if(temp.next == null){
    				temp.next = heroNode;
    				heroNode.pre = temp;
    			}else{
    				//此处是在temp和temp.next中间添加数据
    				heroNode.next = temp.next;
    				temp.next.pre = heroNode;
    				temp.next = heroNode;
    				heroNode.pre = temp;
    			}
    		}
    	}
    
    展开全文
  • 1. 应用场景 当不知道数据量大小的时候,可以使用“链表”来动态储存和处理数据 需要对链表进行反向操作时 2. 思路 分类:(本文使用 “有头...本文章按照节点值的 从小到大 顺序添加 3. 数据结构(类结构):

    1. 应用场景

    • 当不知道数据量大小的时候,可以使用“链表”来动态储存和处理数据
    • 需要对链表进行反向操作时

    2. 思路

    • 分类:(本文使用 “有头节点”)
      • 有头节点 链表
      • 无头节点 链表
    • 存储方式:节点
    • 节点结构
      • 数据域(Data):存储 当前节点数据
      • 地址域1(Next):指向 下一个节点地址
      • 地址域2(Pre):指向 上一个节点地址
      • 头指针:数据域无意义,只有指向下一节点的地址域
      • 不一定 是连续存储
      • 本文章按照节点值的 从小到大 顺序添加
        有序双向链表示意图

    3. 数据结构(类结构):

    【节点 DoubleNode】

    (1)成员变量(Field)

    • data: int,节点所储存的数据
    • nextNode: Node,所指向的下一个节点
    • preNode: Node,所指向的上一个节点
        private int data;
        private DoubleNode nextNode;
        private DoubleNode preNode;
    

    (2)初始化 / 构造器(Constructor)

    • 参数传入节点所要储存的数据
    • 初始化节点数据
        public DoubleNode(int data) {
            this.data = data;
        }
    

    (3)方法(Methods)

    - 三个成员变量的getter和setter

        public int getData() {
            return data;
        }
    
        public void setData(int data) {
            this.data = data;
        }
    
        public DoubleNode getNextNode() {
            return nextNode;
        }
    
        public void setNextNode(DoubleNode nextNode) {
            this.nextNode = nextNode;
        }
    
        public DoubleNode getPreNode() {
            return preNode;
        }
    
        public void setPreNode(DoubleNode preNode) {
            this.preNode = preNode;
        }
    

    - toString方法

        @Override
        public String toString() {
            return "DoubleNode{" +
                    "data=" + data +
                    '}';
        }
    

    【有序双向链表 OrderedDoubleLinkedList】

    (1)成员变量(Field)

    • headPointer: Node,头节点,不储存数据,只通过自身的nextNode负责储存第一个Node的地址。当有序单链表创建时直接实例化,数据域为0。
        private DoubleNode headPointer = new DoubleNode(0);
    

    (2)初始化 / 构造器(Constructor)

    • 默认构造器

    (3)方法(Methods)

    - 添加新节点

    addNode(Node) -> void

    1. 遍历查找插入点
    2. 将新节点插入到当前节点和下一节点之间
        /**
         * 添加新节点到双向链表
         * @param newNode - 要添加的新节点
         */
        public void addNode(DoubleNode newNode) {
            // 1. 遍历查找插入点
            // 1.1 设置节点变量,用来在遍历时储存当前节点
            DoubleNode currentNode = this.headPointer;
            // 1.2 遍历双向链表,寻找插入点,找到时结束遍历
            while (true) {
                // (1) 到达末尾 or 当前节点的next节点值大于新节点值 时,找到插入点(当前值的下一位),结束遍历
                if (currentNode.getNextNode() == null || currentNode.getNextNode().getData() > newNode.getData()) {
                    break;
                }
                // (2) 找到相同值,抛出异常
                else if (currentNode.getNextNode().getData() == newNode.getData()){
                    throw new RuntimeException("The node is existing!");
                }
    
                // (3) 当前节点的next节点值小于新节点值,继续遍历
                currentNode = currentNode.getNextNode();
            }
    
            // 2. 将新节点插入到当前节点和下一节点之间
            // 2.1 设置临时节点变量,用来储存当前节点的下一节点
            DoubleNode nextNode = currentNode.getNextNode();
            // 2.2 连接当前节点和新节点
            currentNode.setNextNode(newNode);
            newNode.setPreNode(currentNode);
            // 2.3 连接当前节点和next节点
            if (nextNode != null) {
                newNode.setNextNode(nextNode);
                nextNode.setPreNode(newNode);
            }
        }
    

    - 查找某节点是否存在

    isNodeExist(Node) -> boolean

    1. 若链表为空,抛出异常
    2. 遍历查找相同值
    3. 返回boolean变量
        /**
         * 查找节点是否存在于双向链表中
         * @param node - 要查找的节点
         * @return boolean - 是否存在
         */
        public boolean isNodeExist(DoubleNode node) {
            // 1. 若链表为空,抛出异常
            if (this.headPointer.getNextNode() == null) {
                throw new RuntimeException("The list is empty! ");
            }
    
            // 2. 遍历查找相同值
            // 2.1 设置boolean变量,用来标识是否找到相同值
            boolean found = false;
            // 2.2 设置节点变量,用来在遍历时储存当前节点
            DoubleNode currentNode = this.headPointer.getNextNode();
            // 2.3 循环遍历,查找相同值,找到or到达末尾时,结束遍历
            while (currentNode != null) {
                // (1) 若当前节点值等于输入节点值,boolean变量设置为true,结束遍历
                if (currentNode.getData() == node.getData()) {
                    found = true;
                    break;
                }
    
                // (2) 否则移动到下一节点,继续循环
                currentNode = currentNode.getNextNode();
            }
    
            // 3. 返回boolean变量
            return found;
        }
    

    - 删除某节点

    deleteNode(Node) -> void

    1. 若链表为空,抛出异常
    2. 遍历查找待删除节点,找到后删除(无需辅助节点,直接删除)
        /**
         * 删除双向链表中的某节点
         * @param node -- 要删除的节点
         */
        public void deleteNode(DoubleNode node) {
            // 1. 若链表为空,抛出异常
            if (this.headPointer.getNextNode() == null) {
                throw new RuntimeException("The list is empty");
            }
    
            // 2. 遍历查找待删除节点,找到后删除
            // 2.1 设置节点变量,用来在遍历时储存当前节点
            DoubleNode currentNode = this.headPointer.getNextNode();
            // 2.2 循环遍历,查找待删除节点,找到删除,找不到结束循环
            while (currentNode != null) {
                if (currentNode.getData() == node.getData()) {
                    // (1) 设置上一节点的next节点为下一节点
                    currentNode.getPreNode().setNextNode(currentNode.getNextNode());
                    // (2) 若下一节点不为null,设置下一节点的pre节点为上一节点
                    if (currentNode.getNextNode() != null) {
                        currentNode.getNextNode().setPreNode(currentNode.getPreNode());
                    }
                    break;
                }
                currentNode = currentNode.getNextNode();
            }
        }
    

    - 获取全部节点的计数

    countNodes() -> int

    1. 遍历统计节点个数
    2. 返回统计数
        /**
         * 统计双向链表的有效节点数
         * @return int - 有效节点数
         */
        public int countNodes() {
            // 1. 遍历统计节点个数
            // 1.1 设置临时int变量,用来储存节点个数
            int count = 0;
            // 1.2 设置临时节点变量,用来储存当前变量
            DoubleNode currentNode = this.headPointer.getNextNode();
            // 1.3 循环遍历,统计所有节点数
            while (currentNode != null) {
                // count加1
                count++;
                // 移动到下一节点
                currentNode = currentNode.getNextNode();
            }
    
            // 2. 返回统计数
            return count;
        }
    

    - 打印全部节点的数据

    displayAllNodes() -> void

        /**
         * 打印双向链表中的所有节点值
         */
        public void displayAllNode() {
            // 1. 判断链表是否为空,为空抛出异常
            if (this.headPointer.getNextNode() == null) {
                throw new RuntimeException("The double linked list is empty!");
            }
    
            // 2. 设置节点变量,用来在遍历时储存当前节点
            DoubleNode currentNode = this.headPointer.getNextNode();
            // 3. 遍历双向链表,打印每个节点值
            while (currentNode != null) {
                // (1) 打印节点值
                System.out.println(currentNode.toString());
    
                // (2) 移动节点到下一位
                currentNode = currentNode.getNextNode();
            }
    
        }
    

    4. 完整实现

    /**
     * 双向链表(按节点值从小到大添加)
     * @author hoy 
     */
    public class OrderedDoubleLinkedList {
        private DoubleNode headPointer = new DoubleNode(0);
    
        /**
         * 添加新节点到双向链表
         * @param newNode - 要添加的新节点
         */
        public void addNode(DoubleNode newNode) {
            // 1. 遍历查找插入点
            // 1.1 设置节点变量,用来在遍历时储存当前节点
            DoubleNode currentNode = this.headPointer;
            // 1.2 遍历双向链表,寻找插入点,找到时结束遍历
            while (true) {
                // (1) 到达末尾 or 当前节点的next节点值大于新节点值 时,找到插入点(当前值的下一位),结束遍历
                if (currentNode.getNextNode() == null || currentNode.getNextNode().getData() > newNode.getData()) {
                    break;
                }
                // (2) 找到相同值,抛出异常
                else if (currentNode.getNextNode().getData() == newNode.getData()){
                    throw new RuntimeException("The node is existing!");
                }
    
                // (3) 当前节点的next节点值小于新节点值,继续遍历
                currentNode = currentNode.getNextNode();
            }
    
            // 2. 将新节点插入到当前节点和下一节点之间
            // 2.1 设置临时节点变量,用来储存当前节点的下一节点
            DoubleNode nextNode = currentNode.getNextNode();
            // 2.2 连接当前节点和新节点
            currentNode.setNextNode(newNode);
            newNode.setPreNode(currentNode);
            // 2.3 连接当前节点和next节点
            if (nextNode != null) {
                newNode.setNextNode(nextNode);
                nextNode.setPreNode(newNode);
            }
        }
    
        /**
         * 查找节点是否存在于双向链表中
         * @param node - 要查找的节点
         * @return boolean - 是否存在
         */
        public boolean isNodeExist(DoubleNode node) {
            // 1. 若链表为空,抛出异常
            if (this.headPointer.getNextNode() == null) {
                throw new RuntimeException("The list is empty! ");
            }
    
            // 2. 遍历查找相同值
            // 2.1 设置boolean变量,用来标识是否找到相同值
            boolean found = false;
            // 2.2 设置节点变量,用来在遍历时储存当前节点
            DoubleNode currentNode = this.headPointer.getNextNode();
            // 2.3 循环遍历,查找相同值,找到or到达末尾时,结束遍历
            while (currentNode != null) {
                // (1) 若当前节点值等于输入节点值,boolean变量设置为true,结束遍历
                if (currentNode.getData() == node.getData()) {
                    found = true;
                    break;
                }
    
                // (2) 否则移动到下一节点,继续循环
                currentNode = currentNode.getNextNode();
            }
    
            // 3. 返回boolean变量
            return found;
        }
    
        /**
         * 统计双向链表的有效节点数
         * @return int - 有效节点数
         */
        public int countNodes() {
            // 1. 遍历统计节点个数
            // 1.1 设置临时int变量,用来储存节点个数
            int count = 0;
            // 1.2 设置临时节点变量,用来储存当前变量
            DoubleNode currentNode = this.headPointer.getNextNode();
            // 1.3 循环遍历,统计所有节点数
            while (currentNode != null) {
                // count加1
                count++;
                // 移动到下一节点
                currentNode = currentNode.getNextNode();
            }
    
            // 2. 返回统计数
            return count;
        }
    
        /**
         * 删除双向链表中的某节点
         * @param node -- 要删除的节点
         */
        public void deleteNode(DoubleNode node) {
            // 1. 若链表为空,抛出异常
            if (this.headPointer.getNextNode() == null) {
                throw new RuntimeException("The list is empty");
            }
    
            // 2. 遍历查找待删除节点,找到后删除
            // 2.1 设置节点变量,用来在遍历时储存当前节点
            DoubleNode currentNode = this.headPointer.getNextNode();
            // 2.2 循环遍历,查找待删除节点,找到删除,找不到结束循环
            while (currentNode != null) {
                if (currentNode.getData() == node.getData()) {
                    // (1) 设置上一节点的next节点为下一节点
                    currentNode.getPreNode().setNextNode(currentNode.getNextNode());
                    // (2) 若下一节点不为null,设置下一节点的pre节点为上一节点
                    if (currentNode.getNextNode() != null) {
                        currentNode.getNextNode().setPreNode(currentNode.getPreNode());
                    }
                    break;
                }
                currentNode = currentNode.getNextNode();
            }
        }
    
        /**
         * 打印双向链表中的所有节点值
         */
        public void displayAllNode() {
            // 1. 判断链表是否为空,为空抛出异常
            if (this.headPointer.getNextNode() == null) {
                throw new RuntimeException("The double linked list is empty!");
            }
    
            // 2. 设置节点变量,用来在遍历时储存当前节点
            DoubleNode currentNode = this.headPointer.getNextNode();
            // 3. 遍历双向链表,打印每个节点值
            while (currentNode != null) {
                // (1) 打印节点值
                System.out.println(currentNode.toString());
    
                // (2) 移动节点到下一位
                currentNode = currentNode.getNextNode();
            }
    
        }
    }
    
    class DoubleNode {
        private int data;
        private DoubleNode nextNode;
        private DoubleNode preNode;
    
        public DoubleNode(int data) {
            this.data = data;
        }
    
        @Override
        public String toString() {
            return "DoubleNode{" +
                    "data=" + data +
                    '}';
        }
    
        public int getData() {
            return data;
        }
    
        public void setData(int data) {
            this.data = data;
        }
    
        public DoubleNode getNextNode() {
            return nextNode;
        }
    
        public void setNextNode(DoubleNode nextNode) {
            this.nextNode = nextNode;
        }
    
        public DoubleNode getPreNode() {
            return preNode;
        }
    
        public void setPreNode(DoubleNode preNode) {
            this.preNode = preNode;
        }
    }
    
    展开全文
  • 一、双向链表(Double Linked List)的修改、删除、查询及编号顺序添加节点到双向链表的代码示例 1、定义一个人员节点类,每一个PersonNode对象就是一个节点 package ...

    一、双向链表(Double Linked List)的修改、删除、查询及按编号顺序添加节点到双向链表的代码示例

    1、定义一个人员节点类,每一个PersonNode对象就是一个节点

    package com.rf.springboot01.dataStructure.doubleLinkedList2;
    
    /**
     * @description: 定义一个人员节点类,每一个PersonNode对象就是一个节点
     * @author: xiaozhi
     * @create: 2020-07-22 21:22
     */
    public class PersonNode3 {
        public int num;//编号
        public String name;//名称
        public String aliasName;//别名
        public PersonNode3 next;//指向下一个节点,默认为null
        public PersonNode3 pre;//指前一个节点,默认为null
    
        //构造器
        public PersonNode3(int num, String name, String aliasName) {
            this.num = num;
            this.name = name;
            this.aliasName = aliasName;
        }
    
        //重写toString方法
        @Override
        public String toString() {
            return "PersonNode{" +
                    "num=" + num +
                    ", name='" + name + '\'' +
                    ", aliasName='" + aliasName + '\'' +
                    '}';
        }
    }
    
    

    2、创建一个双向链表管理人员节点

    package com.rf.springboot01.dataStructure.doubleLinkedList2;
    
    /**
     * @description: 创建一个双向链表管理人员节点
     * @author: xiaozhi
     * @create: 2020-07-22 22:16
     */
    public class DoubleLinkedList3 {
        //先初始化一个头结点,头节点位置固定,不存放任何数据,作用是表示链表的头节点
        private PersonNode3 head =new PersonNode3(0,"","");
    
        public PersonNode3 getHead() {
            return head;
        }
        /**
         * @Description: 按编号顺序添加节点到双向链表
         * @Param:
         * @Author: xz
         * @return:
         * @Date: 2020/7/22 21:28
         */
        public void insertDoubleLinkedList(PersonNode3 personNode3){
            PersonNode3 temp=head;
            boolean flag=false;//插入的编号是否存在,默认不存在
            while(true){
                if(temp.next==null){//已经在链表的尾部
                    break;
                }
                if(temp.next.num >personNode3.num){//找到位置,在temp后添加
                    break;
                }
                if(temp.next.num==personNode3.num){//编号已经存在,不能添加
                    flag=true;
                    break;
                }
                temp=temp.next;//后移,遍历
            }
            if(flag){
                System.out.printf("添加的人员编号%d已经存在,不能添加\n",personNode3.num);
            }else{
                //添加数据到链表中,temp后的位置
                personNode3.next=temp.next;
                temp.next=personNode3;
            }
            //当退出while循环时,temp就指向了链表的最后
            //将最后这个节点temp的next指向新的节点,新节点的pre指向最后个节点temp
            temp.next=personNode3;
            personNode3.pre=temp;
        }
    
        /**
         * @Description: 修改双向链表的节点
         * @Param:
         * @Author: xz
         * @return:
         * @Date: 2020/7/22 21:34
         */
        public void updateDoubleLinkedList(PersonNode3 personNode3){
            if(head.next==null){
                System.out.println("链表为空");
                return;
            }
            //找到需要修改的节点,根据num修改
            PersonNode3 temp=head.next;
            boolean flag=false;//表示是否找到需要修改的节点编号,默认已找到
            while(true){
                if(temp==null){
                    break;//表示已遍历完链表
                }
                if(temp.num==personNode3.num){//已找到需要修改的节点编号
                    flag=true;
                    break;
                }
                temp=temp.next;
            }
            if(flag){//已找到需要修改的节点编号
                temp.name=personNode3.name;
                temp.aliasName=personNode3.aliasName;
            }else{
                System.out.printf("没有找到 编号%d的节点,不能修改\n",personNode3.num);
            }
        }
        /**
         * @Description: 删除双向链表中的一个节点
         * @Param:
         * @Author: xz
         * @return:
         * @Date: 2020/7/22 21:47
         */
        public void deleteDoubleLinkedList(int num){
                if(head.next==null){
                    System.out.println("链表为空,无法删除");
                    return;
                }
                PersonNode3 temp=head.next;//定义一个辅助节点,头节点的后一个节点,即待删除的节点
                boolean flag=false;//标志是否找到待删除节点
                while(true){
                    if (temp==null){//已找到链表最后节点的next域
                        break;
                    }
                    if(temp.num==num){//找到待删除的节点
                        flag=true;
                        break;
                    }
                    temp=temp.next;//临时变量后移
                }
                if(flag){//找到待删除的节点,可以删除
                    temp.pre.next=temp.next;
                    //如果temp是最后一个节点,temp.next=null,会报空指针,所以需要加一个判断
                    if(temp.next!=null){
                        temp.next.pre=temp.pre;
                   }
                }else{//没有找到待删除的节点
                    System.out.printf("要删除的 d% 节点不存在",num);
                }
            }
        /**
         * @Description: 遍历双向链表
         * @Param: []
         * @Author: xz
         * @return: void
         * @Date: 2020/7/22 21:24
         */
        public void selectDoubleLinkedList(){
            //因为头节点不能动,所以需要一个临时变量来遍历
            PersonNode3 temp=head.next;
            //判断链表是否为空
            if(temp==null){
                System.out.println("双向链表为空");
                return;
            }
            //遍历双向链表
            while(true){
                //判断是否到双向链表最后
                if(temp == null){
                    break;
                }
                //输出节点信息
                System.out.println(temp);
                //将temp向后移动
                temp = temp.next;
            }
        }
    }
    
    

    3、定义一个测试类

    package com.rf.springboot01.dataStructure.doubleLinkedList2;
    
    /**
     * @description:
     * @author: xiaozhi
     * @create: 2020-07-22 22:18
     */
    public class DoubleLinkedList3Test {
        public static void main(String[] args) {
            //创建双向链表节点
            PersonNode3 p1 = new PersonNode3(1, "张三", "小张");
            PersonNode3 p2 = new PersonNode3(2, "李四", "小李");
            PersonNode3 p3 = new PersonNode3(3, "王五", "小王");
            PersonNode3 p4 = new PersonNode3(4, "赵二", "小赵");
    
            //添加双向链表节点
            System.out.println("按编号顺序添加节点到双向链表==========");
            DoubleLinkedList3 list = new DoubleLinkedList3();
            list.insertDoubleLinkedList(p1);
            list.insertDoubleLinkedList(p4);
            list.insertDoubleLinkedList(p3);
            list.insertDoubleLinkedList(p2);
            //查询双向链表节点
            list.selectDoubleLinkedList();
    
            System.out.println("修改编号为1的原始双向链表的节点==========");
            //创建一个双向链表节点,根据编号修改原始双向链表的节点
            PersonNode3 p5 = new PersonNode3(1, "java", "学习java");
            list.updateDoubleLinkedList(p5);
            //查询双向链表节点
            list.selectDoubleLinkedList();
    
            System.out.println("删除编号为2的原始双向链表的节点==========");
            list.deleteDoubleLinkedList(2);
            //查询双向链表节点
            list.selectDoubleLinkedList();
        }
    }
    
    

    4、运行测试类,输出结果

    在这里插入图片描述

    展开全文
  • 单向链表查找的方向只能是一个方向,而双向链表可以向前或者向后查找。...2) 添加 (默认添加双向链表的最后) (1) 先找到双向链表的最后这个节点 (2)temp.next=newHeroNode (3)newHeroNode.pre=t..
  • 新建一个双向链表添加节点到双向链表并输出,输出顺序等于编号大小顺序。 一、代码 package linkedlist; /** * 此双链表的头节点不是首节点 * @author Lee * */ //一、 测试类 public class ...
  • 新建一个双向链表添加节点到双向链表并输出,输出顺序等于添加节点顺序。 一、代码 package linkedlist; /** * 此双链表的头节点不是首节点 * @author Lee * */ //一、 测试类 public class DoubleLinkedListDemo ...
  • 修改节点upDate方法7删除方法delete()8.[重点菜]按顺序添加测试总结 前言 双向链表的增删改查,其中难点在于按顺序增加,如何保持节点中指向上一个节点的pre也能被修改成功 提示:以下是本篇文章正文内容,下面案例...
  • 一、链表的基本概念 链表是一种物理上不连续、非顺序的存储结构,...3)查找元素只能按顺序查找 双向链表在单链表的基础上增加了一个指向上一个元素的指针。本篇幅不再分块介绍双向链表。单链表位置:单链表 ...
  • 对于单链表,如果要插入某一个节点或者是删除某一个节点,需要用到一个辅助指针来找到待删除节点的前一个节点,改变它的...具体实现代码如下:(包含:遍历、在末尾添加、按顺序添加、删除操作) package com.Link; p
  • 一、双向链表(Double Linked List)的修改、删除、查询及编号顺序添加节点到双向链表的代码示例1、定义一个人员节点类,每一个PersonNode对象就是一个节点package .../*** @description: 定义一个人员节点类,每一个...
  • C++双向链表电话簿

    2013-05-30 00:04:36
    查看全部数据 删除数据 3) 添加数据(数据姓名顺序排列) 4) 修改数据 5) 查找数据" 6) 从文件中输入数据 7) 将数据输出至文件 8) 退出程序;

空空如也

空空如也

1 2 3 4 5
收藏数 89
精华内容 35
关键字:

双向链表按顺序添加