Sequential Search Algorithm Java: A Comprehensive Guide

The sequential search algorithm, also known as linear search, is a method for finding a particular value in a list by checking every element one at a time until the desired value is found. This algorithm is the most straightforward and is often taught before more advanced algorithms like binary search.

In its worst-case scenario, the linear search algorithm requires n comparisons to find an item in a list of n items. However, in the best case, it can take as few as one comparison if the target value is the first element in the list. The algorithm works by iterating through each element in the list and comparing it with the target value until a match is found.

The sequential search algorithm is useful for searching an item in an array or linked list that is not sorted, and it cannot be used with binary search algorithms. In Java, this algorithm can be implemented using a symbol table, which provides methods like put(), get(), contains(), delete(), size(), and isEmpty().

Here's an example of how the sequential search algorithm works in Java:

```

import java.util.*;

public class SequentialSearchST {

private Node head; // Head of the linked list

public static void main(String'' args) {

SequentialSearchST st = new SequentialSearchST();

StdIn.fromFile('tinyST.txt');

while (!StdIn.isEmpty()) {

String command = StdIn.readString();

if (command.equals('put')) {

st.put(StdIn.readInt(), StdIn.readString());

} else if (command.equals('get')) {

System.out.println(st.get(StdIn.readInt()));

} else if (command.equals('contains')) {

System.out.println(st.contains(StdIn.readInt()));

} else if (command.equals('delete')) {

st.delete(StdIn.readInt());

} else if (command.equals('size')) {

System.out.println(st.size());

} else if (command.equals('isEmpty')) {

System.out.println(st.isEmpty());

}

public void put(int key, String value) {

// Find the node with the given key

Node current = head;

while (current != null) {

if (current.key == key) {

// Replace the old value with the new value

current.value = value;

return;

}

current = current.next;

}

// Create a new node and add it to the end of the list

Node newNode = new Node(key, value);

if (head == null) {

head = newNode;

} else {

Node lastNode = head;

while (lastNode.next != null) {

lastNode = lastNode.next;

}

lastNode.next = newNode;

}

public String get(int key) {

// Find the node with the given key

Node current = head;

while (current != null) {

if (current.key == key) {

return current.value;

}

current = current.next;

}

return null; // Key not found

}

public boolean contains(int key) {

// Find the node with the given key

Node current = head;

while (current != null) {

if (current.key == key) {

return true;

}

current = current.next;

}

return false; // Key not found

}

public void delete(int key) {

// Find the node with the given key

Node current = head;

Node previous = null;

while (current != null) {

if (current.key == key) {

if (previous == null) {

head = current.next;

} else {

previous.next = current.next;

}

return;

}

previous = current;

current = current.next;

}

public int size() {

// Count the number of nodes in the list

Node current = head;

int count = 0;

while (current != null) {

count++;

current = current.next;

}

return count;

}

public boolean isEmpty() {

return head == null;

}

private static class Node {

int key;

String value;

Node next;

Node(int key, String value) {

this.key = key;

this.value = value;

this.next = null;

}

```

In this article, we have explored the sequential search algorithm and its implementation in Java. We have also discussed its advantages and limitations compared to other searching algorithms like binary search.

Sequential search algorithm java