Search in a Linked List

#include <stdio.h>
#include <stdlib.h>

// A node holds a value and a link to the next node.
struct Node {
    int data;
    struct Node* next;
};

// Make a new node on the heap and return it.
struct Node* newNode(int value) {
    struct Node* node = (struct Node*)malloc(sizeof(struct Node));
    node->data = value;
    node->next = NULL;
    return node;
}

// Walk from head, return the position of target, or -1 if missing.
int search(struct Node* head, int target) {
    int position = 0;
    struct Node* current = head;
    while (current != NULL) {        // stop when we run out of nodes
        if (current->data == target) // found it?
            return position;
        current = current->next;     // move one link forward
        position++;
    }
    return -1;                       // reached the end, not found
}

int main() {
    // Build 10 -> 20 -> 30 -> 40
    struct Node* head = newNode(10);
    head->next = newNode(20);
    head->next->next = newNode(30);
    head->next->next->next = newNode(40);

    printf("Position of 30: %d\n", search(head, 30));
    printf("Position of 99: %d\n", search(head, 99));
    return 0;
}

Position of 30: 2
Position of 99: -1

#include <iostream>
using namespace std;

// A node holds a value and a link to the next node.
struct Node {
    int data;
    Node* next;
};

// Make a new node and return it.
Node* newNode(int value) {
    Node* node = new Node();
    node->data = value;
    node->next = nullptr;
    return node;
}

// Walk from head, return the position of target, or -1 if missing.
int search(Node* head, int target) {
    int position = 0;
    Node* current = head;
    while (current != nullptr) {      // stop when we run out of nodes
        if (current->data == target)  // found it?
            return position;
        current = current->next;      // move one link forward
        position++;
    }
    return -1;                        // reached the end, not found
}

int main() {
    // Build 10 -> 20 -> 30 -> 40
    Node* head = newNode(10);
    head->next = newNode(20);
    head->next->next = newNode(30);
    head->next->next->next = newNode(40);

    cout << "Position of 30: " << search(head, 30) << endl;
    cout << "Position of 99: " << search(head, 99) << endl;
    return 0;
}

Position of 30: 2
Position of 99: -1

public class SearchLinkedList {

    // A node holds a value and a link to the next node.
    static class Node {
        int data;
        Node next;
        Node(int value) {
            data = value;
            next = null;
        }
    }

    // Walk from head, return the position of target, or -1 if missing.
    static int search(Node head, int target) {
        int position = 0;
        Node current = head;
        while (current != null) {     // stop when we run out of nodes
            if (current.data == target) // found it?
                return position;
            current = current.next;   // move one link forward
            position++;
        }
        return -1;                    // reached the end, not found
    }

    public static void main(String[] args) {
        // Build 10 -> 20 -> 30 -> 40
        Node head = new Node(10);
        head.next = new Node(20);
        head.next.next = new Node(30);
        head.next.next.next = new Node(40);

        System.out.println("Position of 30: " + search(head, 30));
        System.out.println("Position of 99: " + search(head, 99));
    }
}

Position of 30: 2
Position of 99: -1

# A node holds a value and a link to the next node.
class Node:
    def __init__(self, value):
        self.data = value
        self.next = None

# Walk from head, return the position of target, or -1 if missing.
def search(head, target):
    position = 0
    current = head
    while current is not None:        # stop when we run out of nodes
        if current.data == target:    # found it?
            return position
        current = current.next        # move one link forward
        position += 1
    return -1                         # reached the end, not found

# Build 10 -> 20 -> 30 -> 40
head = Node(10)
head.next = Node(20)
head.next.next = Node(30)
head.next.next.next = Node(40)

print("Position of 30:", search(head, 30))
print("Position of 99:", search(head, 99))

Position of 30: 2
Position of 99: -1

// A node holds a value and a link to the next node.
class Node {
  constructor(value) {
    this.data = value;
    this.next = null;
  }
}

// Walk from head, return the position of target, or -1 if missing.
function search(head, target) {
  let position = 0;
  let current = head;
  while (current !== null) {        // stop when we run out of nodes
    if (current.data === target)    // found it?
      return position;
    current = current.next;         // move one link forward
    position++;
  }
  return -1;                        // reached the end, not found
}

// Build 10 -> 20 -> 30 -> 40
let head = new Node(10);
head.next = new Node(20);
head.next.next = new Node(30);
head.next.next.next = new Node(40);

console.log("Position of 30:", search(head, 30));
console.log("Position of 99:", search(head, 99));

Position of 30: 2
Position of 99: -1