Mavzu: Dinamik turdagi ma’lumotlar tuzilmasi. Bir bog‘lamli ro‘yxat xosil qiling va uning boshidan 3ta element uchirish dasturini tuzing
Reja:
1. Dinamik turdagi ma’lumotlar tuzilmasi
2. Dinamik ma’lumotlar tuzilmasi klassifikatsiyasi
3. Dinamik ma’lumotlar tuzilmasi - ro’yhatlar
4. Dinamik ma'lumotlar tuzilmalari tuzilishi. Afzalliklari va kamchiliklari
5. Xulosa
6. Foydalanilgan adabiyot
Kirish
Ma'lumotlar tuzilmasi dasturlarda ajratish usuli bo'yicha statik va dinamikaga bo'lingan. Statik ma'lumotlar tuzilmasi - bu kompyuterning xotirasida joylashishi va elementlarning o'zaro aloqalari ular tomonidan amalga oshiriladigan sohada dasturni bajarish paytida o'zgarishsiz qoladigan ma'lumotlardir.
Statik strukturaning ma'lumotlariga dasturda e'lon qil ngan asosiy va mahalliy, ham global,darajadagi o'zgaruvchilar kiradi. Dinamik ma'lumotlar tuzilmasi - bu kompyuterning xotirasiga joylashtirilishi va New va Dispose kabi tizim proseduralari yordamida dasturni bajarishda xotiradan o'chirilishi mumkin bo'lgan ma'lumotlar.
Dinamik ma'lumotlar tuzilmalari ikki shaklda bo'ladi: bog'liq bo'lmagan dinamik ma'lumotlar; bog’liq dinamik ma'lumotlar.
Bog’liq bo'lmagan dinamik ma'lumotlar tuzilmasi statik bilan bir xil. Bundan tashqari, bog'liq bo'lmagan dinamik ma'lumotlar avtomatik ravishda emas, balki dasturchi tomonidan xotirada saqlanadi. Bog’liq bo’lgan dinamik ma'lumotlarga ro'yxatlar, navbatlar va ustunlar kiradi; bu elementlar manzillar havolalari yordamida o'zaro bog'liq bo'lgan birlashtirilgan ma'lumotlar.
1.Dinamik turdagi ma’lumotlar tuzilmasi
Statik ma’lumotlar tuzilmasi vaqt o’tishi bilan o’z o’lchamini o’zgartirmaydi. Biz har doim dastur kodidagi statik ma’lumotlar tuzilmasiga qarab ularning o’lchamini bilishimiz mumkin. Bunday ma’lumotlarga teskari ravishda dinamik ma’lumotlar tuzilmasi mavjud bo’lib, bunda dastur bajarilishi davomida dinamik ma’lumotlar tuzilmasi o’lchamini o’zgartirishi mumkin.
Dinamik ma’lumotlar tuzilmasi – bu qandaydir bir qonuniyatga asoslanib shakllangan, lekin elementlari soni, o’zaro joylashuvi va o’zaro aloqasi dastur bajarilishi davomida shu qonuniyat asosida dinamik o’zgaruvchan bo’lgan ma’lumotlar tuzilmasidir. Dinamik ma’lumotlar tuzilmasi 1-rasmdagide k klassifikatsiyalanadi.
1-rasm. Dinamik ma’lumotlar tuzilmasi klassifikatsiyasi
Dasturlarda dinamik ma’lumotlar tuzilmasidan ko’pincha chiziqli ro’yhatlar, steklar, navbatlar va binar daraxtlar ishlatiladi. Bu tuzilmalar bir-biridan elementlarning bog’lanish usuli va ular ustida bajarilishi mumkin bo’lgan amallari bilan farqlanadi. Dinamik tuzilmalar massiv va yozuvdan farqli ravishda operativ xotirada ketma-ket sohalarda joylashmaydi. Ixtiyoriy dinamik tuzilma elementi 2 ta maydondan tashkil topadi: tuzilma tashkil etilishiga sabab bo’layotgan informatsion maydon va elementlarning o’zaro aloqasini ta’minlovchi ko‘rsatkichli maydon.
2. Dinamik ma’lumotlar tuzilmasi klassifikatsiyasi
Ko'pincha jiddiy dasturlarda siz ish paytida hajmi va tuzilishi o'zgarishi kerak bo'lgan ma'lumotlardan foydalanishingiz kerak. Dinamik qatorlar bu erda yordam bermaydi, chunki qancha xotira ajratilishi kerakligini oldindan aytib bo'lmaydi - bu faqat ish paytida aniqlanadi. Masalan, biz matnni tahlil qilishingiz va unda qanday so'zlar va qancha miqdorda mavjudligini aniqlashimiz kerak va bu so'zlarni alifbo tartibida tartibga solish kerak.
Hammasi bo'lib, dinamik ma'lumotlar tuzilishining 6 ta asosiy turi mavjud:
Stek
Navbat
Ro’yhat
Daraxt
Graf
Ro‘yxat. Ro'yxatning 3 turi mavjud:
Bir bog’lamli (chiziqli)
Ikki bog’lamli
Siklik
Bir bog'lamli ro'yxat navbatga o'xshaydi, lekin undan farqli o'laroq, ro'yxat bilan ishlaganda, siz istalgan joyga biron bir narsani qo'shishingiz va ro'yxatning yuqori qismida faqa t bitta ko'rsatgichdan foydalanishingiz mumkin.
Ikkala bog'langan ro'yxat. Bir bog'lamli ro'yxat bilan ishlashda ko'plab muammolar ulardagi oldingi elementga o'tishning iloji yo'qligidan kelib chiqadi rasm. Ro’yhat tuzilishi
Navbat - bu elementlarning to'plamidir, unda yangi elementlarni qo'shishga ruxsat beriladi (u navbatning boshlanishi deb ataladi) va mavjud elementlarni faqat ikkinchi chetidan o'chirish, qaysi biri? chiziqning oxiri deb nomlangan.
Stek - bu elementlarning to'plami bo'lib, unda yangi elementlarni qo'shish va mavjud elementlarni faqat bitta uchidan olish mumkin bo'ladi.
Zamonaviy kompyuterlarda stek quyidagi maqsadlarda ishlatiladi:
mahalliy o'zgaruvchilarni aniqlash
protsedura yoki funktsiya parametrlarini joylashtirish
Qaytish manzilini saqlash (protseduradan qaysi manzilga qaytishingiz kerak)
vaqtincha ma'lumotlarni saqlash, ayniqsa Assembler-da dasturlash paytida
3. Dinamik ma’lumotlar tuzilmasi - ro’yhatlar
Chiziqli ro’yhatlarda har bir element o’zidan keyingisi yoki oldingisi bilan ham bog’langan bo’lishi mumkin. Birinchi holatda, ya’ni elementlar o’zidan keyingi element bilan bog’langan bo’lsa, bunday ro’yhatga bir bog‘lamli ro‘yhat deyiladi. Mazkur ko’rinishdagi ro’yhat elementi k’rsatkichining o’ziga xosligi shundan iboratki, faqatgina ro’yhatning navbatdagi elementi adresini ko’rsatadi. Bir tomonlama yo’naltirilgan ro’yhatda eng so’nggi element ko’rsatkichi bo’sh, ya’ni NULL bo’ladi.
Agar har bir element o’zidan oldingi va o’zidan keyingi element bilan bog’langan bo’lsa, u holda bunday ro’yhatlarga 2 bog‘lamli ro‘yhatlar deyiladi.
Agar oxirgi element birinchi element ko’rsatkichi bilan bog’langan bo’lsa, bunday ro’yhatga halqasimon ro‘yhat deyiladi. Ro’yhatning har bir elementi shu elementni identifikatsiyalash uchun kalitga ega bo’ladi. Kalit odatda butun son yoki satr ko’rinishida ma’lumotlar maydonining bir qismi sifatida mavjud bo’ladi.
Ro’yhatlar ustida quyidagi amallarni bajarish mumkin:
- ro’yhatni shakllantirish (birinchi elementini yaratish);
- ro’yhat oxiriga yangi element qo’shish;
- berilgan kalitga mos elementni o’qish;
- ro’yhatning ko’rsatilgan joyiga element qo’shish (berilgan kalitga mos elementdan oldin yoki keyin)
- berilgan kalitga mos elementni o’chirish;
- kalit bo’yicha ro’yhat elementlarini tartibga keltirish.
Ro’yhatlar bilan ishlashda dasturda boshlang’ich elementni ko’rsatuvchi ko’rsatkich talab etiladi.
4.Dinamik ma'lumotlar tuzilmalari tuzilishi. Afzalliklari va kamchiliklari
Dinamik ma’lumotlar tuzilmasining har bir elementi ikki qismdan iborat:
1.Ma'lumotlar joylashtirilgan ma'lumotlar uchun maydonlar, ular uchun struktura yaratiladi. O'z navbatida, axborot maydonlarida ma'lumotlar tuzilmasi ham bo'lishi mumkin. Elementlarni bir-biriga bog'laydigan bir yoki bir nechta havolalarni o'z ichiga olgan xizmat maydonlari.
Dinamik ma’lumotlar tuzilmasining afzalliklari:
- Strukturaning o'lchami faqat mavjud RAM miqdori bilan cheklangan,
- Ma'lumotlarning tartibini o'zgartirganda ma'lumotlarni ko'chirish emas, balki faqat havolalarni to'g'rilash talab qilinadi;
- Strukturaning ajoyib moslashuvchanligi.
Kamchiliklari:
- O'zboshimchalik elementiga kirish vaqtini oldindan aniqlashning imkoni yo'q,
- Havolalarni saqlash uchun qo'shimcha xotira talab qilinadi.
Xulosa
Men,mavzudan,ushbu tuzilmalarni amaliy topshiriqlarda ishlatishda, faqat ma'lumot maydonlari oxirgi foydalanuvchiga ko'rinadigan qilib qo'yilar va xizmat ko'rsatish maydonlaridan faqat dasturchi foydalananar ekan
Adabiyotlar
1. Информатика: учебник – 3-е переработанное издание/ под ред. Н.В. Макаровой.- М: Финансы и статистика, 2004. – 768 с.
2. Страуструп Б. Язык программирования C++. Специальное издание. Пер. с англ. – М.: ООО «Бином-Пресс», 2006 г. – 1104 с.: ил.
3. Xudoyberdiyev M.X., Akbaraliyev B.B. “Ma‟lumotlat tuzilmasi va algoritmlar” fanidan amaliy mashg’ulotlar uchun topshiriqlar (uslubiy ko’rsatmalari bilan). Toshklent, 2013 y.
#include
using namespace std;
// A linked list node
struct Node
{
int data;
struct Node *next;
};
//insert a new node in front of the list
void push(struct Node** head, int node_data)
{
/* 1. create and allocate node */
struct Node* newNode = new Node;
/* 2. assign data to node */
newNode->data = node_data;
/* 3. set next of new node as head */
newNode->next = (*head);
/* 4. move the head to point to the new node */
(*head) = newNode;
}
//insert new node after a given node
void insertAfter(struct Node* prev_node, int node_data)
{
/*1. check if the given prev_node is NULL */
if (prev_node == NULL)
{
cout<<"the given previous node is required,cannot be NULL"; return; }
/* 2. create and allocate new node */
struct Node* newNode =new Node;
/* 3. assign data to the node */
newNode->data = node_data;
/* 4. Make next of new node as next of prev_node */
newNode->next = prev_node->next;
/* 5. move the next of prev_node as new_node */
prev_node->next = newNode;
}
/* insert new node at the end of the linked list */
void append(struct Node** head, int node_data)
{
/* 1. create and allocate node */
struct Node* newNode = new Node;
struct Node *last = *head; /* used in step 5*/
/* 2. assign data to the node */
newNode->data = node_data;
/* 3. set next pointer of new node to null as its the last node*/
newNode->next = NULL;
/* 4. if list is empty, new node becomes first node */
if (*head == NULL)
{
*head = newNode;
return;
}
/* 5. Else traverse till the last node */
while (last->next != NULL)
last = last->next;
/* 6. Change the next of last node */
last->next = newNode;
return;
}
// display linked list contents
void displayList(struct Node *node)
{
//traverse the list to display each node
while (node != NULL)
{
cout";
node = node->next;
}
if(node== NULL)
cout<<"null";
}
/* main program for linked list*/
int main()
{
/* empty list */
struct Node* head = NULL;
// Insert 10.
append(&head, 10);
// Insert 20 at the beginning.
push(&head, 20);
// Insert 30 at the beginning.
push(&head, 30);
// Insert 40 at the end.
append(&head, 40);
insertAfter(head->next, 50);
cout<<"Final linked list: "<
displayList(head);
return 0;
}
|
class LinkedList
{
Node head; // head of list
//linked list node declaration
class Node
{
int data;
Node next;
Node(int d) {data = d; next = null; }
}
/* Insert a new node at the front of the list */
public void push(int new_data)
{
//allocate and assign data to the node
Node newNode = new Node(new_data);
//new node becomes head of linked list
newNode.next = head;
//head points to new node
head = newNode;
}
// Given a node,prev_node insert node after prev_node
public void insertAfter(Node prev_node, int new_data)
{
//check if prev_node is null.
if (prev_node == null)
{
System.out.println("The given node is required and cannot be null");
return;
}
//allocate node and assign data to it
Node newNode = new Node(new_data);
//next of new Node is next of prev_node
newNode.next = prev_node.next;
//prev_node->next is the new node.
prev_node.next = newNode;
}
//inserts a new node at the end of the list
public void append(intnew_data)
{
//allocate the node and assign data
Node newNode = new Node(new_data);
//if linked list is empty, then new node will be the head
if (head == null)
{
head = new Node(new_data);
return;
}
//set next of new node to null as this is the last node
newNode.next = null;
// if not the head node traverse the list and add it to the last
Node last = head;
while (last.next != null)
last = last.next;
//next of last becomes new node
last.next = newNode;
return;
}
//display contents of linked list
public void displayList()
{
Node pnode = head;
while (pnode != null)
{
System.out.print(pnode.data+"-->");
pnode = pnode.next;
}
if(pnode == null)
System.out.print("null");
}
}
//Main class to call linked list class functions and construct a linked list
class Main{
public static void main(String[] args)
{
/* create an empty list */
LinkedList lList = new LinkedList();
// Insert 40.
lList.append(40);
// Insert 20 at the beginning.
lList.push(20);
// Insert 10 at the beginning.
lList.push(10);
// Insert 50 at the end.
lList.append(50);
// Insert 30, after 20.
lList.insertAfter(lList.head.next, 30);
System.out.println("\nFinal linked list: ");
lList. displayList ();
}
}
|
Output:
Final linked list:
10–>20–>30–>40–>50–>null
http://fayllar.org
|
