Difference between Comb Sort and Shell Sort
Last Updated :
10 Apr, 2023
Comb Sort:
The pre-processing stage of Comb Sort is similar to the Shell Sort method. Comb sort is a significant advancement over bubble sort, and it is accomplished by pre-processing the data by integrating the comparison of the components’ step positions that are far apart from one another. It is a kind of comparison sorting algorithm.
- The major mechanism included in this algorithm is each pair of adjacent elements is matched up and swapped if those elements are not arranged in an order.
- This concept of sorting is called comb sort.
Decision tree for Comb Sort:
In the below decision tree “Y” indicates “yes”, “N” indicates “No” and “IMP” indicates “Impossible”.
Decision Tree for comb sort
Explanation: The above figure is implemented by applying the comb sort to make a decision tree.
- Decision trees are carrying the l with “Y” and “N” which indicates “yes” and “no” respectively.
- The major mechanism included in this algorithm is each pair of adjacent elements is matched up and swapped if those elements are not arranged in an order.
- Leaves are the final value determined at the end of the tree which is notified with “[]” square brackets.
- The above decision tree contains “24” leaves, which can be calculated by “n!” number of elements determined is “4”. Find the factorial value of four. This contains 24 leaves.
- “IMP” indicates the impossible state, there is no leaf implemented after that.
Hence, this is the implementation decision tree by applying the comb sort.
C++
#include<bits/stdc++.h>
using namespace std;
void combSort( int arr[], int N){
for ( int turn = 0; turn < N - 1; turn++) {
for ( int j = 0; j < N - 1 - turn; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
void printArr( int arr[], int N){
for ( int i = 0; i < N; i++) {
cout << arr[i] << " " ;
}
}
int main() {
int arr[] = { 5, 4, 1, 3, 2 };
int N = 5;
combSort(arr, N);
printArr(arr, N);
return 0;
}
|
Java
import java.util.*;
public class BasicSorting {
public static void combSort( int arr[])
{
for ( int turn = 0 ; turn < arr.length - 1 ; turn++) {
for ( int j = 0 ; j < arr.length - 1 - turn;
j++) {
if (arr[j] > arr[j + 1 ]) {
int temp = arr[j];
arr[j] = arr[j + 1 ];
arr[j + 1 ] = temp;
}
}
}
}
public static void printArr( int arr[])
{
for ( int i = 0 ; i < arr.length; i++) {
System.out.print(arr[i] + " " );
}
System.out.println();
}
public static void main(String args[])
{
int arr[] = { 5 , 4 , 1 , 3 , 2 };
combSort(arr);
printArr(arr);
}
}
|
Python3
def comb_sort(arr):
for turn in range ( len (arr) - 1 ):
for j in range ( len (arr) - 1 - turn):
if arr[j] > arr[j + 1 ]:
temp = arr[j]
arr[j] = arr[j + 1 ]
arr[j + 1 ] = temp
def print_arr(arr):
for i in arr:
print (i, end = " " )
print ()
if __name__ = = '__main__' :
arr = [ 5 , 4 , 1 , 3 , 2 ]
comb_sort(arr)
print_arr(arr)
|
C#
using System;
public class BasicSorting {
public static void CombSort( int [] arr)
{
for ( int turn = 0; turn < arr.Length - 1; turn++) {
for ( int j = 0; j < arr.Length - 1 - turn;
j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
public static void PrintArr( int [] arr)
{
for ( int i = 0; i < arr.Length; i++) {
Console.Write(arr[i] + " " );
}
Console.WriteLine();
}
public static void Main( string [] args)
{
int [] arr = { 5, 4, 1, 3, 2 };
CombSort(arr);
PrintArr(arr);
}
}
|
Javascript
const combSort = (arr) => {
for (let turn = 0; turn < arr.length - 1; turn++) {
for (let j = 0; j < arr.length - 1 - turn; j++) {
if (arr[j] > arr[j + 1]) {
let temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
const printArr = (arr) => {
for (let i = 0; i < arr.length; i++) {
console.log(arr[i] + " " );
}
console.log();
}
const main = () => {
let arr = [5, 4, 1, 3, 2];
combSort(arr);
printArr(arr);
}
main();
|
Shell Sort:
The Shell Sort’s main component is referred to as a clever division of the array data into numerous subarrays. Shell sort is defined as the “Diminishing Increment Sort.” The important component is that the items that are further apart are compared first, then the ones that are closer together, and lastly the contiguous elements are compared in the final run.
- Shell sort is initially focusing the first two data of the array, which are data with the index of “0” and data with the index “1”.
- If the data order is not appropriate then a kind of swapping will occur.
- It will consider the third element with index value 2, if this value is lesser than the first one then the element will shift.
Decision tree for Shell Sort:
In the below decision tree “Y” indicates “yes”, “N” indicates “No” and “IMP” indicates “Impossible”.
Decision Tree for Shell sort
Explanation: The above figure is implemented by applying the shell sort to make a decision tree.
- Decision trees are carrying label with “Y” and “N” which indicates “yes” and “no” respectively.
- The shell sort technique is used in each separation of the decision tree, which is ordering all the values by the index values.
- Leaves are the final value at the end of the tree which is notified with “[]” square brackets.
- The above decision tree contains “24” leaves, which can be calculated by “n!” number of elements determined is “4”. Find the factorial value of four. This contains 24 leaves.
Hence, this is the implementation decision tree by applying the shell sort:
C++
#include <iostream>
using namespace std;
void shellSort( int arr[], int n) {
for ( int i = 1; i < n; i++) {
int curr = arr[i];
int prev = i - 1;
while (prev >= 0 && arr[prev] > curr) {
arr[prev + 1] = arr[prev];
prev--;
}
arr[prev + 1] = curr;
}
}
void printArr( int arr[], int n) {
for ( int i = 0; i < n; i++) {
cout << arr[i] << " " ;
}
cout << endl;
}
int main() {
int arr[] = { 5, 4, 1, 3, 2 };
int n = sizeof (arr) / sizeof (arr[0]);
shellSort(arr, n);
printArr(arr, n);
return 0;
}
|
Java
import java.util.*;
public class BasicSorting {
public static void shellSort( int arr[])
{
for ( int i = 1 ; i < arr.length; i++) {
int curr = arr[i];
int prev = i - 1 ;
while (prev >= 0 && arr[prev] > curr) {
arr[prev + 1 ] = arr[prev];
prev--;
}
arr[prev + 1 ] = curr;
}
}
public static void printArr( int arr[])
{
for ( int i = 0 ; i < arr.length; i++) {
System.out.print(arr[i] + " " );
}
System.out.println();
}
public static void main(String args[])
{
int arr[] = { 5 , 4 , 1 , 3 , 2 };
shellSort(arr);
printArr(arr);
}
}
|
Python3
def shellSort(arr):
for i in range ( 1 , len (arr)):
curr = arr[i]
prev = i - 1
while prev > = 0 and arr[prev] > curr:
arr[prev + 1 ] = arr[prev]
prev - = 1
arr[prev + 1 ] = curr
def printArr(arr):
for i in range ( len (arr)):
print (arr[i], end = " " )
print ()
arr = [ 5 , 4 , 1 , 3 , 2 ]
shellSort(arr)
printArr(arr)
|
C#
using System;
public class Program {
static void ShellSort( int [] arr, int n)
{
for ( int i = 1; i < n; i++) {
int curr = arr[i];
int prev = i - 1;
while (prev >= 0 && arr[prev] > curr) {
arr[prev + 1] = arr[prev];
prev--;
}
arr[prev + 1] = curr;
}
}
static void PrintArr( int [] arr, int n)
{
for ( int i = 0; i < n; i++) {
Console.Write(arr[i] + " " );
}
Console.WriteLine();
}
static void Main( string [] args)
{
int [] arr = { 5, 4, 1, 3, 2 };
int n = arr.Length;
ShellSort(arr, n);
PrintArr(arr, n);
}
}
|
Javascript
function shellSort(arr) {
for (let i = 1; i < arr.length; i++) {
let curr = arr[i];
let prev = i - 1;
while (prev >= 0 && arr[prev] > curr) {
arr[prev + 1] = arr[prev];
prev--;
}
arr[prev + 1] = curr;
}
}
function printArr(arr) {
for (let i = 0; i < arr.length; i++) {
console.log(arr[i] + " " );
}
console.log();
}
let arr = [5, 4, 1, 3, 2];
shellSort(arr);
printArr(arr);
|
Difference between Comb sort and Shell Sort:
S.N |
Comb Sort |
Shell Sort |
1. |
A comparison sorting algorithm is called Comb Sort. |
An undependable quadratic sorting algorithm is Shell Sort. |
2. |
Exchange Sorts like the Bubble Sort and the Comb Sort are extremely similar. |
In most cases, Insertion sort provides the basis for this Sorting method. |
3. |
The extended version of the Bubble Sort is known as the Comb Sort. |
The generalized Insertion Sort is referred to as shell sort. |
4. |
The gaps, which represent the overall separation between the two items, are introduced in the comb sort. |
The “diminishing increment” mechanism is what the shell sort uses. |
5. |
The gap in a bubble sort has a value of 1, and it starts out as a large number. |
This mechanism makes sure that the elements with low and high values are moved to the appropriate side of the array very quickly. At each step, only elements that are separated by a certain amount are compared, i.e., the first element is compared with the fifth element and the second element is compared with the sixth element. |
6. |
The value of the gap decreases after the traversal is finished until it equals 1, at which point the comb sort algorithm essentially devolves into a bubble sort. |
Applying this process in each iteration reduces the gaps between the compared elements. • When the algorithm transitions to a conventional insertion sort, which ends quickly because there are now very few misplaced elements in the arrays, the gap value will be set to 1. |
Share your thoughts in the comments
Please Login to comment...