Writing recursive functions without a proper base case can lead to infinite recursion.

// Incorrect
void countDown(int n) {
    printf("%d ", n);
    countDown(n - 1); // Missing base case
}

// Correct
void countDown(int n) {
    if (n <= 0) {
        return;
    }
    printf("%d ", n);
    countDown(n - 1);
}

Neglecting to check the return values of functions that can fail (e.g., malloc, fopen, etc.) can lead to errors.

// Incorrect
FILE *file = fopen("non_existent_file.txt", "r");
// No check for the success of fopen()

// Correct
FILE *file = fopen("non_existent_file.txt", "r");
if (file == NULL) {
    // Handle error (file not opened)
}

Mismatching format specifiers with the data types can lead to undefined behavior or incorrect output.

// Incorrect
int x = 10;
printf("Value of x: %s\n", x); // Incorrect format specifier '%s' for integer

// Correct
int x = 10;
printf("Value of x: %d\n", x); // Output: Value of x: 10

Not handling newline characters left in the input buffer after using scanf().

// Incorrect
char name[50];
printf("Enter your name: ");
scanf("%s", name);
// If the user enters "John Doe", the newline character is left in the buffer

// Correct
char name[50];
printf("Enter your name: ");
scanf("%49[^\n]", name);
// The format specifier reads up to 49 characters or until a newline character

Using pointers without initializing them or dereferencing NULL pointers can lead to crashes.

// Incorrect
int *ptr; // Uninitialized pointer
*ptr = 10; // Dereferencing NULL pointer

// Correct
int *ptr = NULL;
ptr = (int *)malloc(sizeof(int));
*ptr = 10;
free(ptr);

Assigning a value using = instead of comparing with == in conditional statements.

// Incorrect
int x = 5;
if (x = 10) {
    printf("x is 10\n");
}

// Correct
int x = 5;
if (x == 10) {
    printf("x is 10\n");
}

Using incorrect loop conditions can lead to infinite loops or incorrect program behavior.

// Incorrect
int i = 0;
while (i <= 5) {
    printf("%d ", i);
    // Missing increment of 'i' (i++ or i--)
}

// Correct
int i = 0;
while (i <= 5) {
    printf("%d ", i);
    i++;
}

Writing more data into an array than it can hold can cause memory corruption and security vulnerabilities.

// Incorrect
char name[5];
strcpy(name, "John Doe"); // Buffer overflow

// Correct
char name[50];
strcpy(name, "John Doe");

Using variables without initializing them can lead to unpredictable behavior.

// Incorrect
int x;
printf("%d\n", x); // The value of 'x' is undefined

// Correct
int x = 0;
printf("%d\n", x); // Output: 0

Forgetting to add a semicolon at the end of a statement can lead to compilation errors.

// Incorrect
int x = 10
int y = 20

// Correct
int x = 10;
int y = 20;