链表初识（笔记）

可变数组
数组在程序运行时，数组的元素个数是无法被改变的，即无法在程序运行的同时也对数组进行自动扩容，利用C语言的指针以及结构，可以初步实现这种功能
例如下列代码

/*
可无限读入整数，且不断自行增长的函数
*/
#include <stdio.h>
#include <stdlib.h>
//#include <array.h>

int const BLOCK_SIZE = 20;

typedef struct {
	int *array;
	int size;
} Array;//定义一种结构类型（或者说变量类型），名称为Array，在后面可以利用这种类型进行定义结构变量，例如Array a，表示定义了一个变量a，类型为Array

Array array_create(int init_size) //返回一个Array，函数的参数是数组的大小
{
	Array a;
	a.array = (int*)malloc(sizeof(int)*init_size);//对结构a中的指针array进行操作，即
	//创建一个数组，利用malloc进行内存空间的申请，空间所能容纳的数据量为init_size
	a.size = init_size;//将函数中数组的大小赋值
	
	return a;//此时返回的是结构本身，返回的是数值，返回后函数内的所有本地变量都被计算机回收，**但是函数中申请的那块内存空间不会被回收，因为这个内存空间需要利用free进行释放
	//上述表述不理解，待思考**
	//此时array是一个数组 
}
/*
返回类型是一个array类型的本身，因为是本地变量，
不能返回函数中定义的指针（指针指向的变量在释放后，再通过指针来找的时候就找不到了）（但是可以返回函数中定义的变量，因为通俗的说该变量在释放前，已经被返回并在主函数中保存了。）
当用数组来保存字符串的时候,是放在栈中的,当函数执行完毕就释放了.（所以返回后，这个函数释放，在main函数中就取不到了）
*/
void array_free(Array *a) //释放a中的array 
{
	free(a->array);
	a->array = NULL;// 防止别人调用两次，free（0）和free（NULL）无害
	a->size = 0;//防止别人调用两次 
}
//封装，保护内部的实现细节 
int array_size(const Array *a)
{
	return a->size;
}

int* array_at(Array *a, int index)//返回类型是指针，在此函数的内部，会有判断所写入的数据是否越界的条件
{
	void array_inflate(Array *a, int more_size);
	 
	if ( index >= a->size ) {    //某一时刻发现越界，会自动调用此函数 
		array_inflate(a, (index/BLOCK_SIZE+1)*BLOCK_SIZE-a->size);   //index-a->size+1  表示每次扩充一个 
	}
	return &(a->array[index]);// a->array[index] 得到的是一个int，不是指针 
}

void array_inflate(Array *a, int more_size)
{
	int *p = (int*)malloc(sizeof(int)*(a->size + more_size));  //重新申请了一块内存，其大小是原来内存中的大小再加想增长的大小 
	int i;
	for ( i=0; i<a->size; i++ )
	{
		p[i] = a->array[i];
	}  //上述3行代码段可以用 memcpy 函数进行替换 
	free(a->array);
	a->array = p;
	a->size += more_size; //使其长大 
}

int array_get(const Array *a, int index)
{
	a->array[index];
}

void array_set(Array *a, int index, int value)
{
	a->array[index] = value;
}
//get和set两个函数可以替换下方的*array_at(&a, 0) = 0;
int main(int argc, char const *argv[])
{
	Array a = array_create(100);
	printf("%d\n", array_size(&a));//两行输出效果相同，但是第一种是封装了，保护函数内部的运行机制 
	printf("%d\n", a.size);
	
	*array_at(&a, 0) = 0; //因为前方没有给array赋过值，所以返回指针类型是为了方便在函数中给予赋值 
	//可修改 
	printf("%d\n", *array_at(&a, 0));
	int cnt = 0;
	int number = 0;
	while(number != -1) {
		scanf("%d", &number);
		if ( number != -1 )
			*array_at(&a, cnt++) = number;
		//scanf("%d", array_at(&a, cnt++));
	}
	array_free(&a);
	return 0;
}

上述方法，需要不断地申请空间，再释放空间，但是申请的空间是一片连续的地址，当某一时刻数据量过大，内存中即使存在足够使用的容量，也会无法继续申请了

总有一个时刻，会发现，没有办法再继续申请新的内存空间了

链表（linked-list）类似的如下，将内存中分散的数据连接起来，形成一条链式结构，叫做链表

在实际操作中，链表实际用结构来实现

#ifndef __NODE_H
#define __NODE_H
typedef struct _node {
	int value;     //保存数据的结构
	struct _node *next;//在此处不能直接写为 Node *next;，因为Node在下一行才出现
} Node;//可后期自行定义Node
#endif

创建一个节点元素并形成链表的程序

#include <stdlib.h>
#include <stdio.h>

#ifndef __NODE_H
#define __NODE_H
typedef struct _node {
	int value;     //保存数据的结构
	struct _node *next;//在此处不能直接写为 Node *next;，因为Node在下一行才出现
} Node;//可后期自行定义Node
#endif

int main()
{
	Node *head = NULL;
	int number;
	do{
		scanf("%d", &number);
		if ( number != -1 ) {
			Node *p = (Node*)malloc(sizeof(Node));
			p->value = number;
			p->next = NULL;
			Node *last = head;
			if (last) {
				while( last->next ){
					last = last -> next;
				}
			} else {
				head = p;
			}
		}
	} while( number != -1 );

	return 0;
}