SUMMARY OF DESIGN PATTERNS IN JAVA

• Creational patterns deal with the creation of objects. They provide a way to encapsulate the process of creating objects so that it can be easily reused and modified. Some of the most popular creational patterns in Java include:
• Singleton ensures that there is only one instance of a class in a program.
• Factory Method defines an interface for creating objects but leaves the actual implementation of the objects to subclasses.
• Abstract Factory provides a way to create families of related objects without specifying their concrete classes.
• Builder separates the construction of a complex object from its representation.
• Prototype creates a new object by copying an existing object.
• Structural patterns deal with the way that objects are composed together. They provide a way to create structures of objects that are both flexible and maintainable. Some of the most popular structural patterns in Java include:
• Adapter converts the interface of one class into an interface that another class expects.
• Bridge decouples an abstraction from its implementation so that the two can vary independently.
• Composite represents a group of objects that are treated as a single object.
• Decorator attaches additional responsibilities to an object dynamically.
• Facade provides a simplified interface to a complex system.
• Behavioral patterns deal with the way that objects interact with each other. They provide a way to define the relationships between objects and how they communicate with each other. Some of the most popular behavioral patterns in Java include:
• Chain of Responsibility delegates a request to a chain of objects until one object handles it.
• Command encapsulates a request as an object, thereby enabling greater flexibility in handling requests.
• Interpreter defines a grammar and interprets sentences in that grammar.
• Iterator provides a way to traverse a collection of objects.
• Mediator defines an object that encapsulates how a set of objects interact with each other.
• Observer defines a one-to-many dependency between objects so that when one object changes state, all of its dependents are notified and updated automatically.
• State allows an object to change its behavior based on its internal state.
• Strategy defines a family of algorithms, encapsulates each one, and makes them interchangeable.
• Template Method defines the skeleton of an algorithm in an operation, deferring some steps to subclasses.

These are just a few of the many design patterns that are available in Java. By understanding and using design patterns, software developers can create more flexible, extensible, and maintainable code.

Stacks, queues, and doubly linked lists -data structures

 

Stacks, queues, linked lists, and doubly linked lists are all data structures that store data in a linear fashion. However, they each have different characteristics and are used for different purposes.

Stacks are a data structure that follows the Last-In-First-Out (LIFO) principle. This means that the last item that is inserted into the stack is the first item that is removed. Stacks are often used to implement functions like undo and redo, as well as to evaluate mathematical expressions.

Queues are a data structure that follows the First-In-First-Out (FIFO) principle. This means that the first item that is inserted into the queue is the first item that is removed. Queues are often used to implement processes like printing jobs or tasks that need to be executed in order.

 

Linked lists are a data structure that stores data in a linked fashion. This means that each node in the list contains a pointer to the next node in the list. Linked lists can be either singly linked or doubly linked.

Singly linked lists can only be traversed in one direction, while doubly linked lists can be traversed in both directions. Linked lists are often used to implement lists, trees, and graphs.

Doubly linked lists are a type of linked list that has pointers to both the next node and the previous node in the list. This allows doubly linked lists to be traversed in both directions, which makes them more versatile than singly linked lists. Doubly linked lists are often used to implement stacks, queues, and linked lists.

Here is a table that summarizes the key differences between stacks, queues, linked lists, and doubly linked lists:

Feature	Stack	Queue	Linked list	Doubly linked list
Data structure	LIFO	FIFO	Linked	Linked
Direction of traversal	One direction only	One direction only	Both directions	Both directions
Memory usage	Less memory per node	Less memory per node	More memory per node	More memory per node
Applications	Undo/redo, mathematical expressions	Printing jobs, tasks	Lists, trees, graphs	Stacks, queues, linked lists

 

 

//code for a DoublyLinkedList class in Java

public class DoublyLinkedList {

 

    private Node head;

    private Node tail;

 

    public DoublyLinkedList() {

        head = null;

        tail = null;

    }

 

    public void addFirst(int data) {

        Node newNode = new Node(data);

        newNode.next = head;

        if (head != null) {

            head.prev = newNode;

        }

        head = newNode;

        if (tail == null) {

            tail = head;

        }

    }

 

    public void addLast(int data) {

        Node newNode = new Node(data);

        newNode.prev = tail;

        if (tail != null) {

            tail.next = newNode;

        }

        tail = newNode;

        if (head == null) {

            head = tail;

        }

    }

 

    public void removeFirst() {

        if (head == null) {

            return;

        }

        Node temp = head;

        head = head.next;

        if (head != null) {

            head.prev = null;

        } else {

            tail = null;

        }

        temp.next = null;

    }

 

    public void removeLast() {

        if (tail == null) {

            return;

        }

        Node temp = tail;

        tail = tail.prev;

        if (tail != null) {

            tail.next = null;

        } else {

            head = null;

        }

        temp.prev = null;

    }

 

    public void printList() {

        Node current = head;

        while (current != null) {

            System.out.print(current.data + " ");

            current = current.next;

        }

        System.out.println();

    }

private class Node {

        int data;

        Node next;

        Node prev;

 

        public Node(int data) {

            this.data = data;

            next = null;

            prev = null;

        }

    }

}

Data Structures Notes

 Data Structures Notes

• Arrays are a linear data structure that store elements in a contiguous block of memory. They are easy to implement and access, but they can be inefficient for storing large amounts of data or for dynamic data structures.
• Linked lists are a linear data structure that store elements in a linked list of nodes. Each node contains a data element and a pointer to the next node in the list. Linked lists are more efficient than arrays for storing large amounts of data or for dynamic data structures, but they can be more difficult to implement and access.
• Stacks are a linear data structure that follows the last-in, first-out (LIFO) principle. Elements are added to the stack at the top and removed from the top. Stacks are often used to implement functions like undo and redo.
• Queues are a linear data structure that follows the first-in, first-out (FIFO) principle. Elements are added to the queue at the rear and removed from the front. Queues are often used to implement data structures like priority queues.
• Hash tables are a non-linear data structure that store elements in a hash table. Each element is assigned a hash code, which is used to determine the index of the element in the hash table. Hash tables are very efficient for searching, but they can be less efficient for insertion and deletion

Data Structure	Type	Access Order	Applications
Stack	Linear	LIFO	Backtracking, Undo, call stack, Page-visited history
Queue	Linear	FIFO	Simulation, Printer queue, Process scheduling, GUI event
Tree	Non-linear	Hierarchical	Decision processes, File system, binary search, Arithmetic expressions
Graph	Non-linear	Any	Social network, shortest path, minimum spanning tree, Transportation and Computer networks, ERD

Data structure	Description	Access	Advantages	Disadvantages
Stack	LIFO (last in, first out) data structure	Top element	Easy to implement, efficient for operations that only need to access the top element	Can only access the top element
Queue	FIFO (first in, first out) data structure	Front element	Easy to implement, efficient for operations that only need to access the front element	Can only access the front element
Linked list	Linear data structure	Any element	Flexible and efficient for operations that need to access any element in the list	Can be inefficient for some operations, such as inserting and deleting elements in the middle of the list
Graph	Non-linear data structure	Any vertex	Flexible and powerful for modeling relationships between objects	Can be difficult to implement and manage
Hash table	Maps keys to values	Key	Fast lookups	Can be inefficient for some operations, such as inserting and deleting elements

•