Question

我用java（下面的代码）创建了自己的链接列表，并试图将文本文件中的DNA？RNA序列存储在包含枚举DNA / RNA以及链接的自定义数据类型的数组中包含实际DNA序列的列表。我不知道这些字符是否只是没有插入到链表中，或者我的toString是否有问题，但是输出仅显示位置和枚举类型，而不显示列表中的序列。代码如下我的节点类

public class Node<E> {
    private Node<E> next;
    protected E data;

    Node(E data,Node<E> nextVal){
        this.data=data;
        next=nextVal;
    }
    Node(Node<E> nextVal){
        next=nextVal;
    }

    Node<E> Next(){
        return next;
    }
    Node<E>setNext(Node<E> nextVal){
        return next=nextVal;
    }
    E data(){
        return data;
    }
    E setData(E it){
        return data=it;
    }
}

我的链表类

    public class MyLinkedList<E> implements List<E>{
    private Node<E> head;
    private Node<E> tail;
    protected Node<E> curr;
    private int size;
    MyLinkedList(int size){
        this();
    }
    MyLinkedList(){
        curr=tail=head=new Node<E>(null);
        size=0;
    }
      @Override
      public void clear() {
        head.setNext(null);
        curr=tail=head=new Node<E>(null);
        size=0;
      }

      @Override
      public void insert(E item) {
        curr.setNext(new Node<E>(item, curr.Next()));
        if(tail==curr)
            tail=curr.Next();
        size++;

      }
      @Override
      public void append(E item) {
        tail=tail.setNext(new Node<E>(item, null));
        size++;
      }

      @Override
      public E remove() {
        if(curr.Next() ==null)
          return null;
        E item=curr.Next().data();
        if(tail==curr.Next())
            tail=curr;
        curr.setNext(curr.Next().Next());
        size--;
        return item;
    }

      @Override
      public void moveToStart() {
        curr =head;
      }

      @Override
      public void moveToEnd() {
        curr=tail;
      }

      @Override
      public void prev() {
        if(curr==head)
            return;
        Node<E> temp=head;
        while (temp.Next()!=curr)
            temp=temp.Next();
        curr=temp;

      }

      @Override
      public void next() {
        if(curr!=tail)
            curr=curr.Next();
      }

      @Override
      public int length() {
          return size;
      }

      @Override
      public int currPos() {
          Node<E>temp=head;
          int i;
          for(i=0;curr!=temp;i++)
              temp.Next();
          return i;

      }

      @Override
      public void moveToPos(int pos) {
        assert (pos>=0)&& (pos<=size):
          "Position out of Range";
        curr=head;
        for(int i=0;i<pos;i++)
            curr.Next();

      }

      @Override
      public E getValue() {
          if(curr.Next()==null)
              return null;
          return curr.Next().data();
      }

      @Override
     public String toString() {
          String result = "";
          Node current = head;
          while(current.Next() != null){
              result += current.data();
              if(current.Next() != null){
                  result += ", ";
              }
              current = current.Next();
          }
          return "" + result;
      }
}

这是SequenceArr类，用于处理上述数组上的操作（此处不完整，但本示例中使用的所有内容）

 public class SequenceArr {
 private TypeSeq [] SeqArr;
 private int size=0;
 private int MAXSIZE;

 public SequenceArr(int MAXSIZE){
     this.MAXSIZE=MAXSIZE;
     SeqArr =new TypeSeq[MAXSIZE];
     size=0;
 }
 public void insert(int pos, Type t, MyLinkedList<Character> seq){
     TypeSeq currentEl=new TypeSeq(t,seq);
     assert pos<=MAXSIZE: "Position over maximum size of array";
     SeqArr[size]=currentEl;
     size++;
    }
 public void remove(int pos){
     if(SeqArr[pos]!=null){
         while(SeqArr[pos+1]!=null){
             SeqArr[pos]=SeqArr[pos+1];
         }
         if(SeqArr[pos+1]==null){
             SeqArr[pos]=null;
         }
      }
     else
         System.out.print("No sequence to remove at specified position");
    }
 public void print(){
     int i=0;
     while (SeqArr[i]!=null){
         System.out.println(i+"\t"+SeqArr[i].getType()+"\t"+SeqArr[i].getBioSeq().toString());
         i++;
     }
    }
 public void print(int pos){
        if(SeqArr[pos]==null)
            System.out.print("No sequence to print at specified position");
        else
            System.out.println(SeqArr[pos].getType()+"\t"+SeqArr[pos].getBioSeq().toString());
    }

我创建的由数组组成的自定义数据类型

public class TypeSeq {
    private Type type;
    private MyLinkedList<Character> BioSeq;
    public TypeSeq(Type type, MyLinkedList<Character> BioSeq){
        this.type=type;
        this.BioSeq=BioSeq;
    }

    public MyLinkedList<Character> getBioSeq() {
        return BioSeq;
    }

    public void setBioSeq(MyLinkedList<Character> bioSeq) {
        BioSeq = bioSeq;
    }

    public Type getType() {
        return type;
    }

    public void setType(Type type) {
        this.type = type;
    }
}

还有我的DNAList类，它处理输入并包含主要方法

    import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class DNAList {
    static SequenceArr seqar;
    public static void main(String []args){
        MyLinkedList<String> hey=new MyLinkedList<>();
        hey.append("Hello");

        int arraysize= Integer.parseInt(args[0]);
        String filePath=args[1];
        File file=new File(filePath);
        seqar=new SequenceArr(arraysize);
        exefromFile(file);

    }

    public static void exefromFile(File file){
        Scanner sc;
        try{
            sc=new Scanner(file);
            while(sc.hasNextLine()){
                String cmd=sc.nextLine();
                if(!cmd.equals(""))
                    execute(cmd);
            }


        }catch (FileNotFoundException e){
            e.printStackTrace();

        }
    }

    public static void execute(String s){
        s=s.trim();
        String [] commands=s.split("\\s+");
        switch (commands[0])
        {
            case "insert":
                int pos=Integer.parseInt(commands[1]);
                Type t=Type.fromString(commands[2]);
                char [] charArr=commands[3].toCharArray();
                MyLinkedList<Character> seq=new MyLinkedList<>(charArr.length);
                char curChar;
                for(int i=0;i<seq.length();i++){
                    curChar=charArr[i];
                    if(t==Type.DNA&&(curChar=='A'||curChar=='C'||curChar=='G'||curChar=='T'))
                        seq.append(charArr[i]);
                    else
                        System.out.print("Error occurred while inserting");
                }
                seqar.insert(pos,t,seq);
                break;
            case "remove":
                pos=Integer.parseInt(commands[1]);
                seqar.remove(pos);
                break;
            case "print":
                if(commands.length>1&&commands[1]!=null){
                    pos=Integer.parseInt(commands[1]);
                    seqar.print(pos);
                }
                else
                    seqar.print();
                break;
            case "clip":
                pos=Integer.parseInt(commands[1]);
                int start =Integer.parseInt(commands[2]);
                int end =Integer.parseInt(commands[3]);
                seqar.clip(pos,start,end);
                break;
            case "copy":
                int pos1=Integer.parseInt(commands[1]);
                int pos2=Integer.parseInt(commands[2]);
                seqar.copy(pos1,pos2);
                break;
            case "transcribe":
                pos=Integer.parseInt(commands[1]);
                seqar.transcribe(pos);
                break;
        }

    }

}

输入的.txt文件将显示类似

插入0个DNA AATTCCGGAATTCCGG

打印

但是输出将只是

0个DNA 并且该序列将不会被打印。有什么想法吗？

Answer 1

代码中有很多错误，下面是一些错误：

MyLinkedList(int size){
    this();
}
MyLinkedList(){
    curr=tail=head=new Node<E>(null);
    size=0;
}

这始终会初始化大小为0的列表。

char [] charArr=commands[3].toCharArray();
            MyLinkedList<Character> seq=new MyLinkedList<> 
(charArr.length);

我不打算每次用4个大小初始化列表。另外请注意，由于总是将其替换为0，因此不会使用给定的大小进行初始化。

@Override
  public void insert(E item) {
    curr.setNext(new Node<E>(item, curr.Next()));
    if(tail==curr)
        tail=curr.Next();
    size++;

  }

您根本没有使用 head 的概念，您的第一次插入是一个特殊情况，需要明智地处理。

 @Override
 public String toString() {
      String result = "";
      Node current = head;
      while(current.Next() != null){
          result += current.data();
          if(current.Next() != null){
              result += ", ";
          }
          current = current.Next();
      }
      return "" + result;
  }

head始终为null，在打印时总是会导致第一个元素为null。此外，当您找到一个节点，该节点的下一个指向null时，则应使用其数据。在代码中，在返回结果之前，您还需要附加最后一个元素的数据。

Java链表实现不会添加数据

1 个答案: