Тест нарисовать дерево расшифровка: Графический тест «Дерево» | Psylist.net

Психологический тест для детей «Нарисуй дерево»

Если вас беспокоит поведение вашего ребенка, проведите с ним несложный тест, чтобы выяснить, что происходит и как с этим справляться.

Ребенку предлагается нарисовать лиственное дерево. Полноценное изображение дерева подразумевает наличие трех элементов: корней, ствола, кроны. После того как ребенок посчитает свой рисунок законченным, можно приступить к расшифровке изображения и уяснить для себя, по поводу каких проблем следует обратиться к психологу.

Ветви

• Двумерные ветви. Двумерные ветви (изображение двумя параллельными линиями) – практичность, ясное мышление, реалистичный взгляд на вещи и явления. Энергичность, способность находить решения возникающих проблем, самостоятельность.
• Искривленные ветви. Искривленные ветви – мягкий, неустойчивый характер, неуверенность, склонность поддаваться чужому влиянию, подчиняться. Ему больше нравится бездельничать и развлекаться, чем сосредоточенно трудиться над чем-нибудь.
• Направлены вверх. Ветви, бескомпромиссно направленные вверх – прямолинейный, вспыльчивый ребенок, не способный сдержать свои эмоции, контролировать импульсы, склонен к риску. Предпочитает скорее действовать, чем думать.
• Одномерные ветви. Одномерные ветви в виде паутины или напоминающие брызги фонтана. В рисунках маленьких детей – нормальное явление, у детей постарше – признак крайней неуверенности. Ребенка что-то беспокоит. В силу наличия проблемы он чувствует нервозность, вспыльчивость, раздражительность.
• Отделены от ствола. Ветви отделены от ствола – слабая связь с реальностью, поверхностность мышления, непостоянство характера.
• Противоположное направление. Среди ветвей отдельные, растущие в противоположном направлении – тревожный признак. Это выражение внутреннего конфликта (если ребенок старше дошкольного возраста).
• Расширение на концах. Ветви, исходя из ствола, расширяются, так что на конце они оказываются шире, чем вначале. Ребенок – возмутитель спокойствия. Он ориентирован на внешний мир, любит приключения и забавы, не упустит случай проявить себя, склонен к риску, обладает духом авантюризма и здоровой агрессией.
• Слабые ветви. Тонкие, слабые ветви, склоненные вниз – кроткий, покорный характер. Это меланхоличный, замкнутый ребенок, склонный к размышлениям и уединению. Он внешне безропотный, но внутри может переживать сильные эмоции.
• Спиленные ветви. Спиленные ветви – крайний негативизм, угнетенное состояние, отсутствие веры в будущее, ощущение ненужности и бесполезности. Такие ветви обычно рисуют дети старше 9 лет.

Дерево

• Слабое деревце. Очень слабое, немощное деревце (даже с опорой) – потребность в поддержке, отсутствие любви и заботы, желание иметь сильного покровителя и ощущать больше теплоты в семейных отношениях и в отношениях с другими людьми.
• Пейзаж. Если ребенок не ограничивается изображением дерева, а создает вокруг нарисованного дерева целый мир, рисует окружающий пейзаж – наличие чувства неуверенности, незащищенности, уязвимости, которое ребенок маскирует. Ребенок старается не раскрывать себя, опасается негативного к себе отношения со стороны окружающих.

Корни

Корни – часть дерева, непосредственно связанная с землей, питанием, ростом, восстановлением, истоками, природой, но в то же время корни – это скрытый элемент дерева и его опора, средство заземления, основа.

• Огромные корни. Огромные, преувеличенные корни, подчас превосходящие размерами само дерево, — неуравновешенность, внутренний дисбаланс, скрытый конфликт.
• Отдельные корни. Корни изображены отдельными линиями, как трава – поверхностность мышления, леность, нежелание углубляться в детали. Такой ребенок предпочитает заниматься активной физической деятельностью.
• Отсутствие корней. Если на рисунке у основания дерева отсутствуют и корни, и линия земли – подверженность стрессам.
• Реально видимые корни. Ребенок, смотрящий на мир реалистично, все взвешивающий в уме, размышляющий – изобразит только видимую часть корней, которая чуть видна на поверхности земли.
• Чёткие корни. Если корни изображены четко, хорошо прорисованы, имеют адекватные размеры или на них сделан акцент (жирные линии, усиленный нажим и т. д.) – ребенок придает большое значение внешней опоре, поддержке со стороны окружающих. Возможно, он сопротивляется взрослению, отказывается брать на себя ответственность, принимать решения, быть самостоятельным. Ребенок зависим, флегматичен, не уверен в себе, хочет подольше оставаться маленьким. (Задача родителей не потакать, а мягко, без агрессии и сильного давления, воспитывать самостоятельность, поощрять любое проявление инициативы)

Крона

• Каракули. Крона обозначена беспорядочными каракулями – безалаберность, импульсивность. Такой ребенок склонен к резким сменам настроения, легко возбуждается, выплескивает свои эмоции, не любит что-то скрывать и держать в себе. Легко забывает обиды, незлопамятен. Действует спонтанно, руководствуется интуицией, обладает способностями к творческой деятельности, артистичен.
• Крона в завитках.. Крона типа «шкура барашка» — энергичность, трудолюбие, энтузиазм. Ребенок с удовольствием берется за дело, и доводит его до конца, никогда не жалуется, относится к жизни легко, воспринимает ее жизнерадостно, но поверхностно, глубина явлений остается для него скрытой, недоступной. Он не способен «читать между строк», часто рассеян. Увлекающаяся натура, обладает хорошим физическим здоровьем.
• Крона из нескольких частей. Крона состоит из нескольких частей, напоминая стаю облачков, — осторожность, вдумчивость, способность анализировать и находить решения возникающих проблем, склонность к самоконтролю, аккуратность во всем – и в манере поведения, и в отношении к окружающим.
• Крона овальной формы. Крона овальной формы – скрытность, некая отгороженность от внешнего мира. Ребенок, склонен не решать проблемы, а уходить от них, замыкаться в себе. Любит фантазировать, в реальной жизни он не привык к решительным действиям, для этого он слишком медлителен.
• Крона сдвинута влево. Крона сдвинута влево – ребенка больше привлекает свой внутренний мир, ему больше по душе погружение в мечту, чем решительные действия.
• Крона сдвинута вправо. Крона любой формы, сдвинутая вправо – направленность ребенка в будущее, активность, стремление действовать, добиваться своего.
• Крона-цветок. Форма кроны напоминает форму цветка – незрелость и поверхностность мышления или достаточно хорошая адаптация, легкость восприятия, здоровый оптимизм, жизнерадостность. Предпочтение интерпретации отдается с учетом значения других элементов рисунка.
• Нетипичная форма кроны. Любые нетипичные формы кроны – либо сила воображения, творческие способности ребенка, либо низкая социальная приспособленность, спутанность мышления.
• Обвисшее облако. Крона в форме обвисшего облака – слабость «Я», зависимость, слабоволие, безынициативность. Ребенок пассивен, не привык самостоятельно принимать решения, подвержен чужому влиянию.
• Подчеркивание кроны. Чрезмерно подчеркнутая крона, ярко выраженное акцентирование на ней – эмоциональная заторможенность, слабо развитые способности к рассуждению.
• Спиралевидная форма кроны. Овальная, спиралевидная форма кроны – сосредоточенность на собственном «Я», уравновешенность, самодостаточность. Ребенка трудно вывести из себя, он обладает спокойным, мирным характером, старается не контактировать без необходимости с окружающими, избегает суеты, замкнут. Изображение концентрических кругов внутри кроны – перенесенная в прошлом психическая травма.
• Штриховка кроны. Крона любой формы заштрихована или обозначена исключительно нанесением штриховки – нервность, вспыльчивость, несколько ослабленный самоконтроль, подозрительность, смятение, испытывает трудности в принятии решений, склонен скорее доверять авторитетному мнению, чем самому искать ответы на вопросы.

Ствол

Самая распространенная форма – прямая, типично для детей, не достигших 12 лет.

• Асимметрия линий. Ствол изображен двумя асимметричными линиями – неустойчивый характер, несколько замкнут, его контакт с окружением немного осложнен, стремится к уединению. Может быть упрямым, игнорировать оценки и мнения окружающих, противостоять авторитету взрослых.
• Кора. Если ребенок наносит на ствол некий рисунок, пытаясь изобразить кору – рациональность, наблюдательность, критичность ума.
• Корни у ствола. У основания ствола условно изображена корневая система – реальный взгляд на вещи, стремление к определенности и конкретности, развитое чувство ответственности. Также – некоторая неуверенность, сомнения, недостаточная внутренняя опора.
• Кривизна ствола плавная. Кривизна ствола передана волнистыми линиями – символ хорошей приспособляемости, энергичности, позитивного отношения к жизни.
• Неровности ствола. Ствол покрыт мелкой или крупной крапинкой, закрашенными пятнами, с помощью которых ребенок хотел передать неровность поверхности ствола – трезво смотрит на вещи и всегда пытается быть адекватным, но иногда (и в данный момент) он не удовлетворен собой, его беспокоит внутренняя проблема.
• Округленное основание ствола. Припухлое, округленное основание – пассивность, медлительность движений и ума, умеренность, основательность, размеренность. Ребенок не очень деятельный, спокойный, не признает поспешные и резкие действия.
• Прямой ствол. Если ребенок старше – незрелость и инфантилизм; он не продвинулся в развитии, отстает в школе. Он «увяз» в детских отношениях и привычках, застрял на каком-то этапе роста и пользуется теми навыками, которые приобрел ранее, не продвигаясь вперед.
• Расширение ствола к низу. Основание ствола имеет расширение – более зрелая форма.
• Расширение ствола к низу влево. Если расширение перенесено влево – недостаток инициативы и самостоятельности, мягкость, уступчивость, робость.
• Расширение ствола к низу вправо. Основание ствола, расширенное вправо – расчетливость, привычка все взвешивать, находить компромиссные решения, настойчивость, желание добиваться своего.
• Ствол из прерывистых линий. Ствол дерева изображен штриховыми, прерывистыми линиями – неусидчивость, подвижность, нетерпеливость. Такой ребенок чувствителен, раним, подвержен резкой смене настроения, может быть нервным, капризным. Почему ребёнок не слушается?
• Ствол нестандартной формы. Ствол нестандартной формы – признак чувства неудовлетворенности. Ребенок испытывает какие-то трудности, возможно переходного возраста, либо переживает дискомфорт.
• Штриховка слева. Ствол заштрихован только с левой стороны – тонкая, чувствительная натура. Ребенок эмоционален, впечатлителен, восприимчив. Он склонен к творческой деятельности.
• Штриховка справа. На стволе есть штриховка, но она нанесена исключительно на правую сторону – контактность, способность хорошо ладить с окружающими, развитое чувство социального, легкость в установлении и поддержании отношений с людьми. Экстраверт.
• Штриховка ствола. Ствол покрыт штриховкой – неуверенность, застенчивость, скрытность. Ребенок трудно принимает решения, переживает по мелочам. Он очень осторожен, часто испытывает беспокойство. Возможно, обладает тревожным, легко возбудимым характером.

Источник

Рисуночный тест «Слон»

Существуют различные методы диагностики, позволяющие оценить физическое, моральное, эмоциональное состояние человека. Один из таких методов — исследование человека при помощи теста «Слон.» Итак…

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

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

Органы чувств хоть и выписаны, но сделаны несколько небрежно, кое-как прорисован хобот. И очень важная деталь — на ногах слона нет ногтей. Это верный признак, что человек не аккуратист, не тщателен, не обращает особого внимания на качество жизни, не видит в ней малого.

Если еще и ноги прорисованы небрежно, это свидетельство того, что человек неоснователен.

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

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

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

Большие, задранные вверх бивни указывают на возможность и готовность постоять за себя. Если бивни хоть и прорисованы, но маленькие и не задраны вверх — это говорит о неагрессивности рисовавшего.

Прямо за головой, где у слона голова переходит в туловище, видим выемку Если она выписана явно, значит, рисовавший раним, ему о многом хотелось бы забыть в жизни. Хвост и хобот опушены вниз. В принципе, это указывает на раздумчиво-грустный, небойкий характер. Но если наряду с этим в рисунке было бы много всяких округлостей и задора, можно было бы предположить, что автор склонен к частой смене настроений.

Уши нарисованы в спокойном состоянии, что немаловажно для вывода о ровном или нервозном характере. Если у слона уши подняты вверх — не исключено, что автор рисунка постоянно встревожен, ждет от жизни каверз и неприятностей.

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

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

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

Тэги : тест рисуночная методика слон тестирование ребенка взрослый

#

Тэги : #

python — Как я могу создать дерево для кодирования и декодирования Хаффмана?

спросил 10 лет, 11 месяцев назад

Изменено 6 лет, 4 месяца назад

Просмотрено 50 тысяч раз

По моему заданию я должен кодировать и декодировать деревья Хаффмана. У меня проблема с созданием моего дерева, и я застрял.

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

Для первого цикла for я получил все значения и индекс из текстового файла, который использовал в своем основном блоке для тестирования.

Во втором цикле for я вставил все в приоритетную очередь.

Я так застрял в том, куда идти дальше — я пытаюсь создавать узлы, но я не понимаю, как двигаться дальше. Может ли кто-нибудь сказать мне, правильно ли я делаю это?

 def _create_code(я, частоты):
    '''(HuffmanCoder, sequence(int)) -> NoneType
    перебирать индекс в последовательности, сохраняя ее длину 256 элементов, '''
    # исправить строку документации
    p = Приоритетная очередь ()
    частоты печати
    индекс = 0
    для значения в частотах:
        если значение != 0:
            вывести значение #priority
            печатать индекс #elm
            Распечатать '-----------'
        индекс = индекс + 1
    для i в диапазоне (len (частоты)):
        если частоты[i] != 0:
            p. insert(i, частоты[i])
            напечатать i,частоты[i]
            если p.is_empty():
                а = p.get_min()
                б = p.get_min()
                n1 = self.HuffmanNode(Нет, Нет, а)
                n2 = self.HuffmanNode(Нет, Нет, б)
                выведите a, b, n1, n2
    пока не p.is_empty():
        p.get_min()
 

Я вручную вставил первые два, чтобы начать свое дерево, это правильно?

Как мне продолжить? Я знаю идею этого, просто с точки зрения кода я очень застрял.

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

HuffmanNode происходит от этого вложенного класса:

 class HuffmanNode(object):
    def __init__(self, left=None, right=None, root=None):
        self.left = левый
        сам.право = правильно
        self.root = корень
 

• питон
• дерево
• кодировать
• код Хаффмана

2

Алгоритм Хаффмана в Википедии точно говорит вам, как создать дерево узлов, поэтому ваша программа может быть основана на этом или другом подобном алгоритме. Вот программа Python с комментариями, показывающими соответствующий шаг алгоритма википедии. Тестовые данные — частоты букв алфавита в английском тексте.

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

 очередь импорта
класс HuffmanNode (объект):
    def __init__(self, left=None, right=None, root=None):
        self.left = левый
        сам.право = правильно
        self.root = root # Почему? Ни для чего не нужен.
    детей защиты (я):
        возврат((само.слева, само.право))
частота = [
    (8.167, 'а'), (1.492, 'б'), (2.782, 'в'), (4.253, 'г'),
    (12.702, 'д'), (2.228, 'е'), (2.015, 'г'), (6.094, 'з'),
    (6,966, «и»), (0,153, «к»), (0,747, «к»), (4,025, «л»),
    (2,406, «м»), (6,749, «н»), (7,507, «о»), (1,929, «р»),
    (0,095, «к»), (5,987, «г»), (6,327, «с»), (9,056, «т»),
    (2,758, 'и'), (1,037, 'в'), (2,365, 'ш'), (0,150, 'х'),
    (1,974, 'у'), (0,074, 'з')]
def create_tree (частоты):
    p = очередь. PriorityQueue()
    для значения в частотах: # 1. Создайте конечный узел для каждого символа
        p.put(value) # и добавляем в приоритетную очередь
    в то время как p.qsize() > 1: # 2. Пока имеется более одного узла
        l, r = p.get(), p.get() # 2а. удалить два верхних узла
        узел = узел Хаффмана (l, r) # 2b. создать внутренний узел с детьми
        p.put((l[0]+r[0], узел)) # 2c. добавить новый узел в очередь
    return p.get() # 3. дерево завершено - вернуть корневой узел
узел = создать_дерево (частота)
печать (узел)
# Рекурсивно пройтись по дереву до листьев,
# присвоение кодового значения каждому символу
def walk_tree (узел, префикс = "", код = {}):
    возврат (код)
код = walk_tree (узел)
для i в отсортированном (частота, реверс = True):
    печать (i [1], '{: 6.2f}'. формат (i [0]), код [i [1]])
 

При обработке данных алфавита результирующие коды Хаффмана:

 e 12,70 100
т 9.06 000
8.17 1110
о 7,51 1101
я 6,97 1011
п 6,75 1010
с 6.33 0111
ч 6.09 0110
р 5. 99 0101
д 4.25 11111
л 4.03 11110
в 2.78 01001
и 2,76 01000
м 2.41 00111
ш 2.37 00110
ф 2.23 00100
г 2,02 110011
у 1.97 110010
р 1,93 110001
б 1,49 110000
v 1.04 001010
к 0,75 0010111
j 0,15 001011011
х 0,15 001011010
q 0,10 001011001
з 0,07 001011000
 

2

Еще одно решение, возвращающее словарь {метка:код} и рекурсивный словарь дерево , содержащее результирующий граф. Входные данные vals представлены в виде словаря {label:freq} :

 def assign_code (узлы, метка, результат, префикс = ''):
    дочерние элементы = узлы [метка]
    дерево = {}
    если len(дети) == 2:
        дерево ['0'] = assign_code (узлы, дочерние элементы [0], результат, префикс + '0')
        дерево ['1'] = assign_code (узлы, дочерние элементы [1], результат, префикс + '1')
        дерево возврата
    еще:
        результат[метка] = префикс
        ярлык возврата
Def Huffman_code (_vals):
    вальс = _vals.copy()
    узлы = {}
    for n в vals. keys(): # инициализация листьев
        узлы [n] = []
    в то время как len(vals) > 1: # создание бинарного дерева
        s_vals = отсортировано (vals.items (), ключ = лямбда x: x [1])
        a1 = s_vals[0][0]
        a2 = s_vals[1][0]
        vals[a1+a2] = vals.pop(a1) + vals.pop(a2)
        узлы[a1+a2] = [a1, a2]
    код = {}
    корень = а1+а2
    дерево = {}
    tree = assign_code(nodes, root, code) # присвоение кода данному бинарному дереву
    код возврата, дерево
 

Можно использовать как:

 freq = [
(8.167, 'а'), (1.492, 'б'), (2.782, 'в'), (4.253, 'г'),
(12.702, 'д'), (2.228, 'е'), (2.015, 'г'), (6.094, 'з'),
(6,966, «и»), (0,153, «к»), (0,747, «к»), (4,025, «л»),
(2,406, «м»), (6,749, «н»), (7,507, «о»), (1,929, «р»),
(0,095, «к»), (5,987, «г»), (6,327, «с»), (9,056, «т»),
(2,758, 'и'), (1,037, 'в'), (2,365, 'ш'), (0,150, 'х'),
(1,974, 'у'), (0,074, 'з')]
vals = {l:v для (v,l) в частоте}
код, дерево = Huffman_code(vals)
text = 'hello' # текст для кодирования
encoded = ''. join([код[t] для t в тексте])
print('Закодированный текст:',закодированный)
декодировано = []
я = 0
while i < len(encoded): # декодирование с использованием двоичного графа
    ch = закодировано [i]
    действие = дерево[ch]
    пока не isinstance(act, str):
        я += 1
        ch = закодировано [i]
        действие = действие [ч]
    decoded.append(действие)
    я += 1
print('Расшифрованный текст:',''.join(декодированный))
 

Дерево можно визуализировать с помощью Graphviz как:

Рисунок был сгенерирован следующим скриптом как (необходим Graphviz):

 def draw_tree(tree, prefix = ''):
    если isinstance (дерево, улица):
        descr = 'N%s [label="%s:%s", fontcolor=blue, fontsize=16, width=2, shape=box];\n'%(префикс, дерево, префикс)
    else: # Описание узла
        descr = 'N%s [label="%s"];\n'%(префикс, префикс)
        для ребенка в tree.keys():
            descr += draw_tree(дерево[дочерний элемент], префикс = префикс+дочерний элемент)
            descr += 'N%s -> N%s;\n'%(префикс,префикс+потомок)
    вернуть описание
подпроцесс импорта
с open('graph. dot','w') как f:
    f.write('орграф G {\ n')
    f.write (draw_tree (дерево))
    е.написать('}')
subprocess.call('точка -Tpng graph.dot -o graph.png', shell=True)
 

1

@Dave walk_tree отсутствует код обработки дерева

 # Рекурсивно пройти по дереву до листьев,
# присвоение кодового значения каждому символу
def walk_tree (узел, префикс = "", код = {}):
    если isinstance (узел [1].left [1], узел Хаффмана):
        walk_tree (узел [1]. слева, префикс + «0», код)
    еще:
        код[узел[1].left[1]]=префикс+"0"
    если isinstance (узел [1]. право [1], узел Хаффмана):
        walk_tree (узел [1]. право, префикс + "1", код)
    еще:
        код[узел[1].право[1]]=префикс+"1"
    возврат (код)
 

Класс @Dave HuffmanNode(object) содержит небольшую ошибку. Когда две частоты равны, выдается исключение: например, пусть

 freq = [(200/3101, 'd'), (100/3101, 'e'), (100/3101, 'f')]
 

Затем вы получаете TypeError: неупорядоченные типы: HuffmanNode() < str(). Проблема связана с реализацией PriorityQueue. Я подозреваю, что когда первые элементы кортежей сравниваются равными, PriorityQueue хочет сравнить вторые элементы, один из которых является объектом python. Вы добавляете lt для вашего класса, и проблема решена.

 по определению __lt__(я,другой):
        вернуть 0
 

Сегодня я решал эту проблему, пытаясь сопоставить результаты, приведенные выше. По большей части это решение работает хорошо, но единственное, что я нахожу неинтуитивным, — это добавлять [0] и [1] при печати неузла (листа). Но это отвечает на вопрос о чудесах - вы можете распечатать его, используя любой механизм обхода

 очередь импорта
класс HuffmanNode (объект):
    def __init__(self,left=None, right=None, root=None):
        self.left = левый
        сам.право = правильно
        self.root = корень
    детей защиты (я):
        возврат (я.слева,я.право)
    предварительный заказ по определению (я, путь = нет):
        если путь отсутствует:
            путь = []
        если self. left не None:
            если isinstance(self.left[1], HuffmanNode):
                self.left[1].preorder (путь+[0])
            еще:
                печать (я.слева, путь+[0])
        если self.right не None:
            если isinstance(self.right[1], HuffmanNode):
                self.right[1].preorder(путь+[1])
            еще:
                печать (я.право, путь+[1])
частота = [
    (8.167, 'а'), (1.492, 'б'), (2.782, 'в'), (4.253, 'г'),
    (12.702, 'д'), (2.228, 'е'), (2.015, 'г'), (6.094, 'з'),
    (6,966, «и»), (0,153, «к»), (0,747, «к»), (4,025, «л»),
    (2,406, «м»), (6,749, «н»), (7,507, «о»), (1,929, «р»),
    (0,095, «к»), (5,987, «г»), (6,327, «с»), (9,056, «т»),
    (2,758, 'и'), (1,037, 'в'), (2,365, 'ш'), (0,150, 'х'),
    (1,974, 'у'), (0,074, 'з')]
деф кодировать (частоты):
    p = очередь.PriorityQueue()
    для элемента в частотах:
        p.put(элемент)
    #инвариант, что порядок в очереди приоритетов восходящий
    #p.size() дает список элементов
    в то время как p. qsize() > 1:
        влево, вправо = p.get(), p.get()
        узел = узел Хаффмана (слева, справа)
        p.put((левый[0]+правый[0],узел))
    вернуть p.get ()
узел = кодировать (частота)
печать (узел [1]. предзаказ())
 

Зарегистрируйтесь или войдите в систему

Зарегистрируйтесь с помощью Google

Зарегистрироваться через Facebook

Зарегистрируйтесь, используя электронную почту и пароль

Опубликовать как гость

Электронная почта

Требуется, но не отображается

Опубликовать как гость

Электронная почта

Требуется, но не отображается

Нажимая «Опубликовать свой ответ», вы соглашаетесь с нашими условиями обслуживания и подтверждаете, что прочитали и поняли нашу политику конфиденциальности и кодекс поведения.

python - Декодирование Хаффмана с рекурсией

Я создаю класс Хаффмана, который может кодировать и декодировать текст, но у меня возникли проблемы с моим методом декодирования. Мой метод кодирования работает нормально, а мой метод декодирования работает для небольших объемов текста. Но когда я пытаюсь декодировать большие объемы текста, я получаю ошибку максимальной глубины рекурсии и не знаю, как ее исправить. Класс берет словарь с символами и их частотами, а затем превращает их в узлы и строит дерево. После построения дерева он помещает символы и их битовый код в другой словарь, который будет использоваться для кодирования и декодирования.

 класс Узел:
    def __init__(я, значение, данные, слева = нет, справа = нет):
        #Удерживает частоту
        самостоятельная ценность = ценность
        #Удерживает символ
        self.data = данные
        self.left = левый
        сам.право = правильно
        селф. код = ""
    
    def __lt__(я, другой):
        вернуть self.value < другое.value
    
    def __le__(я, другой):
        вернуть self.value <= другое.value
       
    def __gt__(я, другой):
        вернуть self.value > другое.value
      
    def __ge__(я, другой):
        вернуть self.value >= другое.value
класс MyHuffman():
 защита __init__(сам):
    self.chars = {}
    self.tree = Нет
    self.decodePosition = 0
    
 сборка защиты (я, вес):
        huffNodes = []
        heapq.heapify(huffNodes)
        для x, y в weights.items():
            heapq.heappush(huffNodes,Node(y,x))
        
        в то время как len(huffNodes) > 1:
            слева = кучаq.heappop(huffNodes)
            справа = кучаq.heappop(huffNodes)
            левый.код = 1
            правильный код = 0
            heapq.heappush(huffNodes, Node(left.value+right.value, left.data + right.data, left, right))
        self.tree = huffNodes[0]
        self.makeLookupTable(self.tree)
        
    
 def makeLookupTable (я, узел, биткод = ""):
      коды = bitCode + str(node. code)
      если node.left == None и node.right == None:
        self.chars[node.data] = коды
      еще:
          self.makeLookupTable(узел.слева, коды)
          self.makeLookupTable (узел.право, коды)
      вернуть self.chars
    
 деф кодировать (я, слово):
     битовая строка = ""
     для x в диапазоне (0, len(word)):
         если слово [x] в self.chars:
             для y, z в self.chars.items():
                 если слово[х] == у:
                     битовая строка = битовая строка + z
     вернуть битовую строку
      
 def декодировать (я, битовая строка):
     для x в битовой строке:
         если х != "0" и х != "1":
             возврат Нет
     dec = self.recursiveTraverseTree (self.tree, битовая строка)
     self.decodePosition=0
     возвращение дек
 
    
 def recursiveTraverseTree (я, узел, битовая строка, слова = ""):
     если node.left == None и node.right == None:
         слова = слова + строка (node.data)
         узел = self.tree
         
     если self.decodePosition < len(bitString):
             если битовая строка[self. decodePosition] == "0":
                    self.decodePosition+=1
                    вернуть self.recursiveTraverseTree (узел.право, битовая строка, слова)
             elif bitString[self.decodePosition] == "1":
                    self.decodePosition+=1
                    вернуть self.recursiveTraverseTree (узел.левый, битовая строка, слова)
     
     обратные слова
     
     
       
 

Некоторые тестовые прогоны ниже Первый тест работает нормально, но второй выдает ошибку глубины maxRecursion

 huff = MyHuffman()
freqs = {'z': 50, 'j': 1, "'": 11, 'a': 42, 'd': 3, 'l': 1, 'f': 14, ' ': 31, 'i': 1, 'w': 8, 's': 41, 'r': 2, 'k': 49, 'b': 28, 'q': 28, 'p': 32, 'g ': 33, 'v': 51, 'c': 6, 'h': 6, 'm': 5, 'y': 8, 'o': 36, 't': 28, 'u': 23, н: 15}
b = huff.build (частоты)
слово = "чертов сын"
битовая строка = huff.encode(слово)
расшифровано = huff.decode (битовая строка)
print(f"[{word}] -> [{bitstring}] -> [{decrypted}]")
#Выводы[проклятый сын] -> [1000011001110000101000110010100010110001] -> [проклятый сын]
word1 ="bgzqbbvkqpaawaoasczz nfq szbumq'vzmbvbknsvvqouapcpbzkvbgtbsggcohto p tzhytz kkutanbv ubsbaogasznr tzz pzzsgqfqpsnfugsktpuzztq s vkfzavokoogmvzgpk tagkz zaoz'vaqpqk vbuvqtsbzgf zk kuzasovhauoqwtvvvovko fvbwhzpvpkskouaupspstbvgsbszipqvvuvmuaspzna stvvk gu saaokggnmsvtspkvqvsahvozsawszfpws skgg bqkqu salg fovuknaknpupovafbovqssagpgbfkcuz gf ofgyrokasgc guabqzbtkosqzbzvspzwgnsyfhvoz akgo'htsovzpakabayffpkpkvqrpzzqogsfvvatsvqbaapozavuyovzpbzsz ppuzrqbq'jaq zuqhhpptvkguktcbkazsszsgvocppzptzzhtzgt b mkznz qqk avkmztzsbzkgrovkqsssb pvtvssoutssazasunaavgybffppqgqagbsa gqscwpno'pb qsknzagtu pztqfbmbztmtuzktvza гаовапквав говпв оазг'qгрпысзвкqзвгвзтбавсы псвуртаузткзтавв зкквзс гбт згзосфвтпк'гыггбокт ктгукзгскфзф нтавпк бзазвтфвкфба кнп'зг'всыктвуопз твзкс фн'боаакыв skgvgqggqz tknqbbbvskavkgqpskkkvapca rvzpkksvw'p spvhbzfgggzz'fopfsngoujykutkapbvtqzkkaanpogpnozohvqgfwkdpkvgdpouku v zpkkonuzks oznspqz'aszvnt v ytkcptstkftcknfksb kqszqht z wmpafzwf vkofvadvaqagqzpnzavvuzqkau nqobvggzp qv gup fokkbsoaqkoz svu uvzqzzpyfwuq ozszkzspkavsvta tgovt zpyqvpkzpbnvbsakkgvaktkqwukozp zskzr a aobzopg qtmkakk g nz vgagaktwv tptw bfqmsogzhhkpzwaza tokcbta kzzutvzk zvkunqoowako zabvvkqu'zb kp kvakvthgytvsvstpbvngvskgaqnfkokwozbztgszh'pgbopsgdnvzvozzgvsvgpvuzbu vkzat"
битовая строка1 = huff.