This is a repository for my past course projects.
- Map with Hashing
- BL parser
- Binary Search Tree
- BinaryTree
- Crypto Utilities
- Expression Evaluator
- Glossary
- Hashing Experiments
- JCF Explorations
- Java IO Explorations
- List With Retreat
- List With Two Smart Nodes
- Map On Queue
- Program and Statement
- SequenceSmooth
- Set On Binary Search Trees
- Set On Queue
- Sorting Machine With Heapsort
- Stack with LinkedList
- Tag Cloud Generator
- Tokenizer
- WaitingLine Family Design
- Natural Number Calculator
Design and develop the data structure representing a Map object by layering it on top of Array and Map itself. The algorithmic approach is to use hashing to immediately narrow every search to a much smaller Map. A JUnit test is performed on implementations of all the constructors and kernel methods defined in interface MapKernel.
Design and develop the data structrue representing a Set object based on top of binary tree. The purpose of using binary search tree is to produce a reduction in search time. A JUnit test is performed on implementations of constructor and all kernel methods.
Design and develop the data structure representing a SortingMachine object based on top of Queue and Array. Sorting algorithm Heapsort is applied here. A JUnit test is performed on implementations of constructor and all kernel methods.
Design and develop a representation that involves a doubly-linked list of nodes using Java reference. A JUnit test is performed on implementations of constructor and all kernel methods.
Implement and test the constructor and all kernel methods defined in interfaces ProgramKernel and StatementKernel.
Implement a recursive-descent parser for the BL language.
This is a Java program that generates a tag cloud from a given text.
Design the interfaces for a new component family called WaitingLine. WaitingLinecomponent family is trying to capture the idea of a waiting line like you might encounter at a restaurant.
The program takes various hash table sizes and files as input, then do hashing on the hundred lines of text in the file. The purpose of this project is to get familiar with hashing, including hashcode, hash function and mod.
The purpose of this lab is to get familiar with JCF components by implementing two methods using both JCF components and OSU components.
This lab implements two programs that read input from a file and write output to a file. It also includes exceptions handling with try-catch and command-line arguments manipulation.
This lab is to implement and test a kernel component Map2 layered on top of Queue.
This lab is to work with linked structures by modifying a given implementation of the kernel component List2 implemented with a singly-linked list. The given implementation uses only one "smart" node at the start of the singly-linked list. After modification a second smart node should be placed at the end of the list.
This lab is to provide a Tokenizer utility class with the task of tokenizing a simple input.
This lab is to work with linked structures by implementing and testing a kernel component Stack2 implemented with a singly-linked list.
This lab is to implement and test a kernel component Set2 implemented on Queue.
This lab is to get familiar with using the BinaryTree component and recursion by writing the height and isInTree static, generic methods for BinaryTree<T>.
This lab is to get a better understanding of binary search trees and practice using the BinaryTree component and recursion by writing and testing the isInTree static, generic method for BinaryTree<T>.
This lab is to practice writing the smooth static method for Sequence<Integer> in a couple different ways and testing implementations with JUnit test fixture.
This project creates a relatively easy-to-maintain glossary facility in HTML format.
A glossary is a list of difficult or specialized words, or terms, with their definitions, that is usually near the end of a book.
This project is about public-key cryptography, which is a crucial factor in Internet's secure communication. One popular public-key cryptographic scheme, RSA, is provably secure under the assumption that factoring of such large numbers is so expensive in terms of execution time as to be computationally infeasible in practice. RSA relies on the ability to decide efficiently whether such a large number is prime, i.e., whether it has any non-trivial factors at all. The project implements a few utility methods that could be used in cryptographic computations, including one that can generate a huge number that is very likely a prime number.
This program calculates the value of an expression consisting of numbers, arithmetic operators, and parentheses.
Develop a complete calculator application with MVC design(model, view,controller) that uses the NaturalNumber components: a natural number calculator. It works just like any other calculator except that it does exact arithmetic with natural numbers that have no explicit bounds on their values.