首次適應演算法：

  使用該演算法進行記憶體分配時，從空閒分割槽鏈首開始查詢，直至找到一個能滿足其大小需求的空閒分割槽為止；然後再按照作業的大小，從該分割槽中劃出一塊記憶體分配給請求者，餘下的空閒分割槽仍留在空閒分割槽鏈中。

  該演算法傾向於使用記憶體中低地址部分的空閒分割槽，在高地址部分的空閒分割槽非常少被利用，從而保留了高地址部分的大空閒區。顯然為以後到達的大作業分配大的記憶體空間創造了條件。缺點在於低址部分不斷被劃分，留下許多難以利用、非常小的空閒區，而每次查詢又都從低址部分開始，這無疑會增加查詢的開銷。

  首次適應演算法的具體程式碼實現：

  資料結構：我們將計算機的記憶體地址抽象為一個連結串列，連結串列的節點包括首地址、記憶體大小、和當前的狀態（是否被使用）。

 具體程式碼實現：

程序類：

public class Process {
	String pName;   //作業號
	int pSize;      //作業大小
	public String getpName() {
		return pName;
	}
	public void setpName(String pName) {
		this.pName = pName;
	}
	public int getpSize() {
		return pSize;
	}
	public void setpSize(int pSize) {
		this.pSize = pSize;
	}

}
 

public interface DynamicStoreAlgorithm {
	 void init(int size);   //初始化分割槽連結串列
	 boolean allocatePartition(Process process);  //分配分割槽
	 boolean recoverPartition(Process process);   //回收分割槽
	 void unitPartition(MNode mnode);  //合併空閒分割槽
	 void show(); //顯示當前的記憶體狀態	
}

public class DynamicStoreAlgorithmImpl implements DynamicStoreAlgorithm{
	
	private MNode mHeadNode;
	
	public DynamicStoreAlgorithmImpl(){
		mHeadNode = new MNode();
	}
	
	@Override
	public boolean allocatePartition(Process process) {
		// TODO Auto-generated method stub
		boolean flag = false;
		MNode Node = mHeadNode;
		while(Node.getNextNode() != null){
			Node = Node.getNextNode();
			if(Node.getSize()>process.getpSize()){  //當程序所需的大小小於空閒記憶體分割槽時；
				flag = true;
				//申請新的記憶體空間，並進行初始化
				MNode mNode = new MNode();
				mNode.setSize(process.getpSize());
				mNode.setStartIndex(Node.getStartIndex());
				mNode.setFree(false);
				mNode.setProcessName(process.getpName());
				
				//修改原來結點的資料結構
				Node.setSize(Node.getSize()-process.getpSize());
				Node.setStartIndex(Node.getStartIndex()+process.getpSize());
				
				//改變當前連結串列指標的指向
				MNode m = Node.getPreNode();
				mNode.setPreNode(m);
				Node.getPreNode().setNextNode(mNode);
				Node.setPreNode(mNode);
				mNode.setNextNode(Node);
				break;
			}else if(Node.getSize()== process.getpSize()){
				flag = true;
				Node.setProcessName(process.getpName());
				Node.setFree(false);
				break;
			}
			
		}
		//若flag為真，則找到分割槽分配給程序；若為假則沒有適當的空閒分割槽可以分配給該程序
		if(flag){
			return true;
		}
		else
			return false;
	}

	@Override
	public void init(int size) {
		// TODO Auto-generated method stub	
		MNode mNode = new MNode();
		mNode.setNextNode(null);
		mNode.setPreNode(mHeadNode);
		mNode.setStartIndex(0);
		mNode.setSize(size);
		mNode.setFree(true);
		
		mHeadNode.setPreNode(null);
		mHeadNode.setNextNode(mNode);
		
	}

	@Override
	public boolean recoverPartition(Process process) {
		// TODO Auto-generated method stub
		boolean flag = false;
		MNode node = mHeadNode;
		while(node.getNextNode()!= null){
			node = node.getNextNode();
			if(node.getProcessName()!=null && node.getProcessName().equals(process.getpName())){
				node.setFree(true);
				node.setProcessName(null);
				unitPartition(node);
				flag=true;
				break;
			}
		}
		return flag;
	}

	@Override
	public void unitPartition(MNode mnode) {
		// TODO Auto-generated method stub
		MNode preNode = mnode.getPreNode();
		MNode nextNode = mnode.getNextNode();
		
		if(preNode.isFree()&&nextNode.isFree()){
			int size = preNode.getSize()+mnode.getSize()+nextNode.getSize();
			preNode.setSize(size);
			preNode.setNextNode(nextNode.getNextNode());
		}else if(!preNode.isFree() && nextNode.isFree()){
			int size = mnode.getSize()+nextNode.getSize();
			mnode.setSize(size);
			mnode.setNextNode(nextNode.getNextNode());
		}else if(preNode.isFree() && !nextNode.isFree()){
			int size = preNode.getSize()+mnode.getSize();
			preNode.setSize(size);
			preNode.setNextNode(nextNode);
		}
	}

	@Override
	public void show() {
		// TODO Auto-generated method stub
		MNode node = mHeadNode;
		System.out.println("分割槽號"+"\t"+"開始地址"+"\t"+"分割槽大小"+"\t"+"狀態(t空 f忙)"+"\t"+"執行程序");
		int i=1;
		while(node.getNextNode()!= null){
			node = node.getNextNode();
			System.out.println(i+"\t"+node.getStartIndex()+"\t"+node.getSize()+"\t"+node.isFree()+"\t\t"+node.getProcessName());
			i++;
		}
	}
	
}
 

package hwchao.algorithm;

public class MNode {
	private String processName; //正在使用的程序號
	private MNode preNode;      //前驅結點
	private MNode nextNode;		//後繼結點
	private int startIndex;		//開始地址
	private boolean free;		//分割槽狀態 1.true表示空閒 2.false表示使用
	private int size;           //分割槽大小
	
	public String getProcessName() {
		return processName;
	}
	public void setProcessName(String processName) {
		this.processName = processName;
	}
	public MNode getPreNode() {
		return preNode;
	}
	public void setPreNode(MNode preNode) {
		this.preNode = preNode;
	}
	public MNode getNextNode() {
		return nextNode;
	}
	public void setNextNode(MNode nextNode) {
		this.nextNode = nextNode;
	}
	public int getStartIndex() {
		return startIndex;
	}
	public void setStartIndex(int startIndex) {
		this.startIndex = startIndex;
	}

	public boolean isFree() {
		return free;
	}
	public void setFree(boolean free) {
		this.free = free;
	}
	public int getSize() {
		return size;
	}
	public void setSize(int size) {
		this.size = size;
	}
	
	
}

import java.util.Scanner;
import hwchao.algorithm.Process;

import hwchao.algorithm.DynamicStoreAlgorithmImpl;

public class Main {
	static Scanner input = new Scanner(System.in);
	public static void main(String[] args){
		DynamicStoreAlgorithmImpl dsa = new DynamicStoreAlgorithmImpl();
		dsa.init(1024);
		String operation=null;
		System.out.println("'add'新增程序 'delete'刪除程序 'view'檢視記憶體當前狀態 'end'結束程式");
		do{
			operation = input.next();
			if("add".equals(operation)){
				System.out.println("請輸入要新增的程序名和所需的記憶體大小。");
				Process process = new Process();
				String name = input.next();
				int size = input.nextInt();
				process.setpName(name);
				process.setpSize(size);
				dsa.allocatePartition(process);
				System.out.println("程序正在執行...");
			}else if("delete".equals(operation)){
				System.out.println("請輸入要刪除的程序名。");
				Process process = new Process();
				String name = input.next();
				process.setpName(name);
				if(dsa.recoverPartition(process)){
					System.out.println("程序已撤銷...");
				}else{
					System.out.println("程序不存在...");
				}
			}else if("view".equals(operation)){
				System.out.println("當前的記憶體狀態");
				dsa.show();
			}
			
		}while(!("end").equals(operation));
		
	}
}