2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Aivan kuten kirjoitettaessa joitain toiminnallisia käyttöliittymiä yksitellen linkitetyille listoille, kirjoitetaan ensin joitain käyttöliittymiä kaksinkertaisesti linkitetyille listoille, jotta tutustumme sen pääkehykseen:
#sisältää<stdio.h>
#sisältää<stdlib.h>
typedef int LDataType;
//Kaksisuuntaisen pyöreän linkitetyn luettelon solmu
typedef struct ListNode{
LDataType _data;
// Osoita seuraavan solmun aloituspaikkaan
struct ListNode* _next;
// Osoita edellisen solmun aloituspaikkaan
struct LIst* _prev;
}ListNode;
//Kaksisuuntainen pyöreä linkitetty luettelo
typedef struct List{
struct ListNode* _head;
}Lista;
struct ListNode* createListNode(LDataType val){
struct ListNode* solmu = (struct ListSolmu*)malloc(koko(rakenne ListSolmu));
solmu->_data = arvo;
solmu->_seuraava = NULL;
solmu->_edellinen = NULL;
}
void ListInit(List* lst){
//Tyhjä linkitetty lista
lst->_head = createListNode(0);
lst->_head->_ext = lst->_head->_prev = lst->_head;
}
//Hännön lisäys O(1) //Lisätä data otsikon eteen ListInsert(lst, lst->_head, val);
void ListpushBack(List* lst, LDataType val){
if (lst == NULL){
palata;
struct ListNode* last = lst->_head->_prev;
struct ListSolmu* newNode = createListNode(val);
//_head ... viimeinen uusiNode
last->_next = uusiSolmu;
newNode->_prev = viimeinen;
newNode->_next = lst->_head;
lst->_head->_prev = uusiSolmu;
}
}
//Tail delete://Poista pään edellinen solmu ListErase(lst, lst->_head->_prev);
void ListPopBack(List* lst){
if (lst == NULL)
palata;
//Määritä, onko linkitetty luettelo tyhjä
if (lst->_head->_seuraava == lst->_head)
palata;
struct ListNode* last = lst->_head->_prev;
struct ListNode* prev = viimeinen->_edellinen;
vapaa(viimeinen);
lst->_head->_prev = edellinen;
prev->_next = lst->_head;
}
void printList(List* lst){
struct ListNode* cur = lst->_head->_next;
while (cur != lst->_head){
printf("%d", cur->_data);
cur = cur->_next;
}
printf("n");
}
//Head insert//ListInsert(lst,lst->_head->_next,val);
void ListPushFront(List* lst, LDataType val){
if (lst == NULL)
palata;
struct ListNode* next = lst->_head->_next;
struct ListSolmu* newNode = createListNode(val);
//_head, newNode, next
lst->_head->_next = uusiSolmu;
newNode->_prev = lst->_head;
newNode->_next = seuraava;
seuraava->_edellinen = uusiSolmu;
}
//Otsikon poistaminen//ListErase(lst,lst->_head->_next);
void ListPopFront(List* lst){
if (lst == NULL || lst->_head == lst->_head)
palata;
struct ListNode* next = lst->_head->_next;
struct ListNode* nextnext = next->_next;
nextnext->_prev = seuraava->_seuraava;
lst->_head->_next = seuraavaseuraava;
ilmainen (seuraava);
}
void ListErase(List* lst, struct ListNode* solmu){
//Et voi poistaa pääsolmua
if (lst == NULL || lst->_head == solmu)
palata;
//edellinen, solmu, seuraava
struct ListNode* prev = solmu->_edellinen;
struct ListNode* next = solmu->_seuraava;
prev->_next = seuraava;
seuraava->_edellinen = edellinen;
vapaa(solmu);
}
void ListInsert(List* lst, struct ListNode* node, LDataType val){
if (lst == NULL)
palata;
struct ListNode* prev = solmu->_edellinen;
struct ListSolmu* newNode = createListNode(val);
//edellinen uusiSolmusolmu
prev->_next = uusiSolmu;
newNode->_prev = edellinen;
newNode->_next = solmu;
solmu->_edellinen = uusiSolmu;
}
//tuhota
ListDesto(List* lst){
if (lst){
if (lst->_head){
struct ListNode* cur = lst->_head->_next;
while (cur != lst->_head){
struct ListNode* next = cut->_next;
vapaa(cur);
cur = seuraava;
}
free(lst->_head);
}
}
}
void testi(){
List lst;
ListInit(&lst);
ListPushFront(&lst, 5);
printList(&lst);
ListPushFront(&lst, 1);
printList(&lst);
ListPushFront(&lst, 2);
printList(&lst);
ListPushFront(&lst, 3);
printList(&lst);
ListPushFront(&lst, 4);
printList(&lst);
ListPopFront(&lst);
printList(&lst);
ListPopFront(&lst);
printList(&lst);
ListPopFront(&lst);
printList(&lst);
/*ListPopBack(&lst);
printList(&lst);
ListPopBack(&lst);
printList(&lst);
ListPopBack(&lst);
printList(&lst);
ListPopBack(&lst);
printList(&lst);*/
}
int main(){
testata();
system("tauko");
paluu 0;
}
Ero ja yhteys sekvenssiluettelon ja linkitetyn luettelon välillä:
Sekvenssitaulukon edut ja haitat: Erinomainen: Tila on jatkuva, tukee satunnaiskäyttöä, sillä on korkea tilankäyttö, eikä se todennäköisesti aiheuta muistin pirstoutumista, ja sillä on korkea hännän lisäys- ja hännänpoistotehokkuus.
Haitat: 1. Keski- tai etuosan lisäämisen ja poistamisen aika monimutkaisuus on O(N) 2. Kapasiteetin laajentamiskustannukset ovat suhteellisen korkeat: hae kopion vapauttamista
Linkitettyjen luetteloiden edut ja haitat (johtineet kaksisuuntaiset satunnaiset linkitetyt luettelot)
Edut: 1. Lisäyksen ja poistamisen aika monimutkaisuus missä tahansa kohdassa on O(1) 2. Kapasiteetin laajentamiseen ei ole ongelmaa, yhden lisääminen avaa tilaa ja lisäämisen ja poistamisen tehokkuus missä tahansa kohdassa on korkea
Haitat: Se on tallennettu solmuyksiköihin, ei tue satunnaiskäyttöä ja alhainen tilankäyttö voi helposti aiheuttaa muistin pirstoutumista.
pinot ja jonot
Pino: Erityinen lineaarinen luettelo, joka sallii elementtien lisäämisen ja poistamisen vain toisessa päässä. Päätä, jossa tietojen lisäys- ja poistotoiminnot suoritetaan, kutsutaan pinon yläpääksi ja toista päätä kutsutaan pinon alaosaksi pinossa noudattaa LIFO-periaatetta (last in first out).
Pinon työntäminen: Pinon lisäystoimintoa kutsutaan push/push/push, ja lisätyt tiedot ovat pinon päällä
Pop: Pinon poistotoimintoa kutsutaan poppingiksi, ja poksattavat tiedot ovat myös pinon päällä.
Push-operaation toteutus push--->varasto elementtejä pinon yläosasta
Järjestystaulukko: Sitä voidaan pitää hännän lisäysoperaationa
Linkitetty luettelo: (kaksisuuntainen pyöreä linkitetty luettelo) luettelon yläosaa pidetään pinon yläpäänä, joka on otsikon lisäys, ja luettelon loppuosaa pidetään pinon yläpäänä, joka on hännän asettaminen.
Pop-toiminto pop--->poista elementit pinon yläosasta
Järjestystaulukko: Taulukon loppua pidetään pinon yläosana ja sitä pidetään tail delete -operaationa.
Linkitetty lista: (kaksisuuntainen pyöreä linkitetty luettelo) listan yläosaa pidetään pinon yläpäänä, mikä on otsikon poisto, ja luettelon loppuosaa pidetään pinon yläpäänä, joka on hännän poisto.
#sisältää<stdio.h>
#sisältää<stdlib.h>
typedef int STDataType;
//Sekvenssitaulukko toteuttaa pinon
typedef struct pino{
STDataType* _data;
int _size;
int _kapasiteetti;
}pino;
void stackInit(pino* st){
jos (st == NULL)
palata;
st->_data = NULL;
st->_koko = st->_kapasiteetti = 0;
}
void checkCapcacity(pino* st){
if (st->_size == st->_capacity){
int newCapcacity = st->_capacity == 0 ? 1 : 2 * st->_kapasiteetti;
st->_data = (STDataType*)realloc(st->_data, sizeof(STDataType)* newCapcacity);
st->_kapasiteetti = uusi Kapasiteetti;
}
}
//Paina pinoamaan
void stackPush(pino* st, STDataType val){
jos (st == NULL)
palata;
checkCapacity(st);
//Hännän lisäys
st->_data[st->_size++] = arvo;
}
//pop
void stackPop(pino* st){
jos (st == NULL)
palata;
jos (st->_size > 0)
st->_size--;
}
STDataType pinoTop(pino* st){
palauttaa st->_data[st->_size - 1];
}
int stackSize(pino* st){
jos (st == NULL)
paluu 0;
return st->_size;
}
void testi(){
pino st;
stackInit(&st);
stackPush(&st, 1);
stackPush(&st, 2);
stackPush(&st, 3);
stackPush(&st, 4);
for (int i = 0; i < 4; ++i){
printg("%d", pinoTop(&st));
stackPop(&st);
}
printf("n");
}
int main(){
testata();
system("tauko");
paluu 0;
}
Hän on omistautunut teknologian tutkimukselle yli 30 vuoden ajan ja hallitsee useita kieliä, kuten java, linux, javascript, php, css jne. Hän on tehnyt paljon työtä avoimen lähdekoodin alalla Kehittäjän dokumentaatioasema, jossa voit jakaa joitakin teknologian kehittämisen ongelmia myöhempää käyttöä varten
