Question

我正在阅读基于位置的序列。（Michael T.Goodrich）第4章（序列）我理解的是，位置序列继续以线性顺序添加节点。（此外，基于双链表），每个节点可以指向一些其他节点例如，采用一个简单的树，其中有四个节点a，b，c，d由位置序列实现.P（具有节点p1，p2，p3，p4）

现在，如果我想添加新的树节点＆＃34; e＆＃34;作为＆＃34; b的正确孩子。＆＃34;为此，我将在p5中添加此节点，然后我将参考e。 Book说它在O（1）时间内添加了一个节点。我的观点是，要将e添加为b的右子，我们不需要b的位置，我们将从＆＃34; a＆＃34;（链接跳跃）的位置获得。怎么不是O（n）。

我在Stackoverflow中找到的解决方案之一就是以下代码......

 public interface Position{
     Object element();
 }

创建一个实现Position接口的类Node：

 public class Node implements Position {

     private Object data;
     private Node next;
     private Node prev;

     public Node(Node prev, Object data, Node next){

         this.prev = prev;
         this.data = data;
         this.next = next;
     }

     public Object element()     // Method of interface Position
     {
         return data;
     }

     public void setData(Object data)
     {
         this.data = data;
     }

     public void setNext(Node next)
     {
         this.next = next;
     }

     public void setPrev(Node prev)
     {
         this.prev = prev;
     }

     public Node getNext()
     {
         return next;
     }

     public Node getPrev()
     {
         return prev;
     }

}

创建一个实现List ADT的类List：

   // this is a List ADT implemented using a Doubly Linked List

public class List{

      private Node first;
      private Node last;
      private int size;

      List()
      {
         first = null;
         last = null;
         size = 0;
      }

      public int getSize()
      {
         return size;
      }

      public boolean isEmpty()
      {
         return (size==0);
      }


     // Accessor methods

     public Position first()
     {
        return first;
     }

     public Position last()
     {
        return last;
     }

     public Position before(Position p) throws Exception
     {
        Node n = (Node) p;
        try{
             return n.getPrev();
        }catch(NullPointerException ex)
        {
             throw new Exception("Position Doesn't Exists");
        }
     }

     public Position after(Position p) throws Exception
     {
          Node n = (Node) p;
          try{
        return n.getNext();
    }catch(NullPointerException ex)
    {
        throw new Exception("Position Doesn't Exists");
    }
}

 // Update methods

public void insertFirst(Object data)
{
    Node node;
    if(isEmpty())
    {
        Node prev = null;
        Node next = null;
        node  = new Node(prev,data,next);
        first = node;
        last = node;
    }
    else
    {
        Node prev = null;
        Node next = first;
        node  = new Node(prev,data,next);
        first.setPrev(node);
        first = node;
    }
    size++;
}

public void insertLast(Object data)
{
    Node node;
    if(isEmpty())
    {
        Node prev = null;
        Node next = null;
        node  = new Node(prev,data,next);
        first = node;
        last = node;
    }
    else
    {
        Node prev = last;
        Node next = null;
        node  = new Node(prev,data,next);
        last.setNext(node);
        last = node;
    }
    size++;
}

public void insertBefore(Position p, Object data) throws Exception
{
    Node cur = (Node) p;
    Node prev;
    try{
        prev = cur.getPrev();
    }catch(NullPointerException ex)
    {
        throw new Exception("Position Doesn't Exists");
    }
    Node next = cur;
    Node node;
    node  = new Node(prev,data,next);
    next.setPrev(node);
    if(cur!=first)
        prev.setNext(node);
    else
        first=node;
    size++;
}

public void insertAfter(Position p, Object data) throws Exception
{
    Node cur = (Node) p;
    Node prev = cur;
    Node next;
    try{
        next = cur.getNext();
    }catch(NullPointerException ex)
    {
        throw new Exception("Position Doesn't Exists");
    }
    Node node;
    node  = new Node(prev,data,next);
    prev.setNext(node);
    if(cur!=last)
        next.setPrev(node);
    else
        last=node;
    size++;
}

public Object remove(Position p) throws Exception
{
    Node n = (Node) p;

    Object data = n.element();
    if(isEmpty())
    {
        throw new Exception("List is Empty");
    }
    else
    {
        Node prev,next;
        if(n==first && n==last)
        {
            first = null;
            last = null;
        }
        else if(n==first)
        {
            prev = null;
            next = n.getNext();
            next.setPrev(prev);
            first = next;
        }
        else if(n==last)
        {
            prev = n.getPrev();
            next = null;
            prev.setNext(next);
            last = prev;
        }
        else
        {
            prev = n.getPrev();
            next = n.getNext();
            prev.setNext(next);
            next.setPrev(prev);             
        }   
        size--;
    }
    return data;
}

 }

和平

Answer 1

我理解这种情况如下。要将新项添加到列表中，我们必须执行任务：

第一个：找到目标项目，之后我们要添加新项目。

第二个：添加项目并更改链接。

正如您所正确指出的，在链表的情况下，第一个操作取决于列表中的项目数量，并且将采用（最大）O（n）。但是，例如在数组列表的情况下，它可以采用O（1）。

我想，当预定目标项目时，本书会说第二项任务。如果你正在使用链表，这个操作真的会采取一定数量的操作 - O（1）。数组列表上的相同操作可以采用O（n）。

关于你的评论。只是比较：

基于位置

get(i)是O（n）
add(item)是O（1）优势
addToPosition(i, item)是O（n）
delete(item)是O（1）优势
delete(i)来自O（1）至O（n）

排名

get(i)是O（1）优势
add(item)来自O（1）至O（n）
addToPosition(i, item)从O（1）到O（n）
delete(item)来自O（1）至O（2n）
delete(i)来自O（1）至O（n）

所以，你应该知道两种类型的优点，根据情况使用它。例如，如果您需要大量的add和delete操作，则应使用LinkedList，但是当您只需按索引访问项目时，add几乎没有和delete操作 - 选择ArrayList。

基于位置的序列ADT如何在O（1）时间内插入元素？

1 个答案: