【操作系统】Link.cpp

/************************************************************************/
/* 功能：  模拟实现可变分区存储管理的最佳适应算法的链表类
时间：2014年9月1日21:57:21
作者：信管1201 1205020116  肖锋										*/
/************************************************************************/



#include "Link.h"
#include <iostream>

using namespace std;

//freeLink的定义实现

//void swap(int index1, int index2);	//交换连个节点的信息
void freeLink::swap(int index1, int index2)
{
	//交换这两个索引节点的所有信息
	int i = 0;
	Node* p1 = head;
	while (i < index1)
	{
		p1 = p1->next;
		++i;
	}

	int j = 0;
	Node* p2 = head;
	while (j < index2)
	{
		p2 = p2->next;
		++j;
	}

	//p1和p2指向两个不同的节点，将要交换这两个节点，但是链表的位置不变
	int size = p2->size;
	int adress = p2->adress;
	p2->size = p1->size;
	p2->adress = p1->adress;
	
	p1->size = size;
	p1->adress = adress;
}

//Node* getNode(int index);
freeLink::Node* freeLink::getNode(int index)
{
	int i = 0;
	Node* p=head;
	while (i < index)
	{
		p = p->next;
		++i;
	}

	return p;
}

//给自由链表前后的合并分区，循环首次适应算法
//void pingJie2();
void freeLink::pingJie2()
{
	//首先把链表按照地址的大小排序
	//冒泡排序
	int count = 0;
	Node* p = head;
	while (p != tail)
	{
		p = p->next;
		++count;
	}

	//冒泡排序，吧链表按地址递增的方式存放
	for (int i = 1; i <= count; ++i)
	{
		for (int j = 1; j <= count - i; ++j)
		{
			Node *p1, *p2;
			p1 = getNode(j);
			p2 = getNode(j + 1);
			if (p1->adress > p2->adress)
			{
				swap(j, j + 1);
			}
		}
	}

	//排序完成之后考虑是否要合并
	//考虑4种情况
	Node *p1, *p2, *p3;
	if (count == 1)
		return;	//只有一个空闲的节点还合并个屁啊
	else if (count == 2)
	{//如果只有两个空闲的节点的话，那么就直接考虑向后合并
		p1 = head->next;
		p2 = p1->next;
		if ((p1->adress + p1->size) == p2->adress)
		{//如果成立就直接合并这两个节点
			p1->size += p2->size;	//吧容量合并到p1上
			delete p2;
			p1->next = nullptr;
			tail = p1;
		}
	}
	else //这就一般的情况，那就要考虑四种情况了
	{
		p1 = head->next;
		p2 = p1->next;
		p3 = p2->next;	//指向前三个，以p2为操作对象，进行判断
		//一直判断到链表尾部
		while (p3 != nullptr)
		{
			if ((p1->adress + p1->size) == p2->adress || (p2->adress + p2->size) == p3->adress)	//要么前向，要么后巷，或者全要
			{
				if ((p1->adress + p1->size) == p2->adress && (p2->adress + p2->size) != p3->adress)
				{//前向
					//吧p2去除掉合并到p1里面去
					p1->size += p2->size;
					//去除p2,不用考虑为节点
					p1->next = p3;
					delete p2;
					p2 = p3;
					p3 = p2->next;
				}
				else if ((p1->adress + p1->size) != p2->adress && (p2->adress + p2->size) == p3->adress)
				{//向后合并
					//吧p3去掉合并到p2里面去,这个要考虑尾部节点
					p2->size += p3->size;
					if (p3 == tail)
					{//去除p3
						tail = p2;
						delete p3;
						p3 == nullptr;
					}
					else
					{
						p2->next = p3->next;
						delete p3;
						p3 = p2->next;
					}
				}
				else if ((p1->adress + p1->size) == p2->adress && (p2->adress + p2->size) == p3->adress)
				{//前后一起合并，去除p2,p3,考虑尾部节点
					p1->size += p2->size + p3->size;
					if (p3 == tail)
					{
						tail = p1;
						p1->next = nullptr;
						delete p2, p3;
						p3 = nullptr;
					}
				}
				else
				{//什么也不干的类型
					//移动一位
					p1 = p2;
					p2 = p3;
					p3 = p3->next;	//整体下移一位
				}
			}
		}
	}
}

//首次循环适应算法的添加，就是尾部添加
//void addNode2(gSize, gAdress)
void freeLink::addNode2(int size, int adress)
{
	//直接尾部插入这个回收的节点
	//这块内存的起始地址
	Node* newNode = new Node(size, adress, 'O', nullptr);
	tail->next = newNode;
	tail = newNode;   //添加到尾部
}

//循环首次适应
//void setNeed(int index);
void freeLink::setNeed(int index, int size)
{
	Node* p;
	Node* p2;   //就是要返回的索引对象
	p = p2 = head->next;
	int i = 1;
	while (i < index)
	{
		p = p2;
		p2 = p2->next;
		++i;
	}

	p2->size -= size;   //把对应的空闲区间的大小修改
	p2->adress += size;  //新的起始地址

	if (p2->size == 0)
	{
		if (p2 == tail)
		{
			//重置尾节点，并且去除大小为0的节点
			delete p2;
			p->next = nullptr;
			tail = p;
		}
		else
		{
			//不是尾部节点，就直接去除大小为0的节点就可以了
			p->next = p2->next;
			delete p2;
		}
	}
}

//删除尾部节点的函数
//void popTail();
void freeLink::popTail()
{
	//要去除尾部节点，就要重新给tail定位
	Node* p;
	Node* p2;
	p = head;
	p2 = p->next;
	while (p2 != tail)
	{
		p = p2;
		p2 = p2->next;    //循环直到指向最后一个
	}
	//此时p2指向tail
	tail = p;
	delete p2;
	tail->next = nullptr;
}

//合并全部空闲的节点
//void heBing();
void freeLink::heBing(int allFreeAdress)
{
	Node* p;
	Node* p2;
	p = head;
	p2 = p->next;
	int allFreeSize = 0;  //统计所有的空闲区间的大小
	//int allFreeAdress=0;    //得到新的起始地址
	while (head != tail)
	{
		allFreeSize += tail->size;
		popTail();
	}

	//此时全部的节点都被删除,为空闲分区链添加一个最大的空间
	addNode(allFreeSize, allFreeAdress);
}

//去除对应的节点
//void popNeed(int index);
void freeLink::popNeed(int index)
{
	Node* p;
	Node* p2;   //就是要返回的索引对象
	p = p2 = head->next;
	int i = 1;
	while (i < index)
	{
		p = p2;
		p2 = p2->next;
		++i;
	}

	//去除p2
	p = p2->next;
	delete p2;
}

//得到index部节点的地址
//int getNeedAdress(int index);
int freeLink::getNeedAdress(int index)
{
	Node* p;
	Node* p2;   //就是要返回的索引对象
	p = p2 = head->next;
	int i = 1;
	while (i < index)
	{
		p = p2;
		p2 = p2->next;
		++i;
	}

	return p2->getAdress();
}

//得到第index位的size
//int getNeedSize(int index);
int freeLink::getNeedSize(int index)
{
	Node* p;
	Node* p2;   //就是要返回的索引对象
	p = p2 = head->next;
	int i = 1;
	while (i < index)
	{
		p = p2;
		p2 = p2->next;
		++i;
	}

	return p2->getSize();
}

//找到要修改的节点是第几位]
//int getNeedGai(size);
int freeLink::getNeedGai(int size)
{
	int index = 1;    //返回索引
	Node* p;
	Node* p2;
	p = p2 = head->next;    //p2指向要修改的节点
	while (p2->size < size || p2 == nullptr)
	{
		p = p2;
		p2 = p2->next;
		++index;
	}

	if (p2 == nullptr)
		return 0;

	return index;       //返回当前位置的索引

}

//设置第i个节点
//void setHeadNode(int index, int size, int adress);
void freeLink::setNode(int index, int size, int adress)
{
	Node* p; Node* p2;  //p2指向要修改的节点
	p = head;
	p2 = p->next;
	for (int i = 1; i < index; ++i)
	{
		p = p2;
		p2 = p2->next;    //要修改的对象
	}

	/*
	p2->size = size;
	p2->adress = adress;
	*/
	//吧原来的节点删除，重新插入到正确的位置
	//Node* newPaiXu = new Node(size, adress, 'O', nullptr);
	if (p2 == tail)
	{
		//如果p2是尾节点，那就重置为节点，在插入
		delete p2;
		p->next = nullptr;
		tail = p;
	}
	else
	{
		//不是尾部节点那就直接断
		p->next = p2->next;
		delete p2;
	}
	//插入
	addNode(size, adress);
}

//显示当前的分区
//void show();
void freeLink::show()
{
	Node* p;
	p = head->next;
	cout << "自由分区的链表是(剩余, 起始地址)" << endl;
	while (p != nullptr)
	{
		cout << "(" << p->size << " , " << p->adress << ")->";
		p = p->next;
	}
	cout << endl;
}

//内存地址相同的时候的碎片拼接
//void pingJie();
//2014年9月2日17:03:46有问题
void freeLink::pingJie()
{
	Node* p;
	Node* p2;
	p = head;    //指向头结点
	p2 = p->next;     //指向第一个节点
	//int count=1;
	int qiShiAdress;

	//这样来合并，用起始地址加内存的值在链表中找，是不是有节点的起始和他相同，如果相同就向后合并,遍历整个链表
	while (p2 != nullptr)
	{
		qiShiAdress = p2->adress + p2->size;
		Node* p2_3 = head;
		for (Node* p3 = head->next; p3 != nullptr; p3 = p3->next)    //p2_3指向p3的前面
		{
			if (qiShiAdress == p3->adress)
			{
				//找到了可以合并的那么就直接把这两个节点合并,把找到的这两个去掉重新插入
				int newAdress = p2->adress;
				int newSize = p2->size + p3->size;
				//这里断掉链表要小心不是紧挨着,断开怎么断？
				if (p2->next == p3)
				{
					p->next = p3->next;
				}
				else
				{
					p->next = p2->next;
					p2_3->next = p3->next;
				}

				delete p2, p3;
				p2 = p->next;
				//Node* chaRu=new Node(newSize, newAdress, 'O', nullptr);
				this->addNode(newSize, newAdress);
				qiShiAdress = 0;  //重置，作为标准，以便后面判断是否还要到下一个节点
				break;
			}
			p2_3 = p3;
		}

		if (qiShiAdress != 0)
		{
			p = p2;
			p2 = p2->next;
		}
	}

	/*
	//!2014年9月3日09:19:37
	//这里考虑到保持的时候是从小到大，而拼接是按地址重后到前的排序的
	//把Node按地址的位置重新排序保存的vector里面去
	//先知道一共有多少个节点
	while(p2 != nullptr)
	{
	p=p2;
	p2=p2->next;
	++count;    //当p指向尾节点，那就结束，统计一共有多少个节点
	}

	//重置p,p2
	p=head->next;
	p2=p->next;

	//直到全部按地址递增的方式全部放入到vector里面去

	//然后按地址取出Node，按上面的方式合并

	//找到可以拼接的地方进行拼接
	//while(p2 != nullptr)   //重头找到尾，找到就直接跳出，找不到就到达尾部
	//{//可能有多处要合并不止一处

	if((p->adress+p->size) == p2->adress)
	{
	//如果是末尾的话，要重置尾指针
	if(p2 == tail)
	{
	tail=p;
	}
	//如果有可以合并的区间的话
	//1、吧p的内存大小改变成p和p2的内存和
	p->size+=p2->size;
	//2、吧p的指针指向p2的后面
	p->next=p2->next;
	//3、吧p2断开,然后释放p2
	delete p2;
	}
	p=p2;
	p2=p2->next;

	//}

	//如果是尾部节点的话，那么就是没有可以合并的区间
	if(p == tail)
	{//看是不是只有一个节点
	cout<<"xxx"<<endl;
	}
	else
	{
	while(p->next != tail || (p->adress+p->size) != p2->adress) //找到可以合并的区间，或者到了尾部节点
	{
	//cout<<"xxx"<<endl;
	p=p2;   //吧p和p2整体向前移动一位
	p2=p2->next;
	}

	if((p->adress+p->size) == p2->adress && p->next == tail)
	{
	//如果有可以合并的区间的话
	//1、吧p的内存大小改变成p和p2的内存和
	p->size+=p2->size;
	//2、吧p的指针指向p2的后面
	p->next=p2->next;
	//3、吧p2断开,然后释放p2
	delete p2;
	tail=p; //重置尾节点
	}
	}
	*/
}

//添加一个Node,等会选择插入的地点
//void addNode(int size, int adress);
void freeLink::addNode(int size, int adress)
{
	//1、先找到要插入的位置节点p指向前面的那个节点，p2指向后面那个节点
	Node* p;
	Node* p2;
	p = head;
	p2 = head->next;

	if (p2 != nullptr)
	{
		while (p2->size < size)    //找到比size要大的第一个节点
		{
			p = p2;
			p2 = p2->next;
			if (p == tail)
				break;
		}
	}

	//判断是不是尾节点，不然要重置尾节点
	if (p2 == nullptr)
	{
		//如果是尾部节点，那就直接加上去就可以了
		Node* p3 = new Node(size, adress, 'O', nullptr);
		tail->next = p3;
		//重置尾节点
		tail = p3;
	}
	else
	{
		//2、创建一个节点保存这个内存信息,这个节点插入到p和p2之间
		//这块内存的起始地址
		Node* newNode = new Node(size, adress, 'O', p2);

		//3、插入链表
		//就是把newNode插入到两点之间
		p->next = newNode;
	}
}

//删除Node
//void popNode(char name);
/*
freeLink::Node* freeLink::popNode(char name)
{
//空闲分区删除节点一般是改变节点的大小
//判断是要改变还是要删除
}
*/

//busyLink类的定义

//合并所有adress回收碎片
//void reAdress();
int busyLink::reAdress()
{
	Node* p;
	Node* p2;
	p = head;
	p2 = p->next;
	int endAdress = 0;
	//循环到队尾，size不变，adress全部重置
	while (p != tail)
	{
		p2->adress = p->adress + p->size;   //把这个节点的起始地址改为上个节点的结束
		p = p2;
		p2 = p2->next;    //指向下一个
	}

	//当最后一个也得到处理的时候
	//重定位结束，
	//后面再调用freeLink里面的函数，把所有的free节点收集起来做成一个大的空闲节点
	endAdress = tail->adress + tail->size;

	return endAdress;
}

//得到索引节点的adress
//int getNeedAdress(int index);
int busyLink::getNeedAdress(int index)
{
	Node* p;
	Node* p2;   //就是要返回的索引对象
	p = p2 = head->next;
	int i = 1;
	while (i < index)
	{
		p = p2;
		p2 = p2->next;
		++i;
	}
	//cout<<"p2 name:"<<p2->name<<endl;
	return p2->adress;  //记得加return 返回啊！！！！我的天浪费我半天
}

//得到索引节点的size
//int getNeedSize(int index);
int busyLink::getNeedSize(int index)
{
	Node* p;
	Node* p2;   //就是要返回的索引对象
	p = p2 = head->next;
	int i = 1;
	while (i < index)
	{
		p = p2;
		p2 = p2->next;
		++i;
	}
	p2->getSize();

	return p2->getSize();
}

//得到需要的该的节点的索引
//int getNeedGai(char name);
int busyLink::getNeedGai(char name)
{
	int index = 1;    //返回索引
	Node* p;
	Node* p2;
	p = p2 = head->next;    //p2指向要修改的节点
	while (p2->name != name)
	{
		p = p2;
		p2 = p2->next;
		++index;
		if (p == tail)
			break;
	}

	if (p2 == nullptr)
		return 0;

	//cout<<index<<endl;
	return index;       //返回当前位置的索引

}

//显示当前的分区
//void show();
void busyLink::show()
{
	Node* p;
	p = head->next;
	cout << "作业分区的链表是(剩余, 名字, 起始地址)" << endl;
	while (p != nullptr)
	{
		cout << "(" << p->size << " , " << p->name << " , " << p->adress << ")->";
		p = p->next;
	}
	cout << endl;
}

//内存地址相同的时候的碎片拼接
//void pingJie();
//添加一个Node,等会选择插入的地点
//void addNode(int size, int adress, char name);
void busyLink::addNode(int size, int adress, char name)
{
	//工作链表添加的作业直接添加到尾部就可以了
	Node* p;
	//创建一个将要进入内存的作业
	p = new Node(size, adress, name, nullptr);    //其实这里析构函数应该回收p的内存
	tail->next = p;
	tail = p;
}


//删除Node
//void popNode(char name);
void busyLink::popNode(char name)
{
	Node* p;
	Node* p2;
	//1、找到名字为c的内存
	p = p2 = head->next;
	while (p2->name != name || p2 == nullptr)
	{
		p = p2;
		p2 = p2->next;
	}

	if (p2 == nullptr)
	{
		std::cout << "不好意思，没有这个作业进入内存" << std::endl;
		return;
	}
	//2、得到这块内存里面的值
	//int oldAdd=p2->adress;
	//int oldsize=p2->size;

	//3、创建一个节点保存这个内存的值
	//Node* p3=new Node(oldsize, oldAdd, name, nullptr);
	//4、回收原来的这块内存
	if (p->next == tail)
	{
		delete p2;
		p->next = nullptr;
		tail = p;
	}
	else
	{
		p->next = p2->next;
		delete p2;
	}
}