Egyszeresen kapcsolt lineáris lista
Kérlek, bocsásd meg a nagylelkű erőszakos, de szeretnék azonosítani egy másik forrása a lehetséges problémákat. Ha figyelembe vesszük a teljesítményét többszálú környezetben, mindezen funkciók nem képesek arra, hogy újra belépő, azaz Nem menet biztonságos. Ebben az értelemben, hogy a kötési eljárás vagy törölheti a csomópontok listáját, hogy egy atomi művelet, azaz a kódot a részen, ahol a végrehajtott manipulációkat a mutatók és adatmezőket kell elhelyezni a kritikus szakaszban, olyasmi, mint
p = LSt-> ptr; // Add a mutatót a következő csomóponthoz
LSt-> ptr = temp; // előző csomópont jelzi létre
TEMP-> mező = szám; // az adatok mentése terén hozzáadott csomópont
TEMP-> ptr = p; // Létrehozunk egy csomópont pont a következő elemre
Vegyük ezt a példát. Hagyja, hogy a lista 3 elemből áll:
root => elem1 => elem2 => elem3 => NULL
Tegyük fel, hogy van két párhuzamos stream (feladatok, szálak, stb, különböző platformokon az úgynevezett különböző módon, de a lényeg nem változik), amelyben szeretnénk adni egy elemet, hogy a végén a listán (a pszeudo-kód szerinti sorrendben teljesítményének időbeli)
// 1. adatfolyam
// itt valami kód
last_element = find_last_elem (root); // Az egy mutatót az utolsó elem
addelem (last_elem, szám); // egy új elemet, hogy a végén a lista
// itt valami kód
// 2. adatfolyam
// itt valami kód
last_element = find_last_elem (root); // Az egy mutatót az utolsó elem
addelem (last_elem, szám); // egy új elemet, hogy a végén a lista
// itt mi a kód
habár pillanatnyilag az áramlás végrehajtásra kerül, és 1 van egy mutatót az utolsó elem, ebben az esetben az elem, 3, majd okozott addelem () függvény, amely kezd kell teljesíteni:
temp = (struct lista *) malloc (sizeof (lista));
p = LSt-> ptr; // Add a mutatót a következő csomóponthoz, ebben az esetben, ez az utolsó p = NULL
// Uups! Kivitelezés eltolódott a menet 2 nincs garancia arra, hogy ez nem történhet meg ezen a helyen
// patak 2 - most már a falon 2
// megtalálja az utolsó eleme a listán - ez (micsoda meglepetés.) 3. pont, mint mi csak nem volt ideje, hogy újra felvenni mutatókat //
// Most lépett be a addelem () függvény ismét
temp = (struct lista *) malloc (sizeof (lista));
p = LSt-> ptr; // Add a mutatót, hogy a következő csomópont NULL
LSt-> ptr = temp; // előző csomópont jelzi létre, most elem 4
TEMP-> mező = szám; // az adatok mentése terén hozzáadott csomópont
TEMP-> ptr = p; // Létrehozunk egy csomópont pont a következő elem, ebben az esetben NULL
vissza (temp);
// visszatér áramlás funkció 2
// van, hogy az alábbiakban felsorolt root => elem1 => elem2 => elem3 => elem4 => NULL
// némi kódot flow 2
// hoppá. újra bekapcsolásával 1 áram.
// 1. adatfolyam
// továbbra attól a ponttól, ahol megszakadt
// lst még mindig jelzi az elem 3, bár ez nem az utolsó elem a listában.
LSt-> ptr = temp; // jelzi az előző csomópont létre, de ez nem egy hozzáadott elem 4 áramban 2
// mutató így elem 4 létrehozott felülírt adatfolyam 2
TEMP-> mező = szám; // az adatok mentése terén hozzáadott csomópont
TEMP-> ptr = p; // Létrehozunk egy csomópont pont a következő elemre
vissza (temp);
// visszatér a patak funkció 1, végre valami kód flow 1
Tehát, összefoglalni, amit látunk. Látjuk, hogy a doboz tag 3 ptr mutatót az elem 4 hozzáadjuk a végén a lista a falon 2, a régi érték felülírja a potoke1, és ő elveszett. Amellett, hogy a veszteség az elem is, hogy létrehoz egy veszélyes helyzet memóriavesztés, mert mutató egy 4 elem létre az áramlás 2 menthetetlenül elveszett, és nem tudunk semmilyen módon kell szabadítani a lefoglalt memóriát is.
Helló Köszönöm a jó cikk. Alkalmazza a módszer átültetése két linket, hogy módosítsa a minimum és maximum értékeket a listán. Ahhoz, hogy megtalálja linkeket más funkciókat. Abban a pillanatban, hogy működik, de csak akkor, ha a linkeket a középső, azaz a Nem az első és nem az utolsó. Nem számít, számos elemet, vagy sem. Tanácsot, hogyan kell írni a feltétel mindkét lehetőséget, hogy minden jól működjön. Köszi előre.
érvényteleníti switchMinMax (Node * fej) Node * prevMax, * prevMin, * postMax, * postMin, * tmp;
Node * Max, Min *;
Max = getMax (fej);
Min = getMin (fej);
prevMax = fej;
prevMin = fej;
if (prevMax == Max)
prevMax = NULL;
más
while (prevMax-> következő! = Max)
prevMax = prevMax-> következő;
if (prevMin == Min)
prevMin = NULL;
más
while (prevMin-> következő! = Min)
prevMin = prevMin-> következő;
postMax = Max-> következő;
postMin = Min> következő;
if (Min == postMax)
Min-> következő = Max;
Max-> következő = postMin;
if (Max! = fej)
prevMax-> következő = perc;
ha (Max == fej)
prevMin = NULL;
>
else if (Max == postMin)
Max-> következő = perc;
Min-> következő = postMax;
if (Min! = fej)
prevMin-> következő = perc;
ha (Min == fej)
prevMax == NULL;
>
más
if (Max! = fej)
prevMax-> következő = perc;
Min-> következő = postMax;
if (Min! = fej)
prevMin-> következő = Max;
Max-> következő = postMin;
>
>
Jó napot! Tud valaki segíteni, nem kap semmilyen oldja meg a problémát az ilyen típusú, szükséges, hogy egy halom szám, és hogy egy új listát, legfeljebb az első köteg - listát. Saját döntés, minden működik, kivéve a másolat egy új listát. Itt ő rögzítési funkció (a verem megtelt)
Szükség van a ciklusban, hogy meghatározzuk a maximális elem és emlékszik a mutatót.
struct stack * maxelem = kezdődik;
int max = maxelem-> szám;
while (temp = NULL!) if ((TEMP-> szám)> max) maxelem = temp;
max = (TEMP-> szám);
>
hőm = TEMP-> következő;
>
Csak akkor, ha tudjuk, hogy a maximális elemet és egy mutatót, akkor létrehoz egy új listát.
Köszönjük a gyors választ. Azt hiszem, nem ért valamit, meghatározott mutató max elem, hozott egy új értékek listája, de a konzol nem jelenik meg. Lehet látni, nagyon köszönöm a segítséget.
Hiba a kiválasztott vonalra. Azt letette a mutatót a tétel is. Field mutató a következő elem inicializálni kell idején megteremtette a „következő” elem.
struct Stack * new_list = (struct Stack *) malloc (sizeof (struct stack));
new_list-> szám = kezdeteihez> szám; // ez a gyökere az új lista
new_list-> következő = NULL;
while (Temp2 = maxelem!) struct stack * temp3 = new_list;
new_list = (struct Stack *) malloc (sizeof (struct stack));
new_list-> szám = temp2-> szám;
temp3-> következő = new_list;
new_list-> következő = NULL;
Temp2 = temp2-> következő;
>
A addelem () függvény, akkor át a mutatót az elem, ami után elvégzéséhez szükséges az adagolás. Root mutató lista így kell tárolni egy másik változó, és a kimeneti lista kell végezni a gyökér.
Ebben az esetben szükségünk van egy funkció, amely hozzáad egy elemet a lista tetején, mint ez
struct lista * addroot (lista * root, int number) struct lista * temp;
temp = (struct lista *) malloc (sizeof (lista));
TEMP-> ptr = gyökér; // generált az előző gyökércsomópont
TEMP-> mező = szám; // az adatok mentése terén hozzáadott csomópont
vissza (temp); // visszatér az új gyökér a lista
>