最近做一个低功耗的传感器探头项目，是基于TI的MSP430的16位单片机开发，内存才2K。
要做数据结构处理的时候，很不方便，所以手写了一些链表的函数，动态内存分配，动态删减链表，以便达到内存最大程度的利用。

跟普通的链表不一样地方是：

  1. 该链表的长度是动态的，动态的添加和删除。
  2. 该链表的表头head是固定的，不可删除。

头文件

别忘了malloc的头文件是#include “stdlib.h”

#include "stdlib.h"

typedef struct 对象

typedef struct Link{
	float value;
	struct Link *next;
}List;

新建节点

List *creat_node(){
	List *node;
	node = (List*)malloc(sizeof(List));
	if(node==NULL){
		printf("malloc fail!\r\n");
	}
	node->next = NULL;
	return node;
}

插入节点

//node3 insert head->node2->node1
//head->node3->node2->node1
void insert_node(List *head, List *node){
	node->next = head->next;
	head->next = node;
}

新建节点并插入节点

List *insert_creat_node(List *head){
	List *node = creat_node();
	node->next = head->next;
	head->next = node;
	return node;
}

删除节点

void delete(List *head, List *node){
	List *l = head;
	while(l->next != NULL){
		if(l->next == node){
			l->next = node->next;
			free(node);
			break;
		}
		l = l->next;
	}
}

获取节点长度

int get_length(List *head){
	List *l = head->next;
	int length = 0;
	while(l != NULL){
		length++;
		l = l->next;
	}
	return length;
}

获取链表的平均数

float get_average(List *head){
	List *l = head->next;
	float value = 0;
	int length = 0;
	while(l != NULL){
		value += l->value;
		l = l->next;
		length++;
	}
	value /= length;
	return value;
}

删除链表中最大值的节点

void delete_max(List *head){
	List *l = head->next;
	List *max_node = l;
	while(l != NULL){
		if(l->value > max_node->value){
			max_node = l;
		}
		l = l->next;
	}
	delete(head, max_node);
}

获取链表中最大值的节点

List *get_max(List *head){
	List *l = head->next;
	List *max_node = l;
	while(l != NULL){
		if(l->value > max_node->value){
			max_node = l;
		}
		l = l->next;
	}
	return max_node;
}

删除链表中最小值的节点

void delete_min(List *head){
	List *l = head->next;
	List *min_node = l;
	while(l != NULL){
		if(l->value < min_node->value){
			min_node = l;
		}
		l = l->next;
	}
	delete(head, min_node);
}

获取链表中最小值的节点

List *get_min(List *head){
	List *l = head->next;
	List *min_node = l;
	while(l != NULL){
		if(l->value < min_node->value){
			min_node = l;
		}
		l = l->next;
	}
	return min_node;
}