1. Cортировку вставками (Insertion sort), сортирующую за конечное время и эффективному при небольших массивах, а также с частично отсортированными массивами
2. Быструю сортировку (Quicksort), сортирующую быстрее, но требующую O(log n) дополнительной памяти
3. Сортировку подсчетом (Counting sort), эффективный для большого количества данных с небольшим разбросом значений

Далее, в зависимости от типа данных что у нас есть, и их объема, решаем какой алгоритм предпочтительнее использовать.

Вот как паттерн Стратегия, выглядит на UML диаграмме:

А вот пример на языке java, из уже классической, игровой тематики:

// IUnitRender.java
package patterns.strategy;
 
public interface IUnitRender {
 
	public void render();
 
}
 
// UnitRender2D.java
package patterns.strategy;
 
public class UnitRender2D implements IUnitRender {
 
	@Override
	public void render() {
		System.out.println("2D unit");
	}
 
}
 
// UnitRender3D.java
package patterns.strategy;
 
public class UnitRender3D implements IUnitRender {
 
	@Override
	public void render() {
		System.out.println("3D unit");
	}
 
}
 
// UnitSprite
package patterns.strategy;
 
public class UnitSprite {
 
	private IUnitRender render;
 
	public UnitSprite(IUnitRender render) {
		this.render = render;
	}
 
	public void render() {
		render.render();
	}
 
}
 
// TestApp.java
package patterns.strategy;
 
public class TestApp {
 
	public static void main(String[] args) {
		UnitSprite unit;
 
		if(TestApp.hasVideoAdapter()) {
			unit = new UnitSprite(new UnitRender3D());
		} else {
			unit = new UnitSprite(new UnitRender2D());
		}
 
		unit.render();
	}
 
	public static Boolean hasVideoAdapter() {
		return true;
	}
 
}

Пример применения паттерна на UML диаграмме:

А вот, пример применения паттерна в коде, - класс создающий разные типы документов, из одинаковых составных частей:

// IChapter.java
package patterns.factorymethod.report;
 
public interface IChapter {
 
	public String getType();
 
}
 
// IReport.java
package patterns.factorymethod.report;
 
public interface IReport {
 
	public void render();
	public void addChapter(IChapter chapter);	
 
}
 
// CustomReport.java
package patterns.factorymethod.report;
 
import java.util.ArrayList;
import java.util.Iterator;
 
public class CustomReport implements IReport {	
 
	protected ArrayList<IChapter> chapters = new ArrayList<IChapter>();	
 
	@Override
	public void render() {
		for (Iterator<IChapter> iter = chapters.iterator(); iter.hasNext();  ) {
			System.out.println(((IChapter)iter.next()).getType());
		}
	}
 
	@Override
	public void addChapter(IChapter chapter) {
		chapters.add(chapter);
	}
 
}
 
// ExtendedChapter.java
package patterns.factorymethod.report;
 
public class ExtendedChapter implements IChapter {
 
	@Override
	public String getType() {
		return "Extended";
	}
 
}
 
//  IndexChapter.java
package patterns.factorymethod.report;
 
public class IndexChapter implements IChapter {
 
	@Override
	public String getType() {
		return "Index";
	}
 
}
 
// SmallChapter.java
package patterns.factorymethod.report;
 
public class SmallChapter implements IChapter {
 
	@Override
	public String getType() {
		return "Small";
	}
 
}
 
// TitleChapter.java
package patterns.factorymethod.report;
 
public class TitleChapter implements IChapter {
 
	@Override
	public String getType() {
		return "Title";
	}
 
}
 
// ReportCreator.java
package patterns.factorymethod.report;
 
public class ReportCreator {
 
	public IReport createSummaryReport() {
		CustomReport report = new CustomReport();
		report.addChapter(new TitleChapter());
		report.addChapter(new SmallChapter());
		return report;
	}
 
	public IReport createFullReport() {
		CustomReport report = new CustomReport();
		report.addChapter(new TitleChapter());
		report.addChapter(new IndexChapter());
		report.addChapter(new ExtendedChapter());
		return report;
	}
 
}
 
// TestApp.java
package patterns.factorymethod;
 
import patterns.factorymethod.report.ReportCreator;
 
public class TestApp {
 
	public static void main(String[] args) {
		ReportCreator creator = new ReportCreator();
		creator.createFullReport().render();
		System.out.println();
		creator.createSummaryReport().render();
	}
 
}

Результат работы программы:

Title
Index
Extended

Title
Small

Паттерн абстрактная фабрика должен использоваться тогда когда:

• Конкретный вариант требуемого поведения системы дают не отдельные объекты, а четко выраженное семейство связанных объектов
• Объекты одного семейства должны использоваться вместе
• Система должна кофигурироваться одним из семейств объектов

Вот как это выглядит на диаграмме:

В моем примере фабрики мы имеем три вида игровых юнитов Protos, Terran, Zerg (должно быть близко любому кто играл в StarCraft), и некоторое количество игровых юнитов (ботов). Боты создают солдатов нужного типа в зависимости от количества ресурсов добытых работягами, а также боты могут сражаться друг с другом теми юнитами, что были созданы.
Вот код примера, несколько многословный, в силу специфичности синтаксиса явы:

// IUnit.java
package patterns.factory.unit;
 
public interface IUnit {
 
	public int getGroundWeapon();
	public int getAirWeapon();
	public int getShield();
	public int getPrice();
	public String toString();
 
}
 
// CustomUnit.java
package patterns.factory.unit;
 
public class CustomUnit implements IUnit {
 
	@Override
	public int getAirWeapon() {
		return 0;
	}
 
	@Override
	public int getGroundWeapon() {
		return 0;
	}
 
	@Override
	public int getPrice() {
		return 0;
	}
 
	@Override
	public int getShield() {
		return 0;
	}
 
	public String toString() {
		return "a:" + getAirWeapon() + " g:" + getGroundWeapon() + " s:" + getShield() + " p:" + getPrice();
	}
 
}
 
// ProtosSoldier.java
package patterns.factory.unit;
 
public class ProtosSoldier extends CustomUnit implements IUnit {
 
	@Override
	public int getAirWeapon() {
		return 10;
	}
 
	@Override
	public int getGroundWeapon() {
		return 12;
	}
 
	@Override
	public int getPrice() {
		return 100;
	}
 
	@Override
	public int getShield() {
		return 10;
	}
 
}
 
// Terransoldier.java
package patterns.factory.unit;
 
public class TerranSoldier extends CustomUnit implements IUnit {
 
	@Override
	public int getPrice() {
		return 35;
	}
 
	@Override
	public int getAirWeapon() {
		return 5;
	}
 
	@Override
	public int getGroundWeapon() {
		return 8;
	}
 
	@Override
	public int getShield() {
		return 3;
	}
 
}
 
// ZergSoldier.java
package patterns.factory.unit;
 
public class ZergSoldier extends CustomUnit implements IUnit {
 
	@Override
	public int getAirWeapon() {
		return 0;
	}
 
	@Override
	public int getGroundWeapon() {
		return 6;
	}
 
	@Override
	public int getPrice() {
		return 25;
	}
 
	@Override
	public int getShield() {
		return 5;
	}
 
}
 
// IArmyFactory.java
package patterns.factory.army;
 
import patterns.factory.unit.IUnit;
 
public interface IArmyFactory {
 
	public IUnit createSoldier();
 
}
 
// ProtosArmy.java
package patterns.factory.army;
 
import patterns.factory.unit.IUnit;
import patterns.factory.unit.ProtosSoldier;
 
public class ProtosArmy implements IArmyFactory {
 
	@Override
	public IUnit createSoldier() {
		return new ProtosSoldier();
	}
 
}
 
// TerranArmy.java
package patterns.factory.army;
 
import patterns.factory.unit.IUnit;
import patterns.factory.unit.TerranSoldier;
 
public class TerranArmy implements IArmyFactory {
 
	@Override
	public IUnit createSoldier() {
		return new TerranSoldier();
	}
 
}
 
// ZergArmy.java
package patterns.factory.army;
 
import patterns.factory.unit.IUnit;
import patterns.factory.unit.ZergSoldier;
 
public class ZergArmy implements IArmyFactory {
 
	@Override
	public IUnit createSoldier() {
		return new ZergSoldier();
	}
 
}
 
// BotClient.java
package patterns.factory.client;
 
import java.util.ArrayList;
import java.util.Iterator;
 
import patterns.factory.army.IArmyFactory;
import patterns.factory.unit.IUnit;
 
public class BotClient {
 
	private ArrayList <IUnit> units;
	private IArmyFactory factory;
 
	public BotClient(IArmyFactory army) {
		factory = army;
		units = new ArrayList <IUnit> ();
	}
 
	public void createForMoney(int money) {
		Boolean hasMoney = false;
		units.clear();
		do {
			IUnit unit = factory.createSoldier();
			hasMoney = money - unit.getPrice() > 0;
			if(hasMoney){
				units.add(unit);
				money -= unit.getPrice();
			}
		} while(hasMoney);
	}
 
	public int getGroundWeapon() {
		int total = 0;
		Iterator  iter = units.iterator();
	    while (iter.hasNext()) {
	    	total += ((IUnit)iter.next()).getGroundWeapon();
	    }
	    return total;
	}
 
	public int getShield() {
		int total = 0;
		Iterator  iter = units.iterator();
	    while (iter.hasNext()) {
	    	total += ((IUnit)iter.next()).getShield();
	    }
	    return total;
	}
 
	public int unitsCount() {
		return units.size();
	}
 
	public Boolean battle(BotClient client) {
		System.out.println("Units: " + unitsCount() + " vs " + client.unitsCount());
		System.out.println("Attack: " + getGroundWeapon() + " vs " + client.getGroundWeapon());
		System.out.println("Shield: " + getShield() + " vs " + client.getShield());
		float damage = (float)client.getGroundWeapon() / (float)getShield();
		System.out.println("Damage: " + damage);
		float enemyDamage = (float)getGroundWeapon() / (float)client.getShield();
		System.out.println("Enemy damage: " + enemyDamage);
		return enemyDamage < damage;
	}
 
}
 
// TestApp.java
package patterns.factory;
 
import patterns.factory.army.ProtosArmy;
import patterns.factory.army.TerranArmy;
import patterns.factory.army.ZergArmy;
import patterns.factory.client.BotClient;
 
public class TestApp {
 
	public static void main(String[] args) {
		BotClient bot1 = new BotClient(new ProtosArmy());
		BotClient bot2 = new BotClient(new TerranArmy());
		BotClient bot3 = new BotClient(new ZergArmy());
		bot1.createForMoney(400);
		bot2.createForMoney(400);
		bot3.createForMoney(400);
		System.out.println(bot1.battle(bot2));
		System.out.println(bot1.battle(bot3));
	}
 
}

Результат работы примера:

Units: 3 vs 11
Attack: 36 vs 88
Shield: 30 vs 33
Damage: 2.9333334
Enemy damage: 1.0909091
false
Units: 3 vs 15
Attack: 36 vs 90
Shield: 30 vs 75
Damage: 3.0
Enemy damage: 0.48
false

Сегодня речь пойдет о паттерне Строитель, предназначенного для конструирования объектов.
Если процесс создания какого либо сложного объекта из составных имеет схожие этапы, имеет смысл описать единый алгоритм создания включающий в себя действия по созданию необходимого объекта.

Вот как это выглядит в UML:

В моем простом примере логика создания простой игровой карты выносится в класс строителя WorldBuilder, в котором реализовано два метода для создания пустого мира и со случайно расставленными стенами.

 
 
// IPlace.java
 
package patterns.builder.map;
 
public interface IPlace {
 
	public String render();
 
}
 
// FloorPlace.java
 
package patterns.builder.map;
 
public class FloorPlace implements IPlace {
 
	@Override
	public String render() {
		return ".";
	}
 
}
 
// WallPlace.java
 
package patterns.builder.map;
 
public class WallPlace implements IPlace {
 
	@Override
	public String render() {
		return "#";
	}
 
}
 
// World.java
 
package patterns.builder.map;
 
public class World {
 
	private IPlace[][] places;
	private int WIDTH;
	private int HEIGHT;
 
	public World(int width, int height) {
		WIDTH = width;
		HEIGHT = height;
		places = new IPlace[WIDTH][HEIGHT];
	}
 
	public int getWidth() {
		return WIDTH;
	}
 
	public int getHeight() {
		return HEIGHT;
	}
 
	public void setPlace(int x, int y, IPlace place) {
		places[x][y] = place;
	}
 
	public void render() {
		for(int y = 0; y < HEIGHT; y++) {
			for(int x = 0; x < WIDTH; x++) {
				System.out.print(places[x][y].render());
			}
			System.out.println();
		}
	}
 
}
 
// WorldBuilder.java
 
package patterns.builder.map;
 
public class WorldBuilder {
 
	private World world;
 
	public WorldBuilder(World world) {
		this.world = world;
	}
 
	public void createFloorAt(int x, int y) {
		world.setPlace(x, y, new FloorPlace());
	}
 
	public void createWallAt(int x, int y) {
		world.setPlace(x, y, new WallPlace());
	}
 
	public void createEmptyWorld() {
		for(int y = 0; y < world.getHeight(); y++) {
			for(int x = 0; x < world.getWidth(); x++) {
				createFloorAt(x, y);
			}
		}
	}
 
	public void createRandomWorld(int emptynessRatio) {
		for(int y = 0; y < world.getHeight(); y++) {
			for(int x = 0; x < world.getWidth(); x++) {
				if(Math.round(Math.random() * 100) < emptynessRatio){
					createFloorAt(x, y);
				} else {
					createWallAt(x, y);
				}
			}
		}
	}
 
}
 
// TestApp.java
 
package patterns.builder;
 
import patterns.builder.map.World;
import patterns.builder.map.WorldBuilder;
 
public class TestApp {
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		World world = new World(20, 5);
		WorldBuilder builder = new WorldBuilder(world);
		builder.createEmptyWorld();
                      world.render();
		builder.createRandomWorld(90);
		world.render();
	}
 
}
 

А вот результат работы:

....................
....................
....................
....................
....................

...##......#........
.#..................
.......#.......#....
.......#..#.....#...
..##....#.....#.....

Цепочка обязанностей выстраивает объекты составных частей приложения связанными между собой по цепочке, для передачи запроса на обработку от более низких, детализированных слоев системы к более высоким глобальным.

Вот UML диаграмма:

Классический пример это контекстная справка в Microsoft Office, вы можете нажать кнопку вопросительного знака и кликнуть на любом элементе интерфейса, а система попытается найти страницу справки, максимально соответствующую запрошенному элементу. Делается это следующим образом, — поскольку интерфейс системы иерархичен, то запрс справки начинает подниматься снизу вверх — от элемента по которому был произведен клик вверх, первый элемент который «возьмется дать ответ», и покажет справку.

В моем случае Цепочку Ответственности иллюстрирует класс игрового юнита, поведение к которому приближается вражеский ююнит, и в зависимости от игровой ситуации мы решаем как он поступит. Я определил несколько поведений: DefaultBehavoir (бызовый класс с общим функционалом), CarefulBehavoir (осторожность), AttackBehavoir (смелость), AngryBehavoir (злость). Мы можем выстроить иерархию поведения так как захотим (при этом верхнее поведение играет более важную роль при принятии решений).

Вот код примера:

// IBehavoir.java
 
package patterns.chain;
 
public interface IBehavoir {
 
	public int handle(int distance, int power);
 
}
 
// DefaultBehavoir.java
 
package patterns.chain;
 
public class DefaultBehavoir implements IBehavoir {
 
	static public int WAIT = 0;
	static public int ATTACK = 1;
	static public int RUN = 2;
 
	protected DefaultBehavoir behavoir;
	protected Unit unit;
 
	public DefaultBehavoir(Unit unit) {
		this.unit = unit;
	}
 
	public int handle(int distance, int power) {
		if(behavoir != null) {
			return behavoir.handle(distance, power);
		} else {
			System.out.println("DefaultBehavoir::handle()");
			return DefaultBehavoir.WAIT;
		}
	}
 
	public DefaultBehavoir addBehavoir(DefaultBehavoir behavoir) {
		this.behavoir = behavoir;
		return this;
	}	
 
	static public String getCode(int option) {
		switch(option) {
			case 1:
				return "attack!!!";
			case 2:
				return "run!";
			default:
				return "waiting...";
		}
	}
 
}
 
// CarefulBehavoir.java
 
package patterns.chain;
 
public class CarefulBehavoir extends DefaultBehavoir implements IBehavoir {
 
	public CarefulBehavoir(Unit unit) {
		super(unit);
	}
 
	public int handle(int distance, int power) {
		System.out.println("CarefulBehavoir::handle()");
		if(power < unit.getPower()) {
			if(distance < unit.getAttackDistance()) {
				return DefaultBehavoir.ATTACK;
			} else {
				return DefaultBehavoir.WAIT;
			}
		} else if((distance + 2 < unit.getAttackDistance()) && (power > unit.getPower()))  {
			return DefaultBehavoir.RUN;
		}
		return super.handle(distance, power);
	}	
 
}
 
// AttackBehavoir.java
 
package patterns.chain;
 
public class AttackBehavoir extends DefaultBehavoir implements IBehavoir {
 
	public AttackBehavoir(Unit unit) {
		super(unit);
	}
 
	public int handle(int distance, int power) {
		System.out.println("AttackBehavoir::handle()");
		if((distance < unit.getAttackDistance()) && (power < unit.getPower())) {
			return DefaultBehavoir.ATTACK;
		}
		return super.handle(distance, power);
	}
 
}
 
// AngryBehavoir.java
 
package patterns.chain;
 
public class AngryBehavoir extends DefaultBehavoir implements IBehavoir {
 
	public AngryBehavoir(Unit unit) {
		super(unit);
	}
 
	public int handle(int distance, int power) {
		System.out.println("AngryBehavoir::handle()");
		if((distance / 2 < unit.getAttackDistance()) && (power / 5 < unit.getPower())) {
			return DefaultBehavoir.ATTACK;
		}
		return super.handle(distance, power);
	}
 
}
 
// Unit.java
 
package patterns.chain;
 
public class Unit {
 
	protected int power;
	protected int attackDistance;
	private DefaultBehavoir behavoir;
 
	public Unit(int power, int attackDistance) {
		this.power = power;
		this.attackDistance = attackDistance;
	}
 
	public int getPower() {
		return power;
	}
 
	public int getAttackDistance() {
		return attackDistance;
	}
 
	protected void setBehavoir(DefaultBehavoir behavoir) {
		this.behavoir = behavoir;
	}
 
	protected DefaultBehavoir getBehavoir() {
		return behavoir;
	}
 
	public int processSituation(int distance, int power) {
		return behavoir.handle(distance, power);
	}	
 
}
 
// TestApp.java
 
package patterns.chain;
 
public class TestApp {
 
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Unit unit = new Unit(5,10);
		unit.setBehavoir(
			new CarefulBehavoir(unit).addBehavoir(
				new AttackBehavoir(unit).addBehavoir(
					new DefaultBehavoir(unit)
				)
			)
		);
		System.out.println(DefaultBehavoir.getCode(unit.processSituation(1,1)));
		System.out.println(DefaultBehavoir.getCode(unit.processSituation(5,10)));
		System.out.println(DefaultBehavoir.getCode(unit.processSituation(20,5)));
 
		unit.setBehavoir(
			new AngryBehavoir(unit).addBehavoir(
				new CarefulBehavoir(unit).addBehavoir(
					new DefaultBehavoir(unit)
				)
			)
		);
 
		System.out.println(DefaultBehavoir.getCode(unit.processSituation(1,1)));
		System.out.println(DefaultBehavoir.getCode(unit.processSituation(7,20)));
		System.out.println(DefaultBehavoir.getCode(unit.processSituation(20,5)));
 
	}
 
}

Вот результат работы программы:

CarefulBehavoir::handle()
attack!!!
CarefulBehavoir::handle()
run!
CarefulBehavoir::handle()
AttackBehavoir::handle()
DefaultBehavoir::handle()
waiting...
AngryBehavoir::handle()
attack!!!
AngryBehavoir::handle()
attack!!!
AngryBehavoir::handle()
CarefulBehavoir::handle()
DefaultBehavoir::handle()
waiting...

Видно как злость влияет на принятие благоразумных решений.
Пример, к сожалению, далек от совершенства но, надеюсь, общую идею иллюстрирует.

• субъект находится на другой машине и Прокси скрывает протокол доступа, при обращениях
• создает экземпляр субъекта, только когда это действительно надо, кеширует результаты.
• может контролировать права доступа при вызовах
• производит синхронные вызовы в асинхронной среде

На диаграмме прокси выглядит так:

Короткий пример Прокси:

class XMPPRequest():
 
    def __init__(self, connect):
        pass
 
    def send(self, to, text):
        return True
 
class XmppProxy():
 
    def send(self, who, to, text):
        xmpp = XMPPRequest(who)
        return xmpp.send(to, text)
 
if __name__ == '__main__':
    proxy = XmppProxy()
    print(proxy.send("mrjazz", "team", "hi all"))

На диаграмме Приспособленец, выглядит следующим образом:

Имеет использовать Приспособленца если одновременно выполняются следующие условия:

• в приложении используется большое число обьектов, из-за этого высоки расходы на хранение
• большую часть состояния обьектов можно вынести из объекта Приспособленца

Код примера:

 
class Wall:
 
    def draw(self):
        return "#"
 
class Floor:
 
    def draw(self):
        return "."
 
class MapFactory:
 
    def __init__(self):
        self.classes = (Floor(), Wall())
 
    def getMapClassByNum(self, num):
        return self.classes[num]
 
if __name__ == '__main__':
    map = """
111101111111
100000000001
100011110011
101000010001
111111111101"""
 
    factory = MapFactory()
    for line in map.split("\n")[1:]:
        for i in line:
            print(factory.getMapClassByNum(int(i)).draw()),
        print("")
 
--------------------------------
 
# # # # . # # # # # # #
# . . . . . . . . . . #
# . . . # # # # . . # #
# . # . . . . # . . . #
# # # # # # # # # # . #
 

Вот как выглядит Фасад на диаграмме:

Простой пример, реализующий Фасад на Python:

 
class Tree:
 
    def grow(self):
        print("grow tree")
 
class Child:
 
    def born(self):
        print("born child")
 
class House:
 
    def build(self):
        print("build house")
 
class TheMenFacade:
 
    def __init__(self):
        self._tree = Tree()
        self._child = Child()
        self._house = House()
 
    def growTree(self):
        self._tree.grow()
 
    def bornChild(self):
        self._child.born()
 
    def buildHouse(self):
        self._house.build()
 
if __name__ == '__main__':
 
    print 'Content-Type: text/plain'
    print ''    
 
    facade = TheMenFacade()
    facade.bornChild()
    facade.buildHouse()
    facade.growTree()
 
--------------
 
born child
build house
grow tree
 

Классический пример Декоратора, — это какой-нибудь класс, рисующий прямоугольник, с добавлением декораторов, которые рисуют рамки, заливают цветом или изображением. Причем, применение декоратора, рисующего рамку дважды, нарисует двойную рамку.

На диаграмме Декоратор выглядит так:

Пример реализации паттерна Декоратор:

 
class BaseModel():
 
    def __init__(self):
        self.features = {"speakers":4, "airbag": 1, "engine": "1.2L"}
 
    def getPrice(self):
        return 12000
 
class AmbientModel():
 
    def __init__(self, model):
        self.price = model.getPrice() + 2200
        self.features = model.features
        self.features["airbag"] = 2
        self.features["speakers"] = 6
        self.features.setdefault("ligh", "halogen")
 
    def getPrice(self):
        return self.price
 
class SportModel(BaseModel):
 
    def __init__(self, model):
        self.price = model.getPrice() + 3800
        self.features = model.features
        self.features["airbag"] = 4
        self.features["engine"] = "1.6L"
 
    def getPrice(self):
        return self.price
 
class Auto:
 
    def __init__(self, model):
        self.model = model
 
    def specification(self):
        for i in self.model.features.keys():
            print("%-10s: %s" % (i, self.model.features[i]))
        print(("price     : %d") % self.model.getPrice())
 
if __name__ == '__main__':
    model = BaseModel()
    model = AmbientModel(model)
    model = SportModel(model)
    auto = Auto(model)
    auto.specification()
 
-------------------
 
airbag    : 4
engine    : 1.6L
speakers  : 6
ligh      : halogen
price     : 18000
 

Компоновщик организует объекты в древовидные структуры для представления иерархии часть-целое. Всевозможные иерархии деревьев страниц в каталогах, файлов в папках являются яркими представителями паттерна Компоновщик.

Диаграмма для Компоновщика, выглядит так:

Реализовывая Компоновщик, нужно помнить о том чтобы интерфейс Component был максимально дополнен используемыми публичными методами, избавляя клиента от приведения к типу или проверки существования метода (в случае скриптовых языков). Также? стоит сразу позаботиться о максимально удобном функционале для управления элементами (помимо стандартных Add, Remove, GetChildIn).

Пример реализации на Python:

 
class TreeItem:
 
    def __init__(self, name):
        self.items = []
        self.name = name
        self.current = 0
 
    def __iter__(self):
        return self
 
    def add(self, item):
        self.items.append(item)
        return item
 
    def remove(self, name):
        self.items = [i for i in self.items if i.name != name]
 
    def __len__(self):
        return len(self.items)
 
    def get(self, i):
        return self.items[i]
 
    def next(self):
        self.current += 1
        if len(self.items) >= self.current:
            return self.items[self.current-1]
        else:
            raise StopIteration
 
if __name__ == '__main__':
    root = TreeItem('/')
    root.add(TreeItem("folder1"))
 
    print root.get(0).name
    root.remove("folder1")
 
    root.add(TreeItem("folder2")).add(TreeItem("folder21"))
    root.add(TreeItem("folder3")).add(TreeItem("folder31").add(TreeItem("folder311")))
 
    def walk(item, level):
        for i in range(level):
            print(" "),
        print(item.name)
        for i in item:
            walk(i, level + 1)
 
    walk(root, 0)
 
-----------------------------
folder1
/
  folder2
    folder21
  folder3
    folder311