From 47c3c2c3af9cd907461cb74fd913ea199e3ad5bb Mon Sep 17 00:00:00 2001 From: elizaveta Date: Tue, 4 Oct 2022 04:57:14 +0300 Subject: [PATCH 1/2] done --- .../.github/actions/gradle-build/action.yaml | 17 + .../.github/actions/maven-build/action.yaml | 16 + .../.github/workflows/integration.yml | 29 ++ .../algorithms-project-2022/.gitignore | 18 + .../algorithms-project-2022/README.md | 54 +++ .../src/main/Deramida$DeramidaIterator.class | Bin 0 -> 2188 bytes .../src/main/Deramida$Node.class | Bin 0 -> 945 bytes .../src/main/Deramida$NodePair.class | Bin 0 -> 1072 bytes .../Deramida$SubTree$SubTreeIterator.class | Bin 0 -> 2462 bytes .../src/main/Deramida$SubTree.class | Bin 0 -> 2574 bytes .../src/main/Deramida.class | Bin 0 -> 9668 bytes .../src/main/Main.class | Bin 0 -> 2035 bytes .../src/test/DeramidaTest.class | Bin 0 -> 6958 bytes src/main/Deramida.java | 428 ++++++++++++++++++ src/main/Main.java | 55 +++ src/test/DeramidaTest.java | 372 +++++++++++++++ 16 files changed, 989 insertions(+) create mode 100644 out/production/algorithms-project-2022/.github/actions/gradle-build/action.yaml create mode 100644 out/production/algorithms-project-2022/.github/actions/maven-build/action.yaml create mode 100644 out/production/algorithms-project-2022/.github/workflows/integration.yml create mode 100644 out/production/algorithms-project-2022/.gitignore create mode 100644 out/production/algorithms-project-2022/README.md create mode 100644 out/production/algorithms-project-2022/src/main/Deramida$DeramidaIterator.class create mode 100644 out/production/algorithms-project-2022/src/main/Deramida$Node.class create mode 100644 out/production/algorithms-project-2022/src/main/Deramida$NodePair.class create mode 100644 out/production/algorithms-project-2022/src/main/Deramida$SubTree$SubTreeIterator.class create mode 100644 out/production/algorithms-project-2022/src/main/Deramida$SubTree.class create mode 100644 out/production/algorithms-project-2022/src/main/Deramida.class create mode 100644 out/production/algorithms-project-2022/src/main/Main.class create mode 100644 out/production/algorithms-project-2022/src/test/DeramidaTest.class create mode 100644 src/main/Deramida.java create mode 100644 src/main/Main.java create mode 100644 src/test/DeramidaTest.java diff --git a/out/production/algorithms-project-2022/.github/actions/gradle-build/action.yaml b/out/production/algorithms-project-2022/.github/actions/gradle-build/action.yaml new file mode 100644 index 0000000..c05ca06 --- /dev/null +++ b/out/production/algorithms-project-2022/.github/actions/gradle-build/action.yaml @@ -0,0 +1,17 @@ +name: 'Gradle build' +description: 'Run gradle test' +runs: + using: "composite" + steps: + - name: Run the Gradle test task + uses: gradle/gradle-build-action@v2 + with: + arguments: test + - name: Check test report exists # if project has no tests then report is not generated + shell: bash + run: | + if [[ -z $(find . -path "*build/test-results/test/TEST-*.xml") ]] + then + echo "No tests found" + exit 1 + fi \ No newline at end of file diff --git a/out/production/algorithms-project-2022/.github/actions/maven-build/action.yaml b/out/production/algorithms-project-2022/.github/actions/maven-build/action.yaml new file mode 100644 index 0000000..a21b2e6 --- /dev/null +++ b/out/production/algorithms-project-2022/.github/actions/maven-build/action.yaml @@ -0,0 +1,16 @@ +name: 'Maven build' +description: 'Run maven package' +runs: + using: "composite" + steps: + - name: Run the Maven package task + shell: bash + run: mvn package --file pom.xml | tee mvn_out + - name: Check tests exists + shell: bash + run: | + if [[ -z $(cat mvn_out | grep -E "Tests run: [1-9]") ]] + then + echo "No tests found" + exit 1 + fi \ No newline at end of file diff --git a/out/production/algorithms-project-2022/.github/workflows/integration.yml b/out/production/algorithms-project-2022/.github/workflows/integration.yml new file mode 100644 index 0000000..3bed121 --- /dev/null +++ b/out/production/algorithms-project-2022/.github/workflows/integration.yml @@ -0,0 +1,29 @@ +name: Java CI + +on: + push: + pull_request: + types: [ opened, synchronize, reopened, edited, assigned ] + +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v1 + - name: Set up JDK 17 + uses: actions/setup-java@v1 + with: + java-version: 17 + - name: Check maven build + if: hashFiles('pom.xml') != '' + uses: ./.github/actions/maven-build + - name: Check gradle build + if: hashFiles('gradlew') != '' + uses: ./.github/actions/gradle-build + - name: Fail if build system is not detected + if: hashFiles('pom.xml') == '' && hashFiles('gradlew') == '' + run: | + echo "No build system found" + exit 1 diff --git a/out/production/algorithms-project-2022/.gitignore b/out/production/algorithms-project-2022/.gitignore new file mode 100644 index 0000000..3798a3f --- /dev/null +++ b/out/production/algorithms-project-2022/.gitignore @@ -0,0 +1,18 @@ +.gradle +.idea +/build/ +/target/ + +# Ignore Gradle GUI config +gradle-app.setting + +# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored) +!gradle-wrapper.jar + +# Cache of project +.gradletasknamecache + +# # Work around https://youtrack.jetbrains.com/issue/IDEA-116898 +# gradle/wrapper/gradle-wrapper.properties + +*.iml \ No newline at end of file diff --git a/out/production/algorithms-project-2022/README.md b/out/production/algorithms-project-2022/README.md new file mode 100644 index 0000000..1ab10ed --- /dev/null +++ b/out/production/algorithms-project-2022/README.md @@ -0,0 +1,54 @@ +# Базовый репозиторий для курсового проекта по курсу "Алгоритмы и структуры данных" + +## Инструкция +1. Сделайте [fork](https://docs.github.com/en/get-started/quickstart/fork-a-repo) репозитория + * после того как вы сделали fork, перейдите во вкладку Actions в вашем репозитории и включите их (будет большая зеленая кнопка) +3. Настройте систему сборки [maven](https://maven.apache.org/) или [gradle](https://gradle.org/) + * [Работа с maven в IDEA](https://www.jetbrains.com/help/idea/maven-support.html) + * [Работа с gradle в IDEA](https://www.jetbrains.com/help/idea/gradle.html) +4. Используйте этот репозиторий в процессе работы над своей задачей. Весь код и необходимые артефакты +должны быть в репозитории на момент сдачи. **Обязательное условие**: ваше решение должно содержать тесты, +которые должны **успешно проходить**. Дополнительная информация по конфигурации сборки: + * Если вы используете Maven, то вам необходимо явно указать необходимую версию JDK (не ниже 1.8). Пример конфигурации + для Java и JDK 11: + ```xml + + 11 + ${jvm.version} + ${jvm.version} + + ``` + Если все сконфигурировано правильно, то при запуске команды `mvn package` в консоль будет выводиться информация + о сборке и запущенных тестах. Пример необходимого вывода: + ```shell + ... + [INFO] ------------------------------------------------------- + [INFO] T E S T S + [INFO] ------------------------------------------------------- + [INFO] + [INFO] Results: + [INFO] + [INFO] Tests run: 7, Failures: 0, Errors: 0, Skipped: 0 + [INFO] + [INFO] ------------------------------------------------------------------------ + [INFO] BUILD SUCCESS + [INFO] ------------------------------------------------------------------------ + [INFO] Total time: 20.524 s + [INFO] Finished at: 2022-02-01T22:28:30+03:00 + [INFO] ------------------------------------------------------------------------ + ``` + * Если вы используете Gradle, то ничего дополнительного делать не нужно. Перед сдачей своего решения убедитесь, что + при запуске команды `./gradlew build` (или `./gradlew test`) в папке `build/test-results/test` генерируется xml файл + с отчетом о выполненных тестах. Пример успешного выполнения команды `./gradlew build`: + ```shell + BUILD SUCCESSFUL in 7s + 7 actionable tasks: 7 executed + ``` + В той же директории, в которой у вас находится файл `build.gradle` (или `build.gradle.kts`), должна появиться директория `build`. + В результате выполнения команды `./gradlew build` должен сгенерироваться файл с именем `build/test-results/test/TEST-myapp.test.Test.xml`, + где `myapp.test.Test` — имя вашего тестового класса. Если тестовых классов несколько, то для каждого из них генерируется отдельный отчет. +4. Чтобы сдать задание откройте [pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request-from-a-fork) + * В качестве `base repository` выберите этот (базовый) репозиторий. В качестве ветки `base` выберите ветку `main` + * В качестве `head repository` выберите ваш репозиторий (fork). В качестве ветки `compare` выберите ветку 'main' + * В заголовке PR укажите ваше имя, название задания, и номер группы + * например, "Иванов И.И., 'Шашки рэндзю', гр. 3530901/00006" diff --git a/out/production/algorithms-project-2022/src/main/Deramida$DeramidaIterator.class b/out/production/algorithms-project-2022/src/main/Deramida$DeramidaIterator.class new file mode 100644 index 0000000000000000000000000000000000000000..dc102f459a82017edba535c3b1f6cd833b29abfe GIT binary patch literal 2188 zcmah}+in|G6kW%cOzcc*CrwO~0Bu5=`T}talmZTILz>b+>J}0bQmzwch^MtZ)_7c{ z;zv+_fEOM>YEp?x(5G^j0P(;J0>lfKe?Y7~W5;f$g_m>L=bXLPUVESY)jywn3g9`I zF@zA-5YZ7ukHSR5Ddnq%Rm-0-9iwV(7?bVAf=i2QI|@B+*=kH4RoK56xL$~(7cmWS z9evOhl9!FEM!sUyHuD$OFPkNo&u6Tf<(^asr!y-W_9-O1OHJ3Rqy}N1+CO{9J5A<13_YwMSH{K^%0C}7}N2fych`ZSBN;a z?Z)Z$VI2o?NTIjhY?LK>g|YPg9A{R9^n{K_Fi9WsL}4oJ^X&@1kO`V%n8FbaX&o6M zl?ssZxGTge=DY4(*{W;^R!+yGc#Kh7jrnTbz2@n8Nr>ll9Q97hMx$tMxf&i7FlI-bG_x~toDg`xC)7(b)qS)m(utj)4dO9GkE zSyqzVD<&xo2BXz*nqE6)F=tonhGVQ(ObyQ~9PFGdR4V4CQDI5AW*5y_p*ezi9cS@^ z;G0$ZswwIH&jfkWEa-RcTp?E4U7mf`;=X-;u0S{IMl#vu3zWhiJ$5mg7vY zJZ6@c3n!bmJHi+UoqT{0>whGWUT zWsJyYRhSGy27We~rS5idt=@K%3BLCu+uI)KBvSJT_IrQ%yisp4Ied?R_NpWCMbjB- z#y;UERv{NGqAuavsqy7yJuKNxr(~YBM3VkCy=loM|8mi6xaaH!bFVMdYNj(+F&Yh% z0wvow+x{4bWDVo|QN2)DM3^hKBd&{Vo*`V|$i}m~znDx)7p1j_r+s*tC$Dg~<-G(Z zvbk-j>`iFdTj*cAiNrRNS+$L!Z0-gQ?BJn~c{_|H&u^6D*NEW@4B<=G`!{6rEtb8r z5XT9;iWSbX5>$m%u654-*=w9b(!n?ii}yIoyHxHD0dF9g+rjv%ARlfaM?B;~M0o2v zj^DEx{D5Kn*oB(fMNMJNi(ODtzGt2Zs_fTrkxVXe9flfi3HCZo>`WYm&?;vkn-nrT z$X$`x9gM zi|PKmORw>OUSetM#ndE{vsCK@Q3ZdNv*1Um);ZC@FGfEPce?yW1AfIKej}~G-oo45 Zh42mxZyv!q=Rq$WBPbDOibcJF(7!bZ(d_^L literal 0 HcmV?d00001 diff --git a/out/production/algorithms-project-2022/src/main/Deramida$Node.class b/out/production/algorithms-project-2022/src/main/Deramida$Node.class new file mode 100644 index 0000000000000000000000000000000000000000..72e54077caa5782f5087b3497c132d09712a97dc GIT binary patch literal 945 zcmZWnTW=CU6#fQ~Tes~NEUmYS73)GP)O#YxOO26)U}8z%r!d0QWoeeh*f;-@CTQY= zKfoVl{AMXtySte)XU_FImtVhs`~>h4&ohW2o?&3*_4olX@0uWKzglSb`;BpU980=1Ol+dwYDMdI8-V+S5T(AnufpOwJVx ztFWm!mA>+5u^EjUrmh?7oP|8D())ut6UenMC!kRQ8!2pBxQ6QjYY~jh>vTz&4MFIa92&6pqDQFp>38z(V8Bp66?xG}+KK1q3*8!1!%14BD5YB3~ ztv%J5j*gYzmB%h|6VX8-wO-*wxlRO+Z1n!ZGVTY8R zCI#-pzK}b7moL4!RDbohZMK?Lf@cX8#@Z$K8FBtVv9ddZsC-ANB4${w?9H%N`HFRW z>l<#&aOVqc;@BfCFb=Se3~{aSmB$7*WfKoVU5vDdDl?m}7-Em1M!vv|bDhCD*X>X? euWKKPbM7G?Q5(Z!JPGdtp7PE@P*%V*#Qp&3I>Mj; literal 0 HcmV?d00001 diff --git a/out/production/algorithms-project-2022/src/main/Deramida$NodePair.class b/out/production/algorithms-project-2022/src/main/Deramida$NodePair.class new file mode 100644 index 0000000000000000000000000000000000000000..05efa402d8378a6cd31e1df9b7f8fe9c73e16568 GIT binary patch literal 1072 zcmb7C+int36kUf)xj3{yDQc}2E7h6l1)mF&)Ec8HL6Z{R5A+15fx*lSCcgVYnn+B1 z@B{oP<2o~i#ttvOoPEjKd+oi>{{83YF90ualtTi^3{nQtSQFUxy7z~&P6QXqHXj9eMaJjGVM^QM0Ld{4|3W5rv> zGge<9b;dOXHad>0y0ghZc|AE8GgIzNhjQGPo}=UIWJ)U`uoEX-%Ef`I|CWCKxG1;c zb*)~n**;!q-Qrr@sm&%iGxGJ2*^vr*kyaJciZ4PbO)FGnfuvkIrR8b0&QIbc{S~=( z943&zn9jVRdhKXY3XAJF)<4F>niVTEPY>5x$I(7)cC_$ z-eMAEeGL$(FiK#HF~5BoSBph`q9GEzvAe|FWAueKMO(2C<`DJ|WbDH^3ii<)rEekn zKHqYP*+q_g>v+u0d)Q{aMqbw90d{D$r)Nlno@P(tA^jWFBMk~sTT4`xsA%S0PFrL5 zXtGmAg6OpU9fhxSlF*~9g~|Pp-iQF#^qT4>qp6~{dqh21*|v1Mt@R&m>(nG7*vC_n UCGZSpXe}Jj=1H4?g+nC%0*H&syZ`_I literal 0 HcmV?d00001 diff --git a/out/production/algorithms-project-2022/src/main/Deramida$SubTree$SubTreeIterator.class b/out/production/algorithms-project-2022/src/main/Deramida$SubTree$SubTreeIterator.class new file mode 100644 index 0000000000000000000000000000000000000000..72a819e6622cc48de29c75ff31f415254492bc75 GIT binary patch literal 2462 zcmah~ZF3W46g^K~*e2b!0ZJtWDUj5F;%yZ3qa+;h&od-L}{zyAT?0$K?~5H%1p z5yu{dOw%pR)GXVXxvX8QW|ysrLThcs)w;bddED^ouEHL#VmBwwDjZsV>sz@b`j9Y? zG|>-JA@#s|Y|T_HXMN`S+5=tk2s39pwl}X3oy-&s3@QxyhgzOpohf)$>0uHBNC?rr zCiY>!LcA$qg}uu=PUhs)0TUy5N5LqyTvt0xac~!c`FdINcp9Sy4w*QNcNNla)zMaa zMqz(17;(mM)W9(l&f^!}mVRM@v0 z>^UavRBfSNYgn$eR@F&*_pyodm{myH%_XN)ZIyMIE>3pAbk658w?#|N#2hY&7RpyR z*?l-@iQF#ggzKj!E{cMrYp+)V2?F?;i3MC{x$Wj+t>IAy8;PkRxMJdSf2U$K^LoQG zu%vLb(=z#bp;f9ZR&|YCvba&w4bQGSNnAxjfR{~N6W61Sdc(kVg|UteOVz4gx2kMU zPj|hUmp)D78xsZTr@nId5hd9lH%t_<%0_Z^t^Qam9N0~|PyCjN+qgrI9I|HnzESTk zM-AL%(K>=U-)5pLsgMv|L-B!(dEiio#TH>h}C;uWhX)I`SscW}}UE zrWYm<8WNli*DkC9f8t!T8f`+3PyfU&GIx3=YU7g`Iw=A=y%KhHR~6d%0vY-+k>g!Jj|4k5H%YKdd~3i_b%Eux&9 zoSnS?j)Omf?|J2veEobcm6BfoM)z>H9~O7k`1F)-Mz~(cPCbLlK8KNgfq`4kG4u?n zta^swsVyAb!jV@voDFZcaXg#dLTVeQUV^U;|3-iqO1vI{0jQfus2dnoMWod&99Oq7 zt?pn>-9?#aMuLRUxX&l~l@ekK>%2F)N<^c=)#m>Y)W4i45kvmc3`AtS@+$0q<|^!G z$?Wti^b5n<?L-w`X4B!)<)@6HK8ywT(|!8J!Og&huc0`93Oux`!dPhKwrXywY84 zXJ50O#RK0~VH+rsJz+~4+`C5w!aI)WPFMj-fe{XkXkb)5!kB7y8F4D)G0FkD(+JrUM!{a&h$z%hXhW3@i++v8hB_IF z4dbLV{FgAyli^pwP;KFBiIUqkR#rPz8f3ddZIIk1j;SBI3>xn-NFr^6ghc8R?a4Bw zB)`N}lE-P!O%WgU`!_JY(1jcC!Ig;M#zIv!IDCpwPs3lw@QCXu5!3uxaQ!-@(PX+Q IK6{A#2PEqixBvhE literal 0 HcmV?d00001 diff --git a/out/production/algorithms-project-2022/src/main/Deramida$SubTree.class b/out/production/algorithms-project-2022/src/main/Deramida$SubTree.class new file mode 100644 index 0000000000000000000000000000000000000000..deaa2a498d71074969f78c8afb2ba333d420fbff GIT binary patch literal 2574 zcmbVNSx*~R6#lLkjO~E{CWJL5gtlH-lF()|StyWT0wgU<3tb0$N+$7w#^WgIbN>YG zTVEnod1$3Vltyavlt}#<{TY?Id}lm^4GvXR$@abHo^#LrzVDoS{o7wZ{{r9&vSIk( z4(+p6Ih+UVFU*>tr=nN(#s0b*J6lyk}(XbRr`> zPHK1qgG_GP%x;$~B8w-g(G}awk7wNVbQD849m24NH}RH2hjZ$I5QWfPy}V>Rv>o0X zvLmh`fuus9=qz`7xgFjvk_btTXc)zqLc}a*irIW6XXIF+df0U$B{l^584YJ~j?lBE zqRldvkKnlx!aE8>HI*{?ys@R{r>w0?!6@3Z53|O$ZI+4=Odu?oFKDAF6tJL`zm1_?-k zz^6+&o_}n?EE-Fd!lq%ZNNclY7D`z?zouKJ*zRILZkj@0BhGzYRz~&>eZ_l^2$s@?9FuzgU;+_T0zT+6=*qco4 zLM5LflpNVbOLBAO2zt~gmgq}5hbA!95AhLyr5fKet5o(pk#)X8(Er3g zDbqa+ERH1D*DxY^bM3Ewr4I&W^8b{)wPdEtjRs_O-GGhos1Ah>wlE>J^U7#)1=uf6R zP#uChwTJN?9M)9266#u=j{W;O_TyvXs>dKc4?_^X-s`-0@>=s(Br6|2`Wr-_V`BX& z-u=~uaK0u?t58)4}eyA9o{CoKC04^N{kRgD10=RVqfPd4#1;9UX zG8YAA$w`V8evZj?-r%c0(5T+ns?v9yQ>qmWyGqw;EGwdK^_G3oHpPFVq|0rJqofWp z?bPA4!*ywc4QXYCX_@ZkYtzmCuXOvb!8|@CE+0O_=g!!SFF1BM&Cm>;<0QYEQ2ziP C*4YFA literal 0 HcmV?d00001 diff --git a/out/production/algorithms-project-2022/src/main/Deramida.class b/out/production/algorithms-project-2022/src/main/Deramida.class new file mode 100644 index 0000000000000000000000000000000000000000..c44f84603682f3ff769ea83ce3eb53e138c5cecf GIT binary patch literal 9668 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 literal 0 HcmV?d00001 diff --git a/out/production/algorithms-project-2022/src/main/Main.class b/out/production/algorithms-project-2022/src/main/Main.class new file mode 100644 index 0000000000000000000000000000000000000000..495698fe3ef174b71a6e461d10ead4c90878dd4f GIT binary patch literal 2035 zcmb7FTTB#J82-+(%Pi|4cZ3Rb#T(0QE4Q{RU@dCh7Q~98sJ#r!0D~|~hJ{G`LiNEk zT1|{kCXEkGW7;PrT`p2-`qZRJlbM&kHtAy@+oUgTq~95q%K|UmWagYX|M!3A|Nrm& zXMcYAd<8%|Mg#C5LxER?519hFquR6<9@EU>aL>S~9!m&hwi%|8=n%-L3iV~dk1PcN z6?>qj!Fy*W6Z$w&@hLhLb-6@FJbcbF%tUX((zWr3AA9LzKeUt1to_vf-d?o7v!4c# zi#!GSDhg02P_T=qfHEO@#!OOIt#P|SlGreZBcVP8#R7SgRxCWO8D{vTZfWDjpcX)p zOs|wSmv$;)jD>q+nrZ5m%w@ldGL#E=49UC^bkv-fS`Rva61*zQ6BH;(?ajQlLPC9h zR0>4xFPYW6%*(lHCxey8DrFQjtKN@XJ|}k*b$KPnJdhKb1T@qEhHJKEJc-y z5UMGNsozLMO=`_^5%r^1pxS=G)RJUf%imsLf=`{>GABx%4BF4_W#=9jsChlY3SLuj z3=QkzxQdceAJ#2yFs+SE={-XN#Z}SJ7R^(Lh}5=8MKf9$gElz0?P#o>-$>|+#J!>7 zO^M62^zrz#?ngwRd3(4&IQQ3NNsoJJGw!6lm0$r`jr;N#q@Dj(8Q=*OZ_5Vsx#!%Elk^GLk15BBtI{$za&K?D6HCArBr7G@Gjm{(50dqXVV+jZ5@^*HlkT4=F>@@2JBc zyu$uO1O7%MUZP3((Jc0&#g+3sqZwi>m(kBCXE$b#a3-}D!7sQ%t4~UctGLD-a)!zr55+OaH+|1v)WaN<748gmVv! F{{SYAZchLJ literal 0 HcmV?d00001 diff --git a/out/production/algorithms-project-2022/src/test/DeramidaTest.class b/out/production/algorithms-project-2022/src/test/DeramidaTest.class new file mode 100644 index 0000000000000000000000000000000000000000..bbffb640ae911d6b438800f5b0368990cebb2c2f GIT binary patch literal 6958 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 T>vcWeGH2iqO^;Hc2;cZ05FhOr literal 0 HcmV?d00001 diff --git a/src/main/Deramida.java b/src/main/Deramida.java new file mode 100644 index 0000000..3e09b43 --- /dev/null +++ b/src/main/Deramida.java @@ -0,0 +1,428 @@ +package src.main; +import java.util.*; + +public class Deramida> implements SortedSet { + + private Node root = null; + private int size = 0; + private static final Random random = new Random(); + + private class Node { + T key; + int priority; + + Node leftChild; + Node rightChild; + Node parent = null; + + Node(T key) { + this.key = key; + priority = random.nextInt(30); + } + } + + private class NodePair { + private final K treeA; + private final V treeB; + + NodePair(K treeA, V treeB) { + this.treeA = treeA; + this.treeB = treeB; + } + + public K getTreeA() { + return treeA; + } + + public V getTreeB() { + return treeB; + } + } + + @Override + public Comparator comparator() { + return (Comparator) Comparable::compareTo; + } + + private Node merge(Node treeA, Node treeB) { + if (treeA == null) + return treeB; + if (treeB == null) + return treeA; + + if (treeA.priority > treeB.priority) { + treeA.rightChild = merge(treeA.rightChild, treeB); + treeA.rightChild.parent = treeA; + return treeA; + } else { + treeB.leftChild = merge(treeA, treeB.leftChild); + treeB.leftChild.parent = treeB; + return treeB; + } + } + + private NodePair, Node> split(Node start, T key) { + if (start == null) + return new NodePair<>(null, null); + + if (key.compareTo(start.key) > 0) { + NodePair, Node> result = split(start.rightChild, key); + start.rightChild = result.getTreeA(); + + if (start.rightChild != null) start.rightChild.parent = start; + if (result.getTreeB() != null) result.getTreeB().parent = null; + return new NodePair<>(start, result.getTreeB()); + } else { + NodePair, Node> result = split(start.leftChild, key); + start.leftChild = result.getTreeB(); + + if (start.leftChild != null) start.leftChild.parent = start; + if (result.getTreeA() != null) result.getTreeA().parent = null; + return new NodePair<>(result.getTreeA(), start); + } + } + + @Override + public int size() { + return size; + } + + @Override + public boolean isEmpty() { + return size == 0; + } + + private Node find(T key) { + if (root == null) return null; + return find(root, key); + } + + private Node find(Node start, T key) { + if (key.compareTo(start.key) == 0) { + return start; + } else if (key.compareTo(start.key) < 0) { + if (start.leftChild == null) return start; + return find(start.leftChild, key); + } else { + if (start.rightChild == null) return start; + return find(start.rightChild, key); + } + } + + @Override + public boolean contains(Object o) { + T t = (T) o; + Node node = find(t); + return node != null && t.compareTo(node.key) == 0; + } + + @Override + public boolean add(Object key) { + T addKey = (T) key; + + Node node = find(addKey); + + if (node != null && node.key.equals(addKey)) return false; + + NodePair, Node> treaps = split(root, addKey); + Node temp = merge(treaps.getTreeA(), new Node<>(addKey)); + root = merge(temp, treaps.getTreeB()); + + root.parent = null; + size++; + return true; + } + + @Override + public boolean remove(Object o) { + T deleteKey = (T) o; + Node node = find(deleteKey); + + if (node != null && node.key.compareTo(deleteKey) == 0) return removeNode(node); + + return false; + } + + public boolean removeNode(Node node) { + + Node parent = node.parent; + + if (parent != null) { + if (parent.leftChild != null && parent.leftChild.key.equals(node.key)) { + + parent.leftChild = merge(node.leftChild, node.rightChild); + if (parent.leftChild != null) parent.leftChild.parent = parent; + + } else { + + parent.rightChild = merge(node.leftChild, node.rightChild); + if (parent.rightChild != null) parent.rightChild.parent = parent; + } + } else { + root = merge(node.leftChild, node.rightChild); + if (root != null) + root.parent = null; + } + size--; + return true; + } + + @Override + public T first() { + if (root == null) throw new NoSuchElementException(); + + Node node = root; + while (node.leftChild != null) node = node.leftChild; + + return node.key; + } + + @Override + public T last() { + if (root == null) throw new NoSuchElementException(); + + Node node = root; + while (node.rightChild != null) node = node.rightChild; + + return node.key; + } + + @Override + public Iterator iterator() { + return new DeramidaIterator(); + } + + public class DeramidaIterator implements Iterator { + + private Stack> stack = new Stack<>(); + Node current = null; + + private DeramidaIterator() { + pushIter(root); + } + + private void pushIter(Node node) { + if (node != null) { + stack.push(node); + pushIter(node.leftChild); + } + } + + @Override + public boolean hasNext() { + return !stack.isEmpty(); + } + + @Override + public T next() { + if(!hasNext()) throw new NoSuchElementException(); + + Node node = stack.pop(); + current = node; + pushIter(node.rightChild); + + return node.key; + } + + @Override + public void remove() { + if (current == null) throw new IllegalStateException(); + removeNode(current); + current = null; + } + } + + @Override + public boolean addAll(Collection c) { + for (Object o : c) + if (!this.add(o)) return false; + return true; + } + + @Override + public void clear() { + this.root = null; + this.size = 0; + } + + @Override + public boolean containsAll(Collection c) { + for (Object o : c) + if (!contains(o)) return false; + return true; + } + + @Override + public boolean removeAll(Collection c) { + if (this.containsAll(c)) { + for (Object o : c) + remove(o); + return true; + } else return false; + } + + @Override + public boolean retainAll(Collection c) { + if (this.containsAll(c)) { + for (Object o : this) + if (!c.contains(o)) remove(o); + return true; + } else return false; + } + + @Override + public Object[] toArray() { + Object[] array = new Object[this.size]; + Iterator iterator = this.iterator(); + for (int i = 0; i < this.size; i++) + array[i] = iterator.next(); + return array; + } + + @Override + public Object[] toArray(Object[] a) { + Object[] array = this.toArray(); + if (this.size >= 0) System.arraycopy(array, 0, a, 0, this.size); + return a; + } + + private class SubTree extends Deramida { + T bottom; + T up; + Deramida deramida; + + SubTree(T bottom, T up, Deramida deramida) { + this.bottom = bottom; + this.up = up; + this.deramida = deramida; + } + + private boolean isIncluded(T key) { + + return (bottom != null && up != null && key.compareTo(bottom) >= 0 && key.compareTo(up) < 0) + || (bottom == null && key.compareTo(up) < 0) + || (up == null && key.compareTo(bottom) >= 0 ); + } + + public int size() { + if (deramida == null) return 0; + int size = 0; + for (Object key : deramida) + if (isIncluded((T) key)) size++; + return size; + } + + public boolean contains(Object o) { + return isIncluded((T) o) && deramida.contains(o); + } + + public boolean add(Object key) { + if (!isIncluded((T) key)) + throw new IllegalArgumentException(); + return deramida.add(key); + } + + public boolean remove(Object o) { + if (!isIncluded((T) o)) + throw new IllegalArgumentException(); + return deramida.remove(o); + } + + @Override + public Iterator iterator() { + return new SubTreeIterator(); + } + + public class SubTreeIterator implements Iterator { + + private final Stack> stack = new Stack<>(); + Node current = null; + + private SubTreeIterator() { + if (root != null) { + pushIter(root); + current = stack.peek(); + } + } + + private void pushIter(Node node) { + if (node.leftChild != null) pushIter(node.leftChild); + + if (isIncluded(node.key)) stack.push(node); + + if (node.rightChild != null) pushIter(node.rightChild); + } + + @Override + public boolean hasNext() { + return !stack.isEmpty(); + } + + @Override + public T next() { + if (!hasNext()) throw new NoSuchElementException(); + + Node node = stack.pop(); + current = node; + + return node.key; + } + + @Override + public void remove() { + if (current == null) throw new IllegalStateException(); + deramida.remove(current.key); + } + } + } + + @Override + public SortedSet subSet(Object fromElement, Object toElement) { + T from = (T) fromElement; + T to = (T) toElement; + + if (to == null && from == null) throw new IllegalArgumentException(); + if (to != null && from.compareTo(to) >= 0) throw new IllegalArgumentException(); + + return new SubTree(from, to, this); + } + + @Override + public SortedSet headSet(Object toElement) { + T to = (T) toElement; + + if (to == null) throw new IllegalArgumentException(); + + return new SubTree(null, to, this); + } + + @Override + public SortedSet tailSet(Object fromElement) { + T from = (T) fromElement; + + if (from == null) throw new IllegalArgumentException(); + + return new SubTree(from, null, this); + } + + public void print() { + print(root, 0); + } + + public void print(Node node, int level){ + if (node == null ) { + return; + } + + print(node.rightChild, level + 1); + if (level != 0) { + for(int i = 0; i < level - 1; i++) + System.out.print("| \t"); + System.out.println("├-----------" + "[" + node.key + "; " + node.priority + "]"); + } + else { + System.out.println("[" + node.key + "; " + node.priority + "]"); + } + print(node.leftChild, level + 1); + } +} \ No newline at end of file diff --git a/src/main/Main.java b/src/main/Main.java new file mode 100644 index 0000000..177b158 --- /dev/null +++ b/src/main/Main.java @@ -0,0 +1,55 @@ +package src.main; + +import java.io.*; +import java.util.Scanner; + +public class Main { + public static void main(String[] args) throws IOException { + System.out.println("Дерамида"); + Deramida deramida = new Deramida(); + char ch; + int key; + Scanner scanner = new Scanner(System.in); + + do { + System.out.println("Нажмите \"1\", чтобы добавить новый элемент"); + System.out.println("Нажмите \"2\", чтобы удалить элемент"); + System.out.println("Нажмите \"3\", чтобы добавить сразу 5 элементов"); + + int choice = scanner.nextInt(); + switch (choice) { + case 1: + System.out.println("Введите значение ключа"); + key = scanner.nextInt(); + deramida.add(key); + break; + case 2: + System.out.println("Введите значение ключа"); + key = scanner.nextInt(); + deramida.remove(key); + break; + case 3: + System.out.println("Введите пять значений ключей"); + key = scanner.nextInt(); + deramida.add(key); + key = scanner.nextInt(); + deramida.add(key); + key = scanner.nextInt(); + deramida.add(key); + key = scanner.nextInt(); + deramida.add(key); + key = scanner.nextInt(); + deramida.add(key); + break; + default: + System.out.println("Вы нажали что-то не то...\n"); + break; + } + + System.out.println("Новая дерамида:"); + deramida.print(); + System.out.println("\nПродолжить? y/n \n"); + ch = scanner.next().charAt(0); + } while (ch == 'y'); +} +} diff --git a/src/test/DeramidaTest.java b/src/test/DeramidaTest.java new file mode 100644 index 0000000..cafef8d --- /dev/null +++ b/src/test/DeramidaTest.java @@ -0,0 +1,372 @@ +package src.test; + +import src.main.Deramida; +import org.junit.Test; + +import java.util.*; + +import static org.junit.Assert.*; + +public class DeramidaTest { + @Test + public void testAdd() { + + Deramida deramida = new Deramida<>(); + + assertTrue(deramida.isEmpty()); + + assertTrue(deramida.add(1)); + assertTrue(deramida.add(8)); + assertTrue(deramida.add(9)); + + assertEquals(3, deramida.size()); + + assertTrue(deramida.add(15)); + assertTrue(deramida.add(7)); + assertTrue(deramida.add(21)); + assertTrue(deramida.add(11)); + + assertEquals(7, deramida.size()); + } + @Test + public void testRemove() { + Deramida deramida = new Deramida<>(); + + deramida.add(3); + deramida.add(7); + deramida.add(18); + deramida.add(76); + deramida.add(20); + + assertEquals(5, deramida.size()); + + assertTrue(deramida.remove(3)); + assertTrue(deramida.remove(20)); + assertTrue(deramida.remove(76)); + assertFalse(deramida.remove(55)); + + assertEquals(2, deramida.size()); + + assertTrue(deramida.remove(7)); + assertTrue(deramida.remove(18)); + + assertTrue(deramida.isEmpty()); + } + + @Test + public void testContains() { + Deramida deramida = new Deramida<>(); + + deramida.add(31); + deramida.add(27); + deramida.add(138); + + assertTrue(deramida.contains(31)); + assertTrue(deramida.contains(27)); + assertTrue(deramida.contains(138)); + assertFalse(deramida.contains(0)); + assertFalse(deramida.contains(13)); + + deramida.remove(31); + assertFalse(deramida.contains(31)); + } + + @Test + public void testFirst() { + Deramida deramida = new Deramida<>(); + + deramida.add(3); + + assertEquals(3, deramida.first()); + + deramida.add(1); + deramida.add(10); + + assertEquals(1, deramida.first()); + + deramida.remove(1); + deramida.remove(3); + + assertEquals(10, deramida.first()); + } + + @Test + public void testLast() { + Deramida deramida = new Deramida<>(); + deramida.add(11); + + assertEquals(11, deramida.last()); + + deramida.add(1); + deramida.add(23); + + assertEquals(23, deramida.last()); + + deramida.remove(11); + deramida.remove(23); + + assertEquals(1, deramida.last()); + } + + @Test + public void testAddAll() { + Deramida deramida = new Deramida<>(); + List list = new ArrayList<>(); + List list1 = new ArrayList<>(); + List list2 = new ArrayList<>(); + + assertTrue(deramida.isEmpty()); + + list.add(1); + list.add(10); + list.add(16); + list.add(4); + list.add(45); + + list2.add(1); + list2.add(45); + + deramida.addAll(list); + + assertTrue(deramida.contains(1)); + assertTrue(deramida.contains(10)); + assertTrue(deramida.contains(16)); + assertTrue(deramida.contains(4)); + assertTrue(deramida.contains(45)); + assertEquals(5, deramida.size()); + + deramida.addAll(list1); + assertEquals(5, deramida.size()); + + deramida.addAll(list2); + assertEquals(5, deramida.size()); + } + + @Test + public void testContainsAll() { + Deramida deramida = new Deramida<>(); + List list = new ArrayList<>(); + + deramida.add(106); + deramida.add(687); + deramida.add(224); + deramida.add(1566); + + list.add(106); + list.add(687); + list.add(224); + + assertTrue(deramida.containsAll(list)); + + list.add(1566); + + assertTrue(deramida.containsAll(list)); + + list.remove(3); + assertTrue(deramida.containsAll(list)); + + list.add(136); + assertFalse(deramida.containsAll(list)); + } + + @Test + public void testRemoveAll() { + Deramida deramida = new Deramida<>(); + List list = new ArrayList<>(); + List list1 = new ArrayList<>(); + + deramida.add(125); + deramida.add(246); + deramida.add(688); + deramida.add(2536); + + list.add(125); + list.add(246); + + list1.add(688); + list1.add(2536); + + deramida.removeAll(list); + + assertTrue(deramida.contains(688)); + assertTrue(deramida.contains(2536)); + assertEquals(2, deramida.size()); + + deramida.removeAll(list1); + assertTrue(deramida.isEmpty()); + } + + @Test + public void testRetainAll() { + Deramida deramida = new Deramida<>(); + List list = new ArrayList<>(); + List list1 = new ArrayList<>(); + + deramida.add(4); + deramida.add(978); + deramida.add(468); + deramida.add(24); + deramida.add(987); + deramida.add(534); + + list.add(534); + list.add(978); + + deramida.retainAll(list); + assertEquals(list.size(), deramida.size()); + assertTrue(deramida.contains(534)); + assertTrue(deramida.contains(978)); + + deramida.retainAll(list1); + assertTrue(deramida.isEmpty()); + } + + @Test + public void testClear() { + Deramida deramida = new Deramida<>(); + + deramida.add(4); + deramida.add(978); + deramida.add(468); + deramida.add(24); + + deramida.clear(); + assertTrue(deramida.isEmpty()); + + deramida.add(1); + deramida.clear(); + assertTrue(deramida.isEmpty()); + } + + @Test + public void testIterator() { + Deramida deramida = new Deramida<>(); + Set expectedSet = new HashSet<>(); + + deramida.add(4); + deramida.add(14); + deramida.add(1); + deramida.add(35); + deramida.add(7); + deramida.add(13); + deramida.add(789); + deramida.add(90); + deramida.add(55); + + expectedSet.add(4); + expectedSet.add(14); + expectedSet.add(1); + expectedSet.add(35); + expectedSet.add(7); + expectedSet.add(13); + expectedSet.add(789); + expectedSet.add(90); + expectedSet.add(55); + + + Iterator iterator1 = deramida.iterator(); + Iterator iterator2 = deramida.iterator(); + Iterator iterator3 = deramida.iterator(); + + while (iterator1.hasNext()) { + assertEquals(iterator2.next(), iterator1.next()); + } + + while (iterator3.hasNext()) { + assertTrue(expectedSet.contains(iterator3.next())); + iterator3.remove(); + } + + assertTrue(deramida.isEmpty()); + } + + @Test + public void testSubSet() { + Deramida deramida = new Deramida<>(); + + deramida.add(7); + deramida.add(2); + deramida.add(0); + deramida.add(5); + deramida.add(10); + deramida.add(14); + + SortedSet subTree = deramida.subSet(5, 11); + + assertFalse(subTree.contains(0)); + assertFalse(subTree.contains(2)); + assertFalse(subTree.contains(14)); + assertTrue(subTree.contains(5)); + assertTrue(subTree.contains(7)); + assertTrue(subTree.contains(10)); + + SortedSet subTree2 = deramida.subSet(3, 10); + + assertFalse(subTree2.contains(0)); + assertFalse(subTree2.contains(2)); + assertFalse(subTree2.contains(10)); + assertFalse(subTree2.contains(14)); + assertTrue(subTree2.contains(5)); + assertTrue(subTree2.contains(7)); + } + + @Test + public void testTailSet() { + Deramida deramida = new Deramida<>(); + + deramida.add(6); + deramida.add(1); + deramida.add(0); + deramida.add(15); + deramida.add(18); + deramida.add(34); + + SortedSet subTree = deramida.tailSet(15); + + assertFalse(subTree.contains(0)); + assertFalse(subTree.contains(1)); + assertFalse(subTree.contains(6)); + assertTrue(subTree.contains(15)); + assertTrue(subTree.contains(18)); + assertTrue(subTree.contains(34)); + + SortedSet subTree2 = deramida.tailSet(3); + + assertFalse(subTree2.contains(0)); + assertFalse(subTree2.contains(1)); + assertTrue(subTree2.contains(6)); + assertTrue(subTree2.contains(15)); + assertTrue(subTree2.contains(18)); + assertTrue(subTree2.contains(34)); + } + + @Test + public void testHeadSet() { + Deramida deramida = new Deramida<>(); + + deramida.add(6); + deramida.add(1); + deramida.add(0); + deramida.add(15); + deramida.add(18); + deramida.add(34); + + SortedSet subTree = deramida.headSet(15); + + assertTrue(subTree.contains(0)); + assertTrue(subTree.contains(1)); + assertTrue(subTree.contains(6)); + assertTrue(!subTree.contains(15)); + assertFalse(subTree.contains(18)); + assertFalse(subTree.contains(34)); + + SortedSet subTree2 = deramida.headSet(3); + + assertTrue(subTree2.contains(0)); + assertTrue(subTree2.contains(1)); + assertFalse(subTree2.contains(6)); + assertFalse(subTree2.contains(15)); + assertFalse(subTree2.contains(18)); + assertFalse(subTree2.contains(34)); + } +} From cc1970f607150bde734a638999cff4bd6733f569 Mon Sep 17 00:00:00 2001 From: elizaveta Date: Tue, 4 Oct 2022 15:42:24 +0300 Subject: [PATCH 2/2] done --- .../src/main/Deramida$DeramidaIterator.class | Bin 2188 -> 2188 bytes .../src/main/Deramida$Node.class | Bin 945 -> 945 bytes .../src/main/Deramida$NodePair.class | Bin 1072 -> 1072 bytes .../Deramida$SubTree$SubTreeIterator.class | Bin 2462 -> 2462 bytes .../src/main/Deramida$SubTree.class | Bin 2574 -> 2574 bytes .../src/main/Deramida.class | Bin 9668 -> 9668 bytes .../src/main/Main.class | Bin 2035 -> 2038 bytes pom.xml | 16 ++++++++++++++++ 8 files changed, 16 insertions(+) create mode 100644 pom.xml diff --git a/out/production/algorithms-project-2022/src/main/Deramida$DeramidaIterator.class b/out/production/algorithms-project-2022/src/main/Deramida$DeramidaIterator.class index dc102f459a82017edba535c3b1f6cd833b29abfe..adb1d240a2739f314f4ac7808a35292d81039d5e 100644 GIT binary patch delta 99 zcmV-p0G$7f5sVSAs09(o00{ua02Bbm02u(u03iU%leq02=`303ZP9limkc0mG9v F2v)8G9oql^ delta 99 zcmV-p0G$7f5sVSAs09(r00{ud02Bbp02u(x03iU)leq6m=$E?k$24sZ+0LKRj`2YX_ delta 41 wcmdnMv4La5cP3tW22KVA20jKw24M!J$t=uujH;7wF>6m=$E?k$31o!<0LX_53jhEB diff --git a/out/production/algorithms-project-2022/src/main/Deramida$SubTree$SubTreeIterator.class b/out/production/algorithms-project-2022/src/main/Deramida$SubTree$SubTreeIterator.class index 72a819e6622cc48de29c75ff31f415254492bc75..e7afc53164a685463fd70ff4269908d0ae204654 100644 GIT binary patch delta 99 zcmbOyJWqH-J)2}G11Dn;g9u|VgCt`ZgEC_{gC1i9gAHTUS z7?UQuu{SWLO+LjEM$;pES~JoF@duJC{oFw$XGS`1xGkz@MH(hH~B-n%8cefS&PY1?7fUOlh<$DkC%8XV(S?kGC?7fWklh<$t5xLAh6a{cP9 zl>#kGzL{HOtk`G?@oXZI%>*bT%oYmRN+H|WZmWVFGvAVnrMTR}ce9c`gxE_i`zU3< zxew4lB_}z^IjU)+mR=5VpTk<~o0lV+ui@e1FYX zt@Rl-ULj7F5R#>=7Z-Wr)|rfPZ@ke2(j}21@lYZwG#0w&UuD#XNBjgNg-kowNDKO{w%~OV+G&-Dodf>DQ0h0jW6I?j^)ktE cd9Lfi9pbV%hxJ1^@Bb~LX_1W*r|X-^`nDX5K=@LdDaMrjZN_46aoD zWJaY(OPzgrtI0}`gf&P-DblbO9;`zc>#-agP>7A(H=!JxXFfZNrFbjDw;>%n5Wr64 zVHY1)(7gw7RN@GtIElSz#Xej{3<*?g)b(2StHWI*wOa44w;p5xhxEOBE~^0!9EB6d z5JDpgaGXV)pjeZRWlR~TV8vwE?BMz8pqjW3+nSLXhvY5o@D2i1OZlE1Xy-(>uz z?+<-{>8sT0>?+fO6tN;8NmwSy$d?qI$-ZOSNf*H{=~yWatP)e}0|V|1QV;Bs36EqU z$a9H!)fF5z0 + + 4.0.0 + + groupId + algorithms-project-2022 + 1.0-SNAPSHOT + + + 17 + 17 + + + \ No newline at end of file