Chiziqli Ma'lumotlar Tuzilmalari

Elementlar ketma-ket tartibda joylashgan tuzilmalar

Array List Stack Queue LinkedList

Array (Massiv)

Access: O(1) Insert: O(n) Delete: O(n) Search: O(n)

Tavsif

Array - bu bir xil turdagi elementlarning ketma-ket xotirada joylashgan to'plami. Har bir elementga indeks orqali O(1) vaqtda kirish mumkin. Array o'lchami belgilangandan keyin o'zgartirib bo'lmaydi.

Xususiyatlari:

  • Tez kirish (O(1))
  • Xotira samaradorligi
  • Cache-friendly
  • O'lcham o'zgarmas
  • Element qo'shish/o'chirish sekin

Real hayotdagi misollar:

  • Haftaning kunlari
  • Piksellar (rasmda)
  • Statistik ma'lumotlar

Interaktiv Demo

C# Kodi

// Array yaratish
int[] numbers = new int[5];  // Bo'sh massiv
int[] values = { 1, 2, 3, 4, 5 };  // Qiymatlar bilan

// Elementga kirish - O(1)
int firstElement = values[0];  // 1
int lastElement = values[values.Length - 1];  // 5

// Element o'zgartirish
values[2] = 10;  // [1, 2, 10, 4, 5]

// Massiv uzunligi
int length = values.Length;  // 5

// Massivni aylantirish
foreach (int num in values)
{
    Console.WriteLine(num);
}
// Qidirish - O(n)
int searchValue = 10;
int index = Array.IndexOf(values, searchValue);

// Tartiblash - O(n log n)
Array.Sort(values);

// Teskari aylantirish
Array.Reverse(values);

// Ko'chirish
int[] copy = new int[values.Length];
Array.Copy(values, copy, values.Length);

// Barcha elementlarni o'zgartirish
Array.Fill(values, 0);  // Barcha elementlarni 0 ga

// Minimal va maksimal
int min = values.Min();
int max = values.Max();

// Yig'indi
int sum = values.Sum();
// 2D massiv yaratish
int[,] matrix = new int[3, 4];  // 3 qator, 4 ustun

// Qiymatlar bilan
int[,] grid = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

// Elementga kirish
int element = grid[1, 2];  // 7

// Aylantirish
for (int i = 0; i < grid.GetLength(0); i++)
{
    for (int j = 0; j < grid.GetLength(1); j++)
    {
        Console.Write(grid[i, j] + " ");
    }
    Console.WriteLine();
}

List (Ro'yxat)

Access: O(1) Add: O(1)* Insert: O(n) Remove: O(n)

Tavsif

List<T> - bu C# da dinamik o'lchamli massiv. Elementlar soni kerak bo'lganda avtomatik ravishda oshadi. Array ga qaraganda moslashuvchan, lekin bir oz ko'proq xotira talab qiladi.

Xususiyatlari:

  • Dinamik o'lcham
  • Tez kirish (O(1))
  • Oxiriga qo'shish tez
  • Ko'plab qulaylik metodlari
  • Ko'proq xotira

Qachon ishlatish kerak:

  • Savatdagi mahsulotlar
  • Foydalanuvchilar ro'yxati
  • Dinamik ma'lumotlar

Interaktiv Demo

C# Kodi

// List yaratish
List<int> numbers = new List<int>();

// Qiymatlar bilan yaratish
List<string> names = new List<string> 
{ 
    "Ali", "Vali", "Hasan" 
};

// Element qo'shish - O(1) average
numbers.Add(10);
numbers.Add(20);
numbers.Add(30);

// Elementga kirish - O(1)
int first = numbers[0];  // 10

// Element soni
int count = numbers.Count;  // 3

// Aylantirish
foreach (int num in numbers)
{
    Console.WriteLine(num);
}
// Ma'lum pozitsiyaga qo'shish - O(n)
numbers.Insert(1, 15);  // [10, 15, 20, 30]

// Element o'chirish - O(n)
numbers.Remove(20);  // Qiymat bo'yicha
numbers.RemoveAt(0);  // Indeks bo'yicha

// Barchani o'chirish
numbers.Clear();

// Mavjudligini tekshirish
bool exists = numbers.Contains(15);

// Qidirish
int index = numbers.IndexOf(15);
int lastIndex = numbers.LastIndexOf(15);

// Qism ro'yxat
List<int> sublist = numbers.GetRange(0, 3);

// Tartiblash
numbers.Sort();
numbers.Reverse();

// Massivga o'tkazish
int[] array = numbers.ToArray();
using System.Linq;

// Filtrlash
var evenNumbers = numbers.Where(x => x % 2 == 0).ToList();

// Transformatsiya
var doubled = numbers.Select(x => x * 2).ToList();

// Yig'indi, o'rtacha
int sum = numbers.Sum();
double avg = numbers.Average();
int max = numbers.Max();
int min = numbers.Min();

// Birinchi/oxirgi
int first = numbers.First();
int last = numbers.Last();
int firstEven = numbers.FirstOrDefault(x => x % 2 == 0);

// Hammasi/biror-biri
bool allPositive = numbers.All(x => x > 0);
bool anyNegative = numbers.Any(x => x < 0);

// Takrorlanmaganlar
var unique = numbers.Distinct().ToList();

Stack (Stek)

Push: O(1) Pop: O(1) Peek: O(1)

Tavsif

Stack - bu LIFO (Last In First Out) prinsipi asosida ishlaydigan tuzilma. Oxirgi qo'shilgan element birinchi bo'lib chiqariladi. Xuddi plastinkalar to'plami kabi.

Asosiy operatsiyalar:

  • Push - element qo'shish
  • Pop - element olib tashlash
  • Peek - yuqoridagi elementni ko'rish
  • Count - elementlar soni

Qo'llanilishi:

  • Undo/Redo funksiyalari
  • Brauzerdagi orqaga/oldinga
  • Rekursiya (call stack)
  • Ifoda hisoblash

Interaktiv Demo

C# Kodi

// Stack yaratish
Stack<int> stack = new Stack<int>();

// Push - element qo'shish - O(1)
stack.Push(10);
stack.Push(20);
stack.Push(30);
// Stack: [30, 20, 10] (tepada 30)

// Peek - tepasini ko'rish - O(1)
int top = stack.Peek();  // 30 (o'chirmasdan)

// Pop - tepasini olish - O(1)
int removed = stack.Pop();  // 30
// Stack: [20, 10]

// Count - elementlar soni
int count = stack.Count;  // 2

// Contains - mavjudligini tekshirish
bool exists = stack.Contains(20);  // true

// Clear - barchasini o'chirish
stack.Clear();

// Bo'shligini tekshirish
bool isEmpty = stack.Count == 0;
// Qavs tekshirish misoli
public static bool IsValidParentheses(string s)
{
    Stack<char> stack = new Stack<char>();
    
    foreach (char c in s)
    {
        if (c == '(' || c == '{' || c == '[')
        {
            stack.Push(c);
        }
        else
        {
            if (stack.Count == 0) return false;
            
            char top = stack.Pop();
            if (c == ')' && top != '(') return false;
            if (c == '}' && top != '{') return false;
            if (c == ']' && top != '[') return false;
        }
    }
    
    return stack.Count == 0;
}

// Ishlatish
Console.WriteLine(IsValidParentheses("()"));      // true
Console.WriteLine(IsValidParentheses("()[]{}"));  // true
Console.WriteLine(IsValidParentheses("(]"));      // false

Queue (Navbat)

Enqueue: O(1) Dequeue: O(1) Peek: O(1)

Tavsif

Queue - bu FIFO (First In First Out) prinsipi asosida ishlaydigan tuzilma. Birinchi qo'shilgan element birinchi bo'lib chiqariladi. Xuddi navbat kabi.

Asosiy operatsiyalar:

  • Enqueue - oxiriga qo'shish
  • Dequeue - boshidan olish
  • Peek - birinchisini ko'rish
  • Count - elementlar soni

Qo'llanilishi:

  • Print queue (chop etish navbati)
  • Server so'rovlari
  • BFS algoritmi
  • Task scheduling

Interaktiv Demo

C# Kodi

// Queue yaratish
Queue<int> queue = new Queue<int>();

// Enqueue - oxiriga qo'shish - O(1)
queue.Enqueue(10);
queue.Enqueue(20);
queue.Enqueue(30);
// Queue: [10, 20, 30] (10 boshida)

// Peek - birinchisini ko'rish - O(1)
int first = queue.Peek();  // 10 (o'chirmasdan)

// Dequeue - birinchisini olish - O(1)
int removed = queue.Dequeue();  // 10
// Queue: [20, 30]

// Count - elementlar soni
int count = queue.Count;  // 2

// Contains - mavjudligini tekshirish
bool exists = queue.Contains(20);  // true

// Clear - barchasini o'chirish
queue.Clear();

// Massivga o'tkazish
int[] array = queue.ToArray();
// Print Queue (Chop etish navbati) misoli
public class PrintJob
{
    public string DocumentName { get; set; }
    public int Pages { get; set; }
    
    public PrintJob(string name, int pages)
    {
        DocumentName = name;
        Pages = pages;
    }
}

public class PrintQueue
{
    private Queue<PrintJob> queue = new Queue<PrintJob>();
    
    public void AddJob(PrintJob job)
    {
        queue.Enqueue(job);
        Console.WriteLine($"Qo'shildi: {job.DocumentName}");
    }
    
    public void ProcessNext()
    {
        if (queue.Count == 0)
        {
            Console.WriteLine("Navbat bo'sh");
            return;
        }
        
        PrintJob job = queue.Dequeue();
        Console.WriteLine($"Chop etilmoqda: {job.DocumentName} ({job.Pages} bet)");
    }
    
    public void ShowQueue()
    {
        Console.WriteLine($"Navbatda: {queue.Count} ta vazifa");
        foreach (var job in queue)
        {
            Console.WriteLine($"- {job.DocumentName}");
        }
    }
}

LinkedList (Bog'langan Ro'yxat)

Insert: O(1) Delete: O(1) Search: O(n) Access: O(n)

Tavsif

LinkedList - bu tugunlar (nodes) orqali bog'langan elementlar ketma-ketligi. Har bir tugun ma'lumot va keyingi tugunga ko'rsatkich (pointer) saqlaydi. Dinamik xotira boshqaruvi uchun qulay.

Xususiyatlari:

  • Dinamik o'lcham
  • Tez qo'shish/o'chirish
  • Xotira samaradorligi
  • Sekin qidirish
  • Ko'proq xotira (pointerlar)

Turlar:

  • Singly LinkedList - bir yo'nalish
  • Doubly LinkedList - ikki yo'nalish
  • Circular LinkedList - aylanma

Interaktiv Demo

C# Kodi

// LinkedList yaratish
LinkedList<int> linkedList = new LinkedList<int>();

// Boshiga qo'shish - O(1)
linkedList.AddFirst(10);
linkedList.AddFirst(5);
// List: 5 -> 10

// Oxiriga qo'shish - O(1)
linkedList.AddLast(20);
linkedList.AddLast(30);
// List: 5 -> 10 -> 20 -> 30

// Birinchi va oxirgiga kirish
int first = linkedList.First.Value;  // 5
int last = linkedList.Last.Value;    // 30

// Ma'lum elementdan keyin qo'shish
LinkedListNode<int> node = linkedList.Find(10);
if (node != null)
{
    linkedList.AddAfter(node, 15);
}

// Element o'chirish
linkedList.Remove(10);
linkedList.RemoveFirst();
linkedList.RemoveLast();

// Mavjudligini tekshirish
bool contains = linkedList.Contains(15);
// Singly LinkedList implementatsiyasi
public class Node
{
    public int Data { get; set; }
    public Node Next { get; set; }
    
    public Node(int data)
    {
        Data = data;
        Next = null;
    }
}

public class SinglyLinkedList
{
    private Node head;
    
    public void AddFirst(int data)
    {
        Node newNode = new Node(data);
        newNode.Next = head;
        head = newNode;
    }
    
    public void AddLast(int data)
    {
        Node newNode = new Node(data);
        
        if (head == null)
        {
            head = newNode;
            return;
        }
        
        Node current = head;
        while (current.Next != null)
        {
            current = current.Next;
        }
        current.Next = newNode;
    }
    
    public void Display()
    {
        Node current = head;
        while (current != null)
        {
            Console.Write(current.Data + " -> ");
            current = current.Next;
        }
        Console.WriteLine("null");
    }
}

Chiziqli Tuzilmalarni Taqqoslash

Tuzilma Access Search Insert Delete Xotira Qachon Ishlatish
Array O(1) O(n) O(n) O(n) Kam O'lcham ma'lum, tez kirish kerak
List O(1) O(n) O(1)* O(n) O'rta Dinamik o'lcham, universal
Stack N/A O(n) O(1) O(1) Kam LIFO kerak (undo, rekursiya)
Queue N/A O(n) O(1) O(1) Kam FIFO kerak (navbat, BFS)
LinkedList O(n) O(n) O(1) O(1) Ko'p Ko'p insert/delete operatsiyalari