3er Parcial Flashcards
(38 cards)
¿Esta función regresa true si la lista está vacía?
int isListEmpty() {
return head!= NULL;
}
FALSO
para que sea verdadero, necesitaría decir head==NULL;
¿Este código utiliza correctamente malloc?
struct Node *createNewNode(int newData){
struct Node *newNode = malloc(sizeof(struct Node));
newNode->data= newData;
newNode->next=NULL;
free(newNode);
return NULL;
}
FALSO
Se libera free(newNode) antes de que malloc pueda retornarlo y da NULL
¿Es correcto este algoritmo para liberar una lista de memoria?
void freeList() {
struct Node *current = head;
while(current!=NULL){
free(current);
current=current->next;
}
head=NULL;
}
FALSO
¿Es correcto este algoritmo para liberar una lista de memoria?
void freeList() {
struct Node *current = head;
while(current!=NULL){
struct Node *temp =current;
current=current->next;
free(temp);
}
head=NULL;
}
FALSO (chat dice VERDADERO)
¿Esta función regresa true si la lista está vacía?
int isListEmpty() {
return head==NULL|| head->next==NULL;
}
FALSO
¿El apuntador anterior (previous) sigue correctamente al anterior del actual (current)?
void traverseList() {
struct Node *current=head;
while (current!=NULL)
{printf("%d", current->data);
current=current->next;
}
}
FALSO
¿El apuntador anterior (previous) sigue correctamente al anterior del actual (current)?
```void traverseList() {
struct Node *current=head;
struct Node *previous =NULL;
while (current!=NULL)
{
previous = current;
current= current->next;
printf(“%d”, previous->data);
}
}
~~~
VERDADERO
¿El apuntador (previous) sigue correctamente al anteiror del actual (current)?
void traverseList() {
struct Node *current=head;
while (current!=NULL)
{printf("%d", current->data);
current=current->head;
}
FALSO
¿Este código utiliza correctamente malloc?
struct Node *createNewNode(int newData){
struct Node *newNode = malloc(sizeof(struct Node));
if (newNode!=NULL) {
newNode->data=newData;
newNode->next=NULL;
}
return newNode;
}
VERDADERO
¿Es correcto este algoritmo para buscar en una lista?
struct Node *searchNode(int searchData) {
struct Node *current = head;
while(current !=NULL && current->data != searchData) {
current=current->next;
}
return current;
}
VERDADERO
¿Esta definición de estructura define correctamente al apuntador a siguiente nodo?
struct Node {
int data;
struct Node next;
};
FALSO
Falta el apuntador
¿Este algoritmo es correcto para insertar en lista al inicio?
```struct Node{
int data;
struct Node *next; };
struct Node *head=NULL;
void insertAtBeginning(int newData){
struct Node *newNode=malloc(sizeof(struct Node));
newNode->data=newData;
newNode->next=head;
head=newNode;
}```
VERDADERO
¿Este código utiliza correctamente malloc?
struct Node *createNewNode(int newData){
struct Node *newNode = malloc(sizeof(newNode));
newNode->data= newData;
newNode->next=NULL;
return newNode;
}
FALSO
¿Es correcto este algoritmo para liberar una lista de memoria?
~~~
void freeList() {
struct Node *current = head;
while(current!=NULL){
struct Node *temp= current->next;
free(current);
current=temp;
}
head=NULL;
}
~~~
VERDADERO
¿Es correcto este algoritmo para insertar ordenado?
void insertInOrder(int newData) {
struct Node *newNode=malloc(sizeof(struct Node));
newNode->data=newData;
newNode->next=NULL;
struct Node *current = head;
while(current!=NULL && current->next!=NULL) {
current=current->next;
}
current->next=newNode;
}
FALSO
¿El apuntador anterior (previous) sigue correctamente al anterior del actual (current)?
void traverseList() {
struct Node *current=head;
struct Node *previous =head;
while (current!=NULL)
{
printf("%d", current->data);
current=previous->next;
previous=current;
}
}
FALSO
¿Es correcto este algoritmo para insertar ordenado?
void insertInOrder(int newData) {
struct Node *newNode=malloc(sizeof(struct Node));
newNode->data=newData;
newNode->next=head;
head=newNode;
}
FALSO
¿Es correcto este algoritmo para insertar en lista al final?
void insertAtEnd(int newData)
{ struct Node *newNode = malloc(sizeof(struct Node));
newNode->data=newData;
newNode->next= head->next;
head->next=newNode;
FALSO
¿Es correcto este algoritmo para insertar en lista al final?
void insertAtEnd(int newData) {
struct Node *newNode = malloc(siezeof(struct Node));
newNode->data =newData;
newNode->next=head;
head=newNode;
}
FALSO
¿Es correcto este algoritmo para buscar en una lista?
struct Node *searchNode(int searchData) {
struct Node *current = head;
while(current !=NULL= {
if(current->data>searchData){
return current;
}
current=current->next;
}
return NULL;
}
FALSO
¿Esta función regresa true si la lista está vacía?
int isListEmpty() {
return head!= NULL;
}
FALSO
¿Este algoritmo Bubblesort es correcto?
~~~
void bubbleSort (int arr[], int n) {
for (int i =0; i<n-1; i++) {
for (int j=0; j<n-i-1; j++) {
if(arr[j]>arr[j+1]) {
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}}}}
~~~
VERDADERO
¿Es correcto este algoritmo para liberar una lista en memoria?
void freeList(){
if(head==NULL) {
return;
}
struct node *current =head;
struct Node *nextNode =NULL;
while {current!=NULL){
nextNode=current->next;
free(current);
current=nextNode;
}
head=NULL;
}
VERDADERO
¿Esta función regresa true si la lista está vacía?
~~~
int isListEmpty(){
return head==NULL;
}
~~~
VERDADERO
