Implement `fun insertAtBeginning(element:E)` for Doubly Linked List

Taking reference from issue #48 , implement the insertAtBeginning(element:E) function for a Doubly Linked List. This function will insert an element at the beginning of the Doubly Linked List.

First step

Search, read, and understand information about doubly-linked lists, and how they are implemented.

Second step

Open a pull request with the data structure implementation, and wait for comments from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.

Implement `enqueue(element: E)` function for Queues.

Taking reference from issue #15, implement the enqueue(element: E) function for a queue. This function pushed an element to the tail of the queue.

First step

Search, read, and understand information about queues and how they are implemented.

Second step

After you open a pull request with the data structure implementation, wait for comments or approval from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.
Compare efficiency using a dynamic array as underlying data structure vs using a linked list. Choose the most efficient.

Related resources:

Implement container tests for Singly Linked Lists

Taking reference from this dummy test, implement the container tests for a Singly Linked List.

First step

Search, read, and understand information about lists, linked lists, and singly-linked lists, and how they are implemented.

Second step

Open a pull request with the data structure implementation, and wait for comments from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.

Related resources:

https://medium.com/swlh/a-different-look-at-api-tests-with-rest-assured-junit-5-and-kotlin-590789f31097

Implement `insertAtEnd(element:E)` function for a Doubly Linked List

Taking reference from issue #48 , implement the insertAtEnd(element:E) function for a Doubly Linked List. This function will insert an element at the end of the Doubly Linked List.

First step

Search, read, and understand information about doubly-linked lists, and how they are implemented.

Second step

Open a pull request with the data structure implementation, and wait for comments from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.

Implement container tests for Stacks

Taking reference from this dummy test, implement the container tests for a Stack.

First step

Search, read, and understand information about stacks and how they are implemented.

Second step

Open a pull request with the data structure implementation, and wait for comments from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.

Related resources:

https://medium.com/swlh/a-different-look-at-api-tests-with-rest-assured-junit-5-and-kotlin-590789f31097

Test

Implement `insertAtEnd()` function for a Singly Linked List

Taking reference from issue #12, implement the insertAtEnd() function for a Singly Linked List.

First step

Search, read, and understand information about lists, linked lists, and singly-linked lists, and how they are implemented.

Second step

Open a pull request with the data structure implementation, and wait for comments from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.

Related resources:

Implement `deleteNode(position: Integer)` function for a Singly Linked List

Taking reference from issue #12, implement the deleteNode() function for a Singly Linked List.

First step

Search, read, and understand information about lists, linked lists, and singly-linked lists, and how they are implemented.

Second step

Open a pull request with the data structure implementation, and wait for comments from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.

Related resources:

Implement `pop()` function for Stacks

Taking reference from issue #14, implement the pop() function for a Stack. This function removes an element from the top of the stack.

First step

Search, read, and understand information about stacks and how they are implemented.

Second step

After you open a pull request with the data structure implementation, wait for comments or approval from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.
Compare efficiency using a dynamic array as underlying data structure vs using a singly linked list. Choose the most efficient.

Related resources:

Stack implementation

First step

Search, read and understand information about stacks and how they are implemented.

Second step

You have to share a code snippet in markdown with an interface proposal for this data structure. Below you can find an interface example of an hypothetical data structure:

class MyDataStructure<E> {

    fun add(element: E) {
        TODO("Not yet implemented")
    }

    fun get(index: Int): E {
        TODO("Not yet implemented")
    }
}

Third step

After @code-sherpas/kollections-maintainers approve your interface proposal, open a pull request with the data structure implementation and wait for comments.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to the Computer Science. Here you can find a very helpful cheatsheet.
Compare efficiency using a dynamic array as underlying data structure vs using a singly linked list. Choose the most efficient.

Related resources:

Implement `size()` function for Queues.

Taking reference from issue #15, implement the size() function for a queue. This function finds the size of the queue.

First step

Search, read, and understand information about queues and how they are implemented.

Second step

After you open a pull request with the data structure implementation, wait for comments or approval from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.
Compare efficiency using a dynamic array as underlying data structure vs using a linked list. Choose the most efficient.

Related resources:

Update README.md

Implement `insertAtBeginning()` function for a Singly Linked List

Taking reference from issue #12, implement the insertAtBeginning() function for a Singly Linked List.

First step

Search, read, and understand information about lists, linked lists, and singly-linked lists, and how they are implemented.

Second step

Open a pull request with the data structure implementation, and wait for comments from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.

Related resources:

Implement `size()` function for Stacks

Taking reference from issue #14, implement the size() function for a Stack. This function finds the size of the stack.

First step

Search, read, and understand information about stacks and how they are implemented.

Second step

After you open a pull request with the data structure implementation, wait for comments or approval from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.
Compare efficiency using a dynamic array as underlying data structure vs using a singly linked list. Choose the most efficient.

Related resources:

Implement `peek()` function for Stacks

Taking reference from issue #14, implement the peek() function for a Stack. This function gets the element on the top of the stack without removing it.

First step

Search, read, and understand information about stacks and how they are implemented.

Second step

After you open a pull request with the data structure implementation, wait for comments or approval from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.
Compare efficiency using a dynamic array as underlying data structure vs using a singly linked list. Choose the most efficient.

Related resources:

Implement `dequeue()` function for Queues.

Taking reference from issue #15, implement the dequeue() function for a queue. This function removes an element from the head of the queue.

First step

Search, read, and understand information about queues and how they are implemented.

Second step

After you open a pull request with the data structure implementation, wait for comments or approval from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.
Compare efficiency using a dynamic array as underlying data structure vs using a linked list. Choose the most efficient.

Related resources:

Interface Implementation for Doubly Linked List

First step

Search, read, and understand information about doubly linked lists and how they are implemented.

Second step

You have to share a code snippet in markdown with an interface proposal for this data structure. Below you can find an interface example of a hypothetical data structure:

class MyDataStructure<E> {

    fun add(element: E) {
        TODO("Not yet implemented")
    }

    fun get(index: Int): E {
        TODO("Not yet implemented")
    }
}

Third step

After @code-sherpas/kollections-maintainers approve your interface proposal, open a pull request with the data structure implementation, and wait for comments.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.

Create CODE_OF_CONDUCT.md

Create a CODE_OF_CONDUCT.md to ensure the contributors follow a code of conduct.

Setup a workflow for every push to `main` branch

This workflow entails the following steps:

Setup JDK 11
Grant execute permission for gradlew

Singly Linked List implementation

First step

Search, read and understand information about lists, linked lists and singly linked lists, and how they are implemented.

Second step

You have to share a code snippet in markdown with an interface proposal for this data structure. Below you can find an interface example of an hypothetical data structure:

class MyDataStructure<E> {

    fun add(element: E) {
        TODO("Not yet implemented")
    }

    fun get(index: Int): E {
        TODO("Not yet implemented")
    }
}

Third step

After @code-sherpas/kollections-maintainers approve your interface proposal, open a pull request with the data structure implementation and wait for comments.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to the Computer Science. Here you can find a very helpful cheatsheet.

Related resources:

Test

Implement `isEmpty()` function for Queues

Taking reference from issue #15, implement the isEmpty() function for a queue. This function checks if the queue is empty.

First step

Search, read, and understand information about queues and how they are implemented.

Second step

After you open a pull request with the data structure implementation, wait for comments or approval from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.
Compare efficiency using a dynamic array as underlying data structure vs using a linked list. Choose the most efficient.

Related resources:

Queue implementation

First step

Search, read and understand information about queues and how they are implemented.

Second step

You have to share a code snippet in markdown with an interface proposal for this data structure. Below you can find an interface example of an hypothetical data structure:

class MyDataStructure<E> {

    fun add(element: E) {
        TODO("Not yet implemented")
    }

    fun get(index: Int): E {
        TODO("Not yet implemented")
    }
}

Third step

After @code-sherpas/kollections-maintainers approve your interface proposal, open a pull request with the data structure implementation and wait for comments.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to the Computer Science. Here you can find a very helpful cheatsheet.
Compare efficiency using a dynamic array as underlying data structure vs using a linked list. Choose the most efficient.

Related resources:

Implement `push(element: E)` function for Stacks

Taking reference from issue #14, implement the push(element: E) function for a Stack. This function adds an element to the top of the stack.

First step

Search, read, and understand information about stacks and how they are implemented.

Second step

After you open a pull request with the data structure implementation, wait for comments or approval from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.
Compare efficiency using a dynamic array as underlying data structure vs using a singly linked list. Choose the most efficient.

Related resources:

Implement `get(index:Integer)` function for a Singly Linked List

Taking reference from issue #12, implement the get(index:Integer) function for a Singly Linked List. This function will get elements from the specified position.

First step

Search, read, and understand information about lists, linked lists, and singly-linked lists, and how they are implemented.

Second step

Open a pull request with the data structure implementation, and wait for comments from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.

Related resources:

Implement container tests for Queues

Taking reference from this dummy test, implement the container tests for a Queue.

First step

Search, read, and understand information about queues and how they are implemented.

Second step

Open a pull request with the data structure implementation, and wait for comments from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.

Related resources:

https://medium.com/swlh/a-different-look-at-api-tests-with-rest-assured-junit-5-and-kotlin-590789f31097

Create CONTRIBUTING.md

We need to create a CONTRIBUTING.md file that will contain all guidelines for contribution.

Implement `insertAtIndex(index: Integer)` function for a Doubly Linked List

Taking reference from issue #48 , implement the insertAtIndex(index: Integer) function for a Doubly Linked List. This function will insert elements at the specified index of the Doubly Linked List.

First step

Search, read, and understand information about doubly-linked lists, and how they are implemented.

Second step

Open a pull request with the data structure implementation, and wait for comments from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.

Implement `isEmpty()` function for Stacks

Taking reference from issue #14, implement the isEmpty() function for a Stack. This function checks if the stack is empty.

First step

Search, read, and understand information about stacks and how they are implemented.

Second step

After you open a pull request with the data structure implementation, wait for comments or approval from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.
Compare efficiency using a dynamic array as underlying data structure vs using a singly linked list. Choose the most efficient.

Related resources:

Implement `head()` function for a Doubly Linked List

Taking reference from issue #48 , implement the head() function for a Doubly Linked List. This function will get the element at the head of the Doubly Linked List.

First step

Search, read, and understand information about doubly-linked lists, and how they are implemented.

Second step

Open a pull request with the data structure implementation, and wait for comments from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.

Implement `isEmpty()` function for a Singly Linked List

Taking reference from issue #12, implement the isEmpty() function for a Singly Linked List. This function will check if the list is empty.

First step

Search, read, and understand information about lists, linked lists, and singly-linked lists, and how they are implemented.

Second step

Open a pull request with the data structure implementation, and wait for comments from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.

Related resources:

Implement `head()` function for a Singly Linked List

Taking reference from issue #12, implement the head() function for a Singly Linked List. This function will find the element at the head of the list.

First step

Search, read, and understand information about lists, linked lists, and singly-linked lists, and how they are implemented.

Second step

Open a pull request with the data structure implementation, and wait for comments from @code-sherpas/kollections-maintainers.

Minimum acceptance criteria

The implementation must be well documented with proper Javadoc at Class and function levels.
The implementation must be tested with automatic tests that cover all relevant cases and situations.
The implementation must be generic.
The implementation must have the expected time complexity according to Computer Science. Here you can find a very helpful cheat sheet.

code-sherpas / kollections Goto Github PK

kollections's People

Contributors

Stargazers

Watchers

Forkers

kollections's Issues

First step

Second step

Minimum acceptance criteria

First step

Second step

Minimum acceptance criteria

Related resources:

First step

Second step

Minimum acceptance criteria

Related resources:

First step

Second step

Minimum acceptance criteria

First step

Second step

Minimum acceptance criteria

Related resources:

First step

Second step

Minimum acceptance criteria

Related resources:

First step

Second step

Minimum acceptance criteria

Related resources:

First step

Second step

Minimum acceptance criteria

Related resources:

First step

Second step

Third step

Minimum acceptance criteria

Related resources:

First step

Second step

Minimum acceptance criteria

Related resources:

First step

Second step

Minimum acceptance criteria

Related resources:

First step

Second step

Minimum acceptance criteria

Related resources:

First step

Second step

Minimum acceptance criteria

Related resources:

First step

Second step

Minimum acceptance criteria

Related resources:

First step

Second step

Third step

Minimum acceptance criteria

First step

Second step

Third step

Minimum acceptance criteria

Related resources:

First step

Second step

Minimum acceptance criteria

Related resources:

First step

Second step

Third step

Minimum acceptance criteria

Related resources: