Shift the vowels node at beginning of linked list

Here given code implementation process.

// C Program 
// Shift the vowels node at beginning of linked list
#include <stdio.h>

#include <stdlib.h> //for malloc function

// Linked List LinkNode
struct LinkNode
{
    char data;
    struct LinkNode *next;
};
// Singly linked list 
struct SingleLL
{
    struct LinkNode *head;
    struct LinkNode *tail;
};
// Returns the new linked list
struct SingleLL *newLinkedList()
{
    // Create memory of head and tail Nodes
    struct SingleLL *sll = (struct SingleLL *) malloc(sizeof(struct SingleLL));
    if (sll == NULL)
    {
        printf("Memory overflow\n");
    }
    else
    {
        sll->head = NULL;
        sll->tail = NULL;
    }
    return sll;
}
// Returns a new Node of linked list
struct LinkNode *createLinkNode(char data)
{
    // Create dynamic node
    struct LinkNode *node = (struct LinkNode *) malloc(sizeof(struct LinkNode));
    if (node == NULL)
    {
        printf("Memory overflow\n");
    }
    else
    {
        // Set initial node value
        node->data = data;
        node->next = NULL;
    }
    return node;
}
// Add new Node at end of linked list 
void addNode(struct SingleLL *sll, char data)
{
    struct LinkNode *node = createLinkNode(data);
    if (sll->head == NULL)
    {
        sll->head = node;
    }
    else
    {
        // Append the node at last position
        sll->tail->next = node;
    }
    sll->tail = node;
}
// Display linked list element
void display(struct SingleLL *sll)
{
    if (sll->head == NULL)
    {
        printf("\n Empty linked list\n");
        return;
    }
    struct LinkNode *temp = sll->head;
    // iterating linked list elements
    while (temp != NULL)
    {
        printf(" %c →", temp->data);
        // Visit to next node
        temp = temp->next;
    }
    printf(" NULL\n");
}

// Determine that given value is an vowel or not
int isVowels( char value)
{
    if(value=='a' || value=='e' || value=='i'|| value=='o'|| value=='u'
     || value=='A'|| value=='E' || value=='I'|| value=='O'|| value=='U')
    {
        return 1;
    }
    return 0;
}
//  Move the vowels value at beginning position
void shiftVowels(struct SingleLL *sll)
{
    if (sll->head == NULL)
    {
        printf("\n Empty linked list\n");
        return;
    }
    // Define some auxiliary variable
    struct LinkNode *auxiliary = sll->head;
    struct LinkNode *ordinary  = sll->head;
    char temp = ' ';

    // iterate linked list nodes
    // Using swap value , shift vowels at front of linked list
    while(auxiliary != NULL && ordinary != NULL )
    {
        if(isVowels(auxiliary->data)==1 )
        {
            if(ordinary==auxiliary)
            {   
                // When both node is same
                // Visit to next node
                ordinary  = ordinary->next;
                auxiliary = auxiliary->next;
            }
            else if(isVowels(ordinary->data)==1)
            {
                // When ordinary value is an vowel
                ordinary = ordinary->next;
            }
            else
            {
                // Swap node value
                temp = ordinary->data;
                ordinary->data  = auxiliary->data;
                auxiliary->data = temp;

                // Visit to next node
                auxiliary = auxiliary->next;
                ordinary = ordinary->next;
            }
        }
        else
        {
            // Visit to next node
            auxiliary = auxiliary->next;
        }
    }
}
int main()
{
    // Define linked list
    struct SingleLL *sll = newLinkedList();


    // Constructed linked list
    addNode(sll, 'E');
    addNode(sll, 'D');
    addNode(sll, 'U');
    addNode(sll, 'C');
    addNode(sll, 'A');
    addNode(sll, 'T');
    addNode(sll, 'I');
    addNode(sll, 'O');
    addNode(sll, 'N');
    printf(" Before Shift \n");
    // E → D → U → C → A → T → I → O → N → NULL
    display(sll);

    shiftVowels(sll);
    printf(" After Shift \n");
    // E → U → A → I → O → T → C → D → N → NULL
    display(sll);
 
    return 0;
}

Output

 Before Shift
 E → D → U → C → A → T → I → O → N → NULL
 After Shift
 E → U → A → I → O → T → C → D → N → NULL
/*
  Java Program 
  Shift the vowels node at beginning of linked list
*/
// Linked list node
class LinkNode
{
    public char data;
    public LinkNode next;
    public LinkNode(char data)
    {
        this.data = data;
        this.next = null;
    }
}
public class SingleLL
{
    public LinkNode head;
    public LinkNode tail;
    public SingleLL()
    {
        this.head = null;
        this.tail = null;
    }
    //Add new Node at end of linked list 
    public void addNode(char data)
    {
        LinkNode node = new LinkNode(data);
        if (this.head == null)
        {
            this.head = node;
        }
        else
        {
            // Append the node at last position
            this.tail.next = node;
        }
        this.tail = node;
    }
    // Display linked list element
    public void display()
    {
        if (this.head == null)
        {
            System.out.print("\n Empty linked list\n");
            return;
        }
        LinkNode temp = this.head;
        //iterating linked list elements
        while (temp != null)
        {
            System.out.print(" " + temp.data + " →");
            // Visit to next node
            temp = temp.next;
        }
        System.out.print(" NULL\n");
    }
    // Determine that given value is an vowel or not
    public boolean isVowels(char value)
    {
        if (value == 'a' || value == 'e' 
            || value == 'i' || value == 'o' 
            || value == 'u' || value == 'A' 
            || value == 'E' || value == 'I' 
            || value == 'O' || value == 'U')
        {
            return true;
        }
        return false;
    }
    //  Move the vowels value at beginning position
    public void shiftVowels()
    {
        if (this.head == null)
        {
            System.out.print("\n Empty linked list\n");
            return;
        }
        // Define some auxiliary variable
        LinkNode auxiliary = this.head;
        LinkNode ordinary = this.head;
        char temp = ' ';
        // iterate linked list nodes
        // Using swap value , shift vowels at front of linked list
        while (auxiliary != null && ordinary != null)
        {
            if (isVowels(auxiliary.data) == true)
            {
                if (ordinary == auxiliary)
                {
                    // When both node is same
                    // Visit to next node
                    ordinary = ordinary.next;
                    auxiliary = auxiliary.next;
                }
                else if (isVowels(ordinary.data) == true)
                {
                    // When ordinary value is an vowel
                    ordinary = ordinary.next;
                }
                else
                {
                    // Swap node value
                    temp = ordinary.data;
                    ordinary.data = auxiliary.data;
                    auxiliary.data = temp;
                    // Visit to next node
                    auxiliary = auxiliary.next;
                    ordinary = ordinary.next;
                }
            }
            else
            {
                // Visit to next node
                auxiliary = auxiliary.next;
            }
        }
    }
    public static void main(String[] args)
    {
        SingleLL sll = new SingleLL();
        // Constructed linked list
        sll.addNode('E');
        sll.addNode('D');
        sll.addNode('U');
        sll.addNode('C');
        sll.addNode('A');
        sll.addNode('T');
        sll.addNode('I');
        sll.addNode('O');
        sll.addNode('N');
        System.out.print(" Before Shift \n");
        // E → D → U → C → A → T → I → O → N → NULL
        sll.display();
        sll.shiftVowels();
        System.out.print(" After Shift \n");
        // E → U → A → I → O → T → C → D → N → NULL
        sll.display();
    }
}

Output

 Before Shift
 E → D → U → C → A → T → I → O → N → NULL
 After Shift
 E → U → A → I → O → T → C → D → N → NULL
// Include header file
#include <iostream>
using namespace std;

/*
  C++ Program 
  Shift the vowels node at beginning of linked list
*/

// Linked list node
class LinkNode
{
	public: char data;
	LinkNode *next;
	LinkNode(char data)
	{
		this->data = data;
		this->next = NULL;
	}
};
class SingleLL
{
	public: LinkNode *head;
	LinkNode *tail;
	SingleLL()
	{
		this->head = NULL;
		this->tail = NULL;
	}
	//Add new Node at end of linked list
	void addNode(char data)
	{
		LinkNode *node = new LinkNode(data);
		if (this->head == NULL)
		{
			this->head = node;
		}
		else
		{
			// Append the node at last position
			this->tail->next = node;
		}
		this->tail = node;
	}
	// Display linked list element
	void display()
	{
		if (this->head == NULL)
		{
			cout << "\n Empty linked list\n";
			return;
		}
		LinkNode *temp = this->head;
		//iterating linked list elements
		while (temp != NULL)
		{
			cout << " " << temp->data << " →";
			// Visit to next node
			temp = temp->next;
		}
		cout << " NULL\n";
	}
	// Determine that given value is an vowel or not
	bool isVowels(char value)
	{
		if (   value == 'a' || value == 'e' 
            || value == 'i' || value == 'o' 
            || value == 'u' || value == 'A' 
            || value == 'E' || value == 'I' 
            || value == 'O' || value == 'U')
		{
			return true;
		}
		return false;
	}
	//  Move the vowels value at beginning position
	void shiftVowels()
	{
		if (this->head == NULL)
		{
			cout << "\n Empty linked list\n";
			return;
		}
		// Define some auxiliary variable
		LinkNode *auxiliary = this->head;
		LinkNode *ordinary = this->head;
		char temp = ' ';
		// iterate linked list nodes
		// Using swap value , shift vowels at front of linked list
		while (auxiliary != NULL && ordinary != NULL)
		{
			if (this->isVowels(auxiliary->data) == true)
			{
				if (ordinary == auxiliary)
				{
					// When both node is same
					// Visit to next node
					ordinary = ordinary->next;
					auxiliary = auxiliary->next;
				}
				else if (this->isVowels(ordinary->data) == true)
				{
					// When ordinary value is an vowel
					ordinary = ordinary->next;
				}
				else
				{
					// Swap node value
					temp = ordinary->data;
					ordinary->data = auxiliary->data;
					auxiliary->data = temp;
					// Visit to next node
					auxiliary = auxiliary->next;
					ordinary = ordinary->next;
				}
			}
			else
			{
				// Visit to next node
				auxiliary = auxiliary->next;
			}
		}
	}
};
int main()
{
	SingleLL sll = SingleLL();
	// Constructed linked list
	sll.addNode('E');
	sll.addNode('D');
	sll.addNode('U');
	sll.addNode('C');
	sll.addNode('A');
	sll.addNode('T');
	sll.addNode('I');
	sll.addNode('O');
	sll.addNode('N');
	cout << " Before Shift \n";
	// E → D → U → C → A → T → I → O → N → NULL
	sll.display();
	sll.shiftVowels();
	cout << " After Shift \n";
	// E → U → A → I → O → T → C → D → N → NULL
	sll.display();
	return 0;
}

Output

 Before Shift
 E → D → U → C → A → T → I → O → N → NULL
 After Shift
 E → U → A → I → O → T → C → D → N → NULL
// Include namespace system
using System;
/*
  C# Program 
  Shift the vowels node at beginning of linked list
*/
// Linked list node
public class LinkNode
{
	public char data;
	public LinkNode next;
	public LinkNode(char data)
	{
		this.data = data;
		this.next = null;
	}
}
public class SingleLL
{
	public LinkNode head;
	public LinkNode tail;
	public SingleLL()
	{
		this.head = null;
		this.tail = null;
	}
	//Add new Node at end of linked list
	public void addNode(char data)
	{
		LinkNode node = new LinkNode(data);
		if (this.head == null)
		{
			this.head = node;
		}
		else
		{
			// Append the node at last position
			this.tail.next = node;
		}
		this.tail = node;
	}
	// Display linked list element
	public void display()
	{
		if (this.head == null)
		{
			Console.Write("\n Empty linked list\n");
			return;
		}
		LinkNode temp = this.head;
		//iterating linked list elements
		while (temp != null)
		{
			Console.Write(" " + temp.data + " →");
			// Visit to next node
			temp = temp.next;
		}
		Console.Write(" NULL\n");
	}
	// Determine that given value is an vowel or not
	public Boolean isVowels(char value)
	{
		if (value == 'a' || value == 'e' || value == 'i' || value == 'o' || value == 'u' || value == 'A' || value == 'E' || value == 'I' || value == 'O' || value == 'U')
		{
			return true;
		}
		return false;
	}
	//  Move the vowels value at beginning position
	public void shiftVowels()
	{
		if (this.head == null)
		{
			Console.Write("\n Empty linked list\n");
			return;
		}
		// Define some auxiliary variable
		LinkNode auxiliary = this.head;
		LinkNode ordinary = this.head;
		char temp = ' ';
		// iterate linked list nodes
		// Using swap value , shift vowels at front of linked list
		while (auxiliary != null && ordinary != null)
		{
			if (isVowels(auxiliary.data) == true)
			{
				if (ordinary == auxiliary)
				{
					// When both node is same
					// Visit to next node
					ordinary = ordinary.next;
					auxiliary = auxiliary.next;
				}
				else if (isVowels(ordinary.data) == true)
				{
					// When ordinary value is an vowel
					ordinary = ordinary.next;
				}
				else
				{
					// Swap node value
					temp = ordinary.data;
					ordinary.data = auxiliary.data;
					auxiliary.data = temp;
					// Visit to next node
					auxiliary = auxiliary.next;
					ordinary = ordinary.next;
				}
			}
			else
			{
				// Visit to next node
				auxiliary = auxiliary.next;
			}
		}
	}
	public static void Main(String[] args)
	{
		SingleLL sll = new SingleLL();
		// Constructed linked list
		sll.addNode('E');
		sll.addNode('D');
		sll.addNode('U');
		sll.addNode('C');
		sll.addNode('A');
		sll.addNode('T');
		sll.addNode('I');
		sll.addNode('O');
		sll.addNode('N');
		Console.Write(" Before Shift \n");
		// E → D → U → C → A → T → I → O → N → NULL
		sll.display();
		sll.shiftVowels();
		Console.Write(" After Shift \n");
		// E → U → A → I → O → T → C → D → N → NULL
		sll.display();
	}
}

Output

 Before Shift
 E → D → U → C → A → T → I → O → N → NULL
 After Shift
 E → U → A → I → O → T → C → D → N → NULL
<?php
/*
  Php Program 
  Shift the vowels node at beginning of linked list
*/
// Linked list node
class LinkNode
{
	public $data;
	public $next;

	function __construct($data)
	{
		$this->data = $data;
		$this->next = null;
	}
}
class SingleLL
{
	public $head;
	public $tail;

	function __construct()
	{
		$this->head = null;
		$this->tail = null;
	}
	//Add new Node at end of linked list
	public	function addNode($data)
	{
		$node = new LinkNode($data);
		if ($this->head == null)
		{
			$this->head = $node;
		}
		else
		{
			// Append the node at last position
			$this->tail->next = $node;
		}
		$this->tail = $node;
	}
	// Display linked list element
	public	function display()
	{
		if ($this->head == null)
		{
			echo "\n Empty linked list\n";
			return;
		}
		$temp = $this->head;
		//iterating linked list elements
		while ($temp != null)
		{
			echo " ". $temp->data ." →";
			// Visit to next node
			$temp = $temp->next;
		}
		echo " NULL\n";
	}
	// Determine that given value is an vowel or not
	public	function isVowels($value)
	{
		if ($value == 'a' || $value == 'e' 
            || $value == 'i' || $value == 'o' 
            || $value == 'u' || $value == 'A' 
            || $value == 'E' || $value == 'I' 
            || $value == 'O' || $value == 'U')
		{
			return true;
		}
		return false;
	}
	//  Move the vowels value at beginning position
	public	function shiftVowels()
	{
		if ($this->head == null)
		{
			echo "\n Empty linked list\n";
			return;
		}
		// Define some auxiliary variable
		$auxiliary = $this->head;
		$ordinary = $this->head;
		$temp = ' ';
		// iterate linked list nodes
		// Using swap value , shift vowels at front of linked list
		while ($auxiliary != null && $ordinary != null)
		{
			if ($this->isVowels($auxiliary->data) == true)
			{
				if ($ordinary == $auxiliary)
				{
					// When both node is same
					// Visit to next node
					$ordinary = $ordinary->next;
					$auxiliary = $auxiliary->next;
				}
				else if ($this->isVowels($ordinary->data) == true)
				{
					// When ordinary value is an vowel
					$ordinary = $ordinary->next;
				}
				else
				{
					// Swap node value
					$temp = $ordinary->data;
					$ordinary->data = $auxiliary->data;
					$auxiliary->data = $temp;
					// Visit to next node
					$auxiliary = $auxiliary->next;
					$ordinary = $ordinary->next;
				}
			}
			else
			{
				// Visit to next node
				$auxiliary = $auxiliary->next;
			}
		}
	}
}

function main()
{
	$sll = new SingleLL();
	// Constructed linked list
	$sll->addNode('E');
	$sll->addNode('D');
	$sll->addNode('U');
	$sll->addNode('C');
	$sll->addNode('A');
	$sll->addNode('T');
	$sll->addNode('I');
	$sll->addNode('O');
	$sll->addNode('N');
	echo " Before Shift \n";
	// E → D → U → C → A → T → I → O → N → NULL
	$sll->display();
	$sll->shiftVowels();
	echo " After Shift \n";
	// E → U → A → I → O → T → C → D → N → NULL
	$sll->display();
}
main();

Output

 Before Shift
 E → D → U → C → A → T → I → O → N → NULL
 After Shift
 E → U → A → I → O → T → C → D → N → NULL
/*
  Node Js Program 
  Shift the vowels node at beginning of linked list
*/
// Linked list node
class LinkNode
{
	constructor(data)
	{
		this.data = data;
		this.next = null;
	}
}
class SingleLL
{
	constructor()
	{
		this.head = null;
		this.tail = null;
	}
	//Add new Node at end of linked list
	addNode(data)
	{
		var node = new LinkNode(data);
		if (this.head == null)
		{
			this.head = node;
		}
		else
		{
			// Append the node at last position
			this.tail.next = node;
		}
		this.tail = node;
	}
	// Display linked list element
	display()
	{
		if (this.head == null)
		{
			process.stdout.write("\n Empty linked list\n");
			return;
		}
		var temp = this.head;
		//iterating linked list elements
		while (temp != null)
		{
			process.stdout.write(" " + temp.data + " →");
			// Visit to next node
			temp = temp.next;
		}
		process.stdout.write(" NULL\n");
	}
	// Determine that given value is an vowel or not
	isVowels(value)
	{
		if (value == 'a' || value == 'e' 
            || value == 'i' || value == 'o' 
            || value == 'u' || value == 'A' 
            || value == 'E' || value == 'I' 
            || value == 'O' || value == 'U')
		{
			return true;
		}
		return false;
	}
	//  Move the vowels value at beginning position
	shiftVowels()
	{
		if (this.head == null)
		{
			process.stdout.write("\n Empty linked list\n");
			return;
		}
		// Define some auxiliary variable
		var auxiliary = this.head;
		var ordinary = this.head;
		var temp = ' ';
		// iterate linked list nodes
		// Using swap value , shift vowels at front of linked list
		while (auxiliary != null && ordinary != null)
		{
			if (this.isVowels(auxiliary.data) == true)
			{
				if (ordinary == auxiliary)
				{
					// When both node is same
					// Visit to next node
					ordinary = ordinary.next;
					auxiliary = auxiliary.next;
				}
				else if (this.isVowels(ordinary.data) == true)
				{
					// When ordinary value is an vowel
					ordinary = ordinary.next;
				}
				else
				{
					// Swap node value
					temp = ordinary.data;
					ordinary.data = auxiliary.data;
					auxiliary.data = temp;
					// Visit to next node
					auxiliary = auxiliary.next;
					ordinary = ordinary.next;
				}
			}
			else
			{
				// Visit to next node
				auxiliary = auxiliary.next;
			}
		}
	}
}

function main()
{
	var sll = new SingleLL();
	// Constructed linked list
	sll.addNode('E');
	sll.addNode('D');
	sll.addNode('U');
	sll.addNode('C');
	sll.addNode('A');
	sll.addNode('T');
	sll.addNode('I');
	sll.addNode('O');
	sll.addNode('N');
	process.stdout.write(" Before Shift \n");
	// E → D → U → C → A → T → I → O → N → NULL
	sll.display();
	sll.shiftVowels();
	process.stdout.write(" After Shift \n");
	// E → U → A → I → O → T → C → D → N → NULL
	sll.display();
}
main();

Output

 Before Shift
 E → D → U → C → A → T → I → O → N → NULL
 After Shift
 E → U → A → I → O → T → C → D → N → NULL
#   Python 3 Program 
#   Shift the vowels node at beginning of linked list

#  Linked list node
class LinkNode :
	
	def __init__(self, data) :
		self.data = data
		self.next = None
	

class SingleLL :
	
	def __init__(self) :
		self.head = None
		self.tail = None
	
	# Add new Node at end of linked list 
	def addNode(self, data) :
		node = LinkNode(data)
		if (self.head == None) :
			self.head = node
		else :
			#  Append the node at last position
			self.tail.next = node
		
		self.tail = node
	
	#  Display linked list element
	def display(self) :
		if (self.head == None) :
			print("\n Empty linked list")
			return
		
		temp = self.head
		# iterating linked list elements
		while (temp != None) :
			print("", temp.data ,"→", end = "")
			#  Visit to next node
			temp = temp.next
		
		print(" NULL")
	
	#  Determine that given value is an vowel or not
	def isVowels(self, value) :
		if (value == 'a'
			or value == 'e'
			or value == 'i'
			or value == 'o'
			or value == 'u'
			or value == 'A'
			or value == 'E'
			or value == 'I'
			or value == 'O'
			or value == 'U') :
			return True
		
		return False
	
	#   Move the vowels value at beginning position
	def shiftVowels(self) :
		if (self.head == None) :
			print("\n Empty linked list")
			return
		
		#  Define some auxiliary variable
		auxiliary = self.head
		ordinary = self.head
		temp = ' '
		#  iterate linked list nodes
		#  Using swap value , shift vowels at front of linked list
		while (auxiliary != None and ordinary != None) :
			if (self.isVowels(auxiliary.data) == True) :
				if (ordinary == auxiliary) :
					#  When both node is same
					#  Visit to next node
					ordinary = ordinary.next
					auxiliary = auxiliary.next
				
				elif(self.isVowels(ordinary.data) == True) :
					#  When ordinary value is an vowel
					ordinary = ordinary.next
				else :
					#  Swap node value
					temp = ordinary.data
					ordinary.data = auxiliary.data
					auxiliary.data = temp
					#  Visit to next node
					auxiliary = auxiliary.next
					ordinary = ordinary.next
				
			else :
				#  Visit to next node
				auxiliary = auxiliary.next
			
		
	

def main() :
	sll = SingleLL()
	#  Constructed linked list
	sll.addNode('E')
	sll.addNode('D')
	sll.addNode('U')
	sll.addNode('C')
	sll.addNode('A')
	sll.addNode('T')
	sll.addNode('I')
	sll.addNode('O')
	sll.addNode('N')
	print(" Before Shift ")
	#  E → D → U → C → A → T → I → O → N → NULL
	sll.display()
	sll.shiftVowels()
	print(" After Shift ")
	#  E → U → A → I → O → T → C → D → N → NULL
	sll.display()

if __name__ == "__main__": main()

Output

 Before Shift
 E → D → U → C → A → T → I → O → N → NULL
 After Shift
 E → U → A → I → O → T → C → D → N → NULL
#   Ruby Program 
#   Shift the vowels node at beginning of linked list

#  Linked list node
class LinkNode  
	# Define the accessor and reader of class LinkNode  
	attr_reader :data, :next
	attr_accessor :data, :next
 
	
	def initialize(data) 
		self.data = data
		self.next = nil
	end

end

class SingleLL  
	# Define the accessor and reader of class SingleLL  
	attr_reader :head, :tail
	attr_accessor :head, :tail
 
	
	def initialize() 
		self.head = nil
		self.tail = nil
	end

	# Add new Node at end of linked list 
	def addNode(data) 
		node = LinkNode.new(data)
		if (self.head == nil) 
			self.head = node
		else 
			#  Append the node at last position
			self.tail.next = node
		end

		self.tail = node
	end

	#  Display linked list element
	def display() 
		if (self.head == nil) 
			print("\n Empty linked list\n")
			return
		end

		temp = self.head
		# iterating linked list elements
		while (temp != nil) 
			print(" ", temp.data ," →")
			#  Visit to next node
			temp = temp.next
		end

		print(" NULL\n")
	end

	#  Determine that given value is an vowel or not
	def isVowels(value) 
		if (value == 'a' || value == 'e' || 
            value == 'i' || value == 'o' || 
            value == 'u' || value == 'A' || 
            value == 'E' || value == 'I' || 
            value == 'O' || value == 'U') 
			return true
		end

		return false
	end

	#   Move the vowels value at beginning position
	def shiftVowels() 
		if (self.head == nil) 
			print("\n Empty linked list\n")
			return
		end

		#  Define some auxiliary variable
		auxiliary = self.head
		ordinary = self.head
		temp = ' '
		#  iterate linked list nodes
		#  Using swap value , shift vowels at front of linked list
		while (auxiliary != nil && ordinary != nil) 
			if (self.isVowels(auxiliary.data) == true) 
				if (ordinary == auxiliary) 
					#  When both node is same
					#  Visit to next node
					ordinary = ordinary.next
					auxiliary = auxiliary.next
				elsif(self.isVowels(ordinary.data) == true) 
					#  When ordinary value is an vowel
					ordinary = ordinary.next
				else 
					#  Swap node value
					temp = ordinary.data
					ordinary.data = auxiliary.data
					auxiliary.data = temp
					#  Visit to next node
					auxiliary = auxiliary.next
					ordinary = ordinary.next
				end

			else 
				#  Visit to next node
				auxiliary = auxiliary.next
			end

		end

	end

end

def main() 
	sll = SingleLL.new()
	#  Constructed linked list
	sll.addNode('E')
	sll.addNode('D')
	sll.addNode('U')
	sll.addNode('C')
	sll.addNode('A')
	sll.addNode('T')
	sll.addNode('I')
	sll.addNode('O')
	sll.addNode('N')
	print(" Before Shift \n")
	#  E → D → U → C → A → T → I → O → N → NULL
	sll.display()
	sll.shiftVowels()
	print(" After Shift \n")
	#  E → U → A → I → O → T → C → D → N → NULL
	sll.display()
end

main()

Output

 Before Shift 
 E → D → U → C → A → T → I → O → N → NULL
 After Shift 
 E → U → A → I → O → T → C → D → N → NULL
/*
  Scala Program 
  Shift the vowels node at beginning of linked list
*/
// Linked list node
class LinkNode(var data: Character , var next: LinkNode)
{
	def this(data: Char)
	{
		this(data, null);
	}
}
class SingleLL(var head: LinkNode , var tail: LinkNode)
{
	def this()
	{
		this(null, null);
	}
	//Add new Node at end of linked list
	def addNode(data: Char): Unit = {
		var node: LinkNode = new LinkNode(data);
		if (this.head == null)
		{
			this.head = node;
		}
		else
		{
			// Append the node at last position
			this.tail.next = node;
		}
		this.tail = node;
	}
	// Display linked list element
	def display(): Unit = {
		if (this.head == null)
		{
			print("\n Empty linked list\n");
			return;
		}
		var temp: LinkNode = this.head;
		//iterating linked list elements
		while (temp != null)
		{
			print(" " + temp.data + " →");
			// Visit to next node
			temp = temp.next;
		}
		print(" NULL\n");
	}
	// Determine that given value is an vowel or not
	def isVowels(value: Char): Boolean = {
		if (value == 'a' || value == 'e' 
             || value == 'i' || value == 'o' 
             || value == 'u' || value == 'A' 
             || value == 'E' || value == 'I' 
             || value == 'O' || value == 'U')
		{
			return true;
		}
		return false;
	}
	//  Move the vowels value at beginning position
	def shiftVowels(): Unit = {
		if (this.head == null)
		{
			print("\n Empty linked list\n");
			return;
		}
		// Define some auxiliary variable
		var auxiliary: LinkNode = this.head;
		var ordinary: LinkNode = this.head;
		var temp: Char = ' ';
		// iterate linked list nodes
		// Using swap value , shift vowels at front of linked list
		while (auxiliary != null && ordinary != null)
		{
			if (this.isVowels(auxiliary.data) == true)
			{
				if (ordinary == auxiliary)
				{
					// When both node is same
					// Visit to next node
					ordinary = ordinary.next;
					auxiliary = auxiliary.next;
				}
				else if (this.isVowels(ordinary.data) == true)
				{
					// When ordinary value is an vowel
					ordinary = ordinary.next;
				}
				else
				{
					// Swap node value
					temp = ordinary.data;
					ordinary.data = auxiliary.data;
					auxiliary.data = temp;
					// Visit to next node
					auxiliary = auxiliary.next;
					ordinary = ordinary.next;
				}
			}
			else
			{
				// Visit to next node
				auxiliary = auxiliary.next;
			}
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var sll: SingleLL = new SingleLL();
		// Constructed linked list
		sll.addNode('E');
		sll.addNode('D');
		sll.addNode('U');
		sll.addNode('C');
		sll.addNode('A');
		sll.addNode('T');
		sll.addNode('I');
		sll.addNode('O');
		sll.addNode('N');
		print(" Before Shift \n");
		// E → D → U → C → A → T → I → O → N → NULL
		sll.display();
		sll.shiftVowels();
		print(" After Shift \n");
		// E → U → A → I → O → T → C → D → N → NULL
		sll.display();
	}
}

Output

 Before Shift
 E → D → U → C → A → T → I → O → N → NULL
 After Shift
 E → U → A → I → O → T → C → D → N → NULL
/*
  Swift 4 Program 
  Shift the vowels node at beginning of linked list
*/
// Linked list node
class LinkNode
{
	var data: Character;
	var next: LinkNode? ;
	init(_ data: Character)
	{
		self.data = data;
		self.next = nil;
	}
}
class SingleLL
{
	var head: LinkNode? ;
	var tail: LinkNode? ;
	init()
	{
		self.head = nil;
		self.tail = nil;
	}
	//Add new Node at end of linked list
	func addNode(_ data: Character)
	{
		let node: LinkNode? = LinkNode(data);
		if (self.head == nil)
		{
			self.head = node;
		}
		else
		{
			// Append the node at last position
			self.tail!.next = node;
		}
		self.tail = node;
	}
	// Display linked list element
	func display()
	{
		if (self.head == nil)
		{
			print("\n Empty linked list");
			return;
		}
		var temp: LinkNode? = self.head;
		//iterating linked list elements
		while (temp  != nil)
		{
			print("", temp!.data ,"→", terminator: "");
			// Visit to next node
			temp = temp!.next;
		}
		print(" NULL");
	}
	// Determine that given value is an vowel or not
	func isVowels(_ value: Character)->Bool
	{
		if (value == "a" || value == "e" || 
            value == "i" || value == "o" || 
            value == "u" || value == "A" || 
            value == "E" || value == "I" || 
            value == "O" || value == "U")
		{
			return true;
		}
		return false;
	}
	//  Move the vowels value at beginning position
	func shiftVowels()
	{
		if (self.head == nil)
		{
			print("\n Empty linked list");
			return;
		}
		// Define some auxiliary variable
		var auxiliary: LinkNode? = self.head;
		var ordinary: LinkNode? = self.head;
		var temp: Character = " ";
		// iterate linked list nodes
		// Using swap value , shift vowels at front of linked list
		while (auxiliary  != nil && ordinary  != nil)
		{
			if (self.isVowels(auxiliary!.data) == true)
			{
				if (ordinary === auxiliary)
				{
					// When both node is same
					// Visit to next node
					ordinary = ordinary!.next;
					auxiliary = auxiliary!.next;
				}
				else if (self.isVowels(ordinary!.data) == true)
				{
					// When ordinary value is an vowel
					ordinary = ordinary!.next;
				}
				else
				{
					// Swap node value
					temp = ordinary!.data;
					ordinary!.data = auxiliary!.data;
					auxiliary!.data = temp;
					// Visit to next node
					auxiliary = auxiliary!.next;
					ordinary = ordinary!.next;
				}
			}
			else
			{
				// Visit to next node
				auxiliary = auxiliary!.next;
			}
		}
	}
}
func main()
{
	let sll: SingleLL = SingleLL();
	// Constructed linked list
	sll.addNode("E");
	sll.addNode("D");
	sll.addNode("U");
	sll.addNode("C");
	sll.addNode("A");
	sll.addNode("T");
	sll.addNode("I");
	sll.addNode("O");
	sll.addNode("N");
	print(" Before Shift ");
	// E → D → U → C → A → T → I → O → N → NULL
	sll.display();
	sll.shiftVowels();
	print(" After Shift ");
	// E → U → A → I → O → T → C → D → N → NULL
	sll.display();
}
main();

Output

 Before Shift
 E → D → U → C → A → T → I → O → N → NULL
 After Shift
 E → U → A → I → O → T → C → D → N → NULL
/*
  Kotlin Program 
  Shift the vowels node at beginning of linked list
*/
// Linked list node
class LinkNode
{
	var data: Char;
	var next: LinkNode ? ;
	constructor(data: Char)
	{
		this.data = data;
		this.next = null;
	}
}
class SingleLL
{
	var head: LinkNode ? ;
	var tail: LinkNode ? ;
	constructor()
	{
		this.head = null;
		this.tail = null;
	}
	//Add new Node at end of linked list
	fun addNode(data: Char): Unit
	{
		var node: LinkNode = LinkNode(data);
		if (this.head == null)
		{
			this.head = node;
		}
		else
		{
			// Append the node at last position
			this.tail?.next = node;
		}
		this.tail = node;
	}
	// Display linked list element
	fun display(): Unit
	{
		if (this.head == null)
		{
			print("\n Empty linked list\n");
			return;
		}
		var temp: LinkNode ? = this.head;
		//iterating linked list elements
		while (temp != null)
		{
			print(" " + temp.data + " →");
			// Visit to next node
			temp = temp.next;
		}
		print(" NULL\n");
	}
	// Determine that given value is an vowel or not
	fun isVowels(value: Char): Boolean
	{
		if (value == 'a' || value == 'e' || 
            value == 'i' || value == 'o' || 
            value == 'u' || value == 'A' || 
            value == 'E' || value == 'I' || 
            value == 'O' || value == 'U')
		{
			return true;
		}
		return false;
	}
	//  Move the vowels value at beginning position
	fun shiftVowels(): Unit
	{
		if (this.head == null)
		{
			print("\n Empty linked list\n");
			return;
		}
		// Define some auxiliary variable
		var auxiliary: LinkNode ? = this.head;
		var ordinary: LinkNode ? = this.head;
		var temp: Char ;
		// iterate linked list nodes
		// Using swap value , shift vowels at front of linked list
		while (auxiliary != null && ordinary != null)
		{
			if (this.isVowels(auxiliary.data) == true)
			{
				if (ordinary == auxiliary)
				{
					// When both node is same
					// Visit to next node
					ordinary = ordinary.next;
					auxiliary = auxiliary.next;
				}
				else if (this.isVowels(ordinary.data) == true)
				{
					// When ordinary value is an vowel
					ordinary = ordinary.next;
				}
				else
				{
					// Swap node value
					temp = ordinary.data;
					ordinary.data = auxiliary.data;
					auxiliary.data = temp;
					// Visit to next node
					auxiliary = auxiliary.next;
					ordinary = ordinary.next;
				}
			}
			else
			{
				// Visit to next node
				auxiliary = auxiliary.next;
			}
		}
	}
}
fun main(args: Array <String> ): Unit
{
	var sll: SingleLL = SingleLL();
	// Constructed linked list
	sll.addNode('E');
	sll.addNode('D');
	sll.addNode('U');
	sll.addNode('C');
	sll.addNode('A');
	sll.addNode('T');
	sll.addNode('I');
	sll.addNode('O');
	sll.addNode('N');
	print(" Before Shift \n");
	// E → D → U → C → A → T → I → O → N → NULL
	sll.display();
	sll.shiftVowels();
	print(" After Shift \n");
	// E → U → A → I → O → T → C → D → N → NULL
	sll.display();
}

Output

 Before Shift
 E → D → U → C → A → T → I → O → N → NULL
 After Shift
 E → U → A → I → O → T → C → D → N → NULL

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







© 2021, kalkicode.com, All rights reserved