Advertisement
Guest User

Untitled

a guest
Apr 19th, 2018
68
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 7.37 KB | None | 0 0
  1. // lista z bomblem.cpp : Defines the entry point for the console application.
  2. //
  3.  
  4. #include "stdafx.h"
  5. #include <iostream>
  6. #include <fstream>
  7. #include <string>
  8.  
  9. using namespace std;
  10.  
  11.  
  12.  
  13. struct node {
  14. string val;
  15. node *next;
  16. node *prev;
  17. };
  18.  
  19. struct list {
  20. node *head;
  21. node *tail;
  22. unsigned int count;
  23. };
  24.  
  25.  
  26.  
  27. //vol1
  28.  
  29.  
  30.  
  31. void add(node *&head, string nval) {
  32. node *new_elem = new node;
  33. new_elem->val = nval;
  34. new_elem->next = head;
  35. new_elem->prev = NULL;
  36. head->prev = new_elem;
  37. head = new_elem;
  38. }
  39.  
  40. void show(node *head, int &licznik) {
  41. node *p = head;
  42. int i = 0;
  43. while (p->next != NULL) {
  44. cout << p->val << "\t";
  45. p = p->next;
  46. i++;
  47. }
  48. licznik = i;
  49. }
  50.  
  51. void readfromfile(node *&head) {
  52. ifstream plik("plik.txt");
  53. string nval;
  54. if (plik.good() == true) {
  55. while (!plik.eof()) {
  56. plik >> nval;
  57. node *new_elem = new node;
  58. new_elem->val = nval;
  59. new_elem->next = head;
  60. new_elem->prev = NULL;
  61. //head->prev = new_elem;
  62. head = new_elem;
  63. }
  64.  
  65. }
  66. else {
  67. cout << "Blad odczytu! ";
  68. }
  69. }
  70.  
  71. void destroy(node *&head) { //poczatek listy
  72. if (head != NULL) {
  73. node *p = head;
  74. head = head->next;
  75. delete p;
  76. }
  77.  
  78. }
  79.  
  80. /*void damage(node *&head) {
  81. node *p = head;
  82. while (p) {
  83. p = p->next;
  84. }
  85. p->prev = p->next;
  86. delete p;
  87. }*/
  88.  
  89. void pick_one(node *&head, string a) {//szukanie po wartosci
  90. node *p = head;
  91. while (p->next != NULL) {
  92. if (p->val == a) {
  93. cout << p->val;
  94. break;
  95. }
  96. else if (p->next->val == a) {
  97. cout << p->next->val;
  98. break;
  99. }
  100. else {
  101. p = p->next;
  102. }
  103. }
  104. }
  105.  
  106. void pick_indeks(node *&head, int licznik, int indeks) {//szukanie po indeksie
  107. node *p = new node;
  108. p = head;
  109. string zmienna;
  110. if (licznik == 0) {
  111. cout << "Pusta lista.";
  112.  
  113. }
  114. else {
  115. for (int i = 1; i <= licznik; i++)
  116. {
  117. if (i == indeks) {
  118. cout << "Podaj wartosc ";
  119. cin >> zmienna;
  120. p->val = zmienna;
  121. }
  122.  
  123. else {
  124. p = p->next;
  125. }
  126. }
  127. }
  128. }
  129.  
  130. /*void podziel(node *&head,int licznik) {
  131. node *H1 = new node;
  132. node *H2 = new node;
  133. H1= head;
  134. H2 = head->next;
  135. bool s = false;
  136. if (licznik <= 1) {
  137. cout << "lista pusta lub ma jeden element -nie mozna jej podzielic." << endl;
  138. }
  139. else {
  140. while (head)
  141. {
  142. if (s) {
  143. H2->next = head;
  144. H2 = H2->next;
  145. }
  146. else {
  147. H1->next = head;
  148. H1 = H1->next;
  149. }
  150. head = head->next;
  151. s = !s;
  152. }
  153. H1->next = H2->next = NULL;
  154. add(H1);
  155. add(H2);
  156. }
  157.  
  158. }
  159. */
  160.  
  161.  
  162.  
  163. //vol2
  164.  
  165.  
  166. void push_front(list &L, string nval) {
  167. node *p = new node;
  168. p->val = nval;
  169. p->next = L.head;
  170. p->prev = NULL;
  171. L.head = p;
  172. L.count++;
  173. if (p->next) {
  174. p->next->prev = p;
  175. }
  176. else {
  177. L.tail = p;
  178. }
  179. }
  180.  
  181. void push_back(list &L, string nval) {
  182. node *p = new node;
  183. p->val = nval;
  184. p->next = NULL;
  185. p->prev = L.tail;
  186. L.tail = p;
  187. L.count++;
  188. if (p->prev) {
  189. p->prev->next = p;
  190. }
  191. else {
  192. L.head = p;
  193. }
  194. }
  195.  
  196. void pokaz(list &L) {
  197. node *p;
  198. p = L.head;
  199. while (p) {
  200. cout << p->val << "\t";
  201. p = p->next;
  202. }
  203.  
  204. }
  205.  
  206. void remove(list &L, node *e) {
  207. L.count--;
  208. if (e->prev) {
  209. e->prev->next = e->next;
  210. }
  211. else if (e->next) {
  212. e->next->prev = e->prev;
  213. }
  214. else {
  215. L.tail = e->prev;
  216. }
  217.  
  218. delete e;
  219. }
  220.  
  221. void remove_front(list &L) {
  222. if (L.count) {
  223. remove(L, L.head);
  224. }
  225. }
  226.  
  227. void remove_back(list &L) {
  228. if (L.count) {
  229. remove(L, L.tail);
  230. }
  231. }
  232. /*
  233. node *podziel(node *&head) {
  234. if (head == NULL || head->next==NULL) {
  235. cout << "Pusta lista lub ma jeden element" << endl;
  236. }
  237. else {
  238. node *newListP = NULL;
  239. node *newListN = NULL;
  240. node *p = head;
  241. int counter = 0;
  242. while (p->next != NULL)
  243. {
  244. if (counter % 2 == 0) {
  245. cout << p->val;
  246. //add(newListP,p->val);
  247. }
  248. else {
  249. cout << p->val;
  250. //add(newListN,p->val);
  251. }
  252. counter ++ ;
  253. p = p->next;
  254. }
  255. if (p->next == NULL) {
  256. if (counter % 2 == 0)
  257. {
  258. add(newListP, p->val);
  259. }
  260. else
  261. {
  262. add(newListN, p->val);
  263. }
  264. head = newListN;
  265. show(head,counter);
  266. cout << endl;
  267. show(newListP,counter);
  268. }
  269. return newListP;
  270.  
  271. }
  272.  
  273. }*/
  274.  
  275. void swapElem(list &L, unsigned int nr_el1, unsigned int nr_el2)
  276. {
  277. node* pom1 = new node;
  278. node* pom2 = new node;
  279. node* tmp1 = new node;
  280. node* tmp2 = new node;
  281. pom1 = L.head;
  282. if (nr_el1 > nr_el2)
  283. {
  284. unsigned int pom;
  285. pom = nr_el1;
  286. nr_el1 = nr_el2;
  287. nr_el2 = pom;
  288. }
  289. for (unsigned int i = 1; i < nr_el2; i++)
  290. {
  291. tmp1 = pom1;
  292. pom1 = pom1->next;
  293. if (pom1 != NULL) continue;
  294. else {
  295. cout << "Lista konczy sie na elemencie nr" << i << "!\n";
  296. pom1 = NULL;
  297. pom2 = NULL;
  298. break;
  299. }
  300. }
  301. cout << "Tmp1 =" << tmp1->val << " Pom1 = " << pom1->val << endl;
  302. if (pom1 == NULL && pom2 == NULL) { cout << "Zamiana nie powiodla sie\n"; }
  303. else {
  304. pom2 = L.head;
  305. tmp2 = L.head;
  306. for (unsigned int i = 1; i < nr_el1; i++)
  307. {
  308. tmp2 = pom2;
  309. pom2 = pom2->next;
  310. }
  311. if ((nr_el2 - nr_el1) > 1) {
  312. cout << "Tmp2 =" << tmp2->val << " Pom2 = " << pom2->val << endl;
  313.  
  314.  
  315. if (nr_el1 != 1)
  316. {
  317. /*pom2->next = pom1->next;
  318. tmp1->next = pom2;
  319. pom1->next = tmp1;
  320. tmp2->next = pom1;*/
  321. tmp1->next = pom2->next;
  322. tmp2->next = pom1;
  323. pom2->next = pom1->next;
  324. pom1->next = tmp1->next;
  325. tmp1->next = pom2;
  326. //head = tmp2;
  327. }
  328. else {
  329. tmp2 = pom2->next;
  330. pom2->next = pom1->next;
  331. tmp1->next = pom2;
  332. pom1->next = tmp2;
  333. L.head = pom1;
  334. }
  335.  
  336. }
  337. else
  338. {
  339. tmp1->next = pom1->next;
  340. pom1->next = pom2;
  341. if (nr_el1 != 1)
  342. {
  343. tmp2->next = pom1;
  344. //head = tmp2;
  345. }
  346. else L.head = pom1;
  347. }
  348. cout << "Zamiana powiodla sie\n";
  349. }
  350. }
  351.  
  352. void Bombel(list &L) {
  353. node *p = new node;
  354. node *temp = new node;
  355. while (p) {
  356. p = L.head;
  357. temp = p->next;
  358. L.count = 1;
  359. bool swapped = false;
  360. while (temp) {
  361. if (p->val <= temp->val) {
  362. p = temp;
  363. temp = temp->next;
  364. L.count++;
  365. break;
  366. }
  367. else {
  368. swapElem(L, L.count, L.count++);
  369. p = temp;
  370. temp = temp->next;
  371. swapped = true;
  372. L.count++;
  373. break;
  374. }
  375.  
  376. }
  377.  
  378. if (swapped) {
  379. L.head = p;
  380. p = nullptr;
  381. }
  382. else {
  383. L.head = p;
  384. break;
  385. }
  386.  
  387. }
  388. }
  389.  
  390. int main()
  391. {
  392. //vol1
  393. unsigned int nr_el1, nr_el2;
  394. /*
  395. node *head = NULL;
  396. head = new node;
  397. head->next = NULL;
  398. head->prev = NULL;
  399.  
  400.  
  401. node *tail = NULL;
  402. tail = new node;
  403. tail->next = NULL;
  404. tail->prev = NULL;
  405.  
  406.  
  407. string a, b;
  408. int n, licznik, indeks;
  409. licznik = 0;
  410.  
  411. cout << "Podaj ilosc elementow listy:";
  412. cin >> n;
  413. for (int i = 0; i < n; i++) {
  414. cout << "Podaj a:";
  415. cin >> a;
  416. add(head, a);
  417.  
  418. }
  419. cout << "Elementy listy to: \n";
  420. show(head, licznik);
  421. cout << endl << endl;
  422.  
  423. cout << "Odczytanie z pliku.\n";
  424. readfromfile(head);
  425. show(head,licznik);
  426. cout << endl << endl;
  427.  
  428. destroy(head);
  429. //damage(head);
  430. show(head,licznik);
  431.  
  432. cout << "Podaj szukana wartosc: ";
  433. cin >> b;
  434. pick_one(head, b);
  435.  
  436. cout << "Podaj indeks: ";
  437. cin >> indeks;
  438. pick_indeks(head,licznik,indeks);
  439. show(head, licznik);
  440.  
  441.  
  442.  
  443. cout << "podaj elementy do zamiany ";
  444. cin >> nr_el1 >> nr_el2;
  445. swapElem(head, nr_el1, nr_el2);
  446. show(head, licznik);
  447. */
  448.  
  449. //vol2
  450.  
  451.  
  452. list L;
  453. string a;
  454. L.head = L.tail = NULL;
  455. L.count = 0;
  456.  
  457. int n;
  458.  
  459. cout << "Podaj ilosc elementow tablicy:";
  460. cin >> n;
  461. for (int i = 0; i < n; i++) {
  462. cout << "Podaj a:";
  463. cin >> a;
  464. push_back(L, a);
  465.  
  466. }
  467. /*
  468. readfromfile(L.head);
  469. pokaz(L);
  470. cout << endl << endl;
  471.  
  472. remove(L, L.head->next);
  473. pokaz(L);
  474. */
  475.  
  476. Bombel(L);
  477. pokaz(L);
  478.  
  479. system("Pause");
  480. return 0;
  481. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement