有向图和无向图的主要区别在于边是有向的,在添加边的时候,不是统一的双向添加,而是根据条件添加,当然也可以是双向的。
java代码
package mypackage;
import java.util.Iterator;
//队列类,用链表实现,后面有用
class Queue<T> implements Iterable<T>{
// 节点个数,头节点,尾节点
private int N;
private Node head;
private Node last;
//节点类
public class Node {
public T data;
public Node next;
public Node(T data, Node next) {
this.data = data;
this.next = next;
}
}
//构造方法,初始化
public Queue() {
this.N = 0;
this.head = new Node(null,null);
this.last = null;
}
//队列长度
public int size(){
return N;
}
//队列是否为空
public boolean isEmpty(){
return N==0;
}
//入队列
public void enqueue(T data){
// 如果队列为空,说明尾节点为空,让新节点为尾节点,头借点指向尾节点
if (isEmpty()){
last=new Node(data,null);
head.next=last;
// 如果队列不为空,让新节点为尾节点,老的尾节点指向新尾节点
}else {
Node oldlast=last;
last=new Node(data,null);
oldlast.next=last;
}
// 最后元素+1
N++;
}
//出队列,注意先入先出,每次出的节点就是head指向的第一个节点,然后让head只想第二个节点即可
// 且注意,如果队列为空,要将last=null
public T dequeue(){
// 如果为空,返回null
if (isEmpty()){
return null;
// 如果不为空,让head只想第二个节点,元素-1,且如果队列为空,要将last=null
}else {
Node oldfirst=head.next;
head.next=oldfirst.next;
N--;
if (isEmpty()){
last=null;
}
// 返回弹出的元素
return oldfirst.data;
}
}
// 遍历
@Override
public Iterator iterator() {
return new QIterator();
}
// 创建一个内部类实现Iterator接口
public class QIterator implements Iterator {
// 定义一个遍历的节点
private Node n;
public QIterator() {
// 初始化为0索引位置
this.n = head;
}
//重写两个方法
@Override
public boolean hasNext() {
// 这个方法判断是否超出最大索引,如果超出会停止遍历
return n.next != null;
}
@Override
public Object next() {
// 这个方法会遍历得每个节点
n = n.next;
return n.data;
}
}
}
class Digraph<T>{
private int V;//顶点数
private int E;//边数
private Queue<Integer>[] adj;//邻接表,用于装每个顶点的相连的顶点组成的队列,注意索引是每个顶点,这个索引对应的值是相连的顶点组成的队列
//构造方法,传入顶点个数,初始化边数为0,
public Digraph(int v) {
this.V = v;
this.E=0;
this.adj=new Queue[v];//初始化队列数组,大小为顶点的个数
for (int i = 0; i <adj.length ; i++) {
adj[i]=new Queue<Integer>();//初始化数组的每个队列
}
}
//获得顶点的个数
public int getV(){
return V;
}
//添加边,即将顶点v,w连接起来形成图,注意是有向图,只是有v指向w,adj[v].enqueue(w)
//和无向图的主要区别
public void addEdge(int v, int w){
adj[v].enqueue(w);
E++;//边数+1
}
// 获取边的个数
public int getE(){
return E;
}
//获取某个顶点相邻的所有顶点,返回这个队列即可
public Queue<Integer> getAdj(int v){
return adj[v];
}
//反向图,循环每一个顶点,再循环每个邻接表,让指向反转
public Digraph reverse(){
Digraph digraph=new Digraph(V);
for (int v = 0; v<V ; v++) {
for (int w:adj[v]){
digraph.addEdge(w,v);//本来是v指向w,现在改为w指向v即可
}
}
return digraph;
}
}
//测试
public class MyJava {
public static void main(String[] args){
Digraph<Integer> digraph = new Digraph<>(5);
digraph.addEdge(0,1);
digraph.addEdge(0,2);
digraph.addEdge(1,3);
digraph.addEdge(4,2);
System.out.println("顶点个数"+digraph.getV());
System.out.println("边的条数"+digraph.getE());
System.out.println("顶点0指向的顶点包括:");
Queue queue=digraph.getAdj(0);
for (Object q:queue) {
System.out.print(q+"--");
}
System.out.println();
Digraph re=digraph.reverse();
System.out.println("反转后2指向的顶点包括(也就是反转前,指向2的顶点包括):");
Queue requeue=re.getAdj(2);
for (Object req:requeue) {
System.out.print(req+"--");
}
}
}