Funkcja szukająca sąsiadujących identycznych elementów

Cześć, próbuję napisać funkcję, która szuka sąsiednich identycznych elementów tablicy dwuwymiarowej liter, a następnie zamienia je na ten sam element.

X:
0 Accb
1 cccb
2 cbca
3 ccac
  0123 :Y

Użytkownik może zamieniać wielkie litery, w powyższym przypadku po zmianie "A" na "C" wszystkie sąsiadujące elementy powinny zamienić się w wielkie "C".

Jak na razie napisałem 2 funkcje, jedna przeszukująca tablice od lewego górnego rogu, druga od lewego dolnego z tym że obie z nich raz działają, a raz nie :/ Czy ma ktoś może pomysł jakby to napisać, żeby gwarantowało 100% funkcjonalność?

Tutaj funkcje jakie napisałem:

void sprawdzodgory(char** tab, int w, int k){
        for(int i=0;i<w;i++){
        for(int j=0;j<k;j++){
            if(j==0){
                if(tab[i][j]==toupper(tab[i][j+1]))
                    tab[i][j+1]=tab[i][j];
            }
            else if(j>0 && j<k-1){
                if(tab[i][j]==toupper(tab[i][j+1]))
                    tab[i][j+1]=tab[i][j];
                else if(tab[i][j]==toupper(tab[i][j-1]))
                    tab[i][j-1]=tab[i][j];
            }
            else if(j==k-1){
                if(tab[i][j]==toupper(tab[i][j-1]))
                    tab[i][j]=tab[i][j-1];
            }
            if(i==0){
                if(tab[i][j]==toupper(tab[i+1][j]))
                    tab[i+1][j]=tab[i][j];
            }
            else if(i>0 && i<w-1){
                if(tab[i][j]==toupper(tab[i+1][j]))
                    tab[i+1][j]=tab[i][j];
                else if(tab[i][j]==toupper(tab[i-1][j]))
                    tab[i-1][j]=tab[i][j];
            }
            else if(i==w-1){
                if(tab[i][j]==toupper(tab[i-1][j]))
                    tab[i][j]=tab[i-1][j];
            }
        }
        }
}

void sprawdzoddolu(char** tab, int w, int k){
        for(int i=w-1;i>=0;i--){
            for(int j=k-1;j>=0;j--){
                if(j==k-1){
                    if(tab[i][j]==toupper(tab[i][j-1]))
                        tab[i][j-1]=tab[i][j];
                }
                else if(j>0 && j<k-1){
                    if(tab[i][j]==toupper(tab[i][j+1]))
                        tab[i][j+1]=tab[i][j];
                    else if(tab[i][j]==toupper(tab[i][j-1]))
                    tab[i][j-1]=tab[i][j];
                }
                else if(j==0){
                if(tab[i][j]==toupper(tab[i][j+1]))
                    tab[i][j]=tab[i][j+1];
                }
                if(i==w-1){
                    if(tab[i][j]==toupper(tab[i-1][j]))
                        tab[i-1][j]=tab[i][j];
                }
                else if(i>0 && i<w-1){
                    if(tab[i][j]==toupper(tab[i+1][j]))
                        tab[i+1][j]=tab[i][j];
                    else if(tab[i][j]==toupper(tab[i-1][j]))
                        tab[i-1][j]=tab[i][j];
                }
                else if(i==0){
                    if(tab[i][j]==toupper(tab[i+1][j]))
                        tab[i][j]=tab[i+1][j];
                }
            }
        }
}

if(tab[i][j]==toupper(tab[i][j+1]))

czemu nie robisz toupper też dla lewego wyrażenia?

if(toupper(tab[i][j])==toupper(tab[i][j+1]))

Jak na razie napisałem 2 funkcje, jedna przeszukująca tablice od lewego górnego rogu,
druga od lewego dolnego z tym że obie z nich raz działają, a raz nie

1. Sprawdzałeś to debuggerem?
2. Pomyśl o jakimś bardziej czytelnym kodzie, bo przy takiej kaszy będzie ci trudno samemu zrozumieć co robisz (jest tu dużo możliwości do refaktoru: wydzielenie zduplikowanych wyrażeń do jakoś sensownie nazwanych zmiennych, nadmiarowe warunki, których też można by się jakoś pewnie pozbyć itp.). Bo tak to co chwila będziesz się gubić.

Poza tym moja intuicja mówi mi, że jeśli przechodzisz przez tablicę, którą jednocześnie mutujesz(zmieniasz w miejscu), to jeśli sprawdzasz kolejne warunki, będą one zanieczyszczone przez zmiany, które wprowadziłeś. (jak to mówią "shared mutable state is the root of all evil"). I tym sposobem mogłoby się tak zdarzyć, że twoje ify sprawdzałyby literę i raz ta litera pochodziłaby ze starej wersji tablicy, a raz już od tej nowej. (nie wiem, czy na 100% to jest przyczyną błędu, ale jest to jakaś potencjalna przyczyna)

Można by tego uniknąć np. nie zmieniając tablicy w miejscu, ale tworząc całą nową wersję tablicę. Albo w inny sposób. Np. tworząc listę zmian do zaaplikowania (np. pole 3, 10 = ustaw na C, pole 4, 4 ustaw na C itp.), i dopiero potem ją zaaplikować.