प्रौद्योगिकी साझेदारी

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

---

क्रमिकभण्डारणरेखीयसारणी एकः मूलभूतदत्तांशसंरचना अस्ति, या रेखीयसारणीयाः तत्त्वानि भण्डारण-एककानां समुच्चये क्रमिक-सङ्केतैः सह निश्चितक्रमेण संग्रहयति अस्मिन् ब्लोग् मध्ये वयं क्रमिकभण्डारणरेखीयसारणीयाः कार्यान्वयनस्य विस्तरेण परिचयं करिष्यामः, तथा च क्रमिकभण्डारणरेखीयसारणीं कथं कार्यान्वितुं शक्यते इति दर्शयितुं C, C# तथा C++ इत्येतयोः त्रीणि प्रोग्रामिंगभाषाः उदाहरणरूपेण गृह्णीमः

1. रेखीयसारणीनां क्रमिकभण्डारणस्य मूलभूतसंकल्पना

क्रमिकभण्डारणरेखीयसारणी रेखीयसारणीयाः कार्यान्वयनविधिः अस्ति, यस्याः निम्नलिखितलक्षणाः सन्ति ।

तत्त्वप्रकाराः समानाः सन्ति : क्रमिकभण्डारणरेखीयसारणीयां तत्त्वानि समानप्रकारस्य भवन्ति, प्रत्येकं तत्त्वं च निश्चितं भण्डारणस्थानं गृह्णाति
तत्त्वानि क्रमेण भवन्ति : क्रमिकभण्डारणरेखीयसूचौ तत्त्वानि एकेन क्रमेण व्यवस्थितानि भवन्ति, प्रायः अनिवृत्तक्रमेण ।
यादृच्छिकप्रवेशः : क्रमिकभण्डारणरेखीयसारणीः यादृच्छिकप्रवेशस्य समर्थनं कुर्वन्ति, अर्थात् सारणीयां कोऽपि तत्त्वः अनुक्रमणिकायाः ​​माध्यमेन प्रत्यक्षतया अभिगन्तुं शक्यते ।
गतिशीलविस्तारः : क्रमिकभण्डारणरेखीयसारणीः अधिकतत्त्वानां समायोजनाय आवश्यकतानुसारं गतिशीलरूपेण भण्डारणस्थानं विस्तारयितुं शक्नुवन्ति ।

2. क्रमिकभण्डारणरेखीयसारणीयाः कार्यान्वयनम्

1. दत्तांशसंरचना परिभाषा

प्रथमं रेखीयसारणीनां क्रमिकभण्डारणार्थं दत्तांशसंरचना परिभाषितव्या । C भाषां उदाहरणरूपेण गृहीत्वा, भवान् संरचनायाः (struct) उपयोगं कृत्वा परिभाषितुं शक्नोति:

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int *data; // 指向动态分配的数组
    int size;  // 线性表的当前长度
    int capacity; // 线性表的容量
} SequenceList;
1
2
3
4
5
6
7
8

2. आरम्भीकरणम्

रेखीयसारणी आरम्भक्रमे संगृहीता भवति, तस्मै प्रारम्भिकक्षमता आवंटिता भवति । C भाषायां वयं memory इत्यस्य गतिशीलरूपेण आवंटनार्थं malloc फंक्शन् इत्यस्य उपयोगं कर्तुं शक्नुमः :

void initSequenceList(SequenceList *list, int capacity) {
    list->data = (int *)malloc(capacity * sizeof(int));
    if (list->data == NULL) {
        exit(-1); // 内存分配失败，退出程序
    }
    list->size = 0;
    list->capacity = capacity;
}
1
2
3
4
5
6
7
8

3. तत्त्वानि योजयन्तु

क्रमेण संगृहीतरेखीयसूचौ तत्त्वानि योजयन्तु । यदि वर्तमानक्षमता नूतनानां तत्त्वानां समायोजनाय पर्याप्तं नास्ति तर्हि प्रथमं भवद्भिः क्षमतायाः विस्तारः करणीयः :

void appendSequenceList(SequenceList *list, int value) {
    if (list->size == list->capacity) {
        // 扩展容量
        int newCapacity = list->capacity * 2;
        int *newData = (int *)malloc(newCapacity * sizeof(int));
        if (newData == NULL) {
            exit(-1); // 内存分配失败，退出程序
        }
        for (int i = 0; i < list->size; i++) {
            newData[i] = list->data[i];
        }
        free(list->data);
        list->data = newData;
        list->capacity = newCapacity;
    }
    list->data[list->size++] = value;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

4. अभिगमतत्त्वानि

क्रमेण संगृहीतस्य रेखीयसूचौ निर्दिष्टतत्त्वानां अभिगमनं कुर्वन्तु:

int getSequenceList(const SequenceList *list, int index) {
    if (index < 0 || index >= list->size) {
        return -1; // 索引无效，返回-1
    }
    return list->data[index];
}
1
2
3
4
5
6

5. तत्त्वानि परिवर्तयन्तु

क्रमिकभण्डारणरेखीयसूचौ निर्दिष्टतत्त्वानि परिवर्तयन्तु:

void setSequenceList(SequenceList *list, int index, int value) {
    if (index < 0 || index >= list->size) {
        return; // 索引无效，不进行操作
    }
    list->data[index] = value;
}
1
2
3
4
5
6

6. तत्त्वानि विलोपयन्तु

क्रमेण संगृहीतरेखीयसूचौ निर्दिष्टानि तत्त्वानि विलोपयन्तु:

void removeSequenceList(SequenceList *list, int index) {
    if (index < 0 || index >= list->size) {
        return; // 索引无效，不进行操作
    }
    for (int i = index + 1; i < list->size; i++) {
        list->data[i - 1] = list->data[i];
    }
    list->size--;
}
1
2
3
4
5
6
7
8
9

7. नाशयतु

क्रमिकभण्डारणरेखीयसारणीं नष्टं कृत्वा आवंटितस्मृतिं मुक्तं कुर्वन्तु:

void destroySequenceList(SequenceList *list) {
    free(list->data);
    list->data = NULL;
    list->size = 0;
    list->capacity = 0;
}
1
2
3
4
5
6

3. उदाहरणम्

अधः वयं क्रमिकभण्डारणरेखीयसारणीं कार्यान्वितुं, रेखीयसारणीयां तत्त्वानि योजयितुं, विलोपयितुं, अभिगन्तुं, मुद्रयितुं च C, C# तथा C++ इति त्रीणि प्रोग्रामिंगभाषाः उपयुञ्ज्महे ।

ग भाषा उदाहरणम्

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int *data;
    int size;
    int capacity;
} SequenceList;

void initSequenceList(SequenceList *list, int capacity) {
    list->data = (int *)malloc(capacity * sizeof(int));
    if (list->data == NULL) {
        exit(-1);
    }
    list->size = 0;
    list->capacity = capacity;
}

void appendSequenceList(SequenceList *list, int value) {
    if (list->size == list->capacity) {
        int newCapacity = list->capacity * 2;
        int *newData = (int *)malloc(newCapacity * sizeof(int));
        if (newData == NULL) {
            exit(-1);
        }
        for (int i = 0; i < list->size; i++) {
            newData[i] = list->data[i];
        }
        free(list->data);
        list->data = newData;
        list->capacity = newCapacity;
    }
    list->data[list->size++] = value;
}

int getSequenceList(const SequenceList *list, int index) {
    if (index < 0 || index >= list->size) {
        return -1;
    }
    return list->data[index];
}

void setSequenceList(SequenceList *list, int index, int value) {
    if (index < 0 || index >= list->size) {
        return;
    }
    list->data[index] = value;
}

void removeSequenceList(SequenceList *list, int index) {
    if (index < 0 || index >= list->size) {
        return;
    }
    for (int i = index + 1; i < list->size; i++) {
        list->data[i - 1] = list->data[i];
    }
    list->size--;
}

void destroySequenceList(SequenceList *list) {
    free(list->data);
    list->data = NULL;
    list->size = 0;
    list->capacity = 0;
}

int main() {
    SequenceList list;
    initSequenceList(&list, 10);
    appendSequenceList(&list, 1);
    appendSequenceList(&list, 2);
    appendSequenceList(&list, 3);
    printf("Get element at index 1: %dn", getSequenceList(&list, 1));
    setSequenceList(&list, 1, 4);
    printf("Get element at index 1 after modification: %dn", getSequenceList(&list, 1));
    removeSequenceList(&list, 0);
    printf("Get element at index 0 after removal: %dn", getSequenceList(&list, 0));
    destroySequenceList(&list);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

C # भाषा उदाहरणम्

using System;

public class SequenceList
{
    private int[] data;
    private int size;
    private int capacity;

    public SequenceList(int capacity)
    {
        this.data = new int[capacity];
        this.size = 0;
        this.capacity = capacity;
    }

    public void Append(int value)
    {
        if (size == capacity)
        {
            int newCapacity = capacity * 2;
            int[] newData = new int[newCapacity];
            for (int i = 0; i < size; i++)
            {
                newData[i] = data[i];
            }
            data = newData;
            capacity = newCapacity;
        }
        data[size++] = value;
    }

    public int Get(int index)
    {
        if (index < 0 || index >= size)
        {
            return -1;
        }
        return data[index];
    }

    public void Set(int index, int value)
    {
        if (index < 0 || index >= size)
        {
            return;
        }
        data[index] = value;
    }

    public void RemoveAt(int index)
    {
        if (index < 0 || index >= size)
        {
            return;
        }
        for (int i = index + 1; i < size; i++)
        {
            data[i - 1] = data[i];
        }
        size--;
    }

    public void Clear()
    {
        size = 0;
    }
}

class Program
{
    static void Main(string[] args)
    {
        SequenceList list = new SequenceList(10);
        list.Append(1);
        list.Append(2);
        list.Append(3);
        Console.WriteLine("Get element at index 1: " + list.Get(1));
        list.Set(1, 4);
        Console.WriteLine("Get element at index 1 after modification: " + list.Get(1));
        list.RemoveAt(0);
        Console.WriteLine("Get element at index 0 after removal: " + list.Get(0));
        list.Clear();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

C++ भाषा उदाहरणम्

#include <iostream>

class SequenceList {
private:
    int *data;
    int size;
    int capacity;

public:
    SequenceList(int capacity) {
        data = new int[capacity];
        size = 0;
        capacity = capacity;
    }

    void Append(int value) {
        if (size == capacity) {
            int newCapacity = capacity * 2;
            int *newData = new int[newCapacity];
            for (int i = 0; i < size; i++) {
                newData[i] = data[i];
            }
            delete[] data;
            data = newData;
            capacity = newCapacity;
        }
        data[size++] = value;
    }

    int Get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }
        return data[index];
    }

    void Set(int index, int value) {
        if (index < 0 || index >= size) {
            return;
        }
        data[index] = value;
    }

    void RemoveAt(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
    }

    void Clear() {
        size = 0;
    }
};

int main() {
    SequenceList list(10);
    list.Append(1);
    list.Append(2);
    list.Append(3);
    std::cout << "Get element at index 1: " << list.Get(1) << std::endl;
    list.Set(1, 4);
    std::cout << "Get element at index 1 after modification: " << list.Get(1) << std::endl;
    list.RemoveAt(0);
    std::cout << "Get element at index 0 after removal: " << list.Get(0) << std::endl;
    list.Clear();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

एतेषु त्रयेषु उदाहरणेषु वयं क्रमिकभण्डारणरेखीयसूचीवर्गं परिभाषयामः तथा च तत्त्वानि योजयितुं, विलोपनं, अभिगमनं, मुद्रणं च इत्यादीनां मूलभूतक्रियाणां श्रृङ्खलां प्रदामः एतैः उदाहरणैः सह भवान् भिन्न-भिन्न-प्रोग्रामिंग-भाषासु क्रमिक-भण्डारण-रेखीय-सारणीः कथं कार्यान्वितुं शक्नोति इति ज्ञातुं शक्नोति ।