Beispiel zur rekursiven Algorithmus-Traversal von Abteilungscode in Java

Rekursion ist ein sehr nützliches Konzept. Ein paar Beispiele helfen mir, mich zu erinnern

Mittlerer Prozesscode

Erste javapojo-Klasse

package com.qcf.po;
import java.util.HashSet;
import java.util.Set;
public class Depart {
	private long id;
	private String name;
	private String destion;
	//Benutzer
	Set<User> users = new HashSet<User>();
	//Unterklasse-Abteilung
	Set<Depart> departs = new HashSet<Depart>();
	//Elterklasse-Abteilung
	private Depart depart;
	public long getId() {
		return id;
	}
	public void setId(long id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<User> getUsers() {
		return users;
	}
	public void setUsers(Set<User> users) {
		this.users = users;
	}
	public Set<Depart> getDeparts() {
		return departs;
	}
	public void setDeparts(Set<Depart> departs) {
		this.departs = departs;
	}
	public Depart getDepart() {
		return depart;
	}
	public void setDepart(Depart depart) {
		this.depart = depart;
	}
	public String getDestion() {
		return destion;
	}
	public void setDestion(String destion) {
		this.destination = destination;
	}
}

测试代码：

package com.qcf.util;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.aspectj.weaver.patterns.ThisOrTargetAnnotationPointcut;
import com.qcf.po.Depart;
public class PreDepart {
	/**
   *  结构
   *  ┝开发部
   *    ┝开发一部
   *      ┝开发一组
   *      ┝开发二组
   *    ┝开发二部
   *      ┝开发三组
   *      ┝开发四组
   *  ┝销售部
   *    ┝销售一部
   *    ┝销售二部
   */
	public static List<Depart> findDepartTopList(){
		//顶级
		Depart depart1= new Depart();
		depart1.setName("开发部");
		//二级
		Depart depart1_1= new Depart();
		depart1_1.setName("开发一部");
		//三级
		Depart depart1_1_1= new Depart();
		depart1_1_1.setName("开发一组");
		Depart depart1_1_2= new Depart();
		depart1_1_2.setName("开发二组");
		Set<Depart> departs1_1= new HashSet<Depart>();
		departs1_1.add(depart1_1_1);
		departs1_1.add(depart1_1_2);
		depart1_1.setDeparts(departs1_1);
		Depart depart1_2= new Depart();
		depart1_2.setName("开发二部");
		Depart depart1_2_1= new Depart();
		depart1_2_1.setName("开发一组");
		Depart depart1_2_2= new Depart();
		depart1_2_2.setName("开发二组");
		Set<Depart> departs1_2= new HashSet<Depart>();
		departs1_2.add(depart1_1_1);
		departs1_2.add(depart1_1_2);
		depart1_2.setDeparts(departs1_1);
		Set<Depart> departs1= new HashSet<Depart>();
		departs1.add(depart1_1);
		departs1.add(depart1_2);
		depart1.setDeparts(departs1);
		//顶级
		Depart depart2= new Depart();
		depart2.setName("销售部");
		//二级
		Depart depart2_1= new Depart();
		depart2_1.setName("销售一部");
		Depart depart2_2= new Depart();
		depart2_2.setName("销售二部");
		Set<Depart> departs = new HashSet<Depart>();
		departs.add(depart2_1);
		departs.add(depart2_2);
		depart2.setDeparts(departs);
		List<Depart> list = new ArrayList<Depart>();
		list.add(depart1);
		list.add(depart2);
		return list;
	}
	public static void main(String[] args) {
		List<Depart> list = findDepartTopList();
		//    for (Depart depart : list) {
		//      getAllDepartName(depart);
		//    }
		getAllDepartName_2(list,"=");
	}
	/**alle Abteilungen ausgeben*/
	public static void getAllDepartName(Depart depart){
		System.out.println(depart.getName());
		for (Depart chirden : depart.getDeparts()) {
			getAllDepartName(chirden);
		}
	}
	/**alle Abteilungen ausgeben*/
	public static void getAllDepartName_2(Collection<Depart> list,String pre){
		for (Depart depart2 : list) {
			System.out.println( pre +depart2.getName());
			getAllDepartName_2(depart2.getDeparts(),"  "+pre);
		}
	}
}

Zusammenfassung

Das ist der gesamte Inhalt dieses Artikels über die Durchsuchung rekursiver Algorithmen in Java. Hoffentlich ist es für alle hilfreich. Interessierte Freunde können weiterhin die Website konsultieren:

Analyse von Beispielen rekursiver Algorithmen in Java

Codebeispiel zur Lösung des Hanoi-Problems mit einem Stapel in Java (nicht rekursiv)

Detaillierte Erklärung zur Auswahl der Map-Through-Methoden in Java

Bitte hinterlassen Sie Kommentare, wenn Sie Verbesserungen vorschlagen. Vielen Dank für die Unterstützung unserer Freunde!

Erklärung: Der Inhalt dieses Artikels wurde aus dem Internet übernommen und gehört dem Urheberrechtsinhaber. Der Inhalt wurde von Internetbenutzern freiwillig beigesteuert und hochgeladen. Diese Website besitzt keine Eigentumsrechte und hat den Inhalt nicht manuell bearbeitet. Sie übernimmt auch keine rechtlichen Verantwortlichkeiten. Wenn Sie urheberrechtlich anstößige Inhalte entdecken, sind Sie herzlich eingeladen, eine E-Mail an notice#w zu senden.3codebox.com (Bitte ersetzen Sie # durch @ beim Senden von E-Mails zur Meldung von Verstößen und stellen Sie relevante Beweise zur Verfügung. Sobald nachgewiesen, wird diese Website die beanstandeten urheberrechtlichen Inhalte sofort löschen.)