API tools faq
paste
Advertisement
Aiaa

list sure ya salma

Aiaa
Apr 10th, 2016
64
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 16.11 KB | None | 0 0
raw download clone embed print report
  1. package eg.edu.alexu.csd.datastructure.linkedList.cs04;
  2.  
  3. import java.awt.Point;
  4.  
  5. import java.util.Arrays;
  6. import java.util.Comparator;
  7. import java.util.Scanner;
  8.  
  9. import eg.edu.alexu.csd.datastructure.linkedList.ILinkedList;
  10.  
  11. import eg.edu.alexu.csd.datastructure.linkedList.IPolynomialSolver;
  12.  
  13. public class SinglyLinkedList implements IPolynomialSolver, ILinkedList {
  14.  
  15. private SListNode head = null;
  16. public int size = 0;
  17. static int x, y;
  18. SinglyLinkedList list = new SinglyLinkedList();
  19. SinglyLinkedList a1 = new SinglyLinkedList();
  20. SinglyLinkedList b1 = new SinglyLinkedList();
  21. SinglyLinkedList c1 = new SinglyLinkedList();
  22.  
  23. SinglyLinkedList subt = new SinglyLinkedList();
  24. SinglyLinkedList multi = new SinglyLinkedList();
  25.  
  26. SinglyLinkedList tempList2 = new SinglyLinkedList();
  27. int pointsSumed = 0;
  28.  
  29. public static void main(String[] args) {
  30. // TODO Auto-generated method stub
  31. SinglyLinkedList object = new SinglyLinkedList();
  32. // SinglyLinkedList list = new SinglyLinkedList();
  33. // SinglyLinkedList tempList2 = new SinglyLinkedList();
  34. Scanner scan = new Scanner(System.in);
  35. Object ob = scan.next();
  36. //// list.add(5);
  37. //// list.print();
  38. //// list.remove(0);
  39. //// list.print();
  40. // Object get_object ;
  41. //// list.add(1,5);
  42. //// list.print();
  43. // list.add(50);
  44. // // list.add(40);
  45. // //list.add(30);
  46. // //list.print();
  47. // get_object = list.get(0);
  48. // System.out.println(get_object);
  49. //
  50. // // list.print();
  51. //
  52. // get_object = list.get(1);
  53. // System.out.println(get_object);
  54. //
  55. // //list.print();
  56. //
  57. // get_object = list.get(2);
  58. // System.out.println(get_object);
  59. // list.add(50);
  60. // list.add(40);
  61. // list.add(30);
  62. // list.set(0, 5);
  63. // list.print();
  64. // list.set(1, 4);
  65. // list.print();
  66. // list.set(2, 3);
  67. // list.print();
  68. // list.set(2, 4);
  69. // list.set(2, -1);
  70. // list.remove(0);
  71. // list.print();
  72. // list.remove(1);
  73. // list.print();
  74. // list.remove(0);
  75. // list.print();
  76. // list.clear();
  77. // list.print();
  78. // Object get_object = list.get(0);
  79. // System.out.println(get_object);
  80. // int size2 = list.size();
  81. // System.out.println(size2);
  82. // list.add(0, 5);
  83. // list.add('v');
  84. // size2 = list.size();
  85. // System.out.println(size2);
  86. // Object get_object = list.get(1);
  87. // System.out.println(get_object);
  88. // boolean bool = list.contains('v');
  89. // System.out.println(bool);
  90. object.list.add(0);
  91. object.list.add(1);
  92. object.list.add(2);
  93. object.list.add(3);
  94. object.list.add(4);
  95. object.list.add(5);
  96. object.list.removeAtTail();
  97. // boolean bool = list.contains(3);
  98. // System.out.println(bool);
  99. // tempList2 = (SinglyLinkedList) list.sublist(5, 5);
  100. // int temp1 = object.x ;
  101. // System.out.println(x);
  102. // System.out.println(y);
  103. // int temp = Math.abs(x - y) + 1;
  104. // System.out.println(temp);
  105. // for (int i = 0; i < temp; i++) {
  106. // System.out.print(tempList2.get(i) + " ");
  107. // }
  108. object.list.print();
  109. }
  110.  
  111. SinglyLinkedList list2 = new SinglyLinkedList();
  112.  
  113. // public void sort(SinglyLinkedList l) {
  114. // int xx, yy, conv;
  115. // SListNode i = head;
  116. //
  117. // while (i != null) {
  118. // // System.out.print(i.value + " ");
  119. // // String str = i.value.toString();
  120. // // conv = Integer.parseInt(str);
  121. // i = i.next;
  122. // }
  123. // // System.out.println();
  124. //
  125. // }
  126.  
  127.  
  128.  
  129. public void print() {
  130. SListNode i = head;
  131. if (i == null) {
  132. System.out.println("empty");
  133. }
  134. while (i != null) {
  135. System.out.print(i.value + " ");
  136.  
  137. i = i.next;
  138. }
  139. System.out.println();
  140. }
  141.  
  142. // public SinglyLinkedList addTwoLists(SinglyLinkedList poly1,
  143. // SinglyLinkedList poly2) {
  144. // SListNode pointer1 = poly1.head;
  145. // SListNode pointer2 = poly1.head;
  146. // int shortSize = poly1.size ;
  147. // if( poly1.size > poly2.size){
  148. // shortSize = poly2.size ;
  149. // }
  150. // for (int counter = 0; counter <= shortSize - 1; counter++) {
  151. // if (counter == shortSize - 1) {
  152. // if (pointer1.value.x == pointer2.value.x){
  153. // sum.add((pointer1.value.x , pointer1.value.y + pointer2.value.y));
  154. // }
  155. // else{
  156. // sum.add(pointer1.value);
  157. // for ( int counterB = 0 ; counterB < Math.abs(poly1.size - poly2.size) ;
  158. // counterB++){
  159. // sum.add(pointer2.value);
  160. // }
  161. // }
  162. // } else {
  163. // if (pointer1.value.x == pointer2.value.x){
  164. // sum.add((pointer1.value.x , pointer1.value.y + pointer2.value.y));
  165. // pointer1 = pointer1.next ;
  166. // pointer2 = pointer2.next ;
  167. // }
  168. // else{
  169. // sum.add(pointer1.value);
  170. // pointer1 = pointer1.next ;
  171. // }
  172. // }
  173. // }
  174. //
  175. // return sum;
  176. // }
  177. // public SinglyLinkedList subtractTwoLists(SinglyLinkedList poly1 ,
  178. // SinglyLinkedList poly2) {
  179. // SListNode pointer1 = poly1.head;
  180. // SListNode pointer2 = poly1.head;
  181. // int shortSize = poly1.size ;
  182. //// if( poly1.size > poly2.size){
  183. //// shortSize = poly2.size ;
  184. //// }
  185. // for (int counter = 0; counter <= shortSize - 1; counter++) {
  186. // if (counter == shortSize - 1) {
  187. // if (pointer1.value.x == pointer2.value.x){
  188. // sum.add((pointer1.value.x , pointer1.value.y + pointer2.value.y));
  189. // }
  190. // else{
  191. // sum.add(pointer1.value);
  192. // for ( int counterB = 0 ; counterB < Math.abs(poly1.size - poly2.size) ;
  193. // counterB++){
  194. // sum.add(pointer2.value);
  195. // }
  196. // }
  197. // } else {
  198. // if (pointer1.value.x == pointer2.value.x){
  199. // subt.add((pointer1.value.x , pointer1.value.y - pointer2.value.y));
  200. // pointer1 = pointer1.next ;
  201. // pointer2 = pointer2.next ;
  202. // }
  203. // else{
  204. // sum.add(pointer1.value);
  205. // pointer1 = pointer1.next ;
  206. // }
  207. // }
  208. // }
  209. //
  210. // return subt;
  211. // }
  212. // public SinglyLinkedList convertToPoints(int[][] array) {
  213. // SinglyLinkedList toBeReturnList = new SinglyLinkedList();
  214. // //Point fPoint
  215. // return toBeReturnList;
  216. // }
  217.  
  218. @Override
  219. public void add(int index, Object element) {
  220. // TODO Auto-generated method stub
  221.  
  222. SListNode adder = new SListNode(element);
  223. SListNode i = head;
  224. if (index > size) {
  225. throw new RuntimeException("index greater than the size can't be available");
  226. } else {
  227. // done
  228. if (index == 0) {
  229. adder.next = head;
  230. head = adder;
  231. size++;
  232. } else {
  233. adder.value = element;
  234. for (int counter = 0; counter < index - 1; counter++) {
  235. i = i.next;
  236. }
  237. adder.next = i.next;
  238. i.next = adder;
  239. size++;
  240. }
  241.  
  242. }
  243.  
  244. }
  245.  
  246. @Override
  247. public void add(Object element) {
  248.  
  249. add(size, element);
  250.  
  251. }
  252.  
  253. @Override
  254. public Object get(int index) {
  255. // TODO Auto-generated method stub
  256. // SListNode adder = new SListNode(index);
  257. SListNode i = head;
  258. if (size == 0 || index < 0 || index > size - 1 || head == null) {
  259. throw new RuntimeException("no ellement empty list or out of bound");
  260. } else {
  261. if (index == 0) {
  262. return i.value;
  263. } else {
  264. if (index == 1) {
  265. i = i.next;
  266. return i.value;
  267. } else {
  268. for (int counter = 0; counter < index; counter++) {
  269. i = i.next;
  270. }
  271.  
  272. }
  273.  
  274. return i.value;
  275. }
  276. }
  277.  
  278. // return null;
  279. }
  280.  
  281. @Override
  282. public void set(int index, Object element) {
  283.  
  284. SListNode adder = new SListNode(element);
  285. SListNode i = head;
  286. SListNode j = head;
  287.  
  288. if (index >= size || index < 0) {
  289. throw new RuntimeException("can't replace ");
  290. }
  291. if (index == 0) {
  292. adder.next = i.next;
  293. head = adder;
  294. // size++;
  295. } else {
  296. adder.value = element;
  297. for (int counter = 0; counter < index - 1; counter++) {
  298. j = j.next;
  299. }
  300. for (int counter = 0; counter < index; counter++) {
  301. i = i.next;
  302. }
  303. adder.next = i.next;
  304. j.next = adder;
  305. // i.next = null;
  306. // size++;
  307. }
  308.  
  309. }
  310.  
  311. @Override
  312. public void clear() {
  313. // TODO Auto-generated method stub
  314. head = null;
  315. size = 0;
  316.  
  317. }
  318.  
  319. @Override
  320. public boolean isEmpty() {
  321. SListNode i = head;
  322. if (i == null) {
  323.  
  324. return true;
  325. }
  326. // TODO Auto-generated method stub
  327. return false;
  328. }
  329.  
  330. @Override
  331. public void remove(int index) {
  332.  
  333. if (index < 0 || index >= size) {
  334. throw new RuntimeException(" already empty or out of bound");
  335.  
  336. }
  337.  
  338. else {
  339.  
  340. SListNode i = head;
  341. if (index == 0) {
  342. head = head.next;
  343. size--;
  344. }
  345.  
  346. else
  347.  
  348. {
  349. if (head == null) {
  350. throw new RuntimeException(" already empty or out of bound");
  351.  
  352. // added new
  353. }
  354.  
  355. for (int counter = 0; counter < index - 1; counter++) {
  356.  
  357. i = i.next;// while i!=null cased the error do not put it
  358. // again
  359.  
  360. }
  361. SListNode remover = i.next;
  362. i.next = remover.next;
  363. size--;
  364.  
  365. }
  366. }
  367.  
  368. }
  369.  
  370. void removeAtTail() {
  371. SListNode i = head;
  372. for (int counter = 0; counter < size - 2; counter++) {
  373. i = i.next;
  374. }
  375. i.next = null;
  376. size--;
  377. }
  378.  
  379. @Override
  380. public int size() {
  381. return size;
  382. }
  383.  
  384. @Override
  385. public ILinkedList sublist(int fromIndex, int toIndex) {
  386. x = fromIndex;
  387. y = toIndex;
  388. SListNode i = head;
  389. SinglyLinkedList tempList = new SinglyLinkedList();
  390. if (size == 0 || toIndex < fromIndex || toIndex < 0 || toIndex >= size || fromIndex < 0 || fromIndex >= size) {
  391. throw new RuntimeException("no ellement empty list or out of bound");
  392. } else {
  393. x = fromIndex;
  394. y = toIndex;
  395. for (int counter = fromIndex; counter <= toIndex; counter++) {
  396. tempList.add(counter);
  397. }
  398. return tempList;
  399. }
  400.  
  401. }
  402.  
  403. // changed == to .equals
  404. public boolean contains(Object o) {
  405.  
  406. boolean flag = false;
  407. SListNode i = head;
  408.  
  409. if (size == 0) {
  410. throw new RuntimeException("size is zero");
  411. }
  412. if (size == 1) {
  413. if (i.value.equals(o)) {
  414. flag = true;
  415. }
  416. } else {
  417. if (i.value.equals(o)) {
  418. flag = true;
  419. }
  420. for (int counter = 1; (counter <= size - 1) && (flag == false); counter++) {
  421.  
  422. i = i.next;
  423. if (i.value.equals(o)) {
  424. flag = true;
  425. }
  426.  
  427. }
  428. }
  429. return flag;
  430. }
  431. public SinglyLinkedList initialPoints(int[][] array2D) {
  432. int length2 = array2D[0].length;
  433. int max = -5000;
  434. int min = 5000;
  435. Point initialArray[] = new Point[length2];
  436. for (int i = 0; i < length2; length2++) {
  437. initialArray[i] = new Point();
  438. initialArray[i].x = array2D[i][0];
  439. initialArray[i].y = array2D[i][1];
  440. if (max < initialArray[i].x) {
  441. max = initialArray[i].x;
  442. }
  443. if (min > initialArray[i].x) {
  444. min = initialArray[i].x;
  445. }
  446.  
  447. }
  448. Arrays.sort(initialArray, new Comparator<Point>() {
  449. public int compare(Point fPoint, Point sPoint) {
  450. int xDif = Integer.compare(fPoint.x, sPoint.x);
  451. if (xDif == 0)
  452. return Integer.compare(fPoint.y, sPoint.y);
  453. else
  454. return xDif;
  455. }
  456. });
  457. int lengthOfUnsorted = max - min + 1;
  458. boolean visited[] = new boolean[lengthOfUnsorted];
  459. int counterOfExponent = 0;
  460. for (int ii = 0; ii < length2; ii++) {
  461. int index = initialArray[ii].x - min;
  462. if (visited[index] == false) {
  463. visited[index] = true;
  464. counterOfExponent++;
  465. }
  466. }
  467.  
  468. Point finalArray[] = new Point[counterOfExponent];
  469.  
  470. for (int ii = 0; ii < counterOfExponent; ii++) {
  471. finalArray[ii] = new Point();
  472. }
  473. int indexOfFinalarray = 0;
  474. Point pointMovable = new Point(initialArray[0].x, initialArray[0].y);
  475. for (int i = 1; i < initialArray.length; i++) {
  476. if (initialArray[i].x == initialArray[i - 1].x) {
  477. int xx = initialArray[i - 1].x;
  478. int yy = initialArray[i - 1].y + pointMovable.y;
  479. pointMovable.x = xx;
  480. pointMovable.y = yy;
  481. } else {
  482. finalArray[indexOfFinalarray].x = pointMovable.x;
  483. finalArray[indexOfFinalarray].y = pointMovable.y;
  484.  
  485. }
  486. }
  487. SinglyLinkedList returened = new SinglyLinkedList();
  488. for(int i = 0 ; i < finalArray.length ; i++){
  489. returened.add(finalArray[i]);
  490. }
  491. return returened;
  492.  
  493. }
  494.  
  495. public SinglyLinkedList addTwoLists(SinglyLinkedList list1, SinglyLinkedList list2) {
  496. Point[] array1 = new Point[list1.size];
  497. Point[] array2 = new Point[list2.size];
  498. for (int i = 0 ; i < array1.length ; i++){
  499. array1[i] = new Point();
  500. }
  501. for (int i = 0 ; i < array2.length ; i++){
  502. array2[i] = new Point();
  503. }
  504. SinglyLinkedList sum = new SinglyLinkedList();
  505. // int shortSize = array1.length;
  506. // int longSize = array2.length;
  507. Point[] fArray = array1;
  508. Point[] sArray = array2;
  509. if (array2[0].x < array1[0].x) {
  510. fArray = array2;
  511. sArray = array1;
  512. // shortSize = array2.length;
  513.  
  514. // shortArray = array2;
  515. // longArray = array1;
  516. }
  517. Point sumPoint = new Point();
  518. int pointer1 = 0;
  519. int pointer2 = 0;
  520. boolean[] array11 = new boolean[fArray.length];
  521. boolean[] array22 = new boolean[sArray.length];
  522. int counterFalse1 = 0;
  523. int counterFalse2 = 0;
  524. for (int i = 0; i < fArray.length; i++) {
  525. if (fArray[pointer1].x == sArray[pointer2].x) {
  526. sumPoint.x = fArray[pointer1].x;
  527. sumPoint.y = sArray[pointer1].y + sArray[pointer2].y;
  528. sum.add(sumPoint);
  529. pointer1++;
  530. pointer2++;
  531. pointsSumed++;
  532. array11[pointer1] = true;
  533. array22[pointer2] = true;
  534. } else {
  535. sumPoint.x = fArray[pointer1].x;
  536. sumPoint.y = sArray[pointer1].y;
  537. sum.add(sumPoint);
  538. pointer1++;
  539. pointsSumed++;
  540. array11[pointer1] = true;
  541. }
  542. }
  543. for (int i = 0; i < array11.length; i++) {
  544. if (array11[i] == false) {
  545. counterFalse1++;
  546. }
  547. }
  548. for (int i = 0; i < array22.length; i++) {
  549. if (array22[i] == false) {
  550. counterFalse2++;
  551. }
  552. }
  553. Point[] notAdded = new Point[counterFalse1 + counterFalse2];
  554. for (int i = 0; i < counterFalse1 + counterFalse2; i++) {
  555. notAdded[i] = new Point();
  556. }
  557. int indexNotAdded = 0;
  558. for (int i = 0; i < counterFalse1; i++) {
  559. notAdded[indexNotAdded] = fArray[i + (fArray.length - counterFalse1)];
  560. indexNotAdded++;
  561. }
  562. for (int i = 0; i < counterFalse2; i++) {
  563. notAdded[indexNotAdded] = sArray[i + (sArray.length - counterFalse2)];
  564. indexNotAdded++;
  565. }
  566. Arrays.sort(notAdded, new Comparator<Point>() {
  567. public int compare(Point ffPoint, Point ssPoint) {
  568. int xDif = Integer.compare(ffPoint.x, ssPoint.x);
  569. return xDif;
  570. }
  571. });
  572. for (int i = 0; i < notAdded.length; i++) {
  573. sum.add(notAdded[i]);
  574. }
  575. return sum;
  576. }
  577. @Override
  578. public void setPolynomial(char poly, int[][] terms) {
  579. // TODO Auto-generated method stub
  580. if( poly == 'A' || poly == 'a' ){
  581. a1 = initialPoints(terms);
  582. }
  583. if( poly == 'B' || poly == 'b'){
  584. b1 = initialPoints(terms);
  585. }
  586. if( poly == 'C' || poly == 'c'){
  587. c1 = initialPoints(terms);
  588. }
  589.  
  590. }
  591.  
  592. @Override
  593. public String print(char poly) {
  594. // TODO Auto-generated method stub
  595. return null;
  596. }
  597.  
  598. @Override
  599. public void clearPolynomial(char poly) {
  600. // TODO Auto-generated method stub
  601.  
  602. }
  603.  
  604. @Override
  605. public float evaluatePolynomial(char poly, float value) {
  606. // TODO Auto-generated method stub
  607. return 0;
  608. }
  609.  
  610. @Override
  611. public int[][] add(char poly1, char poly2) {
  612. // TODO Auto-generated method stub
  613. SinglyLinkedList result = new SinglyLinkedList();
  614. if ( ( ( poly1 == 'A' || poly1 == 'a') && ( poly2 == 'B'|| poly2 == 'b' ) ) || ( ( poly2 == 'A' || poly2 == 'a') && ( poly1 == 'B'|| poly1 == 'b' ) ) ){
  615. result = addTwoLists(a1, b1);
  616. }
  617.  
  618. else if ( ( ( poly1 == 'A' || poly1 == 'a') && ( poly2 == 'C'|| poly2 == 'c' ) ) || ( ( poly2 == 'A' || poly2 == 'a') && ( poly1 == 'C'|| poly1 == 'c' ) ) ){
  619. result = addTwoLists(a1 , c1 );
  620. }
  621.  
  622. else if ( ( ( poly1 == 'C' || poly1 == 'c') && ( poly2 == 'B'|| poly2 == 'b' ) ) || ( ( poly2 == 'C' || poly2 == 'c') && ( poly1 == 'B'|| poly1 == 'b' ) ) ){
  623. result = addTwoLists(c1 , b1 );
  624. }
  625. int length2 = result.size ;
  626. Point[] returnedPoint = new Point [length2];
  627. for (int i = 0 ; i < length2 ; i++){
  628. returnedPoint[i] = new Point();
  629. returnedPoint[i] = (Point)result.get(i);
  630. }
  631. int[][] toBeReturnedArray = new int [2][length2];
  632. // for(int i =0 ; i < 1 ; i++){
  633. for (int j = 0; j < toBeReturnedArray.length; j++) {
  634. toBeReturnedArray[0][j] = returnedPoint[j].x ;
  635. toBeReturnedArray[1][j] = returnedPoint[j].y ;
  636.  
  637. }
  638.  
  639. return toBeReturnedArray;
  640. }
  641.  
  642. @Override
  643. public int[][] subtract(char poly1, char poly2) {
  644. // TODO Auto-generated method stub
  645. return null;
  646. }
  647.  
  648. @Override
  649. public int[][] multiply(char poly1, char poly2) {
  650. // TODO Auto-generated method stub
  651. return null;
  652. }
  653.  
  654. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!