C语言：边界标志法

---

1 边界标志法

动态内存管理，双向循环链表

• 首次拟合法
  链表中查找第一个能满足要求的内存块，进行分配，时间复杂度O(n)
  回收内存时，直接从头部插入，时间复杂度O(1)。（链表无序）
• 最佳拟合法
  链表中查找第一个满足要求且适合的内存块（即，满足分配要求，且多出部分剩余最少），进行分配，时间复杂度O(n)。
  （最佳拟合法尽量使用从小到大有序的链表，此时查找次数为n/2）
  回收内存时，仍需使链表有序，时间复杂度O(n)。
  内存碎片，两极分化，适合内存块分布较广。
• 最差拟合法
  链表中查找第一个满足要求且富余的内存块（即，满足分配要求，且多出部分剩余最多），进行分配。
  （最佳拟合法尽量使用从大到小有序的链表，时间复杂度O(1)）
  回收内存时，仍需使链表有序，时间复杂度O(n)
  内存均匀，适合内存块大小范围变化不大。

2 C语言实现

2.1 头文件

#pragma once
#define MEM_SIZE 1024
#define e 10//定义误差

typedef struct Word//定义双向循环链表节点
{
	union //头尾信息属于同一个结构体，联合体内共用地址，区分两个前驱名称
	{
		struct Word* llink;//头信息的前驱
		struct Word* uplink;//尾信息的前驱
	};
	int tag;//0为空闲，1为占用
	int size;//大小包含头尾
	struct Word* rlink;//头信息的后继
}Word,*Space;//内存单元

#define FootLoc(p) (p+p->size-1)//求尾信息节点

Space CreateMem();//创建内存池

Space AllocBoundTag(Space *pav, int n);//分配内存单元

void Free(Space* pav, Space p);//回收内存

2.2 创建内存池

#include"boundary.h"
#include 
#include 

Space CreateMem()
{
	Word* pmem = (Word*)malloc(MEM_SIZE * sizeof(Word));//创建内存池
	assert(pmem != NULL);

	
	pmem->llink = pmem;
	pmem->rlink = pmem;
	pmem->tag = 0;
	pmem->size = MEM_SIZE;

	FootLoc(pmem)->uplink = pmem;
	FootLoc(pmem)->tag = 0;

	return pmem;
}

2.3 分配内存单元

Space AllocBoundTag(Space *pav, int n)
{
	if (pav == NULL || *pav == NULL)
	{
		return NULL;
	}

	Word* p = *pav;
	do//先执行一次，避免第二个内存单元的rlink指向内存池头部pav的问题
	{
		if (p->size >= n)
		{
			break;
		}
		p = p->rlink;
	} while (p != *pav);

	if (p->size >= n)
	{
		*pav = p->rlink;//将原内存池头部指向下一个内存单元

		if (p->size - n <= e)//所需空间大小与该内存单元大小在误差范围内，将其全部分配
		{
			if (p->rlink == p)//只有一个内存单元时，分配后需要将原内存池置空，所以需要传入指针的地址
			{
				*pav = NULL;
			}
			p->llink->rlink = p->rlink;
			p->rlink->llink = p->llink;
			p->tag = 1;
			FootLoc(p)->tag = 1;

			return p;
		}

		else//从该内存单元的高地址分配
		{
			p->size -= n;
			FootLoc(p)->uplink = p;//新的尾信息
			FootLoc(p)->tag = 0;

			Word* q = FootLoc(p) + 1;//分配出去的内存单元
			q->size = n;
			q->tag = 1;
			FootLoc(q)->uplink = q;
			FootLoc(q)->tag = 1;

			return q;
		}
	}

	return NULL;
}

2.4 回收内存

void Free(Space* pav, Space p) 
{
	Space left;
	Space right;

	if (*pav == NULL)//该内存池为空
	{
		p->tag = 0;//将p内存单元状态转换为空闲
		FootLoc(p)->tag = 0;
		FootLoc(p)->uplink = p;

		*pav = p;
		p->llink = p;
		p->rlink = p;
	}

	//通过p内存单元的实际左的后继信息，实际右的前驱信息，进行判断
	else if ((p - 1)->tag != 0 && (FootLoc(p) + 1)->tag != 0)//左右都不为空，简单插入在内存池头部单元pav的左边
	{
		p->tag = 0;//将p内存单元状态转换为空闲
		FootLoc(p)->tag = 0;
		FootLoc(p)->uplink = p;

		left = (*pav)->llink;

		left->rlink = p;
		p->llink = left;

		p->rlink = *pav;
		(*pav)->llink = p;
	}

	else if ((p - 1)->tag == 0 && (FootLoc(p) + 1)->tag != 0)//左空，右不为空，和p的实际左边合并
	{
		left = (p - 1)->uplink;

		left->size += p->size;//与实际左边内存单元合并
		FootLoc(p)->uplink = left;
		FootLoc(p)->tag = 0;
	}

	else if ((p - 1)->tag != 0 && (FootLoc(p) + 1)->tag == 0)//左不为空，右空，和p的右边合并
	{
		right = (FootLoc(p) + 1);

		//将p的实际右边内存单元从内存池中删除

		right->llink->rlink = right->rlink;
		right->rlink->llink = right->llink;

		//与实际右边内存单元合并
		p->size += right->size;
		FootLoc(right)->uplink = p;

		//插入到内存池头部单元pav的左边
		left = (*pav)->llink;

		p->tag = 0;
		left->rlink = p;
		p->llink = left;

		p->rlink = (*pav);
		(*pav)->llink = p;
	}

	else//左右都空，将三个实际内存单元合并
	{
		left = (p - 1)->uplink;
		right = FootLoc(p) + 1;

		//将p的实际右边内存单元从内存池中删除
		if (right == *pav)//如果right是内存池头部pav指向的内存单元
		{
			*pav = left;
		}
		right->llink->rlink = right->rlink;
		right->rlink->llink = right->llink;
		

		//将三个实际内存单元合并
		left->size = left->size + p->size + right->size;
		FootLoc(right)->uplink = left;
	}

}

2.5 测试

#include"boundary.h"
#include 

void Show(Space *arr,int len)//输出占用内存情况
{
	printf("占用内存:\n\n");
	for (int i = 0; i < len; i++)
	{

		if (arr[i] != NULL)
		{
			printf("起始地址：%p，内存大小：%d，状态：%d\n\n", arr[i], arr[i]->size, FootLoc(arr[i])->tag);
		}
	}
}
void Show0(Space pav)//输出空闲内存情况
{
	Space p = pav;
	if (pav != NULL)
	{
		printf("空闲内存:\n\n");
		
		do
		{
			printf("起始地址：%p，内存大小：%d，结束地址：%p，状态：%d\n\n", p, p->size, FootLoc(p) + 1, p->tag);
			p = p->rlink;
		} while (p != pav);
	}
	
}
int main()
{
	
	Space pav = CreateMem();
	//Show0(pav);

	Space usedarr[10] = {};
	usedarr[0] = AllocBoundTag(&pav, 100);
	usedarr[1] = AllocBoundTag(&pav, 400);
	usedarr[2] = AllocBoundTag(&pav, 200);
	usedarr[3] = AllocBoundTag(&pav, 300);
	usedarr[4] = AllocBoundTag(&pav, 100);
	usedarr[4] = AllocBoundTag(&pav, 20);

	Show0(pav);
	Show(usedarr, sizeof(usedarr)/sizeof(usedarr[0]));

	printf("\n-----------------------------------\n");

	Free(&pav, usedarr[0]);//第一次回收
	usedarr[0] = NULL;
    Free(&pav, usedarr[3]);//左右都不空
	usedarr[3] = NULL;
	Free(&pav, usedarr[2]);//左空
	usedarr[2] = NULL;
	Free(&pav, usedarr[4]);//右空
	usedarr[4] = NULL;
	Free(&pav, usedarr[1]);//左右都空
	usedarr[1] = NULL;

	Show0(pav);
	Show(usedarr, sizeof(usedarr) / sizeof(usedarr[0]));

	free(pav);//全部回收才能释放内存池
	pav = NULL;

	return 0;
}