ARM_C Advanced Study Notes (xiii) la introducción de la lista, y el nodo de recorrido de inserción

La introducción de (a) la lista

1. A partir de los defectos de la matriz

1. Matriz tiene dos defectos, uno de todos los elementos de la matriz debe ser el mismo, y el segundo es el número de elementos de la matriz debe ser establecido de antemano y no se puede cambiar una vez especificado.
2. ¿Cómo resolver la matriz dos defectos: La primera falla por la estructura de matriz de resolver. Estructura permite que los elementos en el mismo no son del mismo tipo, la resolución de este modo un defecto de la matriz. Por lo que la estructura es debido a que la matriz no puede resolver algunos de los problemas por lo que acaba de invención.
3. ¿Cómo resolver la segunda matriz defecto? Esperamos ampliar el tamaño de la matriz en tiempo real. Por ejemplo, sólo empecé a establecer un número de elementos es 10, entonces eso no es suficiente, por lo tanto ampliarse de forma dinámica a 20. La matriz común Obviamente no, podemos encapsular la matriz con el fin de lograr el propósito de este programa se está ejecutando; también podemos utilizar un nuevo estructura de datos para resolver, esta nueva estructura de datos es una lista enlazada.
4. Resumen: Casi se puede entender: la lista es el número de elementos en un tiempo real de matriz grande / pequeña.

2. ¿Qué tipo de lista?

1. Como su nombre indica, es una lista enlazada de mesa se une a una cadena. Tabla este documento se refiere a un nodo de un nodo tiene algo de memoria para almacenar datos (denominada tabla, la tabla es la tabla de datos); en el presente documento se refiere a un eslabón de la cadena cada método de la tabla, el lenguaje C se utiliza para conectar tabla 2 (de hecho, dos de memoria) método es un puntero.
2. Cadena se compone de varios nodos (la estructura lista de nodos vinculados respectivo es completamente análogo),punteros a nodos y los datos válidos se compone de. Siguiente área de datos de nodo para almacenar la información de la tarea, la lista de punteros para apuntar a la región para constituir la lista.

3. No olvidar el momento en la lista se utiliza para hacer

1. Siempre tener en cuenta:La lista se utiliza para resolver la expansión dinámica del tamaño de la matriz no es un problema, por lo que la lista es en realidad cuando se utiliza la matriz. Sin rodeos: la lista podría completar la tarea puede ser completada por la matriz, la matriz se puede completar con una lista de tareas puede ser completada. Sin embargo, la flexibilidad no es la misma.
2. En pocas palabras: la lista se utiliza para almacenar datos. Lista utilizado para mantener los datos relativos a la serie de ventajas es la flexibilidad que necesita para asignar dinámicamente el número de cuántos, no ocupan memoria adicional. Ventaja de la matriz es simple de usar (simple y en bruto).

(Parte dos) lista única

1. La lista única de nodos que constituyen

1. Es una lista de nodos, comprendiendo el nodo: un puntero de datos válidos y.
2. La definición de nodo de estructura es sólo una estructura, la variable que no generan ni consumen memoria. Estructura se define como la capacidad de definir una plantilla de nodo de la lista, pero no es un nodo, un nodo cuando sea necesario en el futuro para utilizar esta plantilla cuando en realidad crear una lista enlazada se puede copiar.

2. La aplicación y uso de la memoria de pila

1. Lista de requisitos de memoria más flexibles, no pueden utilizar la pila y no pueden conseguir segmento de datos.Sólo utilice la pila de memoria.
2. Para utilizar la memoria de pila para crear una lista de nodos: 1, el tamaño de la memoria pila de aplicación es el tamaño de un nodo (comprobar el resultado de la aplicación es correcta); 2, se aplican para limpiar la memoria de pila; 3, para aplicar a la memoria de pila como un nuevo nodo; 4, los datos válidos se llena y la región puntero Oh nuevo nodo.

3. La lista de punteros de cabeza

1. Nodo no es un puntero cabeza, pero un puntero normal, sólo 4 bytes. Cabeza tipo de puntero es struct node * Tipo, por lo que puede apuntar a la lista de nodos.
2. Una aplicación típica de una lista enlazada es: un puntero de cabeza a una lista enlazada de nodos, el primer nodo y el puntero al siguiente nodo, y así sucesivamente hasta el último nodo. Esto constituye una cadena.

4. El acceso a los datos de cada nodo en la lista

1. Sólo con el puntero de cabeza, no puede usar sus manos cada nodo. Debido a que en la práctica se guarda la lista no se guarda cuando el puntero de cada nodo, nodo de la lista sólo se puede acceder por el puntero de cabeza.
2. En el interior del puntero del nodo anterior pNext puede ayudarnos a encontrar el siguiente nodo.

5. combate: Construcción de un sencillo de una sola cadena

1. Objetivos: construir una lista, algunos datos (por ejemplo, tres dígitos 1,2,3) y almacenados en la lista enlazada

/*
* 描述：创建单链表
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//链表结构体
struct node
{
	int data;             // 有效数据
	struct node *pNext;   // 指向下一个节点的指针
};

int main(void)
{
	//第一步：定义并初始化头指针
	struct node *pHeader = NULL;      
//***********************************************************************	
//创建第一个节点
//***********************************************************************	
	//第二步：申请堆内存，创建节点
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if(NULL == p)
	{
		printf("malloc error.\n");
		return -1;
	}
	// 清理申请到的堆内存
	memset(p, 0 , sizeof(struct node)); 
	// 填充节点
	p->data = 1;                        
	p->pNext = NULL;
	
	//第三步：将本节点和它前面的头指针(节点)关联起来	
	pHeader = p;
//***********************************************************************	
//创建第二个节点
//***********************************************************************
	struct node *p1 = (struct node *)malloc(sizeof(struct node));
	if(NULL == p1)
	{
		printf("malloc error.\n");
		return -1;
	}
	memset(p1, 0 , sizeof(struct node));
	p1->data = 2;
	p1->pNext = NULL;
	p->pNext = p1;
//***********************************************************************	
//创建第三个节点
//***********************************************************************
	struct node *p2 = (struct node *)malloc(sizeof(struct node));
	if(NULL == p2)
	{
		printf("malloc error.\n");
		return -1;
	}
	memset(p2, 0 , sizeof(struct node));
	p2->data = 3;
	p2->pNext = NULL;
	p1->pNext = p2;
//***********************************************************************

//打印节点中的数据
	printf("p->data = %d.\n", pHeader->data);
	printf("p1->data = %d.\n", pHeader->pNext->data);
	printf("p2->data = %d.\n", pHeader->pNext->pNext->data);

	return 0;
}

6. Crear un nodo encapsulado en código de función

struct node *create_node(int data)
{
	struct node *p = (struct node *)malloc(sizeof(struct node));
	if(NULL == p)
	{
		printf("malloc error.\n");
		return NULL;
	}
	memset(p, 0 , sizeof(struct node));
	p->data = data;
	p->pNext = NULL;
	return p;
}

• llamada a la función
  

(C) algoritmo de cadena única - el nodo de inserción

1. Insertar un nuevo nodo de la cola de la lista

/*
* 描述：尾部插入新节点函数
*/
void insert_tail(struct node *pH, struct node *new)
{
	struct node * p = pH;
	//第一步：查找到最后一个节点
	while(NULL != p->pNext)
	{
		p = p->Next;
	}
	//第二步：插入新的节点
	p->Next = new;
}

• llamada a la función
  

1. La introducción del nodo de cabecera

1. ¿Cuál es el nodo principal

1. problema:Debido a que tenemos un puntero nodo principal tácitamente directa en insert_tail, por lo que si el programa de definir directamente el puntero de cabeza después del segmento dependerá directamente de error insert_tail. Tenemos que definir el puntero de cabeza después de la primera create_node crear un nuevo nodo al puntero de cabeza se inicializa, o no se puede evitar este error, sin embargo resuelto para crear el primer nodo atrás miradas de nodos y dejar que la lógica del programa se ve un poco menos suave, porque , añadir un poco diferente.
   
2. Hay otra lista de uso, el primer nodo se utiliza como un puntero de cabecera al nodo de cabeza.Características del nodo principal es: primero , inmediatamente detrás del puntero de cabeza. En segundo lugar , la parte de datos del nodo de cabeza está vacía (y, a veces no está vacío, sino a toda la lista de nodos de almacenamiento), un puntero apunta al siguiente nodo porción, que es el primer nodo.
3. Parecería que el nodo de cabeza y otros nodos en diferente de hecho. Nuestro método para añadir un nodo cuando se crea una lista enlazada es diferente. Junto con el primer nodo crea tras puntero de cabeza y el puntero de cabeza y asociados; cierto nodo de almacenamiento de datos nodo detrás de una función añadida a tales insert_tail completa,.
4. No hay ningún nodo de la lista cabeza es diferente. Reflejada en la lista de nodos de inserción, nodos de eliminar, nodos que atraviesan, cada análisis sintáctico lista de funciones algoritmo es diferente. Así que si hay una lista del algoritmo de diseño detrás del nodo principal a continuación, todo esto debe ser manejado, si no existe un diseño nodo principal, todos los algoritmos detrás deben hacerse de acuerdo con ningún nodo principal.Debe prestar atención para ver si no tiene un nodo principal de programación real cuando hay personas con una lista de dos, por lo que nos fijamos en el código escrito por otra persona.
   

2. Introducir el nuevo nodo de cabecera de la lista

/*
* 描述：头部插入链表节点函数
*/
void insert_head(struct node *pH, struct node *new)
{
	//第一步：先将原来的第一个节点指向新插入的节点的尾部
	new->pNext = pH->pNext;
	
	//第二步：再将新节点插入头节点的尾部
	pH->pNext = new;
	
	//头节点计数节点个数加一	
	pH->data += 1;
}

(D) una sola lista de algoritmos - nodo Traverse

1. ¿Qué es atravesada

1. Es para atravesar una única lista en cada nodo de uno en uno, llamado de recorrido.
2. Puntos de recorrido: no se puede perder, y en segundo lugar, no se puede repetir, la búsqueda de la eficiencia.

2. ¿Cómo la lista de enlace simple recorrido

1. Cómo analizar un recorrido estructura de datos, la clave es analizar las características de esta estructura de datos en sí. Luego de desarrollar de acuerdo a su algoritmo de recorrido de características propias.
2. de cadena sencilla se caracteriza por un número de nodos, el primer nodo como una cabeza de partida puntero + lista entera, y el último nodo se caracteriza porque el valor del puntero pNext interna es NULL. Desde el principio hasta el final de la media para montar el puntero pNext respectivos nodos internos. Desde el principio hasta el final y sólo un camino. Estas características por sí solas determinar sus algoritmos de recorrido de lista.
3. métodos Traversal: Ab + nodo de cabecera de puntero aperturas, cada nodo a lo largo del gancho de la cadena acceso secuencialmente el puntero lista de los datos del nodo extraída, y luego hacia abajo un nodo, hasta el último nodo, el final de la vuelta.

3. Ejemplos de función de salto de

• función Traversal 1

void bianli(struct node *pH)
{
	struct node *p = pH->pNext;
	int count = 0;
	printf("-------------------链表遍历开始-------------------------\n");
	while(NULL != p->pNext)
	{
		count++;
		printf("node%d = %d.\n", count, p->data);
		p = p->pNext;
	}
	printf("node%d = %d.\n", count + 1, p->data);
	printf("-------------------链表遍历结束-------------------------\n");
}

• función Traversal 2

void bianli2(struct node *pH)
{
	struct node *p = pH;
	int count = 0;
	printf("-------------------链表遍历开始-------------------------\n");
	while(NULL != p->pNext)
	{
		count++;
		p = p->pNext;
		printf("node%d = %d.\n", count, p->data);
	}
	printf("-------------------链表遍历结束-------------------------\n");
}

• Las llamadas a funciones y resultados operativos