Размещено на http://allbest.ru

1

ВСТУП

піраміда сортування алгоритм

В обчислювальній техніці структури даних - це спосіб зберігання та представлення даних у комп'ютері, що забезпечує більш ефективне її використання. Структури даних бувають простими та складними: прості характеризуються типом одиниці інформації, що зберігається (цілочисельний, логічний, текстовий і так далі), складні поділяють на динамічні (такі структури створюють можливість зміни свого розміру в процесі виконання програми, тобто додавати чи видаляти елементи) та статичні (без можливості додавання та видалення елементів - розмір залишається незмінним) способи організації даних. Найчастіше правильно підібрана структура даних допомагає використати більш ефективний алгоритм. Добре спроектована структура даних дозволяє виконувати типові операції, використовуючи при цьому оптимальний обсяг ресурсів, таких як час виконання чи використовуваний об'єм оперативної пам'яті. Однією із найбільш широко використовуваних структур даних є піраміда, або бінарна купа.

Постановка задачі: описати структуру даних «піраміда», її переваги та обмеження, а також методи, характерні для роботи з нею. Самостійно реалізувати клас для представлення структури даних «піраміда» засобами мови програмування C# (якщо існує відповідний стандартний .NET-клас, відтворити його функціональність). Функціональні елементи класу повинні забезпечувати повний, мінімальний та зручний інтерфейс класу, який не має протиріч. При виникненні специфічних для класу помилок повинні вкидатися виключні ситуації. Навести приклад задачі, для ефективного розв'язання якої необхідне використання структури даних «піраміда». Обґрунтувати необхідність використання саме піраміди . Реалізувати розв'язання цієї задачі засобами мови програмування C#.

1. ТЕОРЕТИЧНА ЧАСТИНА

1.1 Піраміда або бінарна купа. Означення піраміди

Двійкове дерево - це така ієрархічна структура даних (елементи, пов'язані між собою за певними правилами), що являє собою сукупність деяких елементів та зв'язків між ними; кожна вершина такого дерева має не більш ніж два нащадки).

Структура даних піраміда має ще дві назви, а саме: бінарна купа або дерево сортування. Дерево сортування -- це таке двійкове дерево, для якого виконані наступні умови:

1) значення елемента будь-якої вершини не менше за значення його нащадків;

2) глибина листків ( відстань до кореня) відрізняється не більш як на один шар;

3) останній шар заповнюється зліва направо;

Рис.1.1 - Графічне зображення структури «піраміда»

Існують також купи, де значення елемента будь-якої вершини, навпаки, не більше за значення його нащадків. Такі купи мають назву min-heap, а купи, опис яких наведено вище - max-heap. Далі розглядатимемо лише max-heap, дії з min-heap виконуються аналогічно.

Зручна структура даних для дерева сортування - масив, перший елемент якого є кореневим елементом дерева, а нащадками елемента А[i] є А[2i] та А[2i+1] - у випадку, коли нумерація починається з 1, або A[2i+1] та A[2i+2] - у випадку, коли нумерація починається з нуля. За умови, що елементи зберігаються таким способом, умови 2 та 3 виконуються автоматично.

Рис.1.2 - Приклад структури для зберігання даних дерева сортування

Висота купи визначається як висота двійкового дерева. Тобто, вона дорівнює кількості ребер (з'єднують вершини дерева) у найдовшому простому шляхові, що з'єднує корінь купи з одним із її листків, або термінальних вершин (вершина, що не має нащадків). Висота купи визначається за наступною формулою:

де N - кількість вершин дерева.

1.2 Функціональність

Над купою можна виконувати наступні операції:

- додати елемент до купи;

- виключити максимальний елемент із купи;

- змінити значення будь-якого елемента.

На основі цих операцій можна виконати наступні дії:

- перетворити невпорядкований масив елементів у купу;

- відсортувати масив шляхом перетворення його в купу, а купу - у відсортований масив.

Бінарні купи використовують, наприклад, для того, щоб вилучити мінімум із набору чисел.

1.3 Базові процедури

1.3.1 Пірамідальне сортування

Процедура, яку умовно називають Heapsort - це алгоритм сортування, що працює гарантовано. Така процедура сортує масив без використання додаткових ресурсів пам'яті, ця її властивість не залежить від розміру масиву. Можна розглядати її як вдосконалене сортування так званою «бульбашкою» (або сортування обміном), в якому елемент, так би мовити, «спливає» (в разі якщо маємо min-heap) або «тоне» (у випадку max-heap).

Пірамідальне сортування (або сортування купою) було запропоноване Дж. Вільямсом у 1964 році.

Опис алгоритму

Пірамідальне сортування використовує бінарне дерево сортування - це таке дерево, яке задовольняє дві умови:

1) кожен листок має глибину d або (d - 1), де d - максимальна глибина дерева;

2) значення елемента будь-якої вершини не менше (або не більше) за значення його нащадків.

Алгоритм сортування складається з двох основних кроків. Спершу елементи масиву Array розміщуються так, щоб вони мали вигляд дерева сортування. Мають виконуватися такі умови:

Array[i] ? Array [2i];

Array[i] ? Array [2i + 1];

Потім видаляються елементи із кореня по одному за раз і перебудовується дерево. Тобто на першому кроці міняються місцями Array[1] та Array[n], а Array[1], Array[2], … , Array[n-1] таким чином перетворюються на дерево сортування. Далі переставляється Array[1] на місце Array[n-1], а Array[1], Array[2], … , Array[n-2] перетворюються на дерево сортування. Процес продовжується доти, доки в дереві сортування не залишиться один елемент. Тоді отримується Array[1], Array[2], … , Array[n] - впорядкована послідовність.

Як і будь-який інший алгоритм, пірамідальне сортування має свої плюси та мінуси.

Переваги:

- сортує одразу, тобто майже не використовує додаткових ресурсів пам'яті.

Недоліки:

- складний у реалізації;

- для майже відсортованих масивів працює так само довго, як і на хаотичних даних.

Втім саме алгоритм сортування купою активно використовується в ядрі операційної системи Linux.

1.3.2 Відновлення властивостей купи

Якщо в купі змінюється один з елементів, то вона може перестати задовольняти умову впорядкованості (тобто всі нащадки мають бути меншими за своїх предків чи навпаки). Для відновлення цієї властивості використовують процедуру відновлення властивостей купи, яку умовно називають Heapify. Така процедура відновлює властивість купи в дереві (тобто пріоритет кожної вершини більший за пріоритет її нащадків), у якого ліве та праве піддерева задовольняють вищевказану умову. Вхідними параметрами цієї процедури є масив елементів А та індекс і. Вона відновлює властивість впорядкованості в усьому піддереві, коренем якого є елемент А[i].

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

Можна сказати, що процедуру Heapify також іноді називають просіюванням. Виділяють просіювання вгору і просіювання вниз.

Просіювання вгору

Якщо просто додати елемент в кінець масиву, то властивість піраміди може бути порушена. Для відновлення властивостей піраміди, виконується процедура просіювання вгору для доданого елемента. Процедуру можна описати за допомогою наступного алгоритму. Якщо елемент кореневий або його значення менше чи рівне за значення його попередника, то процес завершено, в іншому ж разі міняються місцями значення елемента та його попередника. Далі виконується перехід до попередника й виконання для нього вищевказаного алгоритму, починаючи з пункту 1. Після виконання такої процедури властивість купи буде відновлено.



Рис.3.1 - Просіювання вгору

Просіювання вниз

За потреби замінити кореневий елемент на будь-який інший, пірамідальну структуру бінарного дерева можна відновити за допомогою процедури просіювання вниз, яка має наступний опис. За умови, що елемент листковий або його значення більше чи рівне за значення нащадків, процес завершено, в іншому разі міняються місцями значення елемента і його нащадка, який має максимальне значення. Далі відбувається перехід до зміненого нащадка й виконання для нього вищевказаного алгоритму, починаючи з пункту 1.

Рис.3.2 - Просіювання вниз

1.3.3 Побудова купи

Ця процедура розроблена для створення купи із невпорядкованого масиву вхідних даних. Слід зазначити, що в разі виконання Heapify для всіх елементів масиву А, починаючи з останнього й закінчуючи першим, буде отримано купу. Насправді, очевидно, що до виконання Heapify(A, i) всі піддерева, корені яких мають індекс більший за і, є купами. Як наслідок, після виконання вищевказаної процедури купами стануть усі піддерева, корені яких мають індекс не менший за і.

Крім того, Heapify (A, i) не виконується за умови, що i > N/2 (в разі нумерації з першого елемента), де N - кількість елементів масиву. Насправді такі елементи не мають нащадків, як наслідок, відповідні піддерева вже є купами, оскільки містять лише один елемент.

Таким чином, достатньо викликати Heapify для всіх елементів масиву А, починаючи з [N/2]-го та закінчуючи першим.

1.3.4 Зміна значення елемента

Ця процедура заміняє елемент купи на новий із значенням, яке не є меншим за значення вихідного елемента. Зазвичай цю процедуру використовують для додавання будь-якого елемента до купи.

Якщо внесений елемент менший за свого попередника, то умова 1(див. п. 1) виконана для всього дерева, більше нічого не потрібно. Якщо ж він більший, то міняється місцями з попередником. В тому разі, коли попередник виявляється більшим за свого попередника, вони міняються місцями і т. д. Інакше кажучи, найбільший елемент «спливе».

Якщо необхідно зменшити значення елемента, достатньо викликати процедуру Heapify.

1.3.5 Додавання елемента

Процедура виконує додавання елемента в купу. Потім відновлюється властивість впорядкованості за допомогою наведеної вище процедури Heap_increase_key.

1.3.6 Вилучення максимального елемента

Така процедура виконується за чотири кроки. Спершу значення кореневого елемента (який і є максимальним) зберігається для повернення, а останній елемент копіюється в корінь, після чого видаляється із купи і викликається Heapify для нового кореня. Збережений елемент повертається.

2. ОПИС ПРОГРАМИ

У даній програмі реалізовано структуру даних «піраміда» і продемонстровано основні дії над нею: створення піраміди; додавання та заміна, вилучення максимального елемента.

2.1 Опис класу Pyramid

Щоб реалізувати структуру даних «піраміда», були використані засоби мови С#. Клас Pyramid містить у собі основні методи, використовувані для роботи зі структурою.

Методи класу Pyramid

1. Heap_Insert(int value, List<int> elements): додавання елемента, вказаного користувачем, до купи.

2. Heapify(int i): відновлює основну властивість купи для дерева з кореневим елементом в і-й вершині.

3. BuildHeap(int[] source): забезпечує побудову піраміди з дотриманням властивостей купи.

4. HeapExtractMax(): вилучає максимальний елемент із купи, який і є результатом роботи метода.

5. public void HeapSort(int[] array): реалізовує алгоритм пірамідального сортування для невпорядкованого масиву.

2.2 Інструкція для користувача

Щоб створити піраміду на основі елементів обраного Вами файлу, натисніть «Actions» «Build» «Source file…». В новому вікні оберіть файл та натисніть кнопку «Open».

Якщо бажаєте створити піраміду, ввівши її елементи власноруч, натисніть «Actions» «Build» «Enter elements». На екрані з'явиться нове вікно, в якому необхідно ввести всі елементи майбутньої піраміди. По закінченню натисніть кнопку «CREATE».

Для вилучення максимального елемента вже побудованої піраміди натисніть «Actions» «Extract max».

Щоб додати елемент до вже побудованої піраміди натисніть «Actions» «Add element». У вікні, що з'явиться, введіть значення елемента, який бажаєте додати.

Для отримання інформації про програму та розробника натисніть «About».

Якщо ви бажаєте отримати допомогу з приводу користування програмою, натисніть «Help».

Щоб вийти натисніть «Actions» «Quit».

ВИСНОВКИ

В процесі виконання курсової роботи навички програмування мовою C# та роботи з графічним інтерфейсом були суттєво покращені.

Було реалізовано клас для представлення структури даних «піраміда» та основних методів для роботи з нею, а саме: побудова піраміди з дотриманням властивостей купи, відновлення властивостей купи, пірамідальне сортування, додавання елемента до побудованої купи, вилучення максимального елемента. Піраміда - багатофункціональна структура, що дозволяє як додавати, так і вилучати елементи. Виявилося, що пірамідальне сортування потребує дуже мало, тобто О(1) віртуальної пам'яті, швидко працює (потребує (n log₂n) часу на сортування n елементів), проте алгоритм доволі нестійкий та досить складний у реалізації.

ДОДАТОК

Рис. А1 - Головне вікно програми

Рис. А2 - Вікно вводу елементів

Рис. А3 - Вікно «Про програму»

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Curseme1

{

public class Pyramid

{

private List<int> list; // колекція елементів купи

public int Size // розмір купи -- кількість елементів

{

get

{

return this.list.Count(); // повертаємо значення розміру

}

}

public List<int> List

{

get

{

return list;

}

set

{

list = value;

}

}

public Pyramid()

{

list = new List<int>() { };

}

public void Heap_Insert(int value) // метод для додавання елемента до купи

{

list.Add(value); // новий елемент додаємо в кінець масиву, тобто на позицію з індексом heapsize

int i = list.Count - 1;

int parent = (i - 1) / 2; // індекс позиції елемента вершини

while (i > 0 && list[parent] < list[i]) // поки елемент вершини менший за листковий елемент, проводимо процедуру

{

// міняємо місцями елемент вершини та листковий елемент

int temp = list[i];

list[i] = list[parent];

list[parent] = temp;

// для подальшої перевірки на дотримання властивостей купи...

i = parent;

parent = (i - 1) / 2;

}

}

public void Heapify(int i) // відновлює основну властивість купи для дерева з коренем в i-й вершині

{

int leftLeaf; // лівий листок

int rightLeaf; // правий листок

int largestLeaf; // найбільший із листків

while (true) // поки властивість піраміди не буде відновлено, цикл триватиме

{

leftLeaf = 2 * i + 1; // індекс лівого листка відносно обраного елемента

rightLeaf = 2 * i + 2; // індекс правого листка відносно обраного елемента

largestLeaf = i; // індекс обраного елемента

// якщо один із елементів виявляється більшим за обраний, міняємо їх місцями

if ((leftLeaf < list.Count) && (list[leftLeaf] > list[largestLeaf]))

{

largestLeaf = leftLeaf;

}

if ((rightLeaf < list.Count) && (list[rightLeaf] > list[largestLeaf]))

{

largestLeaf = rightLeaf;

}

// в іншому випадку властивість купи дотримано

if (largestLeaf == i)

{

break;

}

int temp = list[i];

list[i] = list[largestLeaf];

list[largestLeaf] = temp;

i = largestLeaf;

}

}

public void BuildHeap(int[] source) // побудова піраміди із дотриманням властивості купи

{

list = source.ToList();

for (int i = list.Count / 2; i >= 0; i--)

{

Heapify(i); // викликаємо процедуру для дотримання властивості купи

}

}

public int HeapExtractMax() // вилучення максимального елемента, що знаходиться у корені

{

int result = list[0];

list[0] = list[list.Count - 1];

list.RemoveAt(list.Count - 1);

return result;

}

public int HeapExtractMaxWithDel() // вилучення максимального елемента, що знаходиться у корені, з його подальшим видаленням

{

int result = list[0];

list.Remove(list[0]);

return result;

}

public void HeapSort(int[] array) // пірамідальне сортування

{

BuildHeap(array);

List<int> cult = new List<int>(list.Count);

cult = list.GetRange(0, list.Count);

int[] test = new int[list.Count];

for (int i = 0; i < test.Length; i++)

{

test[i] = HeapExtractMax();

Heapify(0);

}

list = test.ToList();

}

public void Heap_Increase_Key(int index, int changing) // зміна елемента купи з певним індексом

{

list[index] = changing;

int nod = (index - 1) / 2; // знаходимо індекс попередника змінюваного елемента

while ((list[index] > list[nod]) && (index > 0)) // якщо листок виявився більшим за вузол, міняємо їх місцями

{

Swap(list[index], list[nod]);

index = nod;

nod = (index - 1) / 2;

}

}

public void Swap(int a, int b)

{

int c = a;

a = b;

b = c;

}

}

}

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

using System.IO;

namespace Curseme1

{

partial class Form1 : Form

{

Pyramid pyramid = new Pyramid();

public Form1()

{

InitializeComponent();

}

private void sourceFileToolStripMenuItem_Click(object sender, EventArgs e) // побудувати піраміду з елементів з файлу

{

if (openFileDialog1.ShowDialog() == System.Windows.Forms.DialogResult.OK) // відкриваємо файл

{

int[] source = new int[12]; // початковий масив

BinaryReader r = new BinaryReader(File.Open(openFileDialog1.FileName, FileMode.Open)); // зчитуємо елементи файла

try

{

for (int i = 0; i < 12; i++) // для зручності відображення беруться лише 12 перших елементів

source[i] = r.ReadInt32();

}

catch (EndOfStreamException) { r.Close(); }

pyramid.HeapSort(source); // побудова купи

pictureBox1.Visible = true;

pictureBox1.Invalidate(); // промальовка елементів

}

}

public void pictureBox1_Paint(object sender, PaintEventArgs e) // промальовка елементів

{

// засоби для малювання

Graphics g = e.Graphics;

Brush mynewbrush = new SolidBrush(Color.FloralWhite);

Font digits = new Font("Colibri", 40);

Pen circles = new Pen(Color.LightSkyBlue, 3);

PointF pointdrawer = new PointF();

float width = pictureBox1.Width; // необхідна для розміщення вершин дерева величина

float rootcoord = 0; // координата кореня за ігреком (т.я. дерево спускатиметься вниз, приймає значення нуля)

int topsperlvl = 1, depths = 1; // вершин на рівні, глибина

int aux = 0;

if (pyramid.List == null || pyramid.Size < 0)

{

MessageBox.Show("Your pyramid is empty or it's size is less than 0!", "Error!", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);

}

else

{

int size = pyramid.Size;

int tops = 1;

while (tops < size) // дізнаємося глибину піраміди: щоразу к-ть вершин збільшуватиметься у 2 рази

{

size -= tops;

tops *= 2;

depths++;

}

size = pyramid.Size;

for (int i = 0; i < depths; i++) // маємо промалювати всі рівні вершин

{

for (int k = 0; k < topsperlvl; k++) // маємо промалювати всі вершини на рівні

{

e.Graphics.DrawEllipse(circles, (2 * k + 1) * (width / 2), rootcoord, 80, 80);

if (rootcoord != 0 && k % 2 != 0) // якщо було створено корінь і ще не обидві з двох вершин промальовані, малюємо ребро одразу

{ e.Graphics.DrawLine(circles, (2 * k + 1) * (width / 2) + 40, rootcoord, k * width + 40, rootcoord - 80); } // лінія з*єднує середини кіл

if (rootcoord != 0 && k % 2 == 0) // те саме для другої вершини

{ e.Graphics.DrawLine(circles, (2 * k + 1) * (width / 2) + 40, rootcoord, (k + 1) * width + 40, rootcoord - 80); } // -||-

string comp = Convert.ToString(pyramid.List[(aux + k)]);

if (comp.Length >= 2)

{

pointdrawer = new PointF((2 * k + 1) * (width / 2), (rootcoord + 12)); // намагаємось вмістити число в серединку кола

e.Graphics.DrawString(Convert.ToString(pyramid.List[(aux + k)]), digits, mynewbrush, pointdrawer); // вміщуємо число

}

else

{

pointdrawer = new PointF((2 * k + 1) * (width / 2) + 15, (rootcoord + 12)); // намагаємось вмістити число в серединку кола

e.Graphics.DrawString(Convert.ToString(pyramid.List[(aux + k)]), digits, mynewbrush, pointdrawer); // вміщуємо число

}

}

size -= topsperlvl; // віднімаємо вже намальовані вершини

aux = 2 * aux + 1; // для обходу листків подвоюємо допоміжну змінну і додаємо +1 елемент

if (size < 2 * topsperlvl) // якщо вийшли на останній рівень, розмір -- кількість вершин на останньому рівні

{

topsperlvl = size;

rootcoord = rootcoord + 160; // інакше змінюємо координату кореня піддерева

width = width / 2; // ділимо бокс навпіл

}

else

{

rootcoord = rootcoord + 160; // інакше змінюємо координату кореня піддерева

width = width / 2; // ділимо бокс навпіл

topsperlvl = 2 * topsperlvl; // збільшуємо вдвічі кількість вершин на рівні

}

}

}

}

private void Form1_SizeChanged(object sender, EventArgs e)

{

pictureBox1.Invalidate();

}

private void enterElementsToolStripMenuItem_Click(object sender, EventArgs e) // введення елементів піраміди з клавіатури

{

Form2 form = new Form2();

form.ShowDialog();

pyramid.List = form.Array.ToList();

pyramid.HeapSort(pyramid.List.ToArray()); // відновлюємо властивість купи

pictureBox1.Invalidate();

}

private void quitToolStripMenuItem_Click(object sender, EventArgs e) // вихід із програми

{

DialogResult wanttoquit = MessageBox.Show("Do you sure want to quit?", "Quit", MessageBoxButtons.YesNo);

if (wanttoquit == DialogResult.Yes) Application.Exit();

}

private void pictureBox1_VisibleChanged(object sender, EventArgs e)

{

pictureBox1.Invalidate();

}

private void deleteElementToolStripMenuItem_Click(object sender, EventArgs e) // для зміни елемента

{

Form3 form3 = new Form3();

form3.ShowDialog();

int tochange = form3.ChangeElement; // елемент готової купи, який необхідно замінити

if (pyramid.List.Contains(tochange))

{

// якщо такий елемент знайдено, вказати новий елемент

int index = pyramid.List.IndexOf(tochange);

MessageBox.Show("Now enter the element you want to see instead of the old one");

form3.ShowDialog();

int change = form3.ChangeElement;

pyramid.Heap_Increase_Key(index, change);

pictureBox1.Invalidate();

pyramid.HeapSort(pyramid.List.ToArray()); // відновлюємо властивість купи

}

else // якщо вказаного елемента не існує в купі, повідомлення про помилку

{

MessageBox.Show("There is no such element in the pyramid! Try again!");

}

}

private void addElementToolStripMenuItem_Click(object sender, EventArgs e) // для додавання елемента

{

Form3 add = new Form3();

add.ShowDialog();

int addme = add.ChangeElement; // значення для додавання

pyramid.Heap_Insert(addme);

pictureBox1.Invalidate();

pyramid.HeapSort(pyramid.List.ToArray()); // відновлюємо властивість купи

}

private void extractMaxToolStripMenuItem_Click(object sender, EventArgs e) // для вилученння максимального елемента з його подальшим видаленням

{

string s = "Maximum element is ";

MessageBox.Show((s += pyramid.HeapExtractMaxWithDel()), "Success!");

pyramid.HeapSort(pyramid.List.ToArray());

pictureBox1.Invalidate();

}

private void helpToolStripMenuItem_Click(object sender, EventArgs e) // для отримання допомоги по роботі з програмою

{

Form4 help = new Form4();

help.ShowDialog();

pictureBox1.Invalidate();

}

private void aboutToolStripMenuItem_Click(object sender, EventArgs e) // для отримання інформації про програму

{

Form5 about = new Form5();

about.ShowDialog();

pictureBox1.Invalidate();

}

}

}

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

namespace Curseme1

{

public partial class Form2 : Form

{

Form1 owner;

public int[] array;

public Form2()

{

array = new int[12];

this.owner = (Form1)Owner;

InitializeComponent();

}

public int[] Array

{

get

{

return array;

}

}

Form1 form = new Form1();

// далі -- методи для вводу значень у бокси

private void textBox1_TextChanged(object sender, EventArgs e)

{

if (!int.TryParse(textBox1.Text, out array[0]))

{

{

MessageBox.Show("Ivalid element format or even no element at all!");

textBox1.Refresh();

}

}

}

private void textBox12_TextChanged(object sender, EventArgs e)

{

if (!int.TryParse(textBox12.Text, out array[2]))

{

MessageBox.Show("Ivalid element format or even no element at all!");

textBox12.Refresh();

}

}

private void textBox13_TextChanged(object sender, EventArgs e)

{

if (!int.TryParse(textBox13.Text, out array[1]))

{

MessageBox.Show("Ivalid element format or even no element at all!");

textBox13.Refresh();

}

}

private void textBox11_TextChanged(object sender, EventArgs e)

{

if (!int.TryParse(textBox11.Text, out array[3]))

{

MessageBox.Show("Ivalid element format or even no element at all!");

textBox11.Refresh();

}

}

private void textBox10_TextChanged(object sender, EventArgs e)

{

if (!int.TryParse(textBox10.Text, out array[4]))

{

MessageBox.Show("Ivalid element format or even no element at all!");

textBox10.Refresh();

}

}

private void textBox9_TextChanged(object sender, EventArgs e)

{

if (!int.TryParse(textBox9.Text, out array[5]))

{

MessageBox.Show("Ivalid element format or even no element at all!");

textBox9.Refresh();

}

}

private void textBox8_TextChanged(object sender, EventArgs e)

{

if (!int.TryParse(textBox8.Text, out array[6]))

{

MessageBox.Show("Ivalid element format or even no element at all!");

textBox8.Refresh();

}

}

private void textBox7_TextChanged(object sender, EventArgs e)

{

if (!int.TryParse(textBox7.Text, out array[7]))

{

MessageBox.Show("Ivalid element format or even no element at all!");

textBox7.Refresh();

}

}

private void textBox6_TextChanged(object sender, EventArgs e)

{

if (!int.TryParse(textBox6.Text, out array[8]))

{

MessageBox.Show("Ivalid element format or even no element at all!");

textBox6.Refresh();

}

}

private void textBox5_TextChanged(object sender, EventArgs e)

{

if (!int.TryParse(textBox5.Text, out array[9]))

{

MessageBox.Show("Ivalid element format or even no element at all!");

textBox5.Refresh();

}

}

private void textBox4_TextChanged(object sender, EventArgs e)

{

if (!int.TryParse(textBox4.Text, out array[10]))

{

MessageBox.Show("Ivalid element format or even no element at all!");

textBox4.Refresh();

}

}

private void textBox3_TextChanged(object sender, EventArgs e)

{

if (!int.TryParse(textBox3.Text, out array[11]))

{

MessageBox.Show("Ivalid element format or even no element at all!");

textBox3.Refresh();

}

}

private void button1_Click(object sender, EventArgs e)

{

Close();

}

private void label4_Click(object sender, EventArgs e)

{

}

}

}

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

namespace Curseme1

{

public partial class Form3 : Form

{

Form1 owner;

public int changeelement; // для елемента, який необхідно додати чи змінити

public int ChangeElement

{

get

{

return changeelement;

}

}

public Form3()

{

this.owner = (Form1)Owner;

InitializeComponent();

}

private void textBox1_TextChanged(object sender, EventArgs e)

{

textBox1.Refresh();

if (!int.TryParse(textBox1.Text, out changeelement))

{

{ MessageBox.Show("Ivalid element format or even no element at all!"); textBox1.Refresh(); }

}

}

private void button1_Click(object sender, EventArgs e)

{

Close();

}

}

}

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

namespace Curseme1

{

public partial class Form4 : Form

{

public Form4()

{

InitializeComponent();

}

private void button1_Click(object sender, EventArgs e)

{

this.Close();

}

}

}

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Windows.Forms;

namespace Curseme1

{

public partial class Form5 : Form

{

public Form5()

{

InitializeComponent();

}

}

}





Размещено на Allbest.ru

...