黑马程序员技术交流社区

标题: 关于链表的删除操作问题 [打印本页]

作者: wuyuecns    时间: 2014-3-28 18:21
标题: 关于链表的删除操作问题
本帖最后由 wuyuecns 于 2014-3-28 22:18 编辑

看书的时候看到个这样的代码,关于链表的删除操作,程序如下:
public void deleteNode(String data){                // 删除节点
                if(this.contains(data)){        // 判断节点是否存在
                        // 一定要判断此元素现在是不是根元素相等的
                        if(this.root.data.equals(data)){        // 内容是根节点
                                this.root = this.root.next ;        // 修改根节点,将第一个节点设置成根节点
                        }else{
                                this.root.next.delete(root,data) ;        // 把下一个节点的前节点和数据一起传入进去
                        }

最后一行,this.root.next.delete(root,data),代码的注释看不明白,哪位高手给解释下什么意思?谢谢!
作者: haixian    时间: 2014-3-28 18:25
你这个方法名写错了,它是一个递归调用,递归遍历,找到要删除的为止。
作者: 阳春烟景    时间: 2014-3-28 18:29
this.root代表当前的根结点,this.root.next指把当前的根结点指向下一个节点...this.root.next.delete调用delete方法,括号里的是传入的两个参数 ,一个是结点,另一个一个是数据。。
作者: wuyuecns    时间: 2014-3-28 18:52
阳春烟景 发表于 2014-3-28 18:29
this.root代表当前的根结点,this.root.next指把当前的根结点指向下一个节点...this.root.next.delete调用d ...

为什么要下一个节点删除?我的理解是如果当前节点的数据和要删除的数据不等,该把下一个节点设置为要访问的节点?可是和那个删除操作对不上号?谢谢啊,弯没绕过来
作者: haixian    时间: 2014-3-28 19:18
你应该把代码贴全,应该是当前数据判断不对就移到下一个数据。应该是递归。
作者: wuyuecns    时间: 2014-3-28 19:19
haixian 发表于 2014-3-28 18:25
你这个方法名写错了,它是一个递归调用,递归遍历,找到要删除的为止。

怎么个写错了?不懂。不过好像还真是一个递归,这个类是在一个删除单项链表的程序里面的。
作者: haixian    时间: 2014-3-28 19:21
wuyuecns 发表于 2014-3-28 19:19
怎么个写错了?不懂。不过好像还真是一个递归,这个类是在一个删除单项链表的程序里面的。 ...

你把整个类的代码贴一下
作者: wuyuecns    时间: 2014-3-28 19:23
haixian 发表于 2014-3-28 19:21
你把整个类的代码贴一下
  1. class Link{                // 链表的完成类
  2.         class Node{        // 保存每一个节点,此处为了方便直接定义成内部类
  3.                 private String data ;        // 保存节点的内容
  4.                 private Node next ;                // 保存下一个节点
  5.                 public Node(String data){
  6.                         this.data = data ;                // 通过构造方法设置节点内容
  7.                 }
  8.                 public void add(Node newNode){                // 将节点加入到合适的位置
  9.                         if(this.next==null){                        // 如果下一个节点为空,则把新节点设置在next的位置上
  10.                                 this.next = newNode ;
  11.                         }else{                // 如果不为空,则需要向下继续找next
  12.                                 this.next.add(newNode) ;
  13.                         }
  14.                 }
  15.                 public void print(){
  16.                         System.out.print(this.data + "\t") ;        // 输出节点内容
  17.                         if(this.next!=null){                // 还有下一个元素,需要继续输出
  18.                                 this.next.print() ;        // 下一个节点继续调用print
  19.                         }
  20.                 }
  21.                 public boolean search(String data){        // 内部搜索的方法
  22.                         if(data.equals(this.data)){                // 判断输入的数据是否和当前节点的数据一致
  23.                                 return true ;
  24.                         }else{        // 向下继续判断
  25.                                 if(this.next!=null){        // 下一个节点如果存在,则继续查找
  26.                                         return this.next.search(data) ;        // 返回下一个的查询结果
  27.                                 }else{
  28.                                         return false ;                // 如果所有的节点都查询完之后,没有内容相等,则返回false
  29.                                 }
  30.                         }
  31.                 }
  32.                 public void delete(Node previous,String data){
  33.                         if(data.equals(this.data)){        // 找到了匹配的节点
  34.                                 previous.next = this.next ;        // 空出当前的节点
  35.                         }else{
  36.                                 if(this.next!=null){        // 还是存在下一个节点
  37.                                         this.next.delete(this,data) ;        // 继续查找
  38.                                 }
  39.                         }
  40.                 }
  41.         };
  42.         private Node root ;                // 链表中必然存在一个根节点
  43.         public void addNode(String data){        // 增加节点
  44.                 Node newNode = new Node(data) ;        // 定义新的节点
  45.                 if(this.root==null){                        // 没有根节点
  46.                         this.root = newNode ;        // 将第一个节点设置成根节点
  47.                 }else{                // 不是根节点,放到最后一个节点之后
  48.                         this.root.add(newNode) ;        // 通过Node自动安排此节点放的位置
  49.                 }
  50.         }
  51.         public void printNode(){                // 输出全部的链表内容
  52.                 if(this.root!=null){                // 如果根元素不为空
  53.                         this.root.print() ;        // 调用Node类中的输出操作
  54.                 }
  55.         }
  56.         public boolean contains(String name){        // 判断元素是否存在
  57.                 return this.root.search(name) ;        // 调用Node类中的查找方法
  58.         }
  59.         public void deleteNode(String data){                // 删除节点
  60.                 if(this.contains(data)){        // 判断节点是否存在
  61.                         // 一定要判断此元素现在是不是根元素相等的
  62.                         if(this.root.data.equals(data)){        // 内容是根节点
  63.                                 this.root = this.root.next ;        // 修改根节点,将第一个节点设置成根节点
  64.                         }else{
  65.                                 this.root.next.delete(root,data) ;        // 把下一个节点的前节点和数据一起传入进去
  66.                         }
  67.                 }
  68.         }
  69. };
  70. public class LinkDemo02{
  71.         public static void main(String args[]){
  72.                 Link l = new Link() ;
  73.                 l.addNode("A") ;                // 增加节点
  74.                 l.addNode("B") ;                // 增加节点
  75.                 l.addNode("C") ;                // 增加节点
  76.                 l.addNode("D") ;                // 增加节点
  77.                 l.addNode("E") ;                // 增加节点
  78.                 System.out.println("======= 删除之前 ========") ;
  79.                 l.printNode() ;
  80.                 // System.out.println(l.contains("X")) ;
  81.                 l.deleteNode("C") ;                // 删除节点
  82.                 l.deleteNode("D") ;                // 删除节点
  83.                 l.deleteNode("A") ;                // 删除节点
  84.                 System.out.println("\n====== 删除之后 =========") ;
  85.                 l.printNode() ;
  86.                 System.out.println("\n查询节点:" + l.contains("B")) ;
  87.         }
  88. };
复制代码

作者: haixian    时间: 2014-3-28 19:42
wuyuecns 发表于 2014-3-28 19:23

这个delete方法是一个递归。这行就是调这个delete方法啊。。。。。。
作者: haixian    时间: 2014-3-28 19:44
wuyuecns 发表于 2014-3-28 19:23

因为链表删除的时候,不仅要删除数据还要修改前一个节点的next引用,所以删除的时候要把previous传进去。
作者: wuyuecns    时间: 2014-3-28 20:28
haixian 发表于 2014-3-28 19:44
因为链表删除的时候,不仅要删除数据还要修改前一个节点的next引用,所以删除的时候要把previous传进去。 ...

就是说那个类里面,else后面的this.root.next.delete(root,data),这个删除操作的意思是,因为当前的节点数据不等于要删除的那个值,所以用this.root.next.delete来删除掉现在的节点,从而指向下一个节点,对吗?




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2