User:Margusmartsepp/Contributions/Java/Utils.java

From Rosetta Code

<lang java> import java.util.ArrayList; import java.util.Collections;

public class Utils { private static <T> void swap(ArrayList<T> data, int i, int j) { T t = data.get(i); data.set(i, data.get(j)); data.set(j, t); }

public static <T extends Comparable<? super T>> boolean nextPerm(ArrayList<T> data) { // find the swaps int c = -1, d = data.size(); for (int i = d - 2; i >= 0; i--) if (data.get(i).compareTo(data.get(i + 1)) < 0) { c = i; break; }

if (c < 0) return false;

int s = c + 1; for (int j = c + 2; j < d; j++) if (data.get(j).compareTo(data.get(s)) < 0 && // data.get(j).compareTo(data.get(c)) > 0) s = j;

// do the swaps swap(data, c, s); while (--d > ++c) swap(data, c, d);

return true; }

public static <T extends Comparable<? super T>> ArrayList<ArrayList<T>> Permutations(ArrayList<T> d) { ArrayList<ArrayList<T>> result = new ArrayList<ArrayList<T>>(); Collections.sort(d); do { result.add(new ArrayList<T>(d)); } while (nextPerm(d)); return result; }

/**

*

* Topological sort solves a problem of - finding a linear ordering * of the vertices of V such that for each edge (i, j) ∈ E, * vertex i is to the left of vertex j. (Skiena 2008, p. 481) *

*

*

* Method is derived from of <a * href="http://en.wikipedia.org/wiki/Topological_sort#Algorithms" > Kahn's * pseudo code</a> and traverses over vertices as they are returned by input * map. Leaf nodes can have null or empty values. Every missing definition * is considered as a leaf node. *

*

* 

	 * // Input:
	 * { F1=[F2, F3, F4], F10=[F7, F4], F11=[F4], F2=[F3, F8, F4], F3=[F6], 
	 *   F4=null, F5=[F6, F4], F6=[F7, F8, F4], F7=[F4], F8=[F4], F9=[F4]}
	 *   
	 * // Output based on input type: 
	 * HashMap: [F4, F11, F8, F9, F7, F10, F6, F5, F3, F2, F1]
	 * TreeMap: [F4, F11, F7, F8, F9, F10, F6, F3, F5, F2, F1]
	 *

* * @param g * <a href="http://en.wikipedia.org/wiki/Directed_acyclic_graph" * > Directed Acyclic Graph</a>, where vertices are stored as * {@link java.util.HashMap HashMap} elements. * * @return Linear ordering of input nodes. If input map contains a * prerequisite that is undefined or cyclic dependency is detected, * then empty ArrayList will be returned. * */ public static <T> ArrayList<T> tSort(java.util.Map<T, ArrayList<T>> g) /** * @param L * Answer. * @param S * Not visited leaf vertices. * @param V * Visited vertices. * @param P * Predefined vertices. * @param n * Current element. */ { java.util.ArrayList<T> L = new ArrayList<T>(g.size()); java.util.Queue<T> S = new java.util.concurrent.LinkedBlockingDeque<T>(); java.util.HashSet<T> V = new java.util.HashSet<T>(), P = new java.util.HashSet<T>(); P.addAll(g.keySet()); T n;

// Find leaf nodes and missing leaf nodes. for (T t : g.keySet()) if (g.get(t) == null || g.get(t).isEmpty()) S.add(t); else for (T m : g.get(t)) if (!P.contains(m)) S.add(t);

// Visit all leaf nodes. while (!S.isEmpty()) { // First time seeing this leaf node? if (V.add(n = S.poll())) L.add(n);

// If any vertex contains only visited vertices and // contained current element n, add it to leaf nodes. for (T t : g.keySet()) if (g.get(t) != null && V.containsAll(g.get(t)) && !V.contains(t)) S.add(t); }

// Return empty ArrayList if input is not valid DAG. if (!L.containsAll(g.keySet())) return new ArrayList<T>(0); return L; }

/** * Creates a new {@code ArrayList} instance, containing input data. * * @param data * List of mutable input elements. * @return New {@link ArrayList} with input elements. */ public static <T> ArrayList<T> aList(T... data) { if (data == null) return new ArrayList<T>(0); int capacity = 8 + data.length + (data.length >> 3); ArrayList<T> list = new ArrayList<T>(capacity); Collections.addAll(list, data); return list; }

/** * Creates a new {@code ArrayList} instance, containing integer sequence * between form and to. Sequence can be negative. * * @param from * Integer with what sequence starts. * @param to * Integer with what sequence ends. * @return List of mutable integer sequence. {@code if (from == to)}, then * empty ArrayList is returned. */ public static ArrayList<Integer> mRange(int from, int to) { if (from == to) return new ArrayList<Integer>(0); if (from < to) { ArrayList<Integer> result = new ArrayList<Integer>(// Math.abs(from - to) + 1); for (int i = from; i <= to; i++) result.add(i); return result; } ArrayList<Integer> result = new ArrayList<Integer>( Math.abs(from - to) + 1); for (int i = from; i >= to; i--) result.add(i); return result; } } </lang>

Retrieved from "https://rosettacode.org/wiki/User:Margusmartsepp/Contributions/Java/Utils.java?oldid=161943"