public static List<List<Integer>> levelOrderBottom(TreeNode root) {
   if (root == null) {
     return new ArrayList<>();
   }
   List<List<Integer>> res = new ArrayList<>();
   List<Integer> level = new ArrayList<>();
   Queue<TreeNode> queue = new LinkedList<>(); // 新建一个queue,用来记录哪些nodes是目前的波前
   queue.add(root); // 向root注水作为波前
   queue.add(null); // 在波前队列queue加null作为Flag代表这层level已访问结束
   while (queue.size() != 0) {
     TreeNode u = queue.poll();
     if (u != null) {
       level.add(u.val);
       /*
        * 波前u向其所有有连同的node扩散
        * u是v的predecessor前驱 or parent
        * v是u的 descendent后记
        * */
       if (u.left != null) {
         queue.add(u.left);
       }
       if (u.right != null) {
         queue.add(u.right);
       }
     } else {
       res.add(level);
       level = new ArrayList<Integer>();
       if (!queue.isEmpty()) {
         queue.add(null);
       }
     }
   }
   Collections.reverse(res);
   return res;
 }
예제 #2
0
  /**
   * put the flip lake tile of the game
   *
   * @param players list of players
   */
  private void setUpLakeTile(Queue<Player> players) {
    Random r = new Random();
    int randomRedLantern = r.nextInt(players.size());
    Queue<Color> color = startLakeTile.getColorOfFourSides();
    // change the current player who get red lantern card
    color.add(color.remove());
    for (int i = 0; i < randomRedLantern; i++) {
      players.add(players.remove());
    }
    int current_number_player = 0;
    // add index to player
    for (int i = 0; i < players.size(); i++) {
      Player p = players.remove();
      p.setIndex(i);
      players.add(p);
    }

    for (Color lantern_color : color) {
      if (current_number_player == players.size()) {
        break;
      } else {
        current_number_player++;
      }
      Player p = players.remove();

      p.getLanternCards().add(supply.get(lantern_color).pop());
      players.add(p);
    }
  }
  // Returns a code tree that is optimal for these frequencies. Always contains at least 2 symbols,
  // to avoid degenerate trees.
  public CodeTree buildCodeTree() {
    // Note that if two nodes have the same frequency, then the tie is broken by which tree contains
    // the lowest symbol. Thus the algorithm is not dependent on how the queue breaks ties.
    Queue<NodeWithFrequency> pqueue = new PriorityQueue<NodeWithFrequency>();

    // Add leaves for symbols with non-zero frequency
    for (int i = 0; i < frequencies.length; i++) {
      if (frequencies[i] > 0) pqueue.add(new NodeWithFrequency(new Leaf(i), i, frequencies[i]));
    }

    // Pad with zero-frequency symbols until queue has at least 2 items
    for (int i = 0; i < frequencies.length && pqueue.size() < 2; i++) {
      if (i >= frequencies.length || frequencies[i] == 0)
        pqueue.add(new NodeWithFrequency(new Leaf(i), i, 0));
    }
    if (pqueue.size() < 2) throw new AssertionError();

    // Repeatedly tie together two nodes with the lowest frequency
    while (pqueue.size() > 1) {
      NodeWithFrequency nf1 = pqueue.remove();
      NodeWithFrequency nf2 = pqueue.remove();
      pqueue.add(
          new NodeWithFrequency(
              new InternalNode(nf1.node, nf2.node),
              Math.min(nf1.lowestSymbol, nf2.lowestSymbol),
              nf1.frequency + nf2.frequency));
    }

    // Return the remaining node
    return new CodeTree((InternalNode) pqueue.remove().node, frequencies.length);
  }
 private void adjustIncomingPosition(Queue<PositionElement> longs, Queue<PositionElement> shorts) {
   if (mIncomingPosition.signum() == 1) {
     longs.add(new PositionElement(mIncomingPosition, mClosingPrice));
   } else if (mIncomingPosition.signum() == -1) {
     shorts.add(new PositionElement(mIncomingPosition.negate(), mClosingPrice));
   }
 }
 private Map<String, File> getAllClasses(String rootDir) {
   File[] arr = new File(rootDir).listFiles();
   Queue<File> toNavigate = new LinkedList<File>();
   Queue<String> toNavigateString = new LinkedList<String>();
   Map<String, File> classMap = new HashMap<String, File>();
   for (File f : arr) {
     toNavigate.add(f);
     toNavigateString.add("");
   }
   while (!toNavigate.isEmpty()) {
     File next = toNavigate.poll();
     String nextString = toNavigateString.poll();
     if (next.isDirectory()) {
       arr = next.listFiles();
       for (File f : arr) {
         toNavigate.add(f);
         toNavigateString.add(nextString + next.getName() + ".");
       }
     } else {
       if (next.getName().endsWith(".class")) {
         System.out.println(nextString + next.getName().substring(0, next.getName().length() - 6));
         classMap.put(nextString + next.getName().substring(0, next.getName().length() - 6), next);
       }
     }
   }
   return classMap;
 }
예제 #6
0
  /**
   * Locate each unexpanded Structure|Sequence and: 1. check that none of its fields is referenced
   * => do not expand 2. add all of its fields as leaves Note that #2 may end up adding additional
   * leaf structs &/or seqs
   */
  public void expand() {
    // Create a queue of unprocessed leaf compounds
    Queue<DapVariable> queue = new ArrayDeque<DapVariable>();

    for (int i = 0; i < variables.size(); i++) {
      DapVariable var = variables.get(i);
      if (!var.isTopLevel()) continue;
      // prime the queue
      if (var.getSort() == DapSort.STRUCTURE || var.getSort() == DapSort.SEQUENCE) {
        DapStructure struct = (DapStructure) var; // remember Sequence subclass Structure
        if (expansionCount(struct) == 0) queue.add(var);
      }
    }
    // Process the queue in prefix order
    while (queue.size() > 0) {
      DapVariable vvstruct = queue.remove();
      DapStructure dstruct = (DapStructure) vvstruct;
      for (DapVariable field : dstruct.getFields()) {
        if (findVariableIndex(field) < 0) {
          // Add field as leaf
          this.segments.add(new Segment(field));
          this.variables.add(field);
        }
        if (field.getSort() == DapSort.STRUCTURE || field.getSort() == DapSort.SEQUENCE) {
          if (expansionCount((DapStructure) field) == 0) queue.add(field);
        }
      }
    }
    this.expansion = Expand.EXPANDED;
  }
예제 #7
0
 static long maxFlow() {
   long totalFlow = 0;
   while (true) {
     Queue<Integer> q = new LinkedList<>();
     int[] parent = new int[cap.length];
     Arrays.fill(parent, -1);
     q.add(s);
     while (!q.isEmpty()) {
       int node = q.poll();
       for (int j = 1; j <= n; j++) {
         if (cap[node][j] - flow[node][j] > 0 && parent[j] == -1) {
           parent[j] = node;
           q.add(j);
         }
       }
     }
     if (parent[t] == -1) break;
     long cflow = Long.MAX_VALUE;
     int current = t;
     while (current != s) {
       cflow = Math.min(cflow, cap[parent[current]][current] - flow[parent[current]][current]);
       current = parent[current];
     }
     current = t;
     while (current != s) {
       flow[parent[current]][current] += cflow;
       flow[current][parent[current]] -= cflow;
       current = parent[current];
     }
     totalFlow += cflow;
   }
   return totalFlow;
 }
예제 #8
0
 /* Creates tree by mapping the array left to right, top to bottom. */
 public static TreeNode createTreeFromArray(int[] array) {
   if (array.length > 0) {
     TreeNode root = new TreeNode(array[0]);
     java.util.Queue<TreeNode> queue = new java.util.LinkedList<TreeNode>();
     queue.add(root);
     boolean done = false;
     int i = 1;
     while (!done) {
       TreeNode r = (TreeNode) queue.element();
       if (r.left == null) {
         r.left = new TreeNode(array[i]);
         i++;
         queue.add(r.left);
       } else if (r.right == null) {
         r.right = new TreeNode(array[i]);
         i++;
         queue.add(r.right);
       } else {
         queue.remove();
       }
       if (i == array.length) done = true;
     }
     return root;
   } else {
     return null;
   }
 }
예제 #9
0
  // Minimize the distance in k sorted arrays
  public static int p15(int[][] arrs) {
    Queue<P15Obj> q = new PriorityQueue<P15Obj>();
    int max = Integer.MIN_VALUE;
    for (int i = 0; i < arrs.length; i++) {
      if (arrs[i].length > 0) {
        q.add(new P15Obj(i, 0, arrs[i][0]));
        if (max < arrs[i][0]) {
          max = arrs[i][0];
        }
      } else {
        return -1;
      }
    }

    int minDist = Integer.MAX_VALUE;
    do {
      P15Obj min = q.remove();
      minDist = Math.min(max - min.val, minDist);

      int newVal = arrs[min.i][min.j + 1];
      if (newVal > max) max = newVal;
      q.add(new P15Obj(min.i, min.j + 1, newVal));

    } while (q.peek().j < arrs[q.peek().i].length - 1);

    return minDist;
  }
예제 #10
0
  // Algorithm to randomly shuffle the elements of a message.
  final Message shuffle(Message message) throws FormatException {

    Message shuffled = messages.make();

    // Read all elements of the packet and insert them in a Queue.
    Queue<String> old = new LinkedList<>();
    int N = 0;
    while (!message.isEmpty()) {
      old.add(message.readString());
      message = message.rest();
      N++;
    }

    // Then successively and randomly select which one will be inserted until none remain.
    for (int i = N; i > 0; i--) {
      // Get a random number between 0 and N - 1 inclusive.
      int n = crypto.getRandom(i - 1);

      for (int j = 0; j < n; j++) {
        old.add(old.remove());
      }

      // add the randomly selected element to the queue.
      shuffled = shuffled.attach(old.remove());
    }

    return shuffled;
  }
  @Override
  public void buildRecursiveCountInfo() throws WikitException {
    if (!hasConceptRelationCreated()) {
      throw new WikitException("Category-concept relation hasn't created.");
    }

    Collection<Integer> leafIds = getLeafCategoryIds();
    ProgressCounter progress = new ProgressCounter();
    progress.setMaxCount(leafIds.size());
    for (int catId : leafIds) {
      int cptCount = getConceptCount(catId);
      incRecursiveConceptCount(catId, cptCount);

      // visit all ancestor node, and inc recursive concept count
      Queue<Integer> queue = new LinkedList<>();
      queue.add(catId);
      while (!queue.isEmpty()) {
        int childId = queue.poll();
        Set<Integer> parentIds = getParentIds(childId);
        for (int pid : parentIds) {
          incRecursiveConceptCount(pid, cptCount);
          queue.add(pid);
        }
      }
      progress.increment();
    }

    String key = (prefix + "cnf");
    jedis.hset(key, "assignRecursiveCount", "created");
    progress.done();
  }
  @Override
  public void buildEdgeRelation(CategoryCache categoryCache) throws WikitException {
    if (!categoryCache.hasDone()) {
      throw new WikitException("Please create category cache first.");
    }
    String[] skippedCategories = new String[] {"跨学科领域", "总类", "词汇列表"};
    Set<Integer> skippedCatIds = new HashSet<>();
    for (String c : skippedCategories) {
      skippedCatIds.add(categoryCache.getIdByName(c));
    }

    ProgressCounter counter = new ProgressCounter();
    try {
      String root = conf.getWikiRootCategoryName();
      int id = categoryCache.getIdByName(root);

      this.saveNameIdMapping(root, id);
      this.rootId = id;
      this.saveDepth(id, 0);

      Queue<Integer> queue = new LinkedList<>();
      queue.add(id);
      while (!queue.isEmpty()) {
        int pid = queue.poll();
        int depth = this.getDepth(pid);
        Set<Integer> childIds = categoryCache.getChildIds(pid);

        for (Integer childId : childIds) {
          if (skippedCatIds.contains(childId)) {
            continue;
          }

          int childDepth = categoryCache.getDepth(childId, -1);
          if (childDepth != (depth + 1)) {
            continue; // skip
          }

          if (!idExist(childId)) {
            String name = categoryCache.getNameById(childId);
            this.saveNameIdMapping(name, childId);
            this.saveDepth(childId, depth + 1);

            queue.add(childId);
          }
          this.saveParents(childId, pid);
          this.saveChildren(pid, childId);
        }

        counter.increment();
      }
      this.finishNameIdMapping();
      this.edgeRelationCreated();
    } catch (MissedException e) {
      LOG.error(e.toString());
      throw new WikitException(e);
    }

    counter.done();
    LOG.info("Edge relation has created.");
  }
 public List<List<Integer>> levelOrderBottom(TreeNode root) {
   List<List<Integer>> results = new LinkedList<List<Integer>>();
   Queue<TreeNode> currentLevel = new LinkedList<TreeNode>();
   Queue<TreeNode> nextLevel = new LinkedList<TreeNode>();
   if (root == null) {
     return results;
   } else {
     currentLevel.add(root);
   }
   List<Integer> tmp = new LinkedList<Integer>();
   while (!currentLevel.isEmpty()) {
     TreeNode node = currentLevel.remove();
     if (node != null) {
       tmp.add(node.val);
       nextLevel.add(node.left);
       nextLevel.add(node.right);
     }
     if (currentLevel.isEmpty()) {
       if (!tmp.isEmpty()) {
         results.add(0, tmp);
       }
       tmp = new LinkedList<Integer>();
       currentLevel = nextLevel;
       nextLevel = new LinkedList<TreeNode>();
     }
   }
   return results;
 }
예제 #14
0
 /**
  * Returns an array of strings naming the files and directories in the directory denoted by this
  * abstract pathname, and all of its subdirectories.
  *
  * <p>If this abstract pathname does not denote a directory, then this method returns {@code
  * null}. Otherwise an array of strings is returned, one for each file or directory in the
  * directory and its subdirectories. Names denoting the directory itself and the directory's
  * parent directory are not included in the result. Each string is a path relative to the given
  * directory.
  *
  * <p>There is no guarantee that the name strings in the resulting array will appear in any
  * specific order; they are not, in particular, guaranteed to appear in alphabetical order.
  *
  * @param path the abstract pathname to list
  * @return An array of strings naming the files and directories in the directory denoted by this
  *     abstract pathname and its subdirectories. The array will be empty if the directory is
  *     empty. Returns {@code null} if this abstract pathname does not denote a directory.
  * @throws IOException if a non-Alluxio error occurs
  */
 public String[] listRecursive(String path) throws IOException {
   // Clean the path by creating a URI and turning it back to a string
   AlluxioURI uri = new AlluxioURI(path);
   path = uri.toString();
   List<String> returnPaths = new ArrayList<>();
   Queue<String> pathsToProcess = new ArrayDeque<>();
   // We call list initially, so we can return null if the path doesn't denote a directory
   String[] subpaths = list(path);
   if (subpaths == null) {
     return null;
   } else {
     for (String subp : subpaths) {
       pathsToProcess.add(PathUtils.concatPath(path, subp));
     }
   }
   while (!pathsToProcess.isEmpty()) {
     String p = pathsToProcess.remove();
     returnPaths.add(p.substring(path.length() + 1));
     // Add all of its subpaths
     subpaths = list(p);
     if (subpaths != null) {
       for (String subp : subpaths) {
         pathsToProcess.add(PathUtils.concatPath(p, subp));
       }
     }
   }
   return returnPaths.toArray(new String[returnPaths.size()]);
 }
 static int maxFlow() {
   int mf = 0;
   while (true) {
     Queue<Integer> q = new LinkedList<Integer>();
     p = new int[V];
     Arrays.fill(p, -1);
     p[0] = 0;
     q.add(0);
     while (!q.isEmpty()) {
       int u = q.remove();
       if (u == 1) break;
       for (int i = 0; i < adjList[u].size(); ++i) {
         int v = adjList[u].get(i);
         if (p[v] == -1 && res[u][v] > 0) {
           p[v] = u;
           q.add(v);
         }
       }
     }
     if (p[1] == -1) break;
     augment(1);
     ++mf;
   }
   return mf;
 }
예제 #16
0
  // pathing
  private List<Room> path(Room start, Room destination, Set<Room> travelable) {
    Queue<Room> frontier = new LinkedList<Room>();
    frontier.add(start);

    Map<Room, Room> visited = new HashMap<Room, Room>();
    visited.put(start, null);

    while (!frontier.isEmpty()) {
      Room current = frontier.poll();
      System.out.println("\n---\n" + frontier + "\n\n" + travelable + "\n---\n");

      if ((destination == null && current.visited == false) || current == destination) {
        List<Room> path = new ArrayList<Room>();

        Room next = current;
        while (visited.get(next) != null) {
          path.add(0, next);
          next = visited.get(next);
        }

        System.out.println("Returning: " + path);
        return path;
      }

      for (Room next : current.adjacent) {
        if (!visited.containsKey(next) && travelable.contains(next)) {
          frontier.add(next);
          visited.put(next, current);
        }
      }
    }

    System.out.println("Returning: null");
    return null;
  }
예제 #17
0
  public static Phylogeny generatePerfectTree(int size, boolean randomNames) {
    Phylogeny tree = new Phylogeny();
    int currentTreeSize = 0;
    Queue<PhylogenyNode> currentLeaves = new LinkedList<>();

    PhylogenyNode root = new PhylogenyNode();
    tree.setRoot(root);
    currentLeaves.add(root);
    currentTreeSize++;

    while (currentTreeSize < size) {
      PhylogenyNode currentNode = currentLeaves.poll();
      PhylogenyNode child1 = new PhylogenyNode();
      PhylogenyNode child2 = new PhylogenyNode();
      currentNode.setChild1(child1);
      currentNode.setChild2(child2);
      currentLeaves.add(child1);
      currentLeaves.add(child2);
      currentTreeSize++;
    }

    if (randomNames) renameTreeLeavesRandomly(tree);
    else renameTreeLeavesLeftToRight(tree);

    return tree;
  }
예제 #18
0
파일: CarSim.java 프로젝트: 13djwright/CS2
  public static void lightChange(Queue<Car> q) {
    // if light is true, that means the green light is for N and S
    // This means we must change the cars wait times in E and W
    Queue<Car> temp = new LinkedList<Car>();
    Car tc;
    while (!q.isEmpty()) {
      tc = q.remove();
      temp.add(tc);
    }
    int tnum = 1;
    q.clear();
    // System.out.println("In the light change");

    while (!temp.isEmpty()) {
      Car tcar = temp.remove();
      // System.out.println("Light Change: " + tcar.display());
      if (tnum == 1) {
        tcar.setTotalWait(3);
        tcar.setWaitTime(3);
        q.add(tcar);
      } else if (tnum == 2) {
        tcar.setTotalWait(2);
        tcar.setWaitTime(2);
        q.add(tcar);

      } else {

        tcar.setTotalWait(1);
        tcar.setWaitTime(1);
        q.add(tcar);
      }
      tnum++;
    }
  }
예제 #19
0
  /**
   * Using a serialized list of tree nodes to generate a binary tree. There is detail information:
   * https://leetcode.com/problems/binary-tree-inorder-traversal/
   *
   * @param serializedTreeNode a serialized list of tree nodes
   * @return the node of tree root
   */
  public static TreeNode generateTree(String serializedTreeNode) {
    String[] tokens = serializedTreeNode.split(",");
    if (tokens.length <= 0) return null;
    TreeNode root = new TreeNode(Integer.parseInt(tokens[0]));
    Queue<TreeNode> queue = new LinkedList<>();
    queue.add(root);
    int pos = 1;
    while (pos < tokens.length) {

      TreeNode temp = queue.remove();
      if (!tokens[pos].equals("#")) {
        TreeNode left = new TreeNode(Integer.parseInt(tokens[pos]));
        temp.left = left;
        queue.add(left);
      }
      pos++;

      if (pos >= tokens.length) break;
      if (!tokens[pos].equals("#")) {
        TreeNode right = new TreeNode(Integer.parseInt(tokens[pos]));
        temp.right = right;
        queue.add(right);
      }
      pos++;
    }
    return root;
  }
예제 #20
0
 private static boolean a(Context context, String str) {
   boolean z = false;
   synchronized (g) {
     SharedPreferences j = m.a(context).j();
     if (c == null) {
       String[] split = j.getString("pref_msg_ids", com.xiaomi.e.a.f).split(f.i);
       c = new LinkedList();
       for (Object add : split) {
         c.add(add);
       }
     }
     if (c.contains(str)) {
       z = true;
     } else {
       c.add(str);
       if (c.size() > 10) {
         c.poll();
       }
       String a = d.a(c, f.i);
       Editor edit = j.edit();
       edit.putString("pref_msg_ids", a);
       edit.commit();
     }
   }
   return z;
 }
  public static int minDepth(Node root) {
    Queue<Node> q = new LinkedList<Node>();
    q.add(root);
    System.out.println(root.val);
    int countLevel = 0;
    while (!q.isEmpty()) {
      int level = q.size();
      countLevel++;
      while (level > 0) {
        Node temp = q.poll();
        if (temp.left == null && temp.right == null) {
          return countLevel;
        } else {
          if (temp.left != null) {
            q.add(temp.left);
            System.out.print(temp.left.val + " ");
          }
          if (temp.right != null) {
            q.add(temp.right);
            System.out.print(temp.right.val + " ");
          }
        }
        level--;
      }
      System.out.println("");
    }

    return 0;
  }
예제 #22
0
    /**
     * breadth first search -- ONLY prints edges in this version
     *
     * @param Starting vertex
     */
    public void bfs(String start) {
      clearAll(); // reset scratches for all Vertices
      Vertex root = verts.get(start); // get root Vertex
      root.dist = 0; // set distance to zero

      if (root == null) // throw exception if root Vertex DNE
      throw new NoSuchElementException("Start Vertex not found");

      Queue<Vertex> queue = new LinkedList<Vertex>(); // create queue
      queue.add(root); // add root Vertex to queue

      while (!queue.isEmpty()) { // continue while not empty
        Vertex tempVertex = queue.poll(); // grab next Vertex from queue
        tempVertex.scratch = 2; // mark vertex as visited

        for (int i = 0; i < numVertices; i++) { // search for nodes in tempVetex's row
          // if an edge exists and dest Vertex is unseen add to queue
          if ((matrix[tempVertex.vertNumber][i] > 0) && numbers.get(i).scratch == 0) {
            Vertex neighbor = numbers.get(i);
            neighbor.dist = tempVertex.dist + 1; // set distance
            neighbor.prev = tempVertex; // set previous Vertex
            neighbor.scratch = 1; // mark as seen
            queue.add(neighbor); // add to queue
            // print edge
            System.out.println(
                neighbor.prev.name
                    + "->"
                    + neighbor.name
                    + ":"
                    + matrix[neighbor.prev.vertNumber][neighbor.vertNumber]);
          }
        }
      }
    }
예제 #23
0
  /* Fill the bipartite graph if possible. */
  boolean[] solve() {
    Map<Integer, List<Integer>> gr = makeGraph();

    boolean[] truthTable = new boolean[count];
    // keep track of which ones we've visited
    boolean[] visited = new boolean[count];
    Queue<Integer> queue = new LinkedList<Integer>();
    truthTable[0] = true; // assume the first person tells the truth
    queue.add(0);

    // Breadth first search on graph
    while (!queue.isEmpty()) {
      int next = queue.remove();
      boolean truth = truthTable[next];
      List<Integer> list = gr.get(next);

      // Go through list and toggle when needed
      for (int i = 0; i < list.size(); i++) {
        int node = list.get(i);
        if (!visited[node]) {
          visited[node] = true;
          truthTable[node] = !truth;
          queue.add(node);
        }
      }
    }

    return truthTable;
  }
예제 #24
0
  /**
   * Creates a new Game instance*
   *
   * @param p1Id the id of the first player
   * @param p2Id the id of the second player
   * @return a new game instance
   */
  private IGame createGame(String p1Id, String p2Id) {

    String gid = UUID.randomUUID().toString();

    ArrayList<Integer> shuffleArray = new ArrayList<>();
    for (int i = 0; i < 52; i++) {
      shuffleArray.add(i);
    }
    Collections.shuffle(shuffleArray);

    int split = shuffleArray.size() / 2;
    Queue<Integer> player1Cards = new LinkedList<>();
    for (int i = 0; i < split; i++) {
      player1Cards.add(shuffleArray.get(i));
    }

    Queue<Integer> player2Cards = new LinkedList<>();
    for (int i = split; i < shuffleArray.size(); i++) {
      player2Cards.add(shuffleArray.get(i));
    }
    Game game = new Game(gid, p1Id, p2Id, player1Cards, player2Cards);
    games.put(gid, game);

    return game;
  }
  private static void traverse(BinaryTreeNode node) {

    if (node == null) return;

    Queue<BinaryTreeNode> queue = new LinkedList<BinaryTreeNode>();
    Stack<BinaryTreeNode> stack = new Stack<BinaryTreeNode>();
    queue.add(node);
    queue.add(null);
    while (!queue.isEmpty()) {
      node = queue.poll();
      stack.push(node);
      if (node == null) {
        if (!queue.isEmpty()) queue.add(null);
      } else {
        if (node.getRightNode() != null) queue.add(node.getRightNode());
        if (node.getLeftNode() != null) queue.add(node.getLeftNode());
      }
    }
    while (!stack.isEmpty()) {
      BinaryTreeNode btNode = stack.pop();
      if (btNode != null) {
        System.out.print(btNode.getData() + " ");
      } else {
        System.out.println(" ");
      }
    }
  }
예제 #26
0
 // 思路,还是一样借助两个队列来进行完成
 public void connect(TreeLinkNode root) {
   if (root == null) {
     return;
   }
   Queue<TreeLinkNode> q1 = new LinkedList<TreeLinkNode>();
   Queue<TreeLinkNode> q2 = new LinkedList<TreeLinkNode>();
   q1.add(root);
   root.next = null;
   while (!(q1.isEmpty() && q2.isEmpty())) {
     while (!q1.isEmpty()) {
       TreeLinkNode node = q1.poll();
       if (node.left != null) {
         q2.add(node.left);
       }
       if (node.right != null) {
         q2.add(node.right);
       }
     }
     while (!q2.isEmpty()) {
       TreeLinkNode node = q2.poll();
       if (q2.isEmpty()) {
         node.next = null;
       } else {
         node.next = q2.peek();
       }
       q1.add(node);
     }
   }
 }
예제 #27
0
  @Override
  public String[] findFiles(final String folderName) {

    File folder = new File(folderName);
    if (!folder.exists()) {
      throw new IllegalArgumentException();
    }

    List<String> foundFiles = new ArrayList<String>();
    Queue<File> folders = new LinkedList<File>();

    folders.add(folder);

    while (!folders.isEmpty()) {

      File currentFolder = folders.remove();
      File[] currentFiles = currentFolder.listFiles();

      for (File f : currentFiles) {
        if (f.isDirectory()) {
          folders.add(f);
        } else if (f.isFile()) {
          foundFiles.add(f.getAbsolutePath());
        } else {
          throw new RuntimeException("It isn't file or folder");
        }
      }
    }

    return foundFiles.toArray(new String[foundFiles.size()]);
  }
예제 #28
0
 public static int[][] findMinimumDistanceToNearestZero(int[][] matrix) {
   // step 1: initialize
   int totalRow = matrix.length, totalCol = matrix[0].length;
   int[][] dis = new int[totalRow][totalCol];
   boolean[][] vis = new boolean[totalRow][totalCol];
   Queue<Position> queue = new LinkedList<Position>();
   for (int i = 0; i < totalRow; ++i) {
     for (int j = 0; j < totalCol; ++j) {
       if (matrix[i][j] == 0) {
         dis[i][j] = 0;
         vis[i][j] = true;
         queue.add(new Position(i, j, 0));
       }
     }
   }
   // step 2: BFS
   while (!queue.isEmpty()) {
     Position pos = queue.poll();
     for (int i = 0; i < 4; ++i) {
       int nr = pos.row + MOVE[i][0], nc = pos.col + MOVE[i][1];
       if (nr < 0 || nr >= totalRow || nc < 0 || nc >= totalCol) continue;
       if (vis[nr][nc]) continue;
       dis[nr][nc] = pos.dis + 1;
       vis[nr][nc] = true;
       queue.add(new Position(nr, nc, dis[nr][nc]));
     }
   }
   return dis;
 }
예제 #29
0
  @Override
  protected AbstractPlanNode recursivelyApply(AbstractPlanNode planNode) {
    assert (planNode != null);

    // breadth first:
    //     find AggregatePlanNode with exactly one child
    //     where that child is an AbstractScanPlanNode.
    //     Inline any qualifying AggregatePlanNode to its AbstractScanPlanNode.

    Queue<AbstractPlanNode> children = new LinkedList<AbstractPlanNode>();
    children.add(planNode);

    while (!children.isEmpty()) {
      AbstractPlanNode plan = children.remove();
      AbstractPlanNode newPlan = inlineAggregationApply(plan);
      if (newPlan != plan) {
        if (plan == planNode) {
          planNode = newPlan;
        } else {
          planNode.replaceChild(plan, newPlan);
        }
      }

      for (int i = 0; i < newPlan.getChildCount(); i++) {
        children.add(newPlan.getChild(i));
      }
    }

    return planNode;
  }
예제 #30
0
 int[] nextPillBFS(Node start) {
   ArrayList<Node> alreadyVisited = new ArrayList<Node>();
   Queue<Node> nextToVisit = new LinkedList<Node>();
   Queue<Tuple> startDirection = new LinkedList<Tuple>();
   ArrayList<Edge> firstDirections = start.getEdges();
   for (int i = 0; i < firstDirections.size(); i++) {
     Node nextFieldToVisit = firstDirections.get(i).end;
     nextToVisit.add(nextFieldToVisit);
     startDirection.add(new Tuple(nextFieldToVisit.x - start.x, nextFieldToVisit.y - start.y));
   }
   Node lastTouched;
   Tuple beginningDirection;
   while (true) {
     if (nextToVisit.size() == 0) return new int[] {0, 0};
     lastTouched = nextToVisit.remove();
     beginningDirection = startDirection.remove();
     if (alreadyVisited.contains(lastTouched)) continue;
     if (lastTouched.hasPill()) {
       break;
     }
     alreadyVisited.add(lastTouched);
     ArrayList<Edge> neighbourEdges = lastTouched.getEdges();
     for (int i = 0; i < neighbourEdges.size(); i++) {
       nextToVisit.add(neighbourEdges.get(i).end);
       startDirection.add(beginningDirection);
     }
   }
   return new int[] {beginningDirection.x, beginningDirection.y};
 }