列車組合的最佳解決方案

Question

最近我回答了我的在線面試測試，其中被問到以下問題

TrainComposition 是通過從左側和右側連接和拆卸貨車來構建的。

例如，如果我們首先從左側連接貨車 7，然后再從左側連接貨車 13，我們將得到兩個貨車的組合（從左到右分別為 13 和 7）。 現在第一個可以從右側分離的貨車是 7 輛，第一個可以從左側分離的貨車是 13 輛。實現一個模擬這個問題的 TrainComposition。

我用雙向鏈表來解決這個問題

class Node

{
    protected int data;
    protected Node next, prev;
    /* Constructor */
    public Node()
    {
        next = null;
        prev = null;
        data = 0;
    }

    /* Constructor */

    public Node(int d, Node n, Node p)
    {
        data = d;
        next = n;
        prev = p;
    }

    /* Function to set link to next node */
    public void setLinkNext(Node n) {
        next = n;
    }
    /* Function to set link to previous node */
    public void setLinkPrev(Node p) {
        prev = p;
    }

    /* Funtion to get link to next node */

    public Node getLinkNext() {
        return next;
    }

    /* Function to get link to previous node */

    public Node getLinkPrev() {
        return prev;
    }

    /* Function to set data to node */
    public void setData(int d) {
        data = d;
    }

    /* Function to get data from node */

    public int getData() {
        return data;
    }
}

public class SortedSearch {
    protected Node start;
    protected Node end;
    public int size;
    /* Constructor */
    public SortedSearch()
    {
        start = null;
        end = null;
        size = 0;
    }
    public boolean isEmpty()
    {
        return start == null;
    }

    public int getSize()
    {
        return size;
    }

    public void attachWagonFromLeft(int wagonId) {
        Node nptr = new Node(wagonId, null, null);
        if (start == null)
        {
            start = nptr;
            end = start;
        }
        else
        {
            start.setLinkPrev(nptr);
            nptr.setLinkNext(start);
            start = nptr;
        }
        size++;
    }
    public void attachWagonFromRight(int wagonId) {
        Node nptr = new Node(wagonId, null, null);
        if (start == null)
        {
            start = nptr;
            end = start;
        }
        else
        {
            nptr.setLinkPrev(end);
            end.setLinkNext(nptr);
            end = nptr;
        }
        size++;
    }
    public int detachWagonFromLeft() {
        int value=0;
        if (size == 1)
        {
            value = start.getData();
            start = null;
            end = null;
            size = 0;
            return value;

        }
        value = start.getData();
        start = start.getLinkNext();
        start.setLinkPrev(null);
        size--;
        return value;
    }

    public int detachWagonFromRight() {
        int value=0;
            value = end.getData();
            end = end.getLinkPrev();
            end.setLinkNext(null);
            size-- ;
            return value;
    }

    public static void main(String[] args) {
        SortedSearch tree = new SortedSearch();
        tree.attachWagonFromLeft(7);
        tree.attachWagonFromLeft(13);
        tree.attachWagonFromLeft(12);
        tree.attachWagonFromLeft(10);
        tree.attachWagonFromLeft(6);
        tree.attachWagonFromLeft(4);
        tree.attachWagonFromLeft(3);
        tree.attachWagonFromLeft(2);
        System.out.println(tree.detachWagonFromRight()); // 7
        System.out.println(tree.detachWagonFromRight()); // 13
        System.out.println(tree.detachWagonFromRight()); // 7
        System.out.println(tree.detachWagonFromRight()); // 13
        System.out.println(tree.detachWagonFromRight()); // 7
        System.out.println(tree.detachWagonFromRight()); // 13

    }
}

並相應地對其進行了測試。 但是提交時說內部測試用例失敗，答案被標記為錯誤。 你能告訴我哪個是這個問題的最佳解決方案嗎？

Answer 1

為什么不直接使用這個簡單的實現呢？

private static class TrainComposition {

  private final Deque<Integer> wagons = new LinkedList<>();

  public void attachLeft(int wagonNumber) {
    wagons.addFirst(wagonNumber);
  }

  public void attachRight(int wagonNumber) {
    wagons.addLast(wagonNumber);
  }

  public void detachLeft() {
    if (!wagons.isEmpty()) {
      wagons.removeFirst(); // Alternative if exception should not be bubbled up: wagons.pollFirst()
    } else {
      throw new IndexOutOfBoundsException("No wagons available");
    }
  }

  public void detachRight() {
    if (!wagons.isEmpty()) {
      wagons.removeLast(); // Alternative if exception should not be bubbled up: wagons.pollLast()
    } else {
      throw new IndexOutOfBoundsException("No wagons available");
    }
  }
}

Answer 2

似乎detachWagonFromRight缺少detachWagonFromLeft具有的檢查：

public int detachWagonFromLeft() {
    int value=0;
    if (size == 1)
    {
        value = start.getData();
        start = null;
        end = null;
        size = 0;
        return value;

    }
    value = start.getData();
    start = start.getLinkNext();
    start.setLinkPrev(null);
    size--;
    return value;
}

public int detachWagonFromRight() {
    int value=0;
        value = end.getData();
        end = end.getLinkPrev();
        end.setLinkNext(null);
        size-- ;
        return value;
}

因此，當您從右側卸下最后一輛貨車時， start仍然指向它

Answer 3

看起來有點“長”，你的解決方案。 我會定義一個名為“train”的對象，它有一個 object.value=number_of_wagons（一個列表）。 然后定義2個方法：

• train.attach(site,number)：使用 append 命令或 insert 命令從所需的一側附加新號碼
• train.detach(site)：刪除列表中的元素，並可能打印出數字。

但是，據我所知（問題的描述也不是很詳細，所以我不知道預期的答案應該是什么）您只能從一側連接貨車，因為發動機在另一側）；）

Answer 4

我希望你做得很好，因為我提出了這個問題，我對 C# 的解決方案如下：

using System;
using System.Collections.Generic;

public class TrainComposition
{
    public List <int> wagon = new List <int> ();

    public void AttachWagonFromLeft(int wagonId)
    {
        wagon.Add(wagonId);
        //throw new NotImplementedException("Waiting to be implemented.");
    }

    public void AttachWagonFromRight(int wagonId)
    {
        wagon.Insert(0, wagonId);
        //throw new NotImplementedException("Waiting to be implemented.");
    }

    public int DetachWagonFromLeft()
    {
        int elem = 0;
        int indexValue = 0;

        elem = wagon[wagon.Count - 1]; // Get the value of the last element

        indexValue = wagon.LastIndexOf(elem); //Get the index the last value

        wagon.RemoveAt(indexValue);// This will remove the part at index 

        return elem;
        //throw new NotImplementedException("Waiting to be implemented.");
    }

    public int DetachWagonFromRight()
    {
        int elem = 0;

        elem = wagon[0];

        wagon.RemoveAt(0);

        return elem;
        //throw new NotImplementedException("Waiting to be implemented.");
    }

    public static void Main(string[] args)
    {
        TrainComposition tree = new TrainComposition();
        tree.AttachWagonFromLeft(7);
        tree.AttachWagonFromLeft(13);
        Console.WriteLine(tree.DetachWagonFromRight()); // 7 
        Console.WriteLine(tree.DetachWagonFromLeft()); // 13
    }
}

Answer 5

import java.util.*;
public class TrainComposition {
    LinkedList<Integer> wagons = new LinkedList<Integer>();
  public static void main(String[] args) {



    TrainComposition tree = new TrainComposition();
    tree.attachWagonFromLeft(7);
    tree.attachWagonFromLeft(13);
    System.out.println(tree.detachWagonFromRight()); // 7
    System.out.println(tree.detachWagonFromLeft()); // 13
}

public void attachWagonFromLeft(int wagonId) {
    wagons.addFirst(wagonId);
   // throw new UnsupportedOperationException("Waiting to be implemented.");
}

public void attachWagonFromRight(int wagonId) {
    wagons.addLast(wagonId);
   // throw new UnsupportedOperationException("Waiting to be implemented.");
}

public int detachWagonFromLeft() {
    if (!wagons.isEmpty()) {
  return wagons.removeFirst();

   } else {
  throw new IndexOutOfBoundsException("No wagons available");
}
}    
 public int detachWagonFromRight() {
    if (!wagons.isEmpty()) {
  return wagons.removeLast();

   } else {
  throw new IndexOutOfBoundsException("No wagons available");
}

}