protected void split() { int halfGuides = guides.size() / 2; int halfKids = halfGuides + 1; GuideNode<K, V> left = new GuideNode<K, V>(comparator, guides.subList(0, halfGuides), kids.subList(0, halfKids)); GuideNode<K, V> right = new GuideNode<K, V>( comparator, guides.subList(halfGuides + 1, guides.size()), kids.subList(halfKids, kids.size())); left.setLeft(getLeft()); left.setRight(right); getLeft().setRight(left); left.setParent(getParent()); for (Node<K, V> kid : left.kids) { kid.setParent(left); } right.setLeft(left); right.setRight(getRight()); getRight().setLeft(right); right.setParent(getParent()); for (Node<K, V> kid : right.kids) { kid.setParent(right); } parent.insertKid(this, guides.get(halfGuides), left, right); }
public void right_rotate(Node curr) { if (curr != null) { if (curr.getLeftChild() == null) { System.out.println("Cannot rotate right since left child is not present"); return; } Node rotateWith = curr.getLeftChild(); rotateWith.setParent(curr.getParent()); if (curr.getParent() != null) { Node currParent = curr.getParent(); if (curr == currParent.getLeftChild()) currParent.setLeftChild(rotateWith); else currParent.setRightChild(rotateWith); } else { root = rotateWith; } curr.setLeftChild(rotateWith.getRightChild()); if (rotateWith.getRightChild() != null) rotateWith.getRightChild().setParent(curr); rotateWith.setRightChild(curr); curr.setParent(rotateWith); } }
@Override protected void setupAST() { left.setParent(this); right.setParent(this); left.setStatement(getStatement()); right.setStatement(getStatement()); left.setupAST(); right.setupAST(); }
public InternalNode(int d, Node p0, int k1, Node p1, Node n, Node p) { super(d, n, p); ptrs[0] = p0; keys[1] = k1; ptrs[1] = p1; lastindex = 1; if (p0 != null) p0.setParent(new Reference(this, 0, false)); if (p1 != null) p1.setParent(new Reference(this, 1, false)); }
@Override protected void removeParent() { final Node parent = getParent(); if (parent instanceof Level) ((Level) parent).removeComment(this); else ((ContentSpec) parent).removeComment(this); super.setParent(null); }
public void insert(int val, Node ptr) { // find correct position to insert int p = this.findKeyIndex(val); // if node is not full if (!full()) { // if val is larger than last key, increment p if (val > this.getKey(this.getLast())) { p++; } // insertion for simple case this.insertSimple(val, ptr, p); } else { // create a neighbor node with val and ptr Node split = new InternalNode(degree, null, val, ptr, this.getNext(), this); // set split to be next node of current node this.setNext(split); // get val to be inserted into parent int parentVal = this.redistribute(); // if current node has a parent, insert value into parent if (this.getParent() != null) { this.getParent().getNode().insert(parentVal, split); // if no parent for current node, create a new root } else { Node newRoot = new InternalNode(degree, this, parentVal, split, null, null); // set parent references this.setParent(new Reference(newRoot, 0, false)); split.setParent(new Reference(newRoot, 1, false)); } } }
// Another BFS path-finding implementation // This one doesn't rely on getting all reachable nodes through BFS // Instead, it stops once it finds the node during BFS. // Also, the queue keeps track of paths instead of individual nodes public static List<Node> BFS2(Node root, Node find) { Node.resetTree(root); LinkedList<ArrayList<Node>> queue = new LinkedList<ArrayList<Node>>(); root.setDistance(0); ArrayList<Node> path = new ArrayList<Node>(); path.add(root); queue.add(path); while (queue.size() > 0) { ArrayList<Node> curPath = queue.remove(); Node endNode = curPath.get(curPath.size() - 1); if (endNode == find) { return curPath; } else { List<Node> endNodeChildren = endNode.getChildren(); for (Node node : endNodeChildren) { if (node.getDistance() == Double.POSITIVE_INFINITY) { node.setDistance(endNode.getDistance() + 1); node.setParent(endNode); ArrayList<Node> newPath = new ArrayList<Node>(curPath); newPath.add(node); queue.add(newPath); } } } } return Collections.emptyList(); }
// Breadth first search // Returns a list of all reachable nodes in the order visited public static List<Node> BFS(Node root) { Node.resetTree(root); List<Node> reachable = new ArrayList<Node>(); LinkedList<Node> queue = new LinkedList<Node>(); root.setDistance(0); queue.add(root); reachable.add(root); while (queue.size() > 0) { Node cur = queue.remove(); List<Node> children = cur.getChildren(); for (Node node : children) { if (node.getDistance() == Double.POSITIVE_INFINITY) { node.setDistance(cur.getDistance() + 1); node.setParent(cur); queue.add(node); reachable.add(node); } } } return reachable; }
public static void main(String args[]) { String str = "bbb0www"; // "087465132"; 054832761 // Initial Board State as a String with 0 as the // Blank Space Node top = new Node(); Node node = new Node(); System.out.println("Start state: " + str); /*for(int i=0;i<str.length();i++){ if(i%3==0){ System.out.println(""); } System.out.print(str.charAt(i)+"\t"); }*/ SlidingTileDFS e = new SlidingTileDFS(); node.setState(str); node.setParent(null); e.add(node, 0); // e.s.push(str); while (!(e.s.empty())) { top = e.s.pop(); // node.setState(top); // node.setParent(null); e.left(top); // Move the blank space up and add new state to queue e.leftjump1(top); e.leftjump2(top); e.right(top); // Move the blank space down e.rightjump1(top); // Move left e.rightjump2(top); // Move right and remove the current node from Queue } System.out.println("Solution doesn't exist"); }
void left(Node node) { String str = node.getState(); String parent = node.getParent(); Node newState = new Node(); int a = str.indexOf("0"); char temp; char[] s = str.toCharArray(); String newStr; if (a != 0) { temp = s[a - 1]; s[a - 1] = '0'; s[a] = temp; newStr = this.gString(s); newState.setState(newStr); newState.setParent(str); // newState.setLevel(node.getLevel()+1); // newState.setHeuristic(newState.calculateHeuristic(goal)); // newState.setFvalue(newState.getHeuristic() + newState.getLevel()); add(newState, map.get(str) + 1); // add(s,map.get(str)+1); if (newStr.equals("www0bbb")) { System.out.println( "Solution found after searching through " + map.get(newStr) + " states of the tree"); printSolution(); System.exit(0); } } }
/** Removes all child nodes from this element. */ public void removeChildren() { for (int i = 0; i < getChildCount(); ++i) { Node child = getChild(i); child.setParent(null); } clearChildren(); }
/** * Adds the node to this parent. Children must be stored in the order in which they were added. * Otherwise various operators will perform incorrectly (such as - % / and others). * * @param node child node. */ public void addChild(Node node) { ParentNode parent = node.getParent(); if (parent != null) { parent.children.remove(node); } children.add(node); node.setParent(this); } // addChild
// encapsulated/private working method private void insert(Node newNode, Node currRoot) { if (newNode.getKey() <= currRoot.getKey()) { if (currRoot.getLeftChild() != null) { insert(newNode, currRoot.getLeftChild()); } else { currRoot.setLeftChild(newNode); newNode.setParent(currRoot); } } else { if (currRoot.getRightChild() != null) { insert(newNode, currRoot.getRightChild()); } else { currRoot.setRightChild(newNode); newNode.setParent(currRoot); } } }
public void transplant(Node curr, Node replace) { if (curr.getParent() == null) root = replace; else if (curr == curr.getParent().getLeftChild()) { curr.getParent().setLeftChild(replace); } else { curr.getParent().setRightChild(replace); } if (replace != null) replace.setParent(curr.getParent()); }
@Override public Node copyTree() { BodyNode newThis = new BodyNode(); for (Node child : this) { Node newChild = child.copyTree(); newChild.setParent(newThis); newThis.addChild(newChild); } return newThis; }
/** * Replace two nodes * * @param x node * @param n node * @throws HsqlException */ private void replace(Session session, Node x, Node n) throws HsqlException { if (x.equals(getRoot(session))) { setRoot(session, n); if (n != null) { n.setParent(null); } } else { set(x.getParent(), x.isFromLeft(), n); } }
/** * Set a node as child of another * * @param x parent node * @param isleft boolean * @param n child node * @throws HsqlException */ private void set(Node x, boolean isleft, Node n) throws HsqlException { if (isleft) { x.setLeft(n); } else { x.setRight(n); } if (n != null) { n.setParent(x); } }
public void optimizeRoot() { List<Node> list = getChildren(); if (list.size() == 1) { Node node = list.get(0); List<Node> children = node.getChildren(); this.children.remove(0); for (Node child : children) { this.children.add(child); child.setParent(null); } } }
public Node( String name, Vector3f pos, Vector3f scale, Quat4f rot, List<Node<?>> nodes, K kind) { this.name = name; this.pos = pos; this.scale = scale; this.rot = rot; this.nodes = buildNodeMap(nodes); this.kind = kind; kind.setParent(this); for (Node<?> child : this.nodes.values()) { child.setParent(this); } }
private static void buildSubtreeFromNewick(Node parent, String subTreeStr) { ArrayList<String> kids = getChildStrings(0, subTreeStr); for (String kidStr : kids) { stripSpaces(kidStr); Node kid = new Node(); if (hasKids(kidStr)) buildSubtreeFromNewick(kid, kidStr); else { kid.setId(kidStr.substring(0, kidStr.indexOf(":"))); } parent.addChild(kid); kid.setDistToParent(subTreeDistFromParent(kidStr)); kid.setParent(parent); // System.out.println("dist from parent is : " + kid.getDistToParent()); // System.out.println("dist to root is : " + getDistToRoot(kid)); } }
/** * (Deep) Clone Method, Returns An Object Equal To This One * * @return a clone of this object */ @Override public Object clone() { Node<T> nodeTMP = new Node<T>((T) this.value, this.fixedValue); nodeTMP.setColor(this.getColor()); nodeTMP.setDiscoveryTIME(this.getDiscoveryTIME()); nodeTMP.setDistance(this.getDistance()); nodeTMP.setFinalTIME(this.getFinalTIME()); nodeTMP.setParent(this.parent); return nodeTMP; }
/** * Expands the node's state therefore generating a list of successor nodes. Expansion takes place * by invoking the problem's operators apply() method on the node's state. * * @param node node whose state is to be expanded. * @param problem problem to solve * @param generatedStates List<State> the nodes that are in the frontier of the search algorithm. * @param expandedStates List<State> the states that have been expended so far along the search * process. * @return List<Node> containing the successor nodes. */ public List<Node> expand( Node node, Problem problem, List<State> generatedStates, List<State> expandedStates) { List<Node> successorNodes = new ArrayList<Node>(); Node successorNode = null; State currentState = null; State successorState = null; // If neither node or problem are null if (node != null && problem != null) { // Get the node's state. currentState = node.getState(); // Remove current state from the list of generated states. generatedStates.remove(currentState); // Insert current state to the list of generated states. expandedStates.add(currentState); // If the state is not null if (currentState != null) { // Go over the list of problem operators for (Operator operator : problem.getOperators()) { // Apply the operator to the current state successorState = operator.apply(currentState); // If the operator has been successfully applied and the resulting successor // state hadn't been previously generated nor expanded if (successorState != null && !generatedStates.contains(successorState) && !expandedStates.contains(successorState)) { // make a new node to contain the new successor state successorNode = new Node(successorState); successorNode.setOperator(operator.getName()); successorNode.setParent(node); successorNode.setDepth(node.getDepth() + 1); // add the newly created node to the list of successor nodes. successorNodes.add(successorNode); // Insert current successor State to the list of generated states generatedStates.add(successorState); } } } } return successorNodes; }
// 处理只有一个儿子的文件夹 private void move1ChildFolder(Node node) { if ("folder".equals(node.getType())) { if (node.getSize() == 1) { Node child = node.getChildren().get(0); Node parent = node.getParent(); if (parent != null) { // 将单个儿子节点往上移动 parent.getChildren().add(child); child.setParent(parent); // 并从当前节点中移除 node.getChildren().remove(0); parent.getChildren().remove(node); // 继续网上移动单个儿子节点 move1ChildFolder(child); } } } }
// returns the root public static Node buildTreeFromNewick(String treeStr) { Node root = new Node("root"); treeStr = treeStr.replaceAll("\\[&[^\\]]+\\]", ""); // Used to strip off beast-style annotations, int first = treeStr.indexOf("("); int last = treeStr.lastIndexOf(");"); treeStr = treeStr.substring(first, last + 1); treeStr = stripSpaces(treeStr); buildSubtreeFromNewick(root, treeStr); // Sometimes we'll get an extra node at the root, so strip it off // Will we ever want to preserve these? while (root.numChildren() == 1) { root = root.getChild(0); root.setDistToParent(0); root.setParent(null); } return root; }
private Node makeCrunchNode(Node topologicalNode) { // copy the intrinsic properties: id, weights, relationship, and selectors will be set Node node = new Node(topologicalNode); // assign the id from the name hash node.setId(computeId(node)); if (!topologicalNode.isLeaf()) { List<Node> newChildren = new ArrayList<Node>(); List<Node> children = topologicalNode.getChildren(); for (Node child : children) { // depth-first traversal Node newChild = makeCrunchNode(child); // set the child-parent relationship newChildren.add(newChild); newChild.setParent(node); } node.setChildren(newChildren); // weights and selector should be set after all lower nodes are crunched computeWeightAndSelector(node); } return node; }
public void addResult(Cursor cursor, Set<EventBean> lookupResults, int resultStream) { if (lookupResults.isEmpty()) { throw new IllegalArgumentException("Attempting to add zero results"); } Node parentNode = cursor.getNode(); if (parentNode == null) { Node leafNode = new Node(resultStream); leafNode.setEvents(lookupResults); if (nodesPerStream == null) { nodesPerStream = new List[numStreams]; } List<Node> nodes = nodesPerStream[resultStream]; if (nodes == null) { nodes = new LinkedList<Node>(); nodesPerStream[resultStream] = nodes; } leafNode.setParentEvent(rootEvent); nodes.add(leafNode); return; } Node leafNode = new Node(resultStream); leafNode.setEvents(lookupResults); leafNode.setParent(cursor.getNode()); leafNode.setParentEvent(cursor.getTheEvent()); List<Node> nodes = nodesPerStream[resultStream]; if (nodes == null) { nodes = new LinkedList<Node>(); nodesPerStream[resultStream] = nodes; } nodes.add(leafNode); }
/** * parse sentence and generate .trees file * * @param en * @param align * @param out */ public static void parse(String en, String align, String out, boolean verbose) { // use alignments? boolean use_alignments = true; if (align.startsWith("no_align")) { use_alignments = false; System.err.println("Not using alignments."); } else { System.err.println("Using alignments from " + align); } // setup stanfordparser String grammar = "edu/stanford/nlp/models/lexparser/englishPCFG.ser.gz"; String[] options = {"-outputFormat", "wordsAndTags, typedDependencies"}; LexicalizedParser lp = LexicalizedParser.loadModel(grammar, options); TreebankLanguagePack tlp = lp.getOp().langpack(); java.util.function.Predicate<java.lang.String> punctuationFilter = x -> true; GrammaticalStructureFactory gsf = new edu.stanford.nlp.trees.EnglishGrammaticalStructureFactory(punctuationFilter); // read document Iterable<List<? extends HasWord>> sentences; Reader r = new Reader(en); String line = null; List<List<? extends HasWord>> tmp = new ArrayList<List<? extends HasWord>>(); while ((line = r.getNext()) != null) { Tokenizer<? extends HasWord> token = tlp.getTokenizerFactory().getTokenizer(new StringReader(line)); List<? extends HasWord> sentence = token.tokenize(); tmp.add(sentence); } sentences = tmp; // set up alignment file reader Reader alignment = new Reader(); if (use_alignments) { alignment = new Reader(align); } // set up tree file writer Writer treeWriter = new Writer(out); // parse long start = System.currentTimeMillis(); // System.err.print("Parsing sentences "); int sentID = 0; for (List<? extends HasWord> sentence : sentences) { Tree t = new Tree(); // t.setSentID(++sentID); System.err.println("parse Sentence :" + sentence + "..."); // System.err.print("."); System.err.println("-----------------------------------------------------------------------"); edu.stanford.nlp.trees.Tree parse = lp.parse(sentence); // parse.pennPrint(); // List for root node and lexical nodes List<Node> loneNodes = new LinkedList<Node>(); List<Node> governingNodes = new LinkedList<Node>(); // ROOT node Node root = new Node(true, true); root.setTag("ROOT"); t.setRoot(root); loneNodes.add(root); governingNodes.add(root); // tagging int counter = 0; String surface = ""; String tag = ""; for (TaggedWord tw : parse.taggedYield()) { Node n = new Node(); Node governingNode = new Node(); n.setNodeID(++counter); surface = tw.value(); tag = tw.tag(); if (surface.startsWith("-LRB-")) { surface = "("; } else if (surface.startsWith("-RRB-")) { surface = ")"; // } else if (surface.startsWith("-LSB-")){ // surface = "["; // } else if (surface.startsWith("-RSB-")){ // surface = "]"; // } else if (surface.startsWith("-LCB-")){ // surface = "{"; // } else if (surface.startsWith("-RCB-")){ // surface = "}"; } else if (surface.startsWith("''")) { surface = "\""; } tag = tag.replaceAll("#", "-NUM-"); surface = surface.replaceAll("&", "-AMP-"); surface = surface.replaceAll("#", "-NUM-"); surface = surface.replaceAll(">", "-GRE-"); surface = surface.replaceAll("=", "-EQU-"); n.setInitialLexicalIndex(counter); governingNode.setInitialLexicalIndex(counter); n.setSurface(surface); // System.out.print("("+tw.value()+" : "); n.setTag(tag); governingNode.setTag("_" + tag); governingNode.setLabel("_gov"); // System.out.print(tw.tag()+")"); loneNodes.add(n); governingNodes.add(governingNode); governingNode.setChild(n); } // System.out.println(""); // t.setSentLength(t.getNodes().size() - 1); // List<Node> loneNodes = new LinkedList<Node>(); Node[] nodes = new Node[2000]; // labeling int depIndex; int govIndex; String[] depInfo; String[] govInfo; GrammaticalStructure gs = gsf.newGrammaticalStructure(parse); List<TypedDependency> tdl = gs.typedDependencies(false); // List<TypedDependency> tdl = gs.typedDependenciesCCprocessed(); for (TypedDependency td : tdl) { depIndex = td.dep().index(); govIndex = td.gov().index(); // System.out.println("Index1:"+depIndex); // System.out.println("Index2:"+govIndex); // if (nodes[depIndex] == null){ // System.out.println("Making node!"); // nodes[depIndex] = new Node(); // } // if (nodes[govIndex] == null){ // System.out.println("Making node!"); // nodes[govIndex] = new Node(); // } Node dep = loneNodes.get((depIndex)); Node gov = governingNodes.get((govIndex)); Node depcopy = governingNodes.get((depIndex)); Node govcopy = loneNodes.get((govIndex)); dep.setLabel(td.reln().toString()); depcopy.setLabel(td.reln().toString()); govcopy.setLabel("head"); // System.out.println(td.toString()); govInfo = td.gov().toString().split("/"); depInfo = td.dep().toString().split("/"); // System.out.println(td.gov().toString()); // System.out.println(td.dep().toString()); // dep.setSurface(depInfo[0]); // dep.setTag(depInfo[1]); gov.setChild(governingNodes.get(depIndex)); governingNodes.get(depIndex).setParent(gov); // gov.setChild(dep); dep.setParent(governingNodes.get(depIndex)); } // t.setRoot(nodes[0]); // Collapse tree to remove unneeded governing nodes: Node gov; Node dep; Node parent; List<Node> children; for (int i = 1; i < governingNodes.size(); i++) { // start with index 1 to skip root gov = governingNodes.get(i); dep = loneNodes.get(i); if (gov.getChildren().size() <= 1) { int k = 0; parent = gov.getParent(); children = parent.getChildren(); for (Node n : children) { if (n == gov) { gov.getParent().replaceChild(k, dep); dep.setParent(gov.getParent()); } k++; } } } // Mark head nodes with appropriate label: int k = 0; for (Node n : loneNodes) { if (k != 0) { if (n.getLabel() == n.getParent().getLabel()) { n.setLabel("head"); } } else { n.setLabel("null"); } k++; } // Sort lexical children of each governing node in lexical order for (Node n : governingNodes) { n.sortChildrenByInitialIndex(); } // combine with alignment if (use_alignments) { t.initialize(alignment.readNextAlign()); } else { t.initializeUnaligned(); } // write tree to file treeWriter.write(t); // print tree to console System.out.println(t.toSentence()); if (verbose) { System.err.println(t.toString()); // t.recursivePrint(); } System.err.println("#######################################################################"); } long stop = System.currentTimeMillis(); System.err.println("...done! [" + (stop - start) / 1000 + " sec]."); treeWriter.close(); }
public void setRoot(Node root) { this.root = root; root.setParent(null); }
/** Test parent/child relationships */ public void testChildNodes() { Node net = Node.ROOT_NODE.newInstance(testLibrary, "net"); Node rect = Node.ROOT_NODE.newInstance(testLibrary, "rect"); rect.setParent(net); assertTrue(net.contains("rect")); }
public int findBestMove(Node currentNode, int best) { int turn = currentNode.getBoard().CurrentPlayer(); // set the current value of the current node to compare with children node if (turn != player) currentNode.setValue(Float.POSITIVE_INFINITY); else currentNode.setValue(Float.NEGATIVE_INFINITY); // Check each pit on your side to find the best move. */ for (int i = 0; i < 6; i++) if (currentNode.getBoard().validMove(i)) { try { MancalaGameState newBoard = currentNode.getBoard().copy(); try { newBoard.play(i); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } Node newNode = new Node(newBoard, currentNode.getDepth() + 1); newNode.setParent(currentNode); currentNode.setChild(newNode, i); // CUT OFF if (newNode.getBoard().checkEndGame() || (newNode.getDepth() >= cutoffDepth)) { RegressionState aState = new RegressionState(newNode.getBoard(), player); newNode.setValue(predictedValue(aState, weight)); } else findBestMove(newNode, best); // alpha-beta pruning // AI = MAX // pick the child with larger value if (currentNode.getBoard().CurrentPlayer() == player) { if (currentNode.getChild(i) != null) { if (currentNode.getChild(i).getValue() > currentNode.getValue()) { currentNode.setValue(currentNode.getChild(i).getValue()); best = i; } } currentNode.deleteChild(i); // alpha cut off if our value is greater than ANY // player/MIN parent value Node nodePtr = currentNode; while (nodePtr.getParent() != null) { nodePtr = nodePtr.getParent(); if ((nodePtr.getBoard().CurrentPlayer != player) && (currentNode.getValue() > nodePtr.getValue())) { nodePtr = null; return best; } } nodePtr = null; } // Player = MIN // pick the child with smaller value if (currentNode.getBoard().CurrentPlayer() != player) { if (currentNode.getChild(i) != null) { if (currentNode.getChild(i).getValue() < currentNode.getValue()) { currentNode.setValue(currentNode.getChild(i).getValue()); best = i; } } currentNode.deleteChild(i); // beta cut off if our value is less than ANY // computer/MAX parent value Node nodePtr = currentNode; while (nodePtr.getParent() != null) { nodePtr = nodePtr.getParent(); if ((nodePtr.getBoard().CurrentPlayer() == player) && (currentNode.getValue() < nodePtr.getValue())) { nodePtr = null; return best; } } nodePtr = null; } } catch (java.lang.OutOfMemoryError e) { System.out.println("OUT OF MEM"); return -1; } } return best; // return the best move }