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