├── .vscode
    └── settings.json
├── C++
    ├── .vscode
    │   └── settings.json
    ├── Arrays
    │   ├── DynamicArrays.cpp
    │   ├── WordSplit.cpp
    │   └── WordSplit.exe
    ├── LinkedLists
    │   ├── DoublyLinkedList
    │   │   ├── DoublyLinkedList.cpp
    │   │   └── WithClasses
    │   │   │   ├── DoublyLinkedList.h
    │   │   │   ├── Node.h
    │   │   │   └── main.cpp
    │   └── SinglyLinkedList
    │   │   ├── SinglyLinkedList.cpp
    │   │   └── WithClasses
    │   │       ├── Node.h
    │   │       ├── SinglyLinkedList.h
    │   │       └── main.cpp
    ├── Recursion
    │   ├── Pow.cpp
    │   ├── Product.cpp
    │   └── ReverseString.cpp
    └── StacksQueuesDeques
    │   ├── Deque.cpp
    │   ├── DequeWithTemplates.cpp
    │   ├── Queue.cpp
    │   ├── QueueWithTemplates.cpp
    │   ├── Stack.cpp
    │   └── StackWithTemplates.cpp
├── LICENSE
├── Python
    ├── Arrays
    │   ├── DynamicArrays.py
    │   └── WordSplit.py
    ├── BinaryTrees
    │   ├── BinaryTree.py
    │   ├── Node.py
    │   └── __pycache__
    │   │   └── Node.cpython-38.pyc
    ├── LinkedLists
    │   ├── DoublyLinkedList
    │   │   ├── DoublyLinkedList.py
    │   │   ├── Node.py
    │   │   └── __pycache__
    │   │   │   └── Node.cpython-37.pyc
    │   └── SinglyLinkedList
    │   │   ├── Node.py
    │   │   ├── SinglyLinkedList.py
    │   │   └── __pycache__
    │   │       └── Node.cpython-37.pyc
    ├── Recursion
    │   ├── Pow.py
    │   ├── Product.py
    │   └── ReverseString.py
    └── StacksQueuesDeques
    │   ├── Deques.py
    │   ├── DequesFromPython.py
    │   ├── Queue.py
    │   ├── QueueByTwoStack.py
    │   ├── ReverseStringWithUseStack.py
    │   └── Stack.py
├── README.md
├── bagli_liste.jpg
├── binary_tree_0.png
├── binary_tree_1.png
├── binary_tree_2.png
├── binary_tree_3.png
├── binary_tree_4.png
├── cift_yonlu.jpg
├── dairesel_bagli_liste.jpg
├── dairesel_bagli_liste1.jpg
├── dizi_temsili.png
├── dizi_temsili1.png
└── veri_tipleri.jpg


/.vscode/settings.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "files.associations": {
 3 |         "*.html": "html",
 4 |         "iterator": "cpp",
 5 |         "iostream": "cpp",
 6 |         "ostream": "cpp",
 7 |         "iosfwd": "cpp",
 8 |         "xstring": "cpp"
 9 |     },
10 |     "C_Cpp.errorSquiggles": "Disabled"
11 | }


--------------------------------------------------------------------------------
/C++/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 |     "C_Cpp.errorSquiggles": "Disabled",
3 |     "files.associations": {
4 |         "*.html": "html",
5 |         "ostream": "cpp",
6 |         "iostream": "cpp"
7 |     }
8 | }


--------------------------------------------------------------------------------
/C++/Arrays/DynamicArrays.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | class DynamicArray
 6 | {
 7 | private:
 8 |     int item_count;
 9 |     int capacity;
10 |     int* dynamic_array;
11 | public:
12 |     DynamicArray(/* args */);
13 |     void append(int item);
14 |     int get_item(int index);
15 |     void resize();
16 |     int get_capacity();
17 |     ~DynamicArray();
18 | };
19 | 
20 | DynamicArray::DynamicArray(/* args */)
21 | {
22 |     this->item_count = 0;
23 |     this->capacity = 1;
24 |     this->dynamic_array=new int[this->capacity];
25 | }
26 | 
27 | void DynamicArray::append(int item){
28 |     if(this->item_count==this->capacity)
29 |         this->resize();
30 |     this->dynamic_array[item_count] = item;
31 |     this->item_count++;
32 | }
33 | 
34 | int DynamicArray::get_item(int index){
35 |     return this->dynamic_array[index];
36 | }
37 | 
38 | void DynamicArray::resize(){
39 |     int* temp=new int[this->capacity];
40 |     for (int i = 0; i < this->capacity; i++)
41 |     {
42 |         temp[i]=this->dynamic_array[i];
43 |     }
44 |     this->dynamic_array = new int[++this->capacity];
45 |     for (int i = 0; i < this->capacity - 1; i++)
46 |     {
47 |         this->dynamic_array[i]=temp[i];
48 |     }
49 |     delete[] temp;
50 | }
51 | 
52 | int DynamicArray::get_capacity(){
53 |     return this->capacity;
54 | }
55 | 
56 | DynamicArray::~DynamicArray()
57 | {
58 |     delete[] this->dynamic_array;
59 | }
60 | 
61 | int main(){
62 | 	DynamicArray newarray;
63 |     newarray.append(1);
64 |     newarray.append(3);
65 |     newarray.append(5);
66 |     for (int i = 0; i < newarray.get_capacity(); i++)
67 |     {
68 |         cout<<endl<<newarray.get_item(i);
69 |     }
70 |     return 0;
71 | }
72 | 


--------------------------------------------------------------------------------
/C++/Arrays/WordSplit.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | string word_split(string first_word,string mixed_word);
 6 | 
 7 | int main(){
 8 |     cout<<word_split("asd");
 9 | }
10 | 
11 | string word_split(string first_word,string mixed_word){
12 |     return "asd";
13 | }


--------------------------------------------------------------------------------
/C++/Arrays/WordSplit.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/C++/Arrays/WordSplit.exe


--------------------------------------------------------------------------------
/C++/LinkedLists/DoublyLinkedList/DoublyLinkedList.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | 
  3 | using namespace std;
  4 | 
  5 | struct node{
  6 |     int n;
  7 |     node* next;
  8 |     node* prev;
  9 | };
 10 | 
 11 | void append(node* root, int x){
 12 |     node* new_node = new node[1];
 13 |     new_node->n = x;
 14 |     node* iter = root;
 15 |     while(iter->next!=nullptr){
 16 |         iter=iter->next;
 17 |     }
 18 |     iter->next = new_node;
 19 |     new_node->prev = iter;
 20 |     new_node->next = nullptr;
 21 | }
 22 | 
 23 | node* add_front(node* root, int x){
 24 |     node* new_node = new node[1];
 25 |     new_node->n = x;
 26 |     new_node->prev=nullptr;
 27 |     new_node->next=root;
 28 |     root->prev=new_node;
 29 |     root = new_node;
 30 |     return root;
 31 | }
 32 | 
 33 | node* remove(node* root,int x){
 34 |     node* iter = root;
 35 |     while(iter != nullptr && iter->n != x){
 36 |         iter=iter->next;
 37 |     }
 38 |     if(iter == nullptr){
 39 |         cout<<"Listede Boyle Bir Eleman Yok!";
 40 |     }
 41 |     else{
 42 |     	if(iter->prev == nullptr){
 43 |     		root = iter->next;
 44 | 		}
 45 | 		else if(iter->next == nullptr){
 46 | 			iter->prev->next = nullptr;
 47 | 		}
 48 | 		else{
 49 | 			iter->prev->next = iter->next;
 50 |         	iter->next->prev = iter->prev;
 51 | 		}
 52 |         delete[] iter;
 53 |         return root;
 54 |     }
 55 | }
 56 | 
 57 | void insert_after(node* root, int x, int y){
 58 |     node* iter = root;
 59 |     while(iter != nullptr && iter->n != x){
 60 |         iter = iter->next;
 61 |     }
 62 |     if(iter == nullptr){
 63 |         cout<<"Listede Boyle Bir Eleman Yok!";
 64 |     }
 65 |     else{
 66 |         node* new_node = new node[1];
 67 |         new_node->n = y;
 68 |         new_node->next = iter->next;
 69 |         if(iter->next != nullptr)
 70 | 			iter->next->prev = new_node;
 71 |         iter->next = new_node;
 72 |         new_node->prev = iter;
 73 |     }
 74 | }
 75 | 
 76 | void print_list(node* root){
 77 | 	cout<<endl<<"-------"<<endl;
 78 |     node* iter = root;
 79 |     while(iter!=nullptr){
 80 |         cout<<endl<<iter->n<<endl;
 81 |         iter=iter->next;
 82 |     }
 83 |     cout<<endl<<"-------"<<endl;
 84 | }
 85 | 
 86 | int main(){
 87 |     node* root;
 88 |     root = new node[1];
 89 |     root->n = 0;
 90 |     root->next = nullptr;
 91 |     root->prev = nullptr;
 92 | //    for(int i = 1; i <= 5; i++){
 93 | //        append(root,i);
 94 | //    }
 95 | 	for(int i=1;i<=5;i++){
 96 | 		root=add_front(root,i);
 97 | 	}
 98 | 	append(root,8);
 99 | 	root = remove(root,8);
100 |     append(root,8);
101 |     root = add_front(root,10);
102 |     append(root,13);
103 |     root = remove(root,10);
104 |     root = remove(root,3);
105 | 	print_list(root);
106 |     root = add_front(root,15);
107 |     root = add_front(root,19);
108 |     root = add_front(root,38);
109 |     print_list(root);
110 |     remove(root,3);
111 |     remove(root,19);
112 |     remove(root,28);
113 |     print_list(root);
114 |     cout<<"-------"<<endl;
115 |     insert_after(root, 4, 7);
116 |     insert_after(root, 7, 88);
117 |     insert_after(root, 38, 93);
118 | 	insert_after(root, 15, 103);
119 | 	insert_after(root, 13, 104);
120 | 	root = remove(root,104);
121 | 	append(root,16);
122 | 	root = add_front(root,158);
123 | 	insert_after(root,158,77);
124 |     print_list(root);
125 | 
126 |     return 0;
127 | }
128 | 


--------------------------------------------------------------------------------
/C++/LinkedLists/DoublyLinkedList/WithClasses/DoublyLinkedList.h:
--------------------------------------------------------------------------------
  1 | #ifndef DOUBLY_LINKED_LIST
  2 | #define DOUBLY_LINKED_LIST
  3 | 
  4 | #include <iostream>
  5 | #include "Node.h"
  6 | 
  7 | using namespace std;
  8 | 
  9 | template <class T>
 10 | class DoublyLinkedList
 11 | {
 12 | private:
 13 |     Node<T>* root;
 14 | public:
 15 |     DoublyLinkedList();
 16 |     void add_front(T data);
 17 |     void append(T data);
 18 |     void insert_after(T prev_data,T data);
 19 |     void remove(T data);
 20 |     void print_list();
 21 |     ~DoublyLinkedList();
 22 | };
 23 | 
 24 | template <class T>
 25 | DoublyLinkedList<T>::DoublyLinkedList()
 26 | {
 27 |     this->root = nullptr;
 28 | }
 29 | 
 30 | template <class T>
 31 | void DoublyLinkedList<T>::add_front(T data){
 32 |     Node<T>* new_node = new Node<T>(data);
 33 |     if(this->root != nullptr)
 34 |     	this->root->set_prev(new_node);
 35 | 	new_node->set_next(this->root);
 36 |     this->root = new_node;
 37 | }
 38 | 
 39 | template <class T>
 40 | void DoublyLinkedList<T>::append(T data){
 41 |     Node<T>* new_node = new Node<T>(data);
 42 |     if(this->root == nullptr){
 43 |     	this->root = new_node;
 44 | 	}
 45 | 	else{
 46 | 		Node<T>* iter = this->root;
 47 | 		while(iter->get_next() != nullptr){
 48 |         	iter = iter->get_next();
 49 | 	    }
 50 | 	    iter->set_next(new_node);
 51 | 	    new_node->set_prev(iter);
 52 | 	}
 53 | }
 54 | 
 55 | template <class T>
 56 | void DoublyLinkedList<T>::insert_after(T prev_data, T data){
 57 |     if(this->root == nullptr){
 58 |         cout<<"Listede Eleman Yok"<<endl;
 59 |     }
 60 |     else{
 61 |         Node<T>* iter = this->root;
 62 |         while(iter->get_data() != prev_data && iter != nullptr){
 63 |             iter = iter->get_next();
 64 |         }
 65 |         if(iter == nullptr){
 66 |             cout<<"Listede "<<prev_data<<" Elemani Bulunmuyor!"<<endl;
 67 |         }
 68 |         else{
 69 |             Node<T>* new_node = new Node<T>(data);
 70 |             new_node->set_next(iter->get_next());
 71 |             if(iter->get_next() != nullptr)
 72 |             	iter->get_next()->set_prev(new_node);
 73 |             iter->set_next(new_node);
 74 |             new_node->set_prev(iter);
 75 |         }
 76 |     }
 77 | }
 78 | 
 79 | template <class T>
 80 | void DoublyLinkedList<T>::remove(T data){
 81 |     if(this->root == nullptr){
 82 |         cout<<"Listede Eleman Yok"<<endl;
 83 |     }
 84 |     else{
 85 |         Node<T>* iter = this->root;
 86 |         while(iter != nullptr && iter->get_data() != data){
 87 |             iter = iter->get_next();
 88 |         }
 89 |         if(iter == nullptr){
 90 |             cout<<"Listede "<<data<<"Elemani Bulunmuyor!"<<endl;
 91 |         }
 92 |         else{
 93 |             if(iter->get_prev() == nullptr && iter->get_next()==nullptr){
 94 |             	this->root=nullptr;
 95 |             }
 96 |             else if(iter->get_prev() == nullptr){
 97 | 				iter->get_next()->set_prev(nullptr);
 98 | 				this->root = iter->get_next();
 99 | 			}
100 | 			else if(iter->get_next() == nullptr){
101 | 				iter->get_prev()->set_next(nullptr);
102 | 			}
103 | 			else{
104 |         		iter->get_prev()->set_next(iter->get_next());
105 | 				iter->get_next()->set_prev(iter->get_prev());	
106 | 			}
107 |         }
108 |     }
109 | }
110 | 
111 | template <class T>
112 | void DoublyLinkedList<T>::print_list(){
113 |     Node<T>* iter = this->root;
114 |     while(iter != nullptr){
115 |         cout<<iter->get_data()<<endl;
116 |         iter = iter->get_next();
117 |     }
118 | }
119 | 
120 | template <class T>
121 | DoublyLinkedList<T>::~DoublyLinkedList()
122 | {
123 |     if(this->root!=nullptr){
124 |         this->root->~Node();
125 |     }
126 | }
127 | 
128 | #endif
129 | 


--------------------------------------------------------------------------------
/C++/LinkedLists/DoublyLinkedList/WithClasses/Node.h:
--------------------------------------------------------------------------------
 1 | #ifndef NODE_H
 2 | #define NODE_H
 3 | 
 4 | template <class T>
 5 | class Node
 6 | {
 7 | private:
 8 |     T data;
 9 |     Node* next;
10 |     Node* prev;
11 | public:
12 |     Node(T data);
13 |     T get_data();
14 |     void set_next(Node* next);
15 |     void set_prev(Node* prev);
16 |     Node* get_next();
17 |     Node* get_prev();
18 | 	~Node();
19 | };
20 | 
21 | template <class T>
22 | Node<T>::Node(T data)
23 | {
24 |     this->data = data;
25 |     this->next = nullptr;
26 |     this->prev = nullptr;
27 | }
28 | 
29 | template <class T>
30 | T Node<T>::get_data(){
31 |     return this->data;
32 | }
33 | 
34 | template <class T>
35 | void Node<T>::set_next(Node* next){
36 |     this->next = next;
37 | }
38 | 
39 | template <class T>
40 | void Node<T>::set_prev(Node* prev){
41 |     this->prev = prev;
42 | }
43 | 
44 | template <class T>
45 | Node<T>* Node<T>::get_next(){
46 |     return this->next;
47 | }
48 | 
49 | template <class T>
50 | Node<T>* Node<T>::get_prev(){
51 |     return this->prev;
52 | }
53 | 
54 | template <class T>
55 | Node<T>::~Node()
56 | {
57 |     if(this->next!=nullptr){
58 |         this->next->~Node();
59 |     }
60 | }
61 | #endif
62 | 


--------------------------------------------------------------------------------
/C++/LinkedLists/DoublyLinkedList/WithClasses/main.cpp:
--------------------------------------------------------------------------------
 1 | #include "DoublyLinkedList.h"
 2 | 
 3 | int main(){
 4 |     DoublyLinkedList<int> new_list;
 5 |     new_list.add_front(3);
 6 |     new_list.add_front(8);
 7 |     new_list.add_front(5);
 8 |     new_list.append(5);
 9 |     new_list.append(13);
10 |     new_list.add_front(8);
11 |     new_list.insert_after(8,12);
12 | 	new_list.insert_after(13,15);
13 | 	new_list.insert_after(15,21);
14 |     new_list.add_front(17);
15 |     new_list.append(77);
16 | 	new_list.insert_after(77,99);
17 | 	new_list.insert_after(77,43);
18 | 	new_list.remove(99);
19 | 	new_list.remove(43);
20 | 	new_list.remove(8);
21 | 	new_list.remove(17);
22 | 	new_list.remove(12);
23 | 	new_list.add_front(777);
24 | 	new_list.append(124);
25 | 	new_list.insert_after(124,23);
26 | 	new_list.insert_after(777,25);		
27 | 	new_list.print_list();
28 |     DoublyLinkedList<char> char_list;
29 |     char_list.add_front('a');
30 |     char_list.add_front('k');
31 |     char_list.add_front('n');
32 |     char_list.add_front('a');
33 |     char_list.print_list();
34 |     char_list.append('k');
35 |     char_list.append('u');
36 |     char_list.append('s');
37 |     char_list.append('u');
38 |     char_list.print_list();
39 |     new_list.insert_after(8,99);
40 |     new_list.print_list();
41 |     new_list.insert_after(3,17);
42 |     new_list.print_list();
43 |     new_list.remove(99);
44 |     new_list.print_list();
45 |     new_list.remove(8);
46 |     new_list.print_list();
47 |     char_list.remove('s');
48 |     char_list.print_list();
49 | 
50 |     return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/C++/LinkedLists/SinglyLinkedList/SinglyLinkedList.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | struct node
 6 | {
 7 |     int n;
 8 |     node* next;
 9 | };
10 | 
11 | void append(node* s_l_list,int data){
12 |     node* iter;
13 |     iter = s_l_list;
14 |     while(iter->next != nullptr){
15 |         iter = iter->next;
16 |     }
17 |     iter->next = new node[1];
18 |     iter->next->n = data;
19 |     iter->next->next = nullptr;
20 | }
21 | 
22 | void print_list(node* s_l_list){
23 |     node* iter;
24 |     iter = s_l_list;
25 |     while(iter != nullptr){
26 |         cout<<endl<<iter->n<<endl;
27 |         iter = iter->next;
28 |     }
29 | }
30 | 
31 | node* add_front(node* s_l_list,int data){
32 |     node* new_node=new node[1];
33 |     new_node->n = data;
34 |     new_node->next = s_l_list;
35 |     s_l_list = new_node;
36 |     return s_l_list;
37 | }
38 | 
39 | void insert(node* s_l_list,int prev_data, int data){
40 |     node* iter;
41 |     iter = s_l_list;
42 |     while(iter->n != prev_data){
43 |         iter = iter->next;
44 |     }
45 |     node* new_node = new node[1];
46 |     new_node->n = data;
47 |     new_node->next = iter->next;
48 |     iter->next = new_node;
49 | }
50 | 
51 | void remove(node* s_l_list,int data){
52 |     node* iter;
53 |     iter = s_l_list;
54 |     while(iter->next->n != data){
55 |         iter = iter->next;
56 |     }
57 |     node* temp = iter->next;
58 |     iter->next = temp->next;
59 |     delete[] temp;
60 |     temp = nullptr;
61 | }
62 | 
63 | int main(){
64 |     node* root;
65 |     root = new node[1];
66 |     root->n = 0;
67 |     root->next = nullptr;
68 |     for (int i = 1; i <= 5; i++)
69 |     {
70 |         root = add_front(root,i);
71 |     }
72 |     print_list(root);
73 |     append(root,6);
74 |     print_list(root);
75 |     append(root,17);
76 |     print_list(root);
77 |     insert(root,3,71);
78 |     print_list(root);
79 |     insert(root,6,47);
80 |     print_list(root);
81 |     root = add_front(root,59);
82 |     print_list(root);
83 |     remove(root,47);
84 |     print_list(root);
85 |     insert(root,6,47);
86 |     print_list(root);
87 | 
88 |     return 0;
89 |     
90 | }


--------------------------------------------------------------------------------
/C++/LinkedLists/SinglyLinkedList/WithClasses/Node.h:
--------------------------------------------------------------------------------
 1 | #ifndef NODE_H
 2 | #define NODE_H
 3 | 
 4 | template <class T>
 5 | class Node
 6 | {
 7 | private:
 8 |     T data;
 9 |     Node* next;
10 | public:
11 |     Node(T data);
12 |     T get_data();
13 |     void set_next(Node* next);
14 |     Node* get_next();
15 |     ~Node();
16 | };
17 | 
18 | template <class T>
19 | Node<T>::Node(T data)
20 | {
21 |     this->data = data;
22 |     this->next = nullptr;
23 | }
24 | 
25 | template <class T>
26 | T Node<T>::get_data(){
27 |     return this->data;
28 | }
29 | 
30 | template <class T>
31 | void Node<T>::set_next(Node* next){
32 |     this->next = next;
33 | }
34 | 
35 | template <class T>
36 | Node<T>* Node<T>::get_next(){
37 |     return this->next;
38 | }
39 | 
40 | template <class T>
41 | Node<T>::~Node()
42 | {
43 |     if(this->next!=nullptr){
44 |         this->next->~Node();
45 |     }
46 | }
47 | #endif


--------------------------------------------------------------------------------
/C++/LinkedLists/SinglyLinkedList/WithClasses/SinglyLinkedList.h:
--------------------------------------------------------------------------------
  1 | #ifndef SINGLY_LINKED_LIST
  2 | #define SINGLY_LINKED_LIST
  3 | 
  4 | #include <iostream>
  5 | #include "Node.h"
  6 | 
  7 | using namespace std;
  8 | 
  9 | template <class T>
 10 | class SinglyLinkedList
 11 | {
 12 | private:
 13 |     Node<T>* root;
 14 | public:
 15 |     SinglyLinkedList();
 16 |     void add_front(T data);
 17 |     void append(T data);
 18 |     void insert_after(T prev_data,T data);
 19 |     void remove(T data);
 20 |     void print_list();
 21 |     ~SinglyLinkedList();
 22 | };
 23 | 
 24 | template <class T>
 25 | SinglyLinkedList<T>::SinglyLinkedList()
 26 | {
 27 |     this->root = nullptr;
 28 | }
 29 | 
 30 | template <class T>
 31 | void SinglyLinkedList<T>::add_front(T data){
 32 |     Node<T>* new_node = new Node<T>(data);
 33 |     new_node->set_next(this->root);
 34 |     this->root = new_node;
 35 | }
 36 | 
 37 | template <class T>
 38 | void SinglyLinkedList<T>::append(T data){
 39 |     Node<T>* new_node = new Node<T>(data);
 40 |     Node<T>* iter = this->root;
 41 |     while(iter->get_next() != nullptr){
 42 |         iter = iter->get_next();
 43 |     }
 44 |     iter->set_next(new_node);
 45 | }
 46 | 
 47 | template <class T>
 48 | void SinglyLinkedList<T>::insert_after(T prev_data, T data){
 49 |     if(this->root == nullptr){
 50 |         cout<<"Listede Eleman Yok"<<endl;
 51 |     }
 52 |     else{
 53 |         Node<T>* iter = this->root;
 54 |         while(iter->get_data() != prev_data && iter != nullptr){
 55 |             iter = iter->get_next();
 56 |         }
 57 |         if(iter == nullptr){
 58 |             cout<<"Listede "<<prev_data<<" Elemani Bulunmuyor!"<<endl;
 59 |         }
 60 |         else{
 61 |             Node<T>* new_node = new Node<T>(data);
 62 |             new_node->set_next(iter->get_next());
 63 |             iter->set_next(new_node);
 64 |         }
 65 |     }
 66 | }
 67 | 
 68 | template <class T>
 69 | void SinglyLinkedList<T>::remove(T data){
 70 |     if(this->root == nullptr){
 71 |         cout<<"Listede Eleman Yok"<<endl;
 72 |     }
 73 |     else{
 74 |         Node<T>* iter = this->root;
 75 |         while(iter->get_next() != nullptr && iter->get_next()->get_data() != data){
 76 |             iter = iter->get_next();
 77 |         }
 78 |         if(iter->get_next() == nullptr){
 79 |             cout<<"Listede "<<data<<"Elemani Bulunmuyor!"<<endl;
 80 |         }
 81 |         else{
 82 |             Node<T>* temp = iter->get_next();
 83 |             iter->set_next(temp->get_next());
 84 |             delete temp;
 85 |         }
 86 |     }
 87 | }
 88 | 
 89 | template <class T>
 90 | void SinglyLinkedList<T>::print_list(){
 91 |     Node<T>* iter = this->root;
 92 |     while(iter != nullptr){
 93 |         cout<<iter->get_data()<<endl;
 94 |         iter = iter->get_next();
 95 |     }
 96 | }
 97 | 
 98 | template <class T>
 99 | SinglyLinkedList<T>::~SinglyLinkedList()
100 | {
101 |     if(this->root!=nullptr){
102 |         this->root->~Node();
103 |     }
104 | }
105 | 
106 | #endif


--------------------------------------------------------------------------------
/C++/LinkedLists/SinglyLinkedList/WithClasses/main.cpp:
--------------------------------------------------------------------------------
 1 | #include "SinglyLinkedList.h"
 2 | 
 3 | int main(){
 4 |     SinglyLinkedList<int> new_list;
 5 |     new_list.add_front(3);
 6 |     new_list.add_front(8);
 7 |     new_list.add_front(5);
 8 |     new_list.print_list();
 9 |     SinglyLinkedList<char> char_list;
10 |     char_list.add_front('a');
11 |     char_list.add_front('k');
12 |     char_list.add_front('n');
13 |     char_list.add_front('a');
14 |     char_list.print_list();
15 |     char_list.append('k');
16 |     char_list.append('u');
17 |     char_list.append('s');
18 |     char_list.append('u');
19 |     char_list.print_list();
20 |     new_list.insert_after(8,99);
21 |     new_list.print_list();
22 |     new_list.insert_after(3,17);
23 |     new_list.print_list();
24 |     new_list.remove(99);
25 |     new_list.print_list();
26 |     new_list.remove(8);
27 |     new_list.print_list();
28 |     char_list.remove('s');
29 |     char_list.print_list();
30 | 
31 |     return 0;
32 | }


--------------------------------------------------------------------------------
/C++/Recursion/Pow.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | int my_product(int x,int y){
 6 |     if(x == 1){
 7 |         return y;
 8 |     }
 9 |     return y + my_product(x-1, y);
10 | }
11 | 
12 | int my_pow(int x, int y){
13 |     if(y == 1){
14 |         return x;
15 |     }
16 |     return my_product(x,my_pow(x, y - 1));
17 | }
18 | 
19 | int main(){
20 |     cout<<my_pow(5,2);
21 | 
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/C++/Recursion/Product.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | 
 3 | using namespace std;
 4 | 
 5 | int my_product(int x, int y){
 6 |     if(x == 1){
 7 |         return y;
 8 |     }
 9 |     return y + my_product(x-1,y);
10 | }
11 | 
12 | int my_product2(int x, int y){
13 |     if(y == 1){
14 |         return x;
15 |     }
16 |     return x + my_product(x, y-1);
17 | }
18 | 
19 | int main(){
20 |     cout<<my_product(2,3)<<endl<<my_product2(3,2);
21 | 
22 |     return 0;
23 | }


--------------------------------------------------------------------------------
/C++/Recursion/ReverseString.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | 
 4 | string reverse_string(string str){
 5 |     if(str.length() == 1){
 6 |         return str;
 7 |     }
 8 |     return str.substr(str.length() - 1).append(reverse_string(str.substr(0,str.length() - 1)));
 9 | }
10 | 
11 | string reverse_string2(string str){
12 |     if(str.size() == 1){
13 |         return str;
14 |     }
15 |     return reverse_string2(str.substr(1,str.size())).append(str.substr(0,1));
16 | }
17 | 
18 | int main(){
19 |     cout<<reverse_string("Zumrudu")<<endl;
20 |     cout<<reverse_string2("Anka");
21 |     return 0;
22 | }


--------------------------------------------------------------------------------
/C++/StacksQueuesDeques/Deque.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | 
  3 | using namespace std;
  4 | 
  5 | class Deque
  6 | {
  7 | private:
  8 |     int* dequee;
  9 |     int item_count;
 10 | public:
 11 |     Deque();
 12 |     void add_front(int item);
 13 |     void add_back(int item);
 14 |     void remove_front();
 15 |     void remove_back();
 16 |     int get_size();
 17 |     int get_item(int index);
 18 |     ~Deque();
 19 | };
 20 | 
 21 | Deque::Deque()
 22 | {
 23 |     this->dequee = nullptr;
 24 |     this->item_count = 0;
 25 | }
 26 | 
 27 | void Deque::add_front(int item){
 28 |     if(this->item_count==0){
 29 |         this->dequee = new int[1];
 30 |         this->dequee[this->item_count++] = item;
 31 |     }
 32 |     else{
 33 |         int* temp = new int[this->item_count];
 34 |         for(int i=0;i<this->item_count;i++){
 35 |             temp[i]=this->dequee[i];
 36 |         }
 37 |         this->dequee = new int[++this->item_count];
 38 |         this->dequee[0]=item;
 39 |         for(int i=1;i<this->item_count;i++){
 40 |             this->dequee[i]=temp[i-1];
 41 |         }
 42 |         delete[] temp;
 43 |     }
 44 | }
 45 | 
 46 | void Deque::add_back(int item){
 47 |     if(this->item_count==0){
 48 |         this->dequee = new int[1];
 49 |         this->dequee[this->item_count++] = item;
 50 |     }
 51 |     else{
 52 |         int* temp = new int[this->item_count];
 53 | 		for (int i = 0; i < this->item_count; i++)
 54 | 		{
 55 | 			temp[i] = this->dequee[i];
 56 | 		}
 57 | 		this->dequee = new int[++this->item_count];
 58 | 		for (int i = 0; i < this->item_count - 1; i++)
 59 | 		{
 60 | 			this->dequee[i] = temp[i];
 61 | 		}
 62 | 		delete[] temp;
 63 | 		this->dequee[this->item_count - 1] = item;
 64 |     }
 65 | }
 66 | 
 67 | void Deque::remove_front(){
 68 |     if(this->item_count!=0){
 69 |         int* temp = new int[--this->item_count];
 70 |         for(int i=0;i<this->item_count;i++){
 71 |             temp[i]=this->dequee[i+1];
 72 |         }
 73 |         this->dequee = new int[this->item_count];
 74 |         for(int i=0;i<this->item_count;i++){
 75 |             this->dequee[i]=temp[i];
 76 |         }
 77 |         delete[] temp;
 78 |     }
 79 |     else{
 80 | 		cout<<endl<<"Deque is empty!"<<endl;
 81 |     }
 82 | }
 83 | 
 84 | void Deque::remove_back(){
 85 |     if(this->item_count!=0){
 86 |         int* temp = new int[--this->item_count];
 87 |         for(int i=0;i<this->item_count;i++){
 88 |             temp[i]=this->dequee[i];
 89 |         }
 90 |         this->dequee = new int[this->item_count];
 91 |         for(int i=0;i<this->item_count;i++){
 92 |             this->dequee[i]=temp[i];
 93 |         }
 94 |         delete[] temp;
 95 |     }
 96 |     else{
 97 | 		cout<<endl<<"Deque is empty!"<<endl;
 98 |     }
 99 | }
100 | 
101 | int Deque::get_item(int index){
102 |     if(this->item_count!=0){
103 |         return this->dequee[index];
104 |     }
105 | }
106 | 
107 | int Deque::get_size(){
108 |     return this->item_count;
109 | }
110 | 
111 | Deque::~Deque()
112 | {
113 |     delete[] this->dequee;
114 | }
115 | 
116 | void print(Deque &deq){
117 |     cout<<endl<<"--"<<endl;
118 |     for(int i=0;i<deq.get_size();i++){
119 |         cout<<deq.get_item(i)<<endl;
120 |     }
121 | }
122 | 
123 | int main(){
124 |     Deque new_deq;
125 |     cout<<endl<<new_deq.get_size()<<endl;
126 |     new_deq.remove_back();
127 |     new_deq.remove_front();
128 |     new_deq.add_back(1);
129 |     new_deq.add_back(7);
130 |     new_deq.add_back(5);
131 |     new_deq.add_back(3);
132 |     print(new_deq);
133 |     new_deq.add_front(13);
134 |     new_deq.add_front(41);
135 |     print(new_deq);
136 |     new_deq.remove_back();
137 |     new_deq.remove_back();
138 |     print(new_deq);
139 |     new_deq.remove_front();
140 |     print(new_deq);
141 |     new_deq.remove_front();
142 |     print(new_deq);
143 | 
144 |     return 0;
145 | }


--------------------------------------------------------------------------------
/C++/StacksQueuesDeques/DequeWithTemplates.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | 
  3 | using namespace std;
  4 | 
  5 | template <class T>
  6 | class Deque
  7 | {
  8 | private:
  9 |     T* dequee;
 10 |     int item_count;
 11 | public:
 12 |     Deque();
 13 |     void add_front(T item);
 14 |     void add_back(T item);
 15 |     void remove_front();
 16 |     void remove_back();
 17 |     int get_size();
 18 |     T get_item(int index);
 19 |     ~Deque();
 20 | };
 21 | 
 22 | template <class T>
 23 | Deque<T>::Deque()
 24 | {
 25 |     this->dequee = nullptr;
 26 |     this->item_count = 0;
 27 | }
 28 | 
 29 | template <class T>
 30 | void Deque<T>::add_front(T item){
 31 |     if(this->item_count==0){
 32 |         this->dequee = new T[1];
 33 |         this->dequee[this->item_count++] = item;
 34 |     }
 35 |     else{
 36 |         T* temp = new T[this->item_count];
 37 |         for(int i=0;i<this->item_count;i++){
 38 |             temp[i]=this->dequee[i];
 39 |         }
 40 |         this->dequee = new T[++this->item_count];
 41 |         this->dequee[0]=item;
 42 |         for(int i=1;i<this->item_count;i++){
 43 |             this->dequee[i]=temp[i-1];
 44 |         }
 45 |         delete[] temp;
 46 |     }
 47 | }
 48 | 
 49 | template <class T>
 50 | void Deque<T>::add_back(T item){
 51 |     if(this->item_count==0){
 52 |         this->dequee = new T[1];
 53 |         this->dequee[this->item_count++] = item;
 54 |     }
 55 |     else{
 56 |         T* temp = new T[this->item_count];
 57 | 		for (int i = 0; i < this->item_count; i++)
 58 | 		{
 59 | 			temp[i] = this->dequee[i];
 60 | 		}
 61 | 		this->dequee = new T[++this->item_count];
 62 | 		for (int i = 0; i < this->item_count - 1; i++)
 63 | 		{
 64 | 			this->dequee[i] = temp[i];
 65 | 		}
 66 | 		delete[] temp;
 67 | 		this->dequee[this->item_count - 1] = item;
 68 |     }
 69 | }
 70 | 
 71 | template <class T>
 72 | void Deque<T>::remove_front(){
 73 |     if(this->item_count!=0){
 74 |         T* temp = new T[--this->item_count];
 75 |         for(int i=0;i<this->item_count;i++){
 76 |             temp[i]=this->dequee[i+1];
 77 |         }
 78 |         this->dequee = new T[this->item_count];
 79 |         for(int i=0;i<this->item_count;i++){
 80 |             this->dequee[i]=temp[i];
 81 |         }
 82 |         delete[] temp;
 83 |     }
 84 |     else{
 85 | 		cout<<endl<<"Deque is empty!"<<endl;
 86 |     }
 87 | }
 88 | 
 89 | template <class T>
 90 | void Deque<T>::remove_back(){
 91 |     if(this->item_count!=0){
 92 |         T* temp = new T[--this->item_count];
 93 |         for(int i=0;i<this->item_count;i++){
 94 |             temp[i]=this->dequee[i];
 95 |         }
 96 |         this->dequee = new T[this->item_count];
 97 |         for(int i=0;i<this->item_count;i++){
 98 |             this->dequee[i]=temp[i];
 99 |         }
100 |         delete[] temp;
101 |     }
102 |     else{
103 | 		cout<<endl<<"Deque is empty!"<<endl;
104 |     }
105 | }
106 | 
107 | template <class T>
108 | T Deque<T>::get_item(int index){
109 |     if(this->item_count!=0){
110 |         return this->dequee[index];
111 |     }
112 | }
113 | 
114 | template <class T>
115 | int Deque<T>::get_size(){
116 |     return this->item_count;
117 | }
118 | 
119 | template <class T>
120 | Deque<T>::~Deque()
121 | {
122 |     delete[] this->dequee;
123 | }
124 | 
125 | template <class T>
126 | void print(Deque<T> &deq){
127 |     cout<<endl<<"--"<<endl;
128 |     for(int i=0;i<deq.get_size();i++){
129 |         cout<<deq.get_item(i)<<endl;
130 |     }
131 | }
132 | 
133 | int main(){
134 |     Deque<int> new_deq;
135 |     cout<<endl<<new_deq.get_size()<<endl;
136 |     new_deq.remove_back();
137 |     new_deq.remove_front();
138 |     new_deq.add_back(1);
139 |     new_deq.add_back(7);
140 |     new_deq.add_back(5);
141 |     new_deq.add_back(3);
142 |     print(new_deq);
143 |     new_deq.add_front(13);
144 |     new_deq.add_front(41);
145 |     print(new_deq);
146 |     new_deq.remove_back();
147 |     new_deq.remove_back();
148 |     print(new_deq);
149 |     new_deq.remove_front();
150 |     print(new_deq);
151 |     new_deq.remove_front();
152 |     print(new_deq);
153 | 
154 |     Deque<char> new_deq2;
155 |     cout<<endl<<new_deq2.get_size()<<endl;
156 |     new_deq2.remove_back();
157 |     new_deq2.remove_front();
158 |     new_deq2.add_back('a');
159 |     new_deq2.add_back('c');
160 |     new_deq2.add_back('e');
161 |     new_deq2.add_back('b');
162 |     print(new_deq2);
163 |     new_deq2.add_front('z');
164 |     new_deq2.add_front('k');
165 |     print(new_deq2);
166 |     new_deq2.remove_back();
167 |     new_deq2.remove_back();
168 |     print(new_deq2);
169 |     new_deq2.remove_front();
170 |     print(new_deq2);
171 |     new_deq2.remove_front();
172 |     print(new_deq2);
173 | 
174 |     return 0;
175 | }


--------------------------------------------------------------------------------
/C++/StacksQueuesDeques/Queue.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | 
  3 | using namespace std;
  4 | 
  5 | class Queue
  6 | {
  7 | private:
  8 |     int* queuee;
  9 |     int item_count;
 10 | public:
 11 |     Queue(/* args */);
 12 |     void push(int item);
 13 |     void pop();
 14 |     int get_size();
 15 |     int get_item(int index);
 16 |     ~Queue();
 17 | };
 18 | 
 19 | Queue::Queue(/* args */)
 20 | {
 21 |     this->queuee = nullptr;
 22 |     this->item_count = 0;
 23 | }
 24 | 
 25 | void Queue::push(int item){
 26 |     if(this->item_count == 0){
 27 |         this->queuee = new int[1];
 28 |         queuee[this->item_count++] = item;
 29 |     }
 30 |     else{
 31 |         int* temp = new int[this->item_count];
 32 |         for(int i=0;i<this->item_count;i++){
 33 |             temp[i]=this->queuee[i];
 34 |         }
 35 |         this->queuee = new int[++this->item_count];
 36 |         this->queuee[0]=item;
 37 |         for(int i=1;i<this->item_count;i++){
 38 |             this->queuee[i]=temp[i-1];
 39 |         }
 40 |     }
 41 | }
 42 | 
 43 | void Queue::pop(){
 44 |     if (this->item_count != 0)
 45 | 	{
 46 | 		if(--this->item_count == 0){
 47 | 			delete[] this->queuee;
 48 | 			this->queuee = nullptr;
 49 | 		}
 50 | 		else{
 51 | 			int* temp = new int[this->item_count];
 52 | 			for (int i = 0; i < item_count; i++)
 53 | 			{
 54 | 				temp[i]=this->queuee[i];
 55 | 			}
 56 | 			this->queuee=new int[this->item_count];
 57 | 			for (int i = 0; i < item_count; i++)
 58 | 			{
 59 | 				this->queuee[i]=temp[i];
 60 | 			}
 61 | 			delete[] temp;
 62 | 		}
 63 | 	}
 64 | 	else{
 65 | 		cout<<endl<<"Queue is empty!"<<endl;
 66 | 	}
 67 | }
 68 | 
 69 | int Queue::get_item(int index){
 70 |     if(this->item_count!=0){
 71 |         return this->queuee[index];
 72 |     }
 73 | }
 74 | 
 75 | int Queue::get_size(){
 76 |     return this->item_count;
 77 | }
 78 | 
 79 | Queue::~Queue()
 80 | {
 81 |     delete[] this->queuee;
 82 | }
 83 | 
 84 | int main(){
 85 |     Queue new_queue;
 86 |     cout<<endl<<"Size: "<<new_queue.get_size()<<endl;
 87 |     new_queue.pop();
 88 |     new_queue.push(1);
 89 |     new_queue.push(3);
 90 |     new_queue.push(7);
 91 |     new_queue.push(2);
 92 |     cout<<endl<<"Size: "<<new_queue.get_size()<<endl;
 93 |     cout<<endl<<new_queue.get_item(0)<<endl;
 94 |     cout<<endl<<new_queue.get_item(3)<<endl;
 95 |     new_queue.pop();
 96 |     cout<<endl<<new_queue.get_item(0)<<endl;
 97 |     cout<<endl<<new_queue.get_item(2)<<endl;
 98 |     new_queue.pop();
 99 |     new_queue.push(5);
100 |     cout<<endl<<"Size: "<<new_queue.get_size()<<endl;
101 |     cout<<endl<<new_queue.get_item(0)<<endl;
102 |     cout<<endl<<new_queue.get_item(2)<<endl;
103 |     new_queue.pop();
104 |     new_queue.pop();
105 |     new_queue.pop();
106 | 	
107 |     return 0;
108 | }


--------------------------------------------------------------------------------
/C++/StacksQueuesDeques/QueueWithTemplates.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | 
  3 | using namespace std;
  4 | 
  5 | template <class T>
  6 | class Queue
  7 | {
  8 | private:
  9 |     T* queuee;
 10 |     int item_count;
 11 | public:
 12 |     Queue(/* args */);
 13 |     void push(T item);
 14 |     void pop();
 15 |     int get_size();
 16 |     T get_item(int index);
 17 |     ~Queue();
 18 | };
 19 | 
 20 | template <class T>
 21 | Queue<T>::Queue(/* args */)
 22 | {
 23 |     this->queuee = nullptr;
 24 |     this->item_count = 0;
 25 | }
 26 | 
 27 | template <class T>
 28 | void Queue<T>::push(T item){
 29 |     if(this->item_count == 0){
 30 |         this->queuee = new T[1];
 31 |         queuee[this->item_count++] = item;
 32 |     }
 33 |     else{
 34 |         T* temp = new T[this->item_count];
 35 |         for(int i=0;i<this->item_count;i++){
 36 |             temp[i]=this->queuee[i];
 37 |         }
 38 |         this->queuee = new T[++this->item_count];
 39 |         this->queuee[0]=item;
 40 |         for(int i=1;i<this->item_count;i++){
 41 |             this->queuee[i]=temp[i-1];
 42 |         }
 43 |     }
 44 | }
 45 | 
 46 | template <class T>
 47 | void Queue<T>::pop(){
 48 |     if (this->item_count != 0)
 49 | 	{
 50 | 		if(--this->item_count == 0){
 51 | 			delete[] this->queuee;
 52 | 			this->queuee = nullptr;
 53 | 		}
 54 | 		else{
 55 | 			T* temp = new T[this->item_count];
 56 | 			for (int i = 0; i < item_count; i++)
 57 | 			{
 58 | 				temp[i]=this->queuee[i];
 59 | 			}
 60 | 			this->queuee=new T[this->item_count];
 61 | 			for (int i = 0; i < item_count; i++)
 62 | 			{
 63 | 				this->queuee[i]=temp[i];
 64 | 			}
 65 | 			delete[] temp;
 66 | 		}
 67 | 	}
 68 | 	else{
 69 | 		cout<<endl<<"Queue is empty!"<<endl;
 70 | 	}
 71 | }
 72 | 
 73 | template <class T>
 74 | T Queue<T>::get_item(int index){
 75 |     if(this->item_count!=0){
 76 |         return this->queuee[index];
 77 |     }
 78 | }
 79 | 
 80 | template <class T>
 81 | int Queue<T>::get_size(){
 82 |     return this->item_count;
 83 | }
 84 | 
 85 | template <class T>
 86 | Queue<T>::~Queue()
 87 | {
 88 |     delete[] this->queuee;
 89 | }
 90 | 
 91 | int main(){
 92 |     Queue<int> new_queue;
 93 |     cout<<endl<<"Size: "<<new_queue.get_size()<<endl;
 94 |     new_queue.pop();
 95 |     new_queue.push(1);
 96 |     new_queue.push(3);
 97 |     new_queue.push(7);
 98 |     new_queue.push(2);
 99 |     cout<<endl<<"Size: "<<new_queue.get_size()<<endl;
100 |     cout<<endl<<new_queue.get_item(0)<<endl;
101 |     cout<<endl<<new_queue.get_item(3)<<endl;
102 |     new_queue.pop();
103 |     cout<<endl<<new_queue.get_item(0)<<endl;
104 |     cout<<endl<<new_queue.get_item(2)<<endl;
105 |     new_queue.pop();
106 |     new_queue.push(5);
107 |     cout<<endl<<"Size: "<<new_queue.get_size()<<endl;
108 |     cout<<endl<<new_queue.get_item(0)<<endl;
109 |     cout<<endl<<new_queue.get_item(2)<<endl;
110 |     new_queue.pop();
111 |     new_queue.pop();
112 |     new_queue.pop();
113 | 	
114 |     return 0;
115 | }


--------------------------------------------------------------------------------
/C++/StacksQueuesDeques/Stack.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <iterator>
  3 | using namespace std;
  4 | 
  5 | class Stack{
  6 | 	private:
  7 | 		int* stack_list;
  8 | 		int item_count;
  9 | 	public:
 10 | 		Stack();
 11 | 		int top();
 12 | 		void push(int item);
 13 | 		void pop();
 14 | 		int size();
 15 | 		int get_item(int index);
 16 | 		~Stack();
 17 | };
 18 | 
 19 | Stack::Stack(){
 20 | 	this->stack_list = nullptr;
 21 | 	this->item_count = 0;
 22 | }
 23 | 
 24 | int Stack::top(){
 25 | 	if(this->item_count!=0){
 26 | 		return this->stack_list[this->item_count-1];
 27 | 	}
 28 | 	//	must use try catch
 29 | }
 30 | 
 31 | int Stack::get_item(int index){
 32 | 	if(this->item_count!=0){
 33 | 		return this->stack_list[index];
 34 | 	}
 35 | }
 36 | 
 37 | void Stack::push(int item){
 38 | 	if(this->item_count == 0){
 39 | 		this->stack_list = new int[++this->item_count];
 40 | 		this->stack_list[0] = item;
 41 | 	}
 42 | 	else{
 43 | 		int* temp = new int[this->item_count];
 44 | 		for (int i = 0; i < this->item_count; i++)
 45 | 		{
 46 | 			temp[i] = this->stack_list[i];
 47 | 		}
 48 | 		this->stack_list = new int[++this->item_count];
 49 | 		for (int i = 0; i < this->item_count - 1; i++)
 50 | 		{
 51 | 			this->stack_list[i] = temp[i];
 52 | 		}
 53 | 		delete[] temp;
 54 | 		this->stack_list[this->item_count - 1] = item;
 55 | 	}
 56 | }
 57 | 
 58 | void Stack::pop(){
 59 | 	if (this->item_count != 0)
 60 | 	{
 61 | 		if(--this->item_count == 0){
 62 | 			delete[] this->stack_list;
 63 | 			this->stack_list = nullptr;
 64 | 		}
 65 | 		else{
 66 | 			int* temp = new int[this->item_count];
 67 | 			for (int i = 0; i < item_count; i++)
 68 | 			{
 69 | 				temp[i]=this->stack_list[i];
 70 | 			}
 71 | 			this->stack_list=new int[this->item_count];
 72 | 			for (int i = 0; i < item_count; i++)
 73 | 			{
 74 | 				this->stack_list[i]=temp[i];
 75 | 			}
 76 | 			delete[] temp;
 77 | 		}
 78 | 	}
 79 | 	else{
 80 | 		cout<<endl<<"Stack is empty!"<<endl;
 81 | 	}
 82 | 	
 83 | }
 84 | 
 85 | int Stack::size(){
 86 | 	return this->item_count;
 87 | }
 88 | 
 89 | Stack::~Stack(){
 90 | 	delete[] this->stack_list;
 91 | }
 92 | 
 93 | int main(){
 94 | 	Stack new_stack;
 95 | 	cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
 96 | 	new_stack.pop();
 97 | 	new_stack.push(1);
 98 | 	new_stack.push(2);
 99 | 	new_stack.push(5);
100 | 	new_stack.push(9);
101 | 	new_stack.push(3);
102 | 	cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
103 | 	cout<<endl<<"Top Element: "<<new_stack.top()<<endl;
104 | 	new_stack.pop();
105 | 	cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
106 | 	cout<<endl<<"Top Element: "<<new_stack.top()<<endl;
107 | 	new_stack.pop();cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
108 | 	cout<<endl<<"Top Element: "<<new_stack.top()<<endl;
109 | 	new_stack.pop();
110 | 	cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
111 | 	cout<<endl<<"Top Element: "<<new_stack.top()<<endl;
112 | 	new_stack.pop();
113 | 	cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
114 | 	cout<<endl<<"Top Element: "<<new_stack.top()<<endl;
115 | 	new_stack.pop();
116 | 	cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
117 | 	cout<<endl<<"Top Element: "<<new_stack.top()<<endl;
118 | 	new_stack.pop();
119 | 	new_stack.push(7);
120 | 	cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
121 | 	cout<<endl<<"Top Element: "<<new_stack.top()<<endl;
122 | 	return 0;
123 | }
124 | 


--------------------------------------------------------------------------------
/C++/StacksQueuesDeques/StackWithTemplates.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <iterator>
  3 | using namespace std;
  4 | 
  5 | template <class T>
  6 | class Stack{
  7 | 	private:
  8 | 		T* stack_list;
  9 | 		int item_count;
 10 | 	public:
 11 | 		Stack();
 12 | 		T top();
 13 | 		void push(T item);
 14 | 		void pop();
 15 | 		int size();
 16 | 		T get_item(int index);
 17 | 		~Stack();
 18 | };
 19 | 
 20 | template <class T>
 21 | Stack<T>::Stack(){
 22 | 	this->stack_list = nullptr;
 23 | 	this->item_count = 0;
 24 | }
 25 | 
 26 | template <class T>
 27 | T Stack<T>::top(){
 28 | 	if(this->item_count!=0){
 29 | 		return this->stack_list[this->item_count-1];
 30 | 	}
 31 | 	//	must use try catch
 32 | }
 33 | 
 34 | template <class T>
 35 | T Stack<T>::get_item(int index){
 36 | 	if(this->item_count!=0){
 37 | 		return this->stack_list[index];
 38 | 	}
 39 | }
 40 | 
 41 | template <class T>
 42 | void Stack<T>::push(T item){
 43 | 	if(this->item_count == 0){
 44 | 		this->stack_list = new T[++this->item_count];
 45 | 		this->stack_list[0] = item;
 46 | 	}
 47 | 	else{
 48 | 		T* temp = new T[this->item_count];
 49 | 		for (int i = 0; i < this->item_count; i++)
 50 | 		{
 51 | 			temp[i] = this->stack_list[i];
 52 | 		}
 53 | 		this->stack_list = new T[++this->item_count];
 54 | 		for (int i = 0; i < this->item_count - 1; i++)
 55 | 		{
 56 | 			this->stack_list[i] = temp[i];
 57 | 		}
 58 | 		delete[] temp;
 59 | 		this->stack_list[this->item_count - 1] = item;
 60 | 	}
 61 | }
 62 | 
 63 | template <class T>
 64 | void Stack<T>::pop(){
 65 | 	if (this->item_count != 0)
 66 | 	{
 67 | 		if(--this->item_count == 0){
 68 | 			delete[] this->stack_list;
 69 | 			this->stack_list = nullptr;
 70 | 		}
 71 | 		else{
 72 | 			T* temp = new T[this->item_count];
 73 | 			for (int i = 0; i < item_count; i++)
 74 | 			{
 75 | 				temp[i]=this->stack_list[i];
 76 | 			}
 77 | 			this->stack_list=new T[this->item_count];
 78 | 			for (int i = 0; i < item_count; i++)
 79 | 			{
 80 | 				this->stack_list[i]=temp[i];
 81 | 			}
 82 | 			delete[] temp;
 83 | 		}
 84 | 	}
 85 | 	else{
 86 | 		cout<<endl<<"Stack is empty!"<<endl;
 87 | 	}
 88 | 	
 89 | }
 90 | 
 91 | template <class T>
 92 | int Stack<T>::size(){
 93 | 	return this->item_count;
 94 | }
 95 | 
 96 | template <class T>
 97 | Stack<T>::~Stack(){
 98 | 	delete[] this->stack_list;
 99 | }
100 | 
101 | int main(){
102 | 	Stack<int> new_stack;
103 | 	cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
104 | 	new_stack.pop();
105 | 	new_stack.push(1);
106 | 	new_stack.push(2);
107 | 	new_stack.push(5);
108 | 	new_stack.push(9);
109 | 	new_stack.push(3);
110 | 	cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
111 | 	cout<<endl<<"Top Element: "<<new_stack.top()<<endl;
112 | 	new_stack.pop();
113 | 	cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
114 | 	cout<<endl<<"Top Element: "<<new_stack.top()<<endl;
115 | 	new_stack.pop();cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
116 | 	cout<<endl<<"Top Element: "<<new_stack.top()<<endl;
117 | 	new_stack.pop();
118 | 	cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
119 | 	cout<<endl<<"Top Element: "<<new_stack.top()<<endl;
120 | 	new_stack.pop();
121 | 	cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
122 | 	cout<<endl<<"Top Element: "<<new_stack.top()<<endl;
123 | 	new_stack.pop();
124 | 	cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
125 | 	cout<<endl<<"Top Element: "<<new_stack.top()<<endl;
126 | 	new_stack.pop();
127 | 	new_stack.push(7);
128 | 	cout<<endl<<"Stack Size: "<<new_stack.size()<<endl;
129 | 	cout<<endl<<"Top Element: "<<new_stack.top()<<endl;
130 | 	return 0;
131 | }
132 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 Osman Durdağ
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Python/Arrays/DynamicArrays.py:
--------------------------------------------------------------------------------
 1 | import ctypes # for the create array
 2 | 
 3 | class DynamicArray(object):
 4 | 
 5 |     #initialize(constructor)
 6 |     def __init__(self):
 7 |         self.n = 0          #array element count
 8 |         self.capacity = 1   #array capacity
 9 |         self.arr = self.make_array(self.capacity)
10 |     
11 |     def __len__(self):
12 |         return self.n
13 |     
14 |     def __getitem__(self,index):
15 |         if self.n > index >= 0:
16 |             return self.arr[index]
17 |         else:
18 |             return IndexError("index is out of bounds!")
19 |         
20 |     def append(self,element):
21 |         if self.n == self.capacity:
22 |             self._resize(self.capacity + 1)
23 |             #self._resize(2 * self.capacity)
24 |         self.arr[self.n] = element
25 |         self.n += 1     #increase element count
26 |     
27 |     def _resize(self,new_capacity):
28 | 
29 |         new_arr = self.make_array(new_capacity)     #create new array
30 |         
31 |         #move old array to new array
32 |         for i in range(self.n):
33 |             new_arr[i] = self.arr[i]
34 | 
35 |         self.arr = new_arr
36 |         self.capacity = new_capacity
37 |     
38 |     def make_array(self,new_capacity):
39 |         return (new_capacity*ctypes.py_object)()
40 | 
41 | arr = DynamicArray()
42 | arr.append(1)
43 | arr.append(3)
44 | arr.append(5)
45 | arr.append(9)
46 | arr.append(2)
47 | for i in range(arr.n):
48 |     print(arr[i])
49 | 
50 | 
51 | 


--------------------------------------------------------------------------------
/Python/Arrays/WordSplit.py:
--------------------------------------------------------------------------------
 1 | def word_split(words):
 2 |     words_in_second_param = words[1].split(",")
 3 |     output = []
 4 |     for i in range(len(words[0])-1):
 5 |         if words[0][:i+1] in words_in_second_param and words[0][i+1:] in words_in_second_param:
 6 |             output.append(words[0][:i+1])
 7 |             output.append(words[0][i+1:])
 8 |     if output == []:
 9 |         return "Bulunamadi"
10 |     return output
11 | 
12 |     #   Alternative Solution
13 |     # word = list(words[0])
14 |     # words_in_second_param = words[1].split(",")
15 |     # for i in range(1,len(word)):
16 |     #     temp = word[:]
17 |     #     temp.insert(i," ")
18 |     #     x , y = "".join(temp).split()
19 |     #     if x in words_in_second_param and y in words_in_second_param:
20 |     #         return x + " , " + y
21 |     # return "Bulunamadi"
22 | 
23 | print(word_split(["deeplearning","d,dll,a,deep,dee,base,lear,learning"]))


--------------------------------------------------------------------------------
/Python/BinaryTrees/BinaryTree.py:
--------------------------------------------------------------------------------
1 | from Node import Node
2 | 
3 | root = Node("A")
4 | root.left = Node("B")
5 | root.left.left = Node("D")
6 | root.right = Node("C")
7 | 


--------------------------------------------------------------------------------
/Python/BinaryTrees/Node.py:
--------------------------------------------------------------------------------
 1 | class Node():
 2 |     """
 3 |         Binary Tree Nodes
 4 |     """
 5 |     def __init__(self, data):
 6 |         """
 7 |             constructor
 8 |         """
 9 |         self.value = data
10 |         self.left = None
11 |         self.right = None
12 | 


--------------------------------------------------------------------------------
/Python/BinaryTrees/__pycache__/Node.cpython-38.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/Python/BinaryTrees/__pycache__/Node.cpython-38.pyc


--------------------------------------------------------------------------------
/Python/LinkedLists/DoublyLinkedList/DoublyLinkedList.py:
--------------------------------------------------------------------------------
  1 | from Node import Node
  2 | 
  3 | class DoublyLinkedList():
  4 | 
  5 |     def __init__(self):
  6 |         self.head = None
  7 | 
  8 |     def push(self, data):
  9 |         if self.head:
 10 |             new_node = Node(data)
 11 |             new_node.nextnode = self.head
 12 |             self.head.prevnode = new_node
 13 |             self.head = new_node
 14 |         else:
 15 |             new_node = Node(data)
 16 |             self.head = new_node
 17 | 
 18 |     def append(self, data):
 19 |         if self.head:
 20 |             temp = self.head
 21 |             while temp.nextnode:
 22 |                 temp = temp.nextnode
 23 |             new_node = Node(data)
 24 |             temp.nextnode = new_node
 25 |             new_node.prevnode = temp
 26 |         else:
 27 |             new_node = Node(data)
 28 |             self.head = new_node
 29 | 
 30 |     def insert_after(self, prev_data, data):
 31 |         if self.head:
 32 |             temp = self.head
 33 |             while temp and temp.getNodeValue() != prev_data:
 34 |                 temp = temp.nextnode
 35 |             if temp:
 36 |                 new_node = Node(data)
 37 |                 new_node.nextnode = temp.nextnode
 38 |                 temp.nextnode = new_node
 39 |                 new_node.prevnode = temp
 40 |                 if new_node.nextnode:
 41 |                     new_node.nextnode.prevnode = new_node
 42 |             else:
 43 |                 print("Listede Boyle Bir Eleman Yok!")
 44 |         else:
 45 |             print("Listede Boyle Bir Eleman Yok!")
 46 | 
 47 |     def delete(self,data):
 48 |         if self.head:
 49 |             temp = self.head
 50 |             while temp and temp.getNodeValue() != data:
 51 |                 temp = temp.nextnode
 52 |             if temp:
 53 |                 if temp == self.head:
 54 |                     if temp.nextnode:
 55 |                         temp.nextnode.prevnode = None
 56 |                         self.head = temp.nextnode
 57 |                         temp = None
 58 |                     else:
 59 |                         self.head = None
 60 |                 else:
 61 |                     temp.prevnode.nextnode = temp.nextnode
 62 |                     if temp.nextnode:
 63 |                         temp.nextnode.prevnode = temp.prevnode
 64 |                     temp = None
 65 |             else:
 66 |                 print("Listede Boyle Bir Eleman Yok!")
 67 |         else:
 68 |             print("Listede Eleman Yok!")
 69 | 
 70 |     def print_list(self):
 71 |         if self.head:
 72 |             temp = self.head
 73 |             while temp:
 74 |                 print(temp.data)
 75 |                 temp = temp.nextnode
 76 |         else:
 77 |             print("Listede Eleman Yok!")
 78 | 
 79 | linked_list = DoublyLinkedList()
 80 | linked_list.push(14)
 81 | linked_list.push(3)
 82 | linked_list.push(5)
 83 | linked_list.push(17)
 84 | linked_list.print_list()
 85 | linked_list.append(12)
 86 | linked_list.append(77)
 87 | linked_list.append(91)
 88 | linked_list.print_list()
 89 | linked_list.insert_after(77,15)
 90 | linked_list.insert_after(3,13)
 91 | linked_list.insert_after(91,68)
 92 | linked_list.insert_after(68,69)
 93 | linked_list.insert_after(17,1)
 94 | linked_list.insert_after(19,12)
 95 | linked_list.print_list()
 96 | print("--------------------")
 97 | linked_list.delete(999)
 98 | linked_list.delete(77)
 99 | linked_list.delete(68)
100 | linked_list.delete(5)
101 | linked_list.delete(69)
102 | linked_list.delete(91)
103 | linked_list.delete(17)
104 | linked_list.append(91)
105 | 
106 | linked_list.print_list()


--------------------------------------------------------------------------------
/Python/LinkedLists/DoublyLinkedList/Node.py:
--------------------------------------------------------------------------------
 1 | class Node():
 2 | 
 3 |     def __init__(self, data):
 4 |         self.data = data
 5 |         self.nextnode = None
 6 |         self.prevnode = None
 7 | 
 8 |     def setNextNode(self,node):
 9 |         self.nextnode = node
10 |     
11 |     def setPrevNode(self,node):
12 |         self.prevnode = node
13 | 
14 |     def getNextNode(self):
15 |         return self.nextnode
16 |     
17 |     def getPrevNode(self):
18 |         return self.prevnode
19 | 
20 |     def getNodeValue(self):
21 |         return self.data
22 | 


--------------------------------------------------------------------------------
/Python/LinkedLists/DoublyLinkedList/__pycache__/Node.cpython-37.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/Python/LinkedLists/DoublyLinkedList/__pycache__/Node.cpython-37.pyc


--------------------------------------------------------------------------------
/Python/LinkedLists/SinglyLinkedList/Node.py:
--------------------------------------------------------------------------------
 1 | class Node():
 2 | 
 3 |     def __init__(self, data):
 4 |         self.data = data
 5 |         self.nextnode = None
 6 | 
 7 |     def setNextNode(self,node):
 8 |         self.nextnode = node
 9 |     
10 |     def getNextNode(self):
11 |         return self.nextnode
12 |     
13 |     def getNodeValue(self):
14 |         return self.data
15 | 


--------------------------------------------------------------------------------
/Python/LinkedLists/SinglyLinkedList/SinglyLinkedList.py:
--------------------------------------------------------------------------------
 1 | from Node import Node
 2 | 
 3 | class SinglyLinkedList():
 4 | 
 5 |     def __init__(self):
 6 |         self.head = None
 7 |     
 8 |     def push(self, data):
 9 | 
10 |         new_node = Node(data)
11 |         new_node.nextnode = self.head
12 |         self.head = new_node
13 |     
14 |     def insert_after(self,prev_node,data):
15 |         new_node = Node(data)
16 |         temp = self.head
17 |         while temp:
18 |             if(temp.getNodeValue() == prev_node):
19 |                 prev_node = temp
20 |                 break
21 |             temp = temp.nextnode
22 |         if not temp:
23 |             print("Boyle bir dugum yok")
24 |         else:
25 |             new_node.nextnode = prev_node.nextnode
26 |             prev_node.nextnode = new_node
27 | 
28 |     def append(self,data):
29 |         if self.head:
30 |             new_node = Node(data)
31 |             temp = self.head
32 |             while temp.nextnode:
33 |                 temp = temp.nextnode
34 |             temp.nextnode = new_node
35 |         else:
36 |             self.push(data)
37 |     
38 |     def delete_node(self,data):
39 |         if self.head:
40 |             temp = self.head
41 |             if self.head.getNodeValue() == data:
42 |                 self.head = temp.nextnode
43 |                 temp = None
44 |             else:
45 |                 temp = self.head
46 |                 while temp.nextnode:
47 |                     if temp.nextnode.getNodeValue() == data:
48 |                         break
49 |                     temp = temp.nextnode
50 |                 del_node = temp.nextnode
51 |                 temp.nextnode = del_node.nextnode
52 |                 del_node = None
53 |         else:
54 |             print("Liste Bos")
55 | 
56 |     def printLinkedList(self):
57 |         temp = self.head
58 |         while temp:
59 |             print(temp.data)
60 |             temp = temp.nextnode
61 | 
62 | linked_list = SinglyLinkedList()
63 | linked_list.append(27)
64 | linked_list.push("tail")
65 | linked_list.push(25)
66 | linked_list.push(10)
67 | linked_list.push("head")
68 | linked_list.insert_after(10,13)
69 | linked_list.insert_after(13,"aga")
70 | linked_list.insert_after(18,"aga")
71 | linked_list.append(33)
72 | linked_list.delete_node(25)
73 | linked_list.delete_node("aga")
74 | linked_list.delete_node("head")
75 | linked_list.delete_node(10)
76 | linked_list.delete_node("tail")
77 | linked_list.push("head")
78 | linked_list.insert_after(33,"tail")
79 | 
80 | linked_list.printLinkedList()
81 | 


--------------------------------------------------------------------------------
/Python/LinkedLists/SinglyLinkedList/__pycache__/Node.cpython-37.pyc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/Python/LinkedLists/SinglyLinkedList/__pycache__/Node.cpython-37.pyc


--------------------------------------------------------------------------------
/Python/Recursion/Pow.py:
--------------------------------------------------------------------------------
 1 | def product(x,y):
 2 |     if x == 1:
 3 |         return y
 4 |     return y + product(x-1,y)
 5 | 
 6 | def product2(x,y):
 7 |     if y == 1:
 8 |         return x
 9 |     return x + product(x,y-1)
10 | 
11 | def my_pow(x,y):
12 |     if y == 1:
13 |         return x
14 |     return product(x, pow(x,y-1))
15 | 
16 | print(my_pow(5,2))


--------------------------------------------------------------------------------
/Python/Recursion/Product.py:
--------------------------------------------------------------------------------
 1 | def product(x,y):
 2 |     if x == 1:
 3 |         return y
 4 |     return y + product(x-1,y)
 5 | 
 6 | def product2(x,y):
 7 |     if y == 1:
 8 |         return x
 9 |     return x + product(x,y-1)
10 | 
11 | print(product(2,3))
12 | print(product2(2,3))
13 | 


--------------------------------------------------------------------------------
/Python/Recursion/ReverseString.py:
--------------------------------------------------------------------------------
 1 | def reverse_string(string):
 2 |     if len(string) == 1:
 3 |         return string
 4 |     return string[len(string)-1] + reverse_string(string[:(len(string)-1)])
 5 | 
 6 | def reverse_string2(string):
 7 |     if len(string) == 1:
 8 |         return string
 9 |     return reverse_string2(string[1:]) + string[0]
10 | 
11 | print(reverse_string("Zumrudu"))
12 | print(reverse_string2("Anka"))
13 | 


--------------------------------------------------------------------------------
/Python/StacksQueuesDeques/Deques.py:
--------------------------------------------------------------------------------
 1 | class Deque():
 2 |     def __init__(self):
 3 |         self.items = []
 4 | 
 5 |     def add_rear(self,item):
 6 |         self.items.append(item)
 7 |     
 8 |     def add_front(self,item):
 9 |         self.items.insert(0,item)
10 |     
11 |     def remove_rear(self):
12 |         self.items.pop()
13 |     
14 |     def remove_front(self):
15 |         self.items.pop(0)
16 | 
17 |     def deque_is_empty(self):
18 |         return self.items == []
19 | 
20 |     def size(self):
21 |         return len(self.items)
22 |     
23 |     def get_item(self,index):
24 |         return self.items[index]
25 | 
26 | deque = Deque()
27 | 
28 | print(deque.deque_is_empty())
29 | deque.add_front("deep")
30 | print(deque.get_item(0))
31 | deque.add_front("learning")
32 | print(deque.get_item(0))
33 | print("size: ",deque.size())
34 | deque.remove_front()
35 | print("size: ",deque.size())
36 | deque.remove_rear()
37 | print("size: ",deque.size())
38 | print(deque.deque_is_empty())
39 | 


--------------------------------------------------------------------------------
/Python/StacksQueuesDeques/DequesFromPython.py:
--------------------------------------------------------------------------------
 1 | from collections import deque
 2 | 
 3 | queue = deque(["data","ml","ai"])
 4 | 
 5 | print(queue)
 6 | queue.insert(0,"deep")
 7 | print(queue)
 8 | queue.insert(0,"learning")
 9 | print(queue)
10 | queue.pop()
11 | print(queue)
12 | queue.popleft()
13 | print(queue)
14 | queue.append("ai")
15 | print(queue)
16 | 


--------------------------------------------------------------------------------
/Python/StacksQueuesDeques/Queue.py:
--------------------------------------------------------------------------------
 1 | class Queue():
 2 | 
 3 |     def __init__(self):
 4 |         self.items = []
 5 |     
 6 |     def queue_is_empty(self):
 7 |         return self.items == []
 8 | 
 9 |     def enqueue(self,item):
10 |         self.items.insert(0,item)
11 |     
12 |     def dequeue(self):
13 |         self.items.pop()
14 |     
15 |     def size(self):
16 |         return len(self.items)
17 | 
18 |     def get_item(self,index):
19 |         return self.items[index]
20 |         
21 | queue = Queue()
22 | 
23 | print(queue.queue_is_empty())
24 | queue.enqueue("istanbul")
25 | queue.enqueue("ankara")
26 | print("size: " ,queue.size())
27 | queue.dequeue()
28 | print("size: " ,queue.size())
29 | 


--------------------------------------------------------------------------------
/Python/StacksQueuesDeques/QueueByTwoStack.py:
--------------------------------------------------------------------------------
 1 | class QueueByTwoStack():
 2 |     def __init__(self):
 3 |         self.stack1 = []
 4 |         self.stack2 = []
 5 |     
 6 |     def enqueue(self,item):
 7 |         self.stack1.append(item)
 8 |     
 9 |     def dequeue(self):
10 |         while len(self.stack1) > 0:
11 |             self.stack2.append(self.stack1.pop())
12 |         return self.stack2.pop()
13 | 
14 | queue = QueueByTwoStack()
15 | 
16 | queue.enqueue("1")
17 | queue.enqueue("2")
18 | queue.enqueue("3")
19 | queue.enqueue("5")
20 | queue.enqueue("4")
21 | print(queue.dequeue())
22 | print(queue.dequeue())
23 | queue.enqueue("1")
24 | print(queue.dequeue())
25 | 
26 | 


--------------------------------------------------------------------------------
/Python/StacksQueuesDeques/ReverseStringWithUseStack.py:
--------------------------------------------------------------------------------
 1 | def createStack():
 2 |     stack = []
 3 |     return stack
 4 | 
 5 | def size(stack):
 6 |     pass
 7 | 
 8 | def top(stack):
 9 |     pass
10 | 
11 | def push(stack,item):
12 |     stack.append(item)
13 | 
14 | def pop(stack):
15 |     return stack.pop()
16 | 
17 | def reverse(string):
18 |     l = len(string)
19 |     stack = createStack()
20 |     for i in range(l):
21 |         push(stack, string[i])
22 |     result = ""
23 |     for i in range(l):
24 |         result += pop(stack)
25 |     return result
26 | 
27 | print(reverse("Osman"))


--------------------------------------------------------------------------------
/Python/StacksQueuesDeques/Stack.py:
--------------------------------------------------------------------------------
 1 | class Stack:
 2 |    
 3 |     def __init__(self):
 4 |         self.items = []
 5 |     
 6 |     def stack_is_empty(self):
 7 |         return self.items == []     #return boolean phrase
 8 | 
 9 |     def push(self, item):
10 |         self.items.append(item)
11 |     
12 |     def pop(self):
13 |         return self.items.pop()
14 |     
15 |     def top(self):
16 |         return self.items[len(self.items)-1]
17 |     
18 |     def size(self):
19 |         return len(self.items)
20 | 
21 | stack = Stack()
22 | print(stack.stack_is_empty())
23 | stack.push("ankara")
24 | print(stack.top())
25 | stack.push("istanbul")
26 | print(stack.top())
27 | stack.push("izmir")
28 | print(stack.top())
29 | print(stack.size())
30 | stack.pop()
31 | print(stack.top())
32 | print(stack.stack_is_empty())
33 | stack.pop()
34 | print(stack.top())
35 | print(stack.stack_is_empty())
36 | stack.pop()
37 | print(stack.stack_is_empty())


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ## [Orkhan ALIYEV](https://github.com/aliyevorkhan) arkadaşıma katkılarından dolayı teşekkür ederim.
  2 | 
  3 | ## İçindekiler
  4 | 
  5 | 1. [Veri Yapılarına Genel Bakış](#veri-yapılarına-genel-bakış)
  6 | 1. [Veri Yapısının Özellikleri](#veri-yapısının-özellikleri)
  7 | 1. [Veri Yapısı İhtiyacı](#veri-yapısı-ihtiyacı)
  8 | 1. [Yürütme Süresi Kutuları](#yürütme-süresi-kutuları)
  9 | 1. [Temel Terminoloji](#temel-terminoloji)
 10 | 1. [Veri Yapıları Temelleri](#veri-yapıları-temelleri)
 11 |     1. [Veri Tanımı](#veri-tanımı)
 12 |     1. [Veri Nesnesi](#veri-nesnesi)
 13 |     1. [Veri Tipi](#veri-tipi)
 14 |         1. [Dahili Veri Tipi](#dahili-veri-tipi)
 15 |         1. [Türetilmiş Veri Tipi](#türetilmiş-veri-tipi)
 16 | 1. [Diziler](#diziler)
 17 |     1. [Dizilerde Temel İşlemler](#dizilerde-temel-işlemler)
 18 |         1. [Ekleme İşlemi](#ekleme-işlemi)
 19 |         1. [Silme İşlemi](#silme-işlemi)
 20 |         1. [Arama İşlemi](#arama-işlemi)
 21 |         1. [Güncelleme İşlemi](#güncelleme-işlemi)
 22 | 1. [Listeler](#listeler)
 23 |     1. [Bağlı Liste(Linked List)](#bağlı-liste)
 24 |         1. [Bağlı Liste Türleri](#bağlı-liste-türleri)
 25 |             * [Tek Yönlü Bağlı Liste(Singly Linked List)](#tek-yönlü-bağlı-liste)
 26 |             * [Çift Yönlü Bağlı Liste(Doubly Linked List)](#çift-yönlü-bağlı-liste)
 27 |             * [Dairesel Bağlı Liste(Circular Linked List)](#dairesel-bağlı-liste)
 28 | 1. [Trees(Ağaçlar)](#trees)
 29 |     1. [Binary Trees(İkili Ağaçlar)](#binary-trees)
 30 |         1. [Properties of Binary Trees(İkili Ağaçların Özellikleri)](#properties-of-binary-trees)
 31 |         1. [Types of Binary Trees(İkili Ağaçların Türleri)](#types-of-binary-trees)
 32 |             * [Full Binary Tree](#full-binary-tree)
 33 |             * [Complete Binary Tree](#complete-binary-tree)
 34 |             * [Perfect Binary Tree](#perfect-binary-tree)
 35 |             * [Balanced Binary Tree](#balanced-binary-tree)
 36 | 1. [Kaynakça](#kaynakça)
 37 | 
 38 | ## Veri Yapılarına Genel Bakış
 39 | 
 40 | Veri Yapısı, verileri verimli kullanmak için verileri organize etmenin sistematik bir yoludur. Aşağıdaki terimler bir
 41 | veri yapısının temel terimleridir.
 42 | <ul>
 43 |     <li>
 44 |         <b>Arayüz</b> - Her veri yapısının bir arayüzü vardır. Arayüz bir veri yapısının desteklediği işlem kümesini
 45 |         temsil
 46 |         eder. Bir arabirim yalnızca desteklenen işlemlerin listesini, kabul edebilecekleri parametre türlerini ve bu
 47 |         işlemlerin
 48 |         türünü döndürür.
 49 |     </li>
 50 |     <li><b>Uygulama</b> - Uygulama, bir veri yapısının iç temsilini sağlar. Uygulama ayrıca, veri yapısının
 51 |         işlemlerinde
 52 |         kullanılan algoritmaların tanımını sağlar.
 53 |     </li>
 54 | </ul>
 55 | 
 56 | ## Veri Yapısının Özellikleri
 57 | 
 58 | <ul>
 59 |     <li>
 60 |         <b>Doğruluk</b> - Veri Yapısı uygulaması, arayüzünü doğru şekilde uygulamalıdır.
 61 |     </li>
 62 |     <li>
 63 |         <b>Zaman Karmaşıklığı</b> - Veri yapısı işlemlerinin çalışma süresi veya yürütme süresi mümkün olduğu kadar
 64 |         küçük
 65 |         olmalıdır.
 66 |     </li>
 67 |     <li>
 68 |         <b>Karmaşıklığı</b> - Bir veri yapısı işleminde bellek kullanımı mümkün olduğunca az olmalıdır.
 69 |     </li>
 70 | </ul>
 71 | 
 72 | ## Veri Yapısı İhtiyacı
 73 | 
 74 | Uygulamalar karmaşıklaştıkça ve veri bakımından zenginleştikçe, uygulamaların bugünlerde karşılaştığı üç genel
 75 | sorun var.
 76 | <ul>
 77 |     <li>
 78 |         <b>Veri Arama</b> - Bir mağazanın 1 milyon (10^6) kaleminden oluşan bir envanteri düşünün. Eğer uygulamanın
 79 |         amacı
 80 |         bir öğeyi
 81 |         aramaksa.
 82 |         Aramayı yavaşlatan sebep her seferinde 1 milyon (10^6) maddede arama yapması gerekmesidir. Veriler büyüdükçe
 83 |         arama
 84 |         yavaşlar.
 85 |     </li>
 86 |     <li>
 87 |         <b>İşlemci hızı</b> - İşlemci hızı çok yüksek olabilir fakat, veriler milyarca olduğu takdirde bu işlemci hızı
 88 |         bir
 89 |         işe
 90 |         yaramaz.
 91 |     </li>
 92 |     <li>
 93 |         <b>Birden çok istek</b> - Binlerce kullanıcı bir web sunucusunda aynı anda veri arayabildiğinden, veri ararken
 94 |         çok
 95 |         hızlı
 96 |         sunucu bile başarısız olur.
 97 |     </li>
 98 |     Veri yapıları yukarıdaki problemleri çözmek için bize yardımcı olur. Veriler, veri yapısında tüm öğelerin aranması
 99 |     gerekmeyebilecek ve gerekli veriler neredeyse anında aranabilecek şekilde düzenlenebilir.
100 | 
101 | </ul>
102 | 
103 | ## Yürütme Süresi Kutuları
104 | 
105 | Çeşitli veri yapısının yürütme süresini göreceli bir şekilde karşılaştırmak için kullanılan üç durum vardır.
106 | <ul>
107 |     <li>
108 |         <b>En Kötü Durum</b> - Bu, belirli bir veri yapısı işleminin alabileceği maksimum süreyi aldığı senaryodur. Bir
109 |         işlemin
110 |         en
111 |         kötü durum süresi ƒ (n) ise, bu işlem ƒ (n) 'in n işlevini temsil ettiği ƒ (n) zamandan daha uzun sürmez.
112 |     </li>
113 |     <li>
114 |         <b>Ortalama Durum</b> - Bu, bir veri yapısının işleminin ortalama yürütme zamanını gösteren senaryodur. Bir
115 |         işlem
116 |         yürütme
117 |         sırasında ƒ (n) zaman alırsa, m işlemleri mƒ (n) zaman alır.
118 |     </li>
119 |     <li>
120 |         <b>En İyi Durum</b> - Bu, bir veri yapısının çalışmasının mümkün olan en az yürütme süresini gösteren
121 |         senaryodur.
122 |         Bir
123 |         işlem
124 |         yürütmede ƒ (n) zaman alırsa, gerçek işlem ƒ (n) kadar maksimum olan rasgele sayı olarak zaman alabilir.
125 |     </li>
126 | </ul>
127 | 
128 | ## Temel Terminoloji
129 | 
130 | <ul>
131 |     <li>
132 |         <b>Veri</b> - Veri değer veya değer kümesidir.
133 |     </li>
134 |     <li>
135 |         <b>Veri Öğesi</b> - Veri öğesi, tek bir değer birimini ifade eder.
136 |     </li>
137 |     <li>
138 |         <b>Grup Öğeleri</b> - Alt öğelere ayrılan veri öğesine Grup Öğeleri denir.
139 |     </li>
140 |     <li>
141 |         <b>Temel Öğeler</b> - Bölünemeyen veri öğesi, Temel Öğeler olarak adlandırılır.
142 |     </li>
143 |     <li>
144 |         <b>Nitelik ve Varlık</b> - Varlık, değer atanabilecek belirli nitelikleri veya özellikleri içeren varlıktır.
145 |     </li>
146 |     <li>
147 |         <b>Varlık Kümesi</b> - Benzer özellikteki varlıklar, bir varlık kümesini oluşturur.
148 |     </li>
149 |     <li>
150 |         <b>Alan</b> - Alan, bir işletmenin bir niteliğini temsil eden tek bir temel bilgi birimidir.
151 |     </li>
152 |     <li>
153 |         <b>Kayıt</b> - Kayıt, belirli bir varlığın alan değerlerinin toplamıdır.
154 |     </li>
155 |     <li>
156 |         <b>Dosya</b> - Dosya, belirli bir varlık kümesindeki varlıkların kayıtlarının toplamıdır.
157 |     </li>
158 | </ul>
159 | 
160 | ## Veri Yapıları Temelleri
161 | 
162 | Veri Yapısı, verileri verimli kullanılabilecek şekilde organize etmenin bir yoludur. Bu döküman veri yapısı ile ilgili
163 | temel terimleri açıklamaktadır.
164 | 
165 | ### Veri Tanımı
166 | 
167 | Veri Tanımı, aşağıdaki özelliklere sahip belirli bir veriyi tanımlar.
168 | <ul>
169 |     <li>
170 |         <b>Atomik</b> - Tanım tek bir kavram tanımlamalıdır
171 |     </li>
172 |     <li>
173 |         <b>İzlenebilir</b> - Tanım, bazı veri öğelerine eşlenebilmelidir.
174 |     </li>
175 |     <li>
176 |         <b>Düzgün</b> - Tanım net olmalıdır.
177 |     </li>
178 |     <li>
179 |         <b>Açık ve Özlü</b> - Tanım anlaşılabilir olmalıdır.
180 |     </li>
181 | </ul>
182 | 
183 | ### Veri Nesnesi
184 | 
185 | Veri Nesnesi, verileri olan bir nesneyi temsil eder.
186 | 
187 | ### Veri tipi
188 | 
189 | Veri türü, karşılık gelen veri türüyle kullanılabilecek değerleri, karşılık gelen veri türünde gerçekleştirilebilecek
190 | işlem türlerini belirleyen tam sayı, dizge vb. gibi çeşitli veri türlerini sınıflandırma yoludur. İki tip veri türü -
191 | <ul>
192 |     <li>
193 |         <b>Dahili Veri Tipi</b>
194 |     </li>
195 |     <li>
196 |         <b>Türetilmiş Veri Türü</b>
197 |     </li>
198 | </ul>
199 | 
200 | ### Dahili Veri Tipi
201 | 
202 | Bir dilin yerleşik desteğine sahip olduğu veri türleri, Dahili Veri türleri olarak bilinir. Örneğin, dillerin çoğu
203 | yerleşik veri türlerini takip etmeyi sağlar.
204 | <ul>
205 |     <li>
206 |         <b>Tamsayılar</b>
207 |     </li>
208 |     <li>
209 |         <b>Boole (doğru, yanlış)</b>
210 |     </li>
211 |     <li>
212 |         <b>Yüzer (Ondalık sayılar)</b>
213 |     </li>
214 |     <li>
215 |         <b>Karakter ve Dizeler</b>
216 |     </li>
217 | </ul>
218 | 
219 | ### Türetilmiş Veri Tipi
220 | 
221 | Birinden veya başka bir şekilde uygulanabileceğinden uygulamadan bağımsız olan veri tipleri, türetilmiş veri türleri
222 | olarak bilinir. Bu veri tipleri normalde birincil veya dahili veri tiplerinin ve bunlarla ilişkili işlemlerin
223 | birleşimiyle oluşturulur. Örneğin -
224 | <ul>
225 |     <li>
226 |         <b>Liste</b>
227 |     </li>
228 |     <li>
229 |         <b>Dizi</b>
230 |     </li>
231 |     <li>
232 |         <b>Yığın</b>
233 |     </li>
234 |     <li>
235 |         <b>Kuyruk</b>
236 |     </li>
237 | </ul>
238 | <h3>
239 |     Temel işlemler
240 | </h3>
241 | Veri yapılarındaki veriler belirli işlemlerle işlenir. Seçilen belirli veri yapısı büyük ölçüde veri yapısı üzerinde
242 | yapılması gereken işlemin sıklığına bağlıdır.
243 | <ul>
244 |     <li>
245 |         <b>Traversing(Çaprazlama ilerleme)</b>
246 |     </li>
247 |     <li>
248 |         <b>Searching(Arama)</b>
249 |     </li>
250 |     <li>
251 |         <b>Insertion(Ekleme)</b>
252 |     </li>
253 |     <li>
254 |         <b>Deletion(Silme)</b>
255 |     </li>
256 |     <li>
257 |         <b>Sorting(Sıralama)</b>
258 |     </li>
259 |     <li>
260 |         <b>Merging(Birleştirme)</b>
261 |     </li>
262 | </ul>
263 | 
264 | ## Diziler
265 | 
266 | Dizi, sabit sayıda öğeyi tutabilen bir kaptır ve bu öğeler aynı türden olmalıdır. Veri yapısının çoğu, algoritmalarını
267 | uygulamak için dizi kullanır. Array kavramlarını anlamak için önemli terimler aşağıdadır.
268 | <ul>
269 |     <li>
270 |         <b>Öğe</b> - Dizide depolanan her öğeye öğe adı verilir.
271 |     </li>
272 |     <li>
273 |         <b>Dizin</b> - Bir dizideki bir öğenin her konumu, öğeyi tanımlamak için kullanılan sayısal bir dizine
274 |         sahiptir.
275 |     </li>
276 | </ul>
277 | 
278 | ## Dizi Temsili
279 | 
280 | Diziler, farklı dillerde çeşitli şekillerde açıklanabilir. Örnek olarak, C dizi tanımını ele alalım.
281 | 
282 | <img src="dizi_temsili.png" alt="dizi temsili"/>
283 | <img src="dizi_temsili1.png" alt="dizi temsili 1"/>
284 | 
285 | 
286 | Yukarıdaki resmlere göre, dikkate alınması gereken önemli noktalar aşağıdadır.
287 | <ul>
288 |     <li>
289 |         Diziler 0 ile başlar.
290 |     </li>
291 |     <li>
292 |         Dizi uzunluğu 10'dur, yani 10 öğe saklayabilir.
293 |     </li>
294 |     <li>
295 |         Her elemana indeksi üzerinden erişilebilir.
296 |     </li>
297 | </ul>
298 | 
299 | ## Dizilerde Temel işlemler
300 | 
301 | Bir dizi tarafından desteklenen temel işlemler aşağıdadır.
302 | <ul>
303 |     <li>
304 |         <b>Traverseing(Çaprazlama ilerleme)</b> - tüm dizi öğelerini tek tek yazdırın.
305 |     </li>
306 |     <li>
307 |         <b>Insertion(Ekleme)</b> - Verilen dizine bir öğe ekler.
308 |     </li>
309 |     <li>
310 |         <b>Deletion(Silme)</b> - Belirtilen dizindeki bir öğeyi siler.
311 |     </li>
312 |     <li>
313 |         <b>Searching(Arama)</b> - Verilen dizini kullanarak veya değeri kullanarak bir öğeyi arar.
314 |     </li>
315 |     <li>
316 |         <b>Update(Güncelle)</b> - Verilen dizindeki bir öğeyi günceller.
317 |     </li>
318 | </ul>
319 | C'de, bir dizinin boyutu ile başlatıldığında, öğelerine varsayılan değerleri aşağıdaki sırayla atar.
320 | <img src="veri_tipleri.jpg" alt="veri tipleri"/>
321 | 
322 | 
323 | ### Ekleme işlemi
324 | Ekleme işlemi, bir diziye bir veya daha fazla veri öğesi eklemektir. Gereksinime bağlı olarak, başında, sonunda veya
325 | herhangi bir dizi içerisinde yeni bir öğe eklenebilir.
326 | 
327 | 
328 | ### Silme İşlemi
329 | Silme, var olan bir öğeyi diziden kaldırmayı ve dizinin tüm öğelerini yeniden düzenlemeyi ifade eder.
330 | 
331 | ### Arama İşlemi
332 | Bir dizi öğesini, değerini veya indisini temel alarak arama yapabilirsiniz.
333 | 
334 | ### Güncelleme İşlemi
335 | Güncelleme işlemi, belirli bir indiste varolan bir öğenin güncellenmesi anlamına gelir.
336 | 
337 | ## Listeler
338 | 
339 | ## Bağlı Liste
340 | 
341 | Bağlı bir liste, bağlantılar yoluyla birbirine bağlanmış bir dizi veri yapısıdır.
342 | 
343 | Bağlı Liste, öğeleri içeren bir bağlantılar dizisidir. Her bağlantı başka bir bağlantıya bağlantı içerir. Bağlı
344 | liste, diziden sonraki en çok kullanılan veri yapısıdır. Bağlı Liste kavramını anlamak için önemli terimler
345 | aşağıdadır.
346 | <ul>
347 |     <li>
348 |         <b>Bağlantı</b> - Bağlı listedeki her bağlantı, öğe olarak adlandırılan verileri saklayabilir.
349 |     </li>
350 |     <li>
351 |         <b>Sonraki</b> - Bağlı listedeki her bağlantıda İleri adlı bir sonraki bağlantıya bir bağlantı bulunur.
352 |     </li>
353 |     <li>
354 |         <b>LinkedList</b> - Linked List, First adındaki ilk linke bağlantıyı içerir.
355 |     </li>
356 | </ul>
357 | 
358 | <h3>Bağlı Liste Temsili</h3>
359 | 
360 | Bağlı liste, her düğümün bir sonraki düğüme işaret ettiği bir düğüm zinciri olarak örneklendirilebilir.
361 | <img src="bagli_liste.jpg" alt="veri tipleri"/>
362 | Yukarıdaki resme göre, dikkate alınması gereken önemli noktalar aşağıdadır.
363 | <ul>
364 |     <li>
365 |         Bağlı Liste, önce adı verilen bir bağlantı elemanı içerir.
366 |     </li>
367 |     <li>
368 |         Her bağlantı bir veri alanı ve bir sonraki adı verilen bir bağlantı alanı taşır.
369 |     </li>
370 |     <li>
371 |         Her link bir sonraki linkini kullanarak bir sonraki linke bağlanır.
372 |     </li>
373 |     <li>
374 |         Son bağlantı, listenin sonunu işaretlemek için boş bir bağlantı taşır.
375 |     </li>
376 | </ul>
377 | 
378 | ### Bağlı Liste Türleri
379 | 
380 | Çeşitli Bağlı liste türleri aşağıdadır.
381 | <ul>
382 |     <li>
383 |         <b>Tek Yönlü Bağlı Liste</b> - Öğe gezinme sadece ileri.
384 |     </li>
385 |     <li>
386 |         <b>Çift Yönlü Bağlı Liste</b> - Öğeler ileri ve geri götürebilir.
387 |     </li>
388 |     <li>
389 |         <b>Dairesel Bağlı Liste</b> - Son öğe, bir sonraki gibi ilk öğenin bağlantısını içerir ve ilk öğe, önceki
390 |         gibi
391 |         bir son
392 |         öğenin bağlantısını içerir.
393 |     </li>
394 | </ul>
395 | 
396 | ## Tek Yönlü Bağlı Liste
397 | 
398 | <h3>Temel işlemler</h3>
399 | 
400 | Bir liste tarafından desteklenen temel işlemler aşağıdadır.
401 | <ul>
402 |     <li>
403 |         <b>Ekleme</b> - Listenin başına bir öğe ekler.
404 |     </li>
405 |     <li>
406 |         <b>Silme</b> - Listenin başındaki bir öğeyi siler.
407 |     </li>
408 |     <li>
409 |         <b>Görüntüleme</b> - Listenin tamamını görüntüler.
410 |     <li>
411 |         <b>Arama</b> - Verilen anahtarı kullanarak bir öğeyi arar.
412 |     </li>
413 |     <li>
414 |         <b>Silme</b> - Verilen anahtarı kullanarak bir öğeyi siler.
415 |     </li>
416 | </ul>
417 | 
418 | ## Çift Yönlü Bağlı Liste
419 | 
420 | Çift Yönlü Liste, Tek Yönlü Listeye göre kolayca ileri veya geri gezinmenin her iki yönde de mümkün olduğu
421 | Yönlü listenin bir çeşididir. İkili Yönlü liste kavramını anlamak için önemli terimler aşağıdadır.
422 | <ul>
423 |     <li>
424 |         <b>Bağlantı</b> - Yönlü listedeki her bağlantı, öğe olarak adlandırılan verileri saklayabilir.
425 |     </li>
426 |     <li>
427 |         <b>Sonraki</b> - Yönlü listedeki her bağlantıda İleri adlı bir sonraki bağlantıya bir bağlantı bulunur.
428 |     </li>
429 |     <li>
430 |         <b>Önceki</b> - Bağlanan listedeki her bağlantı, Önceki adlı önceki bağlantıya ait bir bağlantı içerir.
431 |     </li>
432 |     <li>
433 |         <b>LinkedList</b> - Bağlı bir Liste, İlk adı verilen ilk bağlantıya ve Son adı verilen son bağlantıya bağlantı
434 |         bağlantısını
435 |         içerir.
436 |     </li>
437 | </ul>
438 | 
439 | <h3>Çift Yönlü Liste</h3>
440 | 
441 | <img src="cift_yonlu.jpg" alt="cift yonlu"/>
442 | Yukarıdaki resme göre, dikkate alınması gereken önemli noktalar aşağıdadır.
443 | <ul>
444 |     <li>
445 |         Çift Bağlantılı Liste, ilk ve son olarak adlandırılan bir bağlantı öğesi içerir.
446 |     </li>
447 |     <li>
448 |         Her bağlantı bir veri alanı ve sonraki ve prev olarak adlandırılan iki bağlantı alanı taşır.
449 |     </li>
450 |     <li>
451 |         Her link bir sonraki linkini kullanarak bir sonraki linke bağlanır.
452 |     </li>
453 |     <li>
454 |         Her bağlantı önceki bağlantıyı kullanarak önceki bağlantıyı kullanarak bağlanır.
455 |     </li>
456 |     <li>
457 |         Son bağlantı, listenin sonunu işaretlemek için boş bir bağlantı taşır.
458 |     </li>
459 | </ul>
460 | 
461 | <h3>Temel işlemler</h3>
462 | Bir liste tarafından desteklenen temel işlemler aşağıdadır.
463 | <ul>
464 |     <li>
465 |         Ekleme - Listenin başına bir öğe ekler.
466 |     </li>
467 |     <li>
468 |         Silme - Listenin başındaki bir öğeyi siler.
469 |     </li>
470 |     <li>
471 |         Sonuncuyu Ekle - Listenin sonuna bir öğe ekler.
472 |     </li>
473 |     <li>
474 |         Sonuncuyu Sil - Bir öğeyi listenin sonundan siler.
475 |     </li>
476 |     <li>
477 |         Sonra Ekle - Listedeki bir öğenin arkasına bir öğe ekler.
478 |     </li>
479 |     <li>
480 |         Sil - tuşunu kullanarak listeden bir öğe siler.
481 |     </li>
482 |     <li>
483 |         İleri göster - Listenin tamamını ileri şekilde görüntüler.
484 |     </li>
485 |     <li>
486 |         Geriye doğru göster - Listenin tamamını geriye doğru görüntüler.
487 |     </li>
488 | </ul>
489 | 
490 | ## Dairesel Bağlı Liste
491 | 
492 | Dairesel Bağlı Liste, ilk öğenin son öğeye, son öğenin ilk öğeye işaret ettiği Bağlı listenin bir çeşididir.
493 | Hem Tekli Bağlı Liste hem de İkili Bağlı Liste, dairesel bir Bağlı listeye eklenebilir.
494 | 
495 | <h3>Dairesel Olarak Tek Bağlı Liste</h3>
496 | Tek başına bağlı listede, son düğümün bir sonraki göstericisi ilk düğüme işaret eder.
497 | 
498 | <img src="dairesel_bagli_liste.jpg" alt="dairesel bagli liste"/>
499 | <h3>Dairesel Olarak İkili Bağlı Liste</h3>
500 | İkili Bağlı listede, son düğümün bir sonraki göstericisi, ilk düğüme işaret eder ve ilk düğümün bir önceki
501 | göstericisi, her iki yönde de dairesel yapan son düğüme işaret eder.
502 | <img src="dairesel_bagli_liste1.jpg" alt="dairesel bagli liste1"/>
503 | Yukarıdaki resme göre, dikkate alınması gereken önemli noktalar aşağıdadır.
504 | <ul>
505 |     <li>
506 |         Son bağlantının sonraki listesi, hem tek tek hem de iki kat bağlantılı listedeki ilk listeye işaret eder.
507 |     </li>
508 |     <li>
509 |         İkili bağlantı durumunda, ilk bağlantı önceki listenin sonunu gösterir.
510 |     </li>
511 | </ul>
512 | 
513 | <h3>Temel işlemler</h3>
514 | Dairesel bir liste tarafından desteklenen önemli operasyonlar aşağıdadır.
515 | <ul>
516 | <li>
517 |     insert - Listenin başına bir öğe ekler.
518 | </li>
519 | <li>
520 |     delete - Bir öğeyi listenin başından siler.
521 | </li>
522 | <li>
523 |     display - Listeyi görüntüler.
524 | </li>
525 | </ul>
526 | 
527 | ## Trees
528 | 
529 | Ağaçlar; dizilerden, bağlı listelerden, doğrusal veri yapıları olan yığın ve kuyruklardan farklı olarak hiyerarşik veri yapılarıdır. En üstteki düğüme ağacın kökü denir. Bir düğümün altındaki düğümlere o düğümün çocukları denir. Bir düğümün üzerindeki düğüme o düğümün ebeveyni adı verilir. Aşağıdaki örnek için, "A", "F" nin çocuğu ve "F", "A" nın ebeveynidir. Çocuğu olmayan düğümlere ise yaprak adı verilir.
530 | 
531 | <img src="binary_tree_0.png" alt="Binary Tree"/>
532 | 
533 | #### Neden Ağaçlar?
534 | 
535 | * Ağaçları doğal olarak hiyerarşi oluşturan bilgileri depolamak istediğimiz zaman kullanabiliriz. Örneğin, bir bilgisayarlardaki dosya sistemleri.
536 | * Ağaçlar orta düzeyde erişim veya arama sağlar(Bağlı listelerden daha hızlı, dizilerden daha yavaş).
537 | * Ağaçlar orta düzeyde ekleme veya silme sağlar(Dizilerden daha hızlı, sıralı olmayan bağlı listelerden daha yavaş).
538 | * Bağlı listelerdeki gibi ama dizilerden farklı olarak, ağaçların düğümleri işaretçiler kullanılarak bağlandığı için, düğüm sayısında üst sınır yoktur.
539 | 
540 | ### Binary Trees
541 | 
542 | Elemanlarının her birinin en fazla 2 çocuğa sahip olduğu ağaçlara ikili ağaç denir. İkili bir ağaçtaki her düğümün sadece 2 çocuğu olabileceğinden, genellikle bunları sol ve sağ çocuk olarak adlandırırız.
543 | 
544 | #### C Dilinde İkili Ağaç Gösterimi
545 | 
546 | Bir ağaç, ağaçtaki en üst düğüme işaretçi ile temsil edilir. Ağaç boşsa, kök değeri NULL olur.
547 | Bir Ağaç düğümü aşağıdaki bölümleri içerir.
548 | * Veri
549 | * Sol çocuk için işaretçi
550 | * Sağ çocuk için işaretçi
551 | 
552 | #### Properties of Binary Trees
553 | 
554 | <ul>
555 |     <li>
556 |         <b>Bir ikili ağacın 'k' seviyesindeki maksimum düğüm sayısı 2<sup>k-1</sup>'dir.</b> Burada seviye, kökten düğüme giden yoldaki düğüm sayısıdır (kök ve düğüm dahil). Kök seviyesi 1'dir. Örneğin;<br>
557 |         Kök için(k = 1); Düğüm Sayısı = 2<sup>k - 1</sup> = 1 olur.
558 |     </li>
559 |     <li>
560 |         <b>H yüksekliğindeki bir ikili ağaçtaki maksimum toplam düğüm sayısı 2<sup>H</sup> - 1'dir.</b> Burada yükseklik, kökten yaprak yoluna kadar olan yüksekliktir. Tek düğümlü bir ağacın yüksekliği 1 olarak kabul edilir. Tüm seviyelerde maksimum düğüm varsa, o ağaçtaki maksimum düğüm sayısına ulaşılmıştır. Bu nedenle, H yüksekliğinde bir ikili ağaçtaki toplam maksimum düğüm sayısı 1 + 2 + 4 + .. + 2<sup>H-1</sup>'dir.<br>Bu ise H terimli basit bir geometrik seridir ve bu serinin toplamı 2<sup>H</sup> - 1'dir.
561 |     </li>
562 |     <li>
563 |         <b>N düğümlü bir ikili ağaç için mümkün olan minimum yükseklik veya minimum seviye sayısı Log<sub>2</sub> (N + 1)dir.</b>
564 |     </li>
565 |     <li>
566 |         <b>L sayıda yaprağı olan ikili ağaç var olabilir mi? Bunun için Log<sub>2</sub>L + 1 denkleminden faydalanırız.</b>
567 | Bir ikili ağaç, tüm seviyeleri tamamen dolu iken maksimum yaprak sayısına (ve minimum seviye sayısına) sahiptir. Tüm yaprakların L seviyesinde olduğunu düşünerek aşağıdaki eşitliği inceleyelim:<br>
568 |    L <= 2<sup>L-1</sup><br>
569 |    L = Log<sub>2</sub>L + 1  => eşitliği sağlanıyorsa L minimum seviye sayısıdır.
570 |     </li>
571 |     <li>
572 |     <b>Her düğümün 0 veya 2 çocuğunun olduğu bir ikili ağaçta, yaprak düğüm sayısı her zaman iki çocuklu düğümlerin sayısından bir fazladır.</b><br>
573 |    L = Yaprak Düğüm Sayısı<br>T = İki Çocuklu Düğüm Sayısı<br>L = T + 1
574 |     </li>
575 | </ul>
576 | 
577 | #### Types of Binary Trees
578 | 
579 | <ul>
580 |     <li>
581 |         <b id="full-binary-tree">Full Binary Tree</b> - Her düğümünün 0 veya 2 çocuğunun olduğu ağaçlar Full Binary Tree(Tam İkili Ağaç) olarak adlandırılır. Aynı zamanda; yaprakları dışındaki tüm düğümlerinin iki çocuğu olan ağaçlar olarak da tanımlayabiliriz. Full Binary Tree örnekleri;<br>
582 |     <img src="binary_tree_1.png" alt="Full Binary Tree"/><br>
583 |     Tam ikili ağaçlarda yaprak düğüm sayısı iç düğüm sayısından 1 fazladır.<br>
584 |     L = Yaprak düğüm sayısı, I = İç düğüm sayısı<br> L = I + 1
585 |     </li>
586 |     <li>
587 |         <b id="complete-binary-tree">Complete Binary Tree</b> - Son seviye hariç tüm seviyelerin tamamen dolu olduğu ve son seviyenin mümkün olduğu kadar düğüme sahip olduğu ağaçlar Complete Binary Tree(tamamlanmış ikili ağaçlar) olarak adlandırılırlar. Örnekler;<br>
588 |     <img src="binary_tree_2.png" alt="Complete Binary Tree"/><br>
589 |     </li>
590 |     <li>
591 |         <b id="perfect-binary-tree">Perfect Binary Tree</b> - Tüm iç düğümlerin iki çocuğa sahip olduğu ve tüm yaprakların aynı seviyede olduğu ağaçlar Perfect Binary Tree(mükemmel ikili ağaç) olarak adlandırılırlar. H yüksekliğindeki mükemmel ikili ağaç 2<sup>H</sup> - 1 düğüme sahiptir. Örnekler;<br>
592 |     <img src="binary_tree_3.png" alt="Perfect Binary Tree"/><br>
593 |     </li>
594 |     <li>
595 |         <b id="balanced-binary-tree">Balanced Binary Tree</b> - Her iç düğümün en fazla bir çocuğunun olduğu ağaçlar Balanced Binary Tree(dengeli ikili ağaç) olarak adlandırılırlar. Bu tür ağaçlar performans bakımından bağlı listelerle aynıdır. Bu ağaçlarda kök ile her yaprağın yolu aynıdır.<br>
596 |     <img src="binary_tree_4.png" alt="Balanced Binary Tree"/><br>
597 |     </li>
598 | </ul>
599 | 
600 | ## Kaynakça
601 | <ul>
602 |     <li> http://www.tutorialspoint.com/ </li>
603 |     <li> https://www.geeksforgeeks.org/ </li> 
604 |     <li> https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-006-introduction-to-algorithms-spring-2008/lecture-notes/ </li>
605 |     
606 | </ul>
607 | 


--------------------------------------------------------------------------------
/bagli_liste.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/bagli_liste.jpg


--------------------------------------------------------------------------------
/binary_tree_0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/binary_tree_0.png


--------------------------------------------------------------------------------
/binary_tree_1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/binary_tree_1.png


--------------------------------------------------------------------------------
/binary_tree_2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/binary_tree_2.png


--------------------------------------------------------------------------------
/binary_tree_3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/binary_tree_3.png


--------------------------------------------------------------------------------
/binary_tree_4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/binary_tree_4.png


--------------------------------------------------------------------------------
/cift_yonlu.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/cift_yonlu.jpg


--------------------------------------------------------------------------------
/dairesel_bagli_liste.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/dairesel_bagli_liste.jpg


--------------------------------------------------------------------------------
/dairesel_bagli_liste1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/dairesel_bagli_liste1.jpg


--------------------------------------------------------------------------------
/dizi_temsili.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/dizi_temsili.png


--------------------------------------------------------------------------------
/dizi_temsili1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/dizi_temsili1.png


--------------------------------------------------------------------------------
/veri_tipleri.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/zumrudu-anka/DataStructures/11b5f9e4bb42b97c1977f21436afe58bed667b1d/veri_tipleri.jpg


--------------------------------------------------------------------------------