Bidirectional bubble sort
Here given code implementation process.
// C Program
// Bidirectional bubble sort
#include <stdio.h>
//Display elements of given sequence
void display(int sequence[], int size)
{
for (int i = 0; i < size; ++i)
{
printf(" %d", sequence[i]);
}
printf("\n");
}
// Swap array elements by given location
void swap(int sequence[], int a, int b)
{
int temp = sequence[a];
sequence[a] = sequence[b];
sequence[b] = temp;
}
// Implementation of bidirectional bubble sort
void bubbleSort(int sequence[], int size)
{
// Get first location of sequence
int left = 0;
// Get the last location of sequence
int right = size - 1;
int position = 0;
while (left < right)
{
for (position = left; position < right; ++position)
{
if (sequence[position] > sequence[position + 1])
{
//Swap element
swap(sequence, position, position + 1);
}
}
// Reduce higher position
right--;
for (position = right; position > left; --position)
{
if (sequence[position] < sequence[position - 1])
{
swap(sequence, position, position - 1);
}
}
// Increase lower position
left++;
}
}
int main()
{
// Given input arrays
int s1[] = {
6 , 2 , 8 , 5 , 2 , 4 , 1 , 17 , 21 , 12 , 1 , 2 , 9
};
int s2[] = {
7 , 2 , 5 , 0 , 9 , 1 , 0 , 3 , 6 , 2 , 7 , 3 , 1
};
// Test case A
int size = sizeof(s1) / sizeof(s1[0]);
printf(" Before Sort \n");
display(s1, size);
printf(" After Sort\n");
bubbleSort(s1, size);
display(s1, size);
// Test case B
size = sizeof(s2) / sizeof(s2[0]);
printf("\n Before Sort \n");
display(s2, size);
bubbleSort(s2, size);
printf(" After Sort \n");
display(s2, size);
return 0;
}
Output
Before Sort
6 2 8 5 2 4 1 17 21 12 1 2 9
After Sort
1 1 2 2 2 4 5 6 8 9 12 17 21
Before Sort
7 2 5 0 9 1 0 3 6 2 7 3 1
After Sort
0 0 1 1 2 2 3 3 5 6 7 7 9
/*
Java program
Bidirectional bubble sort
*/
public class Sorting
{
// Display elements of given sequence
public void display(int[] sequence, int size)
{
for (int i = 0; i < size; ++i)
{
System.out.print(" " + sequence[i] );
}
System.out.print("\n");
}
// Swap array elements by given location
public void swap(int[] sequence, int a, int b)
{
int temp = sequence[a];
sequence[a] = sequence[b];
sequence[b] = temp;
}
// Implementation of bidirectional bubble sort
public void bubbleSort(int[] sequence, int size)
{
// Get first location of sequence
int left = 0;
// Get the last location of sequence
int right = size - 1;
int position = 0;
while (left < right)
{
for (position = left; position < right; ++position)
{
if (sequence[position] > sequence[position + 1])
{
//Swap element
swap(sequence, position, position + 1);
}
}
// Reduce higher position
right--;
for (position = right; position > left; --position)
{
if (sequence[position] < sequence[position - 1])
{
swap(sequence, position, position - 1);
}
}
// Increase lower position
left++;
}
}
public static void main(String[] args)
{
Sorting task = new Sorting();
// Define array of positive integer elements
int[] s1 = {
6 , 2 , 8 , 5 , 2 , 4 , 1 , 17 , 21 , 12 , 1 , 2 , 9
};
int[] s2 = {
7 , 2 , 5 , 0 , 9 , 1 , 0 , 3 , 6 , 2 , 7 , 3 , 1
};
// Test case A
int size = s1.length;
System.out.print(" Before Sort \n");
task.display(s1, size);
System.out.print(" After Sort \n");
task.bubbleSort(s1, size);
task.display(s1, size);
// Test case B
size = s2.length;
System.out.print("\n Before Sort \n");
task.display(s2, size);
task.bubbleSort(s2, size);
System.out.print(" After Sort \n");
task.display(s2, size);
}
}
Output
Before Sort
6 2 8 5 2 4 1 17 21 12 1 2 9
After Sort
1 1 2 2 2 4 5 6 8 9 12 17 21
Before Sort
7 2 5 0 9 1 0 3 6 2 7 3 1
After Sort
0 0 1 1 2 2 3 3 5 6 7 7 9
// Include header file
#include <iostream>
using namespace std;
/*
C++ program
Bidirectional bubble sort
*/
class Sorting
{
public:
// Display elements of given sequence
void display(int sequence[], int size)
{
for (int i = 0; i < size; ++i)
{
cout << " " << sequence[i];
}
cout << "\n";
}
// Swap array elements by given location
void swap(int sequence[], int a, int b)
{
int temp = sequence[a];
sequence[a] = sequence[b];
sequence[b] = temp;
}
// Implementation of bidirectional bubble sort
void bubbleSort(int sequence[], int size)
{
// Get first location of sequence
int left = 0;
// Get the last location of sequence
int right = size - 1;
int position = 0;
while (left < right)
{
// Set higher value
for (position = left; position < right; ++position)
{
if (sequence[position] > sequence[position + 1])
{
//Swap element
this->swap(sequence, position, position + 1);
}
}
// Reduce higher position
right--;
// Set lower value
for (position = right; position > left; --position)
{
if (sequence[position] < sequence[position - 1])
{
this->swap(sequence, position, position - 1);
}
}
// Increase lower position
left++;
}
}
};
int main()
{
Sorting task = Sorting();
// Define array of positive integer elements
int s1[] = {
6 , 2 , 8 , 5 , 2 , 4 , 1 , 17 , 21 , 12 , 1 , 2 , 9
};
int s2[] = {
7 , 2 , 5 , 0 , 9 , 1 , 0 , 3 , 6 , 2 , 7 , 3 , 1
};
// Test case A
int size = sizeof(s1) / sizeof(s1[0]);
cout << " Before Sort \n";
task.display(s1, size);
cout << " After Sort \n";
task.bubbleSort(s1, size);
task.display(s1, size);
// Test case B
size = sizeof(s2) / sizeof(s2[0]);
cout << "\n Before Sort \n";
task.display(s2, size);
task.bubbleSort(s2, size);
cout << " After Sort \n";
task.display(s2, size);
return 0;
}
Output
Before Sort
6 2 8 5 2 4 1 17 21 12 1 2 9
After Sort
1 1 2 2 2 4 5 6 8 9 12 17 21
Before Sort
7 2 5 0 9 1 0 3 6 2 7 3 1
After Sort
0 0 1 1 2 2 3 3 5 6 7 7 9
// Include namespace system
using System;
/*
C# program
Bidirectional bubble sort
*/
public class Sorting
{
// Display elements of given sequence
public void display(int[] sequence, int size)
{
for (int i = 0; i < size; ++i)
{
Console.Write(" " + sequence[i]);
}
Console.Write("\n");
}
// Swap array elements by given location
public void swap(int[] sequence, int a, int b)
{
int temp = sequence[a];
sequence[a] = sequence[b];
sequence[b] = temp;
}
// Implementation of bidirectional bubble sort
public void bubbleSort(int[] sequence, int size)
{
// Get first location of sequence
int left = 0;
// Get the last location of sequence
int right = size - 1;
int position = 0;
while (left < right)
{
// Set higher value
for (position = left; position < right; ++position)
{
if (sequence[position] > sequence[position + 1])
{
//Swap element
swap(sequence, position, position + 1);
}
}
// Reduce higher position
right--;
// Set lower value
for (position = right; position > left; --position)
{
if (sequence[position] < sequence[position - 1])
{
swap(sequence, position, position - 1);
}
}
// Increase lower position
left++;
}
}
public static void Main(String[] args)
{
Sorting task = new Sorting();
// Define array of positive integer elements
int[] s1 = {
6 , 2 , 8 , 5 , 2 , 4 , 1 , 17 , 21 , 12 , 1 , 2 , 9
};
int[] s2 = {
7 , 2 , 5 , 0 , 9 , 1 , 0 , 3 , 6 , 2 , 7 , 3 , 1
};
// Test case A
int size = s1.Length;
Console.Write(" Before Sort \n");
task.display(s1, size);
Console.Write(" After Sort \n");
task.bubbleSort(s1, size);
task.display(s1, size);
// Test case B
size = s2.Length;
Console.Write("\n Before Sort \n");
task.display(s2, size);
task.bubbleSort(s2, size);
Console.Write(" After Sort \n");
task.display(s2, size);
}
}
Output
Before Sort
6 2 8 5 2 4 1 17 21 12 1 2 9
After Sort
1 1 2 2 2 4 5 6 8 9 12 17 21
Before Sort
7 2 5 0 9 1 0 3 6 2 7 3 1
After Sort
0 0 1 1 2 2 3 3 5 6 7 7 9
<?php
/*
Php program
Bidirectional bubble sort
*/
class Sorting
{
// Display elements of given sequence
public function display( & $sequence, $size)
{
for ($i = 0; $i < $size; ++$i)
{
echo " ". $sequence[$i];
}
echo "\n";
}
// Swap array elements by given location
public function swap( & $sequence, $a, $b)
{
$temp = $sequence[$a];
$sequence[$a] = $sequence[$b];
$sequence[$b] = $temp;
}
// Implementation of bidirectional bubble sort
public function bubbleSort( & $sequence, $size)
{
// Get first location of sequence
$left = 0;
// Get the last location of sequence
$right = $size - 1;
$position = 0;
while ($left < $right)
{
// Set higher value
for ($position = $left; $position < $right; ++$position)
{
if ($sequence[$position] > $sequence[$position + 1])
{
//Swap element
$this->swap($sequence, $position, $position + 1);
}
}
// Reduce higher position
$right--;
// Set lower value
for ($position = $right; $position > $left; --$position)
{
if ($sequence[$position] < $sequence[$position - 1])
{
$this->swap($sequence, $position, $position - 1);
}
}
// Increase lower position
$left++;
}
}
}
function main()
{
$task = new Sorting();
// Define array of positive integer elements
$s1 = array(6, 2, 8, 5, 2, 4, 1, 17, 21, 12, 1, 2, 9);
$s2 = array(7, 2, 5, 0, 9, 1, 0, 3, 6, 2, 7, 3, 1);
// Test case A
$size = count($s1);
echo " Before Sort \n";
$task->display($s1, $size);
echo " After Sort \n";
$task->bubbleSort($s1, $size);
$task->display($s1, $size);
// Test case B
$size = count($s2);
echo "\n Before Sort \n";
$task->display($s2, $size);
$task->bubbleSort($s2, $size);
echo " After Sort \n";
$task->display($s2, $size);
}
main();
Output
Before Sort
6 2 8 5 2 4 1 17 21 12 1 2 9
After Sort
1 1 2 2 2 4 5 6 8 9 12 17 21
Before Sort
7 2 5 0 9 1 0 3 6 2 7 3 1
After Sort
0 0 1 1 2 2 3 3 5 6 7 7 9
/*
Node Js program
Bidirectional bubble sort
*/
class Sorting
{
// Display elements of given sequence
display(sequence, size)
{
for (var i = 0; i < size; ++i)
{
process.stdout.write(" " + sequence[i]);
}
process.stdout.write("\n");
}
// Swap array elements by given location
swap(sequence, a, b)
{
var temp = sequence[a];
sequence[a] = sequence[b];
sequence[b] = temp;
}
// Implementation of bidirectional bubble sort
bubbleSort(sequence, size)
{
// Get first location of sequence
var left = 0;
// Get the last location of sequence
var right = size - 1;
var position = 0;
while (left < right)
{
// Set higher value
for (position = left; position < right; ++position)
{
if (sequence[position] > sequence[position + 1])
{
//Swap element
this.swap(sequence, position, position + 1);
}
}
// Reduce higher position
right--;
// Set lower value
for (position = right; position > left; --position)
{
if (sequence[position] < sequence[position - 1])
{
this.swap(sequence, position, position - 1);
}
}
// Increase lower position
left++;
}
}
}
function main()
{
var task = new Sorting();
// Define array of positive integer elements
var s1 = [6, 2, 8, 5, 2, 4, 1, 17, 21, 12, 1, 2, 9];
var s2 = [7, 2, 5, 0, 9, 1, 0, 3, 6, 2, 7, 3, 1];
// Test case A
var size = s1.length;
process.stdout.write(" Before Sort \n");
task.display(s1, size);
process.stdout.write(" After Sort \n");
task.bubbleSort(s1, size);
task.display(s1, size);
// Test case B
size = s2.length;
process.stdout.write("\n Before Sort \n");
task.display(s2, size);
task.bubbleSort(s2, size);
process.stdout.write(" After Sort \n");
task.display(s2, size);
}
main();
Output
Before Sort
6 2 8 5 2 4 1 17 21 12 1 2 9
After Sort
1 1 2 2 2 4 5 6 8 9 12 17 21
Before Sort
7 2 5 0 9 1 0 3 6 2 7 3 1
After Sort
0 0 1 1 2 2 3 3 5 6 7 7 9
# Python 3 program
# Bidirectional bubble sort
class Sorting :
# Display elements of given sequence
def display(self, sequence, size) :
i = 0
while (i < size) :
print(" ", sequence[i], end = "")
i += 1
print(end = "\n")
# Swap array elements by given location
def swap(self, sequence, a, b) :
temp = sequence[a]
sequence[a] = sequence[b]
sequence[b] = temp
# Implementation of bidirectional bubble sort
def bubbleSort(self, sequence, size) :
# Get first location of sequence
left = 0
# Get the last location of sequence
right = size - 1
position = 0
while (left < right) :
# Set higher value
position = left
while (position < right) :
if (sequence[position] > sequence[position + 1]) :
# Swap element
self.swap(sequence, position, position + 1)
position += 1
# Reduce higher position
right -= 1
# Set lower value
position = right
while (position > left) :
if (sequence[position] < sequence[position - 1]) :
self.swap(sequence, position, position - 1)
position -= 1
# Increase lower position
left += 1
def main() :
task = Sorting()
# Define array of positive integer elements
s1 = [6, 2, 8, 5, 2, 4, 1, 17, 21, 12, 1, 2, 9]
s2 = [7, 2, 5, 0, 9, 1, 0, 3, 6, 2, 7, 3, 1]
# Test case A
size = len(s1)
print(" Before Sort ")
task.display(s1, size)
print(" After Sort ")
task.bubbleSort(s1, size)
task.display(s1, size)
# Test case B
size = len(s2)
print("\n Before Sort ")
task.display(s2, size)
task.bubbleSort(s2, size)
print(" After Sort ")
task.display(s2, size)
if __name__ == "__main__": main()
Output
Before Sort
6 2 8 5 2 4 1 17 21 12 1 2 9
After Sort
1 1 2 2 2 4 5 6 8 9 12 17 21
Before Sort
7 2 5 0 9 1 0 3 6 2 7 3 1
After Sort
0 0 1 1 2 2 3 3 5 6 7 7 9
# Ruby program
# Bidirectional bubble sort
class Sorting
# Display elements of given sequence
def display(sequence, size)
i = 0
while (i < size)
print(" ", sequence[i])
i += 1
end
print("\n")
end
# Swap array elements by given location
def swap(sequence, a, b)
temp = sequence[a]
sequence[a] = sequence[b]
sequence[b] = temp
end
# Implementation of bidirectional bubble sort
def bubbleSort(sequence, size)
# Get first location of sequence
left = 0
# Get the last location of sequence
right = size - 1
position = 0
while (left < right)
# Set higher value
position = left
while (position < right)
if (sequence[position] > sequence[position + 1])
# Swap element
self.swap(sequence, position, position + 1)
end
position += 1
end
# Reduce higher position
right -= 1
# Set lower value
position = right
while (position > left)
if (sequence[position] < sequence[position - 1])
self.swap(sequence, position, position - 1)
end
position -= 1
end
# Increase lower position
left += 1
end
end
end
def main()
task = Sorting.new()
# Define array of positive integer elements
s1 = [6, 2, 8, 5, 2, 4, 1, 17, 21, 12, 1, 2, 9]
s2 = [7, 2, 5, 0, 9, 1, 0, 3, 6, 2, 7, 3, 1]
# Test case A
size = s1.length
print(" Before Sort \n")
task.display(s1, size)
print(" After Sort \n")
task.bubbleSort(s1, size)
task.display(s1, size)
# Test case B
size = s2.length
print("\n Before Sort \n")
task.display(s2, size)
task.bubbleSort(s2, size)
print(" After Sort \n")
task.display(s2, size)
end
main()
Output
Before Sort
6 2 8 5 2 4 1 17 21 12 1 2 9
After Sort
1 1 2 2 2 4 5 6 8 9 12 17 21
Before Sort
7 2 5 0 9 1 0 3 6 2 7 3 1
After Sort
0 0 1 1 2 2 3 3 5 6 7 7 9
/*
Scala program
Bidirectional bubble sort
*/
class Sorting
{
// Display elements of given sequence
def display(sequence: Array[Int], size: Int): Unit = {
var i: Int = 0;
while (i < size)
{
print(" " + sequence(i));
i += 1;
}
print("\n");
}
// Swap array elements by given location
def swap(sequence: Array[Int], a: Int, b: Int): Unit = {
var temp: Int = sequence(a);
sequence(a) = sequence(b);
sequence(b) = temp;
}
// Implementation of bidirectional bubble sort
def bubbleSort(sequence: Array[Int], size: Int): Unit = {
// Get first location of sequence
var left: Int = 0;
// Get the last location of sequence
var right: Int = size - 1;
var position: Int = 0;
while (left < right)
{
// Set higher value
position = left;
while (position < right)
{
if (sequence(position) > sequence(position + 1))
{
//Swap element
this.swap(sequence, position, position + 1);
}
position += 1;
}
// Reduce higher position
right -= 1;
// Set lower value
position = right;
while (position > left)
{
if (sequence(position) < sequence(position - 1))
{
this.swap(sequence, position, position - 1);
}
position -= 1;
}
// Increase lower position
left += 1;
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var task: Sorting = new Sorting();
// Define array of positive integer elements
var s1: Array[Int] = Array(6, 2, 8, 5, 2, 4, 1, 17, 21, 12, 1, 2, 9);
var s2: Array[Int] = Array(7, 2, 5, 0, 9, 1, 0, 3, 6, 2, 7, 3, 1);
// Test case A
var size: Int = s1.length;
print(" Before Sort \n");
task.display(s1, size);
print(" After Sort \n");
task.bubbleSort(s1, size);
task.display(s1, size);
// Test case B
size = s2.length;
print("\n Before Sort \n");
task.display(s2, size);
task.bubbleSort(s2, size);
print(" After Sort \n");
task.display(s2, size);
}
}
Output
Before Sort
6 2 8 5 2 4 1 17 21 12 1 2 9
After Sort
1 1 2 2 2 4 5 6 8 9 12 17 21
Before Sort
7 2 5 0 9 1 0 3 6 2 7 3 1
After Sort
0 0 1 1 2 2 3 3 5 6 7 7 9
/*
Swift 4 program
Bidirectional bubble sort
*/
class Sorting
{
// Display elements of given sequence
func display(_ sequence: [Int], _ size: Int)
{
var i: Int = 0;
while (i < size)
{
print(" ", sequence[i], terminator: "");
i += 1;
}
print(terminator: "\n");
}
// Swap array elements by given location
func swap(_ sequence: inout[Int], _ a: Int, _ b: Int)
{
let temp: Int = sequence[a];
sequence[a] = sequence[b];
sequence[b] = temp;
}
// Implementation of bidirectional bubble sort
func bubbleSort(_ sequence: inout[Int], _ size: Int)
{
// Get first location of sequence
var left: Int = 0;
// Get the last location of sequence
var right: Int = size - 1;
var position: Int = 0;
while (left < right)
{
// Set higher value
position = left;
while (position < right)
{
if (sequence[position] > sequence[position + 1])
{
//Swap element
self.swap(&sequence, position, position + 1);
}
position += 1;
}
// Reduce higher position
right -= 1;
// Set lower value
position = right;
while (position > left)
{
if (sequence[position] < sequence[position - 1])
{
self.swap(&sequence, position, position - 1);
}
position -= 1;
}
// Increase lower position
left += 1;
}
}
}
func main()
{
let task: Sorting = Sorting();
// Define array of positive integer elements
var s1: [Int] = [6, 2, 8, 5, 2, 4, 1, 17, 21, 12, 1, 2, 9];
var s2: [Int] = [7, 2, 5, 0, 9, 1, 0, 3, 6, 2, 7, 3, 1];
// Test case A
var size: Int = s1.count;
print(" Before Sort ");
task.display(s1, size);
print(" After Sort ");
task.bubbleSort(&s1, size);
task.display(s1, size);
// Test case B
size = s2.count;
print("\n Before Sort ");
task.display(s2, size);
task.bubbleSort(&s2, size);
print(" After Sort ");
task.display(s2, size);
}
main();
Output
Before Sort
6 2 8 5 2 4 1 17 21 12 1 2 9
After Sort
1 1 2 2 2 4 5 6 8 9 12 17 21
Before Sort
7 2 5 0 9 1 0 3 6 2 7 3 1
After Sort
0 0 1 1 2 2 3 3 5 6 7 7 9
/*
Kotlin program
Bidirectional bubble sort
*/
class Sorting
{
// Display elements of given sequence
fun display(sequence: Array<Int>, size: Int): Unit
{
var i: Int = 0;
while (i<size)
{
print(" " + sequence[i]);
i += 1;
}
print("\n");
}
// Swap array elements by given location
fun swap(sequence: Array<Int>, a: Int, b: Int): Unit
{
var temp: Int = sequence[a];
sequence[a] = sequence[b];
sequence[b] = temp;
}
// Implementation of bidirectional bubble sort
fun bubbleSort(sequence: Array<Int>, size: Int): Unit
{
// Get first location of sequence
var left: Int = 0;
// Get the last location of sequence
var right: Int = size - 1;
var position: Int ;
while (left < right)
{
// Set higher value
position = left;
while (position < right)
{
if (sequence[position] > sequence[position + 1])
{
//Swap element
this.swap(sequence, position, position + 1);
}
position += 1;
}
// Reduce higher position
right -= 1;
// Set lower value
position = right;
while (position > left)
{
if (sequence[position]<sequence[position - 1])
{
this.swap(sequence, position, position - 1);
}
position -= 1;
}
// Increase lower position
left += 1;
}
}
}
fun main(args: Array<String>): Unit
{
var task: Sorting = Sorting();
// Define array of positive integer elements
var s1: Array<Int> = arrayOf(6, 2, 8, 5, 2, 4, 1, 17, 21, 12, 1, 2, 9);
var s2: Array<Int> = arrayOf(7, 2, 5, 0, 9, 1, 0, 3, 6, 2, 7, 3, 1);
// Test case A
var size: Int = s1.count();
print(" Before Sort \n");
task.display(s1, size);
print(" After Sort \n");
task.bubbleSort(s1, size);
task.display(s1, size);
// Test case B
size = s2.count();
print("\n Before Sort \n");
task.display(s2, size);
task.bubbleSort(s2, size);
print(" After Sort \n");
task.display(s2, size);
}
Output
Before Sort
6 2 8 5 2 4 1 17 21 12 1 2 9
After Sort
1 1 2 2 2 4 5 6 8 9 12 17 21
Before Sort
7 2 5 0 9 1 0 3 6 2 7 3 1
After Sort
0 0 1 1 2 2 3 3 5 6 7 7 9
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