diff --git a/QuickSort/.classpath b/QuickSort/.classpath new file mode 100755 index 0000000..d5d7ce9 --- /dev/null +++ b/QuickSort/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/QuickSort/.project b/QuickSort/.project new file mode 100755 index 0000000..55d172b --- /dev/null +++ b/QuickSort/.project @@ -0,0 +1,17 @@ + + + QuickSort + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/QuickSort/TestFile1_r_200 b/QuickSort/TestFile1_r_200 new file mode 100755 index 0000000..528429f --- /dev/null +++ b/QuickSort/TestFile1_r_200 @@ -0,0 +1,200 @@ +E465L;ZPOE;OK +1L1L4;UX8H;Error +8RPUZ;XCTV;OK +JZXHZ;FCB6;Error +FMF1Q;TZ0Q;Error +KC83O;JVA8;Error +NXM6F;6UWJ;Error +3JJG5;VRZE;OK +VM22T;8ESM;Error +L2Z74;99YH;Error +DP56R;7OTD;OK +Q7ZTQ;89QL;OK +86KFC;JR4C;Error +VXNZ7;8ZUK;OK +U36TU;Q5NO;Error +F719A;EV11;Error +EU67U;U9A3;OK +LG932;LEB6;Error +0P5HI;2DMR;OK +0NCJZ;D3CV;OK +1STNG;9LVC;OK +DRRJ7;Q5NO;OK +SAVV1;5KY4;Error +0KQVF;A2B2;OK +9CU9S;2DMR;Error +PAV4X;FJM7;OK +K38C6;FVNX;Error +ZOFOB;XX3N;Error +BSN3X;8AHW;OK +14ST0;1GLP;OK +XBL3V;EGBN;OK +0RC82;WVH9;OK +CLXEN;80QC;Error +JQ83G;L5WJ;OK +BXYWG;YXB1;OK +CO5LB;99YH;OK +K927G;RGU0;OK +NEWII;80QC;OK +NOKXR;2PRB;OK +O1RX0;9LVC;OK +9GRZ6;ZPOE;OK +3W314;H2J2;OK +GFV8X;4TT0;Error +EDG34;09VY;OK +9OZGG;CD24;Error +FMO3R;6UWJ;Error +9OZGG;SF97;OK +8ENSQ;EGV9;OK +YMUEM;9LVC;Error +IUS3K;395W;OK +5IWA9;IAT7;OK +FJCWM;XH85;Error +HS8YT;7V0S;OK +4OVZB;RS9F;OK +9BTCH;8AHW;Error +VUVLP;Y15Z;Error +SYXNL;6YLW;Error +OQZMH;U9A3;OK +G0BSD;EV11;OK +UXF2K;6GIK;OK +7L3ML;7A9L;OK +HRR27;B6JY;Error +REHE6;W3BW;Error +VRDJ7;ATFM;OK +E7A1M;44EK;OK +BGVDD;DD7Y;OK +C5YJW;D6D6;OK +77OJY;WVH9;OK +QRAUS;EV11;Error +H7QMX;ATFM;Error +ZOMQF;YH0E;OK +319BC;WVH9;OK +9CX82;C34A;OK +XHWDP;TP5Y;OK +E95U6;FVNX;Error +TY4L8;P0D3;OK +F719A;XCTV;OK +1JA7N;25C0;Error +LVHB1;T5OJ;OK +OHPOU;KMF6;Error +JRW9L;7A9L;Error +VME7Y;JFE8;OK +5IWA9;8ZUK;OK +BGE1D;4MXI;OK +YQHNJ;0KX3;OK +A7QI4;YXB1;OK +H6H1P;YTB6;OK +DFTPB;ZPOE;Error +CQZ7H;IAT7;OK +LHVNE;VRZE;Error +GFITE;ZJ32;OK +P16DM;YJJ2;Error +CWBC4;Y894;Error +WS23I;WVH9;OK +BQSM1;3P9C;OK +DYBGI;S0SQ;Error +2LX2P;KT7P;Error +8RPUZ;395W;Error +ZSIF7;4Y5Z;Error +SGI9T;5KY4;Error +3DOZW;3ASN;Error +DVOMX;JAQR;OK +CLFZW;9NLE;OK +I7PV7;D6D6;Error +8P8MH;TZ0Q;Error +RQPFF;YH0E;Error +Q5IUI;859T;OK +UJ2HT;D6D6;OK +3FFRR;DN7A;OK +MKO7P;KT7P;OK +ZZ10T;OHGC;OK +TKGOS;DDHF;OK +M4306;5GGN;Error +ESVJM;RJND;Error +WS23I;RGU0;Error +W0KBB;1RE7;Error +9WO9L;P0D3;Error +6O38S;Q50L;OK +BMLKQ;YTB6;Error +2YLSD;9LVC;OK +LKEH0;L2PF;OK +XTIHK;TP5Y;Error +3PY3A;WVH9;Error +3UI43;37J5;OK +YQHNJ;LR7M;Error +OTYAH;43JX;Error +BFC57;0I1Y;Error +UJ2HT;EEDR;OK +8B7N3;OJT3;OK +6KMH1;4Y5Z;OK +I38QI;GSPH;OK +94IJ3;LE63;OK +E9NT6;L5WJ;Error +YC7T3;09VY;OK +QXBAY;Q2L2;OK +G5FWT;XCTV;OK +94IJ3;LEB6;Error +SSG24;YXB1;Error +268AS;2DMR;Error +E465L;F9NB;Error +UXF2K;KT7P;OK +CF16I;4TT0;OK +W1D9U;I014;OK +HHOVE;395W;Error +1JA7N;8ESM;OK +OMH2W;X3M0;OK +3XFEY;5GGN;Error +BUW0P;KT7P;OK +O4SPF;GSPH;OK +A9YFG;CZON;OK +7NMOR;3ID1;Error +USDYV;1RE7;OK +7UAEP;6D24;Error +6XVNR;P0D3;OK +UM6PE;LJ7N;Error +FVLCW;RMHO;OK +YLHFB;R8UM;OK +743OD;MY1V;OK +AUC77;RGU0;Error +Q49RP;DN7A;OK +NH4W8;1RE7;Error +KB7Q0;18FN;Error +6CQWQ;JDDK;OK +ZUU35;DDHF;Error +PIRKE;7A9L;OK +UPTGF;45PZ;OK +M4PKR;VRZE;OK +0JUH1;WVH9;Error +WU7BL;KPAC;OK +T4OJG;O4WO;OK +YNIN7;VWE3;OK +DJTA5;H2J2;OK +KR3V0;X4Q1;Error +DWIK3;KMF6;Error +ZXMUT;RM6U;Error +SFV4O;CTDU;OK +ZE5XG;0KX3;Error +MMHH2;LE63;Error +8PWH0;RM6U;OK +26P62;10KK;OK +S16LO;8ZUK;OK +7GBHX;T5OJ;Error +DVFJ8;SW7O;OK +BBXGH;21W7;Error +B2QM1;OHGC;Error +OA825;7A9L;Error +61AK8;99YH;OK +TC61Z;Q4MB;OK +TZ3WA;6D24;OK +2LIZC;IUS0;Error +IB757;TP5Y;Error +CLFZW;MOM3;OK +CGIT9;A2B2;OK +4H6NB;7OTD;OK +PCAGI;5GGN;OK +L5NTH;RJND;OK +9JELP;37J5;OK +EZPWS;CTDU;OK +QGH3K;43JX;Error +LEYIS;8AHW;Error \ No newline at end of file diff --git a/QuickSort/TestFile2_a_200 b/QuickSort/TestFile2_a_200 new file mode 100755 index 0000000..a9aaf28 --- /dev/null +++ b/QuickSort/TestFile2_a_200 @@ -0,0 +1,200 @@ +0GBP3;86AY;OK +0GBP3;IKXE;OK +0GW45;P2N9;Error +0H6SX;H0JJ;Error +0L064;O8WM;OK +0L064;R0BI;Error +0L064;XSO7;Error +0PJTO;VGA6;OK +0YSKM;DPN4;Error +115BB;WKSI;OK +158A8;JFUE;OK +158A8;KCTK;OK +16RXS;ZM5F;Error +1PEVQ;607G;Error +1PHZC;78TV;OK +2480H;KN8K;Error +2BK6V;W6HR;Error +2ISFI;OCSN;OK +2QYYE;T4BM;Error +2V6VD;HMID;OK +2VN7R;MXRS;OK +32684;T4BM;Error +3581M;9NGF;Error +3GRZ4;CXZV;Error +3QAJU;E8NL;Error +3UPMM;Z6NO;OK +43MZ2;6WM8;Error +448J1;CXQY;OK +448J1;SIS8;OK +5WZS6;6VQ6;Error +5ZO9A;333M;Error +622NT;F56J;OK +624YF;YM29;OK +68VMT;WKSI;OK +6IW9W;T4BM;OK +6SH7N;7JUA;Error +6WVE6;H8JW;Error +706JA;2WXD;OK +74D28;KIRS;Error +7FUNA;WKSI;OK +7Q0TC;E8NL;OK +7Q0TC;ZHO1;Error +7WZDW;8ZRU;Error +87MLJ;IA89;OK +87VBJ;XP7N;Error +8FM9E;WLKL;OK +8K618;O8WM;Error +8MF0K;HEO6;OK +93R1Y;VGA6;Error +979S5;KUMO;Error +98QRU;JMKP;OK +9FKI0;JFUE;Error +9HMDJ;HMID;Error +A46CS;5CAD;Error +AE33P;6EYV;OK +AE33P;8FFE;Error +AVQ1T;IKXE;Error +AYCAP;46XX;OK +B30HO;867Q;Error +B30HO;QUGA;Error +BFJIO;B6BP;OK +BHODM;QUGA;Error +BS1GQ;CXQY;OK +BTMJH;H0JJ;Error +C2DOT;66SO;OK +CA60V;XV31;OK +D0BDA;F9CG;OK +DAXXS;XSO7;Error +DQGZE;IMWN;Error +DSBXK;FLN4;OK +E89EM;4XKA;OK +EDBHN;89BA;OK +EU2Z3;N2AT;Error +F8RPY;Q10Z;OK +FBJ9M;2WXD;OK +FCWQI;WZWB;Error +FJ4JQ;9MMM;Error +FJ4JQ;XSO7;Error +FLKIJ;1JL0;Error +G2LWD;YUIF;OK +G50I2;D05O;OK +G5YES;Z4W7;OK +GETRN;30EP;OK +GHYZV;KCTK;OK +GMCZF;LIDE;Error +GRA1E;ETGA;Error +GSDXS;CJ0G;Error +GWF8H;YM29;Error +H8OQT;HZTZ;OK +HDLS4;FLN4;Error +HJMUK;JTJS;Error +HKJ4Z;OS6Z;OK +HN5WE;A5P1;Error +HPHF4;61U6;Error +HSIK6;XP7N;OK +I4O34;CJ0G;OK +I9NRE;2WXD;Error +ICCT0;CJ0G;Error +IEH2K;2JMX;Error +IV6NS;67X6;Error +J2FHK;6IPE;OK +J2RNK;G9E7;OK +J7BT1;9UPZ;OK +JAEOM;CXZV;Error +JGJMZ;7JUA;Error +JMBBU;67X6;Error +JRWU2;5C3H;Error +JTIKF;FT5L;Error +K2B5N;9RHT;OK +KDT7R;C1HD;Error +KSMOX;HEBA;OK +LI5TN;6WRG;OK +M57DW;JFUE;OK +MAGNO;931H;Error +MGZ00;9UPZ;Error +MGZ00;H8JW;OK +MM1ZE;W6HR;Error +NJZY4;WZGX;OK +NNXXC;W5XD;OK +O3SEP;B10O;OK +O6LPS;A5P1;Error +OBQLI;IA89;OK +OBUQF;PUZ3;Error +OPMJA;2IMJ;Error +OPO09;4XKA;OK +P0A51;C7HC;OK +P0Y4G;XOS3;OK +P6WIR;CXQY;OK +PNUK7;HW49;Error +PNUK7;OLPS;Error +PPT4H;Y4IB;OK +PXUVB;ZVKD;OK +Q6PZO;C7HC;Error +Q6PZO;FX4R;OK +Q7RQX;9RHT;OK +Q8SVP;OL0C;OK +QASS0;46XX;Error +QYHC7;89BA;OK +QYHC7;Q10Z;OK +QYISW;JMKP;Error +R5LG4;1THF;Error +R9G7S;2ENY;OK +RC4IT;36S5;OK +RCOAW;61U6;Error +REN4L;H8JW;OK +RJ4X0;CTX6;Error +RPR1U;8JUJ;Error +RUDFB;7K54;OK +RZSGI;C1HD;Error +SF6HV;320A;Error +SHABI;2IMJ;Error +SKE83;SWZK;Error +SZHCN;Y4IB;OK +T2HR0;86AY;OK +T30ZM;4XKA;OK +TA2ZX;78TV;OK +TI5R3;IKXE;Error +TOBKY;XM2T;Error +TWPJ8;OT1T;Error +TWYGA;477Z;OK +U50BS;R86R;Error +UD0NQ;XM2T;OK +UFPVF;H0JJ;OK +UKB3Z;O8WM;Error +UN9GX;3D6Z;Error +UU7BT;BIDX;OK +UWPYB;W6HR;OK +V0RWP;OS6Z;OK +VF1XC;547O;Error +VL0MR;YOV8;Error +VNSLE;290Y;OK +VPXT7;8FFE;Error +VTLGW;OCGQ;OK +W0YTD;HEBA;OK +W208H;2IMJ;Error +W7EWC;B10O;Error +W9H9D;KN8K;OK +W9O8U;4FHE;OK +WP90I;28KA;Error +WWO8T;WLKL;Error +X51DD;HW49;Error +XD4W2;B6BP;Error +XKDG4;TT2A;Error +XRIP2;O8WM;Error +Y0NFF;30EP;Error +Y206X;2W1J;Error +Y3WZQ;H6KD;Error +Y8SLN;6641;OK +YJ05T;6D3Y;Error +YMLBK;RUNT;OK +YSKQ7;TIEF;OK +YYJ1D;H0JJ;Error +Z1TEX;78TV;Error +ZDYG9;61U6;OK +ZEZ6Z;78TV;Error +ZFQS2;YF49;OK +ZOW24;6IPE;OK +ZP83Z;MXRS;OK +ZREO5;I2MV;OK +ZREO5;T4BM;Error \ No newline at end of file diff --git a/QuickSort/TestFile3_d_200 b/QuickSort/TestFile3_d_200 new file mode 100755 index 0000000..8383af9 --- /dev/null +++ b/QuickSort/TestFile3_d_200 @@ -0,0 +1,200 @@ +ZO1DU;GDBX;Error +ZM6P0;OXS5;Error +ZJ295;MSF2;Error +Z0LWK;V6Q8;Error +YU5Z3;SCFY;OK +YTXJ6;5IMY;OK +YKYMG;2HLI;Error +YGUXQ;3A2Q;OK +YA5YS;LEDT;Error +Y96AD;ZUVS;OK +XYEE7;V05Q;Error +XRTJ4;SZ51;OK +XPJ1I;NUNP;Error +XODKE;R0GS;Error +XH100;SDGS;OK +XFDA0;4MEA;Error +XB7KM;BTR6;OK +X6VO7;WUUF;OK +X2Z08;LEDT;Error +X0YIQ;MEHI;Error +WO4CA;N1IP;Error +WGS8F;EPS3;Error +WCQIY;ZFNL;OK +W74FU;X0ZB;OK +VUW9Q;W4KH;OK +V8HBK;29NW;Error +V5J1T;ZFNL;OK +V1GG0;ICWE;OK +UUNDE;EXV3;OK +UPX7E;PFBH;Error +UGKXM;5JZN;OK +U9UG9;2882;OK +TSE8O;XRG2;Error +TQQIB;SI92;OK +TLLVS;ARTY;OK +TKMV6;QRU2;OK +TH2QA;R0GS;Error +TB5RR;NBKW;OK +T66SV;D8YG;OK +SQ13L;TX35;Error +SMSDM;F4N4;Error +SI3WP;2HLI;Error +SDERI;QVNH;Error +SBLLT;5BF2;Error +S4NUJ;FWAK;Error +RVEWD;YMA9;OK +RRSA0;HU2H;Error +RGDSE;DWUE;Error +R6DIW;GSV9;Error +R3AGO;PYDN;Error +R1C6R;7BNX;Error +QOTSI;MEHI;Error +QMM5X;XPD9;Error +QH8MK;BC31;Error +Q5H11;QVNH;Error +Q3FE0;SDGS;OK +PU3JF;S2MI;Error +PU3JF;FX7J;OK +PRF4N;TQUJ;Error +PHBAF;PRW7;OK +PB6G5;EIPO;Error +P8ZJ5;3A2Q;OK +P34UA;W4KH;OK +OZNJS;SP8I;OK +OYFZZ;5EYM;Error +OO9YN;CE4Q;Error +OEZY2;D29M;OK +O1D4G;S41M;Error +N62UY;ICWE;OK +MWYVH;C8Z2;Error +MRVHM;PFBH;Error +MJ13E;VKF3;Error +ME6BN;W4KH;OK +LWQ1L;TQUJ;OK +LW02D;4DDN;OK +LVLC1;O6WN;Error +LVE40;PYDN;Error +LQH6F;YCRZ;OK +LMQ27;DWUE;OK +L8CZE;RTXJ;OK +L6RT3;TX35;Error +L2QHP;B2QZ;OK +KOJKH;2DPE;OK +KOEK2;XHJP;Error +K3YSH;JEQS;OK +JR6B8;SZ51;Error +JIS9P;BTR6;OK +J6O2J;AII4;OK +IY2EI;P25G;Error +IR9XI;XPD9;OK +IFCGL;SQS8;OK +I49PQ;SZ51;OK +GVJL4;XNXZ;OK +GSR9K;55V3;Error +GORER;B69I;OK +GMERC;YCRZ;OK +GJAWO;PRW7;Error +G5EM7;PBQ5;OK +FYADB;V05Q;Error +FQEVM;8DED;OK +FN2ZA;ICWE;Error +FMY2D;4MEA;Error +EUQ1M;TVVU;Error +ESRAF;0T71;OK +ER3JT;VCD8;OK +EJHHA;ACYP;OK +EFPW5;9X4V;OK +EC1YV;M284;Error +E24VL;24TG;OK +DZEQJ;MSF2;OK +DX3TN;V05Q;Error +DJO3L;SJPV;OK +DIXZD;YMA9;Error +DIGB5;EDII;OK +DFGMB;EHND;Error +D34C2;YCRZ;OK +COTWD;WFK8;OK +CN37J;FOAM;OK +CMBIK;LM9M;Error +CJLIM;ZFNL;OK +C95YJ;4PKB;Error +C5FQR;DWUE;OK +C3QHX;WUUF;Error +BYG1U;2882;OK +BUE8Q;FARW;Error +BT7XY;SZ51;Error +BHFY0;29NW;OK +B4VTE;64PV;OK +B2SLO;D29M;Error +AZRTF;FOAM;Error +AYNQO;T4V4;Error +AQKL0;AII4;OK +AQJH9;QVNH;Error +AO5ZW;PRJA;OK +AO5ZW;9X4V;OK +AMBLP;MEHI;Error +9UKTM;FOAM;OK +9SC2K;X7S3;Error +9POHW;9X4V;OK +990B1;SCFY;OK +97KG6;U1D1;OK +91KC1;QK0I;Error +8YC3S;ICWE;Error +8NM3T;RTXJ;OK +8L88L;NGZ9;Error +8HWP6;SDGS;OK +8AJ9T;86II;Error +8A8FT;55V3;Error +83P67;0N2X;OK +7RP8O;6C3I;OK +7PAZY;SZ51;OK +7PAZY;D8YG;OK +7L3K6;W4KH;OK +74FE7;TX35;Error +74BDS;2V2J;Error +712AV;FVPH;OK +70SQB;SZXV;Error +6Q51I;PRW7;OK +6PW1Z;ML9P;Error +6CAGY;EHND;Error +6359P;02LG;OK +5XNOX;0FX7;OK +5MHY8;RTXJ;OK +5M350;LM9M;Error +5I6ZW;SI92;OK +5I6ZW;BTR6;Error +5GPJ9;SZ51;OK +5FWYC;LM9M;Error +583CX;B51W;OK +573GG;XPD9;Error +4YLPA;PH7F;Error +4RY8Y;2HLI;Error +4ONGU;H44A;Error +4NB1R;FVPH;Error +4GI7V;NBKW;Error +3RRU3;V05Q;OK +3Q5O4;BC31;OK +3OUOJ;3A2Q;Error +3EN9P;VKF3;Error +3EN9P;29NW;Error +3DX9I;NZW9;Error +3CGFX;YM99;OK +3BHYG;LEDT;OK +2Z70A;7AJW;Error +2TDAX;OF8A;OK +2TDAX;NZW9;Error +2P5B1;OXS5;OK +2P0RS;F4N4;OK +2CA7C;5JZN;Error +2BCKD;QMWG;Error +2AUCZ;FU3M;Error +1PXRN;XPD9;OK +1G0XB;VCD8;OK +1D08J;SDGS;OK +1D08J;OXS5;Error +1AJRT;6S6G;OK +16Z41;EXFN;OK +0X1VU;ICWE;OK +0N3JO;IMPQ;Error +0BOFM;ZHMP;Error diff --git a/QuickSort/bin/frame/AllTests$QuickSortAComplexityTest.class b/QuickSort/bin/frame/AllTests$QuickSortAComplexityTest.class new file mode 100644 index 0000000..ac101eb Binary files /dev/null and b/QuickSort/bin/frame/AllTests$QuickSortAComplexityTest.class differ diff --git a/QuickSort/bin/frame/AllTests$QuickSortASortingTest.class b/QuickSort/bin/frame/AllTests$QuickSortASortingTest.class new file mode 100644 index 0000000..6341e7e Binary files /dev/null and b/QuickSort/bin/frame/AllTests$QuickSortASortingTest.class differ diff --git a/QuickSort/bin/frame/AllTests$QuickSortBComplexityTest.class b/QuickSort/bin/frame/AllTests$QuickSortBComplexityTest.class new file mode 100644 index 0000000..4aec976 Binary files /dev/null and b/QuickSort/bin/frame/AllTests$QuickSortBComplexityTest.class differ diff --git a/QuickSort/bin/frame/AllTests$QuickSortBSortingTest.class b/QuickSort/bin/frame/AllTests$QuickSortBSortingTest.class new file mode 100644 index 0000000..efbd230 Binary files /dev/null and b/QuickSort/bin/frame/AllTests$QuickSortBSortingTest.class differ diff --git a/QuickSort/bin/frame/AllTests$TestFileProvider$1.class b/QuickSort/bin/frame/AllTests$TestFileProvider$1.class new file mode 100644 index 0000000..b970e46 Binary files /dev/null and b/QuickSort/bin/frame/AllTests$TestFileProvider$1.class differ diff --git a/QuickSort/bin/frame/AllTests$TestFileProvider$2.class b/QuickSort/bin/frame/AllTests$TestFileProvider$2.class new file mode 100644 index 0000000..8af5f4c Binary files /dev/null and b/QuickSort/bin/frame/AllTests$TestFileProvider$2.class differ diff --git a/QuickSort/bin/frame/AllTests$TestFileProvider.class b/QuickSort/bin/frame/AllTests$TestFileProvider.class new file mode 100644 index 0000000..e07fb5e Binary files /dev/null and b/QuickSort/bin/frame/AllTests$TestFileProvider.class differ diff --git a/QuickSort/bin/frame/AllTests.class b/QuickSort/bin/frame/AllTests.class new file mode 100644 index 0000000..b2d1ca3 Binary files /dev/null and b/QuickSort/bin/frame/AllTests.class differ diff --git a/QuickSort/bin/frame/LibraryFileReader.class b/QuickSort/bin/frame/LibraryFileReader.class new file mode 100644 index 0000000..2214ab4 Binary files /dev/null and b/QuickSort/bin/frame/LibraryFileReader.class differ diff --git a/QuickSort/bin/frame/SortArray.class b/QuickSort/bin/frame/SortArray.class new file mode 100644 index 0000000..7d473d0 Binary files /dev/null and b/QuickSort/bin/frame/SortArray.class differ diff --git a/QuickSort/bin/frame/SortingLab.class b/QuickSort/bin/frame/SortingLab.class new file mode 100644 index 0000000..2c17c7d Binary files /dev/null and b/QuickSort/bin/frame/SortingLab.class differ diff --git a/QuickSort/bin/lab/QuickSort.class b/QuickSort/bin/lab/QuickSort.class new file mode 100644 index 0000000..7df78d9 Binary files /dev/null and b/QuickSort/bin/lab/QuickSort.class differ diff --git a/QuickSort/bin/lab/QuickSortA.class b/QuickSort/bin/lab/QuickSortA.class new file mode 100644 index 0000000..f921d0f Binary files /dev/null and b/QuickSort/bin/lab/QuickSortA.class differ diff --git a/QuickSort/bin/lab/QuickSortB.class b/QuickSort/bin/lab/QuickSortB.class new file mode 100644 index 0000000..8efcb5d Binary files /dev/null and b/QuickSort/bin/lab/QuickSortB.class differ diff --git a/QuickSort/bin/lab/SortingItem.class b/QuickSort/bin/lab/SortingItem.class new file mode 100644 index 0000000..c66b982 Binary files /dev/null and b/QuickSort/bin/lab/SortingItem.class differ diff --git a/QuickSort/src/frame/AllTests.java b/QuickSort/src/frame/AllTests.java new file mode 100755 index 0000000..7c07034 --- /dev/null +++ b/QuickSort/src/frame/AllTests.java @@ -0,0 +1,271 @@ +package frame; + +import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FilenameFilter; +import java.time.Duration; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Stream; + +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.api.TestInstance.Lifecycle; +import org.junit.jupiter.api.extension.ExtensionContext; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.ArgumentsProvider; +import org.junit.jupiter.params.provider.ArgumentsSource; + +import lab.SortingItem; + +/** + * Do NOT change anything in this class! + * + * The test cases defined by this class are used to test if the input file was + * correctly sorted. This class is also responsible for outputting to the + * console. + * + */ + +@DisplayName("QuickSort tests") +class AllTests { + + protected static int NrOfTestFiles; + protected int correct = 0; + protected Duration timeout = Duration.ofSeconds(3); + + static class TestFileProvider implements ArgumentsProvider { + + @Override + public Stream provideArguments(ExtensionContext context) throws Exception { + File dir = new File(System.getProperty("user.dir")); + FilenameFilter filter; + if (context.getParent().get().getDisplayName().startsWith("QuickSortB Complexity")) { + filter = new FilenameFilter() { + public boolean accept(File dir, String name) { + return name.startsWith("TestFile") && !name.contains("_d_"); + } + }; + } else { + filter = new FilenameFilter() { + public boolean accept(File dir, String name) { + return name.startsWith("TestFile"); + } + }; + } + String[] inputFiles = dir.list(filter); + if (inputFiles == null) { + throw new FileNotFoundException("Error: No TestFiles found!"); + } else { + Arrays.sort(inputFiles); + NrOfTestFiles = inputFiles.length; + List tests = new ArrayList(); + for (int i = 0; i < inputFiles.length; i++) { + tests.add(Arguments.of(inputFiles[i], SortingLab.readFile(inputFiles[i]))); + } + return tests.stream(); + } + } + } + + protected boolean sortingTester(SortArray records) { + boolean sorted = true; + SortingItem lastRecord = records.getElementAt(0); + for (int i = 1; i < records.getNumberOfItems() && sorted; i++) { + SortingItem actualRecord = records.getElementAt(i); + sorted = (actualRecord.BookSerialNumber.compareTo(lastRecord.BookSerialNumber) > 0) + || ((actualRecord.BookSerialNumber.compareTo(lastRecord.BookSerialNumber) == 0) + && ((actualRecord.ReaderID.compareTo(lastRecord.ReaderID) > 0) + || ((actualRecord.ReaderID.compareTo(lastRecord.ReaderID) == 0)))); + lastRecord = actualRecord; + } + return sorted; + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + @DisplayName("QuickSortA Sorting") + class QuickSortASortingTest { + + @BeforeAll + public void init() { + correct = 0; + System.out.println("Starting QuicksortA tests!"); + } + + @AfterAll + public void tearDown() { + System.out.println("Correct QuicksortA sortings: " + correct + " out of " + NrOfTestFiles + " tests\n"); + } + + @DisplayName("Tests") + @ParameterizedTest(name = "QuicksortA sorting test with input: {0}") + @ArgumentsSource(TestFileProvider.class) + public void testQuicksortA(String inputFile, SortArray records) { + assertTimeoutPreemptively(timeout, () -> { + SortingLab.QuicksortA(records, 0, records.getNumberOfItems() - 1); + }, () -> { + System.out.println("QuicksortA [" + inputFile + "]: Execution timed out after: " + timeout.getSeconds() + + " seconds"); + return "Test failed!"; + }); + int readOps = records.getReadingOperations(); + int writeOps = records.getWritingOperations(); + assertTrue(sortingTester(records), () -> { + System.out.println("QuicksortA [" + inputFile + "]: Wrong order!"); + return "Test failed!"; + }); + System.out.println( + "QuicksortA [" + inputFile + "]: Correct order! Read Ops: " + readOps + "; Write Ops: " + writeOps); + correct++; + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + @DisplayName("QuickSortB Sorting") + class QuickSortBSortingTest { + + @BeforeAll + public void init() { + correct = 0; + System.out.println("Starting QuicksortB tests!"); + } + + @AfterAll + public void tearDown() { + System.out.println("Correct QuicksortB sortings: " + correct + " out of " + NrOfTestFiles + " tests\n"); + } + + @DisplayName("Tests") + @ParameterizedTest(name = "QuicksortB sorting test with input: {0}") + @ArgumentsSource(TestFileProvider.class) + public void testQuicksortB(String inputFile, SortArray records) { + assertTimeoutPreemptively(timeout, () -> { + SortingLab.QuicksortB(records, 0, records.getNumberOfItems() - 1); + }, () -> { + System.out.println("QuicksortB [" + inputFile + "]: Execution timed out after: " + timeout.getSeconds() + + " seconds"); + return "Test failed!"; + }); + int readOps = records.getReadingOperations(); + int writeOps = records.getWritingOperations(); + assertTrue(sortingTester(records), () -> { + System.out.println("QuicksortB [" + inputFile + "]: Wrong order!"); + return "Test failed!"; + }); + System.out.println( + "QuicksortB [" + inputFile + "]: Correct order! Read Ops: " + readOps + "; Write Ops: " + writeOps); + correct++; + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + @DisplayName("QuickSortA Complexity") + class QuickSortAComplexityTest { + + @BeforeAll + public void init() { + correct = 0; + System.out.println("Starting QuicksortA complexity tests!"); + } + + @AfterAll + public void tearDown() { + System.out.println( + "Passed complexity tests for QuicksortA: " + correct + " out of " + NrOfTestFiles + " tests\n"); + } + + private void complexityTesterA(SortArray records, String inputFile, int readOps) { + int n = records.getNumberOfItems(); + double nlogn = n * (Math.log(n) / Math.log(2)) * 5; + assertTrue(readOps > 0); + if (inputFile.contains("_r_")) { + assertTrue(readOps < nlogn, () -> { + System.out.println("QuickSortA complexity test failed for file: " + inputFile + + " - complexity out of allowed range: O(nlog(n)) required!"); + return "Test failed!"; + }); + } else if (inputFile.contains("_a_") || inputFile.contains("_d_")) { + assertTrue(readOps > Math.pow(n, 2) / 2, () -> { + System.out.println("QuickSortA complexity test failed for file: " + inputFile + + " - complexity out of allowed range: O(n^2) required!"); + return "Test failed!"; + }); + } + correct++; + } + + @DisplayName("Tests") + @ParameterizedTest(name = "QuicksortA complexity test with input: {0}") + @ArgumentsSource(TestFileProvider.class) + public void testQuicksortAComplexity(String inputFile, SortArray records) { + assertTimeoutPreemptively(timeout, () -> { + SortingLab.QuicksortA(records, 0, records.getNumberOfItems() - 1); + }, () -> { + System.out.println("Complexity QuicksortA [" + inputFile + "]: Execution timed out after: " + + timeout.getSeconds() + " seconds"); + return "Test failed!"; + }); + int readOps = records.getReadingOperations(); + complexityTesterA(records, inputFile, readOps); + System.out.println("Complexity QuicksortA [" + inputFile + "]: Complexity within allowed range!"); + } + } + + @Nested + @TestInstance(Lifecycle.PER_CLASS) + @DisplayName("QuickSortB Complexity") + class QuickSortBComplexityTest { + + @BeforeAll + public void init() { + correct = 0; + System.out.println("Starting QuicksortB complexity tests!"); + } + + @AfterAll + public void tearDown() { + System.out.println( + "Passed complexity tests for QuicksortB: " + correct + " out of " + NrOfTestFiles + " tests\n"); + } + + private void complexityTesterB(SortArray records, String inputFile, int readOps) { + int n = records.getNumberOfItems(); + double nlogn = n * (Math.log(n) / Math.log(2)) * 5; + + assertTrue(readOps > 0); + assertTrue(readOps < nlogn, () -> { + System.out.println("QuickSortB complexity test failed for file: " + inputFile + + " - complexity out of allowed range: O(nlog(n)) required!"); + return "Test failed!"; + }); + correct++; + } + + @DisplayName("Tests") + @ParameterizedTest(name = "QuicksortB complexity test with input: {0}") + @ArgumentsSource(TestFileProvider.class) + public void testQuicksortBComplexity(String inputFile, SortArray records) { + assertTimeoutPreemptively(timeout, () -> { + SortingLab.QuicksortB(records, 0, records.getNumberOfItems() - 1); + }, () -> { + System.out.println("Complexity QuicksortB [" + inputFile + "]: Execution timed out after: " + + timeout.getSeconds() + " seconds"); + return "Test failed!"; + }); + int readOps = records.getReadingOperations(); + complexityTesterB(records, inputFile, readOps); + System.out.println("Complexity QuicksortB [" + inputFile + "]: Complexity within allowed range!"); + } + } +} \ No newline at end of file diff --git a/QuickSort/src/frame/LibraryFileReader.java b/QuickSort/src/frame/LibraryFileReader.java new file mode 100755 index 0000000..4d7bd4b --- /dev/null +++ b/QuickSort/src/frame/LibraryFileReader.java @@ -0,0 +1,67 @@ +package frame; + +import java.io.BufferedReader; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.util.ArrayList; + +/** + * Do NOT change anything in this class! + * + * This class contains a method for reading the input files into a Vector + * structure. + * + * @author Stefan Kropp + */ +public class LibraryFileReader { + + private String filename = null; + private ArrayList data = null; + + /** + * The file should be in the same directory as the java application. if not, + * you have to provide the absolute or relative path information within the + * filename string. + * + * @param filename + * the name of the file to read + */ + public LibraryFileReader(String filename) { + this.filename = filename; + this.data = new ArrayList(); + } + + /** + * Reads a file, specified in the private field filename and returns the + * information read. The file should have the same format as specified in + * the first lab. + * + * @return Returns a Vector which holds 3-dimensional String arrays with + * following format: BookSerialNumber, ReaderID, Status. In the case + * an error occured null is returned. + */ + public ArrayList readFile() { + try { + FileReader fr = new FileReader(filename); + BufferedReader in = new BufferedReader(fr); + + String line; + while ((line = in.readLine()) != null) { + data.add(line.split(";")); + } + + in.close(); + fr.close(); + + return data; + + } catch (FileNotFoundException e) { + e.printStackTrace(); + return null; + } catch (IOException e) { + e.printStackTrace(); + return null; + } + } +} diff --git a/QuickSort/src/frame/SortArray.java b/QuickSort/src/frame/SortArray.java new file mode 100755 index 0000000..0ef5fbb --- /dev/null +++ b/QuickSort/src/frame/SortArray.java @@ -0,0 +1,103 @@ +package frame; + +import java.util.ArrayList; + +import lab.SortingItem; + +/** + * Do NOT change anything in this class! + * + * The SortArray class provides simple basic functions, to store a list of + * sortingItems to track the number of operations. + * + * This class contains two members (readingOperations and writingOperations) + * that act as counters for the number of accesses to the arrays to be sorted. + * These are used by the JUnit tests to construct the output. The methods + * provided in this class should be sufficient for you to sort the records of + * the input files. + * + * @author Stefan Kropp + */ + +public class SortArray { + + private int numberOfItems; + + private ArrayList listOfItems; + + private int readingOperations; + private int writingOperations; + + /** + * @param numberOfItems + * number of items to hold + */ + public SortArray(ArrayList items) { + numberOfItems = items.size(); + readingOperations = 0; + writingOperations = 0; + listOfItems = new ArrayList<>(); + + for (String[] element : items) { + SortingItem s = new SortingItem(); + s.BookSerialNumber = element[0]; + s.ReaderID = element[1]; + s.Status = element[2]; + listOfItems.add(s); + } + } + + /** + * sets the elements at index. if index is >= numberOfItems or less then + * zero an IndexOutOfBoundException will occur. + * + * @param index + * the index of the Elements to set + * @param record + * a 3-dimensional record which holds: BookSerialNumber, + * ReaderID, Status + */ + public void setElementAt(int index, SortingItem record) { + this.listOfItems.set(index, record); + + writingOperations++; + } + + /** + * Retrieves the information stored at position Index. if index is >= + * numberOfItems or less then zero an IndexOutOfBoundException will occur. + * + * @param index + * Index defines which elements to retrieve from the SortArray + * @return Returns a 3-dimensional String array with following format: + * BookSerialNumber, ReaderID, Status. + * + */ + public SortingItem getElementAt(int index) { + + SortingItem result = new SortingItem(this.listOfItems.get(index)); + readingOperations++; + return result; + } + + /** + * @return Returns the number of reading operations. + */ + public int getReadingOperations() { + return readingOperations; + } + + /** + * @return Returns the number of writing operations. + */ + public int getWritingOperations() { + return writingOperations; + } + + /** + * @return Returns the numberOfItems. + */ + public int getNumberOfItems() { + return numberOfItems; + } +} diff --git a/QuickSort/src/frame/SortingLab.java b/QuickSort/src/frame/SortingLab.java new file mode 100755 index 0000000..752d771 --- /dev/null +++ b/QuickSort/src/frame/SortingLab.java @@ -0,0 +1,61 @@ +package frame; + +import lab.QuickSort; +import lab.QuickSortA; +import lab.QuickSortB; + +public class SortingLab { + + /** + * Reads the file specified in filename and returns the data as a SortArray + * + * @param filename + * the path and name of the file to read + * @return Returns a SortArray filled with the data of the input file + */ + public static SortArray readFile(String filename) { + LibraryFileReader fileReader = new LibraryFileReader(filename); + return new SortArray(fileReader.readFile()); + } + + static QuickSort sortingMethod; + + /** + * Uses the Quicksort A algorithm to sort the records (the pivot is the + * first element in the list) + * + * @param records + * unsorted SortArray data + * @param left + * the left bound for the algorithm + * @param right + * the right bound for the algorithm + * @return Returns the sorted SortArray + */ + public static SortArray QuicksortA(SortArray records, int left, int right) { + + sortingMethod = new QuickSortA(); + sortingMethod.Quicksort(records, left, right); + return records; + } + + /** + * Uses the Quicksort B algorithm to sort the records (the pivot is the + * median between first, last and middle element in the list) + * + * @param records + * unsorted SortArray data + * @param left + * the left bound for the algorithm + * @param right + * the right bound for the algorithm + * @return Returns the sorted SortArray + */ + public static SortArray QuicksortB(SortArray records, int left, int right) { + + sortingMethod = new QuickSortB(); + sortingMethod.Quicksort(records, left, right); + return records; + } + +} diff --git a/QuickSort/src/lab/QuickSort.java b/QuickSort/src/lab/QuickSort.java new file mode 100755 index 0000000..006d8ac --- /dev/null +++ b/QuickSort/src/lab/QuickSort.java @@ -0,0 +1,17 @@ +package lab; + +import frame.SortArray; + +/** + * Abstract superclass for the Quicksort algorithm. + * + * @author NAJI + */ +public abstract class QuickSort { + + // DO NOT modify this method + public abstract void Quicksort(SortArray records, int left, int right); + + // You may add additional methods here + +} diff --git a/QuickSort/src/lab/QuickSortA.java b/QuickSort/src/lab/QuickSortA.java new file mode 100755 index 0000000..b16b679 --- /dev/null +++ b/QuickSort/src/lab/QuickSortA.java @@ -0,0 +1,28 @@ +package lab; + +import frame.SortArray; + +public class QuickSortA extends QuickSort { + + /** + * Quicksort algorithm implementation to sort a SorrtArray by choosing the + * pivot as the first (leftmost) element in the list + * + * @param records + * - list of elements to be sorted as a SortArray + * @param left + * - the index of the left bound for the algorithm + * @param right + * - the index of the right bound for the algorithm + * @return Returns the sorted list as SortArray + */ + @Override + public void Quicksort(SortArray records, int left, int right) { + // TODO + // implement the Quicksort A algorithm to sort the records + // (choose the pivot as the first (leftmost) element in the list) + } + + // You may add additional methods here + +} diff --git a/QuickSort/src/lab/QuickSortB.java b/QuickSort/src/lab/QuickSortB.java new file mode 100755 index 0000000..8376ddc --- /dev/null +++ b/QuickSort/src/lab/QuickSortB.java @@ -0,0 +1,29 @@ +package lab; + +import frame.SortArray; + +public class QuickSortB extends QuickSort { + + /** + * Quicksort algorithm implementation to sort a SorrtArray by choosing the + * pivot as the median of the elements at positions (left,middle,right) + * + * @param records + * - list of elements to be sorted as a SortArray + * @param left + * - the index of the left bound for the algorithm + * @param right + * - the index of the right bound for the algorithm + * @return Returns the sorted list as SortArray + */ + @Override + public void Quicksort(SortArray records, int left, int right) { + // TODO + // implement the Quicksort B algorithm to sort the records + // (choose the pivot as the median value of the elements at position + // (left (first),middle,right(last))) + } + + // You may add additional methods here + +} diff --git a/QuickSort/src/lab/SortingItem.java b/QuickSort/src/lab/SortingItem.java new file mode 100755 index 0000000..036b3bb --- /dev/null +++ b/QuickSort/src/lab/SortingItem.java @@ -0,0 +1,29 @@ +package lab; + +/** + * + * This class represents one entry of the list that has to be sorted. + * + */ +public class SortingItem { + + // DO NOT modify + public String BookSerialNumber; + public String ReaderID; + public String Status; + + // DO NOT modify + public SortingItem() { + + } + + // DO NOT modify + public SortingItem(SortingItem otherItem) { + this.BookSerialNumber = otherItem.BookSerialNumber; + this.ReaderID = otherItem.ReaderID; + this.Status = otherItem.Status; + } + + // You may add additional methods here + +}