Skip to main content

Check if stack elements are pairwise consecutive

Here given code implementation process.

//C Program
//Check if stack elements are pairwise consecutive
#include <stdio.h>
//For malloc function
#include <stdlib.h> 

//Define Stack Structure
struct Stack
{
  int data;
  struct Stack*next;
};

//Add element into stack
void push(int data,struct Stack**top)
{
  //Create a new stack element
  struct Stack*new_node = (struct Stack*)malloc(sizeof(struct Stack));

  if(new_node!=NULL)
  {
    new_node->data=data;

    new_node->next=*top;

    *top=new_node;
  }
  else
  {
    printf("\nMemory Overflow\n");
  }
}
//remove a top stack elements and return the value of top element
int pop(struct Stack**top)
{

  if(*top!=NULL)
  {
    struct Stack*auxiliary=*top;

    int data = auxiliary->data;

    *top=auxiliary->next;

    //Remove node
    free(auxiliary);

    auxiliary=NULL;

    return data;

  }
  return -1;
}


struct Stack* is_consecutive(struct Stack*top)
{
  //This stack variables are used to store actual stack element
  struct Stack*temp=NULL;

  //This is two auxiliary variables which are used to get pair elements
  struct Stack*first=NULL;
  struct Stack*second=NULL;
  
  //This is a flag variable which is indicate result
  int status = 1;

  while(top!=NULL && status==1)
  {
    push(pop(&top),&temp);

    //Get first pair element
    first = temp;

    if(top != NULL)
    {
      //When in case have two pair element exists
      push(pop(&top),&temp);
      
      //Get second pair element
      second = temp;
      
      //Compare two stack element
      if(first->data != second->data && (second->data+1 != first->data))
      {
        //When pairwise elements are not consecutive
        status=0; 
      }
    }
  }
  if(status==1)
  {
    printf("Pairwise sorted");
  }
  else
  {
    printf("Not Pairwise sorted");
  }
  //Remove element of auxiliary stack and insert to actual stack
  while(temp!=NULL)
  {
    //insert element into actual stack
    push(pop(&temp),&top);
  }

  printf("\n");
  return top;
}
//Remove given stack elements
void remove_elements(struct Stack**top)
{
  struct Stack*temp = NULL;
  while(*top != NULL)
  {
     temp=*top;
     *top = temp->next;
     printf("%d ",temp->data);
     free(temp);
     temp=NULL;
  }
  printf("\n");

}
int main()
{
  struct Stack *top1=NULL;

  //Add element into stack
  push(5, &top1);
  push(6, &top1);
  push(1, &top1);
  push(2, &top1);
 
  top1 = is_consecutive(top1);
  //Remove remaining elements into stack
  remove_elements(&top1);

  struct Stack *top2 = NULL;
  //Case 2
  push(6, &top2);
  push(7, &top2);
  push(1, &top2);
  push(3, &top2);
  push(4, &top2);

  top2 = is_consecutive(top2);

  //Remove remaining elements into stack
  remove_elements(&top2);
 
  return 0;
}

Output

Pairwise sorted
2 1 6 5
Not Pairwise sorted
4 3 1 7 6
/*
  C++ Program
  Check if stack elements are pairwise consecutive
*/
//Stack Node
#include<iostream>

using namespace std;
class Node {
	public:
		int data;
	Node *next;
	Node(int data) {
		this->data = data;
		this->next = NULL;
	}
};
class MyStack {
	public:
		Node *top;
	MyStack() {
		this->top = NULL;
	}
	//Add a new element in stack
	void push(int data) {
		//Make a new stack node
		Node *new_node = new Node(data);
		if (new_node != NULL) {
			new_node->next = this->top;
			this->top = new_node;
		} else {
			cout << "Memory overflow\n";
		}
	}
	//Add a top element in stack
	//When stack is empty it returns -1
	int pop() {
		int temp = -1;
		if (this->top != NULL) {
			temp = this->top->data;
			this->top = this->top->next;
		}
		return temp;
	}
	void is_consecutive() {
		//This stack variables are used to store actual stack element
		MyStack temp =  MyStack();
		//This is two auxiliary variables which are used to get pair elements
		Node *first = NULL;
		Node *second = NULL;
		//This is a flag variable which is indicate result
		bool status = true;
		while (this->top != NULL &&
			status == true) {
			temp.push(this->pop());
			//Get first pair element
			first = temp.top;
			if (this->top != NULL) {
				temp.push(this->pop());
				//Get second pair element
				second = temp.top;
				//Compare two stack element

				if (first->data != second->data &&
					(second->data + 1 != first->data)) {
					//When pairwise elements are not consecutive
					status = false;
				}
			} else {
				break;
			}
		}
		if (status == true) {
			cout << "Pairwise sorted : ";
		} else {
			cout << "Not Pairwise sorted : ";
		}
		//Remove element of auxiliary stack and insert to actual stack
		while (temp.top != NULL) {
			//insert element into actual stack
			this->push(temp.pop());
		}
	}
	void remove_nodes() {
		//This function is printing stack element and remove Existing nodes
		while (this->top != NULL) {
			cout << " " << this->pop();
		}
		cout << "\n";
	}
};
int main() {
	MyStack obj1 =  MyStack();
	//Add element into stack
	obj1.push(5);
	obj1.push(6);
	obj1.push(1);
	obj1.push(2);
	obj1.is_consecutive();
	obj1.remove_nodes();
	MyStack obj2 =  MyStack();
	//Case 2
	obj2.push(6);
	obj2.push(7);
	obj2.push(1);
	obj2.push(3);
	obj2.push(4);
	obj2.is_consecutive();
	obj2.remove_nodes();
	return 0;
}

Output

Pairwise sorted :  2 1 6 5
Not Pairwise sorted :  4 3 1 7 6
/*
  Java Program
  Check if stack elements are pairwise consecutive
*/
//Stack Node
class Node
{
  public int data;
  public Node next;
  public Node(int data)
  {
    this.data = data;
    this.next = null;
  }
}
public class MyStack {
  
  public Node top;

  public MyStack()
  {
    top = null;
  }
  //Add a new element in stack
  public void push(int data)
  {
    //Make a new stack node
    Node new_node = new Node(data);
    if(new_node!=null)
    {
      new_node.next=top;
      top = new_node;
    }
    else
    {
      System.out.print("Memory overflow\n");
    }
  }
  //Add a top element in stack
  //When stack is empty it returns -1
  public int pop()
  {
    int temp = -1;
    if(top!=null)
    {
      temp = top.data;
      top = top.next;
    }
    return temp;
  }
  public void is_consecutive() 
  {
    //This stack variables are used to store actual stack element
    MyStack temp = new MyStack();
    //This is two auxiliary variables which are used to get pair elements
    Node first = null;
    Node second = null;

    //This is a flag variable which is indicate result
    boolean status = true;
    while (this.top  != null && status == true) 
    {
      temp.push(this.pop());

      //Get first pair element
      first = temp.top;

      if (this.top != null) 
      {
        
        temp.push(this.pop());
        //Get second pair element
        second = temp.top;
        //Compare two stack element

        if (first.data != second.data && (second.data + 1 != first.data)) 
        {
          //When pairwise elements are not consecutive
          status = false;
        }
      }
      else
      {
        break;
      }
    }
    if (status == true) 
    {
      System.out.print("Pairwise sorted : ");
    } 
    else 
    {
      System.out.print("Not Pairwise sorted : ");
    }
    //Remove element of auxiliary stack and insert to actual stack
    while (temp.top != null) 
    {
      //insert element into actual stack
      this.push(temp.pop());
    }
  
    
  }
  public void remove_nodes()
  {
    //This function is printing stack element and remove Existing nodes
    while(this.top!=null)
    {
      System.out.print(" "+this.pop());
    }
    System.out.print("\n");
  }
  public static void main(String[] args) {

    MyStack obj1 = new MyStack();
    
    //Add element into stack
    obj1.push(5);
    obj1.push(6);
    obj1.push(1);
    obj1.push(2);
   
    obj1.is_consecutive();
    obj1.remove_nodes();

    MyStack obj2 = new MyStack();

    //Case 2
    obj2.push(6);
    obj2.push(7);
    obj2.push(1);
    obj2.push(3);
    obj2.push(4);
    obj2.is_consecutive();
    obj2.remove_nodes();

  
  }
}

Output

Pairwise sorted :   2  1  6  5
Not Pairwise sorted :   4  3  1  7  6
/*
  C# Program
  Check if stack elements are pairwise consecutive
*/
//Stack Node
using System;
public class Node {
	public int data;
	public Node next;
	public Node(int data) {
		this.data = data;
		this.next = null;
	}
}
public class MyStack {
	public Node top;
	public MyStack() {
		top = null;
	}
	//Add a new element in stack
	public void push(int data) {
		//Make a new stack node
		Node new_node = new Node(data);
		if (new_node != null) {
			new_node.next = top;
			top = new_node;
		} else {
			Console.Write("Memory overflow\n");
		}
	}
	//Add a top element in stack
	//When stack is empty it returns -1
	public int pop() {
		int temp = -1;
		if (top != null) {
			temp = top.data;
			top = top.next;
		}
		return temp;
	}
	public void is_consecutive() {
		//This stack variables are used to store actual stack element
		MyStack temp = new MyStack();
		//This is two auxiliary variables which are used to get pair elements
		Node first = null;
		Node second = null;
		//This is a flag variable which is indicate result
		Boolean status = true;
		while (this.top != null &&
			status == true) {
			temp.push(this.pop());
			//Get first pair element
			first = temp.top;
			if (this.top != null) {
				temp.push(this.pop());
				//Get second pair element
				second = temp.top;
				//Compare two stack element

				if (first.data != second.data &&
					(second.data + 1 != first.data)) {
					//When pairwise elements are not consecutive
					status = false;
				}
			} else {
				break;;
			}
		}
		if (status == true) {
			Console.Write("Pairwise sorted : ");
		} else {
			Console.Write("Not Pairwise sorted : ");
		}
		//Remove element of auxiliary stack and insert to actual stack
		while (temp.top != null) {
			this.push(temp.pop());
		}
	}
	public void remove_nodes() {
		//This function is printing stack element and remove Existing nodes
		while (this.top != null) {
			Console.Write(" " + this.pop());
		}
		Console.Write("\n");
	}
	public static void Main(String[] args) {
		MyStack obj1 = new MyStack();
		obj1.push(5);
		obj1.push(6);
		obj1.push(1);
		obj1.push(2);
		obj1.is_consecutive();
		obj1.remove_nodes();
		MyStack obj2 = new MyStack();
		obj2.push(6);
		obj2.push(7);
		obj2.push(1);
		obj2.push(3);
		obj2.push(4);
		obj2.is_consecutive();
		obj2.remove_nodes();
	}
}

Output

Pairwise sorted :  2 1 6 5
Not Pairwise sorted :  4 3 1 7 6
<?php
/*
  Php Program
  Check if stack elements are pairwise consecutive
*/
//Stack Node
class Node {
	public $data;
	public $next;

	function __construct($data) {
		$this->data = $data;
		$this->next = null;
	}
}
class MyStack {
	public $top;

	function __construct() {
		$this->top = null;
	}
	//Add a new element in stack

	public 	function push($data) {
		//Make a new stack node
		$new_node = new Node($data);
		if ($new_node != null) {
			$new_node->next = $this->top;
			$this->top = $new_node;
		} else {
			echo("Memory overflow\n");
		}
	}
	//Add a top element in stack
	//When stack is empty it returns -1

	public 	function pop() {
		$temp = -1;
		if ($this->top != null) {
			$temp = $this->top->data;
			$this->top = $this->top->next;
		}
		return $temp;
	}
	public 	function is_consecutive() {
		//This stack variables are used to store actual stack element
		$temp = new MyStack();
		//This is two auxiliary variables which are used to get pair elements
		$first = null;
		$second = null;
		//This is a flag variable which is indicate result
		$status = true;
		while ($this->top != null &&
			$status == true) {
			$temp->push($this->pop());
			//Get first pair element
			$first = $temp->top;
			if ($this->top != null) {
				$temp->push($this->pop());
				//Get second pair element
				$second = $temp->top;
				//Compare two stack element

				if ($first->data != $second->data &&
					($second->data + 1 != $first->data)) {
					//When pairwise elements are not consecutive
					$status = false;
				}
			} else {
				break;
			}
		}
		if ($status == true) {
			echo("Pairwise sorted : ");
		} else {
			echo("Not Pairwise sorted : ");
		}
		//Remove element of auxiliary stack and insert to actual stack
		while ($temp->top != null) {
			//insert element into actual stack
			$this->push($temp->pop());
		}
	}
	public 	function remove_nodes() {
		//This function is printing stack element and remove Existing nodes
		while ($this->top != null) {
			echo(" ". $this->pop());
		}
		echo("\n");
	}
}

function main() {
	$obj1 = new MyStack();
	//Add element into stack
	$obj1->push(5);
	$obj1->push(6);
	$obj1->push(1);
	$obj1->push(2);
	$obj1->is_consecutive();
	$obj1->remove_nodes();
	$obj2 = new MyStack();
	//Case 2
	$obj2->push(6);
	$obj2->push(7);
	$obj2->push(1);
	$obj2->push(3);
	$obj2->push(4);
	$obj2->is_consecutive();
	$obj2->remove_nodes();

}
main();

Output

Pairwise sorted :  2 1 6 5
Not Pairwise sorted :  4 3 1 7 6
/*
  Node Js Program
  Check if stack elements are pairwise consecutive
*/
//Stack Node
class Node {
	constructor(data) {
		this.data = data;
		this.next = null;
	}
}
class MyStack {
	constructor() {
		this.top = null;
	}

	//Add a new element in stack
	push(data) {
		//Make a new stack node
		var new_node = new Node(data);
		if (new_node != null) {
			new_node.next = this.top;
			this.top = new_node;
		} else {
			process.stdout.write("Memory overflow\n");
		}
	}

	//Add a top element in stack
	//When stack is empty it returns -1
	pop() {
		var temp = -1;
		if (this.top != null) {
			temp = this.top.data;
			this.top = this.top.next;
		}

		return temp;
	}
	is_consecutive() {
		//This stack variables are used to store actual stack element
		var temp = new MyStack();
		//This is two auxiliary variables which are used to get pair elements
		var first = null;
		var second = null;
		//This is a flag variable which is indicate result
		var status = true;
		while (this.top != null &&
			status == true) {
			temp.push(this.pop());
			//Get first pair element
			first = temp.top;
			if (this.top != null) {
				temp.push(this.pop());
				//Get second pair element
				second = temp.top;
				//Compare two stack element

				if (first.data != second.data &&
					(second.data + 1 != first.data)) {
					//When pairwise elements are not consecutive
					status = false;
				}
			} else {
				break;
			}
		}

		if (status == true) {
			process.stdout.write("Pairwise sorted : ");
		} else {
			process.stdout.write("Not Pairwise sorted : ");
		}

		//Remove element of auxiliary stack and insert to actual stack
		while (temp.top != null) {
			//insert element into actual stack
			this.push(temp.pop());
		}
	}
	remove_nodes() {
		//This function is printing stack element and remove Existing nodes
		while (this.top != null) {
			process.stdout.write(" " + this.pop());
		}

		process.stdout.write("\n");
	}
}

function main(args) {
	var obj1 = new MyStack();
	//Add element into stack
	obj1.push(5);
	obj1.push(6);
	obj1.push(1);
	obj1.push(2);
	obj1.is_consecutive();
	obj1.remove_nodes();
	var obj2 = new MyStack();
	//Case 2
	obj2.push(6);
	obj2.push(7);
	obj2.push(1);
	obj2.push(3);
	obj2.push(4);
	obj2.is_consecutive();
	obj2.remove_nodes();
}

main();

Output

Pairwise sorted :  2 1 6 5
Not Pairwise sorted :  4 3 1 7 6
#   Python 3 Program
#   Check if stack elements are pairwise consecutive

# Stack Node
class Node :
	
	def __init__(self, data) :
		self.data = data
		self.next = None
	

class MyStack :
	
	def __init__(self) :
		self.top = None
	
	# Add a new element in stack
	def push(self, data) :
		# Make a new stack node
		new_node = Node(data)
		if (new_node != None) :
			new_node.next = self.top
			self.top = new_node
		else :
			print("Memory overflow\n", end = "")
		
	
	# Add a top element in stack
	# When stack is empty it returns -1
	def pop(self) :
		temp = -1
		if (self.top != None) :
			temp = self.top.data
			self.top = self.top.next
		
		return temp
	
	def is_consecutive(self) :
		# This stack variables are used to store actual stack element
		temp = MyStack()
		# This is two auxiliary variables which are used to get pair elements
		first = None
		second = None
		# This is a flag variable which is indicate result
		status = True
		while (self.top != None and status == True) :
			temp.push(self.pop())
			# Get first pair element
			first = temp.top
			if (self.top != None) :
				temp.push(self.pop())
				# Get second pair element
				second = temp.top
				# Compare two stack element

				if (first.data != second.data and(second.data + 1 != first.data)) :
					# When pairwise elements are not consecutive
					status = False
				
			else :
				break
			
		
		if (status == True) :
			print("Pairwise sorted : ", end = "")
		else :
			print("Not Pairwise sorted : ", end = "")
		
		# Remove element of auxiliary stack and insert to actual stack
		while (temp.top != None) :
			# insert element into actual stack
			self.push(temp.pop())
		
	
	def remove_nodes(self) :
		# This function is printing stack element and remove Existing nodes
		while (self.top != None) :
			print(" ", self.pop(), end = "")
		
		print("\n", end = "")
	

def main() :
	obj1 = MyStack()
	# Add element into stack
	obj1.push(5)
	obj1.push(6)
	obj1.push(1)
	obj1.push(2)
	obj1.is_consecutive()
	obj1.remove_nodes()
	obj2 = MyStack()
	# Case 2
	obj2.push(6)
	obj2.push(7)
	obj2.push(1)
	obj2.push(3)
	obj2.push(4)
	obj2.is_consecutive()
	obj2.remove_nodes()


if __name__ == "__main__":
	main()

Output

Pairwise sorted :   2  1  6  5
Not Pairwise sorted :   4  3  1  7  6
#   Ruby Program
#   Check if stack elements are pairwise consecutive

# Stack Node
class Node
    # Define the accessor and reader of class Node
    attr_reader :data, :next
    attr_accessor :data, :next 
	
	def initialize(data) 
		self.data = data
		self.next = nil
	end
end
class MyStack
    # Define the accessor and reader of class MyStack
    attr_reader :top
    attr_accessor :top 
	
	def initialize() 
		@top = nil
	end
	# Add a new element in stack
	def push(data) 
		# Make a new stack node
		new_node = Node.new(data)
		if (new_node != nil) 
			new_node.next = @top
			@top = new_node
		else 
			print("Memory overflow\n")
		end
	end
	# Add a top element in stack
	# When stack is empty it returns -1
	def pop() 
		temp = -1
		if (@top != nil) 
			temp = @top.data
			@top = @top.next
		end
		return temp
	end
	def is_consecutive() 
		# This stack variables are used to store actual stack element
		temp = MyStack.new()
		# This is two auxiliary variables which are used to get pair elements
		first = nil
		second = nil
		# This is a flag variable which is indicate result
		status = true
		while (self.top != nil &&
			status == true) 
			temp.push(self.pop())
			# Get first pair element
			first = temp.top
			if (self.top != nil) 
				temp.push(self.pop())
				# Get second pair element
				second = temp.top
				# Compare two stack element

				if (first.data != second.data &&
					(second.data + 1 != first.data)) 
					# When pairwise elements are not consecutive
					status = false
				end
			else 
				break
			end
		end
		if (status == true) 
			print("Pairwise sorted  :")
		else 
			print("Not Pairwise sorted  :")
		end
		# Remove element of auxiliary stack and insert to actual stack
		while (temp.top != nil) 
			# insert element into actual stack
			self.push(temp.pop())
		end
	end
	def remove_nodes() 
		# This function is printing stack element and remove Existing nodes
		while (self.top != nil) 
			print(" ", self.pop())
		end
		print("\n")
	end
end
def main() 
	obj1 = MyStack.new()
	# Add element into stack
	obj1.push(5)
	obj1.push(6)
	obj1.push(1)
	obj1.push(2)
	obj1.is_consecutive()
	obj1.remove_nodes()
	obj2 = MyStack.new()
	# Case 2
	obj2.push(6)
	obj2.push(7)
	obj2.push(1)
	obj2.push(3)
	obj2.push(4)
	obj2.is_consecutive()
	obj2.remove_nodes()
end
main()

Output

Pairwise sorted  : 2 1 6 5
Not Pairwise sorted  : 4 3 1 7 6

/*
  Scala Program
  Check if stack elements are pairwise consecutive
*/
//Stack Node
class Node(var next: Node,
	var data: Int) {


	def this(data: Int) {
		this( null,data);
	}
} 
class MyStack(var top: Node) {

	def this() {
		this(null);
	}
	//Add a new element in stack
	def push(data: Int): Unit = {
		//Make a new stack node
		var new_node: Node = new Node(data);

		if (new_node != null) {
			new_node.next = top;
			top = new_node;
		} else {
			print("Memory overflow\n");
		}
	}
	//Add a top element in stack
	//When stack is empty it returns -1
	def pop(): Int = {
		var temp: Int = -1;

		if (top != null) {
			temp = top.data;
			top = top.next;
		}
		return temp;
	}
	def is_consecutive(): Unit = {
		//This stack variables are used to store actual stack element
		var temp: MyStack = new MyStack();

		//This is two auxiliary variables which are used to get pair elements
		var first: Node = null;
		var second: Node = null;

		//This is a flag variable which is indicate result
		var status: Boolean = true;
		var in_out: Boolean = true;
		while (this.top != null &&
			status == true && in_out==true) {
			temp.push(this.pop());

			//Get first pair element
			first = temp.top;

			if (this.top != null) {
				temp.push(this.pop());

				//Get second pair element
				second = temp.top;

				//Compare two stack element

				if (first.data != second.data &&
					(second.data + 1 != first.data)) {
					//When pairwise elements are not consecutive
					status = false;
				}
			} else {
				in_out=false;
			}
		}
		if (status == true) {
			print("Pairwise sorted : ");
		} else {
			print("Not Pairwise sorted : ");
		}
		//Remove element of auxiliary stack and insert to actual stack
		while (temp.top != null) {
			//insert element into actual stack
			this.push(temp.pop());
		}
	}
	def remove_nodes(): Unit = {
		//This function is printing stack element and remove Existing nodes
		while (this.top != null) {
			print(" " + this.pop());
		}
		print("\n");
	}
}
object Main {
	def main(args: Array[String]): Unit = {
		var obj1: MyStack = new MyStack();

		//Add element into stack
		obj1.push(5);
		obj1.push(6);
		obj1.push(1);
		obj1.push(2);
		obj1.is_consecutive();
		obj1.remove_nodes();
		var obj2: MyStack = new MyStack();

		//Case 2
		obj2.push(6);
		obj2.push(7);
		obj2.push(1);
		obj2.push(3);
		obj2.push(4);
		obj2.is_consecutive();
		obj2.remove_nodes();
	}
}

Output

Pairwise sorted :  2 1 6 5
Not Pairwise sorted :  4 3 1 7 6
/*
  Swift Program
  Check if stack elements are pairwise consecutive
*/
//Stack Node
class Node {
	var data: Int;
	var next: Node? ;
	init(_ data: Int) {
		self.data = data;
		self.next = nil;
	}
}
class MyStack {
	var top: Node? ;
	init() {
		self.top = nil;
	}
	//Add a new element in stack
	func push(_ data: Int) {
		//Make a new stack node
		let new_node: Node? = Node(data);
		if (new_node != nil) {
			new_node!.next = self.top;
			self.top = new_node;
		} else {
			print("Memory overflow\n", terminator: "");
		}
	}
	//Add a top element in stack
	//When stack is empty it returns -1
	func pop() -> Int {
		var temp: Int = -1;
		if (self.top != nil) {
			temp = self.top!.data;
			self.top = self.top!.next;
		}
		return temp;
	}
	func is_consecutive() {
		//This stack variables are used to store actual stack element
		let temp: MyStack? = MyStack();
		//This is two auxiliary variables which are used to get pair elements
		var first: Node? = nil;
		var second: Node? = nil;
		//This is a flag variable which is indicate result
		var status: Bool = true;
		while (self.top != nil &&
			status == true) {
			temp!.push(self.pop());
			//Get first pair element
			first = temp!.top;
			if (self.top != nil) {
				temp!.push(self.pop());
				//Get second pair element
				second = temp!.top;
				//Compare two stack element

				if (first!.data != second!.data &&
					(second!.data + 1 != first!.data)) {
					//When pairwise elements are not consecutive
					status = false;
				}
			} else {
				break;
			}
		}
		if (status == true) {
			print("Pairwise sorted : ", terminator: "");
		} else {
			print("Not Pairwise sorted : ", terminator: "");
		}
		//Remove element of auxiliary stack and insert to actual stack
		while (temp!.top != nil) {
			//insert element into actual stack
			self.push(temp!.pop());
		}
	}
	func remove_nodes() {
		//This function is printing stack element and remove Existing nodes
		while (self.top != nil) {
			print(" ", self.pop(), terminator: "");
		}
		print("\n", terminator: "");
	}
}
func main() {
	let obj1: MyStack? = MyStack();
	//Add element into stack
	obj1!.push(5);
	obj1!.push(6);
	obj1!.push(1);
	obj1!.push(2);
	obj1!.is_consecutive();
	obj1!.remove_nodes();
	let obj2: MyStack? = MyStack();
	//Case 2
	obj2!.push(6);
	obj2!.push(7);
	obj2!.push(1);
	obj2!.push(3);
	obj2!.push(4);
	obj2!.is_consecutive();
	obj2!.remove_nodes();
}
main();

Output

Pairwise sorted :   2  1  6  5
Not Pairwise sorted :   4  3  1  7  6
Last updated on by Kalkicode




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.

New Comment