BF、FF

最新推荐文章于 2022-06-06 22:27:10 发布
最新推荐文章于 2022-06-06 22:27:10 发布
阅读量1k 收藏 31
点赞数 3
分类专栏： Java 操作系统 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44780816/article/details/111281910
版权
Java 同时被 3 个专栏收录
6 篇文章 0 订阅
订阅专栏
操作系统
3 篇文章 1 订阅
订阅专栏
算法
3 篇文章 0 订阅
订阅专栏

BestFit

package com.algorithm.dp_allocation;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * @Class BestFit
 * @Description 最佳适应算法
 * @Author Naren
 * @Date 2020/5/23 15:30
 * @Version 1.0
 */
public class BestFit {
    private static Scanner sc = new Scanner(System.in);
    private static List<Block> blockList = new ArrayList<>();
    /**
     * 内部Block类,分区
     */
    private static class Block {
        int address; //分区首地址
        int size;    //分区大小
        int id;      //进程id

        /*打印分区信息*/
        public String toString(){
            return String.format( "[%5d| %5d| %5d]", address, size, id );
        }
    }

    /**
     * 初始化分区
     */
    private static void initBlock(){
        BestFit.Block block = new BestFit.Block();

        System.out.println("-----------最佳适应算法 BF----------\n\n");
        System.out.println("请输入内存空间大小（KB）：");
        block.size = sc.nextInt();
        block.address = 0;
        block.id = -1;
        blockList.add(block);
    }

    /**
     * 寻找空闲分区并为新作业分配空间
     * @param id
     * @param size
     */
    private static boolean allocation(int id, int size){
        //分配成功与否的标志
        boolean flag = false;
        int blockAddress = 0;
        int blockSize = 0;
        int blockId = 0;
        //标记最佳分区的位置
        int mark = 0;
        int min = 0;
        int count = 0;

        /*顺序遍历所有分区*/
//        int min = blockList.get(0).size;
        for(int i = 0; i < blockList.size(); i++){
            blockAddress = blockList.get(i).address;
            blockSize = blockList.get(i).size;
            blockId = blockList.get(i).id;
            /*若存在空闲且内存合适的分区，重新分配*/
            if(blockId == -1 && blockSize >= size) {
                count++;
                if(count == 1) {
                    min = blockSize - size;
                    mark = i;
                }else if(count > 1) {
                    if (min > blockSize - size) {
                        min = blockSize - size;
                        mark = i;
                    }
                }
                flag = true;
            }
        }
        if(flag) {
            blockAddress = blockList.get(mark).address;
            blockSize = blockList.get(mark).size;
            blockList.get(mark).id = id;
            blockList.get(mark).size = size;
            /*若当前分区重新分配后有剩余内存，
              则将其作为新的分区并设置新的address 和 size*/
            if (blockSize > size) {
                BestFit.Block newBlock = new BestFit.Block();
                newBlock.id = -1;
                newBlock.address = blockAddress + size;
                newBlock.size = blockSize - size;
                blockList.add(mark + 1, newBlock);
            }
        }
        //返回分配结果
        return flag;
    }

    /**
     * 释放内存并合并空闲分区
     * @param id
     */
    private static boolean release(int id) {
        //释放成功与否的标志
        boolean flag = false;
        int blockId = 0;
        int blockSize = 0;

        for(int i = 0; i < blockList.size(); i++) {
            blockId = blockList.get(i).id;
            //释放成功
            if (blockId == id) {
                blockList.get(i).id = -1;
                /*当分区为第一个时*/
                if(i == 0){
                    //若与之相邻下一个分区空闲
                    if (blockList.get(i + 1).id == -1) {
                        /*更新本分区的size并删除下一分区*/
                        blockList.get(i).size += blockList.get(i + 1).size;
                        blockList.remove(i + 1);
                    }
                }
                /*当分区不是第一个也不是最后一个*/
                else if(i < blockList.size() - 1) {
                    //若与之相邻上一个分区空闲且下一分区不空闲
                    if (blockList.get(i - 1).id == -1 && blockList.get(i + 1).id != -1) {
                        /*更新上一分区的size并删除本分区*/
                        blockList.get(i - 1).size += blockList.get(i).size;
                        blockList.remove(i);
                    }
                    //若与之相邻下一个分区空闲且上一分区不空闲
                    else if (blockList.get(i + 1).id == -1 && blockList.get(i - 1).id != -1) {
                        /*更新本分区的size并删除下一分区*/
                        blockList.get(i).size += blockList.get(i + 1).size;
                        blockList.remove(i + 1);
                    }
                    //若与之相邻上下分区都空闲
                    else if (blockList.get(i - 1).id == -1 && blockList.get(i + 1).id == -1) {
                        /*更新上一分区的size并删除本、下一分区*/
                        blockList.get(i - 1).size += blockSize;
                        blockList.get(i - 1).size += blockList.get(i + 1).size;
                        blockList.remove(i);
                        blockList.remove(i);
                    }
                }
                /*当分区为最后一个分区时*/
                else if(i == blockList.size() - 1){
                    //若与之相邻上一个分区空闲
                    if (blockList.get(i - 1).id == -1) {
                        /*更新上一分区的size并删除本分区*/
                        blockList.get(i - 1).size += blockList.get(i).size;
                        blockList.remove(i);
                    }
                }
                flag = true;
                break;
            }
        }

        return flag;
    }

    /**
     * 打印内存分配情况
     */
    private static void show(List<BestFit.Block> blockList) {
        int i = 0;
        System.out.println("         首地址 分区大小 作业id");
        for(BestFit.Block block: blockList)
            System.out.println("  分区" + ++i + "：" + block);
        System.out.println();
    }

    /**
     * 操作面板
     */
    private static void operator(){
        String choose = "";
        int id = 0;
        int size = 0;

        while(true) {
            System.out.println("1.为新作业分配内存  2.作业完成释放内存");
            System.out.println("3.查看当前内存分配  4.退出程序");
            System.out.println("请输入待进行操作编号：");
            choose = sc.next();
            switch (choose) {
                case "1":
                    System.out.println("作业id及申请空间大小：");
                    id = sc.nextInt();
                    size = sc.nextInt();
                    if (allocation(id, size))
                        System.out.println("内存分配成功。\n");
                    else
                        System.out.println("内存分配失败。\n");
                    break;
                case "2":
                    System.out.println("待释放内存进程id：");
                    id = sc.nextInt();
                    if (release(id))
                        System.out.println("内存释放成功。\n");
                    else
                        System.out.println("内存释放失败。\n");
                    break;
                case "3":
                    show(blockList);
                    break;
                case "4":
                    System.exit(0);
            }
        }
    }

    /**
     * main()
     */
    public static void main(String[] args) {
        initBlock();
        operator();
    }
}

FirstFit

package com.algorithm.dp_allocation;

import java.util.*;

/**
 * @Class FirstFit
 * @Description 首次适应算法
 * @Author Naren
 * @Date 2020/5/23 15:29
 * @Version 1.0
 */

public class FirstFit {

    private static Scanner sc = new Scanner(System.in);
    private static List<Block> blockList = new ArrayList<>();
    /**
     * 内部Block类,分区
     */
    private static class Block {
        int address; //分区首地址
        int size;    //分区大小
        int id;      //进程id

        /*打印分区信息*/
        public String toString(){
            return String.format( "[%5d| %5d| %5d]", address, size, id );
        }
    }

    /**
     * 初始化分区
     */
    private static void initBlock(){
        Block block = new Block();

        System.out.println("-----------首次适应算法 FF----------\n\n");
        System.out.println("请输入内存空间大小（KB）：");
        block.size = sc.nextInt();
        block.address = 0;
        block.id = -1;
        blockList.add(block);
    }

    /**
     * 寻找空闲分区并为新作业分配空间
     * @param id
     * @param size
     */
    private static boolean allocation(int id, int size){
        //分配成功与否的标志
        boolean flag = false;
        int blockAddress = 0;
        int blockSize = 0;
        int blockId = 0;

        /*顺序遍历所有分区*/
        for(int i = 0; i < blockList.size(); i++){
            blockAddress = blockList.get(i).address;
            blockSize = blockList.get(i).size;
            blockId = blockList.get(i).id;
            /*若存在空闲且内存合适的分区，重新分配*/
            if(blockId == -1 && blockSize >= size) {
                blockList.get(i).id = id;
                blockList.get(i).size = size;
                /*若当前分区重新分配后有剩余内存，
                  则将其作为新的分区并设置新的address 和 size*/
                if (blockSize > size) {
                    FirstFit.Block newBlock = new Block();
                    newBlock.id = -1;
                    newBlock.address = blockAddress + size;
                    newBlock.size = blockSize - size;
                    blockList.add(i + 1, newBlock);
                }
                flag = true;
                break;
            }
        }
        //返回分配结果
        return flag;
    }

    /**
     * 释放内存并合并空闲分区
     * @param id
     */
    public static boolean release(List<Block> block_List, int id) {
        //释放成功与否的标志
        block_List = blockList;
        boolean flag = false;
        int blockId = 0;
        int blockSize = 0;

        for(int i = 0; i < block_List.size(); i++) {
            blockId = block_List.get(i).id;
            blockSize = block_List.get(i).size;
            //释放成功
            if (blockId == id) {
                block_List.get(i).id = -1;
                /*当分区为第一个时*/
                if(i == 0){
                    //若与之相邻下一个分区空闲
                    if (block_List.get(i + 1).id == -1) {
                        /*更新本分区的size并删除下一分区*/
                        block_List.get(i).size += block_List.get(i + 1).size;
                        block_List.remove(i + 1);
                    }
                }
                /*当分区不是第一个也不是最后一个*/
                else if(i < block_List.size() - 1) {
                    //若与之相邻上一个分区空闲且下一分区不空闲
                    if (block_List.get(i - 1).id == -1 && block_List.get(i + 1).id != -1) {
                        /*更新上一分区的size并删除本分区*/
                        block_List.get(i - 1).size += block_List.get(i).size;
                        block_List.remove(i);
                    }
                    //若与之相邻下一个分区空闲且上一分区不空闲
                    else if (block_List.get(i + 1).id == -1 && block_List.get(i - 1).id != -1) {
                        /*更新本分区的size并删除下一分区*/
                        block_List.get(i).size += block_List.get(i + 1).size;
                        block_List.remove(i + 1);
                    }
                    //若与之相邻上下分区都空闲
                    else if (block_List.get(i - 1).id == -1 && block_List.get(i + 1).id == -1) {
                        /*更新上一分区的size并删除本、下一分区*/
                        block_List.get(i - 1).size += blockSize;
                        block_List.get(i - 1).size += block_List.get(i + 1).size;
                        block_List.remove(i);
                        block_List.remove(i);
                    }
                }
                /*当分区为最后一个分区时*/
                else if(i == blockList.size() - 1){
                    //若与之相邻上一个分区空闲
                    if (blockList.get(i - 1).id == -1) {
                        /*更新上一分区的size并删除本分区*/
                        blockList.get(i - 1).size += blockList.get(i).size;
                        blockList.remove(i);
                    }
                }
                flag = true;
                break;
            }
        }

        return flag;
    }

    /**
     * 打印内存分配情况
     */
    private static void show(List<Block> blockList) {
        int i = 0;
        System.out.println("         首地址 分区大小 作业id");
        for(Block block: blockList)
            System.out.println("  分区" + ++i + "：" + block);
        System.out.println();
    }

    /**
     * 操作面板
     */
    private static void operator(){
        String choose = "";
        int id = 0;
        int size = 0;

        while(true) {
            System.out.println("1.为新作业分配内存  2.作业完成释放内存");
            System.out.println("3.查看当前内存分配  4.退出程序");
            System.out.println("请输入待进行操作编号：");
            choose = sc.next();
            switch (choose) {
                case "1":
                    System.out.println("作业id及申请空间大小：");
                    id = sc.nextInt();
                    size = sc.nextInt();
                    if (allocation(id, size))
                        System.out.println("内存分配成功。\n");
                    else
                        System.out.println("内存分配失败。\n");
                    break;
                case "2":
                    System.out.println("待释放内存进程id：");
                    id = sc.nextInt();
                    if (release(blockList,id))
                        System.out.println("内存释放成功。\n");
                    else
                        System.out.println("内存释放失败。\n");
                    break;
                case "3":
                    show(blockList);
                    break;
                case "4":
                    System.exit(0);
            }
        }
    }

    /**
     * main()
     */
    public static void main(String[] args) {
        initBlock();
        operator();
    }
}
NAREN_BLOG
关注
  • 3
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
主存分配回收算法（BF、FF）用C++实现
weixin_44735393的博客
01-17 1404
一、实验目的 本实验主要让大家熟悉主存的各种分配和回收。所谓分配，就是解决多道作业或多进程如何共享主存空间的问题。所谓回收，就是当作业运行完成时，将作业或进程所占用的主存空间归还给系统。主存的分配和回收的实现就是与主存储器的管理方式有关的。通过本实验，帮助学生理解在不同的存储管理方式下，如何实现主存空间的分配与回收。 二、实验原理 (1)可变式分区管理是指在处理作业过程中建立分区，使分区大小正好适...
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 竞赛树 — 应用 — 箱子装载
coding-hwz
09-27 328
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 竞赛树 — 应用 — 箱子装载一、问题描述二、近似算法三、赢者树和最先适配法 一、问题描述 在箱子装载问题中，箱子的数量不限，每个箱子的容量为 binCapacity，待装箱的物品有 n 个。物品 i 需要占用的箱子容量为 objectSize[i]，0≤objectSize[i]≤binCapacityobjectSize[i]，0 \le objectSize[i] \le binCapacityobjectSize[i]，0≤objectSi
【操作系统】-- 动态分区分配算法（首次适应算法FF、最佳适应算法BF、最坏适应算法WF、循环首次适应算法NF）
张修宇的博客
06-06 1万+
每次从低地址开始查找，找到第一个能满足大小的空闲分区。空闲分区以地址递增的次序排列，每次分配内存时顺序查找空闲分区链，找到大小能满足要求的第一个空闲分区。空闲分区表、空闲分区链优点：①为分配大的内存空间创造了条件②不需要重新排序，算法开销小缺点:①不断被划分，会留下许多难以利用的小分区，产生碎片。空闲分区表↑空闲分区链（按起始地址有小到大排序）↓由于动态分区分配是一种连续分配方式，为各进程分配的空间必须是连续的一整片区域，因此为了保证大进程到来时能有连续的大空间，可以尽可能的留下大空间，优先使用小空间。空闲
内存分配算法——FF、BF、WF、buddy（伙伴算法）
GreyBtfly的博客
11-30 9015
 分区分配算法：        首次适应算法（First Fit）：从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给 作业，这种方法的目的在于减少查找时间。为适应这种算法，空闲分区表（空闲区链）中的空闲分区要按地址由低到 高进行排序。该算法优先使用低址部分空闲区，在低址空间造成许多小的空闲区，在高地址空间保留大的空闲区。         最佳适应算法（Best Fit)...
内存分配算法（FF、BF、MF）
热门推荐
musite 小白成长杂记
05-09 2万+
动态分区分配 最近在学习操作系统内存分配方面的知识点，小小的总结一下知识点。 根据进程的实际需要，动态的为之分配内存空间。在实现动态分区分配时，将涉及到分区分配中所用到的数据结构、分区分配算法和分区的分配与回收操作三方面的问题。 我的理解是，动态分区分配是按照作业需要的主存空间大小来分配的，当要装入一个作业时，根据作业需要的主存量查看是否有足够的空闲空间，若有，则按需要量分割一个分区分配给该作...
BF FF算法模拟内存分配回收（MFC）
03-27
BF FF算法，即Best Fit（最佳适配）和First Fit（首次适配）算法，是两种经典的内存分配策略。本文将深入探讨这两种算法在模拟内存分配回收中的应用，并结合MFC（Microsoft Foundation Classes）库进行多线程编程。 ...
FF_NF_BF_WF.rar_FF_ NF_BF_Java FF BF WF算法_bf wf算法_bf存储分配_ff_wf_b
09-19
在这个主题中，我们主要关注FF（First Fit，首次适应），NF（Next Fit，下次适应），BF（Best Fit，最佳适应）以及WF（Worst Fit，最差适应）这四种算法。这些算法主要用于解决如何在多个大小不一的内存分区中找到...
操作系统_实验_课程设计_动态分区分配_四种内存分配方式_代码&报告 FF、NF、WF、BF
12-10
本实验主要探讨了四种不同的动态分区分配策略：首次适应（First Fit, FF）、最佳适应（Best Fit, NF）、最差适应（Worst Fit, WF）以及最佳 Fit with Buddy（BF）。这些方法在实际操作系统的内存管理中扮演着关键...
操作系统实验和课设，java实现动态内存分配和回收，FF,NF,WF,BF
01-09
在这个实验和课程设计中，我们将深入探讨动态内存分配与回收的机制，通过Java编程语言来实现四种不同的内存分配策略：First Fit（FF）、Next Fit（NF）、Best Fit（BF）以及Worst Fit（WF）。 首先，让我们详细了解...
c++实现的数据结构-DynamicPartitionAllocation（动态分区分配FF、NF、BF、WF）.zip
05-23
c++实现的数据结构-DynamicPartitionAllocation（动态分区分配FF、NF、BF、WF）.zip c++实现的数据结构-DynamicPartitionAllocation（动态分区分配FF、NF、BF、WF）.zip c++实现的数据结构-...
箱子装载FF、BF、FFD、BFD四种解法C++源码
07-25
在箱子装载问题中，有若干个容量为c的箱子和n个待装载入箱子中的物品。物品i需占是s[i]个单元（0<s[i]<=c）。所谓成功装载（feasible packing），是指能把所有物品都装入箱子而不溢出，而最优装载（optimal packing）是指使用了最少箱子的成功装载。对于箱子装载问题，有4种流行的求解算法。采用竞赛树和AVL树的FF、BF、FFD、BFD四种解法C++源代码
内存分配---FF、BF、WF三种算法
weixin_30878501的博客
05-20 3910
动态分区分配是根据进程的实际需要，动态的为之分配内存空间。而在实现可变分区分配时，将涉及到分区分配中 所用的数据结构、分区分配算法和分区的分配与内存回收的过程。 分区分配中的数据结构：（1）描述空闲块的数据结构。（2）内存块的描述。 #define PROCESS_NAME_LEN 32 //进程名长度 #define MIN_SLICE 10 ...
FF BF WF 算法 （java）
JimmyYang的博客
12-24 2206
1. 首次适应 FF • 每次从 低地址 开始查找 2. 最佳适应 BF • 空闲分区 按 容量递增 链接 • 从小的分区开始查找 3. 最坏适应 WF • 空闲分区 按 容量递减 链接 • 从大的分区开始查找 运行结果 -------java代码------------- package o...
内存管理算法（BF FF WF。。）
weixin_44121995的博客
11-05 904
关于首次适应算法、最佳适应算法和最差适应算法，先看一下百度百科的解释，已经说出了三者的最大区别。 首次适应算法（first-fit）： 从空闲分区表的第一个表目起查找该表，把最先能够满足要求的空闲区分配给作业，这种方法的目的在于减少查找时间。 最佳适应算法（best-fit）： 从全部空闲区中找出能满足作业要求的，且大小最小的空闲分区，这种方法能使碎片尽量小。 最差适应算法（worst-fit）：...
FF首次适应算法与BF最佳适应算法（C++实现）
LeopoldZhang2000的博客
02-15 5076
首次适应算法（First Fit）：该算法从空闲分区链首开始查找，直至找到一个能满足其大小要求的空闲分区为止。然后再按照作业的大小，从该分区中划出一块内存分配给请求者，余下的空闲分区仍留在空闲分区链中。 最佳适应算法（Best Fit）：该算法总是把既能满足要求，又是最小的空闲分区分配给作业。为了加速查找，该算法要求将所有的空闲区按其大小排序后，以递增顺序形成一个空白链。这样每次找到的第一个满足要求的空闲区，必然是最优的。孤立地看，该算法似乎是最优的，但事实上并不一定。因为每次分配后剩余的空间一定是最小的，
内存管理BF、FF算法Java实现
efforts_of_losers的博客
11-05 602
内存管理BF、FF java 实现1、BF 算法就是来一个进程，在内存块中从前往后遍历找，找到一个空的且内存下的，就存入；2、FF 最佳分配3、java 代码实现4、运行截图5、对于不懂欢迎提问，代码注释很多；多看几遍应该没问题，欢迎留言。 1、BF 算法 就是来一个进程，在内存块中从前往后遍历找，找到一个空的且内存下的，就存入； 2、FF 最佳分配 把内存遍历一遍找到，与他内存大小最近的，存...
方案-基于云架构的校园信息化建设方案.pdf
最新发布
07-29
方案-基于云架构的校园信息化建设方案.pdf
【创新未发表】Matlab实现蛇群优化算法SO-Kmean-Transformer-LSTM负荷预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
【创新未发表】Matlab实现北方苍鹰优化算法NGO-Kmean-Transformer-LSTM组合状态识别算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
比较首次适应算法（FF）和最佳适应算法(BF)的区别
05-29
首次适应算法（FF）和最佳适应算法（BF）是两种常见的内存分配算法，它们的区别在于如何选择空闲分区。 首次适应算法（FF）从空闲分区链表的头部开始扫描，找到第一个能够满足要求的空闲分区进行分配。这种算法的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值