Merge remote-tracking branch 'upstream/master'

.gitignore

@@ -39,7 +39,6 @@ target/
 spring-openid/src/main/resources/application.properties
 .recommenders/
 /spring-hibernate4/nbproject/
-spring-security-openid/src/main/resources/application.properties
 
 spring-all/*.log
 

README.md

@@ -1,3 +1,4 @@
+**UPDATE**: The price of "Learn Spring Security OAuth" will permanently change on the 11th of December, along with the upcoming OAuth2 material: http://bit.ly/github-lss
 
 The Courses
 ==============================

algorithms-miscellaneous-3/README.md

@@ -15,5 +15,4 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [Creating a Triangle with for Loops in Java](https://www.baeldung.com/java-print-triangle)
 - [Efficient Word Frequency Calculator in Java](https://www.baeldung.com/java-word-frequency)
 - [The K-Means Clustering Algorithm in Java](https://www.baeldung.com/java-k-means-clustering-algorithm)
-- [Creating a Custom Annotation in Java](https://www.baeldung.com/java-custom-annotation)
 - More articles: [[<-- prev]](/algorithms-miscellaneous-2) [[next -->]](/algorithms-miscellaneous-4)

algorithms-miscellaneous-5/README.md

@@ -10,4 +10,6 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [Find If Two Numbers Are Relatively Prime in Java](https://www.baeldung.com/java-two-relatively-prime-numbers)
 - [Knapsack Problem Implementation in Java](https://www.baeldung.com/java-knapsack)
 - [How to Determine if a Binary Tree is Balanced](https://www.baeldung.com/java-balanced-binary-tree)
+- [The Caesar Cipher in Java](https://www.baeldung.com/java-caesar-cipher)
+- [Overview of Combinatorial Problems in Java](https://www.baeldung.com/java-combinatorial-algorithms)
 - More articles: [[<-- prev]](/../algorithms-miscellaneous-4)

algorithms-miscellaneous-5/pom.xml

@@ -34,6 +34,11 @@
             <artifactId>tradukisto</artifactId>
             <version>${tradukisto.version}</version>
         </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>28.1-jre</version>
+        </dependency>
 
         <dependency>
             <groupId>org.assertj</groupId>

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/greedy/Follower.java

@@ -0,0 +1,20 @@
+package com.baeldung.algorithms.greedy;
+
+import lombok.Getter;
+
+public class Follower {
+
+    @Getter String username;
+    @Getter long count;
+    
+    public Follower(String username, long count) {
+        super();
+        this.username = username;
+        this.count = count;
+    }
+    
+    @Override
+    public String toString() {
+        return "User: " + username + ", Followers: " + count + "\n\r" ; 
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/greedy/FollowersPath.java

@@ -0,0 +1,44 @@
+package com.baeldung.algorithms.greedy;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FollowersPath {
+
+    private List<Follower> accounts;
+    private long count;
+    
+    public FollowersPath() {
+        super();
+        this.accounts = new ArrayList<>();
+    }
+    
+    public List<Follower> getAccounts() {
+        return accounts;
+    }
+    public long getCount() {
+        return count;
+    }
+    
+    public void addFollower(String username, long count) {
+        accounts.add(new Follower(username, count));
+    }
+    
+    public void addCount(long count) {
+        this.count += count;
+    }
+    
+    @Override
+    public String toString() {
+        String details = "";
+        for(Follower a : accounts) {
+            details+=a.toString() + ", ";
+        }
+        
+        return "Total: " + count + ", \n\r" +
+                " Details: { " + "\n\r" + 
+                details + "\n\r" + 
+                " }";
+    }
+    
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/greedy/GreedyAlgorithm.java

@@ -0,0 +1,43 @@
+package com.baeldung.algorithms.greedy;
+
+import java.util.List;
+
+public class GreedyAlgorithm {
+
+    int currentLevel = 0;
+    final int maxLevel = 3; 
+    SocialConnector sc;
+    FollowersPath fp;
+    
+    public GreedyAlgorithm(SocialConnector sc) {
+        super();
+        this.sc = sc;
+        this.fp = new FollowersPath();
+    }
+    
+    public long findMostFollowersPath(String account) {
+        long max = 0;
+        SocialUser toFollow = null;
+        
+        List<SocialUser> followers = sc.getFollowers(account);
+        for (SocialUser el : followers) {
+            long followersCount = el.getFollowersCount();
+            if (followersCount > max) {
+                toFollow = el;
+                max = followersCount;
+            }
+        }
+        
+        if (currentLevel < maxLevel - 1) {
+            currentLevel++;
+            max += findMostFollowersPath(toFollow.getUsername());
+            return max;
+        } else {
+            return max;
+        }            
+    }
+    
+    public FollowersPath getFollowers() {
+        return fp;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/greedy/NonGreedyAlgorithm.java

@@ -0,0 +1,43 @@
+package com.baeldung.algorithms.greedy;
+
+import java.util.List;
+
+public class NonGreedyAlgorithm {
+
+    int currentLevel = 0;
+    final int maxLevel = 3; 
+    SocialConnector tc;
+    
+    public NonGreedyAlgorithm(SocialConnector tc, int level) {
+        super();
+        this.tc = tc;
+        this.currentLevel = level;
+    }
+      
+    public long findMostFollowersPath(String account) {
+        List<SocialUser> followers = tc.getFollowers(account);
+        long total = currentLevel > 0 ? followers.size() : 0;
+
+        if (currentLevel < maxLevel ) {
+            currentLevel++;
+
+            long[] count = new long[followers.size()];
+            int i = 0;
+            for (SocialUser el : followers) {
+                NonGreedyAlgorithm sub = new NonGreedyAlgorithm(tc, currentLevel);
+                count[i] = sub.findMostFollowersPath(el.getUsername());
+                i++;
+            }
+            
+            long max = 0;
+            for (; i > 0; i--) {
+                if (count[i-1] > max )
+                    max = count[i-1];
+            }
+            
+            return total + max;
+        }
+        
+        return total;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/greedy/SocialConnector.java

@@ -0,0 +1,36 @@
+package com.baeldung.algorithms.greedy;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import lombok.Getter;
+import lombok.Setter;
+
+public class SocialConnector {
+    private boolean isCounterEnabled = true;
+    private int counter = 4;
+    @Getter @Setter List<SocialUser> users;
+    
+    public SocialConnector() {
+        users = new ArrayList<>();
+    }
+    
+    public boolean switchCounter() {
+        this.isCounterEnabled = !this.isCounterEnabled;
+        return this.isCounterEnabled;
+    }
+    
+    public List<SocialUser> getFollowers(String account) {
+        if (counter < 0)
+            throw new IllegalStateException ("API limit reached");
+        else {
+            if(this.isCounterEnabled) counter--;
+            for(SocialUser user : users) {
+                if (user.getUsername().equals(account)) {
+                    return user.getFollowers();
+                }
+            }
+        }
+        return new ArrayList<>();
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/greedy/SocialUser.java

@@ -0,0 +1,38 @@
+package com.baeldung.algorithms.greedy;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import lombok.Getter;
+
+public class SocialUser {
+
+    @Getter private String username;
+    @Getter private List<SocialUser> followers;
+
+    public SocialUser(String username) {
+        super();
+        this.username = username;
+        this.followers = new ArrayList<>();
+    }
+    
+    public SocialUser(String username, List<SocialUser> followers) {
+        super();
+        this.username = username;
+        this.followers = followers;
+    }
+    
+    public long getFollowersCount() {
+        return followers.size();
+    }
+    
+    public void addFollowers(List<SocialUser> followers) {
+        this.followers.addAll(followers);
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+        return ((SocialUser) obj).getUsername().equals(username);
+    }
+    
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/integerstreammedian/MedianOfIntegerStream.java

@@ -0,0 +1,42 @@
+package com.baeldung.algorithms.integerstreammedian;
+
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+import static java.util.Comparator.reverseOrder;
+
+public class MedianOfIntegerStream {
+
+    private Queue<Integer> minHeap, maxHeap;
+
+    MedianOfIntegerStream() {
+        minHeap = new PriorityQueue<>();
+        maxHeap = new PriorityQueue<>(reverseOrder());
+    }
+
+    void add(int num) {
+        if (!minHeap.isEmpty() && num < minHeap.peek()) {
+            maxHeap.offer(num);
+            if (maxHeap.size() > minHeap.size() + 1) {
+                minHeap.offer(maxHeap.poll());
+            }
+        } else {
+            minHeap.offer(num);
+            if (minHeap.size() > maxHeap.size() + 1) {
+                maxHeap.offer(minHeap.poll());
+            }
+        }
+    }
+
+    double getMedian() {
+        int median;
+        if (minHeap.size() < maxHeap.size()) {
+            median = maxHeap.peek();
+        } else if (minHeap.size() > maxHeap.size()) {
+            median = minHeap.peek();
+        } else {
+            median = (minHeap.peek() + maxHeap.peek()) / 2;
+        }
+        return median;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/integerstreammedian/MedianOfIntegerStream2.java

@@ -0,0 +1,36 @@
+package com.baeldung.algorithms.integerstreammedian;
+
+import java.util.PriorityQueue;
+import java.util.Queue;
+
+import static java.util.Comparator.reverseOrder;
+
+public class MedianOfIntegerStream2 {
+
+    private Queue<Integer> minHeap, maxHeap;
+
+    MedianOfIntegerStream2() {
+        minHeap = new PriorityQueue<>();
+        maxHeap = new PriorityQueue<>(reverseOrder());
+    }
+
+    void add(int num) {
+        if (minHeap.size() == maxHeap.size()) {
+            maxHeap.offer(num);
+            minHeap.offer(maxHeap.poll());
+        } else {
+            minHeap.offer(num);
+            maxHeap.offer(minHeap.poll());
+        }
+    }
+
+    double getMedian() {
+        int median;
+        if (minHeap.size() > maxHeap.size()) {
+            median = minHeap.peek();
+        } else {
+            median = (minHeap.peek() + maxHeap.peek()) / 2;
+        }
+        return median;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/kruskal/CycleDetector.java

@@ -0,0 +1,72 @@
+package com.baeldung.algorithms.kruskal;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CycleDetector {
+
+    List<DisjointSetInfo> nodes;
+
+    public CycleDetector(int totalNodes) {
+        initDisjointSets(totalNodes);
+    }
+
+    public boolean detectCycle(Integer u, Integer v) {
+        Integer rootU = pathCompressionFind(u);
+        Integer rootV = pathCompressionFind(v);
+        if (rootU.equals(rootV)) {
+            return true;
+        }
+        unionByRank(rootU, rootV);
+        return false;
+    }
+
+    private void initDisjointSets(int totalNodes) {
+        nodes = new ArrayList<>(totalNodes);
+        for (int i = 0; i < totalNodes; i++) {
+            nodes.add(new DisjointSetInfo(i));
+        }
+    }
+
+    private Integer find(Integer node) {
+        Integer parent = nodes.get(node).getParentNode();
+        if (parent.equals(node)) {
+            return node;
+        } else {
+            return find(parent);
+        }
+    }
+
+    private Integer pathCompressionFind(Integer node) {
+        DisjointSetInfo setInfo = nodes.get(node);
+        Integer parent = setInfo.getParentNode();
+        if (parent.equals(node)) {
+            return node;
+        } else {
+            Integer parentNode = find(parent);
+            setInfo.setParentNode(parentNode);
+            return parentNode;
+        }
+    }
+
+    private void union(Integer rootU, Integer rootV) {
+        DisjointSetInfo setInfoU = nodes.get(rootU);
+        setInfoU.setParentNode(rootV);
+    }
+
+    private void unionByRank(int rootU, int rootV) {
+        DisjointSetInfo setInfoU = nodes.get(rootU);
+        DisjointSetInfo setInfoV = nodes.get(rootV);
+        int rankU = setInfoU.getRank();
+        int rankV = setInfoV.getRank();
+        if (rankU < rankV) {
+            setInfoU.setParentNode(rootV);
+        } else {
+            setInfoV.setParentNode(rootU);
+            if (rankU == rankV) {
+                setInfoU.setRank(rankU + 1);
+            }
+        }
+    }
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/kruskal/DisjointSetInfo.java

@@ -0,0 +1,28 @@
+package com.baeldung.algorithms.kruskal;
+
+public class DisjointSetInfo {
+
+    private Integer parentNode;
+    private int rank;
+
+    DisjointSetInfo(Integer nodeNumber) {
+        setParentNode(nodeNumber);
+        setRank(1);
+    }
+
+    public Integer getParentNode() {
+        return parentNode;
+    }
+
+    public void setParentNode(Integer parentNode) {
+        this.parentNode = parentNode;
+    }
+
+    public int getRank() {
+        return rank;
+    }
+
+    public void setRank(int rank) {
+        this.rank = rank;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/kruskal/Kruskal.java

@@ -0,0 +1,53 @@
+package com.baeldung.algorithms.kruskal;
+
+import com.google.common.graph.EndpointPair;
+import com.google.common.graph.MutableValueGraph;
+import com.google.common.graph.ValueGraph;
+import com.google.common.graph.ValueGraphBuilder;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+
+public class Kruskal {
+
+    public ValueGraph<Integer, Double> minSpanningTree(ValueGraph<Integer, Double> graph) {
+
+        return spanningTree(graph, true);
+    }
+
+    public ValueGraph<Integer, Double> maxSpanningTree(ValueGraph<Integer, Double> graph) {
+        return spanningTree(graph, false);
+    }
+
+    private ValueGraph<Integer, Double> spanningTree(ValueGraph<Integer, Double> graph, boolean minSpanningTree) {
+        Set<EndpointPair<Integer>> edges = graph.edges();
+        List<EndpointPair<Integer>> edgeList = new ArrayList<>(edges);
+
+        if (minSpanningTree) {
+            edgeList.sort(Comparator.comparing(e -> graph.edgeValue(e).get()));
+        } else {
+            edgeList.sort(Collections.reverseOrder(Comparator.comparing(e -> graph.edgeValue(e).get())));
+        }
+
+        int totalNodes = graph.nodes().size();
+        CycleDetector cycleDetector = new CycleDetector(totalNodes);
+        int edgeCount = 0;
+
+        MutableValueGraph<Integer, Double> spanningTree = ValueGraphBuilder.undirected().build();
+        for (EndpointPair<Integer> edge : edgeList) {
+            if (cycleDetector.detectCycle(edge.nodeU(), edge.nodeV())) {
+                continue;
+            }
+            spanningTree.putEdgeValue(edge.nodeU(), edge.nodeV(), graph.edgeValue(edge).get());
+            edgeCount++;
+            if (edgeCount == totalNodes - 1) {
+                break;
+            }
+        }
+        return spanningTree;
+    }
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/maximumsubarray/BruteForceAlgorithm.java

@@ -0,0 +1,35 @@
+package com.baeldung.algorithms.maximumsubarray;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class BruteForceAlgorithm {
+
+    private Logger logger = LoggerFactory.getLogger(BruteForceAlgorithm.class.getName());
+
+    public int maxSubArray(int[] arr) {
+
+        int size = arr.length;
+        int maximumSubArraySum = Integer.MIN_VALUE;
+        int start = 0;
+        int end = 0;
+
+        for (int left = 0; left < size; left++) {
+
+            int runningWindowSum = 0;
+
+            for (int right = left; right < size; right++) {
+                runningWindowSum += arr[right];
+
+                if (runningWindowSum > maximumSubArraySum) {
+                    maximumSubArraySum = runningWindowSum;
+                    start = left;
+                    end = right;
+                }
+            }
+        }
+        logger.info("Found Maximum Subarray between {} and {}", start, end);
+        return maximumSubArraySum;
+    }
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/maximumsubarray/KadaneAlgorithm.java

@@ -0,0 +1,34 @@
+package com.baeldung.algorithms.maximumsubarray;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class KadaneAlgorithm {
+
+    private Logger logger = LoggerFactory.getLogger(BruteForceAlgorithm.class.getName());
+
+    public int maxSubArraySum(int[] arr) {
+
+        int size = arr.length;
+        int start = 0;
+        int end = 0;
+
+        int maxSoFar = 0, maxEndingHere = 0;
+
+        for (int i = 0; i < size; i++) {
+
+            if (arr[i] > maxEndingHere + arr[i]) {
+                start = i;
+                maxEndingHere = arr[i];
+            } else
+                maxEndingHere = maxEndingHere + arr[i];
+
+            if (maxSoFar < maxEndingHere) {
+                maxSoFar = maxEndingHere;
+                end = i;
+            }
+        }
+        logger.info("Found Maximum Subarray between {} and {}", start, end);
+        return maxSoFar;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/mergesortedarrays/SortedArrays.java

@@ -0,0 +1,33 @@
+package com.baeldung.algorithms.mergesortedarrays;
+
+public class SortedArrays {
+
+    public static int[] merge(int[] foo, int[] bar) {
+
+        int fooLength = foo.length;
+        int barLength = bar.length;
+
+        int[] merged = new int[fooLength + barLength];
+
+        int fooPosition, barPosition, mergedPosition;
+        fooPosition = barPosition = mergedPosition = 0;
+
+        while (fooPosition < fooLength && barPosition < barLength) {
+            if (foo[fooPosition] < bar[barPosition]) {
+                merged[mergedPosition++] = foo[fooPosition++];
+            } else {
+                merged[mergedPosition++] = bar[barPosition++];
+            }
+        }
+
+        while (fooPosition < fooLength) {
+            merged[mergedPosition++] = foo[fooPosition++];
+        }
+
+        while (barPosition < barLength) {
+            merged[mergedPosition++] = bar[barPosition++];
+        }
+
+        return merged;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/prim/Edge.java

@@ -0,0 +1,36 @@
+package com.baeldung.algorithms.prim;
+
+public class Edge {
+
+    private int weight;
+    private boolean isIncluded = false;
+    private boolean isPrinted = false;
+
+    public Edge(int weight) {
+        this.weight = weight;
+    }
+
+    public int getWeight() {
+        return weight;
+    }
+
+    public void setWeight(int weight) {
+        this.weight = weight;
+    }
+
+    public boolean isIncluded() {
+        return isIncluded;
+    }
+
+    public void setIncluded(boolean included) {
+        isIncluded = included;
+    }
+
+    public boolean isPrinted() {
+        return isPrinted;
+    }
+
+    public void setPrinted(boolean printed) {
+        isPrinted = printed;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/prim/Prim.java

@@ -0,0 +1,73 @@
+package com.baeldung.algorithms.prim;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.math3.util.Pair;
+
+public class Prim {
+
+    private List<Vertex> graph;
+
+    public Prim(List<Vertex> graph){
+        this.graph = graph;
+    }
+
+    public void run(){
+        if (graph.size() > 0){
+            graph.get(0).setVisited(true);
+        }
+        while (isDisconnected()){
+            Edge nextMinimum = new Edge(Integer.MAX_VALUE);
+            Vertex nextVertex = graph.get(0);
+            for (Vertex vertex : graph){
+                if (vertex.isVisited()){
+                    Pair<Vertex, Edge> candidate = vertex.nextMinimum();
+                    if (candidate.getValue().getWeight() < nextMinimum.getWeight()){
+                        nextMinimum = candidate.getValue();
+                        nextVertex = candidate.getKey();
+                    }
+                }
+            }
+            nextMinimum.setIncluded(true);
+            nextVertex.setVisited(true);
+        }
+    }
+
+    private boolean isDisconnected(){
+        for (Vertex vertex : graph){
+            if (!vertex.isVisited()){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public String originalGraphToString(){
+        StringBuilder sb = new StringBuilder();
+        for (Vertex vertex : graph){
+            sb.append(vertex.originalToString());
+        }
+        return sb.toString();
+    }
+
+    public void resetPrintHistory(){
+        for (Vertex vertex : graph){
+            Iterator<Map.Entry<Vertex,Edge>> it = vertex.getEdges().entrySet().iterator();
+            while (it.hasNext()) {
+                Map.Entry<Vertex,Edge> pair = it.next();
+                pair.getValue().setPrinted(false);
+            }
+        }
+    }
+
+    public String minimumSpanningTreeToString(){
+        StringBuilder sb = new StringBuilder();
+        for (Vertex vertex : graph){
+            sb.append(vertex.includedToString());
+        }
+        return sb.toString();
+    }
+
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/prim/Vertex.java

@@ -0,0 +1,106 @@
+package com.baeldung.algorithms.prim;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.apache.commons.math3.util.Pair;
+
+public class Vertex {
+
+    private String label = null;
+    private Map<Vertex, Edge> edges = new HashMap<>();
+    private boolean isVisited = false;
+
+    public Vertex(String label){
+        this.label = label;
+    }
+
+    public String getLabel() {
+        return label;
+    }
+
+    public void setLabel(String label) {
+        this.label = label;
+    }
+
+    public Map<Vertex, Edge> getEdges() {
+        return edges;
+    }
+
+    public void addEdge(Vertex vertex, Edge edge){
+        if (this.edges.containsKey(vertex)){
+            if (edge.getWeight() < this.edges.get(vertex).getWeight()){
+                this.edges.replace(vertex, edge);
+            }
+        } else {
+            this.edges.put(vertex, edge);
+        }
+    }
+
+    public boolean isVisited() {
+        return isVisited;
+    }
+
+    public void setVisited(boolean visited) {
+        isVisited = visited;
+    }
+
+    public Pair<Vertex, Edge> nextMinimum(){
+        Edge nextMinimum = new Edge(Integer.MAX_VALUE);
+        Vertex nextVertex = this;
+        Iterator<Map.Entry<Vertex,Edge>> it = edges.entrySet().iterator();
+        while (it.hasNext()) {
+            Map.Entry<Vertex,Edge> pair = it.next();
+            if (!pair.getKey().isVisited()){
+                if (!pair.getValue().isIncluded()) {
+                    if (pair.getValue().getWeight() < nextMinimum.getWeight()) {
+                        nextMinimum = pair.getValue();
+                        nextVertex = pair.getKey();
+                    }
+                }
+            }
+        }
+        return new Pair<>(nextVertex, nextMinimum);
+    }
+
+    public String originalToString(){
+        StringBuilder sb = new StringBuilder();
+        Iterator<Map.Entry<Vertex,Edge>> it = edges.entrySet().iterator();
+        while (it.hasNext()) {
+            Map.Entry<Vertex,Edge> pair = it.next();
+            if (!pair.getValue().isPrinted()) {
+                sb.append(getLabel());
+                sb.append(" --- ");
+                sb.append(pair.getValue().getWeight());
+                sb.append(" --- ");
+                sb.append(pair.getKey().getLabel());
+                sb.append("\n");
+                pair.getValue().setPrinted(true);
+            }
+        }
+        return sb.toString();
+    }
+
+    public String includedToString(){
+        StringBuilder sb = new StringBuilder();
+        if (isVisited()) {
+            Iterator<Map.Entry<Vertex,Edge>> it = edges.entrySet().iterator();
+            while (it.hasNext()) {
+                Map.Entry<Vertex,Edge> pair = it.next();
+                if (pair.getValue().isIncluded()) {
+                    if (!pair.getValue().isPrinted()) {
+                        sb.append(getLabel());
+                        sb.append(" --- ");
+                        sb.append(pair.getValue().getWeight());
+                        sb.append(" --- ");
+                        sb.append(pair.getKey().getLabel());
+                        sb.append("\n");
+                        pair.getValue().setPrinted(true);
+                    }
+                }
+            }
+        }
+        return sb.toString();
+    }
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/greedy/GreedyAlgorithmUnitTest.java

@@ -0,0 +1,58 @@
+package com.baeldung.algorithms.greedy;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.Arrays;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class GreedyAlgorithmUnitTest {
+
+    private SocialConnector prepareNetwork() {
+        SocialConnector sc = new SocialConnector();
+        SocialUser root = new SocialUser("root");
+        SocialUser child1 = new SocialUser("child1");
+        SocialUser child2 = new SocialUser("child2");
+        SocialUser child3 = new SocialUser("child3");
+        SocialUser child21 = new SocialUser("child21");
+        SocialUser child211 = new SocialUser("child211");
+        SocialUser child2111 = new SocialUser("child2111");
+        SocialUser child31 = new SocialUser("child31");
+        SocialUser child311 = new SocialUser("child311");
+        SocialUser child3111 = new SocialUser("child3111");
+        child211.addFollowers(Arrays.asList(new SocialUser[]{child2111}));
+        child311.addFollowers(Arrays.asList(new SocialUser[]{child3111}));
+        child21.addFollowers(Arrays.asList(new SocialUser[]{child211}));
+        child31.addFollowers(Arrays.asList(new SocialUser[]{child311, 
+          new SocialUser("child312"), new SocialUser("child313"), new SocialUser("child314")}));
+        child1.addFollowers(Arrays.asList(new SocialUser[]{new SocialUser("child11"), new SocialUser("child12")}));
+        child2.addFollowers(Arrays.asList(new SocialUser[]{child21, new SocialUser("child22"), new SocialUser("child23")}));
+        child3.addFollowers(Arrays.asList(new SocialUser[]{child31}));
+        root.addFollowers(Arrays.asList(new SocialUser[]{child1, child2, child3}));
+        sc.setUsers(Arrays.asList(new SocialUser[]{root, child1, child2, child3, child21, child31, child311, child211}));
+        return sc;
+    }
+
+    @Test
+    public void greedyAlgorithmTest() {
+        GreedyAlgorithm ga = new GreedyAlgorithm(prepareNetwork());
+        assertEquals(ga.findMostFollowersPath("root"), 5);
+    }
+
+    @Test
+    public void nongreedyAlgorithmTest() {
+        NonGreedyAlgorithm nga = new NonGreedyAlgorithm(prepareNetwork(), 0);
+        Assertions.assertThrows(IllegalStateException.class, () -> {
+            nga.findMostFollowersPath("root");
+          });
+    }
+
+    @Test
+    public void nongreedyAlgorithmUnboundedTest() {
+        SocialConnector sc = prepareNetwork();
+        sc.switchCounter();
+        NonGreedyAlgorithm nga = new NonGreedyAlgorithm(sc, 0);
+        assertEquals(nga.findMostFollowersPath("root"), 6);
+    }
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/integerstreammedian/MedianOfIntegerStreamUnitTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.algorithms.integerstreammedian;
+
+import org.junit.Test;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+
+public class MedianOfIntegerStreamUnitTest {
+
+    @Test
+    public void givenStreamOfIntegers_whenAnElementIsRead_thenMedianChangesWithApproach1() {
+        MedianOfIntegerStream mis = new MedianOfIntegerStream();
+        for (Map.Entry<Integer, Double> e : testcaseFixture().entrySet()) {
+            mis.add(e.getKey());
+            assertEquals(e.getValue(), (Double) mis.getMedian());
+        }
+    }
+
+    @Test
+    public void givenStreamOfIntegers_whenAnElementIsRead_thenMedianChangesWithApproach2() {
+        MedianOfIntegerStream2 mis = new MedianOfIntegerStream2();
+        for (Map.Entry<Integer, Double> e : testcaseFixture().entrySet()) {
+            mis.add(e.getKey());
+            assertEquals(e.getValue(), (Double) mis.getMedian());
+        }
+    }
+
+    private Map<Integer, Double> testcaseFixture() {
+        return new LinkedHashMap<Integer, Double>() {{
+            put(1, 1d);
+            put(7, 4d);
+            put(5, 5d);
+            put(8, 6d);
+            put(3, 5d);
+            put(9, 6d);
+            put(4, 5d);
+        }};
+    }
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/kruskal/KruskalUnitTest.java

@@ -0,0 +1,67 @@
+package com.baeldung.algorithms.kruskal;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Before;
+import org.junit.Test;
+import com.google.common.graph.MutableValueGraph;
+import com.google.common.graph.ValueGraph;
+import com.google.common.graph.ValueGraphBuilder;
+import com.baeldung.algorithms.kruskal.Kruskal;
+
+public class KruskalUnitTest {
+
+    private MutableValueGraph<Integer, Double> graph;
+
+    @Before
+    public void setup() {
+        graph = ValueGraphBuilder.undirected().build();
+        graph.putEdgeValue(0, 1, 8.0);
+        graph.putEdgeValue(0, 2, 5.0);
+        graph.putEdgeValue(1, 2, 9.0);
+        graph.putEdgeValue(1, 3, 11.0);
+        graph.putEdgeValue(2, 3, 15.0);
+        graph.putEdgeValue(2, 4, 10.0);
+        graph.putEdgeValue(3, 4, 7.0);
+    }
+
+    @Test
+    public void givenGraph_whenMinimumSpanningTree_thenOutputCorrectResult() {
+        final Kruskal kruskal = new Kruskal();
+        ValueGraph<Integer, Double> spanningTree = kruskal.minSpanningTree(graph);
+
+        assertTrue(spanningTree.hasEdgeConnecting(0, 1));
+        assertTrue(spanningTree.hasEdgeConnecting(0, 2));
+        assertTrue(spanningTree.hasEdgeConnecting(2, 4));
+        assertTrue(spanningTree.hasEdgeConnecting(3, 4));
+        assertEquals(graph.edgeValue(0, 1), spanningTree.edgeValue(0, 1));
+        assertEquals(graph.edgeValue(0, 2), spanningTree.edgeValue(0, 2));
+        assertEquals(graph.edgeValue(2, 4), spanningTree.edgeValue(2, 4));
+        assertEquals(graph.edgeValue(3, 4), spanningTree.edgeValue(3, 4));
+
+        assertFalse(spanningTree.hasEdgeConnecting(1, 2));
+        assertFalse(spanningTree.hasEdgeConnecting(1, 3));
+        assertFalse(spanningTree.hasEdgeConnecting(2, 3));
+    }
+
+    @Test
+    public void givenGraph_whenMaximumSpanningTree_thenOutputCorrectResult() {
+        final Kruskal kruskal = new Kruskal();
+        ValueGraph<Integer, Double> spanningTree = kruskal.maxSpanningTree(graph);
+
+        assertTrue(spanningTree.hasEdgeConnecting(0, 1));
+        assertTrue(spanningTree.hasEdgeConnecting(1, 3));
+        assertTrue(spanningTree.hasEdgeConnecting(2, 3));
+        assertTrue(spanningTree.hasEdgeConnecting(2, 4));
+        assertEquals(graph.edgeValue(0, 1), spanningTree.edgeValue(0, 1));
+        assertEquals(graph.edgeValue(1, 3), spanningTree.edgeValue(1, 3));
+        assertEquals(graph.edgeValue(2, 3), spanningTree.edgeValue(2, 3));
+        assertEquals(graph.edgeValue(2, 4), spanningTree.edgeValue(2, 4));
+
+        assertFalse(spanningTree.hasEdgeConnecting(0, 2));
+        assertFalse(spanningTree.hasEdgeConnecting(1, 2));
+        assertFalse(spanningTree.hasEdgeConnecting(3, 4));
+    }
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/maximumsubarray/BruteForceAlgorithmUnitTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.algorithms.maximumsubarray;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class BruteForceAlgorithmUnitTest {
+
+    @Test
+    void givenArrayWithNegativeNumberWhenMaximumSubarrayThenReturns6() {
+        //given
+        int[] arr = new int[]{-3, 1, -8, 4, -1, 2, 1, -5, 5};
+        //when
+        BruteForceAlgorithm algorithm = new BruteForceAlgorithm();
+        int maximumSum = algorithm.maxSubArray(arr);
+        //then
+        assertEquals(6, maximumSum);
+    }
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/maximumsubarray/KadaneAlgorithmUnitTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.algorithms.maximumsubarray;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class KadaneAlgorithmUnitTest {
+
+    @Test
+    void givenArrayWithNegativeNumberWhenMaximumSubarrayThenReturns6() {
+        //given
+        int[] arr = new int[]{-3, 1, -8, 4, -1, 2, 1, -5, 5};
+        //when
+        KadaneAlgorithm algorithm = new KadaneAlgorithm();
+        int maxSum = algorithm.maxSubArraySum(arr);
+        //then
+        assertEquals(6, maxSum);
+    }
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/mergesortedarrays/SortedArraysUnitTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.algorithms.mergesortedarrays;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import org.junit.jupiter.api.Test;
+
+import com.baeldung.algorithms.mergesortedarrays.SortedArrays;
+
+public class SortedArraysUnitTest {
+
+    @Test
+    public void givenTwoSortedArrays_whenMerged_thenReturnMergedSortedArray() {
+
+        int[] foo = { 3, 7 };
+        int[] bar = { 4, 8, 11 };
+        int[] merged = { 3, 4, 7, 8, 11 };
+
+        assertArrayEquals(merged, SortedArrays.merge(foo, bar));
+    }
+
+    @Test
+    public void givenTwoSortedArraysWithDuplicates_whenMerged_thenReturnMergedSortedArray() {
+
+        int[] foo = { 3, 3, 7 };
+        int[] bar = { 4, 8, 8, 11 };
+        int[] merged = { 3, 3, 4, 7, 8, 8, 11 };
+
+        assertArrayEquals(merged, SortedArrays.merge(foo, bar));
+    }
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/prim/PrimUnitTest.java

@@ -0,0 +1,54 @@
+package com.baeldung.algorithms.prim;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.junit.Test;
+
+public class PrimUnitTest {
+
+    @Test
+    public void givenAGraph_whenPrimRuns_thenPrintMST() {
+        Prim prim = new Prim(createGraph());
+        System.out.println(prim.originalGraphToString());
+        System.out.println("----------------");
+        prim.run();
+        System.out.println();
+        prim.resetPrintHistory();
+        System.out.println(prim.minimumSpanningTreeToString());
+    }
+
+    public static List<Vertex> createGraph() {
+        List<Vertex> graph = new ArrayList<>();
+        Vertex a = new Vertex("A");
+        Vertex b = new Vertex("B");
+        Vertex c = new Vertex("C");
+        Vertex d = new Vertex("D");
+        Vertex e = new Vertex("E");
+        Edge ab = new Edge(2);
+        a.addEdge(b, ab);
+        b.addEdge(a, ab);
+        Edge ac = new Edge(3);
+        a.addEdge(c, ac);
+        c.addEdge(a, ac);
+        Edge bc = new Edge(2);
+        b.addEdge(c, bc);
+        c.addEdge(b, bc);
+        Edge be = new Edge(5);
+        b.addEdge(e, be);
+        e.addEdge(b, be);
+        Edge cd = new Edge(1);
+        c.addEdge(d, cd);
+        d.addEdge(c, cd);
+        Edge ce = new Edge(1);
+        c.addEdge(e, ce);
+        e.addEdge(c, ce);
+        graph.add(a);
+        graph.add(b);
+        graph.add(c);
+        graph.add(d);
+        graph.add(e);
+        return graph;
+    }
+
+}

algorithms-searching/README.md

@@ -9,3 +9,4 @@ This module contains articles about searching algorithms.
 - [Breadth-First Search Algorithm in Java](https://www.baeldung.com/java-breadth-first-search)
 - [String Search Algorithms for Large Texts](https://www.baeldung.com/java-full-text-search-algorithms)
 - [Monte Carlo Tree Search for Tic-Tac-Toe Game](https://www.baeldung.com/java-monte-carlo-tree-search)
+- [Range Search Algorithm in Java](https://www.baeldung.com/java-range-search)