Information : Data Structure is means of storing a collection of data

A means of storing a collection of data. Computer science is in part the study of methods for effectively using a computer to solve problems, or in other words, determining exactly the problem to be solved. This process entails (1) gaining an understanding of the problem; (2) translating vague descriptions, goals, and contradictory requests, and often unstated desires, into a precisely formulated conceptual solution; and (3) implementing the solution with a computer program. This solution typically consists of two parts: algorithms and data structures.

Relation to algorithms

An algorithm is a concise specification of a method for solving a problem. A data structure can be viewed as consisting of a set of algorithms for performing operations on the data it stores. Thus algorithms are part of what constitutes a data structure. In constructing a solution to a problem, a data structure must be chosen that allows the data to be operated upon easily in the manner required by the algorithm.

Data may be arranged and managed at many levels, and the variability in algorithm design generally arises in the manner in which the data for the program are stored, that is (1) how data are arranged in relation to each other, (2) which data are calculated as needed, (3) which data are kept in memory, and (4) which data are kept in files, and the arrangement of the files. An algorithm may need to put new data into an existing collection of data, remove data from a collection, or query a collection of data for a specific purpose. See also Algorithm.

Abstract data types

Each data structure can be developed around the concept of an abstract data type that defines both data organization and data handling operations. Data abstraction is a tool that allows each data structure to be developed in relative isolation from the rest of the solution. The study of data structure is organized around a collection of abstract data types that includes lists, trees, sets, graphs, and dictionaries. See also Abstract data type.

Primitive and nonprimitive structures

Data can be structured at the most primitive level, where they are directly operated upon by machine-level instructions. At this level, data may be character or numeric, and numeric data may consist of integers or real numbers.

Nonprimitive data structures can be classified as arrays, lists, and files. An array is an ordered set which contains a fixed number of objects. No deletions or insertions are performed on arrays. At best, elements may be changed. A list, by contrast, is an ordered set consisting of a variable number of elements to which insertions and deletions can be made, and on which other operations can be performed. When a list displays the relationship of adjacency between elements, it is said to be linear; otherwise it is said to be nonlinear. A file is typically a large list that is stored in the external memory of a computer. Additionally, a file may be used as a repository for list items (records) that are accessed infrequently.

File structures

Not all information that is processed by a computer necessarily resides in immediately accessible memory because some programs and their data cannot fit into the main memory of the computer. Large volumes of data or records and archival data are commonly stored in external memory as entities called files. Any storage other than main memory may be loosely defined as external storage. This includes tapes, disks, and so forth. See also Computer storage technology.

Virtual memory

This is a system that provides an extension to main memory in a logical sense. In a virtual system, all currently active programs and data are allocated space or virtual addresses in virtual memory. The program and data may not in fact reside in main memory but in an external storage. References to virtual addresses are translated dynamically by the operating system into real addresses in main memory. See also Digital computer.

Contoh program array 2 dimensi

public class searching8 {

public static void main(String[] args){
String [][] mhs = // string dua dimensi ciri [][] ada dua array
{{"08310551", "Mary", "08566767676", "Tankywood"}, // data string yang sudah diisi
{"08310066", "Uthe", "089999998", "Bandungr"},
{"08310088", "Yuni", "021765659", "Jakarta"},
{"08310099", "Ferdian", "023435265", "Tenggarong"},
{"08310055", "Garin", "023455678", "Bandung"},

};

System.out.println("=============================="); // membuat garis
System.out.println("Program Searching Sederhana"); // menampilkan tulisan
System.out.println("1. Searching by NIM"); // menampilkan perintah seaching berdasarkan NIM
System.out.println("2. Searching by Nama"); // menampilkan perintah seaching berdasarkan Nama
System.out.println("3. Searching by No Telp"); // menampilkan perintah seaching berdasarkan Telp
System.out.println("4. Searching by Alamat"); // menampilkan perintah seaching berdasarkan Alamat
System.out.print("Masukkan pilihan : "); // menampilkan perintah untuk memasukan pilihan kita
String temp = BacaKeyboard.bacaString(); //temp untuk menampung nilai sementara
int pil = Integer.parseInt(temp); //mengubah nilai string di temp menjadi integer di pil
System.out.println("=============================="); // membuat tampilan garis
System.out.println(); // perintah untuk menampilkan hasil

String cari; // deklarasi Cari dengan tipe Data string
boolean ketemu = false; // deklarasi ketemu dengan tipe Data boolean jika ketemu maka menjadi false

System.out.print("Data yang ingin dicari: "); // menampilkan tulisan "Data yang ingin dicari"
cari = BacaKeyboard.bacaString(); // deklarasi Cari adalah menggunakan program Bacakeyboard
System.out.println("------------------------------"); // membuat tampilan garis
int i = 0; // deklarasi i = 0 adalah integer
do {
if(mhs[i][pil-1].equalsIgnoreCase(cari)) //proses searching
ketemu = true;
System.out.println("NIM\t: " + mhs[i][0]); //proses searching
System.out.println("Nama\t: " + mhs[i][1]); //proses searching
System.out.println("Telp\t: " + mhs[i][2]); //proses searching
System.out.println("Alamat\t: " + mhs[i][3]); //proses searching
System.out.println("------------------------------");
}
i++; // nilai i akan bertambah
}while(i if(!ketemu){ // if dengan kondisi"!ketemu" artinya tidak (!)True maka jadi false
System.out.println("Data Tidak Ditemukan"); // menampilkan tulisan "Data Tidak Ditemukan"
}
}
}
}

Array in Data Structure

Array is a data structure that consists of many variables with the same data type, in which each element has a value of index variable. Each array element is able to store one type of data. Array is a type of structured data in the form of some kind of data (same data type) that the amount fixed and given a specific name. Array can be 1-dimensional array, 2-dimensional, even n-dimensional. Array is a static data structure, namely the number of elements that must be determined in advance, can not change when the program running. To declare arrays in PASCAL we must first: Defining the number of array elements.
Array Dimension One Dimension One Defining arrays in general is as follows: array with the type / the same type that has only one index is just a line or column only.
MultidimensiArray multidimensional array consists of one-dimensional, two-dimensional, three dimensional and so on. The first index can be a second line and could be a third column and the contents or any other form.
Record
A tape record compiled by several fields. Each field contains data of basic type / specific formation. Record has the advantage to save a set of data elements of different type (in appeal array).

In Indonesia Language please klik :
Indonesia Language

Pointer In Data Structure

Pointer is a pointer variable which points to a specific computer memory address. Pointer is a low-level variables that can be used to denote integer values, character, float, double, or single, and even the data types other language supported by C. Ordinary variables, static in nature and certainly, while the pointer is dynamic in nature and can be more flexible. Pointer variable that does not point to any value that has a NULL value, and referred to as: Dangling pointer because its value is not in the initialization and can not be predicted. Pointer declaring variables using the sign (*) before the variable name, whereas to display the value pointed to by a pointer variable, also used the service (*) asterisk. If you want to show the address where the value of a variable by pointer, used the service (*) marks an ampersand. In an array of data types, Pointer variables need only point to his name only array variable without having to use an ampersand sign or point to a variable array at index zero is to it.

In Indonesia Language please klik :

Indonesia Language

 #Pointer  #Data Structure

Sort the Data Structure

Sort the data sorting process that previously arranged randomly, so be arranged on a regular basis according to a specific rule.
In general there are 2 types of Sort / sequencing:
. Ascending (Up)
. Descending (Decrease)

Data Ordering example:
. Random Data: 5 6 8 1 3 25 10
. Ascending Ascending: 1 3 5 6 8 10 25
. Ascending Descending: 25 10 8 6 5 3 1

Sort Method / Ordering Data
To make the ordering process can be used many different ways /
methods. Some methods include:
. Buble / Exchange Sort
. Selection Sort
. Insertion Sort
. Quick Sort

Bubble / Exchange Sort
) dari elemen berikutnya, maka tukar Proses Pengurutan Data paling akhir dibandingkan dengan data di depannya, jika ternyata lebih kecil maka tukar." onmouseover="this.style.backgroundColor='#ebeff9'" onmouseout="this.style.backgroundColor='#fff'">Moving elements are present with the following elements, if the element is now greater than (>) from the next element, then the exchange process at the end of Ordering Data compared to the data in front of him, if it is smaller then the exchange rate. And the same checks performed on data subsequent to the initial data.

Selection Sort
Comparing the current element with the next element until the last element. If you find another element that is smaller than the recorded elements position now and then exchanged. And so on.

Insertion Sort
Ordering is done by comparing the data to 1 (which starts from 1 to-2 data to final data) with the following data. If you found a smaller data so that data is inserted into the appropriate position should be.

Quick Sort
Comparing an element (called the pivot) with other elements and arranged them so that other elements are smaller than the pivot is located on the left and other elements are greater than the pivot is located on the right. And thus have formed two sublist, which is located on the left and right of pivot.Lalu the sublist left and right sublist we consider a new list and we do the same process as before. And so on until there is no longer sublist.
So that has occurred inside Recursive process.

In Indonesia Language please klik :
Indonesia Language

Linked List In Data Structures

Flat Chain or Linked List is one form of data structure, containing a collection of data (nodes) arranged in connection
connect, dynamic and limited.
Linked List are connected with the help of a pointer variable
Each data in Linked List called the node (node)
which occupies a dynamic memory allocation and usually in the form
struct that consists of several fields.
Linked List or Flat-chain can be illustrated as
one unit train.
The train consists of several cars, each of the car is called the formation of the data type (struct).
In order for these cars can be linked to each other is needed
at least a hook that is called as a pointer.
After declaring data types and pointers on the list, then we will try to make a list (linked list) is not a single spin or a car. There are some operations that we can make on the list, including: add, delete and edit of these cars.
The essence of Linked list is a process (add, edit, delete) from car / node and how to connect between the carriage / node is .....

moore....

Tree In Heap sort

In Heap Sort Tree
2.1 Definition of Heap
Is a data structure that meets the tree-shaped nature of the heap that is, if B is a child of A, then the value stored at node A is greater than or equal to the value stored at node B. This causes the element with the largest value is always located at the root position, and the heap is called a max heap. (If the comparison is diterbalikkan smallest element always at the root node, the heap is called the min heap). Therefore, the heap used to implement queue prioriti. Operations that are used for the heap are:
• Delete-delete-max or min: remove the root node of a max or min heap.
• Increase or decrease-key-key: change the value stored in a node.
• Insert: add a value into the heap.
• Merge: merge two heap to form a new heap which contains all the elements forming the heap.

Graf In Data Structures

Graf is used to represent discrete objects
and the relationship between these objects.

Graf Types
Based on the presence or absence of a bracelet or double side on a graph,
then the graph is classified into two types:

1. Simple graph (simple graph).
Graph does not contain a bracelet and double-side is called
simple graph.

2. Graf-no simple (unsimple-graph).
Graph which contains the so-called dual or bracelet graph
not-simple (unsimple graph).

• Based on the number of nodes in a graph, then the general graph
can be classified into two types:

1. Graf finite (limited graph)
is a graph of the number of the knot, n, finite.

2. Graf an infinite (unlimited graph)
Graph of the number of the knot, n, no finite number of
called an infinite graph.

• Based on the orientation direction, the general graph in
distinguish the 2 types:

1. Non-directional graph (undirected graph)
Graph which side do not have direction orientation is called graph
non-directional.

2. Directed graph (directed graph or digraph)
Graph that each side is given the orientation direction is called a
as a directional graph.

Example
Graf in its application:
Electrical circuits, chemical compounds of carbon Isomers etc..

moore....

Tree In Data Structure

In Data Structures, Tree is one of the data structure
shaped like a tree, which consists of attack
series node (node) of each node is berhubungan.Node-in
vektor.Setiap connect by a node can have 0 or
more child nodes (child). A node that has a child node in -
call the parent node (parent). A child node has only one
parent node. By convention computer science, Tree growing
down, not like in the real world tree that grows up.
Thus the child node will be described under the node
induknya.Node in the base of the tree is called the root node (the root),
while the node is located at the tip of tree pyramid is called
leaf node (leaf).

Binary Tree (Binary Tree)
In the course of data structures, will be specifically studied
finger on the binary tree. Binary tree is a tree that
each knot can only have a maximum of 2 (two)
No child node lebih.Pada binary tree, generally two
child node is called the position, the left and right.
Some terms in the binary tree:
- Size (size): the total number of existing nodes in binary tree.
- Depth (depth): the long path that connects a
node to node until the very end of her child (leaf).
Depth is often called height.Full Binary Tree (Full Binary Tree)
is a binary tree each nodenya has 0 or 2 child nodes.

Perfect Binary Tree
(Binary Tree Perfect) is a binary tree of all nodes leafnya
is at a depth of samadari root node. Also called
as a Complete Binary Tree (Complete Binary Tree)

Almost Complete Binary Tree
(Almost Complete Binary Tree) is a binary tree of each
0 node nodenyadapat have children, or have left, or if
has a right to have kiri.Tidak should have the right course.
Implementation of programming, in this subject will be in
discussed for binary trees only. Initial assumption is that the data
to be inserted in the node, an integer data type.

Stack the Data Structure

Stack or stack is a data structure that seems to look like the data that is composed of 'stacking', where there is data that is located above the other data.
Stack stack or arrangement is LIFO (Last In First Out), means the last incoming data will be out first.
for example in daily life, among others:
Piles of books, piles of coins, etc..

There are two basic operations in use at the Stack:
Push function to add data on STACK on top of the pile
Pop works taking data on STACK at the top
http://www.ziddu.com/download/8190571/Stack.rar.html

Heap Sort

The tree diagram in Heap SortUnderstanding Heap is a data structure that meets the tree-shaped nature of the heap that is, if B is a child of A, then the value stored at node A is greater than or equal to the value stored at node B. This causes the element with the largest value is always located at the root position, and the heap is called a max heap. (If the comparison is diterbalikkan smallest element always at the root node, the heap is called the min heap). Therefore, the heap used to implement the priority queue. Operations that are used for the heap are:
• Delete-delete-max or min: remove the root node of a max or min heap.• Increase or decrease-key-key: change the value stored in a node.• Insert: add a value into the heap.• Merge: merge two heap to form a new heap which contains all the elements forming the heap.
.2 Heap Types
.2.1 Binary heapis the heap created by using binary trees.
.2.2 Binomial heapis the heap created by using the binomial tree.
Binomial tree is defined recursively if is:• A binomial tree with height 0 is a single node• A binomial tree with height k has a root node whose children are the roots of the binomial trees.
.2.3 Fibonacci HeapFibonacci heap is a collection of trees that form the minimum heap.Trees in this data structure does not have a specific shape and in extreme cases this heap contains all the elements in a different tree or a single tree with a height advantage ofFibonacci heap is a heap enough when combined with the combining of two lists of trees.
Heap SORTHeap Sort is a sorting algorithm based on comparative data, and selection are among the sort. Although slower than quick sort in most machines, but the heap sort has the advantages of the complexity of the algorithm in the worst case is n log n.Heap sorting algorithm of this sort to sort the contents of an array of inputs by looking at the array input as a Complete Binary Tree (CBT). After the Complete Binary Tree (CBT) can be converted into a heap tree. After the Complete Binary Tree (CBT) is changed into a priority queue.Heap sorting algorithm starts from building a heap of data collection to be ordered, and then delete the data that has the highest value and placing it in the end of the array which has been ordered. After moving the data with the largest value, the next process is to rebuild the heap and move the greatest value on the heap and put it in last place in the sorted array of other data not specified. This process is repeated until no more data left in the heap and the sorted array is full. In our implementations require two arrays - one to store the heap and one for storing data that is sorted. But for memory optimization, we can use only one array only. That is the way to exchange the contents of the root with the last element in the heap tree. If the memory is not a problem it can be fixed using two rows of input array and the array results.Heap Sort enter input data into a heap data structure. Greatest value (the max-heap) or the smallest value (in min-heap) is taken one by one until the end, the value is taken in the ordered sequence.The algorithm for heap sort:heapSort function (a, count) isInput: an array is not sorted a long length with(first place in a max-heap) heapify (a, count)end: = count -1 0 do" onmouseover="this.style.backgroundColor='#ebeff9'" onmouseout="this.style.backgroundColor='#fff'">while end> 0 doremove ()reheapify ()end: = end - 1
Algorithm HeapifyHeapify algorithm is to build a heap from the bottom up, successively changing down to build the heap. The first problem we must consider the operation of the heapify is where we must begin. When we try to roots heapify operations will occur runut-up operations like bubble sort algorithm that would cause the complexity of the existing time will double.A different version is to build a heap in a top-down and turns up to be conceptually simpler to handle. This version begins with an empty heap and successively enter the data. Another version is to form a tree-lined heap heap-subtree starting from the bottom subtree. If the subtree-subtree of a node is formed from the heap then the tree node is easily made with a flow heap tree down.Once tested, the most efficient idea is the final version, the complexity of the algorithm in the worst case is O (n), while the forming heap-heap tree tree from top to bottom its complexity O (n log n) Thus, the main algorithm heapify is doing an internal iteration starting from the bottom right node (the representation of the array, the elements in the largest index) to the root, then towards the left and climbed into the top level, and so on until reaching the root (as an array [0 .. N -1]). Therefore, the iteration is started from j = N / 2 and less one-one until it reaches j = 0. At the internal node, the examination is only done on the direct child node (not on the other levels below it). At the time iteration in a higher level, is always already formed subtreesubtree heap. Thus, the case will flow towards the bottom node. Thus, this version heapify do as much as N / 2 times iteration, and in the worst case would do as much iteration log (N) times.
Algorithm RemoveThis algorithm remove the root switch (which contains the maximum value) of the heap with the last element. Logically, the nodes that are most kanabawah transferred to the roots to replace the root node to be taken.
Algorithm ReheapifyReheapify algorithm is doing a remake the heap from top to bottom as well as the last iteration of the algorithm heapify methods. The difference between the methods heapify method on iteration reheapify by both the algorithm. The algorithm method was only doing reheapify last iteration of the algorithm heapify. This is because both the left subtree and right subtree is a heap, so no need for such a complete iteration algorithm heapify. And after reheapify the node that will be reduced next diiterasikan one.
DYNAMIC ALLOCATION REPRESENTATIONS heap sorting algorithm SORTCharacteristics of the heap sorting algorithm is that the sort heap sort implementation using heap tree can be solved in order to heap sort. Therefore, to implement the sort heap sorting algorithm in an application program requires a dynamic allocation using a tree data structure (tree). The basic principles of tree data structure used to realize the heap tree is as follows:a. Nodes are interconnected by using a pointer.In this tree data structure is used at least two pointers in each node, each branch to point to the left and right branches of the tree. For example in C language, tree data structure is declared as follows:Class BinaryTreeSimpul (keyType key;infoType info;BinaryTreeSimpul Left,Right; / / methods)
b. Left and Right value NULL if no more branches in the corresponding direction.
c. The structure of the binary tree, including the relationships between nodes, are explicitly represented by the Left and Right. If required search up (backtrack), then it can be done with a scan of the root, the use of algorithms that are recursive, or use of the stack.
d. Another alternative is to add a pointer to the parent.However, this will result in increasing the number of stages in the processes of addition / removal of nodes
COMPARISON WITH OTHER sorting algorithmHeapsort almost equivalent to a quick sort, other data sorting algorithm based on a highly efficient comparison. Quick sort a bit faster, because the cache and other factors, but in the worst casecomplexity O (n), which is very slow for data that are very large. Then because the heap sort has (N log N) is a system that requires strict security usually wear a heap sort algorithm pengurutannya. Heap sort is often compared with merge sort, which mempunyaikompleksitas the same algorithm, but its space complexity (n) larger than the heap sort. Heap sort is also faster on the machine data dengancache small or slow.
CONCLUSIONTaking advantage of the tree data structure, we can get the data sorting algorithm mangkus which can be used to build a good application programs. Sort heap sorting algorithm can be incorporated into the divide and conquer algorithm that caused the division performed by first applying the algorithm as an initialization heapify method to transform a tree into the heap tree, and at every stage of the algorithm is applied reheapify method to reorder the heap tree

Huffman Coding in a Tree Diagram

Huffman code is basically Initialize_model code prefix (prefix code) which is a set that contains a set of binary code. Prefix code is represented as a labeled binary tree where each side is labeled 0 (left branch) or 1 (right branch). Series of bits that form on each path from the root to leaf is a prefix code for the character that matched.
This code also has a wide variety including:

1. Adaptive Huffman coding
2. Length-Limited Huffman Coding
3. N-Ary Huffman Template Algorithm
4. Huffman With Unequal Letter Costs

1. Variations various Huffman Code

A. Adaptive Huffman Coding
Adaptive methods are used at the time of renewal (update) the new algorithm models both the process of compression and decompression
Basic Concept:
Encoder:
Initialize_model
Repeat for each character
(
Encode character
Update_model
)
Decoder
Initialize_model
Repeat for each character
(
Decode character
Update_model
)
The problem is how to update the model consists of algorithms that increase the number and update the Huffman tree. The trick is to update the tree where it is the compression / nirmampat.
Huffman tree initialized with a single node, known as Not-Yet-Transmitted (NYT) Code that is sent each time a new character is found. The algorithm works with a unique numbering on the nodes with different number of leaves.

Lawyer steps update the model
1. If the code was first discovered NYT, then add the two nodes at node NYT. One node as a node NYT and other node as a leaf. Add the number of leaves. If not the NYT, straight to the leaves.

2. If the block does not have the highest rates, exchange with the highest number of blocks.

3. Add the number of node.

4. Check whether the node is the root node. If not go to the parent node.

B. Length-Limited Huffman Coding

Huffman variation is used to obtain the depth of the smallest distance from a symbol, with the restriction that the length of each of which included no less than a given constant value. This method is usually used with GNU gzip.
The steps in Method Length-Limited Huffman are:

1. Selecting two or more symbols to be compressed

2. Combine these symbols and replace them with pseudo-symbol and its frequency.

3. Perform the above steps are iterative until all the nodes that have a single root node.

4. If these nodes have the same frequency, then choose the node with the shortest depth.

C. Binary Huffman Template Algorima

This algorithm is similar to the ordinary Huffman algorithm. The difference, Huffman tree used in this algorithm has more than two roots (0 and 1). While the Huffman template algorithm, allowing to use non-numerical size (the size and frequency in addition to costs).

D. Huffman With Unequal Letter Costs
In this method there is a problem where a set of code that consists of several letters by frequency of occurrence and cost (cost) is different. This method is intended to find a prefix code (prefix code) and calculate the minimum cost (minimum cost). Prefix code is a set of prefix code-free. Cost (cost) of these is the amount of the cost of each letter in the code.
General steps method of Huffman codes with Unequal Letter Cost:

1. Looking for K-prefix code is optimal.

2. Changing K-prefix code into the optimal prefix code.

3. Having obtained the code and then calculate the cost (cost) of his.

Conclusion
Huffman codes proved to have many variations, among them the Adaptive Huffman Code, Code Length-limited Huffman, n-ary Huffman template algorithm, and Huffman codes with unequal letter costs. Various techniques can be used in applications different, but generally used for data compression. This naturally happens because the essence of all the variations of this technique is similar to Huffman codes, namely solving the optimization problem data.

 
 #Huffman Coding #Tree Diagram 

Searching the Data Structure

Searching is a search method in the data structure. Search within this data structure is a job most basic programming.

Sequential searching is a linear search method is a linear search berurutan.Metode quite easy to implement in a program.Metoda writing this using the beginning of the end of the left and then make a comparison of each of the existing elements with a search element. if it is found, the search function to an end and will generate value True.Sementara if the element in question was not found until the end of an array then the search will end with the absence of such elements in the array and the function will generate value in False.Dalam searching methods This array or rows of values must be sorted first dahulu.Karena have ordered then we know that we are looking for elements that have greater value than the elements in the array list designated by index.kita not need to search further because we are looking for elements that would not be we find in the rest of the array that allows the search ada.Ini faster progress when we look for elements in the front of the array list ada.tentu just the opposite: if the element in question is dai end of the array list.

Binary SearchAdalah Searching a method in the conventional manner of the search always starts from the left end of the array where it was at the show by the initiation of the object index with a value of 0. Next we do a search array to perform a search array to the end of the array is reached. To understand how the Binary Search works, imagine when we try to guess the number within a range from 1 to 100 are sequences given to a friend kita.misalkan for each guess that we make, our friends would say we guessed right, too small or too big. The best guess at the beginning of 50 if his guess is too high then we should figure out 25, while if too large a guess our next 75. Every time we always chose to guess at the center by adjusting the lower limit and upper limit of the number.

Searching in the program:
http://www.ziddu.com/download/8718817/ConsoleApplicationSearching.rar.html