Обсуждение участника:KirillKutirev — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
(Реализация)
(Реализация)
Строка 23: Строка 23:
 
   t1 = n, t2 = 0 // указатели на ячейки массивов сразу после последнего элемента в этих массивах
 
   t1 = n, t2 = 0 // указатели на ячейки массивов сразу после последнего элемента в этих массивах
 
   check = 0 // считает на сколько стало меньше элементов
 
   check = 0 // считает на сколько стало меньше элементов
   // ... чтение данных
+
   temp // переменная, на которую ссылаются самые нижние листья дерева
   '''while''' check < n
+
  class vert{ // класс - лист дерева, которое, по сути, строится в коде хаффмана
     '''while''' h1 < t1 // проходим по массиву, выполняющему роль первого; внутри этого цикла мы ищем минимумы и записываем суммы
+
   public:
      '''if''' h2 == t2
+
    val // значение кодового символа {0,1}
        sum[s2][t2] = sum[s1][h1] + sum[s1][h1+1]
+
    w // сумма в данном поддереве
        '''if''' t1 - h1 == 1
+
    left // самый левый элемент начального массива в данном поддереве, чтобы упростить поиск при спуске
          sum[s2][t2] = sum[s2][t2] - sum[s1][h1+1]
+
    check // проверка на то, является ли данный лист самым нижним в дереве
        h1 = h1 + 2
+
     *nextl, *nextr // указатели на левого и правого детей
        t2++
+
    vert(){
      '''else'''
+
      check = 1;
        '''if''' sum[s1][h1] < sum[s2][h2]
+
      val = 0;
          '''if''' sum[s1][h1+1] < sum[s2][h2]
+
    }
            sum[s2][t2] = sum[s1][h1] + sum[s1][h1+1]
+
  };
            h1 += 2
+
 
 +
  make(int str1, int str2, int pos1, int pos2)// функция, которая суммирует, задает указатели и значения переменных val и left
 +
    sum[s2][t2].w = sum[str1][pos1].w + sum[str2][pos2].w
 +
    sum[s2][t2].nextl = &sum[str1][pos1]
 +
    sum[s2][t2].nextr = &sum[str2][pos2]
 +
    sum[s2][t2].left = min(sum[str1][pos1].left,sum[str2][pos2].left)
 +
    sum[str1][pos1].val = 0
 +
    sum[str2][pos2].val = 1
 +
 
 +
  coding(sum)
 +
    '''while''' check < n
 +
      '''while''' h1 < t1 // проходим по массиву, выполняющему роль первого; внутри этого цикла мы ищем минимумы и записываем суммы
 +
          '''if''' sum[s1][h1].w < sum[s2][h2].w
 +
              '''if''' sum[s1][h1+1].w <= sum[s2][h2].w
 +
                make(s1,s1,h1,h1+1)
 +
                '''if'''(t2 - h1 == 2)
 +
                  sum[s2][t2].w -= sum[s1][h1+1].w
 +
                  sum[s2][t2].nextr = &temp;                    
 +
                h1 += 2
 +
              '''else'''
 +
                make(s1,s2,h1,h2)
 +
                h1++
 +
                h2++
 +
              t2++
 
           '''else'''
 
           '''else'''
            sum[s2][t2] = sum[s1][h1] + sum[s2][h2]
+
              '''if''' sum[s1][h1].w < sum[s2][h2+1].w
            h1++
+
                make(s2,s1,h2,h1)
            h2++
+
                h1++
          t2++
+
                h2++
        '''else'''
+
              '''else'''
          '''if''' sum[s1][h1] < sum[s2][h2+1]
+
                make(s2,s2,h2,h2+1)
            sum[s2][t2] = sum[s2][h2] + sum[s1][h1]
+
                h2+=2
            h1++
+
              t2++
            h2++
+
          check++ // учитываем то, что элементов стало на 1 меньше
          '''else'''
+
      s1 = s2 // строки меняются ролями, соответственно все их параметры тоже
            sum[s2][t2] = sum[s2][h2] + sum[s2][h2+1]
+
      h1 = h2
            h2+=2
+
      t1 = t2
          t2++
+
      s2++
      check++ // учитываем то, что элементов стало на 1 меньше
+
      h2 = t2 = 0
    s1 = s2 // строки меняются ролями, соответственно все их параметры тоже
+
  return sum[s1][h1] // возвращает вершину дерева
    h1 = h2
 
    t1 = t2
 
    s2++
 
    h2 = t2 = 0
 

Версия 22:16, 7 января 2014

Алгоритм Хаффмана за [math] O(n) [/math].

У нас есть массив частот (массив, в котором хранится число вхождений каждого символа в строку), отсортированный по возрастанию, нужно построить по нему код Хаффмана за [math] O(n) [/math] (если массив не отсортирован, то это можно сделать, например, цифровой сортировкой за [math] O(n) [/math], что не ухудшит асимптотику).

Идея алгоритма заключается в том, чтобы создать такую очередь с приоритетами, из которой можно было бы доставать два минимума за [math] O(1) [/math], после чего в эту же очередь с приоритетами положить их сумму за [math] O(1) [/math]. У нас уже есть массив с отсортированными частотами, теперь давайте заведем второй массив, в котором мы будем хранить суммы. Несложно заметить, что в этом массиве элементы тоже будут идти по неубыванию. Допустим, что на каком-то шаге сумма получилась меньше чем предыдущая, но это противоречит тому, что на каждом шаге мы выбираем два минимальных (т.е. на каждом последующем шаге мы выбираем два минимума из элементов больших, чем на предыдущем шаге). На каждой итерации мы будет выбирать два минимума из четырех элементов (первые 2 элемента первого массива и первые 2 элемента второго массива). Теперь рассмотрим одну итерацию подробнее.

У нас есть три варианта возможных пар минимумов :

  1. Оба элемента из первого массива.
  2. Первый элемент первого массива и первый элемент второго массива.
  3. Два первых элемента второго массива.

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

На каждом шаге количество элементов уменьшается ровно на один, а минимум из 4-х элементов мы выбираем за константное время, следовательно, программа делает ровно [math]n[/math] итераций.

Реализация

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

 n // количество элементов
 sum = int[logMAXN][MAXN+1] // массив, в котором считаем суммы, сначала заполнен "бесконечностями"
 s1 = 0, s2 = 1 // указатели на строки, которые выполняют функции первого и второго массивов в описании алгоритма
 h1 = 0, h2 = 0 // указатели на первый элемент первой строки и второй строки соответственно
 t1 = n, t2 = 0 // указатели на ячейки массивов сразу после последнего элемента в этих массивах
 check = 0 // считает на сколько стало меньше элементов
 temp // переменная, на которую ссылаются самые нижние листья дерева
 class vert{ // класс - лист дерева, которое, по сути, строится в коде хаффмана
 public:
   val // значение кодового символа {0,1}
   w // сумма в данном поддереве
   left // самый левый элемент начального массива в данном поддереве, чтобы упростить поиск при спуске
   check // проверка на то, является ли данный лист самым нижним в дереве
   *nextl, *nextr // указатели на левого и правого детей
   vert(){
     check = 1;
     val = 0;
   }
 };
 
 make(int str1, int str2, int pos1, int pos2)// функция, которая суммирует, задает указатели и значения переменных val и left
   sum[s2][t2].w = sum[str1][pos1].w + sum[str2][pos2].w
   sum[s2][t2].nextl = &sum[str1][pos1]
   sum[s2][t2].nextr = &sum[str2][pos2]
   sum[s2][t2].left = min(sum[str1][pos1].left,sum[str2][pos2].left)
   sum[str1][pos1].val = 0
   sum[str2][pos2].val = 1
 
 coding(sum)
   while check < n
     while h1 < t1 // проходим по массиву, выполняющему роль первого; внутри этого цикла мы ищем минимумы и записываем суммы
          if sum[s1][h1].w < sum[s2][h2].w
              if sum[s1][h1+1].w <= sum[s2][h2].w
                make(s1,s1,h1,h1+1)
                if(t2 - h1 == 2)
                  sum[s2][t2].w -= sum[s1][h1+1].w
                  sum[s2][t2].nextr = &temp;		                     
                h1 += 2
              else
                make(s1,s2,h1,h2)
                h1++
                h2++
              t2++ 
          else
              if sum[s1][h1].w < sum[s2][h2+1].w
                make(s2,s1,h2,h1)
                h1++
                h2++
              else
                make(s2,s2,h2,h2+1)
                h2+=2
              t2++
          check++ // учитываем то, что элементов стало на 1 меньше
     s1 = s2 // строки меняются ролями, соответственно все их параметры тоже
     h1 = h2
     t1 = t2
     s2++
     h2 = t2 = 0
 return sum[s1][h1] // возвращает вершину дерева