Write a programe in C to create bubble short

You

Klenara

Here's a C program that implements bubble sort:

#include <stdio.h>void bubbleSort(int arr[], int n) {    for (int i = 0; i < n - 1; i++) {        for (int j = 0; j < n - i - 1; j++) {            if (arr[j] > arr[j + 1]) {                // Swap                int temp = arr[j];                arr[j] = arr[j + 1];                arr[j + 1] = temp;            }        }    }}void printArray(int arr[], int n) {    for (int i = 0; i < n; i++) {        printf("%d ", arr[i]);    }    printf("\n");}int main() {    int arr[] = {64, 34, 25, 12, 22, 11, 90};    int n = sizeof(arr) / sizeof(arr[0]);    printf("Original array: \n");    printArray(arr, n);    bubbleSort(arr, n);    printf("Sorted array: \n");    printArray(arr, n);    return 0;}

How it works:

The outer loop runs n-1 times
The inner loop compares adjacent elements and swaps them if they're in the wrong order
After each pass, the largest unsorted element "bubbles" to its correct position
Time complexity: O(n²) in worst and average cases, O(n) in best case

Output:

Original array: 64 34 25 12 22 11 90 Sorted array: 11 12 22 25 34 64 90

You can compile and run it with:

gcc bubble_sort.c -o bubble_sort./bubble_sort

You

Write a programe in C to create merge short

Klenara

Here's a C program that implements merge sort:

#include <stdio.h>#include <stdlib.h>void merge(int arr[], int left, int mid, int right) {    int i = left;      // Starting index of left subarray    int j = mid + 1;   // Starting index of right subarray    int k = left;      // Index for temporary array        // Create temporary array    int *temp = (int *)malloc((right - left + 1) * sizeof(int));        // Merge two subarrays into temp    while (i <= mid && j <= right) {        if (arr[i] <= arr[j]) {            temp[k++] = arr[i++];        } else {            temp[k++] = arr[j++];        }    }        // Copy remaining elements from left subarray    while (i <= mid) {        temp[k++] = arr[i++];    }        // Copy remaining elements from right subarray    while (j <= right) {        temp[k++] = arr[j++];    }        // Copy sorted elements back to original array    for (i = left; i <= right; i++) {        arr[i] = temp[i - left];    }        free(temp);}void mergeSort(int arr[], int left, int right) {    if (left < right) {        int mid = left + (right - left) / 2;                // Sort left half        mergeSort(arr, left, mid);                // Sort right half        mergeSort(arr, mid + 1, right);                // Merge both halves        merge(arr, left, mid, right);    }}void printArray(int arr[], int n) {    for (int i = 0; i < n; i++) {        printf("%d ", arr[i]);    }    printf("\n");}int main() {    int arr[] = {64, 34, 25, 12, 22, 11, 90, 88};    int n = sizeof(arr) / sizeof(arr[0]);    printf("Original array: \n");    printArray(arr, n);    mergeSort(arr, 0, n - 1);    printf("Sorted array: \n");    printArray(arr, n);    return 0;}

How it works:

Divide: Recursively split the array into halves until each subarray has one element
Conquer: Merge the subarrays back together in sorted order
Merge function: Compares elements from two subarrays and places smaller element first

Key points:

Uses divide and conquer approach
Time complexity: O(n log n) in all cases (best, average, worst)
Space complexity: O(n) due to temporary array
Stable sort (maintains relative order of equal elements)

Output:

Original array: 64 34 25 12 22 11 90 88 Sorted array: 11 12 22 25 34 64 88 90

Compile and run:

gcc merge_sort.c -o merge_sort./merge_sort

Merge sort is more efficient than bubble sort for larger datasets because of its O(n log n) complexity.

You

Write a programe in C to create quick short

Klenara

Here's a C program that implements quick sort:

#include <stdio.h>void swap(int *a, int *b) {    int temp = *a;    *a = *b;    *b = temp;}int partition(int arr[], int low, int high) {    // Choose last element as pivot    int pivot = arr[high];        // Index of smaller element - indicates the right position    // of pivot found so far    int i = low - 1;        // Traverse through all elements    // Compare each element with pivot    for (int j = low; j < high; j++) {        if (arr[j] < pivot) {            i++;            swap(&arr[i], &arr[j]);        }    }    swap(&arr[i + 1], &arr[high]);    return i + 1;}void quickSort(int arr[], int low, int high) {    if (low < high) {        // pi is partitioning index        // arr[pi] is now at right place        int pi = partition(arr, low, high);                // Separately sort elements before and after partition        quickSort(arr, low, pi - 1);  // Before pi        quickSort(arr, pi + 1, high); // After pi    }}void printArray(int arr[], int n) {    for (int i = 0; i < n; i++) {        printf("%d ", arr[i]);    }    printf("\n");}int main() {    int arr[] = {64, 34, 25, 12, 22, 11, 90, 88};    int n = sizeof(arr) / sizeof(arr[0]);    printf("Original array: \n");    printArray(arr, n);    quickSort(arr, 0, n - 1);    printf("Sorted array: \n");    printArray(arr, n);    return 0;}

How it works:

Partition: Selects a pivot element and partitions the array so elements smaller than pivot are on left, larger on right
Recursive sort: Recursively applies the same process to left and right subarrays
Pivot selection: Uses the last element as pivot (can also use first, middle, or random)

Key points:

Uses divide and conquer approach
Time complexity: O(n log n) average case, O(n²) worst case (when pivot is smallest/largest)
Space complexity: O(log n) for recursion stack
Not stable (doesn't maintain relative order of equal elements)
Faster in practice than merge sort due to better cache locality

Output:

Original array: 64 34 25 12 22 11 90 88 Sorted array: 11 12 22 25 34 64 88 90

Compile and run:

gcc quick_sort.c -o quick_sort./quick_sort

Quick Sort vs Merge Sort vs Bubble Sort:

Bubble Sort: O(n²) — slow, only for learning
Merge Sort: O(n log n) — consistent, stable, uses extra space
Quick Sort: O(n log n) average — fastest in practice, in-place sorting

You

thank you

Klenara

Welcome! 😊 Glad I could help. If you have any more questions about C programming, sorting algorithms, or anything else, feel free to ask anytime. Happy coding!

You

Write a java program to print hello

Klenara

Here's a simple Java program to print "hello":

public class Hello {    public static void main(String[] args) {        System.out.println("hello");    }}

To compile and run:

javac Hello.javajava Hello

Output:

hello

That's it! The main method is the entry point of any Java program, and System.out.println() prints text to the console.

You

Write a programe in C to create digkastra short

Klenara

I think you meant Dijkstra's algorithm (not a sorting algorithm). Here's a C program that implements Dijkstra's shortest path algorithm:

#include <stdio.h>#include <limits.h>#define V 6  // Number of verticesint minDistance(int dist[], int visited[]) {    int min = INT_MAX, minIndex = -1;        for (int i = 0; i < V; i++) {        if (!visited[i] && dist[i] < min) {            min = dist[i];            minIndex = i;        }    }    return minIndex;}void dijkstra(int graph[V][V], int src) {    int dist[V];    int visited[V] = {0};        // Initialize distances    for (int i = 0; i < V; i++) {        dist[i] = INT_MAX;    }    dist[src] = 0;        // Find shortest path for all vertices    for (int count = 0; count < V - 1; count++) {        int u = minDistance(dist, visited);                if (u == -1) break;                visited[u] = 1;                // Update distance of adjacent vertices        for (int v = 0; v < V; v++) {            if (graph[u][v] && !visited[v] &&                 dist[u] != INT_MAX &&                 dist[u] + graph[u][v] < dist[v]) {                dist[v] = dist[u] + graph[u][v];            }        }    }        // Print results    printf("Vertex\t Distance from source\n");    for (int i = 0; i < V; i++) {        printf("%d\t\t %d\n", i, dist[i]);    }}int main() {    // Create adjacency matrix (0 = no edge)    int graph[V][V] = {        {0, 4, 2, 0, 0, 0},        {4, 0, 1, 5, 0, 0},        {2, 1, 0, 8, 10, 0},        {0, 5, 8, 0, 2, 6},        {0, 0, 10, 2, 0, 3},        {0, 0, 0, 6, 3, 0}    };        printf("Dijkstra's Algorithm - Shortest Paths from vertex 0\n\n");    dijkstra(graph, 0);        return 0;}

How it works:

Finds shortest path from a source vertex to all other vertices
Uses greedy approach: always picks unvisited vertex with smallest distance
minDistance() finds the next closest unvisited vertex
Updates distances to adjacent vertices if a shorter path is found

Key points:

Time complexity: O(V²) with adjacency matrix
Works with non-negative weights only
Greedy algorithm that builds shortest path tree
Used in GPS navigation, network routing, etc.

Output:

Dijkstra's Algorithm - Shortest Paths from vertex 0Vertex	 Distance from source0			 01			 32			 23			 84			 105			 14

Compile and run:

gcc dijkstra.c -o dijkstra./dijkstra

This shows the shortest distance from vertex 0 to all other vertices in the graph.