一道题

package testcase;


import huawei.Demo;

import junit.framework.TestCase;




public class DemoTest extends TestCase {
    Demo oj = new Demo();
    public void testCase01() {
        oj.CreateFreeQueue(10);
        assertEquals(0,oj.GetFreeIndex());
        assertEquals(1,oj.GetFreeIndex());
        oj.Destory();        
    }
    
    public void testCase02() {
        oj.CreateFreeQueue(10);
        
        for (int i = 0; i < 10; i++) {
            assertEquals(i, oj.GetFreeIndex());
        }
        
        assertEquals(-1, oj.GetFreeIndex());

        oj.FreeIndex(7);
        oj.FreeIndex(5);
        assertEquals(7, oj.GetFreeIndex());
         oj.Destory();
    }
    
    public void testCase03() {
        oj.CreateFreeQueue(10);
        
        for (int i = 0; i < 8; i++) {
            assertEquals(i, oj.GetFreeIndex());
        }
        
        oj.FreeIndex(7);
        oj.FreeIndex(5);
    
        assertEquals(8, oj.GetFreeIndex());
        assertEquals(9, oj.GetFreeIndex());
        assertEquals(7, oj.GetFreeIndex());
         oj.Destory();
    }
    
}

 

package huawei;

public final class Demo
{
    /*
    有一个数组，使用时按照需要获得一个数组节点使用，使用完后，放回数组供下次使用。
    节点的使用应该是循环的，也就是说总是选择释放时间最长的节点，
    为了实现这个目的，通过一个循环队列来负责分配数组的空闲节点。
     */
    int Size; //空白队列的总长度
    
    int Head; //FreeIndex的下标，指向队列头，即第一个空闲节点。
    
    int Len; //当前空白元素的个数
    
    int FreeIndex[]; //保存空闲节点的下标。根据数组大小申请动态内存
    
    //请实现如下函数：
    
    /*
    功能: 初始化，完成内存申请等操作
    输入: 数组长度
    返回: 无
     */
    public void CreateFreeQueue(int size)
    {
        FreeIndex = new int[size];
        Size = size;
    }
    
    /*
    功能: 获取一个空闲的节点
    返回: 初始时按数组顺序从大到小分配，所有节点都用过之后，有空闲节点则返回最早释放的节点，否则返回-1
     */
    public int GetFreeIndex()
    {
        if (Head == Size)
        {
            return -1;
        }
        //使用
        Head++;
        FreeIndex[Head - 1] = Head;
        return Head - 1;
    }
    
    /*
    功能: 数组节点使用完后释放，放到队列尾部
    输入: pQueue; Index: 调用者保证非负
    返回: 无
     */
    public void FreeIndex(int Index)
    {
        //将Index压底
        
        for (int i = Index; i < Size - 1; i++)
        {
            FreeIndex[i] = FreeIndex[i] + FreeIndex[i + 1];
            FreeIndex[i + 1] = FreeIndex[i] - FreeIndex[i + 1];
            FreeIndex[i] = FreeIndex[i] - FreeIndex[i + 1];
        }
        FreeIndex[Size - 1] = 0;
        
    }
    
    /*
    功能: 清空申请的动态内存
    返回: 无
     */
    public void Destory()
    {
        FreeIndex = null;
        Head = 0;
        Size = 0;
        Len = 0;
    }
    
}

 

 

package nanoha.oj.freequeue;

public final class FreeQueue {
    /*
     * 有一个数组，使用时按照需要获得一个数组节点使用，使用完后，放回数组供下次使用。 节点的使用应该是循环的，也就是说总是选择释放时间最长的节点，
     * 为了实现这个目的，通过一个循环队列来负责分配数组的空闲节点。
     */
    int Size; // 空白队列的总长度

    int Head; // FreeIndex的下标，指向队列头，即第一个空闲节点。

    int Len; // 当前空白元素的个数

    int FreeIndex[]; // 保存空闲节点的下标。根据数组大小申请动态内存

    // 请实现如下函数：

    /*
     * 功能: 初始化，完成内存申请等操作 输入: 数组长度 返回: 无
     */
    public void CreateFreeQueue(int size) {
        FreeIndex = new int[size];
        Size = size;
        Len = size;
        for (int i = 0; i < FreeIndex.length; i++) {
            FreeIndex[i] = i;
            System.err.print(i + " ");
        }
        System.err.println();
    }

    /*
     * 功能: 获取一个空闲的节点 返回: 初始时按数组顺序从大到小分配，所有节点都用过之后，有空闲节点则返回最早释放的节点，否则返回-1
     */
    public int GetFreeIndex() {
        if (Head == Size) {
            return -1;
        }
        // 使用
        int i = FreeIndex[Head];
        Head++;
        Len--;
        return i;
    }

    /*
     * 功能: 数组节点使用完后释放，放到队列尾部 输入: pQueue; Index: 调用者保证非负 返回: 无
     */
    public void FreeIndex(int Index) {
        // 将Index压底

        for (int i = Index; i < Size - 1; i++) {
            FreeIndex[i] = FreeIndex[i] + FreeIndex[i + 1];
            FreeIndex[i + 1] = FreeIndex[i] - FreeIndex[i + 1];
            FreeIndex[i] = FreeIndex[i] - FreeIndex[i + 1];
        }
        for (int i : FreeIndex) {
            System.err.print(i + " ");
        }
        System.err.println();

        // 重置指针
        if (Len == 0) {
            Head = Index + 1;
        } else {
            Head = Size - Len - 1;
        }

        if (Len < Size) {
            Len++;
        }
        System.err.println("h" + Head);
    }

    public static void main(String[] args) {
        FreeQueue oj = new FreeQueue();
        oj.CreateFreeQueue(10);

        for (int i = 0; i < 8; i++) {
            oj.GetFreeIndex();
        }

        oj.FreeIndex(7);
        oj.FreeIndex(5);
        System.err.println("gi " + oj.GetFreeIndex());
        System.err.println("gi " + oj.GetFreeIndex());
        System.err.println("gi " + oj.GetFreeIndex());
    }

    /*
     * 功能: 清空申请的动态内存 返回: 无
     */
    public void Destory() {
        FreeIndex = null;
        Head = 0;
        Size = 0;
        Len = 0;
    }

}