Computer in Hindi | Business in Hindi: data structure in Hindi
Showing posts with label data structure in Hindi. Show all posts
Showing posts with label data structure in Hindi. Show all posts

Saturday, March 20, 2021

Trie data structure in Hindi - Data Structure in Hindi

March 20, 2021 0
Trie data structure in Hindi - Data Structure in Hindi

 विभिन्न प्रोग्रामिंग समस्याओं के लिए स्ट्रिंग्स को अनिवार्य रूप से सबसे महत्वपूर्ण और सामान्य विषयों के रूप में देखा जा सकता है। स्ट्रिंग प्रसंस्करण में कई वास्तविक दुनिया अनुप्रयोग होते हैं, जैसे:


  • Search Engines
  • Genome Analysis
  • Data Analytics

पाठ्य सामग्री के रूप में हमारे सामने प्रस्तुत सभी सामग्री को केवल  strings के अलावा और कुछ भी नहीं देखा जा सकता है।


trie data structure In Hindi

Tries एक अत्यंत विशेष और उपयोगी डेटा-संरचना है जो एक स्ट्रिंग के उपसर्ग पर आधारित हैं। उनका उपयोग डेटा के “Retrieval” का प्रतिनिधित्व करने के लिए किया जाता है और इस प्रकार Trie नाम।


prefix trie : What is prefix:

एक स्ट्रिंग का उपसर्ग कुछ भी नहीं है लेकिन (n, n<=mod(S)) किसी भी अक्षर को एक स्ट्रिंग की शुरुआत से सख्ती से शुरुआत माना जा सकता है। उदाहरण के लिए, शब्द “abacaba” में निम्नलिखित उपसर्ग हैं:


a
ab
aba
abac
abaca
abacab


Trie एक विशेष Data structure है जिसका उपयोग स्ट्रिंग्स को स्टोर करने के लिए किया जाता है जिसे ग्राफ की तरह देखा जा सकता है। यह नोड्स और किनारों के होते हैं। प्रत्येक नोड में अधिकतम 26 बच्चे होते हैं और प्रत्येक माता-पिता नोड को अपने बच्चों से जोड़ते हैं। ये 26 पॉइंटर्स अंग्रेजी वर्णमाला के 26 अक्षरों में से प्रत्येक के लिए पॉइंटर्स के अलावा और कुछ नहीं हैं। हर किनारे के लिए एक अलग एज बनाए रखा गया है।


एक trie data structure में उनके prefix के आधार पर स्ट्रिंग्स को ऊपर से नीचे तरीके से संग्रहीत किया जाता है। लंबाई 1 के सभी उपसर्गों को स्तर 1 तक संग्रहीत किया जाता है, लंबाई 2 के सभी prefixes को स्तर 2 और इसी तरह तक हल किया जाता है।


For example For trie data structure, consider the following diagram :- :

trie data structure
trie data structure



अब, कोई सोच रहा होगा कि एकल स्ट्रिंग को संसाधित करने के लिए डेटा संरचना जैसे ट्राई का उपयोग क्यों किया जाए? दरअसल, ट्राई का इस्तेमाल आम तौर पर स्ट्रिंग्स के समूहों पर किया जाता है, न कि एक स्ट्रिंग के बजाय। जब कई तार दिए जाते हैं, तो हम उनके आधार पर कई तरह की समस्याओं को हल कर सकते हैं। 

उदाहरण के लिए, एक अंग्रेजी शब्दकोश और एक स्ट्रिंग पर विचार करें, स्ट्रिंग से मेल खाते शब्दकोश स्ट्रिंग (s)से अधिकतम लंबाई का उपसर्ग खोजें। एक Naive approach का उपयोग करके इस समस्या को हल करने के लिए हमें दिए गए स्ट्रिंग के उपसर्ग को शब्दकोश में हर दूसरे शब्द के उपसर्ग के साथ मेल करना होगा और अधिकतम नोट करना होगा। यह एक  expensive प्रक्रिया है जिस पर समय लगेगा। trie in data structure इस समस्या को अधिक कुशल तरीके से हल कर सकती है।

प्रत्येक प्रकार की क्वेरी को संसाधित करने से पहले, जहां हमें सबसे लंबे उपसर्ग की लंबाई की खोज करने की आवश्यकता है, हमें पहले सभी मौजूदा शब्दों को शब्दकोश में जोड़ना होगा। एक trie में एक विशेष नोड होता है जिसे रूट नोड कहा जाता है। इस नोड में कोई आवक नहीं है। इसमें वर्णमाला के प्रत्येक अक्षर के लिए केवल 26 आउटगोइंग ईडीएफ शामिल हैं और यह ट्राइ का मूल है।


तो,  Trie में किसी भी स्ट्रिंग का insertion रूट नोड से शुरू होता है। लंबाई एक के सभी उपसर्ग रूट नोड के प्रत्यक्ष बच्चे हैं। इसके अलावा, लंबाई 2 के सभी उपसर्ग लेवल एक पर मौजूद नोड्स के बच्चे बन जाते हैं।


टायर में स्ट्रिंग डालने के लिए  pseudo code निम्नानुसार दिखेगा:

trie data structure
trie data structure

pseudo code की जाँच करने के लिए एक एकल शब्द शब्दों के शब्दकोश में मौजूद है या नहीं इस प्रकार है:







Monday, January 11, 2021

b tree in data structure in Hindi - Data structure In Hindi

January 11, 2021 0
b tree in data structure in Hindi - Data structure In Hindi

 इस ट्यूटोरियल में, आप सीखेंगे कि b tree in data structure क्या है। साथ ही, आपको C, C ++, Java और पायथन में B - Tree पर सर्च ऑपरेशन के काम के उदाहरण मिलेंगे।

b tree in data structure एक विशेष प्रकार का स्व-संतुलन खोज Tree है जिसमें प्रत्येक नोड में एक से अधिक कुंजी हो सकती हैं और दो से अधिक Child हो सकते हैं। यह b search tree का एक सामान्यीकृत रूप है।

इसे ऊंचाई वाले संतुलित m-way tree के रूप में भी जाना जाता है।



B tree in hindi
B tree in hindi

Why b tree in data structure?


हार्ड-डिस्क की तरह भौतिक भंडारण मीडिया तक पहुँचने में कम समय की आवश्यकता के बढ़ने के साथ
b tree की आवश्यकता उत्पन्न हुई। 

द्वितीयक भंडारण उपकरण एक बड़ी क्षमता के साथ धीमे हैं। इस तरह की डेटा संरचनाओं की आवश्यकता थी जो डिस्क एक्सेस को कम करती हैं।

अन्य डेटा संरचनाएं जैसे कि एक
b search tree, एवल ट्री, रेड-ब्लैक ट्री, आदि एक नोड में केवल एक कुंजी स्टोर कर सकते हैं। 

यदि आपको बड़ी संख्या में चाबियाँ जमा करनी हैं, तो ऐसे पेड़ों की ऊंचाई बहुत बड़ी हो जाती है और पहुंच का समय बढ़ जाता है।

हालांकि,
b tree एक ही नोड में कई चाबियाँ संग्रहीत कर सकते हैं और कई बच्चे नोड्स हो सकते हैं। यह तेजी से डिस्क एक्सेस की अनुमति देते हुए ऊंचाई को कम करता है।


B-tree in Hindi and it's Properties

  •     प्रत्येक नोड x के लिए, कुंजियाँ बढ़ते क्रम में संग्रहीत की जाती हैं।
  •     प्रत्येक नोड में, बूलियन मान x.leaf होता है जो x पत्ती होने पर सत्य होता है।
  •     यदि n पेड़ का क्रम है, तो प्रत्येक आंतरिक नोड में प्रत्येक बच्चे के लिए एक सूचक के साथ अधिकांश n - 1 कुंजी हो सकती हैं।
  •     रूट को छोड़कर प्रत्येक नोड में अधिकांश n बच्चे और कम से कम n / 2 बच्चे हो सकते हैं।
  •     सभी पत्तियों में एक ही गहराई (यानी पेड़ की ऊंचाई-एच) होती है।
  •     मूल में कम से कम 2 बच्चे हैं और इसमें न्यूनतम 1 कुंजी है।
  •     यदि n-1 है, तो ऊँचाई h और न्यूनतम डिग्री t, 2, h + logt (n + 1) / 2 के किसी भी n-key B- वृक्ष के लिए।

Operations b tree in data structure in Hindi

Learn Searching in B tree in Hindi

बी-ट्री में एक तत्व की खोज करना Binary Search Tree में एक तत्व की खोज का सामान्यीकृत रूप है। निम्न चरणों का पालन किया जाता है।

  •     रूट नोड से शुरू, नोड की पहली कुंजी के साथ तुलना करें।
  •     यदि k = the first key of the node, तो नोड और इंडेक्स वापस करें।
  •     यदि k.leaf = true है, तो NULL (यानी नहीं मिला) लौटें।
  •     यदि k < the first key of the root node, तो इस कुंजी के बाएं बच्चे को पुनरावर्ती खोजें।
  •     यदि वर्तमान नोड और k > the first key में एक से अधिक कुंजी है, तो नोड में अगली कुंजी के साथ तुलना करें।
  •     यदि k < next key तो इस कुंजी के बाएं बच्चे को खोजें (यानी। k पहली और दूसरी कुंजियों के बीच स्थित है)।
  •     और, कुंजी के सही बच्चे को खोजें।
  •     पत्ती तक पहुंचने तक चरण 1 से 4 दोहराएं।


Searching b tree example


  •     हमें डिग्री 3 के नीचे के Tree में k= 17 की खोज करनी चाहिए।
B-tree in hindi
B-tree in hindi

  • k रूट में नहीं मिला है, इसलिए इसे रूट की के साथ तुलना करें।

b tree insertion
b tree insertion
  • K> 11 के बाद से, रूट नोड के सही बच्चे पर जाएं।


b tree example
b tree example

 

  • K की तुलना 16 से करें। k> 16 के बाद से k की तुलना अगली कुंजी 18 से करें।

B tree in hindi
B tree in hindi

  • K <18 के बाद से, k 16 और 18 के बीच स्थित है। 16 के दाहिने बच्चे या 18 के बाएं बच्चे में खोजें।


b tree in data structure
b tree in data structure

  • k पाया जाता है।

b tree example
b tree example


Algorithm For B tree in Hindi

BtreeSearch(x, k)
 i = 1
 while i ≤ n[x] and k ≥ keyi[x]        // n[x] means number of keys in x node
    do i = i + 1
if i  n[x] and k = keyi[x]
    then return (x, i)
if leaf [x]
    then return NIL
else
    return BtreeSearch(ci[x], k)

B tree example program in c

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

#define MAX 3
#define MIN 2

struct BTreeNode {
  int val[MAX + 1], count;
  struct BTreeNode *link[MAX + 1];
};

struct BTreeNode *root;

// Create a node
struct BTreeNode *createNode(int val, struct BTreeNode *child) {
  struct BTreeNode *newNode;
  newNode = (struct BTreeNode *)malloc(sizeof(struct BTreeNode));
  newNode->val[1] = val;
  newNode->count = 1;
  newNode->link[0] = root;
  newNode->link[1] = child;
  return newNode;
}

// Insert node
void insertNode(int val, int pos, struct BTreeNode *node,
        struct BTreeNode *child) {
  int j = node->count;
  while (j > pos) {
    node->val[j + 1] = node->val[j];
    node->link[j + 1] = node->link[j];
    j--;
  }
  node->val[j + 1] = val;
  node->link[j + 1] = child;
  node->count++;
}

// Split node
void splitNode(int val, int *pval, int pos, struct BTreeNode *node,
         struct BTreeNode *child, struct BTreeNode **newNode) {
  int median, j;

  if (pos > MIN)
    median = MIN + 1;
  else
    median = MIN;

  *newNode = (struct BTreeNode *)malloc(sizeof(struct BTreeNode));
  j = median + 1;
  while (j <= MAX) {
    (*newNode)->val[j - median] = node->val[j];
    (*newNode)->link[j - median] = node->link[j];
    j++;
  }
  node->count = median;
  (*newNode)->count = MAX - median;

  if (pos <= MIN) {
    insertNode(val, pos, node, child);
  } else {
    insertNode(val, pos - median, *newNode, child);
  }
  *pval = node->val[node->count];
  (*newNode)->link[0] = node->link[node->count];
  node->count--;
}

// Set the value
int setValue(int val, int *pval,
           struct BTreeNode *node, struct BTreeNode **child) {
  int pos;
  if (!node) {
    *pval = val;
    *child = NULL;
    return 1;
  }

  if (val < node->val[1]) {
    pos = 0;
  } else {
    for (pos = node->count;
       (val < node->val[pos] && pos > 1); pos--)
      ;
    if (val == node->val[pos]) {
      printf("Duplicates are not permitted\n");
      return 0;
    }
  }
  if (setValue(val, pval, node->link[pos], child)) {
    if (node->count < MAX) {
      insertNode(*pval, pos, node, *child);
    } else {
      splitNode(*pval, pval, pos, node, *child, child);
      return 1;
    }
  }
  return 0;
}

// Insert the value
void insert(int val) {
  int flag, i;
  struct BTreeNode *child;

  flag = setValue(val, &i, root, &child);
  if (flag)
    root = createNode(i, child);
}

// Search node
void search(int val, int *pos, struct BTreeNode *myNode) {
  if (!myNode) {
    return;
  }

  if (val < myNode->val[1]) {
    *pos = 0;
  } else {
    for (*pos = myNode->count;
       (val < myNode->val[*pos] && *pos > 1); (*pos)--)
      ;
    if (val == myNode->val[*pos]) {
      printf("%d is found", val);
      return;
    }
  }
  search(val, pos, myNode->link[*pos]);

  return;
}

// Traverse then nodes
void traversal(struct BTreeNode *myNode) {
  int i;
  if (myNode) {
    for (i = 0; i < myNode->count; i++) {
      traversal(myNode->link[i]);
      printf("%d ", myNode->val[i + 1]);
    }
    traversal(myNode->link[i]);
  }
}

int main() {
  int val, ch;

  insert(8);
  insert(9);
  insert(10);
  insert(11);
  insert(15);
  insert(16);
  insert(17);
  insert(18);
  insert(20);
  insert(23);

  traversal(root);

  printf("\n");
  search(11, &ch, root);
}

b tree insertion Operation

  •      यदि पेड़ खाली है, तो रूट नोड आवंटित करें और कुंजी डालें।
  •      नोड में कुंजियों की अनुमत संख्या को अपडेट करें।
  •      सम्मिलन के लिए उपयुक्त नोड खोजें।
  •      यदि नोड भरा हुआ है, तो नीचे दिए गए चरणों का पालन करें।
  •      तत्वों को बढ़ते क्रम में डालें।
  •      अब, इसकी सीमा से अधिक तत्व हैं। तो, मंझला में विभाजित करें।
  •      माध्य कुंजी को ऊपर की ओर धकेलें और बाएँ कुंजियों को बाएँ बच्चे के रूप में और दाएँ कुंजियों को दाएँ बच्चे के रूप में बनाएँ।
  •      यदि नोड भरा नहीं है, तो नीचे दिए गए चरणों का पालन करें।
  •      बढ़ते क्रम में नोड डालें।

b tree insertion Example

आइए नीचे दिए गए चित्रों के साथ सम्मिलन ऑपरेशन को समझते हैं।

सम्मिलित किए जाने वाले तत्व 8, 9, 10, 11, 15, 16, 17, 18, 20, 23 हैं।

b tree example
b tree example

 b tree insertion Algorithm

 

BreeInsertion(T, k)
r  root[T]
if n[r] = 2t - 1
    s = AllocateNode()
    root[T] = s
    leaf[s] = FALSE
    n[s] <- 0
    c1[s] <- r
    BtreeSplitChild(s, 1, r)
    BtreeInsertNonFull(s, k)
else BtreeInsertNonFull(r, k)
BtreeInsertNonFull(x, k)
i = n[x]
if leaf[x]
    while i  1 and k < keyi[x]
        keyi+1 [x] = keyi[x]
        i = i - 1
    keyi+1[x] = k
    n[x] = n[x] + 1
else while i  1 and k < keyi[x]
        i = i - 1
    i = i + 1
    if n[ci[x]] == 2t - 1
        BtreeSplitChild(x, i, ci[x])
        if k &rt; keyi[x]
            i = i + 1
    BtreeInsertNonFull(ci[x], k)
BtreeSplitChild(x, i)
BtreeSplitChild(x, i, y)
z = AllocateNode()
leaf[z] = leaf[y]
n[z] = t - 1
for j = 1 to t - 1
    keyj[z] = keyj+t[y]
if not leaf [y]
    for j = 1 to t
        cj[z] = cj + t[y]
n[y] = t - 1
for j = n[x] + 1 to i + 1
    cj+1[x] = cj[x]
ci+1[x] = z
for j = n[x] to i
    keyj+1[x] = keyj[x]
keyi[x] = keyt[y]
n[x] = n[x] + 1



Sunday, January 10, 2021

binary search tree in Hindi with example

January 10, 2021 0
binary search tree in Hindi with example

 एक binary search tree (BST) एक पेड़ है जिसमें सभी नोड्स नीचे वर्णित गुणों का पालन करते हैं -

  •     बाएं sub-tree की कुंजी (Key) का मूल्य उसके parent (root) node's key के मूल्य से कम है।
  •     सही sub-tree की कुंजी का मूल्य उसके parent (रूट) नोड की कुंजी(Key) के मूल्य से अधिक या उसके बराबर है।


इस प्रकार,
binary search tree (BST) अपने सभी sub-tree को दो खंडों में विभाजित करता है; right sub-tree और left sub-tree और इसे इस प्रकार परिभाषित किया जा सकता है -

left_subtree (keys) < node (key) ≤ right_subtree (keys)

Representation binary search tree in data structure in Hindi


BST एक तरह से व्यवस्थित नोड्स का संग्रह है जहां वे BST properties को बनाए रखते हैं। 

प्रत्येक नोड में एक कुंजी (Key) और एक संबद्ध मूल्य (associated value) होता है। 

खोज करते समय, वांछित कुंजी की तुलना BST में कुंजियों से की जाती है और यदि पाया जाता है, तो संबंधित मान पुनः प्राप्त होता है।

निम्नलिखित BST का एक चित्रमय प्रतिनिधित्व है -



binary tree in data structure in hindi
binary tree in data structure

Basic Operations in Binary search tree in Hindi


एक पेड़ के बुनियादी संचालन निम्नलिखित हैं -

  •     Search −  एक Tree में एक तत्व खोजता है।
  •     Insert −  एक tree में एक तत्व सम्मिलित करता है।
  •     Pre-order Traversal - एक ट्री को प्री-ऑर्डर तरीके से ट्रेस करता है।
  •    In-order Traversal −  एक ट्री को इन-ऑर्डर तरीके से ट्रेस करता है।
  •    Post-order Traversal  - पोस्ट-ऑर्डर तरीके से एक पेड़ का पता लगाता है।


Node For binary search tree in Hindi


कुछ डेटा वाले नोड को परिभाषित करें, इसके बाएं और दाएं बच्चे के नोड्स के संदर्भ।


binary search tree in Hindi
Node For binary search tree in Hindi


Search Operation

जब भी कोई तत्व खोजना हो, तो रूट नोड से खोजना शुरू करें। फिर यदि डेटा कुंजी मूल्य से कम है, तो बाएं सबट्री में तत्व की खोज करें। अन्यथा, सही उपशीर्षक में तत्व की खोज करें। प्रत्येक नोड के लिए समान एल्गोरिथ्म का पालन करें।

Algorithm for binary search tree

struct node* search(int data){
   struct node *current = root;
   printf("Visiting elements: ");
	
   while(current->data != data){
	
      if(current != NULL) {
         printf("%d ",current->data);
			
         //go to left tree
         if(current->data > data){
            current = current->leftChild;
         }  //else go to right tree
         else {                
            current = current->rightChild;
         }
			
         //not found
         if(current == NULL){
            return NULL;
         }
      }			
   }
   
   return current;
}

Insert Operation

जब भी कोई तत्व सम्मिलित करना हो, तो पहले उसके उचित स्थान का पता लगाएं। रूट नोड से खोजना शुरू करें, फिर यदि डेटा कुंजी मूल्य से कम है, तो बाएं सबट्री में खाली स्थान खोजें और डेटा डालें। अन्यथा, सही सबट्री में खाली स्थान खोजें और डेटा डालें।

Insert Operation Algorithm For binary search tree

void insert(int data) {
   struct node *tempNode = (struct node*) malloc(sizeof(struct node));
   struct node *current;
   struct node *parent;

   tempNode->data = data;
   tempNode->leftChild = NULL;
   tempNode->rightChild = NULL;

   //if tree is empty
   if(root == NULL) {
      root = tempNode;
   } else {
      current = root;
      parent = NULL;

      while(1) {                
         parent = current;
			
         //go to left of the tree
         if(data < parent->data) {
            current = current->leftChild;                
            //insert to the left
				
            if(current == NULL) {
               parent->leftChild = tempNode;
               return;
            }
         }  //go to right of the tree
         else {
            current = current->rightChild;
            
            //insert to the right
            if(current == NULL) {
               parent->rightChild = tempNode;
               return;
            }
         }
      }            
   }
}   
हमने चर्चा कर ली है-

  •    binary search tree एक विशेष ट्री डेटा संरचना है।
  •     एक binary tree में, प्रत्येक नोड में अधिकतम 2 बच्चे हो सकते हैं।
  •     एक binary tree में, नोड्स को किसी भी यादृच्छिक क्रम में व्यवस्थित किया जा सकता है।


इस लेख में, हम बाइनरी सर्च ट्रीज़ के बारे में चर्चा करेंगे।

 

Binary Search Tree in Hindi-


बाइनरी सर्च ट्री (BST) में, प्रत्येक नोड में-

  •     इसके बाएं उप पेड़ में केवल छोटे मूल्य
  •     इसके दाहिने उप वृक्ष में केवल बड़े मूल्य हैं


 
Example-

binary search tree example
binary search tree


बाइनरी सर्च ट्री की संख्या-

Number of Binary Search Trees
Number of Binary Search Trees


Example binary search tree -

3 अलग-अलग कुंजी के साथ संभव बाइनरी सर्च ट्री की संख्या

= 2 × 3C3 / 3 + 1

= 6C3 / 4

= 5

बाइनरी सर्च ट्री कंस्ट्रक्शन-

Binary Search Tree in Hindi
Binary Search Tree Construction

 

आइए निम्नलिखित उदाहरण का उपयोग करके एक बाइनरी खोज ट्री के निर्माण को समझते हैं-

 
उदाहरण-

संख्याओं के निम्नलिखित अनुक्रम के लिए एक बाइनरी सर्च ट्री (BST) का निर्माण करें-

50, 70, 60, 20, 90, 10, 40, 100

जब तत्वों को एक अनुक्रम में दिया जाता है,

    हमेशा पहले तत्व को रूट नोड मानते हैं।
    दिए गए तत्वों पर विचार करें और उन्हें एक-एक करके BST में डालें।

 

नीचे बताए अनुसार बाइनरी सर्च ट्री का निर्माण किया जाएगा।

 
50 डालें-

binary search tree
Insert 50



 70 डालें-

 

Insert 70
Insert 70-


    70> 50 के रूप में, इसलिए 50 के दाईं ओर 70 डालें।

60 डालें-

    60> 50 के रूप में, इसलिए 60 को 50 के दाईं ओर डालें।
    60 <70 के रूप में, इसलिए 60 को 70 के बाईं ओर डालें।

Insert 60
Insert 60

 20 डालें-

 
Insert 20
Insert 20



    20 <50 के रूप में, इसलिए 50 के बाईं ओर 20 डालें।

90- डालें

 
Insert 90-
binary search tree Insert 90



    90> 50 के रूप में, इसलिए 90 को 50 के दाईं ओर डालें।
    90> 70 के रूप में, इसलिए 70 के दाईं ओर 90 डालें।

10 डालें-

 
Insert 10
Insert 10



    10 <50 के रूप में, इसलिए 10 को 50 के बाईं ओर डालें।
    10 <20 के रूप में, इसलिए 10 को 20 के बाईं ओर डालें।

40- डालें

 
Insert 40 in binary search tree
Insert 40



    40 <50 के रूप में, इसलिए 40 को 50 के बाईं ओर डालें।
    40> 20 के रूप में, इसलिए 40 को 20 के दाईं ओर डालें।

100 डालें-

 
Insert 100
Insert 100 in binary search tree



    100> 50 के रूप में, इसलिए 50 के दाईं ओर 100 डालें।
    100> 70 के रूप में, इसलिए 70 के दाईं ओर 100 डालें।
    100> 90 के रूप में, इसलिए 90 के दाईं ओर 100 डालें।




Sunday, September 27, 2020

Data structure in Hindi | classification of data structure in Hindi

September 27, 2020 0
Data structure in Hindi | classification of data structure in Hindi

what is data structure in hindi



data structure को डेटा तत्वों के समूह के रूप में परिभाषित किया जा सकता है जो कंप्यूटर में डेटा को संग्रहीत और व्यवस्थित करने का एक कुशल तरीका प्रदान करता है ताकि इसे कुशलता से उपयोग किया जा सके। डेटा स्ट्रक्चर्स के कुछ उदाहरण एरेज़, लिंक्ड लिस्ट, स्टैक, क्यू इत्यादि हैं। डेटा स्ट्रक्चर्स का इस्तेमाल कंप्यूटर साइंस के लगभग हर पहलू यानी ऑपरेटिंग सिस्टम, कंपाइलर डिज़ाइन, आर्टिफ़िशियल इंटेलिजेंस, ग्राफिक्स और बहुत कुछ में व्यापक रूप से किया जाता है।



data structure in hindi
data structure in hindi

data structure in Hindi कई कंप्यूटर विज्ञान एल्गोरिदम का मुख्य हिस्सा हैं क्योंकि वे प्रोग्रामर को कुशल तरीके से डेटा को संभालने में सक्षम बनाते हैं। यह सॉफ्टवेयर या प्रोग्राम के प्रदर्शन को बढ़ाने में एक महत्वपूर्ण भूमिका निभाता है क्योंकि सॉफ्टवेयर का मुख्य कार्य उपयोगकर्ता के डेटा को यथासंभव तेजी से संग्रहित करना और प्राप्त करना है।


Basic Terminology in data structure In Hindi


data structure किसी भी प्रोग्राम या सॉफ़्टवेयर के बिल्डिंग ब्लॉक हैं। एक प्रोग्रामर के लिए उपयुक्त डेटा संरचना चुनना एक प्रोग्रामर के लिए सबसे मुश्किल काम है। जहाँ तक डेटा संरचनाओं का संबंध है, शब्दावली का उपयोग किया जाता है

Data: डेटा को एक प्राथमिक मूल्य या मूल्यों के संग्रह के रूप में परिभाषित किया जा सकता है, उदाहरण के लिए, छात्र का नाम और उसकी आईडी छात्र के बारे में डेटा है।

Group Items: जिन डेटा आइटमों के अधीनस्थ डेटा आइटम होते हैं, उन्हें समूह आइटम कहा जाता है, उदाहरण के लिए, किसी छात्र के नाम में पहला नाम और अंतिम नाम हो सकता है।

Record: रिकॉर्ड को विभिन्न डेटा आइटमों के संग्रह के रूप में परिभाषित किया जा सकता है, उदाहरण के लिए, अगर हम छात्र इकाई के बारे में बात करते हैं, तो छात्र का रिकॉर्ड बनाने के लिए उसका नाम, पता, पाठ्यक्रम और अंक एक साथ रखा जा सकता है।

File: एक फ़ाइल एक प्रकार की इकाई के विभिन्न रिकॉर्ड का एक संग्रह है, उदाहरण के लिए, यदि कक्षा में 60 कर्मचारी हैं, तो संबंधित फ़ाइल में 20 रिकॉर्ड होंगे जहां प्रत्येक रिकॉर्ड में प्रत्येक कर्मचारी के बारे में डेटा होता है।

Attribute and Entity: एक इकाई कुछ वस्तुओं के वर्ग का प्रतिनिधित्व करती है। इसमें विभिन्न विशेषताएं हैं। प्रत्येक विशेषता उस इकाई की विशेष संपत्ति का प्रतिनिधित्व करती है।

Field: फ़ील्ड एक इकाई की विशेषता का प्रतिनिधित्व करने वाली जानकारी की एक एकल प्राथमिक इकाई है।


Need of Data Structures In Hindi


जैसे-जैसे एप्लिकेशन जटिल होते जा रहे हैं और डेटा की मात्रा दिन-ब-दिन बढ़ती जा रही है, निम्नलिखित समस्याएं हो सकती हैं:

Processor speed: डेटा की बहुत बड़ी मात्रा को संभालने के लिए, उच्च गति प्रसंस्करण की आवश्यकता होती है, लेकिन जैसा कि डेटा प्रति दिन अरबों फाइलों में बढ़ रहा है, प्रोसेसर डेटा की उस मात्रा से निपटने में विफल हो सकता है।


Data Search: किसी स्टोर में 106 आइटमों की एक सूची आकार पर विचार करें, यदि हमारे एप्लिकेशन को किसी विशेष आइटम की खोज करने की आवश्यकता है, तो उसे हर बार 106 आइटमों को पीछे करने की आवश्यकता होती है, जिसके परिणामस्वरूप खोज प्रक्रिया धीमा हो जाती है।

Multiple requests: यदि हजारों उपयोगकर्ता वेब सर्वर पर एक साथ डेटा खोज रहे हैं, तो ऐसी संभावना है कि इस प्रक्रिया के दौरान एक बहुत बड़ा सर्वर हो सकता है

उपरोक्त समस्याओं को हल करने के लिए, डेटा संरचनाओं का उपयोग किया जाता है। डेटा को इस तरह से डेटा संरचना बनाने के लिए व्यवस्थित किया जाता है कि सभी वस्तुओं को खोजे जाने की आवश्यकता नहीं होती है और आवश्यक डेटा को तुरंत खोजा जा सकता है।



Advantages of Data Structures in Hindi


Efficiency: एक कार्यक्रम की दक्षता Data Structures की पसंद पर निर्भर करती है। उदाहरण के लिए: मान लीजिए, हमारे पास कुछ डेटा है और हमें एक पर्टिकुलर रिकॉर्ड की खोज करने की आवश्यकता है। उस स्थिति में, यदि हम अपने डेटा को किसी सरणी में व्यवस्थित करते हैं, तो हमें तत्व द्वारा क्रमिक रूप से खोज करना होगा। इसलिए, सरणी का उपयोग करना यहां बहुत कुशल नहीं हो सकता है। बेहतर data structure हैं जो खोज की प्रक्रिया को क्रमबद्ध सरणी, बाइनरी सर्च ट्री या हैश टेबल जैसे कुशल बना सकती हैं।

Reusability: data structure पुन: प्रयोज्य हैं, अर्थात् एक बार जब हमने किसी विशेष डेटा संरचना को लागू किया है, तो हम इसे किसी अन्य स्थान पर उपयोग कर सकते हैं। डेटा संरचनाओं के कार्यान्वयन को पुस्तकालयों में संकलित किया जा सकता है जो विभिन्न ग्राहकों द्वारा उपयोग किया जा सकता है।

Abstraction:
data structure ADT द्वारा निर्दिष्ट की जाती है जो अमूर्त स्तर प्रदान करता है। ग्राहक कार्यक्रम कार्यान्वयन विवरण में शामिल किए बिना, केवल इंटरफ़ेस के माध्यम से data structure का उपयोग करता है।

Classification For Data Structure in Hindi


Linear Data Structures in Hindi: एक Data Structures को रैखिक कहा जाता है यदि इसके सभी तत्व रैखिक क्रम में व्यवस्थित होते हैं। रैखिक डेटा संरचनाओं में, तत्वों को गैर-श्रेणीबद्ध तरीके से संग्रहीत किया जाता है जहां प्रत्येक तत्व में पहले और अंतिम तत्व को छोड़कर उत्तराधिकारी और पूर्ववर्ती होते हैं।

रैखिक डेटा संरचना के प्रकार नीचे दिए गए हैं:


Arrays: एक सरणी समान प्रकार के डेटा आइटम का एक संग्रह है और प्रत्येक डेटा आइटम को सरणी का एक तत्व कहा जाता है। तत्व का डेटा प्रकार किसी भी मान्य डेटा प्रकार जैसे चार, इंट, फ्लोट या डबल हो सकता है।

सरणी के तत्व समान चर नाम साझा करते हैं, लेकिन हर एक सबस्क्रिप्ट के रूप में जाना जाता है एक अलग सूचकांक संख्या वहन करती है। सरणी एक आयामी, दो आयामी या बहुआयामी हो सकती है।

सरणी आयु के अलग-अलग तत्व हैं:

age[0], age[1], age[2], age[3]........

Linked List in Hindi: लिंक्ड सूची एक रैखिक डेटा संरचना है जिसका उपयोग मेमोरी में एक सूची को बनाए रखने के लिए किया जाता है। इसे गैर-सन्निहित स्मृति स्थानों पर संग्रहीत नोड्स के संग्रह के रूप में देखा जा सकता है। सूची के प्रत्येक नोड में इसके आसन्न नोड के लिए एक पॉइंटर होता है।

Stack: स्टैक एक रैखिक सूची है जिसमें प्रविष्टि और विलोपन केवल एक छोर पर करने की अनुमति है, जिसे शीर्ष कहा जाता है।

स्टैक एक अमूर्त डेटा प्रकार (ADT) है, जिसे अधिकांश प्रोग्रामिंग भाषाओं में लागू किया जा सकता है। इसे स्टैक के रूप में नामित किया गया है क्योंकि यह एक वास्तविक दुनिया स्टैक की तरह व्यवहार करता है,

 उदाहरण के लिए: - प्लेटों के ढेर या कार्ड के डेक आदि।

Queue:  कतार एक रेखीय सूची है जिसमें तत्वों को केवल एक छोर पर डाला जा सकता है जिसे रियर कहा जाता है और केवल दूसरे छोर पर हटा दिया जाता है जिसे फ्रंट कहा जाता है।

यह स्टैक के समान एक अमूर्त डेटा संरचना है। कतार दोनों छोर पर खोली जाती है इसलिए यह डेटा आइटम संग्रहीत करने के लिए प्रथम-प्रथम-प्रथम-आउट (FIFO) पद्धति का अनुसरण करती है।


Non Linear Data Structures: यह डेटा संरचना एक अनुक्रम नहीं बनाती है अर्थात् प्रत्येक आइटम या तत्व एक गैर-रेखीय व्यवस्था में दो या अधिक अन्य वस्तुओं के साथ जुड़ा हुआ है। डेटा तत्वों को क्रमिक संरचना में व्यवस्थित नहीं किया जाता है।

Non Linear Data Structures के प्रकार नीचे दिए गए हैं:

Trees: पेड़ों को बहुस्तरीय डेटा संरचना होती है, जिसमें इसके तत्वों के बीच पदानुक्रमित संबंध होते हैं जिन्हें नोड्स कहा जाता है। हियरशियो में बॉटलमॉस्ट नोड्स को लीफ नोड कहा जाता है जबकि सबसे ऊपरी नोड को रूट नोड कहा जाता है। प्रत्येक नोड में समीपवर्ती नोड्स को इंगित करने के लिए पॉइंटर्स होते हैं।

ट्री डेटा संरचना नोड्स के बीच parent-child relationship पर आधारित है। पेड़ में प्रत्येक नोड में पत्ती नोड्स को छोड़कर एक से अधिक बच्चे हो सकते हैं, जबकि प्रत्येक नोड में मूल नोड को छोड़कर एक से अधिक माता-पिता हो सकते हैं। पेड़ों को कई श्रेणियों में वर्गीकृत किया जा सकता है जिन पर बाद में इस ट्यूटोरियल में चर्चा की जाएगी।


Graphs: रेखांकन को किनारों के रूप में ज्ञात लिंक द्वारा जुड़े तत्वों के समुच्चय का चित्रण (वर्टिकल द्वारा दर्शाया गया) के रूप में परिभाषित किया जा सकता है। एक ग्राफ इस मायने में पेड़ से अलग है कि एक ग्राफ में चक्र हो सकता है जबकि पेड़ में एक नहीं हो सकता।

Operations on data structure in Hindi

1) Traversing: प्रत्येक डेटा संरचना में डेटा तत्वों का सेट होता है। खोज या छँटाई जैसे कुछ विशिष्ट ऑपरेशन करने के लिए डेटा संरचना के प्रत्येक तत्व का पता लगाने के लिए डेटा संरचना का पता लगाना है।

उदाहरण: यदि हमें किसी छात्र द्वारा 6 अलग-अलग विषयों में प्राप्त अंकों की औसत गणना करने की आवश्यकता है, तो हमें अंकों की पूरी सरणी को पार करने और कुल योग की गणना करने की आवश्यकता है, तो हम उस योग को विषयों की संख्या 6, 6 से विभाजित करेंगे। औसत खोजने के लिए।

2)
Insertion: सम्मिलन को किसी भी स्थान पर डेटा संरचना में तत्वों को जोड़ने की प्रक्रिया के रूप में परिभाषित किया जा सकता है।

यदि डेटा संरचना का आकार n है, तो हम केवल इसमें n-1 डेटा तत्व सम्मिलित कर सकते हैं।

3)
Deletion: डेटा संरचना से एक तत्व को हटाने की प्रक्रिया को डीलेटियन कहा जाता है। हम किसी भी यादृच्छिक स्थान पर डेटा संरचना से एक तत्व को हटा सकते हैं।

यदि हम किसी तत्व को खाली डेटा संरचना से हटाने की कोशिश करते हैं तो अंडरफ्लो होता है।

4)
Searching: डेटा संरचना के भीतर एक तत्व के स्थान को खोजने की प्रक्रिया को खोज कहा जाता है। खोज करने के लिए दो एल्गोरिदम हैं, रैखिक खोज और बाइनरी सर्च। हम इस ट्यूटोरियल में बाद में उनमें से प्रत्येक पर चर्चा करेंगे।

5)
Sorting: डेटा संरचना को एक विशिष्ट क्रम में व्यवस्थित करने की प्रक्रिया को सॉर्टिंग के रूप में जाना जाता है। कई एल्गोरिदम हैं जिनका उपयोग छँटाई करने के लिए किया जा सकता है, उदाहरण के लिए, सम्मिलन प्रकार, चयन प्रकार, बुलबुला प्रकार, आदि।

6)
Merging: जब दो सूचियाँ क्रमश: M और N के आकार A और सूची B की सूची बनाती हैं, समान प्रकार के तत्वों में, तीसरी सूची का निर्माण करने के लिए मिलाया जाता है या आकार की सूची C (M + N) का निर्माण किया जाता है, तो इस प्रक्रिया को विलय कहा जाता है

List Of Topic In data structure in Hindi

Array in data structure

Types Of data structure in Hindi

difference between array and link list in Hindi

Types of Queue in Hindi

binary trees in data structure in Hindi

linked list in Hindi
 

Tuesday, September 8, 2020

binary trees in data structure in Hindi

September 08, 2020 0
binary trees in data structure in Hindi
एक binary tree data structure in hindi एक non-linear data structure है, जो linear data structures जैसे arrays, linked lists, stacks और queues के विपरीत है।

एक
binary tree एक tree data structure है जिसमें प्रत्येक नोड में दो child nodes तक होते हैं जो पेड़ की शाखाएं बनाते हैं। दो childs को आमतौर पर बाएं और दाएं नोड के रूप में संदर्भित किया जाता है। Parent nodes children के साथ नोड्स हैं, जबकि चाइल्ड नोड्स में उनके Parent के संदर्भ हो सकते हैं।  

Tree के सबसे ऊपरी नोड को रूट नोड कहा जाता है, रूट के बाईं ओर नोड लेफ्ट नोड होता है जो लेफ्ट sub-tree के लिए रूट के रूप में कार्य कर सकता है और रूट के दाईं ओर नोड राइट नोड होता है जो सही sub-tree के लिए जड़ के रूप में सेवा कर सकता है।

 

binary tree data structure in hindi
binary tree data structure in hindi

Why Use binary trees in data structure in Hindi?

  •     Binary trees का उपयोग एक पदानुक्रमित क्रम (hierarchical order) में डेटा को स्टोर करने के लिए किया जा सकता है।
  •    arrays and linked lists की तुलना में Tress में Insertion and deletion operation तेज है।
  •     किसी भी संख्या में नोड्स को एक binary tree का उपयोग करके संग्रहीत किया जा सकता है।
  •     Array की तुलना में Linked List और Slower होने पर Trees में Accessing elements तेजी से बढ़ते हैं।


Types of binary trees In Hindi


Binary trees को निम्नानुसार वर्गीकृत किया जा सकता है
  •     Complete binary tree: संभवत: अंतिम स्तर को छोड़कर सभी स्तर पूरी तरह से भरे हुए हैं और अंतिम स्तर के नोड्स को यथासंभव छोड़ दिया गया है।
  •     Full binary tree: binary tree के सभी नोड्स 0 या 2 बच्चों के पास होते हैं।
Types of binary trees In Hindi
Types of binary trees In Hindi
    Perfect binary tree: यह एक Full binary tree है जिसमें सभी नोड्स में लीफ नोड्स के अलावा दो बच्चे होते हैं

 

Applications of binary trees in Hindi

binary trees के आवेदन निम्नलिखित हैं:


Binary Search Tree - कई खोज अनुप्रयोगों में उपयोग किया जाता है जो डेटा, जैसे डेटा को लगातार दिखाता और छिपाता है। उदाहरण के लिए, कसे कई पुस्तकालयों में वस्तुओं को मैप और सेट करें।

Binary Space Partition - यह निर्धारित करने के लिए लगभग किसी भी 3 डी वीडियो गेम में उपयोग किया जाता है कि किन वस्तुओं को प्रदान किया जाना है।

Binary Tries - राउटर टेबल को स्टोर करने के लिए लगभग हर हाई-बैंडविड्थ राउटर में उपयोग किया जाता है।

Syntax Tree - संकलक द्वारा निर्मित और (निहित) भावों को पार्स करने के लिए।

Hash Trees - पी 2 पी कार्यक्रमों और विशेष छवि हस्ताक्षरों में उपयोग किया जाता है, जिसके लिए एक हैश को मान्य करने की आवश्यकता होती है, लेकिन पूरी फ़ाइल उपलब्ध नहीं है।

Heaps - कुशल प्राथमिकता कतारों को लागू करने के लिए उपयोग किया जाता है और ढेर सॉर्ट में भी उपयोग किया जाता है।

Treap - वायरलेस नेटवर्क और मेमोरी आवंटन के लिए यादृच्छिक डेटा संरचना।
T-Tree - हालांकि अधिकांश डेटाबेस ड्राइव पर डेटा को स्टोर करने के लिए बी-ट्री के एक रूप का उपयोग करते हैं, जो डेटाबेस सभी (अधिकांश) डेटा को स्टोर करते हैं वे अक्सर T-Tree का उपयोग करते हैं।

Huffman Coding Tree:- संपीड़न एल्गोरिदम में प्रयुक्त, जैसे। उदाहरण के लिए, .jpeg और .mp3.GGM ट्री फ़ाइल प्रारूप - pseudo-random numbers वाले वृक्ष को उत्पन्न करने के लिए cryptographic applications में उपयोग किए जाते हैं।

Friday, September 4, 2020

Types of data structure in hindi (Linear Data Structure in Hindi,Non-Linear Data Structure)

September 04, 2020 0
Types of data structure in hindi (Linear Data Structure in Hindi,Non-Linear Data Structure)

types of data structure in Hindi

data structure memory में डेटा को व्यवस्थित करने का एक विशेष तरीका है। data structure का मुख्य उद्देश्य  group similar/related items वस्तुओं को एक साथ समूहित करना और उन्हें बंडल करना है, जिससे कार्यक्रम को निष्पादित करना आसान और कुशल हो जाता है। अब हम विभिन्न प्रकार की data structures को देखते हैं।

types of data structure in hindi
types of data structure in hindi


 

data structure को दो श्रेणियों में वर्गीकृत किया गया है।
  •     Linear Data Structure in Hindi
  •     Non-Linear Data Structure in Hindi

Different Linear Data Structures Vs Non-Linear
 Data Structures



अब हम difference between Linear and Non-Linear data structures को देखते हैं।


Data को एक रैखिक फैशन में व्यवस्थित किया जाता है जिसमें तत्व एक के बाद एक जुड़े होते हैं। non-linear data structures में डेटा तत्व पदानुक्रम से संबंधित हैं। सभी डेटा तत्वों को एक बार में पता लगाया जा सकता है, लेकिन एक समय में केवल एक तत्व सीधे पहुंच में आता है। सभी डेटा तत्वों को एक बार में पता नहीं लगाया जा सकता क्योंकि नोड्स क्रमिक रूप से नहीं जाते हैं। linear data structures स्मृति को बेकार कर देती है। स्मृति का कुशल उपयोग। रैखिक डेटा संरचनाओं को लागू करना आसान है। गैर-रैखिक डेटा संरचनाओं का कार्यान्वयन जटिल है। ऐरे, क्यू, स्टैक, लिंक्ड सूची linear data structures हैं। पेड़, ग्राफ non-linear data structures हैं।



अब हम इन Linear and Non-Linear data structures में से प्रत्येक की एक बुनियादी समझ प्राप्त करने का प्रयास करते हैं।

  •     Array समान डेटा प्रकार वाले डेटा आइटम का एक संग्रह है।
  •     एक Linked list नोड्स का एक संग्रह है, जहां प्रत्येक नोड में एक डेटा तत्व और अनुक्रम में अगले नोड का संदर्भ है।
  •     एक Stack एक FILO (First In Last Out) data structure जहां पहले जोड़ा गया तत्व अंतिम हटा दिया जाएगा।
  •     एक Queue एक FILO (First In Last Out) data structure है जहां जोड़ा गया तत्व पहले हटा दिया जाएगा।
  •     Tree नोड्स का एक संग्रह है जहां इन नोड्स को hierarchically रूप से व्यवस्थित किया जाता है और parent-child relationship के संबंध बनाते हैं।
  •     एक Graph एक कोने और किनारों की परिमित संख्या का एक संग्रह है। किनारों को कोने से जोड़ते हैं और इन कोने को जोड़ने वाले कोने के बीच संबंध का प्रतिनिधित्व करते हैं।

Saturday, May 9, 2020

bucket sort Algorithm In Hindi And Its Examples

May 09, 2020 0
bucket sort Algorithm In Hindi And Its Examples
This Chapter Will Help You To learn About bucket sort Algorithm In Hindi And Its Examples and Understand Its Programs and complexity.


bucket sort Algorithm In Hindi And Its Examples
bucket sort Algorithm In Hindi And Its Examples


bucket sort एक comparison sort algorithm है जो तत्वों को अलग-अलग बाल्टियों में विभाजित करके संचालित करता है और फिर इन बाल्टियों को व्यक्तिगत रूप से छांटता है। प्रत्येक बाल्टी को अलग-अलग छँटाई एल्गोरिथ्म का उपयोग करके या bucket sort Algorithm को recursively रूप से उपयोग करके व्यक्तिगत रूप से सॉर्ट किया जाता है। bucket sort मुख्य रूप से उपयोगी होता है जब इनपुट एक सीमा पर समान रूप से वितरित किया जाता है।

मान लें कि उनके सामने निम्नलिखित समस्या है:

एक को निचले और ऊपरी बाउंड के बीच समान रूप से झूठ बोलने वाले फ्लोटिंग पॉइंट पूर्णांक का एक बड़ा सरणी दिया गया है। इस सरणी को अब हल करने की आवश्यकता है। इस समस्या को हल करने का एक सरल तरीका यह होगा कि आप किसी अन्य सॉर्टिंग एल्गोरिथ्म जैसे मर्ज सॉर्ट, हीप सॉर्ट या क्विक सॉर्ट का उपयोग करें। हालांकि, ये algorithms O(N logN) की सबसे अच्छी स्थिति समय जटिलता की गारंटी देते हैं। हालांकि, bucket sort  का उपयोग करके, उपरोक्त कार्य को O(N) समय में पूरा किया जा सकता है। आइए इसे करीब से देखें।

सूची की एक सरणी बनाने के लिए एक पर विचार करें, यानी बाल्टी की। तत्वों को अब उनके गुणों के आधार पर इन बाल्टियों में डाला जाना चाहिए। इन बकेट्स में से प्रत्येक को इंसर्शन सॉर्ट का उपयोग करके व्यक्तिगत रूप से सॉर्ट किया जा सकता है। ऐसा करने के लिए छद्म कोड पर विचार करें:


void bucketSort(float[] a,int n)
{
    for(each floating integer 'x' in n)
    {
        insert x into bucket[n*x]; 
    }
    for(each bucket)
    {
        sort(bucket);
    }
}

Time Complexity in Bucket Sort

Time Complexity In Bucket Sort Algorithm Is O(n)

Bucket Sort Program In C/C++

// C++ program to sort an array using bucket sort
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
  
// Function to sort arr[] of size n using bucket sort
void bucketSort(float arr[], int n)
{
    // 1) Create n empty buckets
    vector<float> b[n];
     
    // 2) Put array elements in different buckets
    for (int i=0; i<n; i++)
    {
       int bi = n*arr[i]; // Index in bucket
       b[bi].push_back(arr[i]);
    }
  
    // 3) Sort individual buckets
    for (int i=0; i<n; i++)
       sort(b[i].begin(), b[i].end());
  
    // 4) Concatenate all buckets into arr[]
    int index = 0;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < b[i].size(); j++)
          arr[index++] = b[i][j];
}
  
/* Driver program to test above funtion */
int main()
{
    float arr[] = {0.897, 0.565, 0.656, 0.1234, 0.665, 0.3434};
    int n = sizeof(arr)/sizeof(arr[0]);
    bucketSort(arr, n);
  
    cout << "Sorted array is \n";
    for (int i=0; i<n; i++)
       cout << arr[i] << " ";
    return 0;
}

Bucket Sort Program In Python

# Python3 program to sort an array 
# using bucket sort 
def insertionSort(b):
    for i in range(1, len(b)):
        up = b[i]
        j = i - 1
        while j >=0 and b[j] > up: 
            b[j + 1] = b[j]
            j -= 1
        b[j + 1] = up     
    return b     
              
def bucketSort(x):
    arr = []
    slot_num = 10 # 10 means 10 slots, each
                  # slot's size is 0.1
    for i in range(slot_num):
        arr.append([])
          
    # Put array elements in different buckets 
    for j in x:
        index_b = int(slot_num * j) 
        arr[index_b].append(j)
      
    # Sort individual buckets 
    for i in range(slot_num):
        arr[i] = insertionSort(arr[i])
          
    # concatenate the result
    k = 0
    for i in range(slot_num):
        for j in range(len(arr[i])):
            x[k] = arr[i][j]
            k += 1
    return x
  
# Driver Code
x = [0.897, 0.565, 0.656,
     0.1234, 0.665, 0.3434
print("Sorted Array is")
print(bucketSort(x))


Also Learn: - Bubble Sort Algorithm And a sorting program in a different language