1. Представление множества битовой строкой. Оценки сложности по памяти и времени.

Проектирование

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

ВОЗМОЖНО ПО ТЕМЕ

Множество – набор элементов

Операции над множествами

• получение значения бита n
• проверка наличия элемента (a принадлежит A)
• при условии, если бит больше -1 и меньше количества битов
• в противном случае возвращается 0

int TBitField::GetBit(const int n) const
{
    if ((n > -1) && (n < BitLen))
        return (pMem[(GetMemIndex(n))] & (GetMemMask(n)));
    else return(0);
}

• установка бита
• добавление элемента (A + a)
• происходит в позицию n том случае, если бит больше -1 и меньше количества битов

void TBitField::SetBit(const int n)
{   if ((n > -1) && (n < BitLen))
        pMem[(GetMemIndex(n))] |= GetMemMask(n);
}

• удаление бита в позиции n
• удаление элемента A – a
• при условии, если бит больше -1 и меньше количества битов

void TBitField::ClrBit(const int n)
{   if ((n > -1) && (n < BitLen))
        pMem[(GetMemIndex(n))] &= ~GetMemMask(n);
}

Теоретико-множественные операции

• объединение A ⋃ B
• Операция "или" для двух битовых полей, осуществляется с помощью сравнивания двух полей, причем, результирующее будет с длиной наибольшего из них
• Затем последовательно выполняется дизъюнкция для i-ых элементов двух массивов

TBitField TBitField::operator|(const TBitField& bf)
{
    int i, len;
    if (BitLen > bf.BitLen)
        len = BitLen;
    else len = bf.BitLen;
    TBitField temp(len);
    for (i = 0; i < MemLen; i++)
        temp.pMem[i] = pMem[i];
    for (i = 0; i < bf.MemLen; i++)
        temp.pMem[i] |= bf.pMem[i];
    return temp;
}

• пересечение A ∩ B
• Операция "и" для двух битовых полей, осуществляется с помощью сравнивания двух полей, результирующее будет с длиной наименьшего из них
• Затем последовательно выполняется конъюнкция для i-ых элементов двух массивов

TBitField TBitField::operator&(const TBitField &bf)
{
    int i, len;
    if (BitLen < bf.BitLen)
        len = BitLen;
    else len = bf.BitLen;
    TBitField temp(len);
    for (i = 0; i < MemLen; i++)
        temp.pMem[i] = pMem[i];
    for (i = 0; i < bf.MemLen; i++)
        temp.pMem[i] &= bf.pMem[i];
    return temp;
}

• вычитание A  B
• Для отрицания последовательно выполняется инверсия для каждого бита массива

TBitField TBitField::operator~(void)
{
    TBitField temp(BitLen);
    for (int i = 0; i < MemLen; i++)
        temp.pMem[i] = ~pMem[i];
    return temp;
}

Универс U – множество всех элементов.

Конкретизация (допущения и ограничения):

• элементы множества проиндексированы (каждому элементу соответствует уникальный индекс)
• множество индексов элементов составляют непрерывный диапазон целых значений
• Тогда любое множество A ⊂ U может быть описано характеристическим вектором
• если иначе
• Множество → битовая строка → массив битовых элементов → оперативная память (обратный порядок хранения)
• Нумерация бит в битовой строке – слева направо
• Нумерация элементов в массиве – слева направо, биты элемента – справа налево
• Байты двухбайтового элемента располагаются в ОП в обратном порядке (сначала байт с младшими битами, затем байт со старшими битами)

2. Реализация стека с использованием динамически распределяемой памяти.

Вставка в стек

    PTDatLink pTemp;
    pTemp = new TDatLink();
    pTemp-> SetDatValue(Val);
    pTemp->SetNextLink(pFirst);
    pFirst = pTemp;

Выборка из стека

    PTDatLink pTemp = pFirst;
    Val = pFirst->GetDatValue();
    pFirst = pFirst->GetNextLink();
    delete pTemp;