Difference between Deterministic and Non-deterministic Algorithms

In a deterministic algorithm, for a given particular input, the computer will always produce the same output going through the same states but in the case of the non-deterministic algorithm, for the same input, the compiler may produce different output in different runs.

• The non-deterministic algorithms can show different behaviors for the same input on different execution and there is a degree of randomness to it.
• Examples of deterministic algorithms are Merge Sort, Binary Search and most of the other algorithms that we generally study and that do not include randomness.
• Example of non-deterministic algorithm is Randomized Quick Sort.
• In P vs NP study, nondeterminism is often modeled using an explicit mechanism for making a nondeterministic choice, such as in a nondeterministic Turing machine. For these models, a nondeterministic algorithm is considered to perform correctly when, for each input, there exists a run that produces the desired result, even when other runs produce incorrect results. This existential power makes nondeterministic algorithms of this sort more efficient than known deterministic algorithms for many problems.

Some of the terms related to the non-deterministic algorithm are defined below:

• choice(X): chooses any value randomly from the set X.
• failure(): denotes the unsuccessful solution.
• success(): The solution is successful and the current thread terminates.

Example :

Problem Statement : Search an element x on A[1:n] where n>=1, on successful search return j if a[j] is equals to x otherwise return 0. 

Non-deterministic Algorithm for this problem :

1.j= choice(a, n)
2.if(A[j]==x) then
{
write(j);
success();
}
3.write(0); failure();

Below is the implementation of above approach:

// C++ program to show difference between Deterministic 
// and Non-deterministic algorithm.
#include <bits/stdc++.h>
using namespace std;

// Deterministic search
int deterministicSearch(vector<int> arr, int x) {
    for (int j = 0; j < arr.size(); j++) {
        if (arr[j] == x) {
            cout << "Deterministic Search: Found at index " << j << endl;
            return j;
        }
    }
    
    cout << "Deterministic Search: Not found" << endl;
    return -1; 
}

// Non-deterministic search (simulated using randomness)
int nonDeterministicSearch(vector<int> arr, int x) {
    
    // Seed random number generator
    srand(time(0));

    // Simulate the non-deterministic choice 
    // by randomly picking an index
    for (int i = 0; i < arr.size(); i++) {
        
        // Randomly pick an index
        int j = rand() % arr.size(); 
        if (arr[j] == x) {
            cout << "Non-deterministic Search: Found at index " << j << endl;
            return j; 
        }
    }
    cout << "Non-deterministic Search: Not found" << endl;
    return -1; 
}

int main() {
    vector<int> arr = { 1, 2, 3, 4, 5 };
    int x = 3;
    deterministicSearch(arr, x);
    nonDeterministicSearch(arr, x);
    return 0;
}

// Java program to show difference between Deterministic 
// and Non-deterministic algorithm.

import java.util.*;

class GfG {

    // Deterministic search
    static int deterministicSearch(int[] arr, int x) {
        for (int j = 0; j < arr.length; j++) {
            if (arr[j] == x) {
                System.out.println("Deterministic Search: Found at index " + j);
                return j;
            }
        }

        System.out.println("Deterministic Search: Not found");
        return -1;
    }

    // Non-deterministic search (simulated using randomness)
    static int nonDeterministicSearch(int[] arr, int x) {

        // Seed random number generator
        Random rand = new Random();

        // Simulate the non-deterministic choice 
        // by randomly picking an index
        for (int i = 0; i < arr.length; i++) {

            // Randomly pick an index
            int j = rand.nextInt(arr.length);
            if (arr[j] == x) {
                System.out.println("Non-deterministic Search: Found at index " + j);
                return j;
            }
        }
        System.out.println("Non-deterministic Search: Not found");
        return -1;
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        int x = 3;
        deterministicSearch(arr, x);
        nonDeterministicSearch(arr, x);
    }
}

# Python program to show difference between Deterministic 
# and Non-deterministic algorithm.

import random

# Deterministic search
def deterministicSearch(arr, x):
    for j in range(len(arr)):
        if arr[j] == x:
            print(f"Deterministic Search: Found at index {j}")
            return j

    print("Deterministic Search: Not found")
    return -1

# Non-deterministic search (simulated using randomness)
def nonDeterministicSearch(arr, x):

    # Seed random number generator
    random.seed()

    # Simulate the non-deterministic choice 
    # by randomly picking an index
    for i in range(len(arr)):

        # Randomly pick an index
        j = random.randint(0, len(arr) - 1)
        if arr[j] == x:
            print(f"Non-deterministic Search: Found at index {j}")
            return j

    print("Non-deterministic Search: Not found")
    return -1

if __name__ == "__main__":
    arr = [1, 2, 3, 4, 5]
    x = 3
    deterministicSearch(arr, x)
    nonDeterministicSearch(arr, x)

// C# program to show difference between Deterministic 
// and Non-deterministic algorithm.

using System;

class GfG {

    // Deterministic search
    static int deterministicSearch(int[] arr, int x) {
        for (int j = 0; j < arr.Length; j++) {
            if (arr[j] == x) {
                Console.WriteLine("Deterministic Search: Found at index " + j);
                return j;
            }
        }

        Console.WriteLine("Deterministic Search: Not found");
        return -1;
    }

    // Non-deterministic search (simulated using randomness)
    static int nonDeterministicSearch(int[] arr, int x) {

        // Seed random number generator
        Random rand = new Random();

        // Simulate the non-deterministic choice 
        // by randomly picking an index
        for (int i = 0; i < arr.Length; i++) {

            // Randomly pick an index
            int j = rand.Next(arr.Length);
            if (arr[j] == x) {
                Console.WriteLine("Non-deterministic Search: Found at index " + j);
                return j;
            }
        }
        Console.WriteLine("Non-deterministic Search: Not found");
        return -1;
    }

    static void Main(string[] args) {
        int[] arr = { 1, 2, 3, 4, 5 };
        int x = 3;
        deterministicSearch(arr, x);
        nonDeterministicSearch(arr, x);
    }
}

// JavaScript program to show difference between Deterministic 
// and Non-deterministic algorithm.

function deterministicSearch(arr, x) {
    for (let j = 0; j < arr.length; j++) {
        if (arr[j] === x) {
            console.log(`Deterministic Search: Found at index ${j}`);
            return j;
        }
    }

    console.log("Deterministic Search: Not found");
    return -1;
}

function nonDeterministicSearch(arr, x) {

    // Seed random number generator
    // Note: JavaScript's random number generator doesn't need to be seeded manually

    // Simulate the non-deterministic choice 
    // by randomly picking an index
    for (let i = 0; i < arr.length; i++) {

        // Randomly pick an index
        let j = Math.floor(Math.random() * arr.length);
        if (arr[j] === x) {
            console.log(`Non-deterministic Search: Found at index ${j}`);
            return j;
        }
    }
    console.log("Non-deterministic Search: Not found");
    return -1;
}

let arr = [1, 2, 3, 4, 5];
let x = 3;
deterministicSearch(arr, x);
nonDeterministicSearch(arr, x);

Deterministic Search: Found at index 2
Non-deterministic Search: Found at index 2