Using max() in SQL

This should do it (and it uses the GROUP BY according to the SQL standard, not the way MySQL implements it)

select s.sid,
       s.sfirstname,
       s.dcode,
       ag.avg_grade
from students s
  join (select sid, avg(grade) as avg_grade
        from studentgrades 
        group by sid) ag on ag.sid = s.sid
  join (select s.dcode,
               max(avg_grade) max_avg_grade
        from students s 
          join (select sid, avg(grade) as avg_grade
                from studentgrades 
                group by sid) ag on ag.sid = s.sid
        group by s.dcode) mag on mag.dcode = s.dcode and mag.max_avg_grade = ag.avg_grade
order by mag.avg_grade;

How this works

This builds up the result in several steps. First it calculates the average grade for each student:

select sid, avg(grade) as avg_grade
from studentgrades 
group by sid

Based on the result of this statement, we can calculate the max. average grade:

select s.dcode,
       max(avg_grade) max_avg_grade
from students s 
  join (select sid, avg(grade) as avg_grade
        from studentgrades 
        group by sid) ag on ag.sid = s.sid
group by s.dcode

Now these two results are joined to the students table. For easier reading assume there is a view called average_grades (the first statement) and max_average_grades (the second one).

The final statement basically does this then:

select s.sid,
       s.sfirstname,
       s.dcode,
       ag.avg_grade
from students s
  join avg_grades ag on ag.sid = s.sid
  join max_avg_grades mag 
    on mag.dcode = s.dcode 
   and mag.max_avg_grade = ag.avg_grade;

The real one (the very first in my answer) simply replaces the names avg_grades and max_avg_grades with the selects I have shown. That's why it looks so complicated.

A solution in standard SQL that is a bit more readable

In standard SQL, this could be expressed using a common table expression which makes it a bit more readable (but is essentially the same thing)

with avg_grades (sid, avg_grade) as (
  select sid, avg(grade) as avg_grade
  from studentgrades 
  group by sid
), 
max_avg_grades (dcode, max_avg_grade) as (
  select s.dcode, max(avg_grade) max_avg_grade
  from students s 
     join avg_grades ag on ag.sid = s.sid
  group by s.dcode
)
select s.sid,
       s.sfirstname,
       s.dcode,
       ag.avg_grade
from students s
  join avg_grades ag on ag.sid = s.sid
  join max_avg_grades mag on mag.dcode = s.dcode and mag.max_avg_grade = ag.avg_grade;

But MySQL is one of the very few DBMS to not support this, so you will need to stick with the initial statement.

A standard SQL solution requiring less derived tables

In standard SQL it could be written even a bit shorter using windowing functions to calculate the rank inside a department (again this does not work in MySQL)

with avg_grades (sid, avg_grade) as (
  select sid, avg(grade) as avg_grade
  from studentgrades 
  group by sid
)
select sid, 
       sfirstname,
       dcode,
       avg_grade
from (       
  select s.sid,
         s.sfirstname,
         s.dcode,
         ag.avg_grade,
         rank() over (partition by s.dcode order by ag.avg_grade desc) as rnk
  from students s
    join avg_grades ag on ag.sid = s.sid
) t
where rnk = 1;

Update the query to use a HAVING clause as below:

   SELECT dcode, averages.sfirstName, averages.average
   FROM (
       SELECT g.sid as studentID, s.sfirstname, s.dcode, AVG(grade) as average
       FROM studentgrades g, student s
       WHERE g.sid = s.sid
       GROUP BY s.sid) averages
  GROUP BY dcode
  HAVING MAX(averages.average) = averages.average

there are many different solutions. Maybe this one is simpler to understand:

/* create a new temporariy table of student performance. to keep the code clean and the performance better */
INSERT INTO studentperformance (studentID, sfirstname, dcode, average)
SELECT g.sid as studentID
     , s.sfirstname
     , s.dcode
     , AVG(grade) as average
FROM studentgrades g, student s
WHERE g.sid = s.sid
GROUP BY s.sid;

/* best grades for each department */
INSERT INTO bestgrades (best_average_per_department)
SELECT (dcode + '|' + MAX(average)) as best_average_per_department /* important string. maybe one has to cast the max(average) to string for this to work */
FROM studentperformance
GROUP BY dcode; /* important groub by ! */

/* get all the students who are best in each department */
SELECT a.studentID
     , a.sfirstname
     , a.dcode
     , a.average
FROM studentperformance as a
JOIN bestgrades as b on (a.dcode + '|' + a.average) = b.best_average_per_department;