一、链式队列
链式存储结构的队列称作链式队列。
链式队列的存储结构如下图所示
二、链式队列的实现
三、链式队列的应用(判断一个字符串是不是回文字符串)
//队列接口 public interface Queue { //入队 public void append(Object obj) throws Exception; //出队 public Object delete() throws Exception; //获得对头元素 public Object getFront() throws Exception; //判断队列是否为空 public boolean isEmpty(); }
public class Node { Object element; Node next; //头结点的构造方法 public Node(Node nextval) { this.next=nextval; } //不带头结点的构造方法 public Node(Object obj,Node nextval) { this.element=obj; this.next=nextval; } public Object getElement() { return element; } public void setElement(Object element) { this.element = element; } public Node getNext() { return next; } public void setNext(Node next) { this.next = next; } @Override public String toString() { return this.element.toString(); } }
public class LinkedQueue implements Queue { //队头 Node front; //队尾 Node rear; //计数器 int count; public LinkedQueue() { init(); } public void init() { front=rear=null; count=0; } @Override public void append(Object obj) throws Exception { Node node=new Node(obj, null); //说明插入的节点是第一个节点 if(front==null) { front=node; } if(rear!=null) { //队尾指针指向新节点 rear.next=node; } //将队尾节点设置为新节点 rear=node; count++; } @Override public Object delete() throws Exception { if(isEmpty()) { throw new Exception("队列为空!"); } Node node=front; front=front.next; count--; return node.getElement(); } @Override public Object getFront() throws Exception { if(isEmpty()) { return null; }else { return front.getElement(); } } @Override public boolean isEmpty() { return count==0; } }
四、优先级队列编写一个判断一个字符串是否是回文的算法。
思路:设字符数组str中存放了要判断的字符串。把字符数组中的字符逐个分别存入一个队列和栈中,然后逐个出队和出栈比较出队的字符与出栈的字符是否相同,若全部相等则该字符串为回文。
public class Main { public static void main(String[] args) throws Exception { /*LinkedQueue queue=new LinkedQueue(); queue.append("a"); queue.append("b"); queue.append("c"); queue.append("d"); queue.append("e"); queue.append("f"); queue.append("g"); queue.append("h"); queue.append("i"); queue.append("j"); queue.delete(); queue.delete(); queue.append("k"); while(!queue.isEmpty()) { System.out.println(queue.delete()); }*/ String str1="ABCDCBA"; String str2="ABCDEFG"; if(isHuiwen(str2)) { System.out.println(str2+"是回文!"); }else { System.out.println(str2+"不是回文!"); } } public static boolean isHuiwen(String str) throws Exception{ LinkedQueue queue=new LinkedQueue(); LinkedStack stack=new LinkedStack(); int len=str.length(); for (int i = 0; i < len; i++) { queue.append(str.substring(i, i+1)); stack.push(str.substring(i,i+1)); } while(!queue.isEmpty()&&!stack.isEmpty()) { if(!queue.delete().equals(stack.pop())) { return false; } } return true; } }
优先级队列是带有优先级的队列。
用顺序存储结构实现的优先级队列称作顺序优先级队列。
顺序优先级队列和顺序循环队列相比主要有两点不同:
(1)对于顺序优先级队列来说,出队列操作不是把队头数据元素出队列,而是把队列中优先级最高的数据元素出队列。
(2)对于顺序优先级队列来说,数据元素由两部分组成,一部分是原先意义上的数据元素,另一部分是优先级。通常设计优先级为int类型的数值,并规定数值越小优先级越高。
五、顺序优先级队列实现用链式存储结构存储的优先级队列称作链式优先级队列。
设计顺序优先级队列(分为两个类)
数据元素类
优先级队列类
六、优先级队列应用
//队列接口 public interface Queue { //入队 public void append(Object obj) throws Exception; //出队 public Object delete() throws Exception; //获得对头元素 public Object getFront() throws Exception; //判断队列是否为空 public boolean isEmpty(); }
//优先级队列元素类 public class Element { //数据 private Object obj; //优先级 private int priority; public Element(Object obj,int priotiry) { this.obj=obj; this.priority=priotiry; } public Object getObj() { return obj; } public void setObj(Object obj) { this.obj = obj; } public int getPriority() { return priority; } public void setPriority(int priority) { this.priority = priority; } }
//优先级队列 public class PrioritySequenceQueue implements Queue{ //队尾 int rear; //队头 int front; //计数器 int count; //队列 Element queue[]; //队列默认长度 static final int defaultSize=10; //队列最大长度 int maxSize; public PrioritySequenceQueue() { init(defaultSize); } public PrioritySequenceQueue(int size) { init(size); } public void init(int size) { maxSize=size; front=rear=0; count=0; queue=new Element[size]; } @Override public void append(Object obj) throws Exception { if(count>=maxSize) { throw new Exception("队列已满!"); } queue[rear]=(Element) obj; rear++; count++; } @Override public Object delete() throws Exception { if(isEmpty()) { throw new Exception("队列为空"); } //默认第一个优先级最高 Element min=queue[0]; int minIndex=0; for(int i=0;i<count;i++) { if(queue[i].getPriority()<min.getPriority()) { min=queue[i]; minIndex=i; } } //找到优先级最高的元素后,将该元素后的所有元素向前移 for(int i=minIndex+1;i<count;i++) { queue[i-1]=queue[i]; } rear--; count--; return min; } @Override public Object getFront() throws Exception { if(isEmpty()) { throw new Exception("队列为空"); } //默认第一个优先级最高 Element min=queue[0]; int minIndex=0; for(int i=0;i<count;i++) { if(queue[i].getPriority()<min.getPriority()) { min=queue[i]; minIndex=i; } } return min; } @Override public boolean isEmpty() { return count==0; } }
设计一个程序模仿操作系统的进程管理问题。进程服务按优先级高的先服务,优先级相同的先到先服务的原则管理。
模仿数据包含两个部分:进程编号和优先级。如下有五个进程:
1 30
2 20
3 40
4 20
5 0 ----------优先级最高,先服务
public class Main { public static void main(String[] args) throws Exception{ PrioritySequenceQueue queue=new PrioritySequenceQueue(); queue.append(new Element(1,20)); queue.append(new Element(2,40)); queue.append(new Element(3,30)); queue.append(new Element(4,20)); queue.append(new Element(5,0)); Element temp; System.out.println("数据 优先级"); while(!queue.isEmpty()) { temp=(Element) queue.delete(); System.out.println(temp.getObj()+" "+temp.getPriority()); } } }