Linked List - Final

### part 3
#DynamicStructure
[[Linked List]] [[Linked List.Clear]] [[Linked List.Final]] [[Linked List Double
(!!!)]]
---
```cpp
#include <iostream>
using namespace std;
template<typename T>
class List {
public:
List() {
size = 0;
head = nullptr;
}
~List() {
clear();
}
int GetSize() { return size; }

void push_front(T data);
void insert(T value, int index);
void push_back(T data);
void pop_front();
void removeAt(int index);
void pop_back();
T& operator [](const int index);

void clear();
private:
class Node {
public:
T data;
Node* pNext;
Node(T data = T(), Node* pNext = nullptr) {

this->data = data;
this->pNext = pNext;
}
};
int size;
Node<T>* head;
};
//operator overloading
T& List<T>::operator [](const int index) {
int counter = 0;
Node<T>* current = head;
while (current->pNext != nullptr) {
if (counter == index)
return current->data;
current = current->pNext;
counter++;
}
}
//elements operations
void List<T>::push_front(T data) {
head = new Node<T>(data, head);
size++;
}
void List<T>::insert(T value, int index) {
if (index == 0)
push_front(value);
else {
Node<T>* previous = head;
for (int i = 0; i < index - 1; i++) {
previous = previous->pNext;
}
previous->pNext = new Node<T>(value, previous->pNext);
size++;
}
}
void List<T>::push_back(T data) {
if (head == nullptr)
head = new Node<T>(data);
else {
while (current->pNext != nullptr)
current->pNext = new Node<T>(data);

}
size++;
}
void List<T>::pop_front() {
Node<T>* temp = head;
head = head->pNext;
delete temp;
size--;
}
void List<T>::removeAt(int index) {
if (index == 0)
pop_front();
else {
for (int i = 0; i < index - 1; i++) {
}
Node<T>* toDelete = previous->pNext;
previous->pNext = toDelete->pNext;
delete toDelete;
size--;
}
}
void List<T>::pop_back(){
removeAt(size - 1);
}
void List<T>::clear() {
while (size)
pop_front();
}
int main() {
List<int> lst;
lst.push_front(4);
lst.push_front(3);
lst.push_front(7);
lst.push_front(8);
lst.push_front(53);
lst.push_front(83);
for (int i = 0; i < lst.GetSize(); i++) {

cout << lst[i] << endl;
}
cout << "\ninsert!\n" << endl;

lst.insert(245, 2);
cout << "\nremove!\n" << endl;
lst.removeAt(4);
for (int i = 0; i < lst.GetSize(); i++){

}
cout << "\npop_back\n";

lst.pop_back();

}
cout << "\nelemenets on the list: " << lst.GetSize() << endl;
cout << "clear" << endl;

lst.clear();
cout << "elements on the list: " << lst.GetSize() << endl;
return 0;
}
```
## More examples
```cpp
#include <iostream>
using namespace std;
class List {
public:
List() {
size = 0;
head = nullptr;
}
~List() {
clear();
}
int GetSize() { return size; }

T& operator [] (const int index);
void push_front(T data);

void insert(T data, int index);
void push_back(T data);
void pop_front();
void removeAt(int index);
void pop_back();
void clear();
private:
template <typename T>
class Node {
public:
T data;
Node* pNext;
Node(T data = T(), Node* pNext = nullptr) {

this->data = data;
this->pNext = pNext;
}
};
int size;
Node<T>* head;
};
//operator overload
T& List<T>::operator[](const int index){
int counter = 0;
while (current != nullptr){
if (counter == index)
return current->data;
counter++;
}
}
//element operation
void List<T>::push_front(T data) {
head = new Node<T>(data, head);
size++;
}
void List<T>::insert(T data, int index) {
if (index == 0)
push_front(data);
else {
for (int i = 0; i < index - 1; i++){
}
previous->pNext = new Node<T>(data, previous->pNext);
size++;
}
}
void List<T>::push_back(T data) {
if (head == nullptr)
head = new Node<T>(data);
else {
while (current->pNext != nullptr) {
}
current->pNext = new Node<T>(data);
}
size++;
}
void List<T>::pop_back() {
removeAt(size - 1);
}
void List<T>::clear(){
while (size)
pop_front();
}
void List<T>::pop_front(){
Node<T>* temp = head;
head = head->pNext;
delete temp;
size--;
}
void List<T>::removeAt(int index){
if (index == 0)
pop_front();
else {
for (int i = 0; i < index - 1; i++){
}
Node<T>* ToDelete = previous->pNext;
previous->pNext = ToDelete->pNext;
delete ToDelete;
size--;
}
}
void printList(List<T>& lst) {
}
}
int main() {
List<int> lst;
int size = 5;
for (int i = 0; i < size; i++){
lst.push_back(rand() % 10);
}
lst.insert(155, 2);
lst.removeAt(2);
printList(lst);
return 0;
}
```

Linked List - Final

Uploaded by

Copyright:

Available Formats

Linked List - Final

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Linked List - Final

Uploaded by

Copyright:

Available Formats

### part 3

int GetSize() { return size; }

T& operator [](const int index);

Node(T data = T(), Node* pNext = nullptr) {

current->pNext = new Node<T>(data);

for (int i = 0; i < lst.GetSize(); i++) {

cout << "\ninsert!\n" << endl;

for (int i = 0; i < lst.GetSize(); i++){

cout << "\npop_back\n";

for (int i = 0; i < lst.GetSize(); i++) {

cout << "clear" << endl;

int GetSize() { return size; }

void push_front(T data);

Node(T data = T(), Node* pNext = nullptr) {

You might also like

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.