---
title: "Rekursiv kolla datum metod"
type: "forum-thread"
url: "https://www.webforum.nu/amne/dotnet/166449-rekursiv-kolla-datum-metod"
topic: ".NET"
topic_url: "https://www.webforum.nu/amne/dotnet"
author: "Addeladde"
published: "2007-11-16T00:29:55.000Z"
updated: "2007-11-17T13:30:25.000Z"
replies: 5
views: 514
page: 1
pages: 1
language: "sv-SE"
site: "webForum — webforum.nu"
rights: "Upphovsrätten till varje inlägg tillhör dess författare."
attribution: "Citera som: webForum, https://www.webforum.nu/amne/dotnet/166449-rekursiv-kolla-datum-metod"
---

# Rekursiv kolla datum metod

## #1 — Addeladde, 2007-11-16T00:29Z

Hej

Jag får inte riktigt till detta. Vet att det inte riktigt stämmer på hur jag vill ha det.

Jag vill kolla datum i en collection och se hur många tider som skulle placera bredvid varandra i en kalender. Funktionen måste göras rekursivt eftersom att de två första tiderna ligger inom samma intervall men den tredje tiden ligger bara inom samma intervall som den andra tiden. Men de måste ändå placera sig efter varandra på grund av överlappningen.

Tänk er som en kalender där tiderna ska placera sig bredvid varandra då de krockar.

Det jag vill åstadkomma är följande:

```
rID  start        stop     order   inIntervall
8    09.30       10.20    1        3
4    09.45       10.50    2        3
9    10.30       11.15    3        3
2    15.30       16.20    1        0
```

Följande har jag försökt med:

```

resvColl = Reservation.GetAll();
        Response.Write(resvColl.Count);
        foreach (Reservation r in resvColl)
        {
            if (r.Order == 0)
                r.InSameInterval = checkForSameInterval(r);
        }
    private int checkForSameInterval(Reservation rObj)
    {
        foreach (Reservation r in resvColl)
        {
            if (r.ReservationID != rObj.ReservationID && r.StartDateTime >= rObj.StartDateTime && r.StartDateTime.Day == rObj.StartDateTime.Day && r.StartDateTime <= rObj.StopDateTime)
            {         
                    r.InSameInterval++;
                    r.Order = r.Order + 1;
                    rObj.InSameInterval = rObj.InSameInterval + checkForSameInterval(r);
                
            }
        }
        return rObj.InSameInterval;

    }
```

Hela testwebbservern hänger sig när jag kör denna kod. Kan det ha med minnesläckage?

Permalänk: https://www.webforum.nu/p/166449

## #2 — Gladh, 2007-11-16T06:40Z

> **Addeladde skrev:**
>
> Hela testwebbservern hänger sig när jag kör denna kod. Kan det ha med minnesläckage?

Det är inte så konstigt eftersom du inte har något slut på din rekursition.

För att rekursiva funktioner skall fungerar så måste du hela tiden jobba dig närmare och närmare slutet. I ditt fall så kontrollerar du samma collection hela tiden, och skulle du hitta ett objekt som matchar din IF sats så kommer du hoppa in i din checkFoSameInterval och köra igenom exakt samma förfarande igen och kommer hitta samma objekt som kommer gå igenom din IF sats och sedan så kommer du hoppa in i din checkForSameInterval och du kommer hitta samma objekt som går igenom din IF-sats osv osv...

Ditt problem i koden är alltså att du inte "ändrar" antalet objekt som kontrolleras, utan du har exakt samma data som kontrolleras vid varje nytt anrop till metoden, och det fungerar ju inte.

\- M

Permalänk: https://www.webforum.nu/p/2051892

## #3 — Addeladde, 2007-11-16T11:57Z

Får verkligen inte till detta.
Löser jag problemet med att den bli oändlig så går den inte igenom allt. Klurigt klurigt.

Permalänk: https://www.webforum.nu/p/2051933

## #4 — Addeladde, 2007-11-16T13:35Z

Jag har fått till den men den loopar ovanligt många poster tycker jag. Någon som kan se en optimeringslösning?

```
private void checkForSameInterval(Reservation rObj, int order, Reservation rObjStart)
    {
        counterGlobal++;
        foreach (Reservation r in resvColl)
        {
            rObj.CheckedWith.Add(r.ReservationID);
            if (r.ReservationID != rObj.ReservationID && r.StartDateTime >= rObj.StartDateTime && r.StartDateTime <= rObj.StopDateTime)
            {
                bool check = false;
                foreach(int id in r.CheckedWith){
                    if(id==r.ReservationID)
                        check = true;
                }
                if (check == false)
                {
                    order++;
                    r.Order = order;
                    rObjStart.MatchingRID.Add(r.ReservationID);
                    checkForSameInterval(r, order, rObjStart);
                }
            }
            
            
        }
        if (rObj.ReservationID == rObjStart.ReservationID)
        {
            rObjStart.InSameInterval = rObjStart.MatchingRID.Count + 1;
            foreach (Reservation r in resvColl)
            {
                foreach (int id in rObjStart.MatchingRID)
                {
                    if (id == r.ReservationID)
                        r.InSameInterval = rObjStart.InSameInterval;
                }
            }
        }

    }
```

Permalänk: https://www.webforum.nu/p/2051951

## #5 — spango, 2007-11-16T13:47Z

En tillfixad variant av din ursprungliga kod som håller reda på vilka noder som redan besökts, och som inte besöker dem igen.

```
private int checkForSameInterval(Reservation rObj)
{
    Dictionary<Reservation, object> visited = new Dictionary<Reservation, object>();
    visited.Add(rObj, null);
    return checkForSameInterval(r, reservations);
}

private int checkForSameInterval(Reservation rObj, Dictionary<Reservation, object> visited)
{
    foreach (Reservation r in resvColl)
    {
        if (!visited.ContainsKey(r) && MatchesButNotEqual(r, rObj))
        {         
            visited.Add(r, null);
            r.InSameInterval++;
            r.Order = r.Order + 1;
            rObj.InSameInterval = rObj.InSameInterval + checkForSameInterval(r, visited);    
        }
    }
    return rObj.InSameInterval;
}

private static bool MatchesButNotEqual(Reservation a, Reservation b)
{
    return 
        a.ReservationID != b.ReservationID && 
        a.StartDateTime >= b.StartDateTime && 
        a.StartDateTime.Day == bStartDateTime.Day && 
        a.StartDateTime <= b.StopDateTime;
}
```

Använder Dictionary istället för List eftersom det ger effektivare uppslag (finns kanske nån lämpligare datasamling, men principen är densamma). Det förutsätter att GetHashCode funkar för Reservation, gör den inte det kan du använda reservations-ID som nyckel istället.

Permalänk: https://www.webforum.nu/p/2051957

## #6 — Addeladde, 2007-11-17T13:30Z

Tack!

Smart lösning så slipper man ha en variabel i själva objektet som håller reda på vilka poster som är genomloopade.

Permalänk: https://www.webforum.nu/p/2052158

---

Tråden på webben: https://www.webforum.nu/amne/dotnet/166449-rekursiv-kolla-datum-metod
