i use this for groups in groups in groups.

public class groupMemberObj{
	public User user {get; set;}
	public Group public_group {get; set;}
	public UserRole role {get; set;}
	public string reason {get; set;}
}

public static list<groupMemberObj> groupMembers;

public static list<groupMemberObj> getGroupMembers(list<Group> groups)
{
	if(groupMembers==null) groupMembers = new list<groupMemberObj>();
	if(groups!=null)
	{
		Group[] sub_groups = new list<Group>();
		id[] group_member_ids = new list<id>();
		//map<id,id> user_ids = new map<id,id>();
		id[] user_ids = new list<id>();
		
		// map userOrGroup to Group Name
		map<id,Group> groupIdToGroup_map = new map<id,Group>();
		
		// map the group member to the group
		map<id,id> groupMemberIdToGroupId_map = new map<id,id>();
				
		/**
			iterate through each sub-group level where the group member
			is another group until we have all users from all group memberships
			of all groups and there are no more sub-groups as group members.
		**/
			
		do{
			// if this list is not cleared each time the list of ids to query
			// keeps growing and eventualy you hit max SQL queries error
			group_member_ids.clear();

			for(Group g : groups)
			{
				// to get information about the group later, e.g. the group name for a user
				if(groupIdToGroup_map.get(g.id)==null){
					groupIdToGroup_map.put(g.id,g);
				}
				
				for(GroupMember gm : g.groupmembers)
				{
					if(groupMemberIdToGroupId_map.get(gm.userOrGroupId)==null){
						groupMemberIdToGroupId_map.put(gm.userOrGroupId,gm.GroupId);
					}
					
					group_member_ids.add(gm.userOrGroupId);
				}
			}

			// keep trying to get groups from GroupMember.userOrGroupId
			sub_groups = [Select g.Type, g.RelatedId, g.Name, g.Id, (Select Id, GroupId, UserOrGroupId From GroupMembers) From Group g where Id In :group_member_ids];
						
			// if group members are groups get those groups members
			if(sub_groups!=null)
			{
				// clear the list of groups and rebuild because we only want these newly found groups each time
				// from group members of groups
				groups.clear();
				for(Group g : sub_groups){
					groups.add(g);
				}
			}
						
			// keep trying to get users from GroupMember.userOrGroupId.
			// skip any users already added to the list
			User[] users = [select Id,Email,Name from User where (Id In :group_member_ids) and (Id Not In :user_ids) and (isActive=true)];
			
			for(User u :users)
			{	
				// add users to the final list of group members
				groupMemberObj gmo = new groupMemberObj();
				gmo.user=u;
				gmo.public_group = groupIdToGroup_map.get(groupMemberIdToGroupId_map.get(u.id));
				groupMembers.add(gmo);
				
				// prevent the user from being selected in the query more than once
				user_ids.add(u.id);
			}
		// keep getting group members for groups
		} while (sub_groups.size()>0);
					
	}
	return groupMembers;
}