|
|
Strategy Pattern
The strategy pattern allows you to use different business rules or algorithms depending on the context in which they occur
When should I use the Strategy Pattern?
1. You can perform an operation in different ways
2. You want to select the operation dynamically at the runtime
3. You want to add new ways without modifying the application code
Real World Examples
1. File Compression Techniques
2. Layout Managers used by Containers in Java Swing
3. Comparators used in Arrays sort function
Read more ...
A generic implementation of Insertion Sort in Java
1 import org.junit.Assert;
2 import org.junit.Test;
3
4 class GenericInsertionSorter
5 {
6 public <T extends Comparable<T>> void sort(T[] elems) {
7 int size = elems.length;
8
9 for (int outerLoopIdx = 1; outerLoopIdx < size; ++outerLoopIdx) {
10 for (int innerLoopIdx = outerLoopIdx; innerLoopIdx > 0; --innerLoopIdx) {
11 if (elems[innerLoopIdx - 1].compareTo(elems[innerLoopIdx]) > 0) {
12 T temp = elems[innerLoopIdx - 1];
13 elems[innerLoopIdx - 1] = elems[innerLoopIdx];
14 elems[innerLoopIdx] = temp;
15 }
16 }
17 }
18 }
19 }
20
21 public class InsertionSortTester
22 {
23 private String[] unsortedNames = new String[] {
24 "Pankaj",
25 "Paresh",
26 "Ankit",
27 "Sankalp",
28 "Aditya",
29 "Prem",
30 "Rocket",
31 "Singh",
32 "Alabama",
33 "Alaska",
34 "Animal" };
35
36 private String[] sortedNames = new String[] {
37 "Aditya",
38 "Alabama",
39 "Alaska",
40 "Animal",
41 "Ankit",
42 "Pankaj",
43 "Paresh",
44 "Prem",
45 "Rocket",
46 "Sankalp",
47 "Singh" };
48
49 @Test
50 public void testStringSort() {
51 GenericInsertionSorter ss = new GenericInsertionSorter();
52 ss.sort(unsortedNames);
53 Assert.assertArrayEquals(unsortedNames, sortedNames);
54 }
55 }
Read more ...
Insertion Sort
An efficient elementary sort method which places each element in it's proper place among the elements which are already placed
1 #include <iostream>
2 #include <string.h>
3
4 template <typename T>
5 class InsertionSort
6 {
7 public:
8 InsertionSort();
9 ~InsertionSort();
10
11 void sort(T arr[], int size);
12 private:
13 void compareExchange(T arr[], int l, int r);
14 bool greater(T left, T right);
15 };
16
17
18 template <typename T>
19 InsertionSort<T>::InsertionSort(){}
20
21
22 template <typename T>
23 InsertionSort<T>::~InsertionSort(){}
24
25 template <typename T>
26 void InsertionSort<T>::sort(T arr[], int size)
27 {
28 for(int i = 1; i < size; ++i)
29 {
30 for(int j = i; j > 0; --j)
31 {
32 compareExchange(arr, j-1, j);
33 }
34 }
35 }
36
37 template <typename T>
38 void InsertionSort<T>::compareExchange(T arr[], int l, int r)
39 {
40 if(greater(arr[l], arr[r]))
41 {
42 T temp = arr[l];
43 arr[l] = arr[r];
44 arr[r] = temp;
45 }
46 }
47
48 template <typename T>
49 bool InsertionSort<T>::greater(T left, T right)
50 {
51 return left > right;
52 }
53
54 template <>
55 bool InsertionSort<const char*>::greater(const char *left, const char *right)
56 {
57 return strcmp(left, right) > 0;
58 }
59
60 template <typename T>
61 void print(T arr[], int size)
62 {
63 for(int i = 0; i < size; ++i)
64 std::cout << arr[i] << " ";
65 std::cout << std::endl;
66 }
67
68 template <>
69 void print(std::string arr[], int size)
70 {
71 for(int i = 0; i < size; ++i)
72 std::cout << arr[i].c_str() << " ";
73 std::cout << std::endl;
74 }
75
76 template <>
77 void print(const char *ptrArray, int size)
78 {
79 for(int i = 0; i < size; ++i)
80 std::cout << ptrArray[i] << " ";
81 std::cout << std::endl;
82 }
83
84 int main()
85 {
86 int arr[] = { 10, 65, 35, 25, 15, 75, 85, 45, 65 };
87 InsertionSort<int> isInt;
88 isInt.sort(arr, 9);
89 print(arr, 9);
90
91 std::string strArr[] = { "pankaj", "paresh", "hello", "world", "ankit", "aditya", "sankalp", "aladdin" };
92 InsertionSort<std::string> isString;
93 isString.sort(strArr, 8);
94 print(strArr, 8);
95
96 const char* ptrArray[] = { "pankaj", "paresh", "hello", "world", "ankit", "aditya", "sankalp", "aladdin", "george"};
97 InsertionSort<const char*> isPtr;
98 isPtr.sort(ptrArray, 9);
99 print(ptrArray, 9);
100
101 return 0;
102 }
Read more ...
A generic implementation of Selection Sort in Java using Generics
1 import org.junit.Assert;
2 import org.junit.Test;
3
4 class GenericSelectionSorter
5 {
6 public <T extends Comparable<T>> void sort(T[] elems) {
7 int size = elems.length;
8
9 for (int outerLoopIdx = 0; outerLoopIdx < size - 1; ++outerLoopIdx) {
10 int min = outerLoopIdx;
11 for (int innerLoopIdx = outerLoopIdx; innerLoopIdx < size; ++innerLoopIdx) {
12 if (elems[min].compareTo(elems[innerLoopIdx]) > 0) {
13 min = innerLoopIdx;
14 }
15 }
16
17
18 T temp = elems[min];
19 elems[min] = elems[outerLoopIdx];
20 elems[outerLoopIdx] = temp;
21 }
22 }
23 }
24
25 public class SelectionSortTester
26 {
27 private String[] unsortedNames = new String[] {
28 "Pankaj",
29 "Paresh",
30 "Ankit",
31 "Sankalp",
32 "Aditya",
33 "Prem",
34 "Rocket",
35 "Singh",
36 "Alabama",
37 "Alaska",
38 "Animal" };
39
40 private String[] sortedNames = new String[] {
41 "Aditya",
42 "Alabama",
43 "Alaska",
44 "Animal",
45 "Ankit",
46 "Pankaj",
47 "Paresh",
48 "Prem",
49 "Rocket",
50 "Sankalp",
51 "Singh" };
52
53 @Test
54 public void testStringSort() {
55 GenericSelectionSorter ss = new GenericSelectionSorter();
56 ss.sort(unsortedNames);
57 Assert.assertArrayEquals(unsortedNames, sortedNames);
58 }
59 }
Read more ...
Selection Sort
An elementary sorting technique which finds the smallest element in the array and then exchanges it with the element in the first position 1 #include <iostream>
2
3 class SelectionSort
4 {
5 public:
6 SelectionSort();
7 ~SelectionSort();
8
9 void sort(int arr[], int size);
10
11 private:
12 void exchange(int &x, int &y);
13 };
14
15
16 SelectionSort::SelectionSort() {}
17
18
19 SelectionSort::~SelectionSort() {}
20
21 void SelectionSort::sort(int arr[], int size)
22 {
23 for(int outerLoopIdx = 0; outerLoopIdx < size - 1; ++outerLoopIdx)
24 {
25 int min = outerLoopIdx;
26 for(int innerLoopIdx = outerLoopIdx + 1; innerLoopIdx < size; ++innerLoopIdx)
27 {
28 if(arr[min] > arr[innerLoopIdx])
29 {
30 min = innerLoopIdx;
31 }
32 }
33 exchange(arr[outerLoopIdx], arr[min]);
34 }
35 }
36
37 void SelectionSort::exchange(int &x, int &y)
38 {
39 int t = x;
40 x = y;
41 y = t;
42 }
43
44 void print(int arr[], int size)
45 {
46 for(int i = 0; i < size; ++i)
47 std::cout << arr[i] << " ";
48 }
49
50 int main()
51 {
52 int arr[] = { 10, 65, 35, 25, 15, 75, 85, 45, 65 };
53 SelectionSort ss;
54 ss.sort(arr, 9);
55 print(arr, 9);
56 }
Output:
Read more ...
|
|
