Users Online

· Guests Online: 30

· Members Online: 0

· Total Members: 188
· Newest Member: meenachowdary055

Forum Threads

Newest Threads

No Threads created

Hottest Threads

No Threads created

Latest Articles

· Do while loop
· The for loop in C
· C while loop
· Pointers in C
· Functions in C

Oh no! Where's the JavaScript?
Your Web browser does not have JavaScript enabled or does not support JavaScript. Please enable JavaScript on your Web browser to properly view this Web site,
or upgrade to a Web browser that does support JavaScript; Firefox, Safari, Opera, Chrome or a version of Internet Explorer newer then version 6.

Articles Hierarchy

Articles Home » Simple C Programs » C Examples on Pancake Sort, Bogo Sort and Shell Sort

C Examples on Pancake Sort, Bogo Sort and Shell Sort

The C programs in this section illustrate Pancake Sort, BogoSort and Shell Sort algorithms. In Pancake Sort, instead of individual elements being sorted, the only operation allowed is to “flip” one end of the list. Bogo Sort shuffles a list of values as long as they are not sorted. Shell sort is a generalization of insertion sort that allows the exchange of items that are far apart.

C Program to Implement Pancake Sort on Array of Integers
C Program to Implement BogoSort in an Integer Array
C Program to Perform Shell Sort without using Recursion

C Program to Implement Pancake Sort on Array of Integers

This C Program Implements Pancake Sort on Array of Integers.Pancake sorting is a variation of the sorting problem in which the only allowed operation is to reverse the elements of some prefix of the sequence.

Here is source code of the C Program to Implement Pancake Sort on Array of Integers. The C program is successfully compiled and run on a Linux system. The program output is also shown below.

```
/*
```

 * C Program to Implement Pancake Sort on Array of Integers

```
 */
```
```
#include <stdio.h>
```
```
#include <stdlib.h>
```
```
 
```
```
void do_flip(int *, int, int);
```
```
 
```

/*Function to implement the pancake sort*/

int pancake_sort(int *list, unsigned int length)

```
{
```
```
    if (length < 2)
```
```
        return 0;
```
```
    int i, a, max_num_pos, moves;
```
```
 
```
```
    moves = 0;
```
```
    for (i = length;i > 1;i--)
```
```
    {
```
```
        max_num_pos = 0;
```
```
        for (a = 0;a < i;a++)
```
```
        {
```

            if (list[a] > list[max_num_pos])

```
                max_num_pos = a;
```
```
        }
```
```
        if (max_num_pos ==  i - 1)
```
```
            continue;
```
```
        if (max_num_pos)
```
```
        {
```
```
            moves++;
```

            do_flip(list, length, max_num_pos + 1);

```
        }
```
```
        do_flip(list, length, i);
```
```
    }
```
```
    return moves;
```
```
}
```
```
 
```

/*Function to do flips in the elements*/

void do_flip(int *list,  int length,  int num)

```
{
```
```
    int swap;
```
```
    int i = 0;
```
```
    for (i;i < --num;i++)
```
```
    {
```
```
        swap = list[i];
```
```
        list[i] = list[num];
```
```
        list[num] = swap;
```
```
    }
```
```
}
```
```
 
```
```
/*Function to print the array*/
```

void print_array(int list[], int length)

```
{
```
```
    int i;
```
```
    for (i = 0;i < length;i++)
```
```
    {
```
```
        printf("%d ", list[i]);
```
```
    }
```
```
}
```
```
 
```
```
int main(int argc,  char **argv)
```
```
{
```
```
   int list[9];
```
```
   int i;
```

   printf("enter the 9 elements of array:\n");

```
   for (i = 0;i < 9;i++)
```
```
       scanf("%d", &list[i]);
```
```
   printf("\nOriginal: ");
```
```
   print_array(list, 9);
```
```
   int moves  =  pancake_sort(list, 9);
```
```
   printf("\nSorted: ");
```
```
   print_array(list, 9);
```

   printf(" - with a total of %d moves\n",  moves);

```
}
```

$ cc pancake.c
$ a.out
enter the 9 elements of array:
10
9
8
7
6
5
4
3
2
 
Original: 10 9 8 7 6 5 4 3 2
Sorted: 2 3 4 5 6 7 8 9 10   - with a total of 0 moves
$ a.out
enter the 9 elements of array:
1
2
3
4
5
6
7
8
9
 
Original: 1 2 3 4 5 6 7 8 9
Sorted: 1 2 3 4 5 6 7 8 9   - with a total of 0 moves
$ a.out
enter the 9 elements of array:
5
6
7
8
9
1
4
2
3
Original: 5 6 7 8 9 1 4 2 3
Sorted: 1 2 3 4 5 6 7 8 9   - with a total of 3 moves

C Program to Implement BogoSort in an Integer Array

This C Program Implements BogoSort in an Integer Array.

Here is source code of the C Program to Implement BogoSort in an Integer Array. The C program is successfully compiled and run on a Linux system. The program output is also shown below.

```
/*
```

 * C Program to Implement BogoSort in an Integer Array

```
 */
```
```
#include <stdio.h>
```
```
#include <stdlib.h>
```
```
 
```
```
#define size 7
```
```
/* Function Prototypes */
```
```
 
```
```
int is_sorted(int *, int);
```
```
void shuffle(int *, int); 
```
```
void bogosort(int *, int);
```
```
 
```
```
int main()
```
```
{
```
```
    int numbers[size];
```
```
    int i;
```
```
 
```

    printf("Enter the elements of array:");

```
    for (i = 0; i < size;i++)
```
```
    {
```
```
        scanf("%d", &numbers[i]);
```
```
    }
```
```
    bogosort(numbers, size);
```

    printf("The array after sorting is:");

```
    for (i = 0;i < size;i++)
```
```
    {
```
```
        printf("%d\n", numbers[i]);
```
```
    }
```
```
    printf("\n");
```
```
}
```
```
 
```

/* Code to check if the array is sorted or not */

```
int is_sorted(int *a, int n)
```
```
{
```
```
    while (--n >= 1)
```
```
    {
```
```
        if (a[n] < a[n - 1])
```
```
        {
```
```
            return 0;
```
```
          }
```
```
    }
```
```
      return 1;
```
```
}
```
```
 
```

/* Code to shuffle the array elements */

```
void shuffle(int *a, int n)
```
```
{
```
```
    int i, t, temp;
```
```
    for (i = 0;i < n;i++)
```
```
    {
```
```
        t = a[i];
```

        temp = rand() % n;    /* Shuffles the given array using Random function */

```
        a[i] = a[temp];
```
```
        a[temp] = t;
```
```
    }
```
```
}
```
```
 
```

/* Code to check if the array is sorted or not and if not sorted calls the shuffle function to shuffle the array elements */

```
void bogosort(int *a, int n)
```
```
{
```
```
    while (!is_sorted(a, n))
```
```
    {
```
```
        shuffle(a, n);
```
```
    }
```
```
}
```

$ cc bogo_sort.c
Average case:
$ a.out
Enter the elements of array:56
34
96
26
08
87
36
The array after sorting is:8
26
34
36
56
87
96
 
Best case:
$ a.out
Enter the elements of array:12
23
34
45
56
67
78
The array after sorting is:12
23
34
45
56
67
78
 
Worst case:
$ a.out
Enter the elements of array:984
38
983
389
37
596
483
The array after sorting is:37
38
389
483
596
983
984

C Program to Perform Shell Sort without using Recursion

This C Program Performs Shell Sort without using Recursion.

Here is source code of the C Program to Perform Shell Sort without using Recursion. The C program is successfully compiled and run on a Linux system. The program output is also shown below.

```
/*
```

 * C Program to Perform Shell Sort without using Recursion

```
 */
```
```
#include  <stdio.h>
```
```
#define size 7
```
```
 
```
```
/* Function Prototype */
```
```
int shell_sort(int []);
```
```
 
```
```
void main()
```
```
{
```
```
    int arr[size], i;
```

    printf("Enter the elements to be sorted:");

```
    for (i = 0;i < size;i++)
```
```
    {
```
```
        scanf("%d", &arr[i]);
```
```
    }
```
```
    shell_sort(arr);
```

    printf("The array after sorting is:");

```
    for (i = 0;i < size;i++)
```
```
    {
```
```
        printf("\n%d", arr[i]);
```
```
    }
```
```
}
```
```
 
```

/* Code to sort array using shell sort */

```
int shell_sort(int array[])
```
```
{
```
```
    int i = 0, j = 0, k = 0, mid = 0;
```
```
    for (k = size / 2;k > 0;k /= 2)
```
```
    {
```
```
        for (j = k;j < size;j++)
```
```
        {
```

            for (i = j - k;i >= 0;i -= k)

```
            {
```

                if (array[i + k] >= array[i])

```
                {
```
```
                    break;
```
```
                }
```
```
                else
```
```
                {
```
```
                    mid = array[i];
```

                    array[i] = array[i + k];

```
                    array[i + k] = mid;
```
```
                }
```
```
            }
```
```
        }
```
```
    }
```
```
    return 0;
```
```
}
```

$ cc shellsort.c
Average case:
$ a.out
Enter the elements to be sorted:57
67
48
93
42
84
95
The array after sorting is:
42
48
57
67
84
93
95
 
Best case:
$ a.out
Enter the elements of array:22
33
74
85
86
87
98
The array after sorting is:22
33
74
85
86
87
98
 
Worst case:
$ a.out
Enter the elements of array:94
92
91
89
85
80
43
The array after sorting is:43
80
85
89
91
92
94