数据结构学习----优先队列(Java实现)

优先队列类，实现队列接口，使用排序单链表存储队列元素，元素按优先级升序排列

package com.clarck.datastructure.queue;

import com.clarck.datastructure.linked.SortedSinglyLinkedList;

/**
 * 优先队列类，实现队列接口，使用排序单链表存储队列元素，元素按优先级升序排列
 * 
 * @author clarck
 * 
 * @param <T>
 */
public class PriorityQueue<T extends Comparable<T>> implements QQueue<T> {
    
    /**
     * 使用排序单链表存储队列元素
     */
    private SortedSinglyLinkedList<T> list;
    
    /**
     * 构造空队列
     */
    public PriorityQueue() {
        this.list = new SortedSinglyLinkedList<T>();
    }

    /**
     * 判断队列是否空，若空返回true
     */
    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    /**
     * 元素x入队，空对象不能入队
     */
    @Override
    public void enqueue(T x) {
        //根据元素大小插入在单链表适当位置
        list.insert(x);
    }

    /**
     * 出队，返回队头元素，若队列空返回null
     */
    @Override
    public T dequeue() {
        //返回队头元素，删除队头结点
        return list.remove(0);
    }

    /**
     * 返回队列所有元素的描述字符串
     */
    @Override
    public String toString() {
        return list.toString();
    }
}

进程按优先级调度管理

package com.clarck.datastructure.queue;

/**
 * 进程按优先级调度管理
 * 
 * @author clarck
 * 
 */
public class Process implements Comparable<Process> {
    /**
     * 进程名
     */
    private String name;
    /**
     * 优先级
     */
    private int priority;

    public Process(String name, int priority) {
        this.name = name;
        this.priority = priority;
    }

    /**
     * 比较两个进程的大小，约定进程排队次序的规则
     */
    @Override
    public int compareTo(Process p) {
        return this.priority - p.priority;
    }
    
    public String toString() {
        return "("+this.name+","+this.priority+")";
    }
}

测试类：

package com.clarck.datastructure.queue;

public class Process_test {
    public static void main(String[] args) {
        Process process[] = { new Process("A", 4), new Process("B", 3),
                new Process("C", 5), new Process("D", 4), new Process("E", 10),
                new Process("F", 1) };
        // 创建一个优先队列
        PriorityQueue<Process> que = new PriorityQueue<Process>();
        System.out.print("入队进程： ");
        for (int i = 0; i < process.length; i++) {
            que.enqueue(process[i]);
            System.out.print(process[i] + " ");
        }
        System.out.print("\n 出队进程： ");
        while (!que.isEmpty()) {
            System.out.print(que.dequeue().toString() + " ");
        }
        System.out.println();
    }
}

测试结果：

入队进程： (A,4) (B,3) (C,5) (D,4) (E,10) (F,1) 
 出队进程： (F,1) (B,3) (D,4) (A,4) (C,5) (E,10)