Posted on by Kalkicode
Code Array

# Find nearest smallest element of left side in array

Here given code implementation process.

``````// C Program
// Find nearest smallest element of left side in array
#include <stdio.h>

// Find the smallest element of left side in given array
void leftSmallest(int arr[], int size)
{
// Loop controlling variables
int i = 0;
int j = 0;
// Define auxiliary variable
int location = -1;
// Outer loop (0...size)
for (i = 0; i < size; ++i)
{
location = -1;
for (j = i - 1; j > 0 && location == -1; --j)
{
if (arr[i] > arr[j])
{
// When get smaller element
location = j;
}
}
if (location == -1)
{
printf("  [%d] : None \n", arr[i]);
}
else
{
printf("  [%d] : %d \n", arr[i], arr[location]);
}
}
}
int main(int argc, char
const * argv[])
{
// Given array elements
int arr[] = {
6 , 3 , 7 , 5 , 12 , 10 , 6 , 2 , 4
};
// Get the size
int size = sizeof(arr) / sizeof(arr[0]);
leftSmallest(arr, size);
return 0;
}``````

#### Output

``````  [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````
``````/*
Java program
Find nearest smallest element of left side in array
*/
public class Element
{
// Find the smallest element of left side in given array
public void leftSmallest(int[] arr, int size)
{
// Loop controlling variables
int i = 0;
int j = 0;
// Define auxiliary variable
int location = -1;
// Outer loop (0...size)
for (i = 0; i < size; ++i)
{
location = -1;
for (j = i - 1; j > 0 && location == -1; --j)
{
if (arr[i] > arr[j])
{
// When get smaller element
location = j;
}
}
if (location == -1)
{
System.out.print(" [" + arr[i] + "] : None \n");
}
else
{
System.out.print(" [" + arr[i] + "] : " + arr[location] + " \n");
}
}
}
public static void main(String[] args)
{
// Given array elements
int[] arr = {
6 , 3 , 7 , 5 , 12 , 10 , 6 , 2 , 4
};
// Get the number of elements
int size = arr.length;
}
}``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````
``````// Include header file
#include <iostream>
using namespace std;

/*
C++ program
Find nearest smallest element of left side in array
*/

class Element
{
public:
// Find the smallest element of left side in given array
void leftSmallest(int arr[], int size)
{
// Loop controlling variables
int i = 0;
int j = 0;
// Define auxiliary variable
int location = -1;
// Outer loop (0...size)
for (i = 0; i < size; ++i)
{
location = -1;
for (j = i - 1; j > 0 && location == -1; --j)
{
if (arr[i] > arr[j])
{
// When get smaller element
location = j;
}
}
if (location == -1)
{
cout << " [" << arr[i] << "] : None \n";
}
else
{
cout << " [" << arr[i] << "] : " << arr[location] << " \n";
}
}
}
};
int main()
{
// Given array elements
int arr[] = {
6 , 3 , 7 , 5 , 12 , 10 , 6 , 2 , 4
};
// Get the number of elements
int size = sizeof(arr) / sizeof(arr[0]);
return 0;
}``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````
``````// Include namespace system
using System;
/*
C# program
Find nearest smallest element of left side in array
*/
public class Element
{
// Find the smallest element of left side in given array
public void leftSmallest(int[] arr, int size)
{
// Loop controlling variables
int i = 0;
int j = 0;
// Define auxiliary variable
int location = -1;
// Outer loop (0...size)
for (i = 0; i < size; ++i)
{

location = -1;
for (j = i - 1; j > 0 && location == -1; --j)
{
if (arr[i] > arr[j])
{
// When get smaller element
location = j;
}
}
if (location == -1)
{
Console.Write(" [" + arr[i] + "] : None \n");
}
else
{
Console.Write(" [" + arr[i] + "] : " + arr[location] + " \n");
}
}
}
public static void Main(String[] args)
{
// Given array elements
int[] arr = {
6 , 3 , 7 , 5 , 12 , 10 , 6 , 2 , 4
};
// Get the number of elements
int size = arr.Length;
}
}``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````
``````<?php
/*
Php program
Find nearest smallest element of left side in array
*/
class Element
{
// Find the smallest element of left side in given array
public  function leftSmallest( & \$arr, \$size)
{
// Loop controlling variables
\$i = 0;
\$j = 0;
// Define auxiliary variable
\$location = -1;
// Outer loop (0...size)
for (\$i = 0; \$i < \$size; ++\$i)
{
\$location = -1;
for (\$j = \$i - 1; \$j > 0 && \$location == -1; --\$j)
{
if (\$arr[\$i] > \$arr[\$j])
{
// When get smaller element
\$location = \$j;
}
}
if (\$location == -1)
{
echo " [". \$arr[\$i] ."] : None \n";
}
else
{
echo " [". \$arr[\$i] ."] : ". \$arr[\$location] ." \n";
}
}
}
}

function main()
{
// Given array elements
\$arr = array(6, 3, 7, 5, 12, 10, 6, 2, 4);
// Get the number of elements
\$size = count(\$arr);
}
main();``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````
``````/*
Node Js program
Find nearest smallest element of left side in array
*/
class Element
{
// Find the smallest element of left side in given array
leftSmallest(arr, size)
{
// Loop controlling variables
var i = 0;
var j = 0;
// Define auxiliary variable
var location = -1;
// Outer loop (0...size)
for (i = 0; i < size; ++i)
{
location = -1;
for (j = i - 1; j > 0 && location == -1; --j)
{
if (arr[i] > arr[j])
{
// When get smaller element
location = j;
}
}
if (location == -1)
{
process.stdout.write(" [" + arr[i] + "] : None \n");
}
else
{
process.stdout.write(" [" + arr[i] + "] : " + arr[location] + " \n");
}
}
}
}

function main()
{
// Given array elements
var arr = [6, 3, 7, 5, 12, 10, 6, 2, 4];
// Get the number of elements
var size = arr.length;
}
main();``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````
``````#   Python 3 program
#   Find nearest smallest element of left side in array

class Element :
#  Find the smallest element of left side in given array
def leftSmallest(self, arr, size) :
#  Loop controlling variables
i = 0
j = 0
#  Define auxiliary variable
location = -1
#  Outer loop (0...size)
while (i < size) :
location = -1
j = i - 1
while (j > 0 and location == -1) :
if (arr[i] > arr[j]) :
#  When get smaller element
location = j

j -= 1

if (location == -1) :
print(" [", arr[i] ,"] : None ")
else :
print(" [", arr[i] ,"] : ", arr[location] ," ")

i += 1

def main() :
#  Given array elements
arr = [6, 3, 7, 5, 12, 10, 6, 2, 4]
#  Get the number of elements
size = len(arr)

if __name__ == "__main__": main()``````

#### Output

`````` [ 6 ] : None
[ 3 ] : None
[ 7 ] :  3
[ 5 ] :  3
[ 12 ] :  5
[ 10 ] :  5
[ 6 ] :  5
[ 2 ] : None
[ 4 ] :  2``````
``````#   Ruby program
#   Find nearest smallest element of left side in array

class Element
#  Find the smallest element of left side in given array
def leftSmallest(arr, size)
#  Loop controlling variables
i = 0
j = 0
#  Define auxiliary variable
location = -1
#  Outer loop (0...size)
while (i < size)
location = -1
j = i - 1
while (j > 0 && location == -1)
if (arr[i] > arr[j])
#  When get smaller element
location = j
end

j -= 1
end

if (location == -1)
print(" [", arr[i] ,"] : None \n")
else
print(" [", arr[i] ,"] : ", arr[location] ," \n")
end

i += 1
end

end

end

def main()
#  Given array elements
arr = [6, 3, 7, 5, 12, 10, 6, 2, 4]
#  Get the number of elements
size = arr.length
end

main()``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2
``````
``````/*
Scala program
Find nearest smallest element of left side in array
*/
class Element
{
// Find the smallest element of left side in given array
def leftSmallest(arr: Array[Int], size: Int): Unit = {
// Loop controlling variables
var i: Int = 0;
var j: Int = 0;
// Define auxiliary variable
var location: Int = -1;
// Outer loop (0...size)
while (i < size)
{
location = -1;
j = i - 1;
while (j > 0 && location == -1)
{
if (arr(i) > arr(j))
{
// When get smaller element
location = j;
}
j -= 1;
}
if (location == -1)
{
print(" [" + arr(i) + "] : None \n");
}
else
{
print(" [" + arr(i) + "] : " + arr(location) + " \n");
}
i += 1;
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Element = new Element();
// Given array elements
var arr: Array[Int] = Array(6, 3, 7, 5, 12, 10, 6, 2, 4);
// Get the number of elements
var size: Int = arr.length;
}
}``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````
``````/*
Swift 4 program
Find nearest smallest element of left side in array
*/
class Element
{
// Find the smallest element of left side in given array
func leftSmallest(_ arr: [Int], _ size: Int)
{
// Loop controlling variables
var i: Int = 0;
var j: Int = 0;
// Define auxiliary variable
var location: Int = -1;
// Outer loop (0...size)
while (i < size)
{
location = -1;
j = i - 1;
while (j > 0 && location == -1)
{
if (arr[i] > arr[j])
{
// When get smaller element
location = j;
}
j -= 1;
}
if (location == -1)
{
print(" [", arr[i],"] : None ");
}
else
{
print(" [", arr[i],"] : ", arr[location]," ");
}
i += 1;
}
}
}
func main()
{
// Given array elements
let arr: [Int] = [6, 3, 7, 5, 12, 10, 6, 2, 4];
// Get the number of elements
let size: Int = arr.count;
}
main();``````

#### Output

`````` [ 6 ] : None
[ 3 ] : None
[ 7 ] :  3
[ 5 ] :  3
[ 12 ] :  5
[ 10 ] :  5
[ 6 ] :  5
[ 2 ] : None
[ 4 ] :  2``````
``````/*
Kotlin program
Find nearest smallest element of left side in array
*/
class Element
{
// Find the smallest element of left side in given array
fun leftSmallest(arr: Array < Int > , size: Int): Unit
{
// Loop controlling variables
var i: Int = 0;
var j: Int ;
// Define auxiliary variable
var location: Int ;
// Outer loop (0...size)
while (i < size)
{
location = -1;
j = i - 1;
while (j > 0 && location == -1)
{
if (arr[i] > arr[j])
{
// When get smaller element
location = j;
}
j -= 1;
}
if (location == -1)
{
print(" [" + arr[i] + "] : None \n");
}
else
{
print(" [" + arr[i] + "] : " + arr[location] + " \n");
}
i += 1;
}
}
}
fun main(args: Array < String > ): Unit
{
// Given array elements
var arr: Array < Int > = arrayOf(6, 3, 7, 5, 12, 10, 6, 2, 4);
// Get the number of elements
var size: Int = arr.count();
}``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````

In above solution are need O(n*n) time to take all the left side smaller element. We can optimize this problem using stack. Stack operations are tack O(n) time to find all nearest smaller element in array. See this solution.

``````// C Program
// Find nearest smallest element of left side in array
// Using stack
#include <stdio.h>
#include <stdlib.h>

// Define stack node
struct StackNode
{
int element;
struct StackNode *next;
};

// Define a custom stack
struct MyStack
{
struct StackNode *top;
int size;
};
struct MyStack *newStack()
{
//Make a stack
struct MyStack *stack = (struct MyStack *) malloc(sizeof(struct MyStack));
if (stack != NULL)
{
//Set node values
stack->top = NULL;
stack->size = 0;
}
else
{
printf("\nMemory overflow when create new stack\n");
}
}
//Create a new node of stack
struct StackNode *newNode(int element, struct StackNode *next)
{
//Make a new node
struct StackNode *node = (struct StackNode *) malloc(sizeof(struct StackNode));
if (node == NULL)
{
printf("\nMemory overflow when create new stack Node \n");
}
else
{
node->element = element;
node->next = next;
}
return node;
}
// Returns the status of empty or non empty stacks
int isEmpty(struct MyStack *stack)
{
if (stack->size > 0 && stack->top != NULL)
{
return 0;
}
else
{
return 1;
}
}
// Add node at the top of stack
void push(struct MyStack *stack, int element)
{
stack->top = newNode(element, stack->top);
stack->size++;
}
int peek(struct MyStack *stack)
{
return stack->top->element;
}
// Remove top element of stack
void pop(struct MyStack *stack)
{
if (isEmpty(stack) == 0)
{
struct StackNode *temp = stack->top;
// Change top element of stack
stack->top = temp->next;
// remove previous top
free(temp);
temp = NULL;
stack->size--;
}
}

// Find the smallest element of left side in given array
void leftSmallest(int arr[], int size)
{
// Loop controlling variables
int i = 0;

struct MyStack*stack = newStack();

// Outer loop (0...size)
for (i = 0; i < size; ++i)
{

while(isEmpty(stack) == 0 && peek(stack) >= arr[i])
{
pop(stack);
}
if(isEmpty(stack) == 0)
{
printf("  [%d] : %d \n", arr[i], peek(stack));
}
else
{
printf("  [%d] : None \n", arr[i]);
}
push(stack,arr[i]);

}
}
int main(int argc, char const *argv[])
{
// Given array elements
int arr[] = {6 , 3 , 7 , 5 , 12 , 10 , 6 , 2 , 4};

// Get the size
int size = sizeof(arr)/sizeof(arr[0]);

leftSmallest(arr,size);
return 0;
}``````

#### Output

``````  [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````
``````/*
Java program
Find nearest smallest element of left side in array
by using stack
*/
// Define stack node
class StackNode
{
public int element;
public StackNode next;
public StackNode(int element, StackNode next)
{
this.element = element;
this.next = next;
}
}
// Define a custom stack
class MyStack
{
public StackNode top;
public int size;
public MyStack()
{
//Set node values
this.top = null;
this.size = 0;
}
// Add node at the top of stack
public void push(int element)
{
this.top = new StackNode(element, this.top);
this.size++;
}
public boolean isEmpty()
{
if (this.size > 0 && this.top != null)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
public void pop()
{
if (this.size > 0 && this.top != null)
{
StackNode temp = this.top;
// Change top element of stack
this.top = temp.next;
// remove previous top
temp = null;
this.size--;
}
}
public int peek()
{
return this.top.element;
}
}
public class Element
{
// Find the smallest element of left side in given array
public void leftSmallest(int[] arr, int size)
{
// Loop controlling variables
int i = 0;
MyStack stack = new MyStack();
// Outer loop (0...size)
for (i = 0; i < size; ++i)
{
// Remove the stack element until its top is not less than current element of array
while (stack.isEmpty() == false && stack.peek() >= arr[i])
{
// Remove top element
stack.pop();
}
if (stack.isEmpty() == false)
{
System.out.print(" [" + arr[i] + "] : " + stack.peek() + " \n");
}
else
{
System.out.print(" [" + arr[i] + "] : None \n");
}
stack.push(arr[i]);
}
}
public static void main(String[] args)
{
// Given array elements
int[] arr = {
6 , 3 , 7 , 5 , 12 , 10 , 6 , 2 , 4
};
// Get the number of elements
int size = arr.length;
}
}``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````
``````// Include header file
#include <iostream>

using namespace std;
/*
C++ program
Find nearest smallest element of left side in array
by using stack
*/
// Define stack node
class StackNode
{
public: int element;
StackNode *next;
StackNode(int element, StackNode *next)
{
this->element = element;
this->next = next;
}
};
// Define a custom stack
class MyStack
{
public: StackNode *top;
int size;
MyStack()
{
//Set node values
this->top = NULL;
this->size = 0;
}
// Add node at the top of stack
void push(int element)
{
this->top = new StackNode(element, this->top);
this->size++;
}
bool isEmpty()
{
if (this->size > 0 && this->top != NULL)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
void pop()
{
if (this->size > 0 && this->top != NULL)
{
StackNode *temp = this->top;
// Change top element of stack
this->top = temp->next;
// remove previous top
delete temp;
temp = NULL;
this->size--;
}
}
int peek()
{
return this->top->element;
}
};
class Element
{
public:
// Find the smallest element of left side in given array
void leftSmallest(int arr[], int size)
{
// Loop controlling variables
int i = 0;
MyStack stack = MyStack();
// Outer loop (0...size)
for (i = 0; i < size; ++i)
{
// Remove the stack element until its top is not less than current element of array
while (stack.isEmpty() == false && stack.peek() >= arr[i])
{
// Remove top element
stack.pop();
}
if (stack.isEmpty() == false)
{
cout << " [" << arr[i] << "] : " << stack.peek() << " \n";
}
else
{
cout << " [" << arr[i] << "] : None \n";
}
stack.push(arr[i]);
}
}
};
int main()
{
// Given array elements
int arr[] = {
6 , 3 , 7 , 5 , 12 , 10 , 6 , 2 , 4
};
// Get the number of elements
int size = sizeof(arr) / sizeof(arr[0]);
return 0;
}``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````
``````// Include namespace system
using System;
/*
C# program
Find nearest smallest element of left side in array
by using stack
*/
// Define stack node
public class StackNode
{
public int element;
public StackNode next;
public StackNode(int element, StackNode next)
{
this.element = element;
this.next = next;
}
}
// Define a custom stack
public class MyStack
{
public StackNode top;
public int size;
public MyStack()
{
//Set node values
this.top = null;
this.size = 0;
}
// Add node at the top of stack
public void push(int element)
{
this.top = new StackNode(element, this.top);
this.size++;
}
public Boolean isEmpty()
{
if (this.size > 0 && this.top != null)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
public void pop()
{
if (this.size > 0 && this.top != null)
{
StackNode temp = this.top;
// Change top element of stack
this.top = temp.next;
// remove previous top
temp = null;
this.size--;
}
}
public int peek()
{
return this.top.element;
}
}
public class Element
{
// Find the smallest element of left side in given array
public void leftSmallest(int[] arr, int size)
{
// Loop controlling variables
int i = 0;
MyStack stack = new MyStack();
// Outer loop (0...size)
for (i = 0; i < size; ++i)
{
// Remove the stack element until its top is not less than current element of array
while (stack.isEmpty() == false && stack.peek() >= arr[i])
{
// Remove top element
stack.pop();
}
if (stack.isEmpty() == false)
{
Console.Write(" [" + arr[i] + "] : " + stack.peek() + " \n");
}
else
{
Console.Write(" [" + arr[i] + "] : None \n");
}
stack.push(arr[i]);
}
}
public static void Main(String[] args)
{
// Given array elements
int[] arr = {
6 , 3 , 7 , 5 , 12 , 10 , 6 , 2 , 4
};
// Get the number of elements
int size = arr.Length;
}
}``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````
``````<?php
/*
Php program
Find nearest smallest element of left side in array
by using stack
*/
// Define stack node
class StackNode
{
public \$element;
public \$next;

function __construct(\$element, \$next)
{
\$this->element = \$element;
\$this->next = \$next;
}
}
// Define a custom stack
class MyStack
{
public \$top;
public \$size;

function __construct()
{
//Set node values
\$this->top = null;
\$this->size = 0;
}
// Add node at the top of stack
public  function push(\$element)
{
\$this->top = new StackNode(\$element, \$this->top);
\$this->size++;
}
public  function isEmpty()
{
if (\$this->size > 0 && \$this->top != null)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
public  function pop()
{
if (\$this->size > 0 && \$this->top != null)
{
\$temp = \$this->top;
// Change top element of stack
\$this->top = \$temp->next;
// remove previous top
\$temp = null;
\$this->size--;
}
}
public  function peek()
{
return \$this->top->element;
}
}
class Element
{
// Find the smallest element of left side in given array
public  function leftSmallest( & \$arr, \$size)
{
// Loop controlling variables
\$i = 0;
\$stack = new MyStack();
// Outer loop (0...size)
for (\$i = 0; \$i < \$size; ++\$i)
{
// Remove the stack element until its top is not less than current element of array
while (\$stack->isEmpty() == false && \$stack->peek() >= \$arr[\$i])
{
// Remove top element
\$stack->pop();
}
if (\$stack->isEmpty() == false)
{
echo " [". \$arr[\$i] ."] : ". \$stack->peek() ." \n";
}
else
{
echo " [". \$arr[\$i] ."] : None \n";
}
\$stack->push(\$arr[\$i]);
}
}
}

function main()
{
// Given array elements
\$arr = array(6, 3, 7, 5, 12, 10, 6, 2, 4);
// Get the number of elements
\$size = count(\$arr);
}
main();``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````
``````/*
Node Js program
Find nearest smallest element of left side in array
by using stack
*/
// Define stack node
class StackNode
{
constructor(element, next)
{
this.element = element;
this.next = next;
}
}
// Define a custom stack
class MyStack
{
constructor()
{
//Set node values
this.top = null;
this.size = 0;
}
// Add node at the top of stack
push(element)
{
this.top = new StackNode(element, this.top);
this.size++;
}
isEmpty()
{
if (this.size > 0 && this.top != null)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
pop()
{
if (this.size > 0 && this.top != null)
{
var temp = this.top;
// Change top element of stack
this.top = temp.next;
// remove previous top
temp = null;
this.size--;
}
}
peek()
{
return this.top.element;
}
}
class Element
{
// Find the smallest element of left side in given array
leftSmallest(arr, size)
{
// Loop controlling variables
var i = 0;
var stack = new MyStack();
// Outer loop (0...size)
for (i = 0; i < size; ++i)
{
// Remove the stack element until its top is not less than current element of array
while (stack.isEmpty() == false && stack.peek() >= arr[i])
{
// Remove top element
stack.pop();
}
if (stack.isEmpty() == false)
{
process.stdout.write(" [" + arr[i] + "] : " + stack.peek() + " \n");
}
else
{
process.stdout.write(" [" + arr[i] + "] : None \n");
}
stack.push(arr[i]);
}
}
}

function main()
{
// Given array elements
var arr = [6, 3, 7, 5, 12, 10, 6, 2, 4];
// Get the number of elements
var size = arr.length;
}
main();``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````
``````#   Python 3 program
#   Find nearest smallest element of left side in array
#   by using stack

#  Define stack node
class StackNode :

def __init__(self, element, next) :
self.element = element
self.next = next

#  Define a custom stack
class MyStack :

def __init__(self) :
# Set node values
self.top = None
self.size = 0

#  Add node at the top of stack
def push(self, element) :
self.top = StackNode(element, self.top)
self.size += 1

def isEmpty(self) :
if (self.size > 0 and self.top != None) :
return False
else :
return True

#  Remove top element of stack
def pop(self) :
if (self.size > 0 and self.top != None) :
temp = self.top
#  Change top element of stack
self.top = temp.next
#  remove previous top
temp = None
self.size -= 1

def peek(self) :
return self.top.element

class Element :
#  Find the smallest element of left side in given array
def leftSmallest(self, arr, size) :
#  Loop controlling variables
i = 0
stack = MyStack()
#  Outer loop (0...size)
while (i < size) :
#  Remove the stack element until its top is not less than current element of array
while (stack.isEmpty() == False and stack.peek() >= arr[i]) :
#  Remove top element
stack.pop()

if (stack.isEmpty() == False) :
print(" [", arr[i] ,"] : ", stack.peek() ," ")
else :
print(" [", arr[i] ,"] : None ")

stack.push(arr[i])
i += 1

def main() :
#  Given array elements
arr = [6, 3, 7, 5, 12, 10, 6, 2, 4]
#  Get the number of elements
size = len(arr)

if __name__ == "__main__": main()``````

#### Output

`````` [ 6 ] : None
[ 3 ] : None
[ 7 ] :  3
[ 5 ] :  3
[ 12 ] :  5
[ 10 ] :  5
[ 6 ] :  5
[ 2 ] : None
[ 4 ] :  2``````
``````#   Ruby program
#   Find nearest smallest element of left side in array
#   by using stack

#  Define stack node
class StackNode
# Define the accessor and reader of class StackNode
attr_accessor :element, :next

def initialize(element, top)
self.element = element
self.next = top
end

end

#  Define a custom stack
class MyStack
# Define the accessor and reader of class MyStack
attr_accessor :top, :size

def initialize()
# Set node values
self.top = nil
self.size = 0
end

#  Add node at the top of stack
def push(element)
self.top = StackNode.new(element, self.top)
self.size += 1
end

def isEmpty()
if (self.size > 0 && self.top != nil)
return false
else
return true
end

end

#  Remove top element of stack
def pop()
if (self.size > 0 && self.top != nil)
temp = self.top
#  Change top element of stack
self.top = temp.next
#  remove previous top
temp = nil
self.size -= 1
end

end

def peek()
return self.top.element
end

end

class Element
#  Find the smallest element of left side in given array
def leftSmallest(arr, size)
#  Loop controlling variables
i = 0
stack = MyStack.new()
#  Outer loop (0...size)
while (i < size)
#  Remove the stack element until its top is not less than current element of array
while (stack.isEmpty() == false && stack.peek() >= arr[i])
#  Remove top element
stack.pop()
end

if (stack.isEmpty() == false)
print(" [", arr[i] ,"] : ", stack.peek() ," \n")
else
print(" [", arr[i] ,"] : None \n")
end

stack.push(arr[i])
i += 1
end

end

end

def main()
#  Given array elements
arr = [6, 3, 7, 5, 12, 10, 6, 2, 4]
#  Get the number of elements
size = arr.length
end

main()``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2
``````
``````/*
Scala program
Find nearest smallest element of left side in array
by using stack
*/
// Define stack node
class StackNode(var element: Int , var next: StackNode);
// Define a custom stack
class MyStack(var top: StackNode , var size: Int)
{
def this()
{
this(null, 0);
}
// Add node at the top of stack
def push(element: Int): Unit = {
this.top = new StackNode(element, this.top);
this.size += 1;
}
def isEmpty(): Boolean = {
if (this.size > 0 && this.top != null)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
def pop(): Unit = {
if (this.size > 0 && this.top != null)
{
var temp: StackNode = this.top;
// Change top element of stack
this.top = temp.next;
// remove previous top
temp = null;
this.size -= 1;
}
}
def peek(): Int = {
return this.top.element;
}
}
class Element
{
// Find the smallest element of left side in given array
def leftSmallest(arr: Array[Int], size: Int): Unit = {
// Loop controlling variables
var i: Int = 0;
var stack: MyStack = new MyStack();
// Outer loop (0...size)
while (i < size)
{
// Remove the stack element until its top is not less than current element of array
while (stack.isEmpty() == false && stack.peek() >= arr(i))
{
// Remove top element
stack.pop();
}
if (stack.isEmpty() == false)
{
print(" [" + arr(i) + "] : " + stack.peek() + " \n");
}
else
{
print(" [" + arr(i) + "] : None \n");
}
stack.push(arr(i));
i += 1;
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Element = new Element();
// Given array elements
var arr: Array[Int] = Array(6, 3, 7, 5, 12, 10, 6, 2, 4);
// Get the number of elements
var size: Int = arr.length;
}
}``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````
``````/*
Swift 4 program
Find nearest smallest element of left side in array
by using stack
*/
// Define stack node
class StackNode
{
var element: Int;
var next: StackNode? ;
init(_ element: Int, _ next: StackNode? )
{
self.element = element;
self.next = next;
}
}
// Define a custom stack
class MyStack
{
var top: StackNode? ;
var size: Int;
init()
{
//Set node values
self.top = nil;
self.size = 0;
}
// Add node at the top of stack
func push(_ element: Int)
{
self.top = StackNode(element, self.top);
self.size += 1;
}
func isEmpty()->Bool
{
if (self.size > 0 && self.top != nil)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
func pop()
{
if (self.size > 0 && self.top != nil)
{
var temp: StackNode? = self.top;
// Change top element of stack
self.top = temp!.next;
// remove previous top
temp = nil;
self.size -= 1;
}
}
func peek()->Int
{
return self.top!.element;
}
}
class Element
{
// Find the smallest element of left side in given array
func leftSmallest(_ arr: [Int], _ size: Int)
{
// Loop controlling variables
var i: Int = 0;
let stack: MyStack = MyStack();
// Outer loop (0...size)
while (i < size)
{
// Remove the stack element until its top is not less than current element of array
while (stack.isEmpty() == false && stack.peek() >= arr[i])
{
// Remove top element
stack.pop();
}
if (stack.isEmpty() == false)
{
print(" [", arr[i],"] : ", stack.peek() ," ");
}
else
{
print(" [", arr[i],"] : None ");
}
stack.push(arr[i]);
i += 1;
}
}
}
func main()
{
// Given array elements
let arr: [Int] = [6, 3, 7, 5, 12, 10, 6, 2, 4];
// Get the number of elements
let size: Int = arr.count;
}
main();``````

#### Output

`````` [ 6 ] : None
[ 3 ] : None
[ 7 ] :  3
[ 5 ] :  3
[ 12 ] :  5
[ 10 ] :  5
[ 6 ] :  5
[ 2 ] : None
[ 4 ] :  2``````
``````/*
Kotlin program
Find nearest smallest element of left side in array
by using stack
*/
// Define stack node
class StackNode
{
var element: Int;
var next: StackNode ? ;
constructor(element: Int, next: StackNode ? )
{
this.element = element;
this.next = next;
}
}
// Define a custom stack
class MyStack
{
var top: StackNode ? ;
var size: Int;
constructor()
{
//Set node values
this.top = null;
this.size = 0;
}
// Add node at the top of stack
fun push(element: Int): Unit
{
this.top = StackNode(element, this.top);
this.size += 1;
}
fun isEmpty(): Boolean
{
if (this.size > 0 && this.top != null)
{
return false;
}
else
{
return true;
}
}
// Remove top element of stack
fun pop(): Unit
{
if (this.size > 0 && this.top != null)
{
var temp: StackNode? = this.top;
// Change top element of stack
this.top = temp?.next;
this.size -= 1;
}
}
fun peek(): Int
{
return this.top!!.element;
}
}
class Element
{
// Find the smallest element of left side in given array
fun leftSmallest(arr: Array < Int > , size: Int): Unit
{
// Loop controlling variables
var i: Int = 0;
var stack: MyStack = MyStack();
// Outer loop (0...size)
while (i < size)
{
// Remove the stack element until its top is not less than current element of array
while (stack.isEmpty() == false && stack.peek() >= arr[i])
{
// Remove top element
stack.pop();
}
if (stack.isEmpty() == false)
{
print(" [" + arr[i] + "] : " + stack.peek() + " \n");
}
else
{
print(" [" + arr[i] + "] : None \n");
}
stack.push(arr[i]);
i += 1;
}
}
}
fun main(args: Array < String > ): Unit
{
// Given array elements
var arr: Array < Int > = arrayOf(6, 3, 7, 5, 12, 10, 6, 2, 4);
// Get the number of elements
var size: Int = arr.count();
}``````

#### Output

`````` [6] : None
[3] : None
[7] : 3
[5] : 3
[12] : 5
[10] : 5
[6] : 5
[2] : None
[4] : 2``````

## Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

Categories
Relative Post