Justification and Design Issues

The assignment content discusses the implementation of a determinant calculator for matrices of different orders using various data structures and design issues. The solution uses a linked list-based stack, which is memory-efficient and suitable for large matrix sizes. The algorithm has a time complexity of O(n^2) and space complexity proportional to the number of nodes in the linked list. Recursion is used to calculate the minor matrices. The author learned about linked lists, recursion, and file input/output operations.

1. Justification of other data structures and design issues
Ans: 2 Dimensional array data structure is also a good option to use it, It’s better for
performance as it has random access. Array has contiguous memory allocation and thus we can
access it randomly. So Ii has fast access and can beneficial when size of matrix is so large.
2. Description of stack implementation and justification for choice
Ans: Linked list based stack is an option for calculating the determinant for matrix of different
order. As linked list is data structure which uses memory chunks which are not contiguous so it
an memory saver data structure and give as better performance in terms of memory.
3. Discuss stacks - Was it a good choice for this lab?
Ans: Performance wise it’s not best but considering the memory it is an good option.
4. Discussion of algorithm efficiency – time complexity
Ans: Time complexity of this algo is size of list * complexity for recursive call to calculate the
minor matrix. Recursive call for calculating minor would be linear. So complexity should be
O(n*n) i.e. O(n^2)
5. Discussion of algorithm efficiency - space complexity
Ans: Space complexity is size of node * number of node.
6. Potential use of recursion
Ans: Solution is recursive as its being calculated by calling minor matrices. Minor matrix is size
smaller than parent matrix. This would be done until we get 1X1 matrix.

7. What did you learn?
Ans:
Linked list: Linked list is being used for storing matrix. So I have learned what is the various way
of implementing it and what all can be stored in linked list. It’s one of the data structures which
can be used where we don’t need random access of data.
Recursion: I have used recursion in this implementation. Recursion in computer science is a
method where the solution to a problem depends on solutions to smaller instances of the same
problem
Writing and reading file: Input for the program is being taken as file and output is being written
in file. So I have learned how to read and write to file from java program.
8. What would you do differently next time?
Ans: Try to use some other data structures instead of Linked List. I can come to know what
challenges I can face when try to implement this problem in those. By that I can come to know
when we should use which data structure.