fork download
copy 
  1. //Compile with "g++ -std=C++11 -O2 -o <programname> <callingfile>.cpp list.hpp"
  2. #ifndef LIST_H
  3. #define LIST_H
  4. #include <iostream>
  5.  
  6. template <typename T>
  7. class linked_list {
  8.     private:
  9. 		int empty = 1;
  10.  
  11. 		struct node {
  12. 			T data;
  13. 			struct node * next;
  14. 		} * head;
  15.  
  16. 		struct node * get_add(int index); 
  17. 	public:
  18.         linked_list(){head = new node;};
  19.         linked_list(T data){head = new node; head = data; empty = 0;}
  20.        ~linked_list();
  21.  
  22.        int size();   
  23.        inline int nsize(){return sizeof(struct node);};
  24.        inline struct node * lhead() {return head;};
  25.        inline struct node * tail() {return get_add(size()-1);};
  26.  
  27.        int search(T key);
  28.  
  29.        T& prepend(T data);                                     
  30.        T& append(T data);
  31.        int insert(T data, int index);
  32. 	   int del(int index);
  33.  
  34.        int set(T data, int index);     
  35.        T get(int index);      
  36.  
  37.        T& operator[](int i);                      
  38. };  
  39.  
  40. template<typename  T>
  41. std::ostream& operator<< (std::ostream &out, linked_list<T> &list); 
  42.  
  43. //////////////IMPLEMENTATION//////////////
  44. //////////////////////////////////////////
  45.  
  46. template <typename T>
  47. T& linked_list<T>::operator[](int index){
  48.  
  49. 	if(index >= size()){
  50.         return append(0);
  51. 	}
  52.  
  53. 	return get_add(index)->data;
  54. }
  55.  
  56. template <typename T>
  57. std::ostream& operator<< (std::ostream &out, linked_list<T> &list){
  58. 	int i;
  59. 	for(i = 0; i < list.size(); i++)
  60. 		out << list.get(i);
  61. 	return out;
  62. }
  63.  
  64. template <typename T>
  65. int linked_list<T>::size(){
  66. 	int i;
  67. 	struct node * tmp = head;
  68.  
  69. 	for(i = 1; tmp->next != NULL; i++)
  70. 		tmp = tmp->next;
  71.  
  72. 	return i;
  73. }
  74.  
  75. template <typename T>
  76. int linked_list<T>::set(T data, int index){
  77. 	if(index >= size())
  78. 		return -1;
  79.  
  80. 	get_add(index)->data = data;
  81.  
  82. 	return data;
  83. }
  84.  
  85. template <typename T>
  86. T& linked_list<T>::prepend(T data){ 
  87. 	if(empty){
  88. 		head->data = data;
  89. 		empty = 0;
  90. 		return (head->data);
  91. 	} else {
  92. 		struct node * tmp = new node;
  93. 		tmp->data = head->data;
  94. 		tmp->next = head->next;
  95.  
  96. 		head->data = data;
  97. 		head->next =  tmp;
  98. 		return (tmp->data);
  99. 	}
  100.  
  101.  
  102. }
  103.  
  104. template <typename T>
  105. T& linked_list<T>::append(T data){
  106. 	if(empty){
  107. 		head->data = data;
  108. 		empty = 0;
  109. 		return (head->data);
  110. 	} else {
  111. 		struct node * tmp = new node;
  112.  
  113. 		tmp->data = data;
  114. 		tmp->next = NULL;
  115.  
  116. 		tail()->next = tmp;
  117. 	}
  118.  
  119. 	return (head->next->data);
  120. }
  121.  
  122. template <typename T>
  123. int linked_list<T>::insert(T data, int index){
  124. 	if(index >= size())
  125. 		return -1;
  126.  
  127. 	if(empty){
  128. 		head->data = data;
  129. 		empty = 0;
  130. 	} else {
  131. 		struct node * tmp = new node;
  132. 		struct node * location = get_add(index);
  133.     struct node * prev = get_add(index-1);
  134.  
  135.     tmp->data = data;
  136.     tmp->next = location;
  137. 		prev->next = tmp;
  138. 	}
  139.  
  140. 	return 0;
  141. }
  142.  
  143. template <typename T>
  144. int linked_list<T>::del(int index){
  145. 	if(index >= size())
  146. 		return -1;
  147.  
  148. 	struct node * prev = get_add(index-1);
  149. 	struct node * tmp = prev->next->next;
  150.  
  151. 	delete prev->next;
  152.  
  153. 	prev->next = tmp;
  154.  
  155. 	return 0;
  156. }
  157.  
  158.  
  159. template <typename T>
  160. int linked_list<T>::search(T key){
  161. 	int i;
  162. 	struct node * tmp = head;
  163.  
  164. 	for(i = 0; key != tmp->data; i++)
  165. 		tmp = tmp->next;
  166.  
  167. 	return i;
  168. }
  169.  
  170. template <typename T>
  171. T linked_list<T>::get(int index){
  172. 	if(index >= size())
  173. 		return 0;
  174.  
  175. 	int i;
  176. 	struct node * tmp = head;
  177.  
  178. 	for(i = 0; tmp->next != NULL && i < index; i++)
  179. 		tmp = tmp->next;
  180.  
  181. 	return tmp->data;
  182. }
  183.  
  184. template <typename T>
  185. struct linked_list<T>::node * linked_list<T>::get_add(int index){
  186. 	if(index >= size())
  187. 		return 0;
  188.  
  189. 	int i = 0;
  190. 	struct node * tmp = head;
  191.  
  192. 	while(i++ < index)
  193. 		tmp = tmp->next;
  194.  
  195. 	return tmp;
  196. }
  197.  
  198. template <typename T>
  199. linked_list<T>::~linked_list(){
  200. 	struct node * tmp = head->next;
  201.  
  202. 	for(; head->next != NULL; tmp = head->next){
  203. 		head->next = head->next->next;	
  204. 		delete tmp;
  205. 	}
  206.  
  207. 	delete head;
  208. }
  209. #endif
  210.  
  211.  
  212. #include <cstdio>
  213.  
  214. bool ispowerof(int number, int base){
  215.     bool value = false;
  216.  
  217. 	while(number >= base && !(number % base)){
  218. 		number /= base;
  219. 		if(number == base){
  220. 			value = true;
  221. 		}
  222.  
  223. 	} 
  224.  
  225. 	return value;
  226. }
  227.  
  228. int main(void){
  229.         linked_list<int> integers;
  230.  
  231.    	int i, root;
  232.  
  233.   	for(i = 0; i < 1000; i++)
  234. 		integers.append(i);
  235.  
  236. 	for(i = 0; i < 1000; i++){
  237. 		root = integers.get(i);
  238. 		integers.set(root*root, i);
  239.  
  240. 		if(ispowerof(root, 2))
  241. 			std::cout << root << ":" << integers.get(i)  << " ";
  242. 	}
  243.  
  244. 	std::cout << std::endl;
  245.  
  246.     //
  247.  
  248.     linked_list<int> tape;
  249.  
  250.     std::cout << ++tape[0];
  251.  
  252.     return 0;
  253. }
Success #stdin #stdout 0s 3028KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
4:16 8:64 16:256 32:1024 64:4096 128:16384 256:65536 512:262144 
1
https://ideone.com/nEohhY
language:
C++14 (gcc 8.3)
created:
11 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!