You are here
Home > 2019 > December

Month: December 2019

Stack Implementation in Java using Linked Lists

by Sunny Srinidhi - 1

More in The Data Structures series. In our previous Stack implementation post, we saw how we can implement a Stack data structure using an ArrayList. But as you can imagine, that's not the right way to implement a stack. A much better implementation is using a LinkedList. In this post, we'll see just that. If you've missed it, I've already written about how to implement Single Linked List (SLL) and Double Linked List (DLL), and I'd encourage you to check those two out first as we'll be using the same Linked List implementation here, and you can find more detailed Linked List explanation there. Assuming that you have done that, let's now move on to the Stack. The Node The first thing we have

Double Linked List Implementation in Java

by Sunny Srinidhi - 2
Double_Linked_List

More in The Data Structures series. In the previous post, we saw how we can implement Single Linked List in Java. In this post, we'll see how we can extend that and implement a double linked list. The difference between a Single Linked List (SLL) and a Double Linked List (DLL) is that in DLL we have links to both the previous and the next node in the list. In SLL, we only have a pointer to the next node. So in DLL, we have the advantage of traversing the list in both the forward and reverse direction. This adds a lot more flexibility in the linked list. This ins't very much difficult once we have the SLL implementation done. So let's

Single Linked List Implementation in Java

by Sunny Srinidhi - 1

More in The Data Structures series. In the previous post, we saw how a stack can be implemented in Java. But as that was the first data structures post on this blog, I used an ArrayList internally. In this post, we'll implement a simple Linked List in Java. Starting with this post, we'll be getting serious about these data structure implementations. So we'll write 100% custom implementation without using any built-in classes in Java. Also, I'm not going to explain how the data structures work. Which means, in this post, I'll not have illustrations like I had for the stack implementation post explaining each step. So we're going to jump right into the implementation from now on. The Node We know that any linked

Stack Implementation example in Java

by Sunny Srinidhi - 2

More in The Data Structures series. A stack is one of the most simplest data structure to understand. If you had data structures in your academia, you already know what it means. It’s a simple Last In First Out (LIFO) queue. What that means is the last element to enter the stack will be first element to go out of the stack. Let’s try to understand the concept first with a few illustrations. The concept Suppose we have an empty container which looks like the container shown in the image below: Empty stack That’s pretty simple to understand. Now suppose again that we “push” a string with value “string1” to this empty stack. The stack now looks like this: Stack with one element That’s pretty simple to

Optimising a fastText model for better accuracy

by Sunny Srinidhi - 0

More in The fastText Series. In our previous post, we saw what n-grams are and how they are useful. Before that post, we built a simple text classifier using Facebook’s fastText library. In this post, we’ll see how we can optimise that model for better accuracy. Precision and Recall Precision and recall are two things we need to know to better understand the accuracy of our models. And these two things are not very difficult to understand. Precision is the number of correct labels that were predicted by the fastText model, and recall is the number of labels, out of the correct labels, that were successfully predicted. That might be a bit confusing, so let’s look at an example to understand it better. Suppose for a sentence

Top