Q:

Stackoverflow Exception in Recursion

Today I wanted to write a program that solves a sudoku.
When my approach didn't quite work I resorted to a solution found here: http://www.heimetli.ch/ffh/simplifiedsudoku.html
But for some reason, I keep getting a StackOverflow Exception.
This is my code:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;

namespace Sudoku_Solver
{
class Program
{
    static void Main(string[] args)
    {
        MainClass _mainClass = new MainClass();

        _mainClass.printSudoku();

        Console.ReadLine();
    }
}

class MainClass
{
    private const int FieldsVertical = 3, FieldsHorizontal = 3;
    private const int RowsInField = 3, ColumnsInField = 3;

    Thread _sudokuSolverThread;

    private int[,] Sudoko = new int[(FieldsVertical * ColumnsInField), (FieldsHorizontal * RowsInField)]{
        { 4, 0, 2, 0, 3, 0, 0, 0, 0},
        { 7, 0, 8, 0, 4, 2, 0, 9, 0},
        { 0, 0, 0, 8, 0, 5, 4, 0, 0},
        { 0, 8, 0, 0, 0, 4, 2, 0, 9},
        { 0, 9, 4, 2, 0, 6, 8, 1, 0},
        { 6, 0, 1, 7, 0, 0, 0, 3, 0},
        { 0, 0, 9, 5, 0, 3, 0, 0, 0},
        { 0, 3, 0, 4, 6, 0, 7, 0, 2},
        { 0, 0, 0, 0, 2, 0, 9, 0, 3},
    };

    public MainClass(){ }

    private void startSudokuSolver()
    {
        solveSudoku(0, 0);
    }

    private bool solveSudoku(int row, int col)
    {
        if (Sudoko[row, col] != 0)
        {
            return next(row, col++);
        }
        else
        {
            for (int i = 0; i < ColumnsInField * RowsInField; i++)
            {
                if (checkColumn(i, row) && checkField(i, row, col) && checkRow(i, col))
                {
                    Sudoko[row, col] = i;

                    //Thread.Sleep(10);

                    return next(row, col++);
                }
            }
            Sudoko[row, col] = 0;

            return false;
        }
    }

    private bool next(int row, int col)
    {
        if (row == 9)
        {
            return false;
        }
        else
        {
            if (col == 9)
            {
                return solveSudoku(row++, 0);
            }
            else
            {
                return solveSudoku(row, col);
            }
        }
    }

    public void printSudoku()
    {
        startSudokuSolver();

        for (int i = 0; i < Sudoko.GetLength(0); i++)
        {
            for (int x = 0; x < Sudoko.GetLength(1); x++)
            {
                Console.Write(Sudoko[i, x] + " ");
            }
            Console.Write(Environment.NewLine);
        }
    }

    private bool checkRow(int number, int col)
    {
        for (int row = 0; row < FieldsVertical * RowsInField; row++)
        {
            if (Sudoko[row, col] == number)
            {
                return false;
            }
        }

        return true;
    }

    private bool checkColumn(int number, int row)
    {
        for (int column = 0; column < FieldsHorizontal * ColumnsInField; column++)
        {
            if (Sudoko[row, column] == number)
            {
                return false;
            }
        }
        return true;
    }

    int _currentFieldRow;
    int _currentFieldColumn;

    private bool checkField(int number, int row, int col)
    {
        _currentFieldRow = (row / RowsInField) * RowsInField;
        _currentFieldColumn = (col / ColumnsInField) * ColumnsInField;

        for (int a = _currentFieldRow; a < _currentFieldRow + RowsInField; a++)
        {
            for (int b = _currentFieldColumn; b < _currentFieldColumn + ColumnsInField; b++)
            {
                if (Sudoko[a, b] == number)
                {
                    return false;
                }
            }
        }
        return true;
    }
}

}

A:

E.g. here
            return solveSudoku(row++, 0);

the original value of row is passed to the function solveSudoku (and after that row is incremented). Change it to row + 1.

A:

The reason for the StackOverflowException is in the next() method. Change
return solveSudoku(row, col);

to
return solveSudoku(row, ++col);

This does at least solve the StackOverflowException. Anyway, you need to enhance the algorithm further as it does not solve the complete Sudoku yet.

