Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

jUnit Test on Selection Sort#20

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to ourterms of service andprivacy statement. We’ll occasionally send you account related emails.

Already on GitHub?Sign in to your account

Open
homnay1234 wants to merge6 commits intorampatra:master
base:master
Choose a base branch
Loading
fromhomnay1234:master
Open
Show file tree
Hide file tree
Changes fromall commits
Commits
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
73 changes: 73 additions & 0 deletionsRefactor BinarySearch Algorithm
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,73 @@
public class BinarySearch {

/**
* Searches an element {@param n} in a sorted array {@param a}
* and returns its index in O(log n) time. The Index may not
* correspond to the first occurrence of the element.
*
* @param a sorted array to be searched
* @param n number to be searched in the array
* @return index of {@param n} or {@code -1} if not present
*/
public static int binarySearch(int[] a, int n) {
return binarySearch(a, n, 0, a.length - 1);
}

public static int binarySearch(int[] a, int n, int low, int high) {

if (low <= high) {
int mid = (low + high) / 2; // to prevent overflow you can instead do: mid = low + (high - low) / 2

if (n == a[mid]) {
return mid;
} else if (n < a[mid]) {
return binarySearch(a, n, 0, mid - 1);
} else {
return binarySearch(a, n, mid + 1, high);
}
} else {
return -1;
}
}

/**
* Non-recursive version of binary search.
*
* @param a sorted array to be searched
* @param n number to be searched in the array
* @return index of {@param n} or {@code -1} if not present
*/
public static int binarySearchNonRecursive(int[] a, int n) {
int low = 0, high = a.length, mid;
while (low <= high) {
mid = (low + high) / 2; // to prevent overflow you can instead do: mid = low + (high - low) / 2
if (n == a[mid]) {
return mid;
} else if (n < a[mid]) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return -1;
}

/**
* Driver for testing.
*
* @param a
*/
public static void main(String[] args) {
System.out.println(binarySearch(new int[]{0, 2}, 2));
System.out.println(binarySearch(new int[]{0, 1, 2, 3}, 2));
System.out.println(binarySearch(new int[]{0, 1, 2, 3}, 3));
System.out.println(binarySearch(new int[]{0, 2}, 0));
System.out.println(binarySearch(new int[]{0, 1, 2, 2, 2, 3, 3}, 2)); // doesn't return index of first occurrence
System.out.println("---------");
System.out.println(binarySearchNonRecursive(new int[]{0, 2}, 2));
System.out.println(binarySearchNonRecursive(new int[]{0, 1, 2, 3}, 2));
System.out.println(binarySearchNonRecursive(new int[]{0, 1, 2, 3}, 3));
System.out.println(binarySearchNonRecursive(new int[]{0, 2}, 0));
System.out.println(binarySearchNonRecursive(new int[]{0, 1, 2, 2, 2, 3, 3}, 2));
}
}
43 changes: 43 additions & 0 deletionsTestBinarySearch
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,43 @@
import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;

class TestSearch {

BinarySearch binarySearch = new BinarySearch() ;
@Test
public void tesInsertIntoSorted() {
int[] inputArr = new int[] {0,1,2,3,4};
assertTrue( binarySearch.binarySearch(inputArr, 2) ==2 );
}

BinarySearch binarySearch1 = new BinarySearch() ;
@Test
public void tesInsertIntoSorted1() {
int[] inputArr = new int[] {0,1,2,3,4};
assertTrue( binarySearch1.binarySearch(inputArr, 1)==1 );
}

BinarySearch binarySearch2 = new BinarySearch() ;
@Test
public void tesInsertIntoSorted2() {
int[] inputArr = new int[] {0,1,2,3,4};
assertTrue( binarySearch2.binarySearch(inputArr, 0)==0 );
}

BinarySearch binarySearch3 = new BinarySearch() ;
@Test
public void tesInsertIntoSorted3() {
int[] inputArr = new int[] {0,1,2,3,4};
assertTrue( binarySearch3.binarySearch(inputArr, 1)==1 );
}

BinarySearch binarySearch4 = new BinarySearch() ;
@Test
public void tesInsertIntoSorted4() {
int[] inputArr = new int[] {0,1,2,3,4};
assertTrue( binarySearch4.binarySearch(inputArr, 1)==1 );
}


}
73 changes: 73 additions & 0 deletionsTestBinarySearch2
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,73 @@
public class BinarySearch {

/**
* Searches an element {@param n} in a sorted array {@param a}
* and returns its index in O(log n) time. The Index may not
* correspond to the first occurrence of the element.
*
* @param a sorted array to be searched
* @param n number to be searched in the array
* @return index of {@param n} or {@code -1} if not present
*/
public static int binarySearch(int[] a, int n) {
return binarySearch(a, n, 0, a.length - 1);
}

public static int binarySearch(int[] a, int n, int low, int high) {

if (low <= high) {
int mid = (low + high) / 2; // to prevent overflow you can instead do: mid = low + (high - low) / 2

if (n == a[mid]) {
return mid;
} else if (n < a[mid]) {
return binarySearch(a, n, 0, mid - 1);
} else {
return binarySearch(a, n, mid + 1, high);
}
} else {
return -1;
}
}

/**
* Non-recursive version of binary search.
*
* @param a sorted array to be searched
* @param n number to be searched in the array
* @return index of {@param n} or {@code -1} if not present
*/
public static int binarySearchNonRecursive(int[] a, int n) {
int low = 0, high = a.length, mid;
while (low <= high) {
mid = (low + high) / 2; // to prevent overflow you can instead do: mid = low + (high - low) / 2
if (n == a[mid]) {
return mid;
} else if (n < a[mid]) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return -1;
}

/**
* Driver for testing.
*
* @param a
*/
public static void main(String[] args) {
System.out.println(binarySearch(new int[]{0, 2}, 2));
System.out.println(binarySearch(new int[]{0, 1, 2, 3}, 2));
System.out.println(binarySearch(new int[]{0, 1, 2, 3}, 3));
System.out.println(binarySearch(new int[]{0, 2}, 0));
System.out.println(binarySearch(new int[]{0, 1, 2, 2, 2, 3, 3}, 2)); // doesn't return index of first occurrence
System.out.println("---------");
System.out.println(binarySearchNonRecursive(new int[]{0, 2}, 2));
System.out.println(binarySearchNonRecursive(new int[]{0, 1, 2, 3}, 2));
System.out.println(binarySearchNonRecursive(new int[]{0, 1, 2, 3}, 3));
System.out.println(binarySearchNonRecursive(new int[]{0, 2}, 0));
System.out.println(binarySearchNonRecursive(new int[]{0, 1, 2, 2, 2, 3, 3}, 2));
}
}
36 changes: 36 additions & 0 deletionsTestSelectionSort
View file
Open in desktop
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
import static org.junit.jupiter.api.Assertions.*;

import org.junit.jupiter.api.Test;

class TestSort {

SelectionSort selectionSort = new SelectionSort();
@Test
public void tesInsertIntoSorted() {
int[] inputArr = new int[] {1,3,5};
int[] inputResult = new int[] {1,3,5};
selectionSort.selectionSort(inputArr);
assertArrayEquals(inputResult, inputArr);
}

SelectionSort selectionSort2 = new SelectionSort();
@Test
public void tesInsertIntoSorted2() {
int[] inputArr = new int[] {5,3,1};
int[] inputResult = new int[] {1,3,5};
selectionSort.selectionSort(inputArr);
assertArrayEquals(inputResult, inputArr);
}


SelectionSort selectionSort3 = new SelectionSort();
@Test
public void tesInsertIntoSorted3() {
int[] inputArr = new int[] {4,5,3,2};
int[] inputResult = new int[] {2,3,4,5};
selectionSort.selectionSort(inputArr);
assertArrayEquals(inputResult, inputArr);
}


}
[8]ページ先頭
©2009-2025 Movatter.jp