Банк рефератов содержит более 364 тысяч рефератов, курсовых и дипломных работ, шпаргалок и докладов по различным дисциплинам: истории, психологии, экономике, менеджменту, философии, праву, экологии. А также изложения, сочинения по литературе, отчеты по практике, топики по английскому.
Полнотекстовый поиск
Всего работ:
364150
Теги названий
Разделы
Авиация и космонавтика (304)
Административное право (123)
Арбитражный процесс (23)
Архитектура (113)
Астрология (4)
Астрономия (4814)
Банковское дело (5227)
Безопасность жизнедеятельности (2616)
Биографии (3423)
Биология (4214)
Биология и химия (1518)
Биржевое дело (68)
Ботаника и сельское хоз-во (2836)
Бухгалтерский учет и аудит (8269)
Валютные отношения (50)
Ветеринария (50)
Военная кафедра (762)
ГДЗ (2)
География (5275)
Геодезия (30)
Геология (1222)
Геополитика (43)
Государство и право (20403)
Гражданское право и процесс (465)
Делопроизводство (19)
Деньги и кредит (108)
ЕГЭ (173)
Естествознание (96)
Журналистика (899)
ЗНО (54)
Зоология (34)
Издательское дело и полиграфия (476)
Инвестиции (106)
Иностранный язык (62792)
Информатика (3562)
Информатика, программирование (6444)
Исторические личности (2165)
История (21320)
История техники (766)
Кибернетика (64)
Коммуникации и связь (3145)
Компьютерные науки (60)
Косметология (17)
Краеведение и этнография (588)
Краткое содержание произведений (1000)
Криминалистика (106)
Криминология (48)
Криптология (3)
Кулинария (1167)
Культура и искусство (8485)
Культурология (537)
Литература : зарубежная (2044)
Литература и русский язык (11657)
Логика (532)
Логистика (21)
Маркетинг (7985)
Математика (3721)
Медицина, здоровье (10549)
Медицинские науки (88)
Международное публичное право (58)
Международное частное право (36)
Международные отношения (2257)
Менеджмент (12491)
Металлургия (91)
Москвоведение (797)
Музыка (1338)
Муниципальное право (24)
Налоги, налогообложение (214)
Наука и техника (1141)
Начертательная геометрия (3)
Оккультизм и уфология (8)
Остальные рефераты (21697)
Педагогика (7850)
Политология (3801)
Право (682)
Право, юриспруденция (2881)
Предпринимательство (475)
Прикладные науки (1)
Промышленность, производство (7100)
Психология (8694)
психология, педагогика (4121)
Радиоэлектроника (443)
Реклама (952)
Религия и мифология (2967)
Риторика (23)
Сексология (748)
Социология (4876)
Статистика (95)
Страхование (107)
Строительные науки (7)
Строительство (2004)
Схемотехника (15)
Таможенная система (663)
Теория государства и права (240)
Теория организации (39)
Теплотехника (25)
Технология (624)
Товароведение (16)
Транспорт (2652)
Трудовое право (136)
Туризм (90)
Уголовное право и процесс (406)
Управление (95)
Управленческие науки (24)
Физика (3463)
Физкультура и спорт (4482)
Философия (7216)
Финансовые науки (4592)
Финансы (5386)
Фотография (3)
Химия (2244)
Хозяйственное право (23)
Цифровые устройства (29)
Экологическое право (35)
Экология (4517)
Экономика (20645)
Экономико-математическое моделирование (666)
Экономическая география (119)
Экономическая теория (2573)
Этика (889)
Юриспруденция (288)
Языковедение (148)
Языкознание, филология (1140)

Реферат: Динамические структуры данных: списки

Название: Динамические структуры данных: списки
Раздел: Рефераты по информатике, программированию
Тип: реферат Добавлен 06:18:05 27 февраля 2008 Похожие работы
Просмотров: 293 Комментариев: 7 Оценило: 0 человек Средний балл: 0 Оценка: неизвестно     Скачать

Введение

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

В языках программирования (Pascal, C, др.) существует и другой способ выделения памяти под данные, который называется динамическим. В этом случае память под величины отводится во время выполнения программы. Такие величины будем называть динамическими. Раздел оперативной памяти, распределяемый статически, называется статической памятью; динамически распределяемый раздел памяти называется динамической памятью (динамически распределяемой памятью).

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

Работа с динамическими величинами связана с использованием еще одного типа данных — ссылочного типа. Величины, имеющие ссылочный тип, называют указателями.

Указатель содержит адрес поля в динамической памяти, хранящего величину определенного типа. Сам указатель располагается в статической памяти.

Адрес величины — это номер первого байта поля памяти, в котором располагается величина. Размер поля однозначно определяется типом.

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

Величина ссылочного типа (указатель) описывается в разделе описания переменных следующим образом:

Var <идентификатор> : ^<имя типа>;

Вот примеры описания указателей:

Type Mas1 = Array[1..100] Of Integer;

Var P1 : ^Integer;

P2 : ^String;

Pm : ^Mas1;

Здесь P1 — указатель на динамическую величину целого типа; P2 — указатель на динамическую величину строкового типа; Pm — указатель на динамический массив, тип которого задан в разделе Type.

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

Каким же образом происходит выделение памяти под динамическую величину? Память под динамическую величину, связанную с указателем, выделяется в результате выполнения стандартной процедуры NEW. Формат обращения к этой процедуре:

NEW(<указатель>);

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

<имя динамической величины> := <указатель>^

Пусть в программе, в которой имеется приведенное выше описание, присутствуют следующие операторы:

NEW(P1); NEW(P2); NEW(Pm);

После их выполнения в динамической памяти оказывается выделенным место под три величины (две скалярные и один массив), которые имеют идентификаторы:

P1^, P2^, Pm^

Например, обозначение P1^ можно расшифровать так: динамическая переменная, на которую ссылается указатель P1.

Дальнейшая работа с динамическими переменными происходит точно так же, как со статическими переменными соответствующих типов. Им можно присваивать значения, их можно использовать в качестве операндов в выражениях, параметров подпрограмм и пр. Например, если переменной P1^ нужно присвоить число 25, переменной P2^ присвоить значение символа "Write", а массив Pm^ заполнить по порядку целыми числами от 1 до 100, то это делается так:

P1^ := 25;

P2^ := 'Write';

For I := 1 To 100 Do Pm^[I] := I;

Кроме процедуры NEW значение указателя может определяться оператором присваивания:

<указатель> := <ссылочное выражение>;

В качестве ссылочного выражения можно использовать

указатель;

ссылочную функцию (т.е. функцию, значением которой является указатель);

константу Nil.

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

До присваивания значения ссылочной переменной (с помощью оператора присваивания или процедуры NEW) она является неопределенной.

Ввод и вывод указателей не допускается.

Рассмотрим пример. Пусть в программе описаны следующие указатели:

Var D, P : ^Integer;

K : ^Boolean;

Тогда допустимыми являются операторы присваивания

D := P; K := Nil;

поскольку соблюдается принцип соответствия типов. Оператор K := D ошибочен, т.к. базовые типы у правой и левой части разные.

Если динамическая величина теряет свой указатель, то она становится "мусором". В программировании под этим словом понимают информацию, которая занимает память, но уже не нужна.

Представьте себе, что в программе, в которой присутствуют описанные выше указатели, в разделе операторов записано следующее:

NEW(D); NEW(P);

{Выделено место в динамической памяти под две целые переменные. Указатели получили соответствующие значения}

D^ := 3; P^ := 5;

{Динамическим переменным присвоены значения}

P := D;

{Указатели P и D стали ссылаться на одну и ту же величину, равную 3}

WriteLn(P^, D^); {Дважды напечатается число 3}

Таким образом, динамическая величина, равная 5, потеряла свой указатель и стала недоступной. Однако место в памяти она занимает. Это и есть пример возникновения "мусора". На схеме показано, что произошло в результате выполнения оператора P := D.

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

DISPOSE(<указатель>);

Например, если динамическая переменная P^ больше не нужна, то оператор

DISPOSE(P)

удалит ее из памяти. После этого значение указателя P становится неопределенным. Особенно существенным становится эффект экономии памяти при удалении больших массивов.

В версиях Турбо-Паскаля, работающих под операционной системой MS DOS, под данные одной программы выделяется 64 килобайта памяти (или, если быть точнее, 65520 байт). Это и есть статическая область памяти. При необходимости работать с большими массивами информации этого может оказаться мало. Размер динамической памяти — много больше (сотни килобайт). Поэтому использование динамической памяти позволяет существенно увеличить объем обрабатываемой информации.

Следует отчетливо понимать, что работа с динамическими данными замедляет выполнение программы, поскольку доступ к величине происходит в два шага: сначала ищется указатель, затем по нему — величина. Как это часто бывает, действует "закон сохранения неприятностей": выигрыш в памяти компенсируется проигрышем во времени.

Пример. Дан текстовый файл размером не более 64 Кб, содержащий действительные числа, по одному в каждой строке. Переписать содержимое файла в массив, разместив его в динамически распределяемой памяти. Вычислить среднее значение элементов массива. Очистить динамическую память. Создать целый массив размером 10000, заполнить его случайными целыми числами в диапазоне от –100 до 100 и вычислить его среднее значение.

{Язык Turbo Pascal}

Program Srednee;

Const NMax = 10000;

Type Diapazon = 1..NMax;

MasInt = Array[Diapazon] Of Integer;

MasReal = Array[Diapazon] Of Real;

Var PIint : ^MasInt; PReal : ^MasReal;

I, Midint : longInt; MidReal : Real; T : Text; S : string;

Begin

Write('Введитеимяфайла: '); ReadLn(S);

Assign(T, S); Reset(T); MidReal := 0; MidInt := 0;

Randomize;

NEW(PReal); {Выделение памяти под вещественный массив}

{Ввод и суммирование вещественного массива}

While Not Eof (T) Do

Begin ReadLn(T, PReal^[I]); MidReal := MidReal + PReal^[I] End;

DISPOSE(PReal); {Удаление вещественного массива}

NEW(PInt); {Выделение памяти под целый массив}

{Вычисление и суммирование целого массива}

For I := 1 To NMax Do

Begin PInt^[I] := -100 + Random(201); MidInt := MidInt + PInt^[I] End;

{Вывод средних значений}

WriteLn('среднее целое равно: ', MidInt Div NMax);

WriteLn('среднее вещественное равно: ', (MidReal / NMax) : 10 : 6)

End.

// Язык C++

#include < stdio.h >

#include < time.h >

#include < stdlib.h >

#include < iostream.h >

#define NMax 10000

typedef int MasInt;

typedef float MasReal;

MasInt *PInt; MasReal *PReal;

int I, n, MidInt; float MidReal; char S[255];

FILE *t; char *endptr;

void main()

{ cout << "Введитеимяфайла: "; cin >> S;

t=fopen(S, "r");

MidReal = 0; MidInt = 0;

randomize(); I=0;

/*Выделение памяти под вещественный массив*/

PReal = (MasReal*) malloc (sizeof(MasReal));

/*Ввод и суммирование вещественного массива*/

while (!feof(t))

{fgets(S, 255, t); // вводим из файла строку

PReal[I] = strtod(S, &endptr); // преобразуем введенную строку в вещественное число

MidReal += PReal[I]; I++;}

n=I+1;

free (PReal); /*Удаление вещественного массива*/

PInt = (MasInt*) malloc(sizeof(MasInt)); /*Выделение памяти под целый массив*/

/* Вычисление и суммирование целого массива */

for (I=0; I < NMax; I++)

{ PInt[I] = -100 + random(201);

MidInt += PInt[I];}

/*Вывод средних значений*/

cout << "\nсреднеецелоеравно " << MidInt / double(NMax) << "\n";

cout << "среднее вещественное равно: " << MidReal / n << "\n";

fclose(t);

}

Списки

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

Разберем следующий пример. В процессе физического эксперимента многократно снимаются показания прибора (допустим, термометра) и записываются в компьютерную память для дальнейшей обработки. Заранее неизвестно, сколько будет произведено измерений.

Если для обработки таких данных не использовать внешнюю память (файлы), то разумно расположить их в динамической памяти. Во-первых, динамическая память позволяет хранить больший объем информации, чем статическая. А во-вторых, в динамической памяти эти числа можно организовать в связанный список, который не требует предварительного указания количества чисел, подобно массиву. Что же такое "связанный список"? Схематически он выглядит так:

Здесь Inf — информационная часть звена списка (величина любого простого или структурированного типа, кроме файлового), Next — указатель на следующее звено списка; First — указатель на заглавное звено списка.

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

Для объявления списка сделано исключение: указатель на звено списка объявляется раньше, чем само звено. В общем виде объявление выглядит так.

Type U = ^Zveno;

Zveno = Record Inf : BT; Next: U End;

Здесь BT — некоторый базовый тип элементов списка.

Если указатель ссылается только на следующее звено списка (как показано на рисунке и в объявленной выше структуре), то такой список называют однонаправленным, если на следующее и предыдущее звенья — двунаправленным списком. Если указатель в последнем звене установлен не в Nil, а ссылается на заглавное звено списка, то такой список называется кольцевым. Кольцевыми могут быть и однонаправленные, и двунаправленные списки.

Более подробно рассмотрим работу со связанными списками на примере однонаправленного некольцевого списка.

Выделим типовые операции над списками:

добавление звена в начало списка;

удаление звена из начала списка;

добавление звена в произвольное место списка, отличное от начала (например, после звена, указатель на которое задан);

удаление звена из произвольного места списка, отличного от начала (например, после звена, указатель на которое задан);

проверка, пуст ли список;

очистка списка;

печать списка.

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

1. Добавление звена в начало списка

{Процедура добавления звена в начало списка; в x содержится добавляемая информация}

Procedure V_Nachalo(Var First : U; X : BT);

Var Vsp : U;

Begin

New(Vsp);

Vsp^.Inf := X;

Vsp^.Next := First; {То звено, что было заглавным, становится вторым по счёту}

First := Vsp; {Новое звено становится заглавным}

End;

2. Удаление звена из начала списка

{Процедура удаления звена из начала списка;

в x содержится информация из удалённого звена}

Procedure Iz_Nachala(Var First : U; Var X : BT);

Var Vsp : U;

Begin

Vsp := First; {Забираем ссылку на текущее заглавное звено}

First := First^.Next; {То звено, что было вторым по счёту, становится заглавным}

X := Vsp^.Inf; {Забираем информацию из удаляемого звена}

Dispose(Vsp); {Уничтожаем звено}

End;

3. Добавление звена в произвольное место списка, отличное от начала (после звена, указатель на которое задан)

{Процедура добавления звена в список после звена,

на которое ссылается указатель Pred;

в x содержится информация для добавления}

Procedure V_Spisok(Pred : U; X : BT);

Var Vsp : U;

Begin

New(Vsp); {Создаемпустоезвено}

Vsp^.Inf := X; {Заносим информацию}

Vsp^.Next := Pred^.Next; {Теперь это звено ссылается на то,

что было следом за звеном Pred}

Pred^.Next := Vsp; {Теперь новое звено встало вслед за звеном Pred}

End;

4. Удаление звена из произвольного места списка, отличного от начала (после звена, указатель на которое задан)

{Процедура удаления звена из списка после звена,

на которое ссылается указатель Pred;

в x содержится информация из удалённого звена}

Procedure Iz_Spiska(Pred : U; Var X : BT);

Var Vsp : U;

Begin

Vsp := Pred^.Next; {Забираемссылкунаудаляемоезвено}

{Удаляем звено из списка, перенаправив ссылку на следующее

за ним звено}

Pred^.Next := Pred^.Next^.Next;

X := Vsp^.Inf; {Забираем информацию из удаляемого звена}

Dispose(Vsp); {Уничтожаем звено}

End;

Приведём полный текст модуля.

{Язык Pascal}

Unit Spisok;

Interface

Type BT = LongInt;

U = ^Zveno;

Zveno = Record Inf : BT; Next: U End;

Procedure V_Nachalo(Var First : U; X : BT);

Procedure Iz_Nachala(Var First : U; Var X : BT);

Procedure V_Spisok(Pred : U; X : BT);

Procedure Iz_Spiska(Pred : U; Var X : BT);

Procedure Ochistka(Var First: U);

Function Pust(First : U) : Boolean;

Procedure Print(First : U);

Implementation

Procedure V_Nachalo;

Var Vsp : U;

Begin

New(Vsp);

Vsp^.Inf := X;

Vsp^.Next := First;

First := Vsp;

End;

Procedure Iz_Nachala;

Var Vsp : U;

Begin

Vsp := First;

First := First^.Next;

X := Vsp^.Inf;

Dispose(Vsp);

End;

Procedure V_Spisok;

Var Vsp : U;

Begin

New(Vsp);

Vsp^.Inf := X;

Vsp^.Next := Pred^.Next;

Pred^.Next := Vsp;

End;

Procedure Iz_Spiska;

Var Vsp : U;

Begin

Vsp := Pred^.Next;

Pred^.Next := Pred^.Next^.Next;

X := Vsp^.Inf;

Dispose(Vsp);

End;

Procedure Ochistka;

Var Vsp : BT;

Begin

While Not Pust(First) Do Iz_Nachala(First, Vsp)

End;

Function Pust;

Begin

Pust := First = Nil

End;

Procedure Print;

Var Vsp : U;

Begin

Vsp := First;

While Vsp <> Nil Do

Begin

Write(Vsp^.Inf : 6);

Vsp := Vsp^.Next

End; WriteLn

End;

Begin

End.

// ЯзыкС++

#include < iostream.h >

#include < conio.h >

#include < stdlib.h >

#include < time.h >

typedef long BT;

struct Zveno{

BT Inf;

Zveno *Next; };

Zveno *V_Nachalo(Zveno *First, BT X)

{ Zveno *Vsp;

Vsp = (Zveno *) malloc(sizeof(Zveno));

Vsp->Inf=X; Vsp->Next=First; First=Vsp;

return First;

}

Zveno *Iz_Nachala(Zveno *First)

{ Zveno *Vsp;

Vsp=First->Next;

free(First);

return Vsp;

}

Zveno *V_Spisok(Zveno *Pred, BT X)

{ Zveno *Vsp;

Vsp = (Zveno *) malloc(sizeof(Zveno));

Vsp->Inf=X;

Vsp->Next=Pred->Next;

Pred->Next=Vsp;

return Vsp;

}

BT Iz_Spiska(Zveno *Pred)

{ BT X;

Zveno *Vsp;

Vsp=Pred->Next;

Pred->Next=Pred->Next->Next;

X=Vsp->Inf;

free(Vsp);

return X;

}

void Print(Zveno *First)

{ Zveno *Vsp;

Vsp=First;

while (Vsp)

{cout << Vsp->Inf << ' '; Vsp=Vsp->Next;}

cout << "\n";

}

int Pust(Zveno *First)

{

return !First;

}

Zveno *Ochistka(Zveno *First)

{

while (!Pust(First)) First=Iz_Nachala(First);

return First;

}

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

При реализации алгоритма будем использовать подпрограммы разработанного модуля. Это существенно облегчает решение задачи.

{Программа на Turbo Pascal}

Program Ex_sp_1;

Uses Spisok;

Var S1, S2, S3, V1, V2, V3 : U; A : BT; I, N : Byte;

Begin

Randomize;

N := 1 + Random(20);

S1 := Nil; A := -100 + Random(201);

V_Nachalo(S1, A); V1 := S1;

For I := 2 To N Do

Begin A := -100 + Random(201); V_Spisok(V1, A); V1 := V1^.Next End;

WriteLn('Исходныйсписок: '); Print(S1);

V1 := s1; S2 := Nil; S3 := Nil;

While V1 <> Nil Do

Begin

If V1^.Inf > 0

Then If S2 = Nil

Then Begin V_Nachalo(S2, V1^.Inf); V2 := S2 End

Else Begin V_Spisok(V2, V1^.Inf); V2 := V2^.Next End;

If V1^.Inf < 0

Then If S3 = Nil

Then Begin V_Nachalo(s3, V1^.Inf); V3 := S3 End

Else Begin V_Spisok(V3, V1^.Inf); V3 := V3^.Next End;

V1:= V1^.Next

End;

WriteLn('Результирующий список из положительных элементов: '); Print(S2);

WriteLn('Результирующий список из отрицательных элементов: '); Print(S3);

Ochistka(S1); Ochistka(S2); Ochistka(S3);

End.

// Программа на C++

#include "SPIS.CPP"

void main()

{Zveno *S1, *S2, *S3, *V1, *V2, *V3;

BT a; int i, n;

clrscr();

randomize();

S1=NULL;

// создаём первый элемент

a=-100+random(201);

S1=V_Nachalo(S1, a);

n=1+random(20);

// формируем список произвольной длины и выводим на печать

V1=S1;

for (i=2; i<=n; i++)

{

a=-100+random(201);

V1=V_Spisok(V1, a);

}

Print(S1);

V1 = S1; S2 = NULL; S3 = NULL;

while (V1)

{if (V1->Inf > 0)

if (!S2)

{S2=V_Nachalo(S2, V1->Inf); V2 = S2;}

else {V_Spisok(V2, V1->Inf); V2 = V2->Next;};

if (V1->Inf < 0)

if (!S3)

{S3=V_Nachalo(S3, V1->Inf); V3 = S3;}

else {V_Spisok(V3, V1->Inf); V3 = V3->Next;};

V1= V1->Next;}

cout << "Результирующий список из положительных элементов: \n";

Print(S2);

cout << "Результирующий список из отрицательных элементов: \n";

Print(S3);

S1=Ochistka(S1); S2=Ochistka(S2); S3=Ochistka(S3);

}

Контрольные вопросы и задания

Чем отличаются статические и динамические величины?

Какая память называется динамически распределяемой?

Что такое указатель?

Какие виды указателей вам известны?

Как определяется адрес переменной?

Приведите примеры объявления указателей.

Как выделить память под динамическую переменную? Как освободить память от динамической переменной?

Что такое "разыменование"?

Что в языке Pascal обозначает константа Nil (в языке C константа NULL)?

В каком случае возможно присваивание указателей?

Какие ситуации приводят к возникновению в динамически распределяемой памяти "мусора"?

Что понимают под "связанным списком"?

Как классифицируют связанные списки?

Какие основные действия над списками и компонентами списков обычно реализуют?

Как описывается список?

Двунаправленный список объявлен следующим образом:

Type BT = Byte;

U = ^Zveno;

Zveno = Record Inf : BT; Pred, Next: U End;

Здесь Pred, Next — соответственно указатели на предыдущее и последующее звенья списка. Разработать основные подпрограммы для обслуживания такого списка.

Оценить/Добавить комментарий
Имя
Оценка
Комментарии:
Где скачать еще рефератов? Здесь: letsdoit777.blogspot.com
Евгений22:31:46 18 марта 2016
Кто еще хочет зарабатывать от 9000 рублей в день "Чистых Денег"? Узнайте как: business1777.blogspot.com ! Cпециально для студентов!
15:57:13 24 ноября 2015
Кто еще хочет зарабатывать от 9000 рублей в день "Чистых Денег"? Узнайте как: business1777.blogspot.com ! Cпециально для студентов!
15:56:04 24 ноября 2015
Кто еще хочет зарабатывать от 9000 рублей в день "Чистых Денег"? Узнайте как: business1777.blogspot.com ! Cпециально для студентов!
09:52:13 24 ноября 2015
Кто еще хочет зарабатывать от 9000 рублей в день "Чистых Денег"? Узнайте как: business1777.blogspot.com ! Cпециально для студентов!
01:09:48 24 ноября 2015

Смотреть все комментарии (7)
Работы, похожие на Реферат: Динамические структуры данных: списки

Назад
Меню
Главная
Рефераты
Благодарности
Опрос
Станете ли вы заказывать работу за деньги, если не найдете ее в Интернете?

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



Результаты(149904)
Комментарии (1829)
Copyright © 2005-2016 BestReferat.ru bestreferat@mail.ru       реклама на сайте

Рейтинг@Mail.ru