From 804bbc4a42b0c951dedb711a5b576b7b8a3003d7 Mon Sep 17 00:00:00 2001 From: TINO Date: Sat, 14 Dec 2019 17:40:21 +0300 Subject: [PATCH 1/5] BAEL- 3482 Initial commit --- .../algorithms/minheapmerge/HeapNode.java | 13 ++++ .../algorithms/minheapmerge/MinHeap.java | 63 +++++++++++++++++++ .../algorithms/minheapmerge/MinHeapMerge.java | 56 +++++++++++++++++ 3 files changed, 132 insertions(+) create mode 100644 algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/HeapNode.java create mode 100644 algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java create mode 100644 algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeapMerge.java diff --git a/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/HeapNode.java b/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/HeapNode.java new file mode 100644 index 0000000000..9e8439cb87 --- /dev/null +++ b/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/HeapNode.java @@ -0,0 +1,13 @@ +package com.baeldung.algorithms.minheapmerge; + +public class HeapNode { + + int element; + int arrayIndex; + int nextElementIndex = 1; + + public HeapNode(int element, int arrayIndex) { + this.element = element; + this.arrayIndex = arrayIndex; + } +} diff --git a/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java b/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java new file mode 100644 index 0000000000..d19ffa6e46 --- /dev/null +++ b/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java @@ -0,0 +1,63 @@ +package com.baeldung.algorithms.minheapmerge; + +public class MinHeap { + + HeapNode[] heapNodes; + int heapSize; + + public MinHeap(HeapNode heapNodes[]) { + this.heapSize = heapNodes.length; + this.heapNodes = heapNodes; + heapifyFromLastLeafsParent(); + } + + void heapifyFromLastLeafsParent() { + int lastLeafsParentIndex = getParentNodeIndex(heapSize); + while (lastLeafsParentIndex >= 0) { + heapify(lastLeafsParentIndex); + lastLeafsParentIndex--; + } + } + + void heapify(int index) { + int leftNodeIndex = getLeftNodeIndex(index); + int rightNodeIndex = getRightNodeIndex(index); + int smallestElementIndex = index; + if (leftNodeIndex < heapSize && heapNodes[leftNodeIndex].element < heapNodes[index].element) + smallestElementIndex = leftNodeIndex; + + if (rightNodeIndex < heapSize && heapNodes[rightNodeIndex].element < heapNodes[smallestElementIndex].element) + smallestElementIndex = rightNodeIndex; + + if (smallestElementIndex != index) { + swap(index, smallestElementIndex); + heapify(smallestElementIndex); + } + } + + int getParentNodeIndex(int index) { + return (index - 1) / 2; + } + + int getLeftNodeIndex(int index) { + return (2 * index + 1); + } + + int getRightNodeIndex(int index) { + return (2 * index + 2); + } + + HeapNode getRootNode() { + return heapNodes[0]; + } + + void hepifyFromRoot(HeapNode root) { + heapify(0); + } + + void swap(int i, int j) { + HeapNode temp = heapNodes[i]; + heapNodes[i] = heapNodes[j]; + heapNodes[j] = temp; + } +} diff --git a/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeapMerge.java b/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeapMerge.java new file mode 100644 index 0000000000..62cb46321c --- /dev/null +++ b/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeapMerge.java @@ -0,0 +1,56 @@ +package com.baeldung.algorithms.minheapmerge; + +public class MinHeapMerge { + + static void printArray(int[] array) { + for (int i = 0; i < array.length; i++) { + System.out.print(array[i] + " "); + } + } + + static int populateHeapNodesAndDetermineResultingArrayLength(int[][] array, HeapNode[] heapNodes) { + int resultSize = 0; + + for (int i = 0; i < array.length; i++) { + HeapNode node = new HeapNode(array[i][0], i); + heapNodes[i] = node; + resultSize += array[i].length; + } + return resultSize; + } + + static int[] createMinHeapAndMergeArrays(int[][] array, HeapNode[] heapNodes, int resultingArraySize) { + + MinHeap minHeap = new MinHeap(heapNodes); + int[] resultingArray = new int[resultingArraySize]; + + for (int i = 0; i < resultingArraySize; i++) { + HeapNode root = minHeap.getRootNode(); + resultingArray[i] = root.element; + + if (root.nextElementIndex < array[root.arrayIndex].length) { + root.element = array[root.arrayIndex][root.nextElementIndex++]; + } else { + root.element = Integer.MAX_VALUE; + } + minHeap.hepifyFromRoot(root); + } + return resultingArray; + } + + static void merge(int[][] array) { + HeapNode[] heapNodes = new HeapNode[array.length]; + int resultingArraySize = populateHeapNodesAndDetermineResultingArrayLength(array, heapNodes); + + int[] resultingArray = createMinHeapAndMergeArrays(array, heapNodes, resultingArraySize); + + printArray(resultingArray); + + } + + public static void main(String args[]) { + int[][] array = { { 0, 6 }, { 1, 5, 10, 100 }, { 2, 4, 650, 200 }, { 3, 4 }, { 1001, 6456, 23000 } }; + + merge(array); + } +} From e9c4979c4d8f942f35824f1504d5ad65cce4ee9f Mon Sep 17 00:00:00 2001 From: TINO Date: Sat, 21 Dec 2019 16:55:42 +0300 Subject: [PATCH 2/5] BAEL - 3482 Added unit test --- .../algorithms/minheapmerge/MinHeap.java | 14 ++++---- .../algorithms/minheapmerge/MinHeapMerge.java | 22 ++---------- .../minheapmerge/MinHeapmergeUnitTest.java | 35 +++++++++++++++++++ 3 files changed, 44 insertions(+), 27 deletions(-) create mode 100644 algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapmergeUnitTest.java diff --git a/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java b/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java index d19ffa6e46..94b3abfbd6 100644 --- a/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java +++ b/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java @@ -3,16 +3,14 @@ package com.baeldung.algorithms.minheapmerge; public class MinHeap { HeapNode[] heapNodes; - int heapSize; public MinHeap(HeapNode heapNodes[]) { - this.heapSize = heapNodes.length; this.heapNodes = heapNodes; heapifyFromLastLeafsParent(); } void heapifyFromLastLeafsParent() { - int lastLeafsParentIndex = getParentNodeIndex(heapSize); + int lastLeafsParentIndex = getParentNodeIndex(heapNodes.length); while (lastLeafsParentIndex >= 0) { heapify(lastLeafsParentIndex); lastLeafsParentIndex--; @@ -23,12 +21,12 @@ public class MinHeap { int leftNodeIndex = getLeftNodeIndex(index); int rightNodeIndex = getRightNodeIndex(index); int smallestElementIndex = index; - if (leftNodeIndex < heapSize && heapNodes[leftNodeIndex].element < heapNodes[index].element) + if (leftNodeIndex < heapNodes.length && heapNodes[leftNodeIndex].element < heapNodes[index].element) smallestElementIndex = leftNodeIndex; - - if (rightNodeIndex < heapSize && heapNodes[rightNodeIndex].element < heapNodes[smallestElementIndex].element) + + if (rightNodeIndex < heapNodes.length && heapNodes[rightNodeIndex].element < heapNodes[smallestElementIndex].element) smallestElementIndex = rightNodeIndex; - + if (smallestElementIndex != index) { swap(index, smallestElementIndex); heapify(smallestElementIndex); @@ -51,7 +49,7 @@ public class MinHeap { return heapNodes[0]; } - void hepifyFromRoot(HeapNode root) { + void heapifyFromRoot() { heapify(0); } diff --git a/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeapMerge.java b/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeapMerge.java index 62cb46321c..8cb375c3c6 100644 --- a/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeapMerge.java +++ b/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeapMerge.java @@ -2,12 +2,6 @@ package com.baeldung.algorithms.minheapmerge; public class MinHeapMerge { - static void printArray(int[] array) { - for (int i = 0; i < array.length; i++) { - System.out.print(array[i] + " "); - } - } - static int populateHeapNodesAndDetermineResultingArrayLength(int[][] array, HeapNode[] heapNodes) { int resultSize = 0; @@ -33,24 +27,14 @@ public class MinHeapMerge { } else { root.element = Integer.MAX_VALUE; } - minHeap.hepifyFromRoot(root); + minHeap.heapifyFromRoot(); } return resultingArray; } - static void merge(int[][] array) { + static int[] merge(int[][] array) { HeapNode[] heapNodes = new HeapNode[array.length]; int resultingArraySize = populateHeapNodesAndDetermineResultingArrayLength(array, heapNodes); - - int[] resultingArray = createMinHeapAndMergeArrays(array, heapNodes, resultingArraySize); - - printArray(resultingArray); - - } - - public static void main(String args[]) { - int[][] array = { { 0, 6 }, { 1, 5, 10, 100 }, { 2, 4, 650, 200 }, { 3, 4 }, { 1001, 6456, 23000 } }; - - merge(array); + return createMinHeapAndMergeArrays(array, heapNodes, resultingArraySize); } } diff --git a/algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapmergeUnitTest.java b/algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapmergeUnitTest.java new file mode 100644 index 0000000000..1d80651f92 --- /dev/null +++ b/algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapmergeUnitTest.java @@ -0,0 +1,35 @@ +package com.baeldung.algorithms.minheapmerge; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertThat; + +import org.junit.Test; + +public class MinHeapmergeUnitTest { + + private final int[][] inputArray = { { 0, 6 }, { 1, 5, 10, 100 }, { 2, 4, 200, 650 } }; + private final int[] expectedArray = { 0, 1, 2, 4, 5, 6, 10, 100, 200, 650 }; + + @Test + public void givenSortedArraysWhenMergedShouldReturnASingleSortedarray() { + int[] resultArray = MinHeapMerge.merge(inputArray); + assertThat(resultArray.length, is(equalTo(10))); + assertThat(resultArray, is(equalTo(expectedArray))); + } + + @Test + public void givenEmptyHeapNodesAndInputArrayWhenPopulatedShouldPopulateAndReturnResultArrayLength() { + int size = MinHeapMerge.populateHeapNodesAndDetermineResultingArrayLength(inputArray, new HeapNode[inputArray.length]); + assertThat(size, is(equalTo(10))); + } + + @Test + public void givenArrayAndHeapNodesAndResultArraySizeWhenMergedShouldReturnASingleSortedarray() { + HeapNode[] heapNodes = new HeapNode[inputArray.length]; + int size = MinHeapMerge.populateHeapNodesAndDetermineResultingArrayLength(inputArray, heapNodes); + int[] resultArray = MinHeapMerge.createMinHeapAndMergeArrays(inputArray, heapNodes, size); + assertThat(resultArray.length, is(equalTo(10))); + assertThat(resultArray, is(equalTo(expectedArray))); + } +} From 5fdffad7641122d25cad56f0db9e7d699f6211ff Mon Sep 17 00:00:00 2001 From: TINO Date: Mon, 23 Dec 2019 18:11:22 +0300 Subject: [PATCH 3/5] BAEL - 3482 --- .../com/baeldung/algorithms/minheapmerge/MinHeap.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java b/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java index 94b3abfbd6..cd6847e2bb 100644 --- a/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java +++ b/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java @@ -21,12 +21,12 @@ public class MinHeap { int leftNodeIndex = getLeftNodeIndex(index); int rightNodeIndex = getRightNodeIndex(index); int smallestElementIndex = index; - if (leftNodeIndex < heapNodes.length && heapNodes[leftNodeIndex].element < heapNodes[index].element) + if (leftNodeIndex < heapNodes.length && heapNodes[leftNodeIndex].element < heapNodes[index].element) { smallestElementIndex = leftNodeIndex; - - if (rightNodeIndex < heapNodes.length && heapNodes[rightNodeIndex].element < heapNodes[smallestElementIndex].element) + } + if (rightNodeIndex < heapNodes.length && heapNodes[rightNodeIndex].element < heapNodes[smallestElementIndex].element) { smallestElementIndex = rightNodeIndex; - + } if (smallestElementIndex != index) { swap(index, smallestElementIndex); heapify(smallestElementIndex); From b5f9e1fd7ad3958e2c174eedffc9cb6cca7c0d57 Mon Sep 17 00:00:00 2001 From: TINO Date: Mon, 23 Dec 2019 18:22:40 +0300 Subject: [PATCH 4/5] BAEL - 3482 --- ...pmergeUnitTest.java => MinHeapMergeUnitTest.java} | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) rename algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/{MinHeapmergeUnitTest.java => MinHeapMergeUnitTest.java} (74%) diff --git a/algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapmergeUnitTest.java b/algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapMergeUnitTest.java similarity index 74% rename from algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapmergeUnitTest.java rename to algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapMergeUnitTest.java index 1d80651f92..6e4b8421c6 100644 --- a/algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapmergeUnitTest.java +++ b/algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapMergeUnitTest.java @@ -6,29 +6,33 @@ import static org.junit.Assert.assertThat; import org.junit.Test; -public class MinHeapmergeUnitTest { +public class MinHeapMergeUnitTest { private final int[][] inputArray = { { 0, 6 }, { 1, 5, 10, 100 }, { 2, 4, 200, 650 } }; private final int[] expectedArray = { 0, 1, 2, 4, 5, 6, 10, 100, 200, 650 }; @Test - public void givenSortedArraysWhenMergedShouldReturnASingleSortedarray() { + public void givenSortedArrays_whenMerged_thenShouldReturnASingleSortedarray() { int[] resultArray = MinHeapMerge.merge(inputArray); + assertThat(resultArray.length, is(equalTo(10))); assertThat(resultArray, is(equalTo(expectedArray))); } @Test - public void givenEmptyHeapNodesAndInputArrayWhenPopulatedShouldPopulateAndReturnResultArrayLength() { + public void givenEmptyHeapNodesAndInputArray_whenPopulated_thenShouldPopulateAndReturnResultArrayLength() { int size = MinHeapMerge.populateHeapNodesAndDetermineResultingArrayLength(inputArray, new HeapNode[inputArray.length]); + assertThat(size, is(equalTo(10))); } @Test - public void givenArrayAndHeapNodesAndResultArraySizeWhenMergedShouldReturnASingleSortedarray() { + public void givenArrayAndHeapNodesAndResultArraySize_whenMerged_thenShouldReturnASingleSortedarray() { HeapNode[] heapNodes = new HeapNode[inputArray.length]; int size = MinHeapMerge.populateHeapNodesAndDetermineResultingArrayLength(inputArray, heapNodes); + int[] resultArray = MinHeapMerge.createMinHeapAndMergeArrays(inputArray, heapNodes, size); + assertThat(resultArray.length, is(equalTo(10))); assertThat(resultArray, is(equalTo(expectedArray))); } From 28a32ae0cb27e97cf868dcc9b61f8424995186ca Mon Sep 17 00:00:00 2001 From: TINO Date: Sat, 4 Jan 2020 12:38:37 +0300 Subject: [PATCH 5/5] BAEL-3482 Code re-factor --- .../algorithms/minheapmerge/MinHeap.java | 27 +++++++++++++ .../algorithms/minheapmerge/MinHeapMerge.java | 40 ------------------- .../minheapmerge/MinHeapMergeUnitTest.java | 39 ------------------ .../minheapmerge/MinHeapUnitTest.java | 22 ++++++++++ 4 files changed, 49 insertions(+), 79 deletions(-) delete mode 100644 algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeapMerge.java delete mode 100644 algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapMergeUnitTest.java create mode 100644 algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapUnitTest.java diff --git a/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java b/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java index cd6847e2bb..b77ce43160 100644 --- a/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java +++ b/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeap.java @@ -58,4 +58,31 @@ public class MinHeap { heapNodes[i] = heapNodes[j]; heapNodes[j] = temp; } + + static int[] merge(int[][] array) { + HeapNode[] heapNodes = new HeapNode[array.length]; + int resultingArraySize = 0; + + for (int i = 0; i < array.length; i++) { + HeapNode node = new HeapNode(array[i][0], i); + heapNodes[i] = node; + resultingArraySize += array[i].length; + } + + MinHeap minHeap = new MinHeap(heapNodes); + int[] resultingArray = new int[resultingArraySize]; + + for (int i = 0; i < resultingArraySize; i++) { + HeapNode root = minHeap.getRootNode(); + resultingArray[i] = root.element; + + if (root.nextElementIndex < array[root.arrayIndex].length) { + root.element = array[root.arrayIndex][root.nextElementIndex++]; + } else { + root.element = Integer.MAX_VALUE; + } + minHeap.heapifyFromRoot(); + } + return resultingArray; + } } diff --git a/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeapMerge.java b/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeapMerge.java deleted file mode 100644 index 8cb375c3c6..0000000000 --- a/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/minheapmerge/MinHeapMerge.java +++ /dev/null @@ -1,40 +0,0 @@ -package com.baeldung.algorithms.minheapmerge; - -public class MinHeapMerge { - - static int populateHeapNodesAndDetermineResultingArrayLength(int[][] array, HeapNode[] heapNodes) { - int resultSize = 0; - - for (int i = 0; i < array.length; i++) { - HeapNode node = new HeapNode(array[i][0], i); - heapNodes[i] = node; - resultSize += array[i].length; - } - return resultSize; - } - - static int[] createMinHeapAndMergeArrays(int[][] array, HeapNode[] heapNodes, int resultingArraySize) { - - MinHeap minHeap = new MinHeap(heapNodes); - int[] resultingArray = new int[resultingArraySize]; - - for (int i = 0; i < resultingArraySize; i++) { - HeapNode root = minHeap.getRootNode(); - resultingArray[i] = root.element; - - if (root.nextElementIndex < array[root.arrayIndex].length) { - root.element = array[root.arrayIndex][root.nextElementIndex++]; - } else { - root.element = Integer.MAX_VALUE; - } - minHeap.heapifyFromRoot(); - } - return resultingArray; - } - - static int[] merge(int[][] array) { - HeapNode[] heapNodes = new HeapNode[array.length]; - int resultingArraySize = populateHeapNodesAndDetermineResultingArrayLength(array, heapNodes); - return createMinHeapAndMergeArrays(array, heapNodes, resultingArraySize); - } -} diff --git a/algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapMergeUnitTest.java b/algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapMergeUnitTest.java deleted file mode 100644 index 6e4b8421c6..0000000000 --- a/algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapMergeUnitTest.java +++ /dev/null @@ -1,39 +0,0 @@ -package com.baeldung.algorithms.minheapmerge; - -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.is; -import static org.junit.Assert.assertThat; - -import org.junit.Test; - -public class MinHeapMergeUnitTest { - - private final int[][] inputArray = { { 0, 6 }, { 1, 5, 10, 100 }, { 2, 4, 200, 650 } }; - private final int[] expectedArray = { 0, 1, 2, 4, 5, 6, 10, 100, 200, 650 }; - - @Test - public void givenSortedArrays_whenMerged_thenShouldReturnASingleSortedarray() { - int[] resultArray = MinHeapMerge.merge(inputArray); - - assertThat(resultArray.length, is(equalTo(10))); - assertThat(resultArray, is(equalTo(expectedArray))); - } - - @Test - public void givenEmptyHeapNodesAndInputArray_whenPopulated_thenShouldPopulateAndReturnResultArrayLength() { - int size = MinHeapMerge.populateHeapNodesAndDetermineResultingArrayLength(inputArray, new HeapNode[inputArray.length]); - - assertThat(size, is(equalTo(10))); - } - - @Test - public void givenArrayAndHeapNodesAndResultArraySize_whenMerged_thenShouldReturnASingleSortedarray() { - HeapNode[] heapNodes = new HeapNode[inputArray.length]; - int size = MinHeapMerge.populateHeapNodesAndDetermineResultingArrayLength(inputArray, heapNodes); - - int[] resultArray = MinHeapMerge.createMinHeapAndMergeArrays(inputArray, heapNodes, size); - - assertThat(resultArray.length, is(equalTo(10))); - assertThat(resultArray, is(equalTo(expectedArray))); - } -} diff --git a/algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapUnitTest.java b/algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapUnitTest.java new file mode 100644 index 0000000000..80d0d20f05 --- /dev/null +++ b/algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/minheapmerge/MinHeapUnitTest.java @@ -0,0 +1,22 @@ +package com.baeldung.algorithms.minheapmerge; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertThat; + +import org.junit.Test; + +public class MinHeapUnitTest { + + private final int[][] inputArray = { { 0, 6 }, { 1, 5, 10, 100 }, { 2, 4, 200, 650 } }; + private final int[] expectedArray = { 0, 1, 2, 4, 5, 6, 10, 100, 200, 650 }; + + @Test + public void givenSortedArrays_whenMerged_thenShouldReturnASingleSortedarray() { + int[] resultArray = MinHeap.merge(inputArray); + + assertThat(resultArray.length, is(equalTo(10))); + assertThat(resultArray, is(equalTo(expectedArray))); + } + +}