Scribd
Upload
2 views

DS1-List

The document provides an overview of data structures, categorizing them into primitive, composite, abstract, linear, and non-linear types. It emphasizes lists as a versatile linear data structure, detailing their characteristics and common operations such as creation, modification, and sorting. Additionally, it includes examples of list operations in C++ using the standard template library.

Uploaded by

kkr795707
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
2 views

DS1-List

The document provides an overview of data structures, categorizing them into primitive, composite, abstract, linear, and non-linear types. It emphasizes lists as a versatile linear data structure, detailing their characteristics and common operations such as creation, modification, and sorting. Additionally, it includes examples of list operations in C++ using the standard template library.

Uploaded by

kkr795707
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 16

DATA STRUCTURE AND ITS TYPES

DATA STRUCTURES ARE FUNDAMENTAL CONCEPTS IN COMPUTER SCIENCE USED TO ORGANIZE,


MANAGE, AND STORE DATA EFFICIENTLY.
HERE ARE SOME COMMON TYPES OF DATA STRUCTURES:
1. PRIMITIVE DATA STRUCTURES:
THESE ARE THE BASIC DATA TYPES PROVIDED BY PROGRAMMING LANGUAGES:
INTEGERS (WHOLE NUMBERS), FLOATS (DECIMAL NUMBERS), CHARACTERS (SINGLE LETTERS
OR SYMBOLS), BOOLEANS(TRUE/FALSE VALUES).
2. COMPOSITE DATA STRUCTURES
THESE ARE BUILT FROM PRIMITIVE DATA STRUCTURES:
• ARRAYS: A COLLECTION OF ELEMENTS IDENTIFIED BY INDEX OR KEY.
• STRINGS: A SEQUENCE OF CHARACTERS TREATED AS A SINGLE DATA TYPE.
• STRUCTURES (STRUCTS): A USER-DEFINED DATA TYPE THAT GROUPS DIFFERENT
DATA TYPES. 1
DATA STRUCTURE AND ITS TYPES

3- ABSTRACT DATA TYPES (ADTS)


THESE DEFINE A DATA TYPE PURELY BY ITS BEHAVIOR (OPERATIONS) RATHER THAN ITS IMPLEMENTATION:
LISTS: AN ORDERED COLLECTION OF ITEMS.
STACKS: A COLLECTION THAT FOLLOWS THE LAST IN FIRST OUT (LIFO) PRINCIPLE.
QUEUES: A COLLECTION THAT FOLLOWS THE FIRST IN FIRST OUT (FIFO) PRINCIPLE.
SETS: A COLLECTION OF UNIQUE ELEMENTS.
MAPS (DICTIONARIES): A COLLECTION OF KEY-VALUE PAIRS.

2
DATA STRUCTURE AND ITS TYPES

4. LINEAR DATA STRUCTURES


THESE STRUCTURES ORGANIZE DATA IN A SEQUENTIAL MANNER:
• LINKED LISTS: A SEQUENCE OF NODES WHERE EACH NODE POINTS TO THE NEXT ONE.
• STACKS: AS MENTIONED, FOLLOWS (LIFO) OR (FILO) ORDER.
• QUEUES: AS MENTIONED, FOLLOWS (FIFO) ORDER.

3
DATA STRUCTURE AND ITS TYPES

5. NON-LINEAR DATA STRUCTURES


THESE STRUCTURES ALLOW FOR MORE COMPLEX RELATIONSHIPS BETWEEN ELEMENTS:
• TREES: HIERARCHICAL STRUCTURES WITH NODES CONNECTED BY EDGES. EXAMPLES INCLUDE BINARY
TREES, BINARY SEARCH TREES, AVL TREES, AND HEAPS.
• GRAPHS: A COLLECTION OF NODES (VERTICES) CONNECTED BY EDGES. CAN BE DIRECTED OR UNDIRECTED,
WEIGHTED OR UNWEIGHTED.

4
LIST AND IT'S OPERATIONS

A LIST IS A LINEAR DATA STRUCTURE THAT IS USED TO STORE A COLLECTION OF


ELEMENTS. LISTS CAN HOLD ITEMS OF DIFFERENT DATA TYPES, INCLUDING
INTEGERS, STRINGS, AND EVEN OTHER LISTS. THEY ARE WIDELY USED IN
PROGRAMMING DUE TO THEIR FLEXIBILITY AND EASE OF USE.
CHARACTERISTICS OF LISTS
• ORDERED: THE ELEMENTS IN A LIST MAINTAIN A SPECIFIC ORDER. EACH ELEMENT HAS A UNIQUE INDEX,
STARTING FROM 0.
• DYNAMIC SIZE: LISTS CAN GROW OR SHRINK IN SIZE AS ELEMENTS ARE ADDED OR REMOVED.
• HETEROGENEOUS: LISTS CAN CONTAIN ELEMENTS OF DIFFERENT DATA TYPES.

5
LIST AND IT'S OPERATIONS

COMMON OPERATIONS ON LISTS :


HERE ARE SOME COMMON OPERATIONS THAT CAN BE PERFORMED ON LISTS:
1. CREATION: YOU CAN CREATE A LIST USING VARIOUS METHODS DEPENDING ON THE PROGRAMMING
LANGUAGE.
2. ACCESSING ELEMENTS: YOU CAN ACCESS ELEMENTS USING THEIR INDEX.
3. MODIFICATION: YOU CAN CHANGE THE VALUE OF AN ELEMENT AT A SPECIFIC INDEX.
4. APPENDING ELEMENTS: YOU CAN ADD AN ELEMENT TO THE END OF THE LIST.
5. INSERTING ELEMENTS: YOU CAN INSERT AN ELEMENT AT A SPECIFIC INDEX.
6. REMOVING ELEMENTS: YOU CAN REMOVE AN ELEMENT BY VALUE.
7. SLICING: YOU CAN RETRIEVE A SUBSET OF THE LIST USING SLICING. 6
LIST AND IT'S OPERATIONS
8. LENGTH: YOU CAN FIND THE NUMBER OF ELEMENTS IN THE LIST.
9. SORTING: YOU CAN SORT THE ELEMENTS OF A LIST,
10. REVERSING: YOU CAN REVERSE THE ORDER OF ELEMENTS IN A LIST.

CONCLUSION
LISTS ARE VERSATILE AND POWERFUL DATA STRUCTURES THAT PROVIDE NUMEROUS OPERATIONS FOR
MANAGING COLLECTIONS OF DATA. THEIR DYNAMIC NATURE AND EASE OF USE MAKE THEM A STAPLE IN
MANY PROGRAMMING TASKS.

7
LIST AND IT'S OPERATIONS IN C++
EXAMPLES OF LIST OPERATIONS IN C++
IN C++, LIST OPERATIONS CAN BE PERFORMED USING THE STD::VECTOR FROM THE STANDARD TEMPLATE LIBRARY (STL), WHICH IS A DYNAMIC ARRAY, OR STD::LIST,
WHICH IS A DOUBLY LINKED LIST. BELOW ARE EXAMPLES OF VARIOUS OPERATIONS USING BOTH STD::VECTOR AND STD::LIST.

#INCLUDE <IOSTREAM>
#INCLUDE <VECTOR>
#INCLUDE <ALGORITHM> // FOR STD::SORT
INT MAIN() {
// 1- CREATING A VECTOR
STD::VECTOR<INT> MY_VECTOR = {1, 2, 3, 4, 5};

// OUTPUT THE VECTOR


FOR (INT NUM : MY_VECTOR) {
STD::COUT << NUM << " ";
}
STD::COUT << STD::ENDL; // OUTPUT: 1 2 3 4 5 8

RETURN 0;
LIST AND IT'S OPERATIONS IN C++
// 2- ACCESSING THE FIRST ELEMENT

INT FIRST_ELEMENT = MY_VECTOR[0];

STD::COUT << FIRST_ELEMENT << STD::ENDL; // OUTPUT: 1

// 3- CHANGING THE SECOND ELEMENT

MY_VECTOR[1] = 10;

STD::COUT << MY_VECTOR[1] << STD::ENDL; // OUTPUT: 10

// 4- ADDING AN ELEMENT TO THE END

MY_VECTOR.PUSH_BACK(6);

STD::COUT << MY_VECTOR.BACK() << STD::ENDL; // OUTPUT: 6

9
LIST AND IT'S OPERATIONS IN C++
//5- INSERTING AT INDEX 2

MY_VECTOR.INSERT(MY_VECTOR.BEGIN() + 2, 20);

STD::COUT << STD::ENDL; // OUTPUT: 1 10 20 3 4 5 6

// 6- REMOVING ELEMENT AT INDEX 1

MY_VECTOR.ERASE(MY_VECTOR.BEGIN() + 1);

STD::COUT << STD::ENDL; // OUTPUT:

// 7. SIZE OF THE VECTOR

STD::COUT << "SIZE: " << MY_VECTOR.SIZE() << STD::ENDL; // OUTPUT: SIZE: 5 (AFTER PREVIOUS OPERATIONS)

// 8- SORTING THE VECTOR


10
STD::SORT(MY_VECTOR.BEGIN(), MY_VECTOR.END());
LIST AND IT'S OPERATIONS IN C++
// 9- REVERSING THE VECTOR

STD::REVERSE(MY_VECTOR.BEGIN(), MY_VECTOR.END());

STD::COUT << STD::ENDL; // OUTPUT:

11
LIST AND IT'S OPERATIONS IN C++ COMPLETE EXAMPLE

• HERE’S A COMPLETE EXAMPLE THAT COMBINES SEVERAL OF THESE OPERATIONS:


#INCLUDE <IOSTREAM>
USING NAMESPACE STD;
INT MAIN()
{
CONST INT N=10;
INT NUMBERS[N], X, K;
// INSERT 5 ELEMENTS TO VECTOR
COUT<<"ENTER FIVE NUMBERS"<<ENDL;
FOR (INT I=0; I<5; I++)
{
COUT<<"ENTER NUMBER : ";
CIN>>NUMBERS[I];
}
12
K=5;
LIST AND IT'S OPERATIONS IN C++
COUT<<"===================="<<ENDL;
COUT<<" VECTOR AFTER ADD ELEMENT 7 TO THE END"<<ENDL;

COUT<<"===================="<<ENDL;
// ADD ELEMENT 7 TO THE END
NUMBERS[5]=7;

K=K+1;
FOR(INT I=0; I<K; I++)
COUT<<NUMBERS[I]<<ENDL;

COUT<<"===================="<<ENDL;
COUT<<" VECTOR AFTER INSERT NEW ELEMENT 44 AT INDEX 1"<<ENDL;
COUT<<"===================="<<ENDL; 13
LIST AND IT'S OPERATIONS IN C++

// INSERT NEW ELEMENT 44 AT INDEX 1


FOR(INT I=5; I>=1; I--)
NUMBERS[I+1]=NUMBERS[I];
NUMBERS[1]=44;
K=K+1;
FOR(INT I=0; I<K; I++)
COUT<<NUMBERS[I]<<ENDL;

14
LIST AND IT'S OPERATIONS IN C++

// SORT THE VECTOR


FOR(INT I=0; I<K-1; I++)
FOR(INT J=I+1; J<K; J++)
IF(NUMBERS[I] > NUMBERS[J])
{
X=NUMBERS[I];
NUMBERS[I]=NUMBERS[J];
NUMBERS[J]=X;
}
15
LIST AND IT'S OPERATIONS IN C++

// OUTPUT SORTED ELEMENTS


COUT<<"===================="<<ENDL;
COUT<<" VECTOR AFTER SORTED ELEMENTS"<<ENDL;
COUT<<"===================="<<ENDL;
FOR(INT I=0; I<K; I++)
COUT<<NUMBERS[I]<<ENDL;

RETURN 0;
} 16

You might also like