Pętla, usuwanie elementów z listy. fsd

Cześć,
Mierzę się z następującym problemem:
Mam listę około 1000 danych typu double i mam zamiar oczyścić listę:
Najpierw robię pętlę i sprawdzam warunek dla kolejnych wartości z listy: ((x_1 < x_2 & x_3 <x_2) || x_1 > x_2 & x_3 > x_2)) --jeżeli warunek jest spełniony usuwam x_1 i x_3
Dostaję nową listę (ale kolejne wartości po usunięciu spełniają powyższy warunek) i tu pojawia się problem, w jaki sposób zrobić aby końcowym efektem była lista kolejnych wartości które nie spełniają tego warunku. W ten sposób chce oczyścić swoje dane.

            var data = db.data;
            int listRowsValue = data.Max(p => p.ID);
            for (int i = 2; i < listRowsValue; i++)
            {
                double x_1 = data.Where(p => p.ID == i - 1).Select(p => p.x).FirstOrDefault();
                double x_2 = data.Where(p => p.ID == i).Select(p => p.x).FirstOrDefault();
                double x_3 = data.Where(p => p.ID == i + 1).Select(p => p.x).FirstOrDefault();

                if ((x_1 < x_2 & x_3 < x_2) || (x_1 > x_2 & x_3 > x_2))
                {
                        var ch = new newdata
                        {
                            x = x_2,
                        };
                        newdata.Add(ch);
                    }
                }
            }

A tak w góralskich słowach, jaka ma być zasada "uporządkowanych" vs "nieuporządkowanych" danych, bo ja nie umeim z kodu wyczytać

EDIT teraz dopiero doczytuję, skąd ci wpadł najbardziej pokręcony sposób na znalezienie n-1 i n+1 elementy tablicy?

EDIT2: dodam, var nie pomaga czytelnikowi fragmentu kodu

@AnyKtokolwiek: Po tej pętli otrzymuje nową listę i tą samo operacje chce powtórzyć dla nowej listy, i później znowu dla nowej listy.. aż nie otrzymam listy zawierającej tylko wartości po sobie nie spełniające warunku ((x_1 < x_2 & x_3 <x_2) || x_1 > x_2 & x_3 > x_2))

Tak na pierwszy rzut oka, to mógłbyś to mocno zoptymalizować

Zmaterializuj sobie (ToList, ToArray) dane do listy par Id, x

Posortuj po Id, a następnie idź forem z skokiem po 3 i bierz po 3 elementy

Po tej pętli otrzymuje nową listę i tą samo operacje chce powtórzyć dla nowej listy, i później znowu dla nowej listy.. aż nie otrzymam listy zawierającej tylko wartości po sobie nie spełniające

var dane = db.data;
var lastSize = dane.Count;
var newdata = new List<Data>();

while (true)
{
	// twój algorytm
	
	// jakiś sposób na wykrycie stopu
	// robisz sobie jakas funcke typu Check(newdata)
	// albo chyba wystarczy ci sprawdzić czy rozmiar nie uległ zmianie?
	if (newData.Count == lastSize)
	{
		// lista nie uległa zmianie, a zatem koniec?
		break;
	}	
}

Jeśli dobrze zrozumiałem problem, to można go ogarnąć w taki sposób (celowo bez komentarzy, żebyś też wsadził pewien wysiłek w rozwiązanie):

            var source = new List<int>() {
                2, 1, 3, // should be present in output
                2, 5, 2, // should be present in output
                1, 2, 3,
                6, 5, 4
            };

            bool isMiddleElementExtremum(IGrouping<int, int> group)
            {
                var elements = group.ToList();
                int x1 = group.ElementAt(0), x2 = group.ElementAt(1), x3 = group.ElementAt(2);
                return (x1 < x2 & x3 < x2) || (x1 > x2 & x3 > x2);
            };

            var result = source
                .Select((element, index) => new { index = index / 3, element })
                .GroupBy(k => k.index, v => v.element)
                .Where(group => isMiddleElementExtremum(group))
                .Select(group => group.ElementAt(1))
                .ToList();
        }