Data Structures & Algorithms

Assignment Brief BTEC Level 4-5 HNC/HND Diploma (QCF) To be filled by the Learner Name of the Learner

:

Edexcel No

:

Centre No :

Batch:

Date of Submission : Unit Assessment Information Qualification

: Higher National Diploma in Computing and Systems Development

Unit Code & Title

: H/601/1456– Unit 34 - Data Structures and Algorithms

Assessment Title & No’s : Understand and implement Data structures and Strings (No 1 of 1) Learning outcomes and grading opportunities: LO 01: Understand data structures and algorithms LO1.1

Learning

LO1.2

LO 1.3

Outcomes LO 02: Be able to implement data structures and algorithms LO2.1

Learning

LO2.2

LO 2.3

Outcomes LO 03: Understand how strings are structured and processed. LO3.1

Learning

LO3.2

Outcomes Assessor

: Ms. J. Menaka

Internal Examiner (IE)

:

Mr.

Praveen

Mahendran Date Reviewed : 25/04/2013

Date of IE

: 25/04/2013

Date : 08/06/2013 MeritIssued and Distinction Descriptor

Date Due

: 30/06/2014

M1

M2

M3

D1

D2

D3

All rights reserved ©ESOFT Metro Campus, Sri Lanka

Page 1 of 52

Statement of Originality and Student Declaration

I hereby, declare that I know what plagiarism entails, namely to use another’s work and to present it as my own without attributing the sources in the correct way. I further understand what it means to copy another’s work. 1. I know that plagiarism is a punishable offence because it constitutes theft. 2. I understand the plagiarism and copying policy of the Edexcel UK. 3. I know what the consequences will be if I plagiaries or copy another’s work in any of the assignments for this program. 4. I declare therefore that all work presented by me for every aspects of my program, will be my own, and where I have made use of another’s work, I will attribute the source in the correct way. 5. I acknowledge that the attachment of this document signed or not, constitutes a binding agreement between myself and Edexcel UK. 6. I understand that my assignment will not be considered as submitted if this document is not attached to the attached.

Student’s Signature: ……………………………


Date:.………………

Page 2 of 52

Task 1 A palindrome is a phrase that reads the same forwards as it does backwards. For example, “a man, a plan, a canal, Panama,” is a palindrome. 1.1. Write a program that figures out whether one string is a palindrome. The program should ignore white space and punctuation. (LO3.2)(D3.4) For example: "a man, a plan, a canal, Panama" is a palindrome. "Don’t nod" is a palindrome. "Taco Cat!" is a palindrome. 1.2. Create an Example Stack class for this problem. Use LinkedList, ArrayList or an array to implement the Stack.(LO 1.1) 1.3. Identify and implement opportunities for error handling and reporting. (LO 2.2) 1.4. Test the above application with a suitable test cases (LO 2.3) 1.5. Prepare a user manual for the developed solution to assist the users to work with it.(M3) Task 2 London Met University provides apartments to undergraduate students. The housing system uses a waiting list for apartment allocation. According to the university policy, when a possible match between applicant and apartment is found, the applicant is contacted via email or phone call and must decide whether to accept the apartment. If the applicant does not accept, he or she is placed back of the waiting list, and must wait again. We will simulate this process using a queue, and simplify the rules. Moreover, we will ignore the realistic constraints of the applicants, and simply have each applicant store a quality threshold for the apartment quality (a random number between 0 and 100). We will also assume that each apartment, once accepted, will be occupied for a random number of school years between 1 and 3. Assume k students apply for housing each school year. Each student node should contain an ID number to keep track. Get k from the user via command line arguments. Insert apartment details through the keyboard. Each apartment should have an ID number, quality score (a random number between 0 and 100) The assignment process should remove a student from the queue if the student “accepts” the apartment (is the apartment’s quality value above the student’s threshold?). If the student accepts then delete the student node. If the student rejects the apartment delete the student, insert him to the back of the queue and compare next student and repeat. This process repeats until all students are housed. 2.1. Write your own implementation of the queue by using a linked list for this problem with all the queue operations (enque, deque,etc). (LO 1.1) 2.2. Test the above application with a suitable test cases (LO 2.3) Task 3


Page 3 of 52

3.1 Implement Binary search using recursive algorithm and non-recursive algorithm, and compare the performance. (LO 1.2) (LO 1.3) 3.2. Sort the array given below with two different algorithms and compare the performance. {10, 30, 20, 45, 85, 90, 75} (LO 1.2) 3.3. Explain common string operations such as concatenation, substring, trim etc., also state their practical applications.(LO 3.1)


Page 4 of 52

Assessment Criteria (Students are not authorized to modify or write anything on below) Outcomes/Criteria for PASS

Possible evidence

Page

Feedback

LO1 Understand data structures and algorithms 1.1 produce design specification for data structures explaining the valid operations that can be carried out on the structures 1.2 explain the operation and performance of sorting and search algorithms 1.3 explain the operation of recursive algorithms and identify situations when recursion is used

Task 1.1, Task 2.1 Task 3.1, Task 3.2 Task 3.2

LO2 Be able to implement data structures and algorithms 2.1 implement data structures in an executable programming language in the context of well-defined problems

2.2 implement opportunities for error handling and

Task 1.2,Task 2.1 Task 1.3

Reporting

2.3 test results to enable comparison with expected results

Task 1.4,Task 2.2

LO3 Understand how strings are structured and processed. 3.1 explain common string operations and their practical applications

3.2 demonstrate the outcome of string operations in specified algorithms.

Task 3.3 Task 1.1 Task 3.3 Task 1.1


Page 5 of 52

Grade Descriptor for MERIT M1 Identify and apply strategies to find appropriate solutions

Possible evidence Task 3.2

M1.3

Compare different algorithms for

an effective approach to study and research has been

Feedback

Task 3.3 searching and sorting

Applied

Search

about

different

string

operations M2

Select / design appropriate methods / techniques

M2.3

a range of sources of information has been used

Task 3 Proper use of Harvard Referencing Search

about

different

string

operations M3

Present and communicate appropriate findings

Task 1.5 Documentation is well structured

M3.1

the appropriate structure and approach has been used.

adhering to the formatting guidelines with non-overlapping facts. Data provided about the company are accurate, reliable and consistent


Page 6 of 52

Grade Descriptor for DISTINCTION D1 Use critical reflection to evaluate own work and justify valid conclusions

Possible evidence Report: shown in the self-reflection section, good conclusion with suggestions for further improvement

Feedback

D1.1

conclusions have been arrived at through synthesis of ideas and have been justified

D2

D2.3

Take responsibility for managing and organizing activities

Undertaken Activities from 01 – 05 as mentioned in the observation sheet

Activities have been managed Submitted the work on time

D3

Demonstrate convergent / lateral / creative thinking

D3.4

problems have been solved.

Task 1.1, Task 2.1, Task 3.1, Task 3.2


Page 7 of 52

Strengths:

Weaknesses:

Future Improvements & Assessor Comment:


Page 8 of 52

Assessor:

Signature:

Date: ____/____/______

Signature:

Date: ____/____/______

Internal Verifier’s Comments:

Internal Verifier:


Page 9 of 52

Practical Observation Sheet Module: Data Structures and Algorithms Unit No: 34 Student Name: _________________________________

Activity

Activity

No 1

2

Learning Outcome (LO)

Provide evidence of coding, and explain a piece of coding to the audience.

LO 2.1

Run the solution

LO 2.1

Date

Signature

LO 3.2

LO 3.2

3

Test the solution with random data

LO 2.3

4

Prove the use of Error Controlling Mechanism in the solution and Error reporting structure

LO 2.2

5

Compare the performance of different algorithms

D2

Comments:

Assessor Name

:

Date

:

Signature

:

Nilshan Devinda

REG: 7919

Data Structures & Algorithms

Unit 34

10

Table of Contents Table of Contents ................................................................................................................. xi Content of the Figures ....................................................................................................... xiii Acknowledgement ............................................................................................................... xv Task 01 ........................................................................................................................ 16 1.1 ........................................................................................................................................ 16 1.2 ........................................................................................................................................ 18 1.3 ........................................................................................................................................ 21 1.4 ........................................................................................................................................ 22 1.5 ........................................................................................................................................ 23 1.5.1 The User Manual .................................................................................................... 23 Task 02 ........................................................................................................................ 27 2.1 ........................................................................................................................................ 27 2.2 ........................................................................................................................................ 32 Task 03 ........................................................................................................................ 34 3.1 ........................................................................................................................................ 34 3.1.1 Binary Search Algorithm ........................................................................................ 34 3.1.2 Performance comparisons of Binary Searching Algorithms .................................. 37 3.2 ........................................................................................................................................ 38 3.2.1 Simple Sorting Algorithms ..................................................................................... 38 3.2.2 Divide and Conquered Algorithms ......................................................................... 40 3.2.3 Performance Comparison of Simple Sorting with Divide and Conquer

Sorting

Algorithms ....................................................................................................................... 42 3.3 ........................................................................................................................................ 42 3.3.1 Sub-Strings ............................................................................................................. 42 3.3.2 Concatenation ......................................................................................................... 44 3.3.3 Trim Method ........................................................................................................... 45 Appendices .......................................................................................................................... 46 Appendix A: Conclusion ................................................................................................. 46 Appendix B: Self-Reflection ........................................................................................... 47 Nilshan Devinda

REG: 7919


Unit 34

xi

Appendix C: The Gantt Chart.......................................................................................... 48 References ........................................................................................................................... 49 Bibliography ........................................................................................................................ 52

Nilshan Devinda

REG: 7919


Unit 34

xii

Content of the Figures Figure 1: Java code to determine whether a word is a Palindrome (Part 1). ....................... 16 Figure 2: Java code to determine whether a word is a Palindrome (Part 2). ....................... 17 Figure 3: Stack Class beginning. ......................................................................................... 18 Figure 4: Push method in Stack class. ................................................................................. 19 Figure 5: Pop method in Stack class. ................................................................................... 19 Figure 6: Peek method and end of Stack class. ................................................................... 20 Figure 7: Try Catch and Exception handling....................................................................... 21 Figure 8: Importing the Project ........................................................................................... 24 Figure 9: Starting the Program ............................................................................................ 25 Figure 10: Working with the Program ................................................................................. 26 Figure 11: Quitting the Program .......................................................................................... 26 Figure 12: Int Single Linked List Node ............................................................................... 27 Figure 13: Java code for Queue class .................................................................................. 27 Figure 14: Enque method in Queue class ............................................................................ 28 Figure 15: Deque method in Queue class ............................................................................ 28 Figure 16: Java code for Single Linked List........................................................................ 29 Figure 17: Remove Head method in Single Linked List class ............................................ 29 Figure 18: Main class for the queue .................................................................................... 30 Figure 19: Get Student ID method in Queue Main class ..................................................... 30 Figure 20: Get Room ID method in Queue Main class ....................................................... 31 Figure 21: Get Room Score method in Queue Main class .................................................. 31 Figure 22: Get Choice method in Queue Main class ........................................................... 32 Figure 23: Recursive Binary Search Function ..................................................................... 35 Figure 24: Main Method which calls the search function ................................................... 35 Figure 25: Non-Recursive Binary Searching Algorithm ..................................................... 36 Nilshan Devinda

REG: 7919


Unit 34

xiii

Figure 26: Main method of Non-Recursive Binary Searching Algorithm .......................... 37 Figure 27: Insertion Sort Algorithm .................................................................................... 39 Figure 28: Main method and Sort method in Merge Sort Algorithm .................................. 40 Figure 29: Do Merge Sort method in Merge Sort Algorithm .............................................. 41 Figure 30: Merge Parts method in Merge Sort Algorithm .................................................. 41 Figure 31: Substring and related methods ........................................................................... 43 Figure 32: Concatenation using the '+' operator .................................................................. 44 Figure 33: Concatenation of strings by append method ...................................................... 44 Figure 34: Concatenation of strings through the concat method ......................................... 45 Figure 35:String Trim method in java ................................................................................. 45

Nilshan Devinda

REG: 7919


Unit 34

xiv

Acknowledgement It is worth mentioning the names of my beloved lecturers including Miss Malsha Sethunge who helped a lot on completing this assignment on time. Special thanks to Mrs. Nimesha Rajakaruna for all the countless hours spent reviewing, helping, and explaining where necessary in making this a successful and accurate document. Finally, my friends require thanksgiving for helping and supporting me on occasion.

Nilshan Devinda

REG: 7919


Unit 34

xv

Task 01 1.1 Write a program that figures out whether one string is a palindrome. The program should ignore white space and punctuation. (LO3.2) (D3.4)

Figure 1: Java code to determine whether a word is a Palindrome (Part 1).

Source: Author’s work.

Nilshan Devinda

REG: 7919


Unit 34

16

Figure 2: Java code to determine whether a word is a Palindrome (Part 2).


Nilshan Devinda

REG: 7919


Unit 34

17

1.2 Create an Example Stack class for this problem. Use LinkedList, ArrayList or an array to implement the Stack. (LO 1.1)

Figure 3: Stack Class beginning.


Nilshan Devinda

REG: 7919


Unit 34

18

Figure 4: Push method in Stack class.


Figure 5: Pop method in Stack class.


Nilshan Devinda

REG: 7919


Unit 34

19

Figure 6: Peek method and end of Stack class.

Source: Author’s work

Nilshan Devinda

REG: 7919


Unit 34

20

1.3 Identify and implement opportunities for error handling and reporting. (LO 2.2)

Figure 7: Try Catch and Exception handling.


Nilshan Devinda

REG: 7919


Unit 34

21

1.4 Test the above application with a suitable test cases (LO 2.3) Table 1: Test results for the program. Expected Test Test Case Case Outcome ID

Actual Outcome

Status

01

Try to input Null value

Display an error message as ‘You didn’t type anything’.

02

Input words less than 3 letters in length

Display an error message as ‘Type at least 3 letters to check’.

Pass

Input a nonpalindrome

Display a message as ‘The text you entered is not a Palindrome’.

Pass

04

Input a Palindrome

Display a message as ‘It’s a palindrome’.

Pass

05

Input words with spaces

Spaces ignored

Pass

06

Input words containing Punctuation marks.

Punctuation marks ignored

Pass

03

Pass


Nilshan Devinda

REG: 7919


Unit 34

22

1.5 Prepare a user manual for the developed solution to assist the users to work with it. (M3)

1.5.1 The User Manual This manual assumes that the user is familiar with performing some basic operations inside the NetBeans IDE and has enough knowledge to follow up with an assisted screen on a CLI like output console. The user should have a working version of the NetBeans IDE to launch this application and therefore access it. 

Setting Things Up

The program uses the NetBeans IDE’s built in output console in order to communicate with the user, therefore it is critical for the source of the program to be imported as a project in the IDE. To import the program, first copy the project folder that came with the drive into one of the directories of the computer. Then launch the NetBeans desktop application. Click ‘File’ from the splitter containers found on top right of the IDE and click ‘Open Project’ in the menu that scrolls down as shown through the figure 8. Watch for the pop up window that appears and use it to navigate to the copied folder containing the project on the computer and select the appropriate project. Click on the ‘Open Project’ button to finish importing and to open the selected project in the IDE.

Nilshan Devinda

REG: 7919


Unit 34

23

Figure 8: Importing the Project

Source: Author’s work. 

Using the Program

Once the project is imported and ready to use, click ‘Debug’ on the splitter containers found on top of the IDE and click on ‘Debug Project’ in the menu that scrolls down as shown through the figure 9 below. The program will now run on the output console which will appear near the bottom of the IDE.

Nilshan Devinda

REG: 7919


Unit 34

24

Figure 9: Starting the Program

Source: Author’s work. The output console would now display a line of text as “Enter Something”. Try entering a palindrome which has to be at least 3 characters in length, and press enter to see whether it is a palindrome or not. Any punctuation marks or white spaces are ignored by the program and would instead focus on the word being entered. Once a cycle is finished where the user enters something to check whether it’s a palindrome, it would start the cycle again automatically giving the option to perform the above operation continuously. This scenario has been illustrated in the figure below.

Nilshan Devinda

REG: 7919


Unit 34

25

Figure 10: Working with the Program

Source: Author’s work. The program will run in an endless loop until it is quitted by its user. To quit the program, click ‘Run’, again at the top of the IDE, and click ‘Stop Build/Run’ to safely stop the program from running as shown through the image below. For further assistance, click ‘Help’ from the top most splitter containers to find a range of help options right from the IDE or from the internet.

Figure 11: Quitting the Program


Nilshan Devinda

REG: 7919


Unit 34

26

Task 02 2.1 Write your own implementation of the queue by using a linked list for this problem with all the queue operations (enque, deque, etc.). (LO 1.1)

Figure 12: Int Single Linked List Node


Figure 13: Java code for Queue class

Source: Author’s work. Nilshan Devinda

REG: 7919


Unit 34

27

Figure 14: Enque method in Queue class


Figure 15: Deque method in Queue class


Nilshan Devinda

REG: 7919


Unit 34

28

Figure 16: Java code for Single Linked List


Figure 17: Remove Head method in Single Linked List class


Nilshan Devinda

REG: 7919


Unit 34

29

Figure 18: Main class for the queue


Figure 19: Get Student ID method in Queue Main class


Nilshan Devinda

REG: 7919


Unit 34

30

Figure 20: Get Room ID method in Queue Main class


Figure 21: Get Room Score method in Queue Main class


Nilshan Devinda

REG: 7919


Unit 34

31

Figure 22: Get Choice method in Queue Main class


2.2 Test the above application with a suitable test cases (LO 2.3)

Nilshan Devinda

REG: 7919


Unit 34

32

Table 2: Test results for the Queue program

Test Case ID

Test Case

Expected Outcome

Actual Outcome

Status

1

Insert 1 as Display choice for message as room “Room has acceptance been assigned”

Pass

2

Insert 0 as Display choice for message as room “Please wait acceptance in the Queue”

Pass

3

Insert integer value other than 0 or 1 as choice for room acceptance

Display message as “Only 1 and 0 is valid”

Pass

4

Insert string value as choice for room acceptance

Display message as “Enter an integer value as the choice”

Pass

5

Insert string Display value as room message as score “Please enter an integer value as the score”

Pass

6

7

Insert integer value greater than 100 for room score

Display message as “Enter a value below 100 for the score”

Pass

Insert string Display value for message as student ID “The value entered is not an integer”

Pass


Nilshan Devinda

REG: 7919


Unit 34

33

Task 03 3.1 Implement Binary search using recursive algorithm and non-recursive algorithm, and compare the performance. (LO 1.2) (LO 1.3)

3.1.1 Binary Search Algorithm Among other types of searching mechanisms, binary search algorithm is a powerful searching algorithm which searches an input key at half intervals of a sorted array. It would then compare the value of the input key with the middle element value of the array to return the index of the middle element in case of a matching value, or to repeat the process in case of an unmatched value (Stoimen 2011). Unlike many sequential algorithms which searches from the beginning to end, binary search algorithm benefits from reduced working data sets where it divides the working range in halves in each comparison resulting in a highly efficient algorithm. Binary search algorithms are further classified as recursive binary search and non-recursive binary search algorithms as explained through the following points. 

Recursive Binary Searching Algorithm

A recursive binary searching algorithm is a function which accepts the array, the target value, the lower bound, and the upper bound as arguments to carry out the necessary calculations to compare the target value against the array as mentioned above. If the target value is found, the function returns the index from which the target value was found in the array. If the target value is not found, the function calls itself assigning new values that resulted from the previous comparison as arguments, and the function is recursively called until the target value is found. If the target value is not found after all possibilities are checked, or if the lower bound is greater than the target value in case of an array sorted in ascending order, -1 is returned to indicate the absence of the target value in the array (Forrest 2016). The 2 images below show how recursive binary searching is implemented in java code.

Nilshan Devinda

REG: 7919


Unit 34

34

Figure 23: Recursive Binary Search Function

Source: Author’s work adopted from Tripathi (2014).

Figure 24: Main Method which calls the search function

Source: Author’s work. The above code shows that, if the target value is greater than the mid value, then the lower bound is assigned with the mid value plus one. Else, the upper bound is assigned with mid value minus one. Thus the two indexes are used to pass the array to the same function where it now focuses only on the specified area.

Nilshan Devinda

REG: 7919


Unit 34

35



Non-Recursive Binary Searching Algorithm

Unlike the recursive approach, the non-recursive binary search uses iterations to perform the same function yet without the need for calling the function recursively. At each iteration, a different section of the array is being compared till the key value is matched. If the key value is matched its index is returned, else the iteration continues. In case of an array sorted in ascending order, the condition for looping is set to be below or equal to the upper bound. If that condition is failed, the iteration stops and return -1 to indicate the absence of the target value in the array. The image below shows this approach being implemented in the java language. Note that the last index or the first index are not required as arguments for the method, because the method is not recursively used and could calculate the values within the method itself.

Figure 25: Non-Recursive Binary Searching Algorithm

Source: Author’s work adopted from Abualrob (2010) & Damier (2015).

Nilshan Devinda

REG: 7919


Unit 34

36

Figure 26: Main method of Non-Recursive Binary Searching Algorithm


3.1.2 Performance comparisons of Binary Searching Algorithms The two types of binary searching approaches introduced above are very similar to each other in terms of both functionality and program logic where they result in the same goal being achieved. However, recursive and non-recursive binary searching algorithms shows variations when compared for their performance where they differentiate themselves with respect to the measurements. Even though it feels intuitive that iterative approach might have some form of an advantage over the other, performance tests carried out by Knight (2013) shows contradictions, where it was assumed that recursive approach perform well over the non-recursive approach. Swartz (2003) shows that even though non-recursive is always usually faster, simpler, and uses less memory, recursive method is better at certain areas such as tree traversals. When compared for performance and efficiency, the recursive binary searching results in a logarithmic performance of 0(1) in terms of average time complexity compared to that of the 0(log n) worst case performance of non-recursive binary search algorithms (C Programming 2011). Therefore, it is evident that recursive binary search algorithms are more efficient than non-recursive binary search algorithms.

Nilshan Devinda

REG: 7919


Unit 34

37

3.2 Sort the array given below with two different algorithms and compare the performance. {-10, 30, 20, 45, 85, 90, 75} (LO 1.2)

3.2.1 Simple Sorting Algorithms In simple sorting techniques, an incrementally increasing boundary of sorted data on an array or data set could be imagined. The incrementing stops when all the data are sorted. These types of sorting require the new item and the data that have already been sorted to be potentially compared at each increment (Ruehr 1998). The following point describes an example of a simple sorting algorithm which leverages these techniques. 

Insertion Sort

Insertion sorting algorithms act in such a way that it picks up a key from the array and compare the key with the elements ahead of it and place the key in the correct position. The procedure iterates until all the elements in the array are sorted, usually in a left to right direction where the algorithm often chooses the second element of the array as the key (Ryerson University 2004). The image below provides an example of this algorithm in java code.

Nilshan Devinda

REG: 7919


Unit 34

38

Figure 27: Insertion Sort Algorithm

Source: Author’s work. Even though this algorithm is inefficient for sorting large data sets, it is very efficient at sorting small data sets and has one of the simplest implementations. According to Beniwal et al. (2016), insertion sorting requires just a single additional memory space where it becomes less space complex and is adaptive and stable making it overall better than selection sort or bubble sort algorithms.

Nilshan Devinda

REG: 7919


Unit 34

39

3.2.2 Divide and Conquered Algorithms The divide and conquer approach for sorting data sets is a highly efficient method in which the problem is divided into sub problems so that individual sub-problems become less complex where it could be solved recursively. The data for the next step is always saved. When the sub-problems are manageable, they are solved in a straightforward manner. These sub-problems are then combined to each other to form the solution of the original problem (Cormen et al. 2009). The following point describes an important algorithm which uses the divide and conquer approach. 

Merge Sort

Merge Sort algorithm is one of the first sorting algorithms. The key to this process is merging 2 sorted arrays into a third party. This process can be used to merge 2 sorted halves on the same array into a single array. The array is divided recursively into halves until the size becomes one. Then each half is compared and sorted where they are merged with other subarrays to complete the merging process resulting in a sorted array (Geeks for Geeks 2016). Java code for merge sort algorithm is shown through the 3 images below.

Figure 28: Main method and Sort method in Merge Sort Algorithm

Source: Author’s work. Nilshan Devinda

REG: 7919


Unit 34

40

Figure 29: Do Merge Sort method in Merge Sort Algorithm


Figure 30: Merge Parts method in Merge Sort Algorithm

Source: Author’s work. The code from the images above shows that the sorted half of the array is also obtained by previously merging 2 sorted parts into one half of the array and each part is also sorted by merging 2 smaller sorted parts and so on. Therefore, the original array is progressively divided and merged through recursive calling or merge sort algorithm until each part has a single element which itself is sorted and no further dividing and merging is required. Nilshan Devinda

REG: 7919


Unit 34

41

According to Toptal (2016), merge sort algorithm is extremely useful for sorting linked lists or in situations where random access is more expensive than sequential access, because of the stability and non-adaptiveness of the algorithm.

3.2.3 Performance Comparison of Simple Sorting with Divide and Conquer Sorting Algorithms Simple sorting algorithms such as insertion sort algorithms are much less efficient on large data sets because it sorts the array one entry at a time in a linear manner (Tang 2012). Even though insertion sorting algorithms are overall better than selection sort or bubble sort as mentioned previously, it still results in a logarithmic performance of just 0(n2) as revealed through the works of Mishra & Garg (2008). Therefore, its performance is lower than that of divide and conquer algorithms which boasts a performance of 0(1) and proves that divide and conquer algorithms are much more efficient than simple sorting algorithms, even as protruded by the vast calculations of the Raford University (2016).

3.3 Explain common string operations such as concatenation, substring, trim etc., also state their practical applications. (LO 3.1)

3.3.1 Sub-Strings A sub-string is a sequence of characters that contains in a string value. Substrings helps in separating a character or a set of characters apart from an existing string value thereby enabling to make a modified copy of the original text. The methods such as IndexOf, IndexOfAny, LastIndexOf, and LastIndexOfAny relies on substring techniques (Deitel & Deitel 2005). The following points shows how sub-strings could be achieved using the Substring method and its practical applications.

Nilshan Devinda

REG: 7919


Unit 34

42



Substring Method

The Substring method takes 2 arguments in integer format to identify where it should start the separation and where it should end. The Substring method does not accept the string itself as an argument, therefore the string object is required to perform the operation rather than the string text. The first 3 lines of code in figure 27 demonstrates the use of the Substring method in C# language. One practical application of this method is that certain phrases from a user’s input could be extracted to form a more relative output based on the input. 

Replace Method

The Replace method also accepts 2 arguments as parameters, it is required that the first argument to be the substring which should be replaced and the second argument to be the substring to be substituted with the first argument. Lines 4 to 6 in figure 27 illustrates the Replace method in use. This method is extremely useful where certain characters are required to be replaced such as in the case of making web URL’s more readable by replacing each forward slash with commas. 

IndexOf Method

The IndexOf method accepts just one argument where a character is passed in return for its index or position in the string, considering the string as an array of characters where white spaces are ignored. The last 3 lines of code in figure below shows the use of IndexOf method to return its index value. The substring method mentioned above requires the starting and ending index to be passed as arguments into the method. IndexOf method would therefore help in finding such indexes. For example, the figure below shows the method used to find the index of ‘C’ from the string s3.

Figure 31: Substring and related methods Source: Microsoft (2016).

Nilshan Devinda

REG: 7919


Unit 34

43

3.3.2 Concatenation Concatenation is the process of merging two data literals into a single literal. Concatenation is not limited to string literals and could be used in any other data type such as binary, integer, floating point characters and Boolean. However, concatenation find its syntax to be different across languages (Techopedia 2016). The application of concatenation for string literals in the Java programming language is discussed below. Even in the Java programming language itself, there are various approaches for concatenation of string values. Each approach has their effects on performance and efficiency of the code. The easiest way to achieve concatenation of strings in java is to simply merge 2 strings using the operator ‘+’ as shown in the image below.

Figure 32: Concatenation using the '+' operator

Source: Author’s work. Even though the above approach for concatenation of strings is almost pleasant and readable, the practice of using ‘+’ operator for concatenation is highly discouraged by Nakov (2013), as the action would result in various performance issues due to reduced efficiency in the process involved while the operator is being used. As a possible solution to this problem, Kulandai (2015) suggests the use of buffered strings as it would significantly reduce the time taken to complete the concatenation process. In this approach, the append method is being used as seen through the image below.

Figure 33: Concatenation of strings by append method


Nilshan Devinda

REG: 7919


Unit 34

44

The above code sample shows string concatenation but with a string buffer in use where the actual result needs to be converted to a string again. However, there are alternative solutions that performs true concatenation yet without the need of string buffers. The concat method is such an approach where the string to be merged is passed as an argument into the method as shown through the image below.

Figure 34: Concatenation of strings through the concat method

Source: Tutorials Point (2016). The practical applications of concatenation include merging certain substrings which might have been extracted from the user into new string literals or in making new content from existing data such as the use of location names from maps to create readable addresses.

3.3.3 Trim Method The string trim method in java language is used to eliminate leading and trailing white spaces from a string. It uses the Unicode value of space which is ‘\u0020’ to check whether a given string contains such a Unicode at the beginning or the end, so this method cannot omit middle spaces in the string (Java T Point 2014). A possible use of this method includes validating user inputs where the user might have accidentally typed in white spaces at the beginning or the end of the input. In such a case, the absence of omission of middle spaces in the trim method comes as an advantage, because the input from the user is not altered while validating. The image below shows how this method is being used in the java language.

Figure 35:String Trim method in java


Nilshan Devinda

REG: 7919


Unit 34

45

Appendices Appendix A: Conclusion In the beginning of this document at Task 1, a program for figuring out whether certain strings are palindromes is developed. It uses many techniques and methods for string processing to process the input strings to validate them, for instance removal of white spaces and punctuation marks from the input string is practiced. This program uses an array based stack to reverse the string to check whether the reversed output matches the processed input. This method could be improved in the future where the array based stack could be replaced with a linked list. However, a program that uses a linked list is developed for the task 2 based scenario where the program enables processing of students in a waiting list in the form of a queue using queue operations such as enque and deque. As this is already a better implementation, this program only requires a better design such as a Graphical User Interface which would be more visually appealing than the current version which aides an Output Console from the IDE. It is clear from the many types of algorithms presented and explained through Task 3, that every algorithm is unique and is more efficient than others on certain tasks, scenarios or conditions. For example, even though insertion sorting algorithms are less efficient than merge sorting algorithms, for data sets below 10 – 12 elements in size, insertion sorting outperforms most of other types of algorithms available including merge sort. However, it is worth noting that on average, for most cases, the Divide and Conquer algorithms are more efficient and faster than Simple Sorting algorithms as they prove a more logarithmic performance. Therefore, the use of the correct type of data structure as well as the algorithm for the specific problem is always essential for implementing faster and efficient programs.

Nilshan Devinda

REG: 7919


Unit 34

46

Appendix B: Self-Reflection Though it took so long to catch up, Data Structures & Algorithms became an interesting area which helps in understanding how certain software work and behave. The different types of data structures, algorithms and multiple approaches for sorting and searching data found on this module reveals that the area studied is just the surface, and promotes the learning of much more sophisticated methods in the future. As a novice, it is always hard to understand how exactly modern software are supported using the techniques introduced in this module, however while completing this assignment, it became evident that there are vast amounts of research and experimental work dedicated for this area alone in which cases, the most efficient approaches, algorithms and methods are found and invented, specially based on their performance. However, it is a reason to worry, that such great research could not be referenced in this document. It is a pleasure to learn about strings and how they could be processed using different methods in a programming language. It is also a pleasure learning about algorithms and where exactly specific algorithms should be used. However, it was unclear and hard to understand about certain data structures such as Graphs and Trees, and how the algorithms are used to sort data in such forms. While it was confusing how certain coding practices and techniques differ the performance of algorithms, such as in the case of recursive and nonrecursive binary searching algorithms where the recursive always outperforms the iterative one, they were always promising a whole new perspective of observing the problem from which knowledge about how they actually work could be increased. These skills whether great or small would be beneficent in the future whether it would be for sorting data or for solving other problems as well. Therefore, this document would serve as a problem solver in the future as it could be used as a revision tool when the above mentioned weaknesses arrive.

Nilshan Devinda

REG: 7919


Unit 34

47

Appendix C: The Gantt Chart

Time Duration: 21 days [ 3 Weeks] Week 2

Week 3

01/09/16 02/09/16 03/09/16 04/09/16 05/09/16 06/09/16 07/09/16 08/09/16 09/09/16 10/09/16 11/09/16 12/09/16 13/09/16 14/09/16

31/08/16

Date

Week 1

15/09/16 16/09/16 17/09/16 18/09/16 19/09/16 20/09/16

Phases

Chapter 1 Chapter 2 Chapter 3 Finalization

Nilshan Devinda

REG: 7919


Unit 34

48

References Abualrob, M. (2010) Iterative Binary search. Weblog. [Online] Available from: http://www.8bitavenue.com/2010/09/iterative-binary-search/ [Accessed 31st August 2016. GMT 11:25:27]. Beniwal, M., Singh, A., Diwan, A., Kaushik, J., Kumar, K.N., Singh, V., Gautam, N. & Joshi,

V.P.

(2016)

Insertion

sorting.

[Online]

http://www.studytonight.com/data-structures/insertion-sorting

Available

from:

31st

August

[Accessed

2016]. C Programming. (2011) Linear Search, Binary Search and other searching Techniques. [Online]

Available

from:

http://www.cprogramming.com/discussionarticles/sorting_and_searching.html

[Accessed

01st September 2016]. Cormen, T.H., Leiserson, C.E., Rivest, R.L. & Stein, C. (2009) Introduction to Algorithms, Third Edition. 3rd edition. [e-book] Massachusetts, MIT Press. Available from: https://mitpress.mit.edu/books/introduction-algorithms [Accessed 02nd September 2016]. Damier,

I.

(2015)

Iterative

Binary

Search.

[Online]

http://www.geekviewpoint.com/java/search/binary_search_iterative

Available

from:

[Accessed

03rd

September 2016]. Deitel, H.M. & Deitel, P. (2005) Strings, Characters and Regular Expressions. In: C# for Programmers. USA, Prentice Hall Professional, p. 616. Forrest, P. (2016) What is non-recursive binary search Algorithm? Weblog. [Online] Available

from:

http://www.answers.com/Q/What_is_non_recursive_binary_search_algorithm

[Accessed

04th September 2016. GMT 10:23:26]. Geeks

for

Geeks.

(2016)

Merge

Sort.

[Online]

Available

from:

http://quiz.geeksforgeeks.org/merge-sort/ [Accessed 05th September 2016]. Java

T

Point.

(2014)

Java

String

trim.

[Online]

Available

from:

http://www.javatpoint.com/java-string-trim [Accessed 6th September 2016]. Nilshan Devinda

REG: 7919


Unit 34

49

Knight, V. (2013) Comparing Recursive and Iterative Algorithms: Binary Search and Factorial.

Weblog.

[Online]

Available

from:

http://drvinceknight.blogspot.com/2013/06/im-in-middle-of-putting-together-new.html [Accessed 07th September 2016. GMT 09:15:37]. Kulandai, J. (2015) Java String Concatenation. Weblog. [Online] Available from: http://javapapers.com/core-java/java-string-concatenation/ [Accessed 08th September 2016. GMT 09:22:26]. Microsoft. (2016) Strings (C# Programming Guide). [Online] Available from: https://msdn.microsoft.com/en-us/library/ms228362(v=vs.100).aspx

[Accessed

09th

September 2016]. Mishra, A.D. & Garg, D. (2008) Selection of best Sorting Algorithm. International Journal of Intelligent Information Processing, 2 (2), 363 – 368. Nakov, S. (2013) Strings and Text processing In: Fundamentals of Computer programming with C#: The Bulgarian C# Book. Bulgaria, Svetlin Nakov, p. 484. Oracle Corporation (1997) PL/SQL User’s Guide and Reference Release 8.0. [Online] Available

from:

https://www.bnl.gov/phobos/Detectors/Computing/Orant/doc/database.804/a58236/06_err s.htm [Accessed 10th September 2016]. Raford University. (2016) Divide and Conquer Algorithms. [Online] Available from: http://www.radford.edu/~nokie/classes/360/divcon.html [Accessed 11th September 2016]. Rouse,

M.

(2007)

Error

Handling.

Weblog

[Online]

Available

http://searchsoftwarequality.techtarget.com/definition/error-handling

from:

[Accessed12th

September 2016. GMT 10:14:17]. Ruehr, F. (1998) Data Structures and Algorithms: Sorting Algorithms. Presented at Willamette

University.

Oregon.

[Online]

Available

from:

http://www.willamette.edu/~fruehr/dsa/lectures/sorting1.html [Accessed 13th September 2016].

Nilshan Devinda

REG: 7919


Unit 34

50

Ryerson

University.

(2004)

Sorting

Algorithms.

[Online]

http://www.ee.ryerson.ca/~courses/coe428/sorting/insertionsort.html

Available

from:

[Accessed

14th

September 2016]. Stoimen. (2011) Computer Algorithms: Binary Search. Weblog. [Online] Available from: http://www.stoimen.com/blog/2011/12/26/computer-algorithms-binary-search/ [Accessed 15th September 2016. GMT 11:38:26]. Swartz, F. (2003) C++ Notes: Algorithms: Recursive Binary Search. [Online] Available from:

http://www.fredosaurus.com/notes-cpp/algorithms/searching/rbinarysearch.html

[Accessed 16th September 2016]. Tang, D. (2012) Introduction to Sorting Algorithms. [Online] Available from: https://www.cpp.edu/~ftang/courses/CS241/notes/sorting.htm [Accessed 17th September 2016]. Techopedia.

(2016)

Concatenation.

[Online]

Available

from:

https://www.techopedia.com/definition/3470/concatenation-programming [Accessed 18th September 2016]. Toptal.

(2016)

Merge

Sort.

[Online]

https://www.toptal.com/developers/sorting-algorithms/merge-sort

Available

from:

[Accessed

19th

September 2016]. Tripathi, P. (2014) Binary Search Implementation using C#. Weblog. [Online] Available from: http://www.c-sharpcorner.com/blogs/binary-search-implementation-using-c-sharp1 [Accessed 20th September 2016. GMT 08:22:23]. Tutorials Point. (2016) Java – String concat() Method. [Online] Available from: http://www.tutorialspoint.com/java/java_string_concat.htm

[Accessed 21st

September

2016].

Nilshan Devinda

REG: 7919


Unit 34

51

Bibliography Bender, M.A., Colton, M.F. & Mosteiro, M.A. (2006) Insertion Sort is 0(n log n). Theory of Computing Systems, 39 (3), 391 – 397. Castro, V.E. & Wood, D. (1992) A Survey of Adaptive Sorting Algorithms. ACM Computing Surveys, 24 (4), 441 – 476. Cook, C.R. & Kim, D.J. (1980) Best sorting algorithm for nearly sorted Lists. Communications of the ACM, 23 (11), 620 – 624. Darlington, J. (1978) A Synthesis of several sorting Algorithms. Acta Informatica, 11 (1), 1 – 30. Department of Computer Science. (2015) Introduction to Data Structures. CS 46B. San Jose, San Jose State University. Franciszek, G. & Dominik, S. (2006) Dynamic Behavior of simple Insertion sort Algorithm. Fundamenta Informaticae, 72 (1), 155 – 165. Karunanithi, A.K. (2014) A Survey, Discussion and Comparison of Sorting algorithms. Master’s thesis. Umea University. Mcllroy, M.D. & Bentley, J.L. (1993) Engineering a sort function. Journal of Software: Practice and Experience, 23 (11), 1249 – 1265. Rajasekaran, S. (2001) A Framework for Simple Sorting Algorithms on Parallel Disk Systems. Theory of Computing Systems, 34 (2), 101 – 114. Samet, H. (1990) The Design and Analysis of Spatial Data Structures. USA, AddisonWesley. Sedgewick, R. (1978) Implementing Quicksort programs. Communications of the ACM. 21 (10), 847–857. Vazirani, U., Dasgupta, S. & Papadimitriou, C. (2006) Algorithms. 1st edition. New York, Mcgraw Hill Education.

Nilshan Devinda

REG: 7919


Unit 34

52

Data Structures & Algorithms

Recommend Documents