diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 0000000..dd84ea7
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,38 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Desktop (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Browser [e.g. chrome, safari]
+ - Version [e.g. 22]
+
+**Smartphone (please complete the following information):**
+ - Device: [e.g. iPhone6]
+ - OS: [e.g. iOS8.1]
+ - Browser [e.g. stock browser, safari]
+ - Version [e.g. 22]
+
+**Additional context**
+Add any other context about the problem here.
diff --git a/.github/ISSUE_TEMPLATE/custom.md b/.github/ISSUE_TEMPLATE/custom.md
new file mode 100644
index 0000000..48d5f81
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/custom.md
@@ -0,0 +1,10 @@
+---
+name: Custom issue template
+about: Describe this issue template's purpose here.
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 0000000..bbcbbe7
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..8d6193c
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,4 @@
+.idea/
+.DS_Store
+composer.lock
+vendor
\ No newline at end of file
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..7ee229d
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at 542684913@qq.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..cc8499a
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,15 @@
+What does “open source” mean?
+
+When a project is open source, that means anybody can view, use, modify, and distribute your project for any purpose. These permissions are enforced through an open source license.
+
+Open source is powerful because it lowers the barriers to adoption, allowing ideas to spread quickly.
+
+To understand how it works, imagine your friend is having a potluck, and you bring a cherry pie.
+
+Everybody tries the pie (use)
+The pie is a hit! They ask you for the recipe, which you provide (view)
+One friend, Alex, who’s a pastry chef, suggests reducing the sugar (modify)
+Another friend, Lisa, asks to use it for a dinner next week (distribute)
+By comparison, a closed source process would be going to a restaurant and ordering a slice of cherry pie. You must pay a fee to eat the pie, and the restaurant probably won’t give you their recipe. If you copied their pie exactly and sold it under your own name, the restaurant could take action against you.
+
+Why do people open source their work?
diff --git a/LICENSE b/LICENSE
index 748bc09..8d0adb8 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,376 +1,21 @@
-Mozilla Public License Version 2.0
-==================================
-
-1. Definitions
---------------
-
-1.1. "Contributor"
- means each individual or legal entity that creates, contributes to
- the creation of, or owns Covered Software.
-
-1.2. "Contributor Version"
- means the combination of the Contributions of others (if any) used
- by a Contributor and that particular Contributor's Contribution.
-
-1.3. "Contribution"
- means Covered Software of a particular Contributor.
-
-1.4. "Covered Software"
- means Source Code Form to which the initial Contributor has attached
- the notice in Exhibit A, the Executable Form of such Source Code
- Form, and Modifications of such Source Code Form, in each case
- including portions thereof.
-
-1.5. "Incompatible With Secondary Licenses"
- means
-
- (a) that the initial Contributor has attached the notice described
- in Exhibit B to the Covered Software; or
-
- (b) that the Covered Software was made available under the terms of
- version 1.1 or earlier of the License, but not also under the
- terms of a Secondary License.
-
-1.6. "Executable Form"
- means any form of the work other than Source Code Form.
-
-1.7. "Larger Work"
- means a work that combines Covered Software with other material, in
- a separate file or files, that is not Covered Software.
-
-1.8. "License"
- means this document.
-
-1.9. "Licensable"
- means having the right to grant, to the maximum extent possible,
- whether at the time of the initial grant or subsequently, any and
- all of the rights conveyed by this License.
-
-1.10. "Modifications"
- means any of the following:
-
- (a) any file in Source Code Form that results from an addition to,
- deletion from, or modification of the contents of Covered
- Software; or
-
- (b) any new file in Source Code Form that contains any Covered
- Software.
-
-1.11. "Patent Claims" of a Contributor
- means any patent claim(s), including without limitation, method,
- process, and apparatus claims, in any patent Licensable by such
- Contributor that would be infringed, but for the grant of the
- License, by the making, using, selling, offering for sale, having
- made, import, or transfer of either its Contributions or its
- Contributor Version.
-
-1.12. "Secondary License"
- means either the GNU General Public License, Version 2.0, the GNU
- Lesser General Public License, Version 2.1, the GNU Affero General
- Public License, Version 3.0, or any later versions of those
- licenses.
-
-1.13. "Source Code Form"
- means the form of the work preferred for making modifications.
-
-1.14. "You" (or "Your")
- means an individual or a legal entity exercising rights under this
- License. For legal entities, "You" includes any entity that
- controls, is controlled by, or is under common control with You. For
- purposes of this definition, "control" means (a) the power, direct
- or indirect, to cause the direction or management of such entity,
- whether by contract or otherwise, or (b) ownership of more than
- fifty percent (50%) of the outstanding shares or beneficial
- ownership of such entity.
-
-2. License Grants and Conditions
---------------------------------
-
-2.1. Grants
-
-Each Contributor hereby grants You a world-wide, royalty-free,
-non-exclusive license:
-
-(a) under intellectual property rights (other than patent or trademark)
- Licensable by such Contributor to use, reproduce, make available,
- modify, display, perform, distribute, and otherwise exploit its
- Contributions, either on an unmodified basis, with Modifications, or
- as part of a Larger Work; and
-
-(b) under Patent Claims of such Contributor to make, use, sell, offer
- for sale, have made, import, and otherwise transfer either its
- Contributions or its Contributor Version.
-
-2.2. Effective Date
-
-The licenses granted in Section 2.1 with respect to any Contribution
-become effective for each Contribution on the date the Contributor first
-distributes such Contribution.
-
-2.3. Limitations on Grant Scope
-
-The licenses granted in this Section 2 are the only rights granted under
-this License. No additional rights or licenses will be implied from the
-distribution or licensing of Covered Software under this License.
-Notwithstanding Section 2.1(b) above, no patent license is granted by a
-Contributor:
-
-(a) for any code that a Contributor has removed from Covered Software;
- or
-
-(b) for infringements caused by: (i) Your and any other third party's
- modifications of Covered Software, or (ii) the combination of its
- Contributions with other software (except as part of its Contributor
- Version); or
-
-(c) under Patent Claims infringed by Covered Software in the absence of
- its Contributions.
-
-This License does not grant any rights in the trademarks, service marks,
-or logos of any Contributor (except as may be necessary to comply with
-the notice requirements in Section 3.4).
-
-2.4. Subsequent Licenses
-
-No Contributor makes additional grants as a result of Your choice to
-distribute the Covered Software under a subsequent version of this
-License (see Section 10.2) or under the terms of a Secondary License (if
-permitted under the terms of Section 3.3).
-
-2.5. Representation
-
-Each Contributor represents that the Contributor believes its
-Contributions are its original creation(s) or it has sufficient rights
-to grant the rights to its Contributions conveyed by this License.
-
-2.6. Fair Use
-
-This License is not intended to limit any rights You have under
-applicable copyright doctrines of fair use, fair dealing, or other
-equivalents.
-
-2.7. Conditions
-
-Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
-in Section 2.1.
-
-3. Responsibilities
--------------------
-
-3.1. Distribution of Source Form
-
-All distribution of Covered Software in Source Code Form, including any
-Modifications that You create or to which You contribute, must be under
-the terms of this License. You must inform recipients that the Source
-Code Form of the Covered Software is governed by the terms of this
-License, and how they can obtain a copy of this License. You may not
-attempt to alter or restrict the recipients' rights in the Source Code
-Form.
-
-3.2. Distribution of Executable Form
-
-If You distribute Covered Software in Executable Form then:
-
-(a) such Covered Software must also be made available in Source Code
- Form, as described in Section 3.1, and You must inform recipients of
- the Executable Form how they can obtain a copy of such Source Code
- Form by reasonable means in a timely manner, at a charge no more
- than the cost of distribution to the recipient; and
-
-(b) You may distribute such Executable Form under the terms of this
- License, or sublicense it under different terms, provided that the
- license for the Executable Form does not attempt to limit or alter
- the recipients' rights in the Source Code Form under this License.
-
-3.3. Distribution of a Larger Work
-
-You may create and distribute a Larger Work under terms of Your choice,
-provided that You also comply with the requirements of this License for
-the Covered Software. If the Larger Work is a combination of Covered
-Software with a work governed by one or more Secondary Licenses, and the
-Covered Software is not Incompatible With Secondary Licenses, this
-License permits You to additionally distribute such Covered Software
-under the terms of such Secondary License(s), so that the recipient of
-the Larger Work may, at their option, further distribute the Covered
-Software under the terms of either this License or such Secondary
-License(s).
-
-3.4. Notices
-
-You may not remove or alter the substance of any license notices
-(including copyright notices, patent notices, disclaimers of warranty,
-or limitations of liability) contained within the Source Code Form of
-the Covered Software, except that You may alter any license notices to
-the extent required to remedy known factual inaccuracies.
-
-3.5. Application of Additional Terms
-
-You may choose to offer, and to charge a fee for, warranty, support,
-indemnity or liability obligations to one or more recipients of Covered
-Software. However, You may do so only on Your own behalf, and not on
-behalf of any Contributor. You must make it absolutely clear that any
-such warranty, support, indemnity, or liability obligation is offered by
-You alone, and You hereby agree to indemnify every Contributor for any
-liability incurred by such Contributor as a result of warranty, support,
-indemnity or liability terms You offer. You may include additional
-disclaimers of warranty and limitations of liability specific to any
-jurisdiction.
-
-4. Inability to Comply Due to Statute or Regulation
----------------------------------------------------
-
-If it is impossible for You to comply with any of the terms of this
-License with respect to some or all of the Covered Software due to
-statute, judicial order, or regulation then You must: (a) comply with
-the terms of this License to the maximum extent possible; and (b)
-describe the limitations and the code they affect. Such description must
-be placed in a text file included with all distributions of the Covered
-Software under this License. Except to the extent prohibited by statute
-or regulation, such description must be sufficiently detailed for a
-recipient of ordinary skill to be able to understand it.
-
-5. Termination
---------------
-
-5.1. The rights granted under this License will terminate automatically
-if You fail to comply with any of its terms. However, if You become
-compliant, then the rights granted under this License from a particular
-Contributor are reinstated (a) provisionally, unless and until such
-Contributor explicitly and finally terminates Your grants, and (b) on an
-ongoing basis, if such Contributor fails to notify You of the
-non-compliance by some reasonable means prior to 60 days after You have
-come back into compliance. Moreover, Your grants from a particular
-Contributor are reinstated on an ongoing basis if such Contributor
-notifies You of the non-compliance by some reasonable means, this is the
-first time You have received notice of non-compliance with this License
-from such Contributor, and You become compliant prior to 30 days after
-Your receipt of the notice.
-
-5.2. If You initiate litigation against any entity by asserting a patent
-infringement claim (excluding declaratory judgment actions,
-counter-claims, and cross-claims) alleging that a Contributor Version
-directly or indirectly infringes any patent, then the rights granted to
-You by any and all Contributors for the Covered Software under Section
-2.1 of this License shall terminate.
-
-5.3. In the event of termination under Sections 5.1 or 5.2 above, all
-end user license agreements (excluding distributors and resellers) which
-have been validly granted by You or Your distributors under this License
-prior to termination shall survive termination.
-
-************************************************************************
-* *
-* 6. Disclaimer of Warranty *
-* ------------------------- *
-* *
-* Covered Software is provided under this License on an "as is" *
-* basis, without warranty of any kind, either expressed, implied, or *
-* statutory, including, without limitation, warranties that the *
-* Covered Software is free of defects, merchantable, fit for a *
-* particular purpose or non-infringing. The entire risk as to the *
-* quality and performance of the Covered Software is with You. *
-* Should any Covered Software prove defective in any respect, You *
-* (not any Contributor) assume the cost of any necessary servicing, *
-* repair, or correction. This disclaimer of warranty constitutes an *
-* essential part of this License. No use of any Covered Software is *
-* authorized under this License except under this disclaimer. *
-* *
-************************************************************************
-
-************************************************************************
-* *
-* 7. Limitation of Liability *
-* -------------------------- *
-* *
-* Under no circumstances and under no legal theory, whether tort *
-* (including negligence), contract, or otherwise, shall any *
-* Contributor, or anyone who distributes Covered Software as *
-* permitted above, be liable to You for any direct, indirect, *
-* special, incidental, or consequential damages of any character *
-* including, without limitation, damages for lost profits, loss of *
-* goodwill, work stoppage, computer failure or malfunction, or any *
-* and all other commercial damages or losses, even if such party *
-* shall have been informed of the possibility of such damages. This *
-* limitation of liability shall not apply to liability for death or *
-* personal injury resulting from such party's negligence to the *
-* extent applicable law prohibits such limitation. Some *
-* jurisdictions do not allow the exclusion or limitation of *
-* incidental or consequential damages, so this exclusion and *
-* limitation may not apply to You. *
-* *
-************************************************************************
-
-8. Litigation
--------------
-
-Any litigation relating to this License may be brought only in the
-courts of a jurisdiction where the defendant maintains its principal
-place of business and such litigation shall be governed by laws of that
-jurisdiction, without reference to its conflict-of-law provisions.
-Nothing in this Section shall prevent a party's ability to bring
-cross-claims or counter-claims.
-
-9. Miscellaneous
-----------------
-
-This License represents the complete agreement concerning the subject
-matter hereof. If any provision of this License is held to be
-unenforceable, such provision shall be reformed only to the extent
-necessary to make it enforceable. Any law or regulation which provides
-that the language of a contract shall be construed against the drafter
-shall not be used to construe this License against a Contributor.
-
-10. Versions of the License
----------------------------
-
-10.1. New Versions
-
-Mozilla Foundation is the license steward. Except as provided in Section
-10.3, no one other than the license steward has the right to modify or
-publish new versions of this License. Each version will be given a
-distinguishing version number.
-
-10.2. Effect of New Versions
-
-You may distribute the Covered Software under the terms of the version
-of the License under which You originally received the Covered Software,
-or under the terms of any subsequent version published by the license
-steward.
-
-10.3. Modified Versions
-
-If you create software not governed by this License, and you want to
-create a new license for such software, you may create and use a
-modified version of this License if you rename the license and remove
-any references to the name of the license steward (except to note that
-such modified license differs from this License).
-
-10.4. Distributing Source Code Form that is Incompatible With Secondary
-Licenses
-
-If You choose to distribute Source Code Form that is Incompatible With
-Secondary Licenses under the terms of this version of the License, the
-notice described in Exhibit B of this License must be attached.
-
-Exhibit A - Source Code Form License Notice
--------------------------------------------
-
- This Source Code Form is subject to the terms of the Mozilla Public
- License, v. 2.0. If a copy of the MPL was not distributed with this
- file, You can obtain one at http://mozilla.org/MPL/2.0/.
-
-If it is not possible or desirable to put the notice in a particular
-file, then You may include the notice in a location (such as a LICENSE
-file in a relevant directory) where a recipient would be likely to look
-for such a notice.
-
-You may add additional accurate notices of copyright ownership.
-
-Exhibit B - "Incompatible With Secondary Licenses" Notice
----------------------------------------------------------
-
- This Source Code Form is "Incompatible With Secondary Licenses", as
- defined by the Mozilla Public License, v. 2.0.
-
-Contact GitHub API Training Shop Blog About
-© 2017 GitHub, Inc. Terms Privacy Security Status Help
\ No newline at end of file
+MIT License
+
+Copyright (c) 2017 Shaowei pu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README-EN.md b/README-EN.md
new file mode 100644
index 0000000..8aeeaef
--- /dev/null
+++ b/README-EN.md
@@ -0,0 +1,167 @@
+:whale:A collection of algorithms that are implemented in PHP:whale:
+
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+ 
+
+
+
+ 中文版
+
+## Simple structure,
+
+```
+├──Package
+│ ├── Sort
+│ │ ├── BubbleSort.php
+│ │ ├── QuickSort.php
+│ │ ├── ShellSort.php
+│ │ ├── MergeSort.php
+│ │ ├── InsertSort.php
+│ │ └── SelectSort.php
+│ │
+│ ├── Query 查找篇
+│ │ ├── BinaryQuery.php
+│ │ ├── InseertQuery.php
+│ │ ├── FibonacciQuery.php
+│ │ ├── BFSQuery.php
+│ │ ├── Kmp.php
+│ │ ├── DijkstraQuery.php
+│ │ └── QulickQuery.php
+│ │
+│ └── Other 其他
+│ ├── MonkeyKing.php
+│ ├── DynamicProgramming.php
+│ ├── Fibonacci.php
+│ ├── StealingApples.php
+│ ├── HanoiGames.php
+│ ├── BidirectionalQueue.php
+│ ├── ColorBricks.php
+│ ├── GetCattle.php
+│ ├── OnlyNumbers.php
+│ ├── Interval.php
+│ ├── Maze.php
+│ ├── AntsClimb.php
+│ ├── Encryption.php
+│ ├── ElevatorDispatch.php
+│ ├── kmp.php
+│ ├── TraversalOfBinary.php
+│ ├── PointInTriangle.php
+│ └── BigSmallReplace.php
+│ └── Knapsack.php
+│ └── Solution.php
+│ └── RotationSort.php
+│ └── Square.php
+│ └── Prim.php
+│ └── CartesianProduct.php
+│ └── Square.php
+│ └── Judge.php
+│ └── Factorial.php
+| └── HashTable.php
+| └── RotateSort.php
+│
+├──LICENSE
+└──README.md
+```
+
+## What to do？
+
+```
+To record their understanding algorithms, data structure, the process of simple comprehensive and detailed as possible, let the learning algorithm using flexible, refueling(ง •̀_•́)ง
+```
+
+## logarithmic
+
+log10100 It's equivalent to saying, "how many tens do you multiply?" the answer is, of course, two
+so log10100=2，The logarithmic operation is the inverse of the power operation
+
+| left | right |
+| ------------------ | --------------------- |
+| 23 = 8 | log28 = 3 |
+| 24 = 16 | log216 = 4 |
+| 25 = 32 | log232 = 5 |
+
+If you don't, we won't wait for you
+
+## The elapsed time
+
+Take binary search for example, how much time can you save by using it? Simply look for the Numbers and if the list contains 100 Numbers, you need to guess 100 times.
+In other words, the number of guesses is the same as the length of the list, which is called linear time, while binary search is different if the list contains 100 elements
+It takes up to seven times, and if the list contains four billion digits, it should be guessed 32 times, while the running time of the subsearch is logarithmic time `O(log)`
+
+## Big O notation
+
+The big O notation is a special representation of how fast the algorithm can be. There's a diaosi. In fact, you often have to copy other people's code.
+In this case, you know how fast these algorithms are
+
+- The running time of the algorithm increases at different speeds
+ - For example, the difference between a simple find and a binary search
+
+| element | Easy to find | Binary search |
+| ------------- | ------------ | ------------- |
+| 100 | 100ms | 7ms |
+| 10000 | 10s | 14ms |
+| 1 000 000 000 | 11day | 30ms |
+
+- ` O ` said hair is pointed out that how fast algorithms, such as list contains ` n ` element, a simple search need to check each element, so you need to perform ` n ` time operations
+ Using large ` O ` said ` O (n) to make this operation `, binary search need to perform logn using large ` O ` said to`O(log n)`
+ - Some common big O runtime
+- O(log n) ,It's also called log time, and this algorithm includes binary algorithms
+- O(n),Also known as linear time, this algorithm includes simple lookups.
+- O(n * log n) Quick sort
+- O(n2),Selection sort
+- O(n!) Factorial time
+ - Here is the point
+- The speed of the algorithm is not the time, but the growth of operands
+- When we talk about the speed of the algorithm, what we're talking about is how fast will it run as the input increases
+- The running time of the algorithm is expressed in large O notation
+- O(log n) is faster than O (n), and the more elements that need to be searched, the more the former is faster than the latter
+
+## A simple comparison of recursion and loops：
+
+1. From a procedural point of view, the recursion manifests itself as calling itself, and the loop does not have this form.
+2. Recursive proceed from the ultimate goal of the problem, and gradually to a complex problem into a simple problem, and simple question solution and complicated problem, at the same time the presence of the benchmark, can eventually get a problem, is the reverse. And the circulation is from the simple question, step by step forward development, finally get the question, is positive.
+3. Any cycle can be represented by recursion, but it is necessary to use the loop to achieve recursion (except for one-way recursion and tail recursion), and the stack structure must be introduced to stack the stack.
+ 4.In general, non-recursive efficiency is higher than recursion. And recursive function calls are expensive and recursive times are limited by stack size.
+
+## Progressive learning
+
+1. Fork 我的项目并提交你的 `idea`
+2. Pull Request
+3. Merge
+
+## 纠错
+
+If you find something wrong, you can initiate a [issue](https://github.com/PuShaoWei/designPatterns-go/issues)or [pull request](https://github.com/PuShaoWei/designPatterns-go/pulls),I will correct it in time
+
+> 补充:发起pull request的commit message请参考文章[Commit message 和 Change log 编写指南](http://www.ruanyifeng.com/blog/2016/01/commit_message_change_log.html)
+
+## Contributors
+
+Thanks for the issue or pull request of the following friends:
+
+- [hailwood ](https://github.com/hailwood)
+
+- [zhangxuanru](https://github.com/zhangxuanru)
+
+- [ifreesec](https://github.com/ifreesec)
+
+- [openset](https://github.com/openset)
+
+- [Neroxiezi](https://github.com/Neroxiezi)
+
+ ## License
+
+MIT
diff --git a/README.md b/README.md
index 9229c40..5217772 100644
--- a/README.md
+++ b/README.md
@@ -1,116 +1,264 @@
-用 PHP 的方式实现的各类算法合集
-===============
+
:whale: 用 PHP 的方式实现的各类算法合集 :whale:
-[](https://github.com/PuShaoWei/arithmetic-php)
-[](https://github.com/PuShaoWei/arithmetic-php)
-[](https://github.com/PuShaoWei/arithmetic-php)
-[](https://github.com/PuShaoWei/arithmetic-php)
-[](https://github.com/PuShaoWei/arithmetic-php)
-[]()
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-## About
-
-> 如果说各种编程语言是程序员的招式,那么数据结构和算法就相当于程序员的内功。
+ English
+> 每周最少一更，求出题，求虐待 At least once a week, ask for problems and abuse
## 简易结构
-
- ├──Package
- │ ├── Sort 排序篇
- │ │ ├── BubbleSort.php 冒泡排序
- │ │ ├── QuickSort.php 快速排序
- │ │ ├── ShellSort.php 希尔排序
- │ │ └── MergeSort.php 归并排序
- │ │
- │ ├── Query 查询篇
- │ │ ├── BinaryQuery.php 二分查找
- │ │ └── 快速查找
- │ │
- │ └── Other 其他
- │ └── BigSmallReplace.php Hello World 输出 Olleh Dlrow
- │
- ├──LICENSE
- └──README.md
-
-## 时间复杂度
-
-> #### 时间频度
- 一个算法执行所耗费的时间，从理论上是不能算出来的，必须上机运行测试才能知道。
- 但我们不可能也没有必要对每个算法都上机测试，只需知道哪个算法花费的时间多，哪个算法花费的时间少就可以了。
- 并且一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。
- 一个算法中的语句执行次数称为语句频度或时间频度。记为 `T(n)`。
-
-> #### 时间复杂度
- 在刚才提到的时间频度中，n称为问题的规模，当n不断变化时，时间频度T(n)也会不断变化。
- 但有时我们想知道它变化时呈现什么规律。为此，我们引入时间复杂度概念。
- 一般情况下，算法中基本操作重复执行的次数是问题规模n的某个函数，用T(n)表示，
- 若有某个辅助函数f(n),使得当n趋近于无穷大时，T（n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。
- 记作T(n)=Ｏ(f(n)),称Ｏ(f(n)) 为算法的渐进时间复杂度，简称时间复杂度。时间频度不同，但时间复杂度可能相同。
- 如：T(n)=n2+3n+4与T(n)=4n2+2n+1它们的频度不同，但时间复杂度相同，都为O(n2)。
- 按数量级递增排列，常见的时间复杂度有：常数阶O(1),对数阶O(log2n),线性阶O(n), 线性对数阶O(nlog2n),平方阶O(n2)，立方阶O(n3),...， k次方阶O(nk),指数阶O(2n)。
- 随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。
-
-> #### 最坏时间复杂度和平均时间复杂度
- 最坏情况下的时间复杂度称最坏时间复杂度。一般不特别说明，讨论的时间复杂度均是最坏情况下的时间复杂度。
- 这样做的原因是：最坏情况下的时间复杂度是算法在任何输入实例上运行时间的上界，这就保证了算法的运行时间不会比任何更长。
- 在最坏情况下的时间复杂度为T(n)=0(n)，它表示对于任何输入实例,该算法的运行时间不可能大于0(n)。
- 平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下，算法的期望运行时间。指数阶0(2n)，显然，时间复杂度为指数阶0(2n)的算法效率极低，当n值稍大时就无法应用。
-
-> #### 求时间复杂度
-> 如果算法的执行时间不随着问题规模n的增加而增长，即使算法中有上千条语句，其执行时间也不过是一个较大的常数。此类算法的时间复杂度是O(1)。
+
```
- x=91; y=100;
- while(y>0) if(x>100) {x=x-10;y--;} else x++;
-```
-解答： T(n)=O(1)，
-这个程序看起来有点吓人，总共循环运行了1100次，但是我们看到n没有?
-没。这段程序的运行是和n无关的，
-就算它再循环一万年，我们也不管他，只是一个常数阶的函数
-- 当有若干个循环语句时，算法的时间复杂度是由嵌套层数最多的循环语句中最内层语句的频度f(n)决定的。
+├──Package
+│ ├── Sort 排序篇
+│ │ ├── BubbleSort.php 冒泡排序
+│ │ ├── HeapSort.php 堆排序 大根堆
+│ │ ├── MBaseSort.php 基数排序 MSD
+│ │ ├── LBaseSort.php 基数排序 LSD
+│ │ ├── QuickSort.php 快速排序
+│ │ ├── ShuttleSort.php 飞梭排序
+│ │ ├── ShellSort.php 希尔排序
+│ │ ├── MergeSort.php 归并排序
+│ │ ├── InsertSort.php 插入排序
+│ │ └── SelectSort.php 选择排序
+│ │
+│ ├── Query 查找篇
+│ │ ├── BinaryQuery.php 二分查找
+│ │ ├── InseertQuery.php 插入查找
+│ │ ├── FibonacciQuery.php 斐波那契查找
+│ │ ├── BFSQuery.php 广度优先查找
+│ ├── Kmp.php 算法导论-KMP算法
+│ ├── DijkstraQuery.php 迪克斯特拉算法
+│ │ └── QulickQuery.php 快速查找
+│ │
+│ ├── Structure 数据结构
+│ │ ├── StackExample.php 堆栈 先进后出 LIFO (Last In First Out)
+│ │ ├── LinearChain.php 线性表 单链存储
+│ │ └── LinearOrder.php 线性表 顺序存储
+│ │ └── BinarySearchTree.php 二叉搜索树
+│ │
+│ ├── Tools 小工具集
+│ │ └── SystemSwitch.php 堆栈实现进制转换
+│ │
+│ └── Other 其他
+│ ├── MonkeyKing.php 约瑟夫环
+│ ├── DynamicProgramming.php 动态规划
+│ ├── Fibonacci.php 斐波那契数列
+│ ├── StealingApples.php 偷苹果求余
+│ ├── HanoiGames.php 汉诺塔游戏
+│ ├── BidirectionalQueue.php 双向队列
+│ ├── ColorBricks.php 彩色砖块
+│ ├── GetCattle.php 牛年求牛
+│ ├── OnlyNumbers.php 求唯一数
+│ ├── PokerGames.php 洗扑克牌
+│ ├── Interval.php 抽奖区间算法
+│ ├── Maze.php 迷宫寻址算法
+│ ├── AntsClimb.php 蚂蚁爬杆算法
+│ ├── Encryption.php 对称加密算法
+│ ├── ElevatorDispatch.php 编程之美-电梯调度算法
+│ ├── PointInTriangle.php 向量叉集计算点是否在三角形中
+│ ├── TraversalOfBinary.php 二叉树非递归遍历算法实现
+│ ├── Knapsack.php 贪心算法之背包问题实现
+│ └── BigSmallReplace.php Hello World 输出 Olleh Dlrow
+│ └── Solution.php Facebook面试题之岛屿周长算法
+│ └── RotationSort.php Facebook面试题之顺时针回旋算法
+│ └── Square.php Facebook面试题之判断四个点能否组成正方形算法
+│ └── Prim.php Prim算法(最小生成树算法)
+│ └── CartesianProduct.php 笛卡尔积算法
+│ └── Square.php 面试题之平面任意四点能否组成一个矩形
+│ └── Judge.php 面试题之扑克牌中任选五张判断是不是顺子
+│ └── Factorial.php 面试题之N的阶乘末尾有多少个0
+| └── HashTable.php HashTable
+| └── RotateSort.php 面试题之风车旋转排序算法
+│
+├──LICENSE
+└──README.md
+```
+
+## 要做什么？
+
```
- x=1;
-for(i=1;i<=n;i++)
- for(j=1;j<=i;j++)
- for(k=1;k<=j;k++)
- x++;
+记录自己理解算法，数据结构的过程，尽可能的简单全面以及详细，让算法学习运用灵活自如，加油(ง •̀_•́)ง
```
-该程序段中频度最大的语句是(5)，内循环的执行次数虽然与问题规模n没有直接关系，但是却与外层循环的变量取值有关，而最外层循环的次数直接与n有关，
-因此可以从内层循环向外层分析语句(5)的执行次数： 则该程序段的时间复杂度为T(n)=O(n3/6+低次项)=O(n3)
-- 算法的时间复杂度不仅仅依赖于问题的规模，还与输入实例的初始状态有关。
-在数值A[0..n-1]中查找给定值K的算法大致如下：
+
+## 当然
+
```
-i=n-1;
-while(i>=0&&(A[i]!=k))
- i--;
-return i;
+用 PHP 实现算法并替代官方提供的函数是愚蠢的事情 .但这决不代表斟酌算法就是件无意义的事 , 每个算法都是一种思想的结晶 , 学习优秀的思想 , 开拓思维
```
-此算法中的语句(3)的频度不仅与问题规模n有关，还与输入实例中A的各元素取值及K的取值有关:
- - ①若A中没有与K相等的元素，则语句(3)的频度f(n)=n；
- - ②若A的最后一个元素等于K, 则语句(3)的频度f(n)是常数0。
-
-- 时间复杂度评价性能
- 有两个算法A1和A2求解同一问题，时间复杂度分别是T1(n)=100n2，T2(n)=5n3。
- （1）当输入量n＜20时，有T1(n)＞T2(n)，后者花费的时间较少。
- （2）随着问题规模n的增大，两个算法的时间开销之比5n3/100n2=n/20亦随着增大。即当问题规模较大时，算法A1比算法A2要有效地多。
- 它们的渐近时间复杂度O(n2)和O(n3)从宏观上评价了这两个算法在时间方面的质量。
- 在算法分析时，往往对算法的时间复杂度和渐近时间复杂度不予区分，而经常是将渐近时间复杂度T(n)=O(f(n))简称为时间复杂度，
- 其中的f(n)一般是算法中频度最大的语句频度。
-
-## 空间复杂度
- 一个程序的空间复杂度是指运行完一个程序所需内存的大小。
- 利用程序的空间复杂度，可以对程序的运行所需要的内存多少有个预先估计。一个程序执行时除了需要存储空间和存储本身所使用的指令、常数、变量和输入数据外，
- 还需要一些对数据进行操作的工作单元和存储一些为现实计算所需信息的辅助空间。程序执行时所需存储空间包括以下两部分。
-> #### 固定部分
- 这部分空间的大小与输入/输出的数据的个数多少、数值无关。主要包括指令空间（即代码空间）、数据空间（常量、简单变量）等所占的空间。这部分属于静态空间。
-> #### 可变空间，这部分空间的主要包括动态分配的空间，以及递归栈所需的空间等。这部分的空间大小与算法有关。
- 一个算法所需的存储空间用f(n)表示。S(n)=O(f(n)) 其中n为问题的规模，S(n)表示空间复杂度。
+
+## 什么是算法？
+
+直白地说，算法就是任何明确定义的计算过程，它接收一些值或集合作为输入，并产生一些值或集合作为输出。这样，算法就是将输入转换为输出的一系列计算过程。来源：Thomas H. Cormen, Chales E. Leiserson (2009), 《算法导论第三版》。
+
+简而言之，我们可以说算法就是用来解决一个特定任务的一系列步骤（是的，不止计算机在使用算法，人类也同样如此）。目前，一个有效的算法应该含有三个重要特性：
+
+- 它必须是有限的：如果你设计的算法永无休止地尝试解决问题，那么它是无用的。
+- 它必须具备明确定义的指令：算法的每一步都必须准确定义，在任何场景下指令都应当没有歧义。
+- 它必须是有效的：一个算法被设计用以解决某个问题，那么它就应当能解决这个问题，并且仅仅使用纸和笔就能证明该算法是收敛的。
+
+## 对数
+
+log10100 相当于问"将多少个10相乘的结果为100"，答案当然是2个了
+因此log10100=2，即对数运算是幂运算的逆运算
+
+| left | right |
+| ------------------ | --------------------- |
+| 23 = 8 | log28 = 3 |
+| 24 = 16 | log216 = 4 |
+| 25 = 32 | log232 = 5 |
+
+## 运行时间
+
+以二分查找为例，使用它可节省多少时间呢？简单查找逐个地检查数字，如果列表包含100个数字，最多需要猜100次。
+换而言之最多需要猜测的次数与列表长度相同，这被称为线性时间(linear time)，而二分查找则不同，如果列表包含100个元素
+最多需要7次，如果列表包含40亿个数字，最多需猜32次，而分查找的运行时间为对数时间 `O(log)`
+
+## 大O表示法
+
+大O表示法是一种特殊的表示法 ，指出了算法的速度有多快。有个屌用啊，实际上，你经常要去复制别人的代码。
+在这种情况下，知道这些算法的速度有快有慢
+
+- 算法的运行时间以不同的速度增加
+ - 例如简单查找与二分查找的区别
+
+| 元素 | 简单查找 | 二分查找 |
+| ----------------- | ----- | ---- |
+| 100个元素 | 100ms | 7ms |
+| 10000个元素 | 10s | 14ms |
+| 1 000 000 000 个元素 | 11天 | 30ms |
+
+- 大`O`表示法指出了算法有多快，例如列表包含`n`个元素，简单查找需要检查每个元素，因此需要执行`n`次操作
+ 使用大`O`表示法这个运行时间为`O(n)`,二分查找需要执行logn次操作，使用大`O`表示为`O(log n)`
+ - 一些常见的大O运行时间
+- O(log n) ,也叫对数时间，这样的算法包括二分算法
+- O(n),也叫线性时间，这样的算法包括简单查找。
+- O(n * log n) 快速排序
+- O(n2),选择排序
+- O(n!) 即阶乘时间
+ - 这里是重点
+- 算法的速度指的并非时间，而是操作数的增速
+- 谈论算法的速度时间时，我们说的是随着输入的增加，其运行时间将以什么样的速度增加
+- 算法的运行时间用大O表示法表示
+- O(log n)比O(n)快，当需要搜索的元素越多时，前者比后者快的越多
+
+## 编写解决实际问题的程序过程
+
+- 如何用数据形式描述问题，即将问题抽象为一个数学模型
+- 问题所涉及到的数据量的大小及数据之间的关系
+- 如何在计算机中储存数据及体现数据之间的关系
+- 处理数据时需要对数据执行的操作
+- 编写的程序的性能是否良好
+
+## 数据(Data)
+
+- 是客观事物的符号表示，在计算机科学中指的是所有能输入到计算机中并被计算机程序处理的符号的总称。
+- 数据元素(Data Element) :是数据的基本单位，在程序中通常作为一个整体来进行考虑和处理。一个数据元素可由若干个数据项(Data Item)组成。
+- 数据项(Data Item) : 是数据的不可分割的最小单位。数据项是对客观事物某一方面特性的数据描述。
+- 数据对象(Data Object) :是性质相同的数据元素的集合，是数据的一个子集。如字符集合C={‘A’,’B’,’C,…} 。
+- 数据结构 :相互之间具有一定联系的数据元素的集合。
+- 数据的逻辑结构 : 数据元素之间的相互关系称为逻辑结构。
+- 数据操作 : 对数据要进行的运算
+- 数据类型(Data Type):指的是一个值的集合和定义在该值集上的一组操作的总称。
+
+## 数据的逻辑结构有四种基本类型
+
+- 集合：结构中数据元素之间除了“属于同一个集合"外,再也没有其他的关系
+- 线性结构：结构中的数据元素存在一对一的关系
+- 树形结构：结构中的数据元素存在一对多的关系
+- 网状或者图状结构：结构中的数据元素存在多对多的关系
+
+## 数据结构的储存方式
+
+由数据元素之间的关系在计算机中有两种不同的表示方法——顺序表示和非顺序表示，从则导出两种储存方式，顺序储存结构和链式储存结构
+
+- 顺序存储结构：用数据元素在存储器中的相对位置来表示数据元素之间的逻辑结构(关系)，数据元素存放的地址是连续的
+- 链式存储结构：在每一个数据元素中增加一个存放另一个元素地址的指针(pointer)，用该指针来表示数据元素之间的逻辑结构(关系)，数据元素存放的地址是否连续没有要求
+
+数据的逻辑结构和物理结构是密不可分的两个方面，一个算法的设计取决于所选定的逻辑结构，而算法的实现依赖于所采用的存储结构
+
+## 算法(Algorithm)
+
+是对特定问题求解方法(步骤)的一种描述，是指令的有限序列，其中每一条指令表示一个或多个操作。
+
+> 算法具有以下五个特性
+
+- 有穷性： 一个算法必须总是在执行有穷步之后结束，且每一步都在有穷时间内完成
+- 确定性：算法中每一条指令必须有确切的含义，不存在二义性，且算法只有一个入口和一个出口
+- 可行性： 一个算法是能行的，即算法描述的操作都可以通过已经实现的基本运算执行有限次来实现
+- 输入： 一个算法有零个或多个输入，这些输入取自于某个特定的对象集合
+- 输出： 一个算法有一个或多个输出，这些输出是同输入有着某些特定关系的量
+
+> 算法和程序是两个不同的概念
+
+一个计算机程序是对一个算法使用某种程序设计语言的具体实现。算法必须可终止意味着不是所有的计算机程序都是算法。
+
+> 评价一个好的算法有以下几个标准
+
+- 正确性(Correctness )： 算法应满足具体问题的需
+- 可读性(Readability)： 算法应容易供人阅读和交流，可读性好的算法有助于对算法的理解和修改
+- 健壮性(Robustness)： 算法应具有容错处理，当输入非法或错误数据时，算法应能适当地作出反应或进行处理，而不会产生莫名其妙的输出结果
+- 通用性(Generality)： 算法应具有一般性 ，即算法的处理结果对于一般的数据集合都成立
+
+> 效率与存储量需求： 效率指的是算法执行的时间；存储量需求指算法执行过程中所需要的最大存储空间，一般地，这两者与问题的规模有关
+
+## 算法的时间复杂度
+
+算法中基本操作重复执行的次数是问题规模n的某个函数，其时间量度记作T(n)=O(f(n))，称作算法的渐近时间复杂度(Asymptotic Time complexity)，简称时间复杂度
+
+## 算法的空间复杂度
+
+是指算法编写成程序后，在计算机中运行时所需存储空间大小的度量，记作：S(n)=O(f(n)),其中n为问题规模
+
+## 递归和循环的简单比较：
+
+1. 从程序上看，递归表现为自己调用自己，循环则没有这样的形式。
+2. 递归是从问题的最终目标出发，逐渐将复杂问题化为简单问题，并且简单的问题的解决思路和复杂问题一样，同时存在基准情况，就能最终求得问题，是逆向的。而循环是从简单问题出发，一步步的向前发展，最终求得问题，是正向的。
+3. 任意循环都是可以用递归来表示的，但是想用循环来实现递归（除了单向递归和尾递归），都必须引入栈结构进行压栈出栈。
+4. 一般来说，非递归的效率高于递归。而且递归函数调用是有开销的，递归的次数受堆栈大小的限制。
## 一起进步学习
- 1. Fork 我的项目
- 2. Pull Request
- 3. Merge
+
+1. Fork 我的项目并提交你的 `idea`
+2. Pull Request
+3. Merge
## 纠错
如果大家发现有什么不对的地方，可以发起一个[issue](https://github.com/PuShaoWei/arithmetic-php/issues)或者[pull request](https://github.com/PuShaoWei/arithmetic-php/pulls),我会及时纠正
+
> 补充:发起pull request的commit message请参考文章[Commit message 和 Change log 编写指南](http://www.ruanyifeng.com/blog/2016/01/commit_message_change_log.html)
+
+## 致谢
+
+感谢以下朋友的issue或pull request：
+
+- [hailwood ](https://github.com/hailwood)
+
+- [zhangxuanru](https://github.com/zhangxuanru)
+
+- [ifreesec](https://github.com/ifreesec)
+
+- [openset](https://github.com/openset)
+
+- [Neroxiezi](https://github.com/Neroxiezi)
+
+ ## License
+
+MIT
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 0000000..ac1360d
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,17 @@
+# Security Policy
+
+## Supported Versions
+
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version | Supported |
+| ------- | ------------------ |
+| 5.1.x | :white_check_mark: |
+| 5.0.x | :x: |
+| 4.0.x | :white_check_mark: |
+| < 4.0 | :x: |
+
+## Reporting a Vulnerability
+
+Please report security issues to
diff --git a/_config.yml b/_config.yml
new file mode 100644
index 0000000..c419263
--- /dev/null
+++ b/_config.yml
@@ -0,0 +1 @@
+theme: jekyll-theme-cayman
\ No newline at end of file
diff --git a/composer.json b/composer.json
new file mode 100644
index 0000000..05a3a26
--- /dev/null
+++ b/composer.json
@@ -0,0 +1,44 @@
+{
+ "name": "algorithm-php",
+ "description": "algorithm-php",
+ "minimum-stability": "stable",
+ "license": "MIT",
+ "authors": [
+ {
+ "name": "pushaowei"
+ }
+ ],
+ "require-dev": {
+ "phpunit/phpunit": "~6.0",
+ "mockery/mockery": "~0.9"
+ },
+ "autoload": {
+ "classmap": [
+ "./src"
+ ]
+ },
+ "autoload-dev": {
+ "classmap": [
+ "tests/"
+ ]
+ },
+ "prefer-stable": true,
+ "config": {
+ "optimize-autoloader": true
+ },
+ "repositories": {
+ "packagist": {
+ "type": "composer",
+ "url": "https://packagist.phpcomposer.com"
+ }
+ },
+ "require": {
+ "ext-json": "*",
+ "ext-ctype": "*",
+ "ext-openssl": "*",
+ "php": ">=5.6.4",
+ "ext-curl": "*",
+ "stojg/recommend": "^1.0",
+ "ext-iconv": "*"
+ }
+}
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 0000000..4cf0e34
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,9 @@
+version: '2.0'
+services:
+ php71-dev:
+ image: "m9rco/php:7.1-dev"
+ ports:
+ - "2222:22"
+ - "29000:9000"
+ volumes:
+ - $PWD:/app:rw
\ No newline at end of file
diff --git a/package/Other/BigSmallReplace.php b/package/Other/BigSmallReplace.php
deleted file mode 100644
index cdd178f..0000000
--- a/package/Other/BigSmallReplace.php
+++ /dev/null
@@ -1,52 +0,0 @@
-
- * @date 2017/8/12
- * @license Mozilla
- */
-
-/**
- * segmentFault： https://segmentfault.com/q/1010000010627229
- *
- * @language php
- * @author Pu Shaowei
- * @param $str
- * @return string
- */
-function BigSmallReplace( $str )
-{
- // Cutting words
- $first = preg_split("/[\s]+/", $str);
- $result = [];
-
- // Start
- foreach ( $first as $f_value ) {
- $str_len = strlen($f_value) - 1; $i = 0; $temp = '';
- while ( $str_len >= 0 ) {
- if ( ord($f_value[$str_len]) > 64 && ord($f_value[$str_len]) < 91 ) {
- $temp .= strtoupper($f_value[$i]);
- }else if ( ord($f_value[$str_len]) > 96 && ord($f_value[$str_len]) < 123 ) {
- $temp .= strtolower($f_value[$i]);
- }
- $i++; $str_len--;
- }
- array_push($result, strrev($temp));
- }
- return implode(' ',$result);
-}
-
-var_dump(BigSmallReplace('Hello World'));
-// Olleh Dlrow
-
-
-/*
-Hello World 输出 Olleh Dlrow
-
-SWAT 输出 TAWS
-
-I am A sTudent 输出 I ma A tNeduts
-*/
-
diff --git a/package/Query/BinaryQuery.php b/package/Query/BinaryQuery.php
deleted file mode 100644
index aedc8c2..0000000
--- a/package/Query/BinaryQuery.php
+++ /dev/null
@@ -1,60 +0,0 @@
-
- * @date 2017/6/17
- * @license Mozilla
- * -------------------------------------------------------------
- * 思路分析：数组中间的值floor((low+top)/2)
- * -------------------------------------------------------------
- * 先取数组中间的值floor((low+top)/2)然后通过与所需查找的数字进行比较，
- * 若比中间值大则将首值替换为中间位置下一个位置，继续第一步的操作；
- * 若比中间值小，则将尾值替换为中间位置上一个位置，继续第一步操作
- * 重复第二步操作直至找出目标数字
- */
-
-/**
- * 非递归版 二分查找
- * @param array $container
- * @param $search
- * @return int|string
- */
-function BinaryQuery( array $container,$search){
- $top = count($container);
- $low = 0;
- while ( $low <= $top){
- $mid = intval( floor( ($low + $top ) / 2) );
- if( !isset($container[$mid]) ) return '没找着哦';
- if( $container[$mid] == $search) return $mid;
- $container[$mid] < $search && $low = $mid+1;
- $container[$mid] > $search && $top = $mid-1;
- }
-}
-// var_dump( BinaryQuery([0,1,2,3,4,5,6,7,8,9],9) );
-/*
- * double(8)
- */
-
-/**
- * 递归版 二分查找
- * @param array $container
- * @param $search
- * @param int $low
- * @param string $top
- * @return int|string
- */
-function BinaryQueryRecursive(array $container,$search,$low = 0,$top = 'default'){
- $top == 'default' && $top = count($container );
- if( $low <= $top ){
- $mid = intval( floor( $low + $top ) /2 );
- if( !isset($container[$mid]) ) return '没找着哦';
- if( $container[$mid] == $search) return $mid;
- if( $container[$mid] < $search ){
- return BinaryQueryRecursive($container,$search,$mid+1,$top);
- }else{
- return BinaryQueryRecursive($container,$search,$low,$mid-1);
- }
- }
-}
-
-// var_dump( BinaryQueryRecursive([0,1,2,3,4,5,6,7,8,9],9) );
diff --git a/package/Sort/QuickSort.php b/package/Sort/QuickSort.php
deleted file mode 100644
index 3902d5f..0000000
--- a/package/Sort/QuickSort.php
+++ /dev/null
@@ -1,34 +0,0 @@
-
- * @date 2017/6/17
- * @license Mozilla
- * -------------------------------------------------------------
- * 思路分析：从数列中挑出一个元素，称为 “基准”（pivot)
- * -------------------------------------------------------------
- * 重新排序数列，所有元素比基准值小的摆放在基准前面
- * 所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
- * 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序
- */
-
-/**
- * @param array $container
- * @return array|void
- */
-function QulickSort( array $container ){
- $count = count( $container );
- if( $count <= 1 ) return;
- $left = $right = [];
- for ( $i =0; $i<$count-1;$i++ ){
- if( $container[$i] < $container[0] ){
- $left[] = $container[$i];
- }else{
- $right[]= $container[$i];
- }
- }
- $left = QulickSort($left); $right = QulickSort($right);
- return array_merge($left,[$container[0],$right]);
-}
-
-var_dump( QulickSort([4,21,41,2,53,1,213,31,21,423]) );
\ No newline at end of file
diff --git a/phpunit.xml b/phpunit.xml
new file mode 100644
index 0000000..5dd071d
--- /dev/null
+++ b/phpunit.xml
@@ -0,0 +1,20 @@
+
+
+
+
+
+
+
+
+ ./tests
+
+
+
\ No newline at end of file
diff --git a/src/Features/SystemSwitch.php b/src/Features/SystemSwitch.php
new file mode 100644
index 0000000..598983b
--- /dev/null
+++ b/src/Features/SystemSwitch.php
@@ -0,0 +1,99 @@
+
+ * @date 2017/10/16
+ * @license MIT
+ * -------------------------------------------------------------
+ * 十进制整数转换为二、八、十六进制整数 n = (n div d) * d + n mod d
+ * -------------------------------------------------------------
+ */
+class SystemSwitch
+{
+ /**
+ * @var array
+ */
+ protected $systemGather;
+
+ /**
+ * @var int
+ */
+ protected $input;
+
+ /**
+ * @var mixed
+ */
+ protected $output;
+
+ /**
+ * SystemSwitch constructor.
+ *
+ * @param $input
+ * @param $output
+ */
+ public function __construct($input, $output)
+ {
+ $this->systemGather = array (2, 8, 16);
+ $this->input = $input;
+ $this->output = $output;
+ }
+
+ public function run()
+ {
+ $before = $this->input;
+ $stack = new StackExample();
+ while ($this->input != 0) {
+ $mod = $this->input % $this->output;
+ $stack->setPushStack($mod);
+ $this->input = (int)($this->input - $mod) / $this->output;
+ }
+ $output = '';
+ if ($this->output == 16) {
+ $output .= '0x';
+ } else if ($this->output == 8) {
+ $output .= '0';
+ }
+
+ foreach ($stack->getAllPopStack() as $value) {
+ if ($this->output == 16) {
+ switch ($value) {
+ case 10:
+ $value = 'A';
+ break;
+ case 11:
+ $value = 'B';
+ break;
+ case 12:
+ $value = 'C';
+ break;
+ case 13:
+ $value = 'D';
+ break;
+ case 14:
+ $value = 'E';
+ break;
+ case 15:
+ $value = 'F';
+ break;
+ }
+ }
+ $output .= $value;
+ }
+ // 因为输出语句会自动将整型的数转换为10进制输出
+ // 也即如果转换后的结果为0xff,直接将0xff输出会得到255，所以返回一数组
+ return array (
+ 'before' => $before, // 转换之前
+ 'after' => intval($output, $this->output), // 转换后的整型数（整型）
+ 'string' => $output // 转换后的整型数的字符串表示（字符串型）
+ );
+ }
+}
+
+// load the stack
+define("DS", DIRECTORY_SEPARATOR);
+require_once dirname(__DIR__) . DS . 'Structure' . DS . 'StackExample.php';
+$systemObj = new SystemSwitch(6, 16);
+$result = $systemObj->run();
+var_dump($result);
\ No newline at end of file
diff --git a/src/Features/YieldExample.php b/src/Features/YieldExample.php
new file mode 100644
index 0000000..6824554
--- /dev/null
+++ b/src/Features/YieldExample.php
@@ -0,0 +1,446 @@
+
+ * @date 2017/9/17
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：笔记局 ,觉得需要认真学习的 Yield
+ * -------------------------------------------------------------
+ * [由来]
+ * PHP从5.5引入了yield关键字，增加了迭代生成器和协程的支持，但并未在言本身级别实现一个完善的协程解决方案。
+ * PHP协程也是基于Generator，Generator可以视为一种“可中断”的函数，而 yield 构成了一系列的“中断点”。
+ * PHP 协程没有resume关键字，而是“在使用的时候唤起”协程。了解如何在PHP中实现协程，首先要解决迭代生成器。
+ * PHP > 手册 > 语言参考 > 生成器 http://php.net/manual/zh/language.generators.overview.php
+ * -------------------------------------------------------------
+ * [概念]
+ * “协程”（Coroutine）概念最早由 Melvin Conway 于1958年提出。
+ * 协程可以理解为纯用户态的线程，其通过协作而不是抢占来进行切换。
+ * 相对于进程或者线程，协程所有的操作都可以在用户态完成，创建和切换的消耗更低。
+ * 总的来说，协程为协同任务提供了一种运行时抽象，这种抽象非常适合于协同多任务调度和数据流处理。
+ * 在现代操作系统和编程语言中，因为用户态线程切换代价比内核态线程小，协程成为了一种轻量级的多任务模型。
+ * -------------------------------------------------------------
+ * [协程与进程线程的区别]
+ * 对于操作系统来说只有进程和线程，协程的控制由应用程序显式调度，非抢占式的
+ * 协程的执行最终靠的还是线程，应用程序来调度协程选择合适的线程来获取执行权
+ * 切换非常快，成本低。一般占用栈大小远小于线程（协程KB级别，线程MB级别），
+ * 所以可以开更多的协程，协程比线程更轻量级
+ * -------------------------------------------------------------
+ */
+
+/**
+ * 协程生产器
+ *
+ * @param $start
+ * @param $end
+ * @param int $step
+ * @return \Generator
+ */
+$SyncFactory = function ($start, $end, $step = 1) {
+ for ($i = $start; $i <= $end; $i += $step) {
+ yield $i;
+ }
+};
+/**
+ * 普通的生产器
+ *
+ * @param $start
+ * @param $end
+ * @param int $step
+ */
+$UsualFactory = function ($start, $end, $step = 1) {
+ for ($i = $start; $i <= $end; $i += $step) {
+ //var_dump($i);
+ }
+};
+
+$SyncFactory(1, 100000); //class Generator#2 PHP 协程没有resume关键字，而是“在使用的时候唤起”协程
+// Generator 这个东西是从 generators返回的 http://php.net/manual/zh/class.generator.php
+$UsualFactory(1, 100000);
+
+/**
+ * 从编程角度上看，协程的思想本质上就是控制流的主动让出（yield）和恢复（resume）机制，迭代器常被用来实现协程，
+ * 所以大部分的语言实现的协程中都有yield关键字，比如Python、PHP、Lua。但也有特殊比如Go就使用的是通道来通信。
+ */
+foreach ($SyncFactory(1, 10) as $value) {
+ echo $value . "\n"; // 我理解的是相当于开了100000协程跑这次输出操作
+} // 那就尝试将它唤醒吧
+
+/**
+ * [中断点]
+ * 我们从生成器认识协程需要认识到：生成器是一种具有中断点的函数，而yield构成了中断点。
+ * 比如, 你调用$range->rewind()，那么xrange()里的代码就会运行到控制流第一次出现yield的地方，
+ * 而函数内传递给yield语句的值，即为迭代的当前值，可以通过$xrange->current()获取。
+ * [PHP中的协程实现]
+ * PHP的协程支持是在迭代生成器的基础上，增加了可以回送数据给生成器的功能，从而达到双向通信即：
+ * -------------------------------------------------------------
+ * >>> 生成器<---数据--->调用者 <<<
+ * -------------------------------------------------------------
+ */
+echo '/* ------------------------- Yield接收与发送数据 ------------------------- */';
+/**
+ * 容器接收示例
+ */
+function container()
+{
+ $test = yield "Hello ";
+ var_dump($test);
+ $test = yield "World ";
+ var_dump($test);
+}
+
+$container = container(); // 这里又进化成 Generator对象了,还记得SPL 那一坨么？ 传送门 [http://php.net/manual/zh/book.spl.php]
+
+var_dump($container->key()); // 返回当前产生的键
+var_dump($container->current()); // 返回当前产生的值
+
+$container->next(); // 生成器继续执行 ,这个next 看下输出结果发现返回了个NULL 你打印什么了？
+$container->send('强势占位');
+
+var_dump($container->key()); // null
+var_dump($container->current()); // null
+
+if (!$container->valid()) {
+ echo "我没有被关闭" . PHP_EOL;
+}
+
+echo '/* ------------------------- 协程与任务调度 ------------------------- */';
+
+/**
+ * yield指令提供了任务中断自身的一种方法，然后把控制交回给任务调度器。
+ * 而PHP语言本身只是提供程序中断的功能，至于任务调度器需要我们自己实现，
+ * 同时协程在运行多个其他任务时，yield还可以用来在任务和调度器之间进行通信。
+ */
+
+/**
+ * PHP协程任务
+ * 简单的定义具有任何ID标识的协程函数，如一个轻量级的协程函数示例代码
+ * @form http://wiki.phpboy.net/doku.php?id=2017-07:54-PHP_Yield%E5%8D%8F%E7%A8%8B%E4%BB%8E%E5%85%A5%E9%97%A8%E5%88%B0%E7%B2%BE%E9%80%9A.md
+ *
+ * @version 1.0
+ */
+class Task
+{
+ protected $taskId;
+ protected $coroutine;
+ protected $sendValue = null;
+ protected $beforeFirstYield = true;
+
+ /**
+ * Task constructor.
+ *
+ * @param $taskId
+ * @param \Generator $coroutine
+ */
+ public function __construct($taskId, Generator $coroutine)
+ {
+ $this->taskId = $taskId;
+ $this->coroutine = $coroutine;
+ }
+
+ /**
+ * setSendValue
+ *
+ * @param $sendValue
+ */
+ public function setSendValue($sendValue)
+ {
+ $this->sendValue = $sendValue;
+ }
+
+ /**
+ * 跑起来的巨人
+ *
+ * @return mixed
+ */
+ public function run()
+ {
+ if ($this->beforeFirstYield) {
+ $this->beforeFirstYield = false;
+ return $this->coroutine->current();
+ } else {
+ $retval = $this->coroutine->send($this->sendValue);
+ $this->sendValue = null;
+ return $retval;
+ }
+ }
+
+ /**
+ * getTaskId
+ *
+ * @return mixed
+ */
+ public function getTaskId()
+ {
+ return $this->taskId;
+ }
+
+ /**
+ * 协程关了没？
+ *
+ * @return bool
+ */
+ public function isFinished()
+ {
+ return !$this->coroutine->valid();
+ }
+}
+
+/**
+ * PHP协程调度器
+ * 简单来说，是可以在多个任务之间相互协调，及任务之间相互切换的一种进程资源的分配器。
+ * 调度器的实现方式有多种,大致分为两类：一是，队列；二是，定时器
+ *
+ * @version 1.0
+ */
+class Scheduler
+{
+ protected $maxTaskId = 0;
+ protected $taskMap = []; // taskId => task
+ protected $taskQueue;
+
+ public function __construct()
+ {
+ // http://php.net/manual/zh/class.splqueue.php
+ $this->taskQueue = new SplQueue();
+ }
+
+ /**
+ * 创建一个task 开启一个协程
+ *
+ * @param \Generator $coroutine
+ * @return int
+ */
+ public function newTask(Generator $coroutine)
+ {
+ $tid = ++$this->maxTaskId;
+ $task = new Task($tid, $coroutine);
+
+ $this->taskMap[$tid] = $task;
+ $this->schedule($task);
+ return $tid;
+ }
+
+ /**
+ * 队列入队
+ *
+ * @param \Task $task
+ */
+ public function schedule(Task $task)
+ {
+ $this->taskQueue->enqueue($task);
+ }
+
+ /**
+ * 消费队列内容
+ */
+ public function run()
+ {
+ GLOBAL $i;
+ while (!$this->taskQueue->isEmpty()) {
+ // 出队列
+ $task = $this->taskQueue->dequeue();
+ $retval = $task->run(); // 跑Task 中的 run
+
+ echo "Scheduler runtime:" . ++$i . " retval is:\n";
+ if ($retval instanceof SystemCall) {
+ $retval($task, $this); // 如果为函数调用则这样跑起来
+ continue;
+ }
+
+ if ($task->isFinished()) { // 结束了就删掉
+ unset($this->taskMap[$task->getTaskId()]);
+ } else {
+ $this->schedule($task); // 那就回炉重造
+ }
+ }
+ }
+}
+
+class SystemCall
+{
+ protected $callback;
+
+ public function __construct(callable $callback)
+ {
+ $this->callback = $callback;
+ }
+
+ /**
+ * 以函数方式调用
+ *
+ * @param \Task $task
+ * @param \Scheduler $scheduler
+ * @return mixed
+ */
+ public function __invoke(Task $task, Scheduler $scheduler)
+ {
+ $callback = $this->callback;
+ return $callback($task, $scheduler);
+ }
+}
+
+/**
+ * newTask()方法创建一个新任务，然后把这个任务放入任务map数组里，接着它通过把任务放入任务队列里来实现对任务的调度。
+ * 接着run()方法扫描任务队列，运行任务，如果一个任务结束了，那么它将从队列里删除，否则它将在队列的末尾再次被调度。
+ */
+
+function getTaskId()
+{
+ return new SystemCall(function (Task $task, Scheduler $scheduler) {
+ $task->setSendValue($task->getTaskId());
+ $scheduler->schedule($task);
+ });
+}
+
+function task($max)
+{
+ $tid = (yield getTaskId());
+ for ($i = 0; $i < $max; $i++) {
+ echo "this is task $tid iteration $i .\n";
+ yield;
+ }
+}
+
+$scheduler = new Scheduler();
+$scheduler->newTask(task(3));
+$scheduler->newTask(task(3));
+
+//function testYield()
+//{
+// yield getTaskId();
+//}
+
+//var_dump(testYield()->current());
+$scheduler->run();
+
+/*
+function task1() {
+ for ($i = 1; $i <= 10; ++$i) {
+ echo "This is task 1 iteration $i.\n";
+ yield;
+ }
+}
+
+function task2() {
+ for ($i = 1; $i <= 5; ++$i) {
+ echo "This is task 2 iteration $i.\n";
+ yield;
+ }
+}
+$scheduler->newTask(task1(21));
+$scheduler->newTask(task2(21));
+$scheduler->run();
+*/
+
+// 最后回顾一下知识点,协程不一定能提高速度，但它一定能节约到内存
+/**
+ * 协程创建
+ *
+ * @param $start
+ * @param $limit
+ * @param int $step
+ * @return \Generator
+ */
+function xrange($start, $limit, $step = 1)
+{
+ for ($i = $start; $i <= $limit; $i += $step) {
+ yield $i;
+ }
+}
+
+$max = 999999;
+$c = new codeStatus(true);
+$c->timeStart();
+
+$simpleStart = microtime(true);
+foreach (range(1, $max, 2) as $number) {
+}
+$simpleEnd = microtime(true);
+$c->timeEnd();
+print_r($c->showStatus());
+
+$c = new codeStatus(true);
+$c->timeStart();
+$start = microtime(true);
+foreach (xrange(1, $max, 2) as $number) {
+}
+
+$end = microtime(true);
+$c->timeEnd();
+print_r($c->showStatus());
+
+
+/**
+ * 程序耗时统计
+ *
+ * @version 1.0
+ */
+class codeStatus
+{
+ /**
+ * @param:boolen $time_type时间类型, boolen$show_m是否显示内存,
+ * boolen$show_type,false是array,ture为json,$regmax是数据保留几位
+ */
+ public $regmax;
+ public $runTime = 0;
+ public $time_type;
+ public $is_show_memory;
+ public $show_type;
+ private static $t1;
+ private static $t2;
+
+ public function __construct($time_type = false, $show_m = true, $show_type = false, $regmax = 3)
+ {
+ $this->regmax = $regmax;
+ $this->is_show_memory = $show_m;
+ $this->time_type = $time_type;
+ $this->show_type = $show_type;
+ }
+
+ public function timeStart()
+ {
+ self::$t1 = microtime(true);
+ }
+
+ public function timeEnd()
+ {
+ self::$t2 = microtime(true);
+ }
+
+ private function getTime()
+ {
+ if (self::$t1 != '' && self::$t2 != '') {
+ if ($this->time_type == false) {
+ return '耗时' . round(self::$t2 - self::$t1, $this->regmax) . '秒';
+ } else if ($this->time_type == true) {
+ return '耗时' . round(self::$t2 - self::$t1, ($this->regmax + 3)) * 1000 . '毫秒';
+ }
+ } else {
+ return "error param";
+ }
+ }
+
+ private function getmemory()
+ {
+ $memory = (!function_exists('memory_get_usage')) ? '0' : round(memory_get_usage() / 1024, $this->regmax) . 'KB';
+ return '占用内存：' . $memory;
+ }
+
+ public function showStatus()
+ {
+ if ($this->is_show_memory == true) {
+ $arr = array (self::getTime(), self::getmemory());
+ } else {
+ $arr = array (self::getTime());
+ }
+ if ($this->show_type == false) {
+ return $arr;
+ } else {
+ return json_encode($arr);
+ }
+ }
+
+
+}
diff --git a/src/Other/AntsClimb.php b/src/Other/AntsClimb.php
new file mode 100644
index 0000000..448c839
--- /dev/null
+++ b/src/Other/AntsClimb.php
@@ -0,0 +1,159 @@
+
+ * @date 2018/1/11
+ * @license MIT
+ * -------------------------------------------------------------
+ * 有一根27厘米的细木杆，在第3厘米、7厘米、11厘米、17厘米、23厘米这五个位置上各有一只蚂蚁。
+ * 木杆很细，不能同时通过一只蚂蚁。开始 时，蚂蚁的头朝左还是朝右是任意的，它们只会朝前走或调头，
+ * 但不会后退。当任意两只蚂蚁碰头时，两只蚂蚁会同时调头朝反方向走。假设蚂蚁们每秒钟可以走一厘米的距离。
+ * -------------------------------------------------------------
+ * 编写程序，求所有蚂蚁都离开木杆的最小时间和最大时间
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式
+// +--------------------------------------------------------------------------
+
+class AntsClimb
+{
+ /**
+ * @var array 蚂蚁位置集合
+ */
+ protected $position;
+
+ /**
+ * AntsClimb constructor.
+ *
+ * @param array $position
+ */
+ public function __construct(array $position)
+ {
+ $this->position = $position;
+ }
+
+ /**
+ * run
+ *
+ * @return void
+ */
+ public function run()
+ {
+ $pathCalculate = $this->path($this->position);
+ echo '计算-';
+ print_r($pathCalculate);
+ echo '排序-';
+ asort($pathCalculate);
+ print_r($pathCalculate);
+ }
+
+ /**
+ * add2
+ *
+ * @param $directionArr
+ * @param $count
+ * @param $i
+ * @return mixed
+ */
+ protected function add2($directionArr, $count, $i)
+ {
+ if (0 > $i) {
+ return $directionArr;
+ }
+ if (0 === $directionArr[$i]) {
+ $directionArr[$i] = 1;
+ return $directionArr;
+ }
+ $directionArr[$i] = 0;
+ return $this->add2($directionArr, $count, $i - 1);
+ }
+
+ /**
+ * path
+ *
+ * @param $positionArr
+ * @return array
+ */
+ protected function path($positionArr)
+ {
+ // 生成测试路径
+ $pathCalculate = array ();
+ $count = count($positionArr);
+ $directionArr = array_fill(0, $count, 0);
+
+ // 朝向
+ $end = str_repeat('1', $count);
+ while (true) {
+ $path = implode('', $directionArr);
+ $total = $this->calculate($positionArr, $directionArr);
+ $pathCalculate['路径:' . $path] = $total;
+ if ($end == $path) { // 遍历完成
+ break;
+ }
+ $directionArr = $this->add2($directionArr, $count, $count - 1);
+ }
+ return $pathCalculate;
+ }
+
+ /**
+ * calculate
+ *
+ * @param $positionArr
+ * @param $directionArr
+ * @return int
+ */
+ protected function calculate($positionArr, $directionArr)
+ {
+ $total = 0;
+ // 总用时
+ $length = 27;
+ // 木杆长度
+ while ($positionArr) {
+ $total++; // 步增耗时
+ $nextArr = array (); // 下一步位置
+ foreach ($positionArr as $key => $value) {
+ if (0 == $directionArr[$key]) {
+ $next = $value - 1; // 向0方向走一步
+ } else {
+ $next = $value + 1; // 向1方向走一步
+ }
+ if (0 == $next) { // 在0方向走出
+ continue;
+ }
+ if ($length == $next) { // 在1方向走出
+ continue;
+ }
+ $nextArr[$key] = $next;
+ }
+ $positionArr = $nextArr;// 将$positionArr置为临时被查找数组
+
+ foreach ($nextArr as $key => $value) {
+ $findArr = array_keys($positionArr, $value);
+ if (count($findArr) < 2) {
+ // 没有重合的位置
+ continue;
+ }
+ foreach ($findArr as $findIndex) {
+ $directionArr[$findIndex] = $directionArr[$findIndex] ? 0 : 1;
+ // 反向处理
+ unset($positionArr[$findIndex]);
+ // 防止重复查找计算
+ }
+ }
+ $positionArr = $nextArr;
+ // 将$positionArr置为下一步结果数组
+ }
+ return $total;
+ }
+}
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+// 蚂蚁位置
+$position = array (3, 7, 11, 17, 23);
+// 测试用例
+(new AntsClimb($position))->run();
\ No newline at end of file
diff --git a/src/Other/BidirectionalQueue.php b/src/Other/BidirectionalQueue.php
new file mode 100644
index 0000000..099d705
--- /dev/null
+++ b/src/Other/BidirectionalQueue.php
@@ -0,0 +1,152 @@
+
+ * @date 2018/1/11
+ * @license MIT
+ * -------------------------------------------------------------
+ * 双向队列的实现及应用
+ * -------------------------------------------------------------
+ * 思路分析： 考察PHP几个内置数组的函数
+ * 双向队列是一种双向开口的连续线性空间，可以高效的在头尾两端插入和删除元素
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+class BidirectionalQueue
+{
+ /**
+ * @var array
+ */
+ public $queue = [];
+ public $maxLength = 0; // 对列最大长度，0表示不限
+ public $type = 0; // 对列类型
+ public $frontNum = 0; // 前端插入的数量
+ public $rearNum = 0; // 后端插入的数量
+
+ const C_AT_BOTH_ENDS = 1; // 1:两端均可输入输出
+ const C_FRONT_ONLY_INPUT = 2; // 2:前端只能输入，后端可输入输出
+ const C_FRONT_ONLY_OUTPUT = 3; // 3:前端只能输出，后端可输入输出
+ const C_BACK_ONLY_INPUT = 4; // 4:后端只能输入，前端可输入输出
+ const C_BACK_ONLY_OUTPUT = 5; // 5:后端只能输出，前端可输入输出
+ const C_BOTH_WAY_ONLY_INPUT = 6; // 6:两端均可输入输出，在哪端输入只能从哪端输出
+
+ /**
+ * BidirectionalQueue 初始化.
+ *
+ * @param int $type
+ * @param int $maxLength
+ */
+ public function __construct($type = self::C_AT_BOTH_ENDS, $maxLength = 0)
+ {
+ var_dump($this->getConfig());
+ $this->_type = in_array($type, [1, 2, 3, 4, 5, 6]) ? $type : self::C_AT_BOTH_ENDS;
+ $this->_maxLength = intval($maxLength);
+ }
+
+ /**
+ * addFirst 前端入列
+ *
+ * @param $item
+ * @return int
+ */
+ public function addFirst($item)
+ {
+ return array_unshift($this->queue, $item);
+ }
+
+ /**
+ * addLast 尾部入列
+ *
+ * @param $item
+ * @return int
+ */
+ public function addLast($item)
+ {
+ return array_push($this->queue, $item);
+ }
+
+ /**
+ * removeFirst 头部出列
+ *
+ * @return mixed
+ */
+ public function removeFirst()
+ {
+ return array_shift($this->queue);
+ }
+
+ /**
+ * removeLast 尾部出列
+ *
+ * @return mixed
+ */
+ public function removeLast()
+ {
+ return array_pop($this->queue);
+ }
+
+ /**
+ * 清空队列
+ */
+ public function makeEmpty()
+ {
+ unset($this->queue);
+ }
+
+ /**
+ * 获取列头
+ *
+ * @return mixed
+ */
+ public function getFirst()
+ {
+ return reset($this->queue);
+ }
+
+ /**
+ * 获取列尾
+ *
+ * @return mixed
+ */
+ public function getLast()
+ {
+ return end($this->queue);
+ }
+
+ /**
+ * 获取长度
+ *
+ * @return int
+ */
+ public function getLength()
+ {
+ return count($this->queue);
+ }
+
+ /**
+ * 获取配置常量
+ */
+ protected function getConfig()
+ {
+ return [
+ self::C_AT_BOTH_ENDS, // 1:两端均可输入输出
+ self::C_FRONT_ONLY_INPUT, // 2:前端只能输入，后端可输入输出
+ self::C_FRONT_ONLY_OUTPUT, // 3:前端只能输出，后端可输入输出
+ self::C_BACK_ONLY_INPUT, // 4:后端只能输入，前端可输入输出
+ self::C_BACK_ONLY_OUTPUT, // 5:后端只能输出，前端可输入输出
+ self::C_BOTH_WAY_ONLY_INPUT, // 6:两端均可输入输出，在哪端输入只能从哪端输出
+ ];
+ }
+}
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+
+new BidirectionalQueue();
\ No newline at end of file
diff --git a/src/Other/BigSmallReplace.php b/src/Other/BigSmallReplace.php
new file mode 100644
index 0000000..547a7b8
--- /dev/null
+++ b/src/Other/BigSmallReplace.php
@@ -0,0 +1,55 @@
+
+ * @date 2018/1/11
+ * @license MIT
+ * -------------------------------------------------------------
+ * Hello World 输出 Olleh Dlrow
+ * -------------------------------------------------------------
+ * SWAT 输出 TAWS
+ * I am A sTudent 输出 I ma A tNeduts
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+/**
+ * BigSmallReplace
+ *
+ * @param $str
+ * @return string
+ */
+function BigSmallReplace($str)
+{
+ // Cutting words
+ $first = preg_split("/[\s]+/", $str);
+ $result = [];
+
+ // Start
+ foreach ($first as $f_value) {
+ $str_len = strlen($f_value) - 1;
+ $i = 0;
+ $temp = '';
+ while ($str_len >= 0) {
+ if (ord($f_value[$str_len]) > 64 && ord($f_value[$str_len]) < 91) {
+ $temp .= strtoupper($f_value[$i]);
+ } else if (ord($f_value[$str_len]) > 96 && ord($f_value[$str_len]) < 123) {
+ $temp .= strtolower($f_value[$i]);
+ }
+ $i++;
+ $str_len--;
+ }
+ array_push($result, strrev($temp));
+ }
+ return implode(' ', $result);
+}
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+var_dump(BigSmallReplace('Hello World'));
diff --git a/src/Other/CartesianProduct.php b/src/Other/CartesianProduct.php
new file mode 100644
index 0000000..63f027d
--- /dev/null
+++ b/src/Other/CartesianProduct.php
@@ -0,0 +1,61 @@
+params = func_get_args();
+ }
+ public function combineDika()
+ {
+ $result = [];
+ if(count($this->params[0])!=count($this->params[0], 1)){
+ $this->params = $this->params[0];
+ }
+ $cnt = count($this->params);
+ foreach($this->params[0] as $item) {
+ $result[] = [$item];
+ }
+ for($i = 1; $i < $cnt; $i++) {
+ $result = $this->combineArray($result,$this->params[$i]);
+ }
+ return $result;
+ }
+
+ private function combineArray($arr_a, $arr_b)
+ {
+ $result = [];
+ foreach ($arr_a as $item) {
+ foreach ($arr_b as $item2) {
+ $temp = $item;
+ $temp[] = $item2;
+ $result[] = $temp;
+ }
+ }
+ return $result;
+ }
+}
+
+$color = array('白色','黑色','红色');
+$size = array('透气','防滑');
+$local = array('37码','38码','39码');
+
+$obj = new CartesianProduct($color,$size,$local);
+print_r($obj->combineDika());
+
+$sets = array(
+ array('白色','黑色','红色'),
+ array('透气','防滑'),
+ array('37码','38码','39码'),
+ array('男款','女款')
+);
+
+$obj1 = new CartesianProduct($sets);
+print_r($obj1->combineDika());
\ No newline at end of file
diff --git a/src/Other/ColorBricks.php b/src/Other/ColorBricks.php
new file mode 100644
index 0000000..d3a498d
--- /dev/null
+++ b/src/Other/ColorBricks.php
@@ -0,0 +1,98 @@
+
+ * @date 2017/9/1
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：
+ * 例如: s = "ABAB",那么小易有六种排列的结果:
+ * "AABB","ABAB","ABBA","BAAB", "BBAA" "BABA",
+ * 1-2 0 2-3 0-1 0-3 1-2
+ * "ABAB", 0
+ * "BAAB", 0-1
+ * "AABB", 0-2
+ * "BABA" 0-3
+ * "ABBA", 1-2
+ * "BBAA" 1-3
+ * -------------------------------------------------------------
+ * 小易有一些彩色的砖块。每种颜色由一个大写字母表示。各个颜色砖块看起来都完全一样。
+ * 现在有一个给定的字符串s,s中每个字符代表小易的某个砖块的颜色。小易想把他所有的砖块排成一行。
+ * 如果最多存在一对不同颜色的相邻砖块,那么这行砖块就很漂亮的。
+ * -------------------------------------------------------------
+ * 请你帮助小易计算有多少种方式将他所有砖块排成漂亮的一行。(如果两种方式所对应的砖块颜色序列是相同的,那么认为这两种方式是一样的。)
+ * -------------------------------------------------------------
+ * 例如: s = "ABAB",那么小易有六种排列的结果:
+ * "AABB","ABAB","ABBA","BAAB","BABA","BBAA"
+ * 其中只有"AABB"和"BBAA"满足最多只有一对不同颜色的相邻砖块。
+ * -------
+ * 输入描述:
+ * 输入包括一个字符串s,字符串s的长度length(1 ≤ length ≤ 50), [s中的每一个字符都为一个大写字母(A到Z)]。
+ * 输出描述:
+ * 输出一个整数,表示小易可以有多少种方式。
+ * -------
+ * 输入例子1:
+ * ABAB
+ * 输出例子1:
+ * 2
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+/**
+ * ColorBricks
+ *
+ * @param $inputting
+ * @return bool|int
+ */
+function ColorBricks($inputting)
+{
+ $count = strlen($inputting);
+ $ascii = ord($inputting);
+
+ if (!($ascii > 64 && $ascii < 91)) {
+ return false;
+ }
+ if (!(1 <= $count && $count <= 50)) {
+ return false;
+ }
+
+ $container = array ();
+ $max = floor($count / 2);
+
+ for ($i = 0; $i < $max; $i++) {
+ for ($j = 1; $j < $count; $j++) {
+ $temp = $inputting[$j];
+ $inputting[$j] = $inputting[0];
+ $inputting[0] = $temp;
+ array_push($container, $inputting);
+ }
+ }
+ $containerCount = count($container);
+ $counter = 0;
+
+ for ($i = 0; $i < $max; $i++) {
+ $success = false;
+ for ($j = 0; $j < $containerCount; $j++) {
+ $str = $container[$j];
+ if ($str[$i] == $str[0]) {
+ $success = true;
+ }
+ }
+ if ($success) {
+ $counter++;
+ }
+ }
+ return $counter;
+}
+
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+echo ColorBricks("AABB");
\ No newline at end of file
diff --git a/src/Other/DynamicProgramming.php b/src/Other/DynamicProgramming.php
new file mode 100644
index 0000000..53b6ad3
--- /dev/null
+++ b/src/Other/DynamicProgramming.php
@@ -0,0 +1,64 @@
+
+ * @date 2017/8/28
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：动态规划原理思想，max(opt(i-1,w),wi+opt(i-1,w-wi)) 当中最大值，opt(i-1,w-wi)指上一个最优解
+ * -------------------------------------------------------------
+ * 一个承受最大重量为W的背包，现在有n个物品，每个物品重量为t, 每个物品的价值为v。
+ * 要使得这个背包重量最大(但不能超过W),同时又需要背包的价值最大
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+/**
+ * DynamicProgramming
+ *
+ * @param $maxSize
+ * @param $goods
+ * @param $cost
+ * @return mixed
+ */
+function DynamicProgramming($maxSize, $goods, $cost)
+{
+ $container = [];
+ $goodsCount = count($goods);
+
+ //初始化
+ for ($i = 0; $i <= $maxSize; $i++) {
+ $container[0][$i] = 0;
+ }
+ for ($j = 0; $j <= $goodsCount; $j++) {
+ $container[$j][0] = 0;
+ }
+ for ($j = 1; $j <= $goodsCount; $j++) {
+ for ($i = 1; $i <= $maxSize; $i++) {
+ $container[$j][$i] = $container[$j - 1][$i];
+ //不大于最大的w=15
+ if ($goods[$j - 1] <= $maxSize) {
+ if (!isset($container[$j - 1][$i - $goods[$j - 1]])) {
+ continue;
+ }
+ //wi+opt(i-1,wi)
+ $tmp = $container[$j - 1][$i - $goods[$j - 1]] + $cost[$j - 1];
+ //opt(i-1,w),wi+opt(i-1,w-wi) => 进行比较
+ if ($tmp > $container[$j][$i]) {
+ $container[$j][$i] = $tmp;
+ }
+ }
+ }
+ }
+ return $container[$j - 1][$i - 1];
+}
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+echo DynamicProgramming(15, array (3, 4, 5, 6), array (8, 7, 4, 9));
diff --git a/src/Other/ElevatorDispatch.php b/src/Other/ElevatorDispatch.php
new file mode 100644
index 0000000..d1811ba
--- /dev/null
+++ b/src/Other/ElevatorDispatch.php
@@ -0,0 +1,111 @@
+
+ * @date 2018/1/11
+ * @license MIT
+ * -------------------------------------------------------------
+ * 解决方案：
+ * (1)使用简单的方法，直接将楼层从1到n开始遍历
+ * sum(person[i] * |i - j| ) 此表达式为一个双重循环，i与j均为1-n的循环。
+ * j下标表示电梯停靠的楼层。
+ * person数组表示，对应i层的下电梯的人数。此算法负责度为o(n*n)
+ * 对应的j是上述和为最小的一层即为所求。 上面的算法复杂度为o(n)
+ *
+ * (2)下面考虑一个简单的算法，使其复杂度达到o(n)
+ * 考虑假如电梯停靠在某一楼层i处，假设在i处下楼的客人为$first_layer,
+ * 在i以上楼层的客人数目为$first_layer_above ，在i一下楼层的客人数目为$first_layer_below。
+ * 且将电梯在i层停止时，全部人员的路程之和记为T。
+ *
+ * 那么加入电梯在i-1层停的话，则原来i层之上的人需要多爬一层，即增加了$first_layer_above
+ * 第i层的人需要多爬一层，则结果增加了$first_layer, i层之下的人则少爬了一层，结果减去$first_layer_below
+ * 所以第i-1层的结果为$time- $first_layer_below + $first_layer + $first_layer_above 。即结果可以即为$time-($first_layer_below - $first_layer - $first_layer_above)
+ *
+ *
+ * 下面考虑在i+1层的结果，若电梯在i+1层停止的话，原来i层之上的客户都会少爬一层，
+ * 则结果减少$first_layer_above ，而i层之下的人员则都会多爬一层即增加了$first_layer_below ，第i层的人员都会多爬一层
+ * 即为增加了$first_layer 。则结果为$time+ $first_layer_below + $first_layer - $first_layer_above
+ *
+ * 综上我们得出，
+ * (1)若$first_layer_below > $first_layer + $first_layer_above的时候， 我们在第i-1层 选择电梯停止最好。
+ * (2)若$first_layer_below + $first_layer < $first_layer_above的时候， 我们选择在第i+1层停止电梯最好。
+ *
+ * 下面我们可以先计算出来当i=1时候的T ，然后判断是否需要在i+1层停止，若是i+1层的花费
+ * 大于i层，则我们可以继续计算，否则退出。
+ */
+
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+class ElevatorDispatch
+{
+ protected $n = 10;
+ protected $person;
+ protected $time = 0; //先计算出在第一层停止的时候 所需要的花费
+ protected $first_layer_below = 0; //在第一层以下下的人数
+ protected $first_layer;
+ protected $first_layer_above = 0;//在第一层之上下电梯的人数
+ public $floor = 1;//存储停靠的楼层
+
+ public function __construct($person = [])
+ {
+ if (empty($person)) {
+ $this->person = [0, 2, 5, 7, 3, 5, 2, 6, 2, 6, 3];
+ }
+ $this->first_layer = $this->person[1]; //在第一层处下的人数
+
+ }
+
+ public function compute()
+ {
+
+ //先计算出第1层停止需要爬取的楼层数目
+ for ($i = 2; $i <= $this->n; $i++) {
+ $this->time += $this->person[$i] * ($i - 1);
+ $this->first_layer_above += $this->person[$i];
+ }
+ for ($j = 2; $j <= $this->n; $j++) {
+ if ($this->first_layer_below + $this->first_layer <= $this->first_layer_above) { //说明第i+1层的结果会大于第i层
+ $this->time += $this->first_layer_below + $this->first_layer - $this->first_layer_above;
+ $this->first_layer_below += $this->first_layer;
+ $this->first_layer = $this->person[$j];
+ $this->first_layer_above -= $this->person[$j];
+ $this->floor = $j;
+ } else {
+ //否则第i层的结果已经最小，故不需要计算第i+1层
+ break;
+ }
+ }
+ return $this->floor;
+ }
+
+ public function computeTwo()
+ {
+ $min = 6553;//存储最小值 ;
+ for ($i = 1; $i <= $this->n; $i++) { //表示第i楼层电梯停靠
+ $this->time = 0;
+ for ($j = 1; $j < $this->n; $j++) {
+ $this->time += abs(($i - $j)) * $this->person[$j];
+ }
+ if ($min > $this->time) {
+ $min = $this->time;
+ $this->floor = $i;
+ }
+ }
+ return $this->floor;
+ }
+
+}
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+
+$obj = new ElevatorDispatch();
+var_dump($obj->compute());
+var_dump($obj->computeTwo());
\ No newline at end of file
diff --git a/src/Other/Encryption.php b/src/Other/Encryption.php
new file mode 100644
index 0000000..22e5eee
--- /dev/null
+++ b/src/Other/Encryption.php
@@ -0,0 +1,78 @@
+
+ * @date 2018/1/11
+ * @license MIT
+ * -------------------------------------------------------------
+ * 位运算进行加密
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+/**
+ * 加密函数
+ *
+ * @param $txt
+ * @param $key
+ * @return string
+ */
+function passport_encrypt($txt, $key)
+{
+ $encrypt_key = md5(rand(0, 32000));
+ $ctr = 0;
+ $tmp = '';
+ for ($i = 0; $i < strlen($txt); $i++) {
+ $ctr = $ctr == strlen($encrypt_key) ? 0 : $ctr;
+ $tmp .= $encrypt_key[$ctr] . ($txt[$i] ^ $encrypt_key[$ctr++]);
+ }
+ return base64_encode(passport_key($tmp, $key));
+}
+
+/**
+ * 解密函数
+ *
+ * @param $txt
+ * @param $key
+ * @return string
+ */
+function passport_decrypt($txt, $key)
+{
+ $txt = passport_key(base64_decode($txt), $key);
+
+ $tmp = '';
+ for ($i = 0; $i < strlen($txt); $i++) {
+ $md5 = $txt[$i];
+ $tmp .= $txt[++$i] ^ $md5;
+ }
+ return $tmp;
+}
+
+/**
+ * passport_key
+ *
+ * @param $txt
+ * @param $encrypt_key
+ * @return string
+ */
+function passport_key($txt, $encrypt_key)
+{
+ $encrypt_key = md5($encrypt_key);
+ $ctr = 0;
+ $tmp = '';
+ for ($i = 0; $i < strlen($txt); $i++) {
+ $ctr = $ctr == strlen($encrypt_key) ? 0 : $ctr;
+ $tmp .= $txt[$i] ^ $encrypt_key[$ctr++];
+ }
+ return $tmp;
+}
+
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
diff --git a/src/Other/Factorial.php b/src/Other/Factorial.php
new file mode 100644
index 0000000..ccd2869
--- /dev/null
+++ b/src/Other/Factorial.php
@@ -0,0 +1,44 @@
+
+ * @date 2017/8/25
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：
+ * -------------------------------------------------------------
+ * 斐波那契数列（Fibonacci Sequence）又称黄金分割数列 兔子数列
+ * 指的是这样一个数列：1、1、2、3、5、8、13、21
+ * 在数学上，斐波纳契数列以如下被以递归的方法定义：F0=0，F1=1，Fn=F(n-1)+F(n-2)（n>=2，n∈N*）。
+ */
+
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+
+/**
+ * 递归方式
+ *
+ * @param $n
+ * @return mixed
+ */
+function FibonacciRecursive($n)
+{
+ if ($n <= 1) {
+ return $n;
+ }
+ return Fibonacci($n - 1) + Fibonacci($n - 2);
+}
+
+/**
+ * 非递归方式
+ *
+ * @param $n
+ * @return mixed
+ */
+function Fibonacci($n)
+{
+ if ($n <= 1) {
+ return $n;
+ }
+ for ($fib = [0, 1], $i = 2; $i <= $n; $i++) {
+ $fib[$i] = $fib[$i - 1] + $fib[$i - 2];
+ }
+ return $fib[$n];
+}
+
+
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+echo Fibonacci(10);
+echo FibonacciRecursive(10);
diff --git a/src/Other/GetCattle.php b/src/Other/GetCattle.php
new file mode 100644
index 0000000..0997ac0
--- /dev/null
+++ b/src/Other/GetCattle.php
@@ -0,0 +1,60 @@
+
+ * @date 2017/8/24
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：见下方注释
+ * -------------------------------------------------------------
+ *
+ * 牛年求牛：
+ * 有一母牛，到4岁可生育，每年一头，所生均是一样的母牛
+ * 15岁绝育，不再能生，
+ * 20岁死亡，问n年后有多少头牛。
+ *
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+/**
+ * getCattle
+ *
+ * @param $n
+ * @return int
+ */
+function getCattle($n)
+{
+ static $num = 1;
+ for ($i = 1; $i <= $n; $i++) {
+ if ($i == 20) {
+ $num--; //死亡需减一
+ } else if ($i >= 4 && $i < 15) {
+ $num++; //生小母牛（这里有小母牛）
+ getCattle($n - $i); //小母牛生小母牛（这里不包含小母牛）
+ }
+ }
+ return $num;
+}
+
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+echo '牛年共有：' . getCattle(10);
+
+/*
+123456789
+ 123456
+ 123
+ 12
+9 - 11
+
+---
+
+ */
\ No newline at end of file
diff --git a/src/Other/HanoiGames.php b/src/Other/HanoiGames.php
new file mode 100644
index 0000000..83b1b51
--- /dev/null
+++ b/src/Other/HanoiGames.php
@@ -0,0 +1,63 @@
+
+ * @date 2017/8/26
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：
+ * -------------------------------------------------------------
+ * 汉诺塔（又称河内塔）问题是印度的一个古老的传说。
+ * 开天辟地的神勃拉玛在一个庙里留下了三根金刚石的棒，
+ * 第一根上面套着64个圆的金片，最大的一个在底下，其余一个比一个小，依次叠上去，
+ * 庙里的众僧不倦地把它们一个个地从这根棒搬到另一根棒上，规定可利用中间的一根棒作为帮助，
+ * 但每次只能搬一个，而且大的不能放在小的上面。
+ * 面对庞大的数字(移动圆片的次数)18446744073709551615，看来，众僧们耗尽毕生精力也不可能完成金片的移动。
+ * 后来，这个传说就演变为汉诺塔游戏:
+ * 1.有三根杆子A,B,C。A杆上有若干碟子
+ * 2.每次移动一块碟子,小的只能叠在大的上面
+ * 3.把所有碟子从A杆全部移到C杆上
+ * 经过研究发现，汉诺塔的破解很简单，就是按照移动规则向一个方向移动金片：
+ * 如3阶汉诺塔的移动：A→C,A→B,C→B,A→C,B→A,B→C,A→C
+ * 此外，汉诺塔问题也是程序设计中的经典递归问题。
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+/**
+ * HanoiGames
+ *
+ * @param $n
+ * @param $x
+ * @param $y
+ * @param $z
+ */
+function HanoiGames($n, $x, $y, $z)
+{
+ if ($n == 1) {
+ echo 'move disk 1 from ' . $x . ' to ' . $z . "\n";
+ } else {
+ HanoiGames($n - 1, $x, $z, $y);
+ echo 'move disk ' . $n . ' from ' . $x . ' to ' . $z . "\n";
+ HanoiGames($n - 1, $y, $x, $z);
+ }
+}
+
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+HanoiGames(3, 'A', 'B', 'C');
+
+// move disk 1 from A to C
+// move disk 2 from A to B
+// move disk 1 from C to B
+// move disk 3 from A to C
+// move disk 1 from B to A
+// move disk 2 from B to C
+// move disk 1 from A to C
diff --git a/src/Other/HashTable.php b/src/Other/HashTable.php
new file mode 100644
index 0000000..cdd6b10
--- /dev/null
+++ b/src/Other/HashTable.php
@@ -0,0 +1,130 @@
+
+ * @date 2019/5/9
+ * @license MIT
+ * -------------------------------------------------------------
+ * HashTable
+ */
+
+
+define('TABLE_SIZE', 100);
+
+class KeyValue
+{
+ public $key;
+ public $value;
+
+ public function __construct($key, $value)
+ {
+ $this->key = $key;
+ $this->value = $value;
+ }
+}
+
+class HashTable
+{
+ public $size = 0;
+ public $data = [];
+}
+
+function create_table($size = TABLE_SIZE)
+{
+ $table = new HashTable();
+ for ($i = 0; $i < $size; ++$i) {
+ $table->data[$i] = null;
+ }
+ $table->size = 100;
+
+ return $table;
+}
+
+function destroy_table(&$table)
+{
+ unset($table);
+}
+
+function hash_key($key, $size = TABLE_SIZE)
+{
+ $len = strlen($key);
+ $hash = 0;
+ for ($i = 0; $i < $len; ++$i) {
+ $hash = $hash * 31 + ord($key[$i]);
+ }
+
+ return abs($hash % $size);
+}
+
+function print_debug($table)
+{
+ for ($i = 0; $i < $table->size; ++$i) {
+ if (null === $table->data[$i]) {
+ echo $i, "\n";
+ } else {
+ echo $i, ' key=', $table->data[$i]->key, ', value=', $table->data[$i]->value , "\n";
+ }
+ }
+}
+
+function exists(&$table, $key)
+{
+ $index = hash_key($key);
+ if (null === $table->data[$index]) {
+ return false;
+ }
+
+ if (0 === strcmp($key, $table->data[$index]->key)) {
+ return true;
+ }
+
+ return false;
+}
+
+function add(&$table, $key, KeyValue $object)
+{
+ $index = hash_key($key);
+ $table->data[$index] = $object;
+}
+
+function get(&$table, $key)
+{
+ $index = hash_key($key);
+ if (0 === strcmp($key, $table->data[$index]->key)) {
+ return $table->data[$index]->value;
+ }
+}
+
+function delete(&$table, $key)
+{
+ $index = hash_key($key);
+ if (null === $table->data[$index]) {
+ return;
+ }
+ if (0 === strcmp($key, $table->data[$index]->key)) {
+ return $table->data[$index] = null;
+ }
+}
+
+$hash_table = create_table();
+print_debug($hash_table);
+
+add($hash_table, 'Wang', new KeyValue('Wang', '50'));
+add($hash_table, 'Li', new KeyValue('Li', '20'));
+add($hash_table, 'Chow', new KeyValue('Chow', '23'));
+print_debug($hash_table);
+
+//get
+echo "----------get-------------- \n";
+var_dump(get($hash_table, 'Wang'));
+
+//delete
+echo "----------delete-------------- \n";
+delete($hash_table, 'Wang');
+var_dump(delete($hash_table, 'Wang'));
+
+//exists
+echo "----------exists-------------- \n";
+var_dump(exists($hash_table, 'Wang'));
+var_dump(exists($hash_table, 'Li'));
\ No newline at end of file
diff --git a/src/Other/Interval.php b/src/Other/Interval.php
new file mode 100644
index 0000000..0b840c2
--- /dev/null
+++ b/src/Other/Interval.php
@@ -0,0 +1,95 @@
+
+ * @date 2018/1/11
+ * @license MIT
+ * -------------------------------------------------------------
+ *
+ * 不同概率的抽奖原理就是把0到*（比重总数）的区间分块
+ * 分块的依据是物品占整个的比重，再根据随机数种子来产生0-* 中的某个数
+ * 判断这个数是落在哪个区间上，区间对应的就是抽到的那个物品。
+ * 随机数理论上是概率均等的，那么相应的区间所含数的多少就体现了抽奖物品概率的不同。
+ */
+
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+/**
+ * get_rand
+ *
+ * @param $proArr
+ * @return array
+ */
+function get_rand($proArr)
+{
+ $result = array();
+ foreach ($proArr as $key => $val) {
+ $arr[$key] = $val['v'];
+ }
+ $proSum = array_sum($arr); // 计算总权重
+ $randNum = mt_rand(1, $proSum);
+ $d1 = 0;
+ $d2 = 0;
+ for ($i = 0; $i < count($arr); $i++) {
+ $d2 += $arr[$i];
+ if ($i == 0) {
+ $d1 = 0;
+ } else {
+ $d1 += $arr[$i - 1];
+ }
+ if ($randNum >= $d1 && $randNum <= $d2) {
+ $result = $proArr[$i];
+ }
+ }
+ unset ($arr);
+ return $result;
+}
+
+/**
+ * 使用较多的为这个方法
+ *
+ * @param $proArr
+ * @return array
+ */
+function get_rand1($proArr)
+{
+ $result = array();
+ foreach ($proArr as $key => $val) {
+ $arr[$key] = $val['v'];
+ }
+ // 概率数组的总概率
+ $proSum = array_sum($arr);
+ asort($arr);
+ // 概率数组循环
+ foreach ($arr as $k => $v) {
+ $randNum = mt_rand(1, $proSum);
+ if ($randNum <= $v) {
+ $result = $proArr[$k];
+ break;
+ } else {
+ $proSum -= $v;
+ }
+ }
+ return $result;
+}
+
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+$arr = array(
+ array('id' => 1, 'name' => '特等奖', 'v' => 1),
+ array('id' => 2, 'name' => '一等奖', 'v' => 5),
+ array('id' => 3, 'name' => '二等奖', 'v' => 10),
+ array('id' => 4, 'name' => '三等奖', 'v' => 12),
+ array('id' => 5, 'name' => '四等奖', 'v' => 22),
+ array('id' => 6, 'name' => '没中奖', 'v' => 50)
+);
+
+var_dump(get_rand($arr));
+
diff --git a/src/Other/Judge.php b/src/Other/Judge.php
new file mode 100644
index 0000000..a69ef43
--- /dev/null
+++ b/src/Other/Judge.php
@@ -0,0 +1,69 @@
+weight = $weight;
+ $this->value = $value;
+ $this->total_weight = $total_weight;
+ }
+
+ # 贪心算法去算最佳的物品
+ public function bag()
+ {
+ $product = [];
+ foreach ($this->weight as $k => $v) {
+ $product[] = ['weight' => $v, 'value' => $this->value[$k], 'pj_value' => ($this->value[$k] / $v)];
+ }
+
+ $total_value = 0;
+ //按价值比去排序
+ $sorted_product = $this->sortByPj_value($product);
+ //print_r($sorted_product);
+ $total = 0;
+ foreach ($sorted_product as $k => $v) {
+ if ($total + $v['weight'] <= $this->total_weight) {
+
+ $total_value += $v['value'];
+
+ $total += $v['weight'];
+ } elseif ($total < $this->total_weight) {
+
+ for ($j = $k + 1; $j < count($sorted_product); $j++) {
+ if (($sorted_product[$j]['weight'] + $total) <= 150) {
+ $total_value += $sorted_product[$j]['value'];
+ $total += $sorted_product[$j]['weight'];
+ }
+ }
+
+ break;
+
+ }else{
+
+ break;
+ }
+ }
+
+ return [$total ,$total_value ];
+
+ }
+
+ private function sortByPj_value($product)
+ {
+ for ($i = 0; $i < count($product); $i++) {
+ for ($j = $i + 1; $j < count($product); $j++) {
+ if ($product[$i]['pj_value'] < $product[$j]['pj_value']) {
+ $temp = $product[$i];
+ $product[$i] = $product[$j];
+ $product[$j] = $temp;
+ }
+ }
+
+ }
+ return $product;
+ }
+}
+
+$obj = new Knapsack([35, 30, 60, 50, 40, 15, 10],[10, 40, 30, 50, 35, 40, 30],150);
+var_dump($obj->bag());
+
+
+
diff --git a/src/Other/Maze.php b/src/Other/Maze.php
new file mode 100644
index 0000000..1efd0a0
--- /dev/null
+++ b/src/Other/Maze.php
@@ -0,0 +1,288 @@
+
+ * @date 2018/1/11
+ * @license MIT
+ * -------------------------------------------------------------
+ * 构造迷宫二维数组
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+
+//迷宫一
+for ($l = 0; $l <= 5; $l++) {
+ for ($m = 0; $m <= 5; $m++) {
+ if ($l == 1 && $m <= 3)
+ $arr[$l][$m] = 0;
+ elseif ($l == 2 && ($m == 1 || $m == 3 || $m == 4))
+ $arr[$l][$m] = 0;
+ elseif ($l == 3 && $m <= 4 && $m != 0 && $m != 3)
+ $arr[$l][$m] = 0;
+ elseif ($l == 4 && ($m == 1 || $m >= 4))
+ $arr[$l][$m] = 0;
+ else
+ $arr[$l][$m] = 1;
+
+ echo $arr[$l][$m] . ' ';
+ }
+ echo '
';
+}
+echo '
寻地址算法的实现：
';
+
+/**
+ * findPath
+ *
+ * @param $i
+ * @param $j
+ * @param $dir
+ * @param $arr
+ * @param $iline
+ * @param $jline
+ * @param $dirline
+ * @return int
+ */
+function findPath($i, $j, $dir, $arr, $iline, $jline, $dirline)
+{
+
+ //判断是否结束
+ if ($i == 4 && $j == 5) return 1;
+ $ifdirs = 0;
+ $newdir = $dir;
+ $lastdir = $dir;
+
+
+ //如果该点为0,则前进
+ if ($arr[$i][$j] == 0) {
+ //判断方向增量
+ switch ($dir) {
+ case 0:
+ $ii = 0;
+ $jj = 1;
+ break;
+ case 1:
+ $ii = 1;
+ $jj = 0;
+ break;
+ case 2:
+ $ii = 0;
+ $jj = -1;
+ break;
+ case 3:
+ $ii = -1;
+ $jj = 0;
+ break;
+ }
+
+ //判断是否路口
+ for ($n = 1; $n <= 4; $n++) {
+ switch ($newdir) {
+ case 0:
+ $aa = 0;
+ $bb = 1;
+ break;
+ case 1:
+ $aa = 1;
+ $bb = 0;
+ break;
+ case 2:
+ $aa = 0;
+ $bb = -1;
+ break;
+ case 3:
+ $aa = -1;
+ $bb = 0;
+ break;
+ }
+ if ($arr[($i + $aa)][($j + $bb)] == 0) {
+ $ifdirs++;
+ }
+ $newdir = ($newdir + 1) % 4;
+ }
+
+ //判断是否路口，是则记录位置和方向
+ if ($ifdirs > 2) {
+
+ if (in_array($i, $iline) && in_array($j, $jline)) {
+ } else {
+ echo "该点是路口:|$i,$j,$dir|
";
+ $iline[] = $i;
+ $jline[] = $j;
+ $dirline[] = $dir;
+ }
+ }
+
+ if ($ifdirs > 1) {
+ //不是死路，前进
+ if ($arr[($i + $ii)][($j + $jj)] == 0) {
+ //方向不变，可以前进
+ $i += $ii;
+ $j += $jj;
+ echo "方向不变，可以前进:|$i,$j,$dir|
";
+ findPath($i, $j, $dir, $arr, $iline, $jline, $dirline);
+ } else {
+ //方向改变，试探
+ if ($ifdirs > 2) {
+ //该点是路口,取来时方向为路口记录方向
+ $lastdir = $dirline[(count($dirline) - 1)];
+ } else {
+ //不是路口，则在改变方向前记录方向
+ $lastdir = $dir;
+ }
+
+ //判断来时方向，不能走回头路
+ switch ($lastdir) {
+ case 0:
+ $errdir = 2;
+ break;
+ case 1:
+ $errdir = 3;
+ break;
+ case 2:
+ $errdir = 0;
+ break;
+ case 3:
+ $errdir = 1;
+ break;
+ }
+ //改变方向
+ $dir = ($dir + 1) % 4;
+
+ //判断改变后方向是否为来时方向
+ echo "不能走回头路：err:$errdir,dir:$dir
";
+ if ($dir != $errdir) {
+ echo "turn:($i,$j,$dir)
";
+ switch ($dir) {
+ case 0:
+ $mm = 0;
+ $nn = 1;
+ break;
+ case 1:
+ $mm = 1;
+ $nn = 0;
+ break;
+ case 2:
+ $mm = 0;
+ $nn = -1;
+ break;
+ case 3:
+ $mm = -1;
+ $nn = 0;
+ break;
+ }
+ if ($arr[($i + $mm)][($j + $nn)] == 0) {
+ $i += $mm;
+ $j += $nn;
+ echo "可以前进:$i,$j,$dir
";
+ findPath($i, $j, $dir, $arr, $iline, $jline, $dirline);
+ } else {
+ $dir = ($dir + 1) % 4;
+ echo "再改变方向,试探:$i,$j,$dir
";
+ if ($dir != $errdir) {
+ echo "turn:($i,$j,$dir)
";
+ switch ($dir) {
+ case 0:
+ $ii = 0;
+ $jj = 1;
+ break;
+ case 1:
+ $ii = 1;
+ $jj = 0;
+ break;
+ case 2:
+ $ii = 0;
+ $jj = -1;
+ break;
+ case 3:
+ $ii = -1;
+ $jj = 0;
+ break;
+ }
+ if ($arr[($i + $ii)][($j + $jj)] == 0) {
+ $i += $ii;
+ $j += $jj;
+ echo "可以前进:$i,$j,$dir
";
+ findPath($i, $j, $dir, $arr, $iline, $jline, $dirline);
+ }
+ } else {
+ $dir = ($dir + 1) % 4;
+ echo "再改变方向,试探:$i,$j,$dir
";
+ switch ($dir) {
+ case 0:
+ $ii = 0;
+ $jj = 1;
+ break;
+ case 1:
+ $ii = 1;
+ $jj = 0;
+ break;
+ case 2:
+ $ii = 0;
+ $jj = -1;
+ break;
+ case 3:
+ $ii = -1;
+ $jj = 0;
+ break;
+ }
+ if ($arr[($i + $ii)][($j + $jj)] == 0) {
+ $i += $ii;
+ $j += $jj;
+ echo "OK:$i,$j,$dir
";
+ findPath($i, $j, $dir, $arr, $iline, $jline, $dirline);
+ }
+
+ }
+ }
+
+ } else {
+ $dir = ($dir + 1) % 4;
+ echo "不能回头,再改变方向,试探:$i,$j,$dir
";
+ switch ($dir) {
+ case 0:
+ $ii = 0;
+ $jj = 1;
+ break;
+ case 1:
+ $ii = 1;
+ $jj = 0;
+ break;
+ case 2:
+ $ii = 0;
+ $jj = -1;
+ break;
+ case 3:
+ $ii = -1;
+ $jj = 0;
+ break;
+ }
+ if ($arr[($i + $ii)][($j + $jj)] == 0) {
+ $i += $ii;
+ $j += $jj;
+ echo "可以前进:$i,$j,$dir
";
+ findPath($i, $j, $dir, $arr, $iline, $jline, $dirline);
+ }
+ }
+ }
+ } else {
+ //是死路，需要返回到上个路口，改变方向，试探
+ $dir = $dirline[(count($dirline) - 1)];
+ $i = $iline[(count($iline) - 1)];
+ $j = $jline[(count($jline) - 1)];
+ echo "是死路，返回到上个路口，记录为：#$i,$j,$dir#
";
+ $dir = ($dir + 1) % 4;
+ findPath($i, $j, $dir, $arr, $iline, $jline, $dirline);
+
+ }
+
+ }
+}
+
+$a[] = $b[] = $c[] = 0;
+echo '初始值=>节点:($i=1,$j=1),方向:($dir=0).
';
+findPath(1, 1, 0, $arr, $a, $b, $c);
\ No newline at end of file
diff --git a/src/Other/MonkeyKing.php b/src/Other/MonkeyKing.php
new file mode 100644
index 0000000..8e25abd
--- /dev/null
+++ b/src/Other/MonkeyKing.php
@@ -0,0 +1,125 @@
+
+ * @date 2017/8/23
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：约瑟夫环问题
+ * -------------------------------------------------------------
+ * 有M个monkey ，转成一圈，第一个开始数数，数到第N个出圈，下一个再从1开始数，再数到第N个出圈，直到圈里只剩最后一个就是大王
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+
+class MonkeyKing
+{
+ protected $next;
+ protected $name;
+
+ /**
+ * MonkeyKing constructor.
+ *
+ * @param $name
+ */
+ public function __construct($name)
+ {
+ $this->name = $name;
+ }
+
+ /**
+ * whoIsKing
+ *
+ * @static
+ * @param $count
+ * @param $num
+ * @return mixed
+ */
+ public static function whoIsKing($count, $num)
+ {
+ // 构造单向循环链表
+ $current = $first = new MonkeyKing(1);
+ for ($i = 2; $i <= $count; $i++) {
+ $current->next = new MonkeyKing($i);
+ $current = $current->next;
+ }
+ // 最后一个指向第一个
+ $current->next = $first;
+ // 指向第一个
+ $current = $first;
+ // 定义一个数字
+ $cn = 1;
+ while ($current !== $current->next) {
+ $cn++;
+ if ($cn == $num) {
+ $current->next = $current->next->next;
+ $cn = 1;
+ }
+ $current = $current->next;
+ }
+ // 返回猴子姓名
+ return $current->name;
+ }
+}
+
+/**
+ * whoIsKing
+ *
+ * @param $n
+ * @param $m
+ * @return int
+ */
+function whoIsKing($n, $m)
+{
+ $r = 0;
+ for ($i = 2; $i <= $n; $i++) {
+ $r = ($r + $m) % $i;
+ }
+ return $r + 1;
+}
+
+/**
+ * king
+ *
+ * @param $n
+ * @param $m
+ * @return mixed
+ */
+function king($n, $m)
+{
+ $monkeys = range(1, $n);
+ $i = 0;
+ $k = $n;
+ while (count($monkeys) > 1) {
+ if (($i + 1) % $m == 0) {
+ unset($monkeys[$i]);
+ } else {
+ array_push($monkeys, $monkeys[$i]);
+ unset($monkeys[$i]);
+ }
+ $i++;
+ }
+ return current($monkeys);
+}
+
+
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+
+// 共10个猴子每3个出圈
+var_dump(MonkeyKing::whoIsKing(10, 3));
+
+
+var_dump(whoIsKing(10, 3));
+
+
+$a = king(10, 3);
+var_dump($a);
\ No newline at end of file
diff --git a/src/Other/NQueen.php b/src/Other/NQueen.php
new file mode 100644
index 0000000..5b16798
--- /dev/null
+++ b/src/Other/NQueen.php
@@ -0,0 +1,89 @@
+
+ * @date 2023/12/06
+ * @license MIT
+ */
+/*
+|--------------------------------------------------------------------------
+| NQueen Algorithm
+|--------------------------------------------------------------------------
+|
+| Arrange N queens on an NxN chessboard without attacking each other diagonally,
+| horizontally, or vertically—a classic problem in combinatorial optimization and
+| recursion.
+|
+*/
+
+class NQueen
+{
+
+ //Variable to store the dimensions of the chessboard
+ protected int $n;
+
+ //Chessboard represented as an array
+ protected array $board;
+
+ //Constructor to initialize the chessboard dimensions and fill it with zeros
+ public function __construct(int $n)
+ {
+ $this->n = $n;
+ $this->board = array_fill(0, $this->n, array_fill(0, $this->n, 0));
+ }
+
+ public function solve_n_queen($col = 0): void
+ {
+ if ($col >= $this->n) {
+ $this->print_result();
+ }
+
+ //Iterating through each row in the current column
+ for ($row = 0; $row < $this->n; $row++) {
+ if ($this->move_is_promising($row, $col)) {
+ //Placing the queen at the current position
+ $this->board[$row][$col] = 1;
+ //Recursively solving for the next column
+ $this->solve_n_queen($col + 1);
+ //Backtracking by removing the queen from the current position
+ $this->board[$row][$col] = 0;
+ }
+ }
+ }
+
+ public function move_is_promising($row, $col): bool
+ {
+ //Checking if there is no queen in the same row
+ for ($index = 0; $index < $col; $index++)
+ if ($this->board[$row][$index])
+ return false;
+
+ //Checking if there is no queen on the upper-left diagonal
+ for ($i = $row, $j = $col; $i >= 0 && $j >= 0; $i--, $j--)
+ if ($this->board[$i][$j])
+ return false;
+
+ //Checking if there is no queen on the lower-left diagonal
+ for ($i = $row, $j = $col; $i < $this->n && $j >= 0; $i++, $j--)
+ if ($this->board[$i][$j])
+ return false;
+
+ //If no conflicts are found, the move is promising
+ return true;
+ }
+
+ public function print_result(): void
+ {
+ for ($i = 0; $i < $this->n; $i++) {
+ for ($j = 0; $j < $this->n; $j++)
+ echo $this->board[$i][$j];
+ echo "\n";
+ }
+ echo "\n";
+ }
+}
+
+$dimensions = 4;
+(new NQueen($dimensions))->solve_n_queen();
diff --git a/src/Other/OnlyNumbers.php b/src/Other/OnlyNumbers.php
new file mode 100644
index 0000000..f076a9d
--- /dev/null
+++ b/src/Other/OnlyNumbers.php
@@ -0,0 +1,86 @@
+
+ * @date 2017/8/30
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：快排同时做唯一标示
+ * -------------------------------------------------------------
+ * 一个数组里只有唯一一个元素是不同于别的元素，其余元素是两两相等如何得到这个元素
+ *
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式
+// +--------------------------------------------------------------------------
+
+/**
+ * OnlyNumbers
+ *
+ * @param array $container
+ * @return array|bool
+ */
+function OnlyNumbers(array $container)
+{
+ $count = count($container);
+ if ($count <= 1) {
+ return $container;
+ }
+ $exist = [];
+ for ($i = 0; $i < $count; $i++) {
+ if (isset($exist[$container[$i]])) {
+ unset($exist[$container[$i]]);
+ continue;
+ }
+ $exist[$container[$i]] = true;
+ }
+ return !empty($exist) ? array_keys($exist)[0] : false;
+}
+
+// +----------------------------------------------------------------------
+// | 方法二
+// +----------------------------------------------------------------------
+/**
+ * @author Openset
+ * @link https://github.com/openset
+ * @date 2017/9/7
+ * @param array $container
+ * @return null
+ */
+function OnlyNumbersV2(array $container)
+{
+ $res = array_flip(array_count_values($container));
+
+ return isset($res[1]) ? $res[1] : null;
+}
+
+// +----------------------------------------------------------------------
+// | 方法三
+// +----------------------------------------------------------------------
+/**
+ * @author Openset
+ * @link https://github.com/openset
+ * @date 2018/2/24
+ * @param array $container
+ * @return null
+ */
+function OnlyNumbersV3(array $container)
+{
+ $num = 0;
+ foreach ($container as $v) {
+ $num ^= $v;
+ }
+
+ return $num;
+}
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+var_dump(OnlyNumbers([11, 22, 22, 11, 5, 63, 13, 5, 63, 18, 89, 13, 89]));
+var_dump(OnlyNumbersV2([11, 22, 22, 11, 5, 63, 13, 5, 63, 18, 89, 13, 89]));
+var_dump(OnlyNumbersV3([11, 22, 22, 11, 5, 63, 13, 5, 63, 18, 89, 13, 89]));
diff --git a/src/Other/PointInTriangle.php b/src/Other/PointInTriangle.php
new file mode 100644
index 0000000..60b1452
--- /dev/null
+++ b/src/Other/PointInTriangle.php
@@ -0,0 +1,113 @@
+
+ * @date 2018/1/11
+ * @license MIT
+ * -------------------------------------------------------------
+ * 利用向量叉集判断一个点是否在三角形中
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+class PointInTriangle
+{
+ /**
+ * @var array
+ */
+ protected $point;
+ /**
+ * @var array
+ */
+ protected $triangle;
+
+ /**
+ * PointInTriangle constructor.
+ *
+ * @param array $point
+ * @param array $triangle
+ */
+ public function __construct(array $point, array $triangle)
+ {
+ $this->point = $point;
+ if (count($triangle) != 3) {
+ exit('这个不是三角形');
+ }
+ $this->triangle = $triangle;
+ }
+
+ /**
+ * 向量叉集计算
+ *
+ * @param $a
+ * @param $b
+ * @param $p
+ * @return mixed
+ */
+ private function cross($a, $b, $p)
+ {
+ return ($b['x'] - $a['x']) * ($p['y'] - $a['y']) - ($b['y'] - $a['y']) * ($p['x'] - $a['x']);
+ }
+
+ /**
+ * 判断是否在左边
+ *
+ * @param $a
+ * @param $b
+ * @param $p
+ * @return bool
+ */
+ private function toLeft($a, $b, $p)
+ {
+ return $this->cross($a, $b, $p) > 0;
+ }
+
+ /**
+ * 开始构造三角形
+ *
+ * @return string
+ */
+ public function inTriangle()
+ {
+ $res = $this->toLeft($this->triangle[0], $this->triangle[1], $this->point);
+
+ if ($res != $this->toLeft($this->triangle[1], $this->triangle[2], $this->point)) {
+ return '不在三角形中';
+ }
+ if ($res != $this->toLeft($this->triangle[2], $this->triangle[0], $this->point)) {
+ return '不在三角形中';
+ }
+
+ if ($this->cross($this->triangle[0], $this->triangle[1], $this->triangle[2]) == 0) {
+ return '不在三角形中';
+ }
+ return '点' . json_encode($this->point) . '在三角形中';
+ }
+}
+
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+$point = [
+ 'x' => 4,
+ 'y' => 1
+];
+$point1 = [
+ 'x' => 4,
+ 'y' => 5
+];
+$triangle = [
+ ['x' => 1, 'y' => 1],
+ ['x' => 6, 'y' => 3],
+ ['x' => 4, 'y' => 7],
+];
+
+$obj = new PointInTriangle($point1, $triangle);
+var_dump($obj->inTriangle());
+exit;
\ No newline at end of file
diff --git a/src/Other/PokerGames.php b/src/Other/PokerGames.php
new file mode 100644
index 0000000..da0aa9b
--- /dev/null
+++ b/src/Other/PokerGames.php
@@ -0,0 +1,206 @@
+
+ * @date 2017/9/18
+ * @license MIT
+ * -------------------------------------------------------------
+ * 随机玩法
+ */
+
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+/**
+ * washCard
+ *
+ * @param $card_num
+ * @return array
+ */
+function washCard($card_num)
+{
+ $cards = range(1, $card_num);
+ for ($i = $card_num - 1; $i > 0; $i--) {
+ $rnd = rand(0, $i - 1);
+ list($cards[$rnd], $cards[$i]) = array ($cards[$i], $cards[$rnd]);
+ }
+ return $cards;
+}
+
+
+/**
+ * PokerGames 纯属娱乐，有空再优化, 这样够随机吧
+ */
+class PokerGames
+{
+ /**
+ *
+ */
+ const RANDOM = "https://www.random.org/integers/?num=%d&min=1&max=%d&col=1&base=10&format=plain&rnd=new";
+ /**
+ *
+ */
+ const LIMIT = 10;
+
+ /**
+ * @var
+ */
+ protected $resources;
+ /**
+ * @var
+ */
+ protected $tally;
+ /**
+ * @var float
+ */
+ protected $i;
+ /**
+ * @var
+ */
+ protected $count;
+ /**
+ * @var bool
+ */
+ protected $clear;
+ /**
+ * @var array
+ */
+ protected $container = array ();
+ /**
+ * @var array
+ */
+ protected $poker = array ();
+
+ /**
+ * PokerGames constructor.
+ */
+ public function __construct()
+ {
+ $this->container = $this->makePoker();
+ $count = count($this->container);
+ $this->i = $this->tally = round(100 / $count, 2);
+ $this->clear = in_array(PHP_OS, array ('Darwin', 'Linux'));
+ $this->taskJob($this->generator($count, round($count / 2)));
+ }
+
+ /**
+ * 弄着玩，不推进实际生产里玩 | 无脑方法2
+ *
+ * @param \Generator $task
+ */
+ public function taskJob(Generator $task)
+ {
+ foreach ($task as $value) {
+ if (empty($value)) {
+ break;
+ }
+ foreach ($value as $_value) {
+ if (isset($this->container[$_value])) {
+ array_push($this->poker, $this->container[$_value]);
+ unset($this->container[$_value]);
+ $this->clear && system("clear");
+ echo "正在洗牌中.. " . intval($this->tally) . "% \n";
+ $this->tally += $this->i;
+ }
+ continue;
+ }
+ }
+ }
+
+ /**
+ * __destruct,
+ */
+ public function __destruct()
+ {
+ curl_close($this->resources); // 2. 关闭资源在这个时候关闭是否合适 有待考究
+ $this->poker = array_merge($this->poker, array_diff_assoc($this->container, $this->poker));
+ var_dump($this->poker);
+ }
+
+ /**
+ * generator 好像没别的用 就为了装
+ *
+ * @param $limit
+ * @param $max
+ * @return \Generator
+ */
+ public function generator($max, $limit = 1)
+ {
+ while ($limit--) {
+ yield $this->makeRand($max);
+ }
+ }
+
+ /**
+ * 创建一副扑克牌
+ *
+ * @return array
+ */
+ public function makePoker()
+ {
+ $porker = array ('大王', '小王');
+ foreach (array ('红桃', '方块', '梅花', '黑桃') as $pValue) {
+ $limit = 13;
+ while ($limit--) {
+ switch ($limit) {
+ case 0:
+ $temp = "J";
+ break;
+ case 1:
+ $temp = "A";
+ break;
+ case 11:
+ $temp = "Q";
+ break;
+ case 12:
+ $temp = "K";
+ break;
+ default:
+ $temp = $limit;
+ break;
+ }
+ array_push($porker, $pValue . $temp);
+ }
+ }
+ return $porker;
+ }
+
+ /**
+ * 去大气噪音那里拿随机数
+ *
+ * @param $max
+ * @return mixed
+ */
+ public function makeRand($max)
+ {
+ $ch = curl_init();
+ curl_setopt_array($ch, [
+ CURLOPT_URL => sprintf(self::RANDOM, $max, $max),
+ CURLOPT_SSL_VERIFYPEER => false,
+ CURLOPT_RETURNTRANSFER => true,
+ CURLOPT_HTTPHEADER => array ('Expect:'),
+ CURLOPT_HEADER => false,
+ CURLOPT_CONNECTTIMEOUT => self::LIMIT,
+ CURLOPT_TIMEOUT => self::LIMIT,
+ ]);
+ $result = curl_exec($ch);
+ $code = curl_getinfo($ch)['http_code'];
+ $this->resources = $ch;
+ if ($code == 200) {
+ return explode(PHP_EOL, $result);
+ }
+ return false;
+ }
+}
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+$card_num = 54;//牌数
+var_dump(washCard($card_num));
+new PokerGames();
diff --git a/src/Other/Prim.php b/src/Other/Prim.php
new file mode 100644
index 0000000..0640ae9
--- /dev/null
+++ b/src/Other/Prim.php
@@ -0,0 +1,78 @@
+lowcost[$i] = $graph[0][$i];
+ $mst[$i] = 0;
+ }
+ for ($i = 1; $i < $n; $i++) {
+ $min = 65535;
+ $minid = 0;
+ for ($j = 1; $j < $n; $j++) {
+ if ($this->lowcost[$j] < $min && $this->lowcost[$j] != 0) {
+ $min = $this->lowcost[$j];
+ $minid = $j;
+ }
+ }
+ echo '';
+ print_r($this->c[$mst[$minid]] ."到" . $this->c[$minid] . " 权值：" . $min);
+ echo '
';
+
+ $sum += $min;
+ $this->lowcost[$minid] = 0;
+
+ for ($j = 1; $j < $n; $j++) {
+ if ($graph[$minid][$j] < $this->lowcost[$j]) {
+ $this->lowcost[$j] = $graph[$minid][$j];
+ $mst[$j] = $minid;
+ }
+ }
+ }
+ print_r("sum:" . $sum);
+ }
+
+ public function main()
+ {
+ $map = [
+ [0, 10, 65535, 65535, 65535, 11, 65535, 65535, 65535],
+ [10, 0, 18, 65535, 65535, 65535, 16, 65535, 12],
+ [65535, 65535, 0, 22, 65535, 65535, 65535, 65535, 8],
+ [65535, 65535, 22, 0, 20, 65535, 65535, 16, 21],
+ [65535, 65535, 65535, 20, 0, 26, 65535, 7, 65535],
+ [11, 65535, 65535, 65535, 26, 0, 17, 65535, 65535],
+ [65535, 16, 65535, 65535, 65535, 17, 0, 19, 65535],
+ [65535, 65535, 65535, 16, 7, 65535, 19, 0, 65535],
+ [65535, 12, 8, 21, 65535, 65535, 65535, 65535, 0]
+ ];
+ $this->prim_main($map, count($map));
+ }
+}
+
+$obj = new Prim();
+$obj->main();
diff --git a/src/Other/Rectangle.php b/src/Other/Rectangle.php
new file mode 100644
index 0000000..725a951
--- /dev/null
+++ b/src/Other/Rectangle.php
@@ -0,0 +1,88 @@
+$value) {
+ $x = abs($value[0]-$one[0]);
+ $y = abs($value[1]-$one[1]);
+ $data[$key] = sqrt(pow($x,2)+pow($y,2));
+ }
+
+ asort($data);
+ $keys = array_keys($data);
+ $maxKey = array_pop($keys);//对焦点
+ $length0 = $data[$maxKey];//对角线长度
+
+ //左右两点 key
+ $left = $keys[0];
+ $right = $keys[1];
+
+ //算第二条对角线长度
+ $x = abs($array[$left][0]-$array[$right][0]);
+ $y = abs($array[$left][1]-$array[$right][1]);
+ $length = sqrt(pow($x,2)+pow($y,2));
+
+ if(!floatEq($length,$length0)) {
+ return false;
+ }
+
+ //算直角
+ $vertical = sqrt(pow($data[$left],2)+pow($data[$right],2));
+
+ if(!floatEq($length,$vertical)) {
+ return false;
+ }
+
+ return true;
+
+}
+
+var_dump(rectangle([0,0],[0,1],[1,1],[1,0])); //true
+var_dump(rectangle([1,2],[0,1],[1,1],[1,0])); //false
+
+/**
+ * 判断两个浮点数是不是相等
+ *
+ * @param $a float
+ * @param $b float
+ * @return bool
+ */
+function floatEq($floatNumber1,$floatNumber2)
+{
+ if(!$floatNumber1 || !$floatNumber2) {
+ return false;
+ }
+ //精度
+ $epsilon = 0.00001;
+
+ if(abs($floatNumber1-$floatNumber2) < $epsilon) {
+ return true;
+ }
+ return false;
+}
diff --git a/src/Other/RotateSort.php b/src/Other/RotateSort.php
new file mode 100644
index 0000000..2fefd3c
--- /dev/null
+++ b/src/Other/RotateSort.php
@@ -0,0 +1,166 @@
+ |
+ * | Date: 2019/10/11 |
+ * | Time: 下午2:56 |
+ * ----------------------------------------
+ * | _____ ______ _ _ |
+ * | | __ \| ____(_) | | |
+ * | | |__) | |__ _ _ __ __ _| | |
+ * | | ___/| __| | | '_ \ / _` | | |
+ * | | | | | | | | | | (_| | | |
+ * | |_| |_| |_|_| |_|\__,_|_| |
+ * ----------------------------------------
+ * 说明: 面试遇到一个写一个函数 让输出效果 如风车一样旋转 如下
+ * foo(4) 逆时针
+ * 16,15,14,13
+ * 5, 4, 3, 12
+ * 6, 1, 2, 11
+ * 7, 8, 9, 10
+ * foo(4) 顺顺时针
+ * 7, 8, 9, 10
+ * 6, 1, 2, 11
+ * 5, 4, 3, 12
+ * 16,15, 14,13
+ *
+ */
+
+ $num = 4;
+ $arr = foo($num);
+ for ($i = 0; $i < $num; $i++) {
+ echo implode(',', $arr[$i])."
";
+ }
+
+ /**
+ * @param $num
+ * @param int $direction 方向 1 为 顺时针旋转 2 为逆时针旋转
+ * @return mixed
+ */
+ function foo($num, $direction = 1)
+ {
+ //填充map
+ $data = new stdClass();
+ $data->x = 1;
+ if ($direction == 1) {
+ $data->y = $num;
+ } elseif ($direction == 2) {
+ $data->y = 1;
+ }
+ $data->num = $num;
+ $data->len = $num * $num;
+ $data->tmp_data = [];
+ $data->rate = 1;//方向
+ $data->struct = create_struct($num);
+ for ($i = $data->len; $i >= 1; $i--) {
+ $data->i = $i;
+ $key = change_key($data, $direction);
+ $data->tmp_data[$key] = $i;
+ unset($data->struct[$key]);
+ }
+
+ //根据y坐标分组
+ $data->struct = create_struct($num);
+ foreach ($data->tmp_data as $key => $value) {
+ $data->struct[$key] = $value;
+ }
+ for ($i = 1; $i <= $data->num; $i++) {
+ $start = ($i - 1) * $data->num;
+ $end = $data->num;
+ $slice = array_slice($data->struct, $start, $end);
+ $data->slice[] = $slice;
+ }
+
+ return $data->slice;
+ }
+
+ function create_struct($num)
+ {
+ $struct = [];
+ for ($i = 1; $i <= $num; $i++) {
+ //嵌套
+ for ($m = 1; $m <= $num; $m++) {
+ $key = $m.','.$i;
+ $struct[$key] = '';
+ }
+ }
+
+ return $struct;
+ }
+
+ function change_key($data, $direction)
+ {
+ $key = $data->x.','.$data->y;
+ if (isset($data->struct[$key])) {
+ return $key;
+ }
+ switch ($data->rate) {
+ // LEFT 方向
+ case 1:
+ $data->tmp_x = $data->x + 1;
+ $key = $data->tmp_x.','.$data->y;
+ if (isset($data->struct[$key])) {
+ $data->x = $data->tmp_x;
+
+ return $key;
+ } else {
+ if ($direction = 1) {
+ $data->rate = 4;
+ } elseif ($direction = 2) {
+ $data->rate = 2;
+ }
+ }
+ break;
+ // DOWN 方向
+ case 2:
+ $data->tmp_y = $data->y + 1;
+ $key = $data->x.','.$data->tmp_y;
+ if (isset($data->struct[$key])) {
+ $data->y = $data->tmp_y;
+
+ return $key;
+ } else {
+ if ($direction = 1) {
+ $data->rate = 1;
+ } elseif ($direction = 2) {
+ $data->rate = 3;
+ }
+ }
+ break;
+ // RIGHT 方向
+ case 3:
+ $data->tmp_x = $data->x - 1;
+ $key = $data->tmp_x.','.$data->y;
+ if (isset($data->struct[$key])) {
+ $data->x = $data->tmp_x;
+
+ return $key;
+ } else {
+ if ($direction = 1) {
+ $data->rate = 2;
+ } elseif ($direction = 2) {
+ $data->rate = 4;
+ }
+ }
+ break;
+ // UP 方向
+ case 4:
+ $data->tmp_y = $data->y - 1;
+ $key = $data->x.','.$data->tmp_y;
+ if (isset($data->struct[$key])) {
+ $data->y = $data->tmp_y;
+
+ return $key;
+ } else {
+ if ($direction = 1) {
+ $data->rate = 3;
+ } elseif ($direction = 2) {
+ $data->rate = 1;
+ }
+ }
+ break;
+ }
+
+ return change_key($data, $direction);
+ }
\ No newline at end of file
diff --git a/src/Other/RotationSort.php b/src/Other/RotationSort.php
new file mode 100644
index 0000000..48d538a
--- /dev/null
+++ b/src/Other/RotationSort.php
@@ -0,0 +1,76 @@
+row = $row;
+ $this->col =$col;
+ $this->start = $start;
+ $this->print_matrix();
+ }
+
+ private function print_matrix()
+ {
+ //当前遍历层数
+ $small =$this->col < $this->row ?$this->col : $this->row;
+
+ $count = ceil($small / 2);
+
+ for($i=0; $i < $count; $i++)
+ {
+ $maxRight = $this->col -1 - $i; //右边最大坐标
+ $maxBottom = $this->row -1 - $i; //下面最大坐标
+
+ for($j=$i; $j<=$maxRight; $j++)
+ {
+ $this->res[$i][$j] = $this->start++;
+ }
+ for($j=$i; $j<$maxBottom; $j++)
+ {
+ $this->res[$j+1][$maxRight] = $this->start++;
+ }
+ for($j=$maxRight-1;$j>=$i; $j--)
+ {
+ if(isset($this->res[$maxBottom][$j])) break;
+ $this->res[$maxBottom][$j] = $this->start++;
+ }
+ for($j=$maxBottom-1;$j>$i;$j--)
+ {
+ if(isset($this->res[$j][$i])) break;
+ $this->res[$j][$i] = $this->start++;
+ }
+ }
+ }
+
+ /**
+ * @return string
+ * 输出回旋形状
+ */
+ public function print_table()
+ {
+ $str = '';
+ for ($i = 0; $i < $this->row; $i++) {
+ $str .='';
+ for ($j = 0; $j < $this->col; $j++) {
+ $str .='| '.$this->res[$i][$j] . " | ";
+ }
+ $str .="
";
+ }
+ $str .='
';
+ return $str;
+ }
+}
+
+$obj = new RotationSort(7, 8);
+echo $obj->print_table();
\ No newline at end of file
diff --git a/src/Other/Solution.php b/src/Other/Solution.php
new file mode 100644
index 0000000..27aca0c
--- /dev/null
+++ b/src/Other/Solution.php
@@ -0,0 +1,63 @@
+grid = $grid;
+ $this->islandPerimeter();
+ }
+
+ public function islandPerimeter()
+ {
+ if (empty($this->grid) || empty($this->grid[0])) return 0;
+
+ foreach ($this->grid as $key => $val) {
+
+ foreach ($this->grid[0] as $k => $v) {
+ if ($this->grid[$key][$k] == 0) continue;
+ $this->result += 4;
+
+ if ($key > 0 && $this->grid[$key - 1][$k] == 1) {
+ $this->result -= 2;
+ }
+ if ($k > 0 && $this->grid[$key][$k - 1] == 1) {
+ $this->result -= 2;
+ }
+ }
+ }
+ }
+}
+
+$arr = [
+ [0,1,0,0],
+ [1,1,1,0],
+ [0,1,0,0],
+ [1,1,0,0]
+];
+
+$result = new Solution($arr);
+var_dump($result->result);
\ No newline at end of file
diff --git a/src/Other/Square.php b/src/Other/Square.php
new file mode 100644
index 0000000..0566953
--- /dev/null
+++ b/src/Other/Square.php
@@ -0,0 +1,43 @@
+point = $point;
+ }
+
+ public function check()
+ {
+ $result = [];
+ if (count($this->point) != 4) return false;
+ for ($i = 0; $i < 4; $i++) {
+ for ($j = $i + 1; $j < 4; $j++) {
+ $result[]=$this->_calculation($i,$j);
+ }
+ }
+ sort($result);
+ if ($result[0] == $result[1] && $result[4] == $result[5] && $result[4] > $result[1]) {
+ return true;
+ }
+ return false;
+
+ }
+
+ private function _calculation($i, $j)
+ {
+ return pow($this->point[$i][0] - $this->point[$j][0],2) + pow($this->point[$i][1] - $this->point[$j][1] ,2);
+ }
+}
+
+$obj = new Square([[0, 0], [1, 0], [1, 1], [0, 1]]);
+var_dump($obj->check());
diff --git a/src/Other/StealingApples.php b/src/Other/StealingApples.php
new file mode 100644
index 0000000..5d821a3
--- /dev/null
+++ b/src/Other/StealingApples.php
@@ -0,0 +1,81 @@
+
+ * @date 2017/8/26
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：
+ * -------------------------------------------------------------
+ * 有5个人偷了一堆苹果，准备在第二天分赃。
+ * 晚上，有一人遛出来，把所有苹果分成5份，但是多了一个，顺手把这个扔给树上的猴了，自己先拿1/5藏了。
+ * 没想到其他四人也都是这么想的，都如第一个人一样分成5份把多的那一个扔给了猴，偷走了1/5。
+ * 第二天，大家分赃，也是分成5份多一个扔给猴了。最后一人分了一份。
+ * 问：共有多少苹果？N 个人呢？
+ * -------------------------------------------------------------
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+$i = 1;
+while (true) {
+ if ($i % 5 == 1) {
+ //第一个人取五分之一，还剩$t
+ $t = $i - round($i / 5) - 1;
+ if ($t % 5 == 1) {
+ //第二个人取五分之一，还剩$r
+ $r = $t - round($t / 5) - 1;
+ if ($r % 5 == 1) {
+ //第三个人取五分之一，还剩$s
+ $s = $r - round($r / 5) - 1;
+ if ($s % 5 == 1) {
+ //第四个人取五分之一，还剩$x
+ $x = $s - round($s / 5) - 1;
+ if ($x % 5 == 1) {
+ //第五个人取五分之一，还剩$y
+ $y = $x - round($x / 5) - 1;
+ if ($y % 5 == 1) {
+ echo $i;
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ $i++;
+}
+
+// +----------------------------------------------------------------------
+// | 方法二
+// +----------------------------------------------------------------------
+/**
+ * @author Openset
+ * @link https://github.com/openset
+ * @date 2017/9/7
+ * @param int $n N个人
+ * @param int $r 共有多少苹果
+ */
+for ($r = 1, $n = 5; ; $r++) {
+ $t = $r;
+ for ($i = 0; $i <= $n; $i++) {
+ if ($t % $n == 1) {
+ $t = $t - round($t / $n) - 1;
+ } else {
+ continue 2;
+ }
+ }
+ echo $r;
+ break;
+}
+
+//15621
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
diff --git a/src/Query/BFSQuery.php b/src/Query/BFSQuery.php
new file mode 100644
index 0000000..cd7c142
--- /dev/null
+++ b/src/Query/BFSQuery.php
@@ -0,0 +1,174 @@
+
+ * @date 2017/6/17
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析： BFS并不使用经验法则算法。从算法的观点，所有因为展开节点而得到的子节点都会被加进一个先进先出的队列中
+ * 时间复杂度：O(n)
+ * -------------------------------------------------------------
+ * 宽度优先搜索算法（又称广度优先搜索）是最简便的图的搜索算法之一，这一算法也是很多重要的图的算法的原型。
+ * Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和宽度优先搜索类似的思想。
+ * 其别名又叫BFS，属于一种盲目搜寻法，目的是系统地展开并检查图中的所有节点，以找寻结果。
+ * 换句话说，它并不考虑结果的可能位置，彻底地搜索整张图，直到找到结果为止。
+ */
+class BFSQuery
+{
+ /**
+ * @var array 关系网络
+ */
+ protected $relationship;
+ /**
+ * @var \SplQueue 处理队列
+ */
+ protected $queue;
+
+ /**
+ * @var string 搜索结果
+ */
+ protected $target;
+
+ /**
+ * BFSQuery constructor.
+ *
+ * @param array $relationship
+ * @param string $target
+ */
+ public function __construct(array $relationship, $target)
+ {
+
+ $this->relationship = $relationship;
+ $this->queue = new SplQueue();
+ $this->target = $target;
+ $this->generator($this->relationship);
+ }
+
+ /**
+ * 开始入列
+ *
+ * @param array $relation
+ * @return \Generator
+ */
+ public function generator($relation)
+ {
+ foreach ($relation as $value) {
+ $this->schedule($value);
+ }
+ }
+
+
+ /**
+ * 队列入队
+ *
+ * @param $item
+ * @return int
+ */
+ public function schedule($item)
+ {
+ $this->queue->enqueue($item);
+ }
+
+ /**
+ * 队列中查找符合条件
+ *
+ * @return string
+ */
+ public function run()
+ {
+ $result = $this->target . '没有人有~!';
+ while (!$this->queue->isEmpty()) {
+ // 出队列
+ $item = $this->queue->dequeue();
+ if (!isset($item['friend'])) {
+ continue;
+ }
+ if (!isset($item['fruit'])) {
+ continue;
+ }
+ $totalFruit = count($item['fruit']);
+ $mark = 0;
+ while ($totalFruit > $mark) {
+ if ($item['fruit'][$mark] === $this->target) {
+ $result = '找到了～！';
+ break 2;
+ }
+ $mark++;
+ }
+ $this->generator($item['friend']);
+ }
+ return $result;
+ }
+}
+
+
+// +--------------------------------------------------------------------------
+// | 方案测试
+// +--------------------------------------------------------------------------
+// 你现在需要一个 `mango` ,所以你需要在你的朋友圈里搜刮，你可以先从Jack 与 tom 身上找，
+// 然后再从他们的朋友身上找，然后再从他们朋友的朋友哪里找
+
+$me = array (
+ 'jack' => array (
+ 'fruit' => array ('apple', 'banana', 'dragon'),
+ 'friend' => array (
+ 'lucy' => array (
+ 'fruit' => array ('bear', 'watermelon'),
+ 'friend' => array (
+ 'marco' => array (
+ 'fruit' => array ('mango', 'cherry'), // Mango 在这儿
+ 'friend' => array (
+ '...',
+ )
+ ),
+ ),
+ ),
+ 'bob' => array (
+ 'fruit' => array ('orange', 'mangosteen', 'peach'),
+ 'friend' => array (
+ '',
+ ),
+ ),
+
+ ),
+ ),
+ 'tom' => array (
+ 'fruit' => array (
+ 'apple',
+ 'banana',
+ ),
+ 'friend' => array (
+ 'lucy' => array (
+ 'fruit' => array (),
+ 'friend' => array (
+ 'lucy' => array (
+ 'fruit' => array ('bear', 'watermelon'),
+ 'friend' => array (
+ 'marco' => array (
+ 'fruit' => array ('mango', 'cherry'), // Mango 在这儿也有
+ 'friend' => array (
+ '...',
+ )
+ ),
+ ),
+ ),
+ ),
+ ),
+ 'bob' => array (
+ 'fruit' => array ('apple', 'peach'),
+ 'friend' => array (
+ 'marco' => array (
+ 'fruit' => array ('mango', 'cherry'), // Mango 在这儿也有
+ 'friend' => array (
+ 'Marco 有无数多的盆友...',
+ )
+ ),
+ )
+ ),
+ ),
+ )
+);
+
+echo (new BFSQuery($me, 'mango'))->run();
\ No newline at end of file
diff --git a/src/Query/BinaryQuery.php b/src/Query/BinaryQuery.php
new file mode 100644
index 0000000..167da6b
--- /dev/null
+++ b/src/Query/BinaryQuery.php
@@ -0,0 +1,101 @@
+
+ * @date 2017/6/17
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：数组中间的值floor((low+top)/2)
+ * -------------------------------------------------------------
+ * 先取数组中间的值floor((low+top)/2)然后通过与所需查找的数字进行比较，
+ * 若比中间值大则将首值替换为中间位置下一个位置，继续第一步的操作；
+ * 若比中间值小，则将尾值替换为中间位置上一个位置，继续第一步操作
+ * 重复第二步操作直至找出目标数字
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+/**
+ * 非递归版 二分查找
+ *
+ * @param array $container
+ * @param $search
+ * @return int|string
+ */
+function BinaryQuery(array $container, $search)
+{
+ $top = count($container);
+ $low = 0;
+ while ($low <= $top) {
+ $mid = intval(floor(($low + $top) / 2));
+ if (!isset($container[$mid])) {
+ return '没找着哦';
+ }
+ if ($container[$mid] == $search) {
+ return $mid;
+ }
+ $container[$mid] < $search && $low = $mid + 1;
+ $container[$mid] > $search && $top = $mid - 1;
+ }
+}
+
+
+/**
+ * 递归版 二分查找
+ *
+ * @param array $container
+ * @param $search
+ * @param int $low
+ * @param string $top
+ * @return int|string
+ */
+function BinaryQueryRecursive(array $container, $search, $low = 0, $top = 'default')
+{
+ $top === 'default' && $top = count($container);
+ if ($low <= $top) {
+ $mid = intval(floor($low + $top) / 2);
+ if (!isset($container[$mid])) {
+ return '没找着哦';
+ }
+ if ($container[$mid] == $search) {
+ return $mid;
+ }
+ if ($container[$mid] < $search) {
+ return BinaryQueryRecursive($container, $search, $mid + 1, $top);
+ } else {
+ return BinaryQueryRecursive($container, $search, $low, $mid - 1);
+ }
+ }
+}
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+var_dump(BinaryQuery([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 9));
+/*
+ * double(8)
+ */
+var_dump(BinaryQueryRecursive([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 9));
+/*
+array(7) {
+ [0] =>
+ int(3)
+ [1] =>
+ int(4)
+ [2] =>
+ int(5)
+ [3] =>
+ int(6)
+ [4] =>
+ int(7)
+ [5] =>
+ int(8)
+ [6] =>
+ int(9)
+}
+*/
diff --git a/src/Query/DijkstraQuery.php b/src/Query/DijkstraQuery.php
new file mode 100644
index 0000000..cf54ce9
--- /dev/null
+++ b/src/Query/DijkstraQuery.php
@@ -0,0 +1,134 @@
+
+ * @date 2017/8/23
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：单源最短路径问题
+ * -------------------------------------------------------------
+ * Dijkstra 算法一般的表述通常有两种方式，一种用永久和临时标号方式，一种是用OPEN, CLOSE表的方式，
+ * 这里均采用永久和临时标号的方式。注意该算法要求图中不存在负权边。
+ * 因此，在包含负边全的图中要找出最短路径，可以使用另一种算法 -- 贝克曼-福德算法
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式
+// +--------------------------------------------------------------------------
+
+/**
+ * DijkstraQuery
+ *
+ * @uses PHPStorm
+ * @version 1.0
+ * @author Pu ShaoWei
+ */
+class DijkstraQuery
+{
+ /**
+ * @var array
+ */
+ protected $graph;
+ /**
+ * @var array
+ */
+ protected $processed;
+ /**
+ * @var int
+ */
+ protected $infinity;
+ /**
+ * @var string
+ */
+ protected $start;
+ /**
+ * @var string
+ */
+ protected $end;
+
+ /**
+ * DijkstraQuery constructor.
+ *
+ * @param array $graph
+ * @param $start
+ * @param $end
+ */
+ public function __construct(array $graph, $start, $end)
+ {
+ $this->graph = $graph;
+ $this->start = $start;
+ $this->end = $end;
+ $this->processed = array ();
+ $this->infinity = mt_getrandmax();
+ }
+
+ /**
+ * 最短路径
+ *
+ * @return string
+ */
+ public function calculate()
+ {
+ $costs = $this->graph[$this->start];
+ $costs[$this->end] = $this->infinity;
+ $node = $this->findLowestCostNode($costs);
+
+ while (null !== $node) {
+ $cost = $costs[$node];
+ $neighbors = $this->graph[$node] ?? array ();
+ foreach ($neighbors as $neighbor => $distance) {
+ $newCost = $cost + $distance;
+ if ($costs[$neighbor] > $newCost) {
+ $costs[$neighbor] = $newCost;
+ }
+ }
+ array_push($this->processed, $node);
+ $node = $this->findLowestCostNode($costs);
+ }
+
+ return 'The shortest distance for：' . $costs[$this->end];
+ }
+
+ /**
+ * findLowestCostNode
+ *
+ * @param $costs
+ * @return null
+ */
+ protected function findLowestCostNode($costs)
+ {
+ $lowestCost = $this->infinity;
+ $lowestCostNode = null;
+ foreach ($costs as $node => $cost) {
+ if ($cost < $lowestCost && !in_array($node, $this->processed)) {
+ $lowestCost = $cost;
+ $lowestCostNode = $node;
+ }
+ }
+ return $lowestCostNode;
+ }
+}
+
+// +--------------------------------------------------------------------------
+// | 验证 me --> claire
+// +--------------------------------------------------------------------------
+// ∞
+$graph = array (
+ 'me' => array (
+ 'alice' => 6,
+ 'bob' => 2,
+ ),
+ 'alice' => array (
+ 'claire' => 1,
+ ),
+ 'bob' => array (
+ 'alice' => 3,
+ 'claire' => 5,
+ ),
+ 'claire' => array (// 没有任何邻居
+
+ ),
+);
+echo (new DijkstraQuery($graph, 'me', 'claire'))->calculate();
\ No newline at end of file
diff --git a/src/Query/FibonacciQuery.php b/src/Query/FibonacciQuery.php
new file mode 100644
index 0000000..1c57fc2
--- /dev/null
+++ b/src/Query/FibonacciQuery.php
@@ -0,0 +1,84 @@
+
+ * @date 2017/8/23
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：斐波那契查找 利用黄金分割原理
+ * -------------------------------------------------------------
+ * $num == $container[$mid],直接返回
+ * $num < $container[$mid],新范围是第 $low 个到 $mid-1 个，此时范围个数为 produced($key-1)-1 个
+ * $num > $container[$mid],新范围是第 $mid+1 个到 $high 个，此时范围个数为 produced($key-2)-1 个
+ */
+
+
+// +--------------------------------------------------------------------------
+// | 解题方式
+// +--------------------------------------------------------------------------
+
+class FibonacciQuery
+{
+ /**
+ * FibonacciQuery constructor.
+ *
+ * @param array $container
+ * @param $num
+ */
+ public function __construct(array $container, $num)
+ {
+ $count = count($container);
+ $lower = $key = $result = 0;
+ $high = $count - 1;
+ //计算$count位于斐波那契数列的位置
+ while ($count > ($this->produced($key) - 1)) {
+ $key++;
+ }
+ //将不满的数值补全，补的数值为数组的最后一位
+ for ($j = $count; $j < $this->produced($key) - 1; $j++) {
+ $container[$j] = $container[$count - 1];
+ }
+ //查找开始
+ while ($lower <= $high) {
+ //计算当前分隔的下标
+ $mid = $lower + $this->produced($key - 1) - 1;
+ if ($num < $container[$mid]) {
+ $high = $mid - 1;
+ $key -= 1; //斐波那契数列数列下标减一位
+ } else if ($num > $container[$mid]) {
+ $lower = $mid + 1;
+ $key -= 2; //斐波那契数列数列下标减两位
+ }
+ if ($mid <= $count - 1) {
+ $result = $mid;
+ break;
+ } else { //这里$mid大于$count-1说明是补全数值，返回$count-1
+ $result = $count - 1;
+ break;
+ }
+ }
+ var_dump($result);
+ }
+
+ /**
+ * 创建一个生产斐波那契数列
+ *
+ * @param $length
+ * @return int
+ */
+ public function produced($length)
+ {
+ if ($length < 2) {
+ return ($length == 0 ? 0 : 1);
+ }
+ return $this->produced($length - 1) + $this->produced($length - 2);
+ }
+}
+
+// +--------------------------------------------------------------------------
+// | 方案测试
+// +--------------------------------------------------------------------------
+
+new FibonacciQuery([4, 5, 7, 8, 9, 10, 8], 8);
\ No newline at end of file
diff --git a/src/Query/InsertQuery.php b/src/Query/InsertQuery.php
new file mode 100644
index 0000000..27c0800
--- /dev/null
+++ b/src/Query/InsertQuery.php
@@ -0,0 +1,62 @@
+
+ * @date 2017/8/25
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：对于数组长度比较大，关键字分布又是比较均匀的来说，插值查找的效率比折半查找的效率高
+ * -------------------------------------------------------------
+ * 它是二分查找的改进。
+ * 在英文词典里查找“apple”，你下意识里翻开词典是翻前面的书页还是后面的书页呢？如果再查“zoo”,你又会怎么查？
+ * 显然你不会从词典中间开始查起，而是有一定目的地往前或往后翻。
+ *
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+/**
+ * insertQuery
+ *
+ * @param array $container
+ * @param $num
+ * @return bool|float|int
+ */
+function insertQuery(array $container, $num)
+{
+ $count = count($container);
+ $lower = 0;
+ $high = $count - 1;
+
+ while ($lower <= $high) {
+ if ($container[ $lower ] == $num) {
+ return $lower;
+ }
+ if ($container[ $high ] == $num) {
+ return $high;
+ }
+
+ $left = intval($lower + $num - $container[ $lower ]);
+ $right = ($container[ $high ] - $container[ $lower ]) * ($high - $lower);
+
+ $middle = $left /$right;
+
+ if ($num < $container[ $middle ]) {
+ $high = $middle - 1;
+ } else if ($num > $container[ $middle ]) {
+ $lower = $middle + 1;
+ } else {
+ return $middle;
+ }
+ }
+ return false;
+}
+
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+echo insertQuery([4, 5, 7, 8, 9, 10, 8], 8);
+// 6
\ No newline at end of file
diff --git a/src/Query/Kmp.php b/src/Query/Kmp.php
new file mode 100644
index 0000000..09238ae
--- /dev/null
+++ b/src/Query/Kmp.php
@@ -0,0 +1,157 @@
+
+ * @date 2018/1/11
+ * @license MIT
+ * -------------------------------------------------------------
+ * KMP算法是一种改进的字符串匹配算法
+ * KMP精要：KMP在进行朴素匹配时，如果发现不匹配字符时，通过对已经匹配的那部分字符串的最大前缀来快速找到下一个模式串需要匹配的位置。
+ * KMP对模式进行预处理时间复杂度O(m)，匹配时间复杂度O(n)，总的KMP时间复杂度为O(m+n)。
+ * 参考 字符串匹配的KMP算法 — 阮一峰
+ */
+
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+class KMP
+{
+ public $haystack;
+ public $needle;
+ private $_haystackLen;
+ private $_needleLen;
+ private $_matchTable;
+ private $_isMatch;
+
+ //构造函数
+ function __construct($haystack, $needle)
+ {
+ $this->haystack = $haystack;
+ $this->needle = $needle;
+ //初始化一些参数
+ $this->_haystackLen = $this->getLen($this->haystack);
+ $this->_needleLen = $this->getLen($this->needle);
+ $this->_matchTable = $this->getMatchTable();
+ $this->_isMatch = false;
+ }
+
+
+ //类似strpos函数功能
+ public function strpos()
+ {
+ //haystack
+ $haystackIdx = $matchNum = 0;
+ while ($haystackIdx <= $this->_haystackLen - $this->_needleLen) {
+ //needle
+ $needIdx = 0;
+ for (; $needIdx < $this->_needleLen; $needIdx++) {
+ if (strcmp($this->haystack[$haystackIdx], $this->needle[$needIdx]) <> 0) {
+ if ($matchNum > 0) {
+ $lastMatchValue = $this->getLastMatchValue($needIdx - 1);
+ $haystackIdx += $this->getStep($matchNum, $lastMatchValue);
+ $matchNum = 0;
+ } else {
+ $haystackIdx++;
+ }
+ break;
+ } else {
+ $haystackIdx++;
+ $matchNum++;
+ if ($matchNum == $this->_needleLen) {
+ $this->_isMatch = true;
+ break;
+ }
+ }
+ }
+ if ($this->_isMatch == true) {
+ break;
+ }
+ }
+ return $this->_isMatch ? $haystackIdx - $this->_needleLen : false;
+ }
+
+ //获取字符长度
+ private function getLen($str)
+ {
+ return mb_strlen($str, 'utf-8');
+ }
+
+ //获取部分匹配表
+ private function getMatchTable()
+ {
+ $matchTable = [];
+ for ($i = 0; $i < $this->_needleLen; $i++) {
+ $intersectLen = 0;
+ $nowStr = mb_substr($this->needle, 0, $i + 1, 'utf-8');
+ $preFixArr = $this->getPreFix($nowStr);
+ $sufFixArr = $this->getSufFix($nowStr);
+ if ($preFixArr && $sufFixArr) {
+ $intersectArr = array_intersect($preFixArr, $sufFixArr);
+ if (!empty($intersectArr)) {
+ $intersect = array_pop($intersectArr);
+ $intersectLen = mb_strlen($intersect, 'utf-8');
+ }
+ }
+ $matchTable[$i] = $intersectLen;
+ }
+ return $matchTable;
+ }
+
+ //获取前缀数组
+ private function getPreFix($str)
+ {
+ $outArr = [];
+ $strLen = $this->getLen($str);
+ if ($strLen > 1) {
+ for ($i = 1; $i < $strLen; $i++) {
+ $outArr[] = mb_substr($str, 0, $i, 'utf-8');
+ }
+ }
+ return $outArr;
+ }
+
+ //获取后缀数组
+ private function getSufFix($str)
+ {
+ $outArr = [];
+ $strLen = $this->getLen($str);
+ if ($strLen > 1) {
+ for ($i = 1; $i < $strLen; $i++) {
+ $outArr[] = mb_substr($str, $i, null, 'utf-8');
+ }
+ }
+ return $outArr;
+ }
+
+ //计算步长
+ private function getStep($matchNum, $lastMatchValue)
+ {
+ return $matchNum - $lastMatchValue;
+ }
+
+ //获取最后匹配值
+ private function getLastMatchValue($index)
+ {
+ return isset($this->_matchTable[$index]) ? $this->_matchTable[$index] : 0;
+ }
+
+}
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+$str = 'a b a c a a b a c a b a c a b a a b b';
+$subStr = 'a b a c a b';
+$kmp = new KMP($str, $subStr);
+var_dump($kmp->strpos());
+$kmp->haystack = 'pull requests';
+$kmp->needle = 'sts';
+var_dump($kmp->strpos());
+$kmp->haystack = 'i love you';
+$kmp->needle = 'hate';
+var_dump($kmp->strpos());
\ No newline at end of file
diff --git a/src/Query/QuickQuery.php b/src/Query/QuickQuery.php
new file mode 100644
index 0000000..05e3fcf
--- /dev/null
+++ b/src/Query/QuickQuery.php
@@ -0,0 +1,46 @@
+
+ * @date 2017/8/23
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：数组中间的值floor((low+top)/2)
+ * -------------------------------------------------------------
+ * 重复第二步操作直至找出目标数字
+ */
+
+/**
+ * QuickQuery
+ *
+ * @param $array
+ * @param $k
+ * @param int $low
+ * @param int $high
+ * @return int
+ */
+function QuickQuery($array, $k, $low = 0, $high = 0)
+{
+ //判断是否为第一次调用
+ if (count($array) != 0 and $high == 0) {
+ $high = count($array);
+ }
+ //如果还存在剩余的数组元素
+ if ($low <= $high) {
+ //取$low和$high的中间值
+ $mid = intval(($low + $high) / 2);
+ //如果找到则返回
+ if ($array[$mid] == $k) {
+ return $mid;
+ } else if ($k < $array[$mid]) {//如果没有找到，则继续查找
+ return QuickQuery($array, $k, $low, $mid - 1);
+ } else {
+ return QuickQuery($array, $k, $mid + 1, $high);
+ }
+ }
+ return -1;
+}
+
+echo QuickQuery([4, 5, 7, 8, 9, 10, 8], 8);
\ No newline at end of file
diff --git a/package/Sort/BubbleSort.php b/src/Sort/BubbleSort.php
similarity index 54%
rename from package/Sort/BubbleSort.php
rename to src/Sort/BubbleSort.php
index 004503f..b93a0ca 100644
--- a/package/Sort/BubbleSort.php
+++ b/src/Sort/BubbleSort.php
@@ -1,9 +1,11 @@
* @date 2017/6/16
- * @license Mozilla
+ * @license MIT
* -------------------------------------------------------------
* 思路分析：就是像冒泡一样，每次从数组当中 冒一个最大的数出来。
* -------------------------------------------------------------
@@ -11,27 +13,39 @@
* 由底至上的把较少的气泡逐步地向上升，这样经过遍历一次后最小的气泡就会被上升到顶（下标为0）
* 然后再从底至上地这样升，循环直至十个气泡大小有序。
* 在冒泡排序中，最重要的思想是两两比较，将两者较少的升上去
+ *
*/
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
/**
- * @param array $container
+ * BubbleSort
+ *
+ * @param array $container
* @return array
*/
-function BubbleSort( array $container ) {
+function BubbleSort(array $container)
+{
$count = count($container);
- for ( $j = 1; $j < $count; $j++ ) {
- for ( $i = 0; $i < $count - $j; $i++ ) {
- if ( $container[$i] > $container[$i + 1] ) {
+ for ($j = 1; $j < $count; $j++) {
+ for ($i = 0; $i < $count - $j; $i++) {
+ if ($container[$i] > $container[$i + 1]) {
$temp = $container[$i];
- $container[$i] = $container[$i+1];
- $container[$i+1] = $temp;
+ $container[$i] = $container[$i + 1];
+ $container[$i + 1] = $temp;
}
}
}
return $container;
}
-var_dump( BubbleSort([4,21,41,2,53,1,213,31,21,423]) );
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+var_dump(BubbleSort([4, 21, 41, 2, 53, 1, 213, 31, 21, 423]));
/*
array(10) {
diff --git a/src/Sort/ChineseTextNumberSort.php b/src/Sort/ChineseTextNumberSort.php
new file mode 100644
index 0000000..e795395
--- /dev/null
+++ b/src/Sort/ChineseTextNumberSort.php
@@ -0,0 +1,219 @@
+ $matchNum) {
+ if ($matchNum === '十') {
+ if ($plane === 0) {
+ $currentNum += 10;
+ continue;
+ }
+ if ($plane === 1) {
+ $index = array_search($structure[0][0], $mapping);
+ $currentNum -= $index;
+ $currentNum += $index * 10;
+ continue;
+ }
+ }
+ $index = array_search($matchNum, $mapping);
+ $currentNum += $index;
+ }
+ return $currentNum;
+ }
+
+ /**
+ * isChinese
+ *
+ * @param $text
+ * @return bool
+ */
+ public function isCompletelyChinese($text)
+ {
+ return boolval(preg_match('/^[\x7f-\xff]+$/', $text));
+ }
+
+ /**
+ * regularModel
+ *
+ * @param $regularModel
+ * @param $text
+ * @return bool
+ */
+ public function regularModel($regularModel, $text)
+ {
+ return boolval(preg_match($regularModel, $text));
+ }
+
+ /**
+ * extractModel
+ *
+ * @param $regularModel
+ * @param $text
+ * @return string
+ * @throws \Exception
+ */
+ public function extractModel($regularModel, $text)
+ {
+ $result = '';
+ if (preg_match($regularModel, $text, $result)) {
+ return trim($result[$this->modelMappingIndex($regularModel)]);
+ }
+ throw new Exception('The matching error');
+ }
+
+ /**
+ * modelMappingIndex
+ *
+ * @param $regularModel
+ * @return int|mixed
+ */
+ protected function modelMappingIndex($regularModel)
+ {
+ return array (
+ static::MODEL_REGULAR_A => 1,
+ static::MODEL_REGULAR_B => 0,
+ static::MODEL_REGULAR_C => 0,
+ static::MODEL_REGULAR_D => 1,
+ static::MODEL_REGULAR_E => 1,
+ static::MODEL_REGULAR_F => 1,
+ static::MODEL_REGULAR_G => 1,
+ static::MODEL_REGULAR_H => 1,
+ static::MODEL_REGULAR_I => 2
+ )[$regularModel] ?? 1;
+ }
+
+ /**
+ * chineseConversionNum
+ *
+ * @param $text
+ * @return mixed
+ */
+ public function chineseConversionNum($text)
+ {
+ if ($this->regularModel(static::CHINESE_DIGITAL_MATCHING, $text)) {
+ $mapping = array ('零', '一', '二', '三', '四', '五', '六', '七', '八', '九', '十');
+ return array_search($text, $mapping);
+ }
+ return ltrim($text, 0);
+ }
+
+ /**
+ * getAllModelRegular
+ *
+ * @return array
+ * @throws \ReflectionException
+ */
+ public function getAllModelRegular()
+ {
+ $constants = (new \ReflectionClass(__CLASS__))->getConstants();
+ $collection = array ();
+ foreach ($constants as $key => $value) {
+ if (strpos($key, 'MODEL_REGULAR_') !== false) {
+ $collection[$key] = $value;
+ }
+ }
+ return $collection;
+ }
+
+ /**
+ * modelAnalysis
+ *
+ * @param $text
+ * @return int|string
+ * @throws \ReflectionException
+ */
+ public function modelAnalysis($text)
+ {
+ foreach ($this->getAllModelRegular() as $item) {
+ if ($this->regularModel($item, $text)) {
+ return $item;
+ }
+ }
+ throw new Exception('Model Analysis of the failure !');
+ }
+
+ /**
+ * textAnalysis
+ *
+ * @param $text
+ * @return int
+ */
+ public function textAnalysis($text)
+ {
+ try {
+ return (int)$this->chineseConversionNum($this->extractModel(
+ $this->modelAnalysis($text),
+ $text
+ )
+ );
+ } catch (Exception $e) {
+ return 0;
+ }
+ }
+
+ /**
+ * chineseTextList
+ *
+ * @param array $list
+ * @return array
+ */
+ public function chineseTextListSorter(array $list)
+ {
+ $container = $generate = array ();
+ foreach ($list as $item) {
+ $container[] = $this->textAnalysis($item);
+ }
+ if (count($container) !== count($list)) {
+ return $list;
+ }
+ uksort($list, function ($left, $right) use ($container) {
+ if ($left == $right) {
+ return 0;
+ }
+ return $container[$left] < $container[$right] ? -1 : 1;
+ });
+ return array_values($list);
+ }
+}
\ No newline at end of file
diff --git a/src/Sort/HeapSort.php b/src/Sort/HeapSort.php
new file mode 100644
index 0000000..acafa03
--- /dev/null
+++ b/src/Sort/HeapSort.php
@@ -0,0 +1,123 @@
+
+ * @date 2017/10/9
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：堆排序利用了大根堆堆顶记录的关键字最大（或最小）这一特征
+ * -------------------------------------------------------------
+ * 堆排序(HeapSort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。
+ * 可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。
+ * 大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，
+ * 因为根据大根堆的要求可知，最大的值一定在堆顶。
+ */
+
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+
+class HeapSort
+{
+ /**
+ * @var int
+ */
+ protected $count;
+
+ /**
+ * @var array
+ */
+ protected $data;
+
+ /**
+ * HeapSort constructor.
+ *
+ * @param array $data
+ */
+ public function __construct(array $data)
+ {
+ $this->count = count($data);
+ $this->data = $data;
+ }
+
+ /**
+ * Action
+ *
+ * @return array
+ */
+ public function run()
+ {
+ $this->createHeap();
+ while ($this->count > 0) {
+ /* 这是一个大顶堆 , 所以堆顶的节点必须是最大的
+ 根据此特点 , 每次都将堆顶数据移到最后一位
+ 然后对剩余数据节点再次建造堆就可以 */
+ $this->swap($this->data[0], $this->data[--$this->count]);
+ $this->buildHeap($this->data, 0, $this->count);
+ }
+ return $this->data;
+ }
+
+ /**
+ * 创建一个堆
+ */
+ public function createHeap()
+ {
+ $i = floor($this->count / 2) + 1;
+ while ($i--) {
+ $this->buildHeap($this->data, $i, $this->count);
+ }
+ }
+
+ /**
+ * 从 数组 的第 $i 个节点开始至 数组长度为0 结束 , 递归的将其 ( 包括其子节点 ) 转化为一个小顶堆
+ *
+ * @param $data
+ * @param $i
+ * @param $count
+ */
+ public function buildHeap(array &$data, $i, $count)
+ {
+ if (false === $i < $count) {
+ return;
+ }
+ // 获取左 / 右节点
+ $right = ($left = 2 * $i + 1) + 1;
+ $max = $i;
+ // 如果左子节点大于当前节点 , 那么记录左节点键名
+ if ($left < $count && $data[$i] < $data[$left]) {
+ $max = $left;
+ }
+ // 如果右节点大于刚刚记录的 $max , 那么再次交换
+ if ($right < $count && $data[$max] < $data[$right]) {
+ $max = $right;
+ }
+ if ($max !== $i && $max < $count) {
+ $this->swap($data[$i], $data[$max]);
+ $this->buildHeap($data, $max, $count);
+ }
+ }
+
+ /**
+ * 交换空间
+ *
+ * @param $left
+ * @param $right
+ */
+ public function swap(&$left, &$right)
+ {
+ list($left, $right) = array ($right, $left);
+ }
+}
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+$array = array (4, 21, 41, 2, 53, 1, 213, 31, 21, 423, 56);
+$result = (new HeapSort($array))->run();
+var_dump($result);
diff --git a/src/Sort/InsertSort.php b/src/Sort/InsertSort.php
new file mode 100644
index 0000000..e0a3489
--- /dev/null
+++ b/src/Sort/InsertSort.php
@@ -0,0 +1,63 @@
+
+ * @date 2017/6/17
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。
+ * -------------------------------------------------------------
+ *
+ * 算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。
+ * 插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，
+ * 但将最后一个元素除外（让数组多一个空间才有插入的位置），而第二部分就只包含这一个元素（即待插入元素）。
+ * 在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。
+ *
+ */
+
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+/**
+ * InsertSort
+ *
+ * @param array $container
+ * @return array
+ */
+function InsertSort(array $container)
+{
+ $count = count($container);
+ for ($i = 1; $i < $count; $i++){
+ $temp = $container[$i];
+ $j = $i - 1;
+ // Init
+ while($j >= 0 && $container[$j] > $temp){
+ $container[$j+1] = $container[$j];
+ $j--;
+ }
+ if($i != $j+1)
+ $container[$j+1] = $temp;
+ }
+ return $container;
+}
+
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+var_dump(InsertSort([3, 12, 42, 1, 24, 5, 346, 7]));
+
+/*
+array (size=8)
+ 0 => int 1
+ 1 => int 3
+ 2 => int 5
+ 3 => int 7
+ 4 => int 12
+ 5 => int 24
+ 6 => int 42
+ 7 => int 346
+ */
diff --git a/package/Sort/MergeSort.php b/src/Sort/MergeSort.php
similarity index 75%
rename from package/Sort/MergeSort.php
rename to src/Sort/MergeSort.php
index 7bb75cd..86bf647 100644
--- a/package/Sort/MergeSort.php
+++ b/src/Sort/MergeSort.php
@@ -1,12 +1,14 @@
* @date 2017/7/22
- * @license Mozilla
+ * @license MIT
* -------------------------------------------------------------
* 思路分析：
+ * 大O表示： O(n log n)
* -------------------------------------------------------------
* 比较a[i]和b[j]的大小，若a[i]≤b[j]，则将第一个有序表中的元素a[i]复制到r[k]中，
* 并令i和k分别加上1；否则将第二个有序表中的元素b[j]复制到r[k]中，并令j和k分别加上1，
@@ -14,6 +16,12 @@
* 归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，
* 最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]
*/
+
+
+// +--------------------------------------------------------------------------
+// | 解题方式
+// +--------------------------------------------------------------------------
+
class MergeSort
{
/**
@@ -49,8 +57,6 @@ public function mSort(&$arr, $left, $right)
$this->mergeArray($arr, $left, $center, $right);
}
}
- // 4, 7, 6, 3, 9, 5, 8
- //
/**
* 将两个有序数组合并成一个有序数组
@@ -62,12 +68,13 @@ public function mSort(&$arr, $left, $right)
*/
public function mergeArray(&$arr, $left, $center, $right)
{
+ echo '| ' . $left . ' - ' . $center . ' - ' . $right . ' - ' . implode(',', $arr) . PHP_EOL;
//设置两个起始位置标记
- $a_i = $left;
- $b_i = $center + 1;
+ $a_i = $left;
+ $b_i = $center + 1;
$temp = [];
- while ($a_i <= $center && $b_i <= $right){
+ while ($a_i <= $center && $b_i <= $right) {
//当数组A和数组B都没有越界时
if ($arr[ $a_i ] < $arr[ $b_i ]) {
$temp[] = $arr[ $a_i++ ];
@@ -76,22 +83,53 @@ public function mergeArray(&$arr, $left, $center, $right)
}
}
//判断 数组A内的元素是否都用完了，没有的话将其全部插入到C数组内：
- while ($a_i <= $center){
+ while ($a_i <= $center) {
$temp[] = $arr[ $a_i++ ];
}
//判断 数组B内的元素是否都用完了，没有的话将其全部插入到C数组内：
- while ($b_i <= $right){
+ while ($b_i <= $right) {
$temp[] = $arr[ $b_i++ ];
}
//将$arrC内排序好的部分，写入到$arr内：
- for ($i = 0, $len = count($temp); $i < $len; $i++){
+ for ($i = 0, $len = count($temp); $i < $len; $i++) {
$arr[ $left + $i ] = $temp[ $i ];
}
}
}
+
+
+// +--------------------------------------------------------------------------
+// | 方案测试
+// +--------------------------------------------------------------------------
+
//do some test:
new mergeSort([4, 7, 6, 3, 9, 5, 8]);
+/*
+| 0 - 0 - 1 - 4,7,6,3,9,5,8
+| 2 - 2 - 3 - 4,7,6,3,9,5,8
+| 0 - 1 - 3 - 4,7,3,6,9,5,8
+| 4 - 4 - 5 - 3,4,6,7,9,5,8
+| 4 - 5 - 6 - 3,4,6,7,5,9,8
+| 0 - 3 - 6 - 3,4,6,7,5,8,9
+
+array(7) {
+ [0] =>
+ int(3)
+ [1] =>
+ int(4)
+ [2] =>
+ int(5)
+ [3] =>
+ int(6)
+ [4] =>
+ int(7)
+ [5] =>
+ int(8)
+ [6] =>
+ int(9)
+}
+ */
\ No newline at end of file
diff --git a/src/Sort/QuickSort.php b/src/Sort/QuickSort.php
new file mode 100644
index 0000000..f2a6688
--- /dev/null
+++ b/src/Sort/QuickSort.php
@@ -0,0 +1,84 @@
+
+ * @date 2017/6/17
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：从数列中挑出一个元素，称为 “基准”（pivot)
+ * 大O表示： O(n log n) 最糟 O(n 2)
+ * -------------------------------------------------------------
+ * 重新排序数列，所有元素比基准值小的摆放在基准前面，C 语言中的 qsort就是快速排序
+ * 所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
+ * 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序
+ */
+
+// +--------------------------------------------------------------------------
+// | 解题方式
+// +--------------------------------------------------------------------------
+
+/**
+ * QuickSort
+ *
+ * @param array $container
+ * @return array
+ */
+function QuickSort(array $container)
+{
+ $count = count($container);
+ if ($count <= 1) { // 基线条件为空或者只包含一个元素，只需要原样返回数组
+ return $container;
+ }
+ $pivot = $container[0]; // 基准值 pivot
+ $left = $right = [];
+
+ for ($i = 1; $i < $count; $i++) {
+ if ($container[$i] < $pivot) {
+ $left[] = $container[$i];
+ } else {
+ $right[] = $container[$i];
+ }
+ }
+ $left = QuickSort($left);
+ $right = QuickSort($right);
+ return array_merge($left, [$container[0]], $right);
+}
+
+// +--------------------------------------------------------------------------
+// | 方案测试
+// +--------------------------------------------------------------------------
+
+
+var_dump(QuickSort([4, 21, 41, 2, 53, 1, 213, 31, 21, 423]));
+/**
+ * array(10) {
+ * [0] =>
+ * int(1)
+ * [1] =>
+ * int(2)
+ * [2] =>
+ * int(4)
+ * [3] =>
+ * int(21)
+ * [4] =>
+ * int(21)
+ * [5] =>
+ * int(31)
+ * [6] =>
+ * int(41)
+ * [7] =>
+ * int(53)
+ * [8] =>
+ * int(213)
+ * [9] =>
+ * int(423)
+ * }
+ */
+/**
+ * PS & EX:
+ * 快速排序使用分而治之【 divide and conquer,D&C 】的策略，D&C 解决问题的过程包括两个步骤
+ * 1. 找出基线条件，这种条件必须尽可能简单
+ * 2. 不断将问题分解（或者说缩小规模），直到符合基线条件
+ * （D&C 并非解决问题的算法，而是一种解决问题的思路）
+ */
\ No newline at end of file
diff --git a/src/Sort/SelectSort.php b/src/Sort/SelectSort.php
new file mode 100644
index 0000000..832861c
--- /dev/null
+++ b/src/Sort/SelectSort.php
@@ -0,0 +1,72 @@
+
+ * @date 2017/6/17
+ * @license MIT
+ * -------------------------------------------------------------
+ * 思路分析：选择排序是不稳定的排序方法
+ * 大O表示： O(n 2)
+ * -------------------------------------------------------------
+ * 它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
+ * 选择排序是不稳定的排序方法（比如序列[5， 5， 3]第一次就将第一个[5]与[3]交换，导致第一个5挪动到第二个5后面）。
+ */
+
+
+// +--------------------------------------------------------------------------
+// | 解题方式
+// +--------------------------------------------------------------------------
+/**
+ * SelectSort
+ *
+ * @param array $container
+ * @return array
+ */
+function SelectSort(array $container)
+{
+ $count = count($container);
+ for ($i = 0; $i < $count; $i++){
+ $k = $i;
+ for ($j = $i + 1; $j < $count; $j++){
+ if($container[$j] < $container[$k]){
+ $k = $j;
+ }
+ }
+ if($k != $i){
+ $temp = $container[$i];
+ $container[$i] = $container[$k];
+ $container[$k] = $temp;
+ }
+ }
+ return $container;
+}
+
+// +--------------------------------------------------------------------------
+// | 方案测试
+// +--------------------------------------------------------------------------
+
+
+var_dump(SelectSort([3, 12, 42, 1, 24, 5, 346, 7]));
+
+/*
+ array(8) {
+ [0] =>
+ int(1)
+ [1] =>
+ int(3)
+ [2] =>
+ int(5)
+ [3] =>
+ int(7)
+ [4] =>
+ int(12)
+ [5] =>
+ int(24)
+ [6] =>
+ int(42)
+ [7] =>
+ int(346)
+}
+ */
\ No newline at end of file
diff --git a/package/Sort/ShellSort.php b/src/Sort/ShellSort.php
similarity index 55%
rename from package/Sort/ShellSort.php
rename to src/Sort/ShellSort.php
index eb5b86d..7b7aad5 100644
--- a/package/Sort/ShellSort.php
+++ b/src/Sort/ShellSort.php
@@ -1,6 +1,7 @@
* @date 2017/7/22
* @license Mozilla
@@ -11,18 +12,26 @@
* 当然每次循环的时候，h也是递减的（h=h/n）。第一次循环就是从下标为h开始。希尔排序的一个思想就是，分成小组去排序。
*/
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+
/**
+ * ShellSort
+ *
* @param array $container
* @return array
*/
-function ShellSort( array $container )
+function ShellSort(array $container)
{
$count = count($container);
- for ( $increment = intval($count / 2); $increment > 0; $increment = intval($increment / 2) ) {
- for ( $i = $increment; $i < $count; $i++ ) {
+ for ($increment = intval($count / 2); $increment > 0; $increment = intval($increment / 2)) {
+ for ($i = $increment; $i < $count; $i++) {
$temp = $container[$i];
- for ( $j = $i; $j >= $increment; $j -= $increment ) {
- if ( $temp < $container[$j - $increment] ) {
+ for ($j = $i; $j >= $increment; $j -= $increment) {
+ if ($temp < $container[$j - $increment]) {
$container[$j] = $container[$j - $increment];
} else {
break;
@@ -34,5 +43,12 @@ function ShellSort( array $container )
return $container;
}
-var_dump( ShellSort([6,13,21,99,18,2,25,33,19,84]));
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+
+var_dump(ShellSort([6, 13, 21, 99, 18, 2, 25, 33, 19, 84]));
+
diff --git a/src/Sort/ShuttleSort.php b/src/Sort/ShuttleSort.php
new file mode 100644
index 0000000..3afdf47
--- /dev/null
+++ b/src/Sort/ShuttleSort.php
@@ -0,0 +1,78 @@
+
+ * @date 2017/12/19
+ * @version 1.0
+ * -------------------------------------------------------------
+ * 思路分析：飞梭排序是冒泡排序的轻微变形。不同的地方在于，飞梭排序是从低到高然后从高到低来回排序，而冒泡排序则仅从低到高去比较序列里的每个元素。
+ * -------------------------------------------------------------
+ * 先对数组从左到右进行冒泡排序（升序），则最大的元素去到最右端
+ * 再对数组从右到左进行冒泡排序（降序），则最小的元素去到最左端
+ * 以此类推，依次改变冒泡的方向，并不断缩小未排序元素的范围，直到最后一个元素结束
+ */
+
+
+// +--------------------------------------------------------------------------
+// | 解题方式 | 这儿，可能有用的解决方案
+// +--------------------------------------------------------------------------
+
+
+/**
+ * ShuttleSort
+ *
+ * @param array $data
+ * @return array
+ */
+function ShuttleSort(array $data)
+{
+ /**
+ * 替换方法
+ *
+ * @param array $data
+ * @param $i
+ * @param $j
+ * @return array
+ */
+ $swap = function (array &$data, $i, $j) {
+ $temp = $data[$i];
+ $data[$i] = $data[$j];
+ $data[$j] = $temp;
+ return $data;
+ };
+
+ $count = count($data);
+ $left = 0;
+ $right = $count - 1;
+
+ while ($left < $right) {
+ // 从左到右
+ $lastRight = 0;
+ for ($i = $left; $i < $right; $i++) {
+ if ($data[$i] > $data[$i + 1]) {
+ $swap($data, $i, 1 + $i);
+ $lastRight = $i;
+ }
+ }
+ $right = $lastRight;
+ // 从右到左
+ $lastLeft = 0;
+ for ($j = $right; $left < $j; $j--) {
+ if ($data[$j - 1] > $data[$j]) {
+ $swap($data, $j - 1, $j);
+ $lastLeft = $j;
+ }
+ }
+ $left = $lastLeft;
+ }
+ return $data;
+}
+
+// +--------------------------------------------------------------------------
+// | 方案测试 | php `this.php` || PHPStorm -> 右键 -> Run `this.php`
+// +--------------------------------------------------------------------------
+
+
+var_dump(ShuttleSort([6, 13, 21, 99, 18, 2, 25, 33, 19, 84]));
diff --git a/src/Structure/BinarySearchTree.php b/src/Structure/BinarySearchTree.php
new file mode 100644
index 0000000..cc3fea2
--- /dev/null
+++ b/src/Structure/BinarySearchTree.php
@@ -0,0 +1,129 @@
+value = $data;
+ $node->left = null;
+ $node->right = null;
+ return $node;
+ }
+
+
+ /**
+ * 插入节点
+ * @param $node 根节点
+ * @param $value 关键值
+ */
+ public function insert(&$node, $value)
+ {
+ if(empty($value) && $value !== 0) {
+ return ;
+ }
+
+ if ($node == null) {
+ $node = $this->createNode($value);
+ } else if ($value < $node->value) {
+ $this->insert($node->left, $value);
+ } else {
+ $this->insert($node->right, $value);
+ }
+ }
+
+ /**
+ * 先序遍历
+ * @param $node 根节点
+ */
+ public function preOrder(&$node)
+ {
+ if ($node != null) {
+ echo $node->value . PHP_EOL ;
+ $this->preOrder($node->left);
+ $this->preOrder($node->right);
+ }
+
+ }
+ /**
+ * 中序遍历
+ * @param $node 根节点
+ */
+ public function middleOrder(&$node)
+ {
+ if ($node != null) {
+ $this->middleOrder($node->left);
+ echo $node->value . PHP_EOL ;
+ $this->middleOrder($node->right);
+ }
+
+ }
+
+ /**
+ * 后序遍历
+ * @param $node 根节点
+ */
+ public function afterOrder(&$node)
+ {
+ if ($node != null) {
+ $this->afterOrder($node->left);
+ $this->afterOrder($node->right);
+ echo $node->value . PHP_EOL;
+ }
+ }
+
+ /**
+ * 获取最大值
+ * @param $node 根节点
+ */
+ public function findMax(&$node)
+ {
+ while($node->right != null) {
+ $node = $node->right;
+ }
+ return $node->value;
+ }
+
+}
+
+$tree = new BinarySearchTree();
+$tree->insert($tree->root, 3);
+$tree->insert($tree->root, 9);
+$tree->insert($tree->root, 2);
+$tree->insert($tree->root, 20);
+
+echo "先序遍历".PHP_EOL;
+$tree->preOrder($tree->root); //324
+echo "中序遍历" . PHP_EOL;
+
+$tree->middleOrder($tree->root); //324
+echo "后序遍历" . PHP_EOL;
+
+$tree->afterOrder($tree->root); //234
+
+$max = $tree->findMax($tree->root);
+
+var_dump($max);
\ No newline at end of file
diff --git a/src/Structure/KitchenQueue.php b/src/Structure/KitchenQueue.php
new file mode 100644
index 0000000..80e87fd
--- /dev/null
+++ b/src/Structure/KitchenQueue.php
@@ -0,0 +1,53 @@
+
+ * @date 2017/12/3
+ * @version 1.0
+ * @license MIT
+ */
+
+class KitchenQueue
+{
+ /**
+ * @var \stdClass $cooking
+ */
+ protected $cooking;
+
+ /**
+ * 服务员
+ *
+ * @param $dishes
+ */
+ public function waiter($dishes)
+ {
+ $node = new \stdClass();
+ $node->element = $dishes;
+ $node->next = $this->cooking;
+ $this->cooking = $node;
+ }
+
+ /**
+ * 厨师
+ *
+ * @return \stdClass
+ */
+ public function kitchen()
+ {
+ return $this->cooking;
+ }
+}
+
+$kitchen = new KitchenQueue();
+$kitchen->waiter("Qin Jiao Rou Si");
+$kitchen->waiter("Ma Po Dou Fu");
+$kitchen->waiter("Fu Qi Fei Pian");
+$kitchen->waiter("Kou Shui Ji");
+var_dump($kitchen->kichen());
diff --git a/src/Structure/LinearChain.php b/src/Structure/LinearChain.php
new file mode 100644
index 0000000..ef6b237
--- /dev/null
+++ b/src/Structure/LinearChain.php
@@ -0,0 +1,403 @@
+
+ * @date 2017/9/29
+ * @license MIT
+ * -------------------------------------------------------------
+ * [基本说明]
+ * =======
+ * 线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的
+ * 注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储）
+ * 但是把最后一个数据元素的尾指针指向了首位结点）。
+ * [基本特点]
+ * =======
+ * - 存在一个唯一的被称为`第一个`的数据元素
+ * - 存在一个唯一的被称为`最后一个`的数据元素
+ * - 除第一个元素外，每个元素均有唯一一个直接前驱
+ * - 除最后一个元素外，每个元素均有唯一一个直接后继
+ * -------------------------------------------------------------
+ * [定义]
+ * =======
+ * 线性表(Linear List) ：是由n(n≧0)个数据元素(结点) [a1，a2， …an] 组成的有限序列。数据元素是一个抽象的符号，其具体含义在不同的情况下一般不同。
+ * 该序列中的所有结点具有相同的数据类型。其中数据元素的个数n称为线性表的长度。
+ * 当n=0时，称为空表。
+ * 当n>0时，将非空的线性表记作： (a1，a2，…an) a1称为线性表的第一个(首)结点，an称为线性表的最后一个(尾)结点。
+ * -------------------------------------------------------------
+ * [线性表单链存储]
+ * =======
+ * 用一组任意的存储单元存储线性表中的数据元素，用这种方法存储的线性表简称线性链表。
+ * -------------------------------------------------------------
+ * [单链存储的线性表的特点]
+ * =======
+ * - 存储链表中结点的一组任意的存储单元可以是连续的，也可以是不连续的，甚至是零散分布在内存中的任意位置上
+ * - 链表中结点的逻辑顺序和物理顺序不一定相同
+ * -------------------------------------------------------------
+ */
+class LinearChain
+{
+ /**
+ * @var string 下一结点指针
+ */
+ public $next;
+
+ /**
+ * @var string 头结点数据
+ */
+ public $elem;
+
+ /**
+ * @var int 链表长度
+ */
+ public $length;
+
+ /**
+ * LinearChain constructor. 线性表初始化
+ */
+ public function __construct()
+ {
+ $this->next = $this->elem = $this->length = null;
+ }
+
+ /**
+ * 清空单链表
+ *
+ * @return mixed
+ */
+ public function clearChain()
+ {
+ if ($this->length <= 0) {
+ return false;
+ }
+ while ($this->next != null) {
+ $q = $this->next->next;
+ $this->next = null;
+ unset($this->next);
+ $this->next = $q;
+ }
+ $this->length = 0;
+ }
+
+ /**
+ * 返回单链表长度
+ *
+ * @return mixed
+ */
+ public function getLength()
+ {
+ return $this->length;
+ }
+
+ /**
+ * 判断单链表是否为空
+ *
+ * @return bool 为空返回true,不为空返回false
+ */
+ public function getIsEmpty()
+ {
+ return $this->length == 0 && $this->next == null;
+ }
+
+ /**
+ * 头插入法建表
+ *
+ * @param array $arr 建立单链表的数据
+ * @return mixed
+ */
+ protected function getHeadCreateChain(array $arr)
+ {
+ $this->clearChain();
+ $iterator = $this->generator($arr);
+ $iterator->rewind();
+ while ($iterator->valid()) {
+ $node = new stdClass();
+ $node->elem = $iterator->current();
+ $node->next = $this->next;
+ $this->next = $node;
+ $this->length++;
+ $iterator->next();
+ }
+ return $this->next;
+ }
+
+ /**
+ * 尾插入法建表
+ *
+ * @param array $arr 建立单链表的数据
+ * @return mixed
+ */
+ protected function getTailCreateChain(array $arr)
+ {
+ $this->clearChain();
+ $self = $this;
+ $iterator = $this->generator($arr);
+ $iterator->rewind();
+ while ($iterator->valid()) {
+ $node = new stdClass();
+ $node->elem = $iterator->current();
+ $node->next = $self->next;
+ $self->next = $node;
+ $self = $node;
+ $iterator->next();
+ $this->length++;
+ }
+ return $this->next;
+ }
+
+ /**
+ * 返回第$i个元素
+ *
+ * @param int $i 元素位序，从1开始
+ * @return mixed
+ */
+ protected function getElemForPos($i)
+ {
+ $i = (int)$i;
+ if ($i > $this->length || $i < 1) {
+ return null;
+ }
+ $mark = 1;
+ $self = $this->next;
+ while ($mark < $i) {
+ $box = $self->next;
+ $self = $box;
+ $mark++;
+ }
+ return $self;
+ }
+
+ /**
+ * 查找单链表中是否存在某个值的元素
+ * 如果有返回该元素结点，否则返回null
+ *
+ * @param mixed $value 查找的值
+ * @return mixed
+ */
+ protected function getElemIsExist($value)
+ {
+ $self = $this;
+ while ($self->next != null && strcmp($self->elem, $value) !== 0) {
+ $self = $self->next;
+ }
+ if (strcmp($self->elem, $value) === 0) {
+ return $self;
+ }
+ return null;
+ }
+
+ /**
+ * 查找单链表中是否存在某个值的元素
+ * 如果有返回该元素位序，否则返回-1
+ *
+ * @param mixed $value 查找的值
+ * @return mixed
+ */
+ protected function getElemPosition($value)
+ {
+ $self = $this;
+ $mark = 0;
+ while ($self->next != null && strcmp($self->elem, $value) !== 0) {
+ $self = $self->next;
+ $mark++;
+ }
+ if (strcmp($self->elem, $value) === 0) {
+ return $mark;
+ }
+ return -1;
+ }
+
+ /**
+ * 单链表的插入操作
+ *
+ * @param int $key 插入元素的位序，即在什么位置插入新的元素,从1开始
+ * @param mixed $value 插入的新的元素值
+ * @return boolean 插入成功返回true，失败返回false
+ */
+ protected function getInsertElem($key, $value)
+ {
+ if ($key > $this->length || $key < 1) {
+ return false;
+ }
+ $mark = 1;
+ $self = $this;
+ while ($self->next != null && $mark < $key) {
+ $self = $self->next;
+ $mark++;
+ }
+ $node = new stdClass();
+ $node->elem = $value;
+ $node->next = $self->next;
+ $self->next = $node;
+ $this->length++;
+ return true;
+ }
+
+ /**
+ * 遍历单链表中的所有元素
+ *
+ * @return array 包括单链中的所有元素
+ */
+ protected function getAllElem()
+ {
+ $result = array ();
+ if ($this->getIsEmpty()) {
+ return $result;
+ }
+ $self = $this->next;
+ while ($self->next != null) {
+ array_push($result, $self->elem);
+ $self = $self->next;
+ }
+ array_push($result, $self->elem);
+ return $result;
+ }
+
+ /**
+ * 根据Key 删除单链中的元素
+ *
+ * @param int $key 元素位序
+ * @return boolean 删除成功返回true,失败返回false
+ */
+ protected function getDeleteElem($key)
+ {
+ $key = (int)$key;
+ if ($key > $this->length || $key < 1) {
+ return false;
+ }
+ $self = $this;
+ $mark = 1;
+ while ($mark < $key) {
+ $self = $self->next;
+ $mark++;
+ }
+ $node = $self->next;
+ $self->next = $node->next;
+ $this->length--;
+ return true;
+ }
+
+ /**
+ * 删除单链表中值为$value的前 $i($i>=1) 个结点
+ *
+ * @param mixed mixed 待查找的值
+ * @param $i mixed 删除的次数，即删除查找到的前$i个
+ * @return mixed
+ */
+ protected function getDeleteElemForValue($value, $i = 1)
+ {
+ if ($i > 1) {
+ $this->getDeleteElemForValue($value, $i - 1);
+ }
+ $vp = $this->getElemPosition($value);
+ $this->getDeleteElem($vp);
+ return $this->getAllElem();
+ }
+
+ /**
+ * 删除单链表所有重复的值
+ *
+ * @return mixed
+ */
+ protected function getElemUnique()
+ {
+ if ($this->getIsEmpty()) {
+ return $this->getAllElem();
+ }
+ $self = $this;
+ while ($self->next != null) {
+ $node = $self->next;
+ $ptr = $self;
+ while ($node->next != null) {
+ if (strcmp($self->elem, $node->elem) === 0) {
+ $ptr->next = $node->next;
+ unset($node->next);
+ $node = $ptr->next;
+ $this->length--;
+ } else {
+ $ptr = $node;
+ $node = $node->next;
+ }
+ }
+ $self = $self->next;
+ }
+ return $this->getAllElem();
+ }
+
+ /**
+ * 迭代器生产
+ *
+ * @param array $info
+ * @return \ArrayIterator
+ */
+ protected function generator(array $info)
+ {
+ return (new ArrayObject($info))->getIterator();
+ }
+
+ /**
+ * 调试用请无视
+ *
+ * @param $name
+ * @param $arguments
+ * @return mixed
+ */
+ public function __call($name, $arguments)
+ {
+ $this->preDispatch(); // 调试用，请无视
+ return call_user_func_array(array ($this, $name), $arguments);
+ }
+
+ /**
+ * 调试用请无视！
+ *
+ * @param bool $isDebug
+ * @return bool
+ */
+ protected function preDispatch($isDebug = true)
+ {
+ if (!$isDebug) {
+ return false;
+ }
+ $debug = debug_backtrace()[1];
+ $reflection = new ReflectionMethod($this, $debug['args'][0]);
+ $args = '';
+ if (isset($debug['args'][1])) {
+ foreach ($debug['args'][1] as &$value) {
+ if (is_array($value)) {
+ $args .= json_encode($debug['args'][1]) . ', ';
+ } else {
+ $args .= $value . ', ';
+ }
+ }
+ }
+ $args = trim($args, ', ');
+ echo "\t" . $reflection->getDocComment() . PHP_EOL;
+ echo "\t{$debug['args'][0]}({$args})\n" . PHP_EOL;
+ }
+}
+
+$echo = function ($str, $action) {
+ echo $str . "\t->\t" . var_export($action, true) . PHP_EOL;
+ echo "--------------------------- " . PHP_EOL;
+};
+$personal = array (
+ "One",
+ "Two",
+ "Three",
+ "Four",
+ "Five",
+);
+
+$oll = new LinearChain();
+$echo('头插入链表数据', $oll->getHeadCreateChain($personal));
+$echo('尾插入链表数据', $oll->getTailCreateChain($personal));
+$echo('返回第二个数据', $oll->getElemForPos(2));
+$echo('是否存在Tow呢？', $oll->getElemIsExist("Two"));
+$echo('One 的下标示是', $oll->getElemPosition("One"));
+$echo('从2号位插入一个Four', $oll->getInsertElem(2, "Four"));
+$echo('遍历整个单链表', $oll->getAllElem());
+$echo('删除第一个元素', $oll->getDeleteElem(1));
+$echo('删除Three 前一个', $oll->getDeleteElemForValue("Three", 1));
+$echo('去重链表中重复值', $oll->getElemUnique());
\ No newline at end of file
diff --git a/src/Structure/LinearOrder.php b/src/Structure/LinearOrder.php
new file mode 100644
index 0000000..926f749
--- /dev/null
+++ b/src/Structure/LinearOrder.php
@@ -0,0 +1,376 @@
+
+ * @date 2017/9/29
+ * @license MIT
+ * -------------------------------------------------------------
+ * [基本说明]
+ * =======
+ * 线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的
+ * 注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储）
+ * 但是把最后一个数据元素的尾指针指向了首位结点）。
+ * [基本特点]
+ * =======
+ * - 存在一个唯一的被称为`第一个`的数据元素
+ * - 存在一个唯一的被称为`最后一个`的数据元素
+ * - 除第一个元素外，每个元素均有唯一一个直接前驱
+ * - 除最后一个元素外，每个元素均有唯一一个直接后继
+ * -------------------------------------------------------------
+ * [定义]
+ * =======
+ * 线性表(Linear List) ：是由n(n≧0)个数据元素(结点) [a1，a2， …an] 组成的有限序列。数据元素是一个抽象的符号，其具体含义在不同的情况下一般不同。
+ * 该序列中的所有结点具有相同的数据类型。其中数据元素的个数n称为线性表的长度。
+ * 当n=0时，称为空表。
+ * 当n>0时，将非空的线性表记作： (a1，a2，…an) a1称为线性表的第一个(首)结点，an称为线性表的最后一个(尾)结点。
+ * -------------------------------------------------------------
+ * [线性表顺序存储]
+ * =======
+ * 把线性表的结点按逻辑顺序依次存放在一组地址连续的存储单元里，用这种方法存储的线性表简称线性表。
+ * -------------------------------------------------------------
+ * [顺序存储的线性表的特点]
+ * =======
+ * - 线性表的逻辑顺序与物理顺序一致；
+ * - 数据元素之间的关系是以元素在计算机内“物理位置相邻”来体现。
+ * -------------------------------------------------------------
+ * @param array
+ */
+class LinearOrder extends ArrayObject
+{
+ const PRECURSOR_KEY = 0;
+ const PRECURSOR_VALUE = 1;
+
+ const SUBSEQUENT_KEY = 0;
+ const SUBSEQUENT_VALUE = 1;
+
+ const ASSIGN_KEY = 0;
+ const DEFAULT_KEY = 1;
+
+ const DELETE_KEY = 0;
+ const DELETE_VALUE = 1;
+
+ /**
+ * @var array|mixed 线性表
+ */
+ public $oll;
+
+ /**
+ * LinearList constructor. 线性表初始化
+ *
+ * @param array $oll
+ */
+ public function __construct($oll = array ())
+ {
+ echo '---------------------------'.PHP_EOL;
+ echo var_export($oll).PHP_EOL;
+ echo '---------------------------'.PHP_EOL;
+ parent::__construct($oll);
+ $this->oll = $this->getIterator();
+ }
+
+ /**
+ * @return void 清空线性表
+ */
+ public function __destruct()
+ {
+ unset($this->oll);
+ }
+
+ /**
+ * 调试用请无视
+ *
+ * @param $name
+ * @param $arguments
+ * @return mixed
+ */
+ public function __call($name, $arguments)
+ {
+ $this->preDispatch(); // 调试用，请无视
+ return call_user_func_array(array($this, $name), $arguments);
+ }
+
+ /**
+ * 判断线性表是否为空
+ *
+ * @return boolean 为空返回true,否则返回false
+ */
+ protected function isEmpty()
+ {
+ return $this->getLength() > 0 ? false : true;
+ }
+
+ /**
+ * 返回线性表的长度
+ *
+ * @return int
+ */
+ protected function getLength()
+ {
+ return $this->oll->count();
+ }
+
+ /**
+ * 返回线性表中下标为$key的元素
+ *
+ * @param mixed $key 线性表元素的下标
+ * @return mixed
+ */
+ protected function getElement($key)
+ {
+ return $this->oll->offsetGet($key);
+ }
+
+ /**
+ * 返回线性表中某个元素的位置
+ *
+ * @param mixed $value 线性表中某个元素的值
+ * @return int 从1开始,如果返回-1表示不存在该元素
+ */
+ protected function getElementPosition($value)
+ {
+ $i = 0;
+ $this->oll->rewind();
+ while ($this->oll->valid()) {
+ $i++;
+ if (strcmp($value, $this->oll->current()) === 0) {
+ return $i;
+ }
+ $this->oll-> next();
+ }
+ return -1;
+ }
+
+ /**
+ * 返回线性表中某个元素的直接前驱元素
+ *
+ * @param string $value 线性表中某个元素的值
+ * @param int $tag 如果$value为下标则为1, 如果$value为元素值则为0
+ * @return array|bool array('value'=>...)直接前驱元素值，array('key'=>...)直接前驱元素下标
+ */
+ protected function getElementPrecursor($value, $tag = self::PRECURSOR_VALUE)
+ {
+ $i = 0;
+ $prev = null;
+ $this->oll->rewind();
+ while ($this->oll->valid()) {
+ $key = $this->oll->key();
+ $current = $this->oll->current();
+ if (strcmp($key, $value) === 0) {
+ if ($i == 1) {
+ return false;
+ }
+ return array ('value' => $this->getElement($prev), 'key' => $prev);
+ }
+ if ($tag == self::PRECURSOR_VALUE) {
+ if (strcmp($current, $value) === 0) {
+ if ($i == 1) {
+ return false;
+ }
+ return array ('value' => $this->getElement($prev), 'key' => $prev);
+ }
+ }
+ $i++;
+ $prev = $this->oll->key();
+ $this->oll->next();
+ }
+ }
+
+ /**
+ * 返回某个元素的直接后继元素
+ *
+ * @param string $value $value线性表中某个元素的值
+ * @param int $tag 如果$value为下标则为1,如果$value为元素值则为0
+ * @return array|bool array('value'=>...)直接后继元素值，array('key'=>...)直接后继元素下标
+ */
+ protected function getElementSubsequent($value, $tag = self::SUBSEQUENT_KEY)
+ {
+ $i = 0;
+ $len = $this->getLength();
+ $this->oll->rewind();
+ while ($this->oll->valid()) {
+ $key = $this->oll->key();
+ $current = $this->oll->current();
+ if ($tag == self::SUBSEQUENT_KEY) {
+ if (strcmp($key, $value) == 0) {
+ if ($i == $len) {
+ return false;
+ }
+ $this->oll->next();
+ return array ('value' => $this->oll->current(), 'key' => $this->oll->key());
+ }
+ }
+ if ($tag == self::SUBSEQUENT_VALUE) {
+ if (strcmp($current, $value) == 0) {
+ if ($i == $len) {
+ return false;
+ }
+ $this->oll->next();
+ return array ('value' => $this->oll->current(), 'key' => $this->oll->key());
+ }
+ }
+ $i++;
+ $this->oll->next();
+ }
+ return false;
+ }
+
+ /**
+ * 在指定位置插入一个新的结点
+ *
+ * @param string $p 新结点插入位置,从0开始
+ * @param string $value 线性表新结点的值
+ * @param null $key 线性表新结点的下标
+ * @param int $tag 是否指定新结点的下标,1表示默认下标,0表示指定下标
+ * @return bool 插入成功返回true，失败返回false
+ */
+ protected function getInsertElement($p, $value, $key = null, $tag = self::DEFAULT_KEY)
+ {
+ $p = (int)$p;
+ $i = 0;
+ if ($p > $this->getLength() || $p < 1) {
+ return false;
+ }
+ $this->oll->rewind();
+ while ($this->oll->valid()) {
+ if ($i != $p) {
+ $i++;
+ $this->oll->next();
+ }
+ switch ($tag){
+ case self::DEFAULT_KEY:
+ $this->oll->append($value);
+ break 2;
+ case self::ASSIGN_KEY:
+ $this->oll->offsetSet($key, $value);
+ break 2;
+ }
+ }
+ return true;
+ }
+
+ /**
+ * 根据元素位置返回线性表中的某个元素
+ *
+ * @param mixed $position 元素位置从1开始
+ * @return array|bool array('value'=>...)元素值，array('key'=>...)元素下标
+ */
+ protected function getElemForPos($position)
+ {
+ $i = 0;
+ $len = $this->getLength();
+ $position = (int)$position;
+ if ($position > $len || $position < 1) {
+ return false;
+ }
+ $this->oll->rewind();
+ while ($this->oll->valid()) {
+ if ($i == $position) {
+ return array ('value' => $this->oll->current(), 'key' => $this->oll->key());
+ }
+ $i++;
+ $this->oll->next();
+ }
+ }
+
+ /**
+ * 根据下标或者元素值删除线性表中的某个元素
+ *
+ * @param mixed $value 元素下标或者值
+ * @param int $tag 0表示$value为下标，1表示$value为元素值
+ * @return bool 成功返回true,失败返回false
+ */
+ protected function getDeleteElement($value, $tag = self::DELETE_KEY)
+ {
+ $this->oll->rewind();
+ while ($this->oll->valid())
+ {
+ $key = $this->oll->key();
+ $current = $this->oll->current();
+ if ($tag == self::DELETE_KEY) {
+ if (strcmp($key, $value) === 0) {
+ $this->oll->offsetUnset($key);
+ }
+ }
+ if ($tag == self::DELETE_VALUE) {
+ if (strcmp($current, $value) === 0) {
+ $this->oll->offsetUnset($key);
+ }
+ }
+ $this->oll->next();
+ }
+ return true;
+ }
+
+ /**
+ * 根据元素位置删除线性表中的某个元素
+ *
+ * @param int $position 元素位置从1开始
+ * @return bool 成功返回true,失败返回false
+ */
+ protected function getDeleteEleForPos($position)
+ {
+ $len = $this->getLength();
+ $i = 0;
+ $position = (int)$position;
+ if ($position > $len || $position < 1) {
+ return false;
+ }
+ $this->oll->rewind();
+ while ($this->oll->valid()) {
+ $key = $this->oll->key();
+ if ($i == $position) {
+ $this->oll->offsetUnset($key);
+ }
+ $i++;
+ $this->oll->next();
+ }
+ return true;
+ }
+
+ /**
+ * 调试用
+ *
+ * @param bool $isDebug
+ * @return bool
+ */
+ protected function preDispatch($isDebug = true)
+ {
+ if (!$isDebug) {
+ return false;
+ }
+ $debug = debug_backtrace()[1];
+ $reflection = new ReflectionMethod($this, $debug['args'][0]);
+ $args = '';
+ if(isset($debug['args'][1])){
+ foreach ($debug['args'][1] as &$value){
+ if( is_array($value )){
+ $args .= json_encode($debug['args'][1]).', ';
+ }else{
+ $args .= $value.', ';
+ }
+ }
+ }
+ $args = trim($args,', ');
+ echo "\t".$reflection->getDocComment() . PHP_EOL;
+ echo "\t{$debug['args'][0]}({$args})\n" . PHP_EOL;
+ }
+}
+
+$echo = function ($str, $action) {
+ echo $str . "\t->\t" . var_export($action, true) . PHP_EOL;
+ echo "--------------------------- " . PHP_EOL;
+};
+
+$oll = new LinearOrder(array ('name' => 'Jack', 10, "age", 'msg' => 10, 666));
+$echo('判断线性表是否为空', $oll->isEmpty());
+$echo('返回线性表的长度', $oll->getLength());
+$echo('根据下标返回线性表中的某个元素', $oll->getElement(1));
+$echo('返回线性表中某个元素的位置', $oll->getElementPosition(666));
+$echo('返回线性表中某个元素的直接前驱元素', $oll->getElementPrecursor(666, LinearOrder::PRECURSOR_VALUE));
+$echo('返回线性表中某个元素的直接后继元素', $oll->getElementSubsequent(0, LinearOrder::SUBSEQUENT_KEY));
+$echo('根据元素位置返回线性表中的某个元素', $oll->getElemForPos(2));
+$echo('根据下标或者元素值删除线性表中的某个元素', $oll->getDeleteElement('name', LinearOrder::DELETE_KEY));
+$echo('在指定位置插入一个新的结点', $oll->getInsertElement(3, "插入新节点", "qzone", LinearOrder::ASSIGN_KEY));
+$echo('$oll->oll的内容 ', $oll->oll);
\ No newline at end of file
diff --git a/src/Structure/StackExample.php b/src/Structure/StackExample.php
new file mode 100644
index 0000000..a8b4f30
--- /dev/null
+++ b/src/Structure/StackExample.php
@@ -0,0 +1,224 @@
+
+ * @date 2017/10/16
+ * @license MIT
+ * -------------------------------------------------------------
+ * [栈的定义]
+ * =======
+ * 栈(Stack)：是限制在表的一端进行插入和删除操作的线性表。又称为后进先出LIFO (Last In First Out)或先进后出FILO (First In Last Out)线性表。
+ * 栈顶(Top)：允许进行插入、删除操作的一端，又称为表尾。用栈顶指针(top)来指示栈顶元素。
+ * 栈底(Bottom)：是固定端，又称为表头。
+ * 空栈：当表中没有元素时称为空栈。
+ * [栈的实现方式]
+ * =======
+ * - 硬堆栈：利用CPU中的某些寄存器组或类似的硬件或使用内存的特殊区域来实现。这类堆栈容量有限，但速度很快；
+ * - 软堆栈：这类堆栈主要在内存中实现。堆栈容量可以达到很大。在实现方式上，又有动态方式和静态方式两种
+ * -------------------------------------------------------------
+ * [定义]
+ * =======
+ * 线性表(Linear List) ：是由n(n≧0)个数据元素(结点) [a1，a2， …an] 组成的有限序列。数据元素是一个抽象的符号，其具体含义在不同的情况下一般不同。
+ * 该序列中的所有结点具有相同的数据类型。其中数据元素的个数n称为线性表的长度。
+ * 当n=0时，称为空表。
+ * 当n>0时，将非空的线性表记作： (a1，a2，…an) a1称为线性表的第一个(首)结点，an称为线性表的最后一个(尾)结点。
+ * -------------------------------------------------------------
+ * [线性表顺序存储]
+ * =======
+ * 把线性表的结点按逻辑顺序依次存放在一组地址连续的存储单元里，用这种方法存储的线性表简称线性表。
+ * -------------------------------------------------------------
+ * [顺序存储的线性表的特点]
+ * =======
+ * - 线性表的逻辑顺序与物理顺序一致；
+ * - 数据元素之间的关系是以元素在计算机内“物理位置相邻”来体现。
+ * -------------------------------------------------------------
+ * @param array
+ */
+class StackExample
+{
+ /**
+ * @var null 栈元素
+ */
+ protected $elem;
+ /**
+ * @var null 下一个节点
+ */
+ protected $next;
+ /**
+ * @var int 栈长度
+ */
+ protected $length;
+
+ /**
+ * 初始化栈
+ * StackExample constructor.
+ */
+ public function __construct()
+ {
+ $this->elem = $this->next = null;
+ $this->length = 0;
+ }
+
+ /**
+ * 判断栈是否空栈
+ *
+ * @return boolean 如果为空栈返回true,否则返回false
+ */
+ protected function getIsEmpty()
+ {
+ return $this->elem ? false : true;
+ }
+
+ /**
+ * 将所有元素出栈
+ *
+ * @return array 返回所有栈内元素
+ */
+ protected function getAllPopStack()
+ {
+ $result = array ();
+ if ($this->getIsEmpty()) {
+ return $result;
+ }
+ while ($this->elem != null) {
+ $result[] = $this->elem->elem;
+ $this->elem = $this->elem->next;
+ }
+ $this->length = 0;
+ return $result;
+ }
+
+ /**
+ * 返回栈内元素个数
+ *
+ * @return int
+ */
+ protected function getLength()
+ {
+ return $this->length;
+ }
+
+ /**
+ * 元素进栈
+ *
+ * @param mixed $element 进栈元素值
+ * @return void
+ **/
+ protected function setPushStack($element)
+ {
+ $stack = new stdClass();
+ $stack->elem = $element;
+ $stack->next = $this->elem;
+ $this->elem = &$stack;
+ $this->length++;
+ }
+
+ /**
+ * 元素出栈
+ *
+ * @return boolean 出栈成功返回true,否则返回false
+ **/
+ protected function getPopStack()
+ {
+ if ($this->getIsEmpty()) {
+ return false;
+ }
+ $node = $this->elem;
+ $this->elem = $node->next;
+ $this->length--;
+ }
+
+ /**
+ * 仅返回栈内所有元素
+ *
+ * @return array 栈内所有元素组成的一个数组
+ */
+ protected function getAllElem()
+ {
+ $result = array ();
+ if ($this->getIsEmpty()) {
+ return $result;
+ }
+ $node = $this->elem;
+ while ($node != null) {
+ $result[] = $node->elem;
+ $node = $node->next;
+ }
+ return $result;
+ }
+
+ /**
+ * 返回栈内某个元素的个数
+ *
+ * @param mixed $elem 待查找的元素的值
+ * @return int
+ **/
+ protected function getCountForElem($elem)
+ {
+ $result = $this->getAllElem();
+ $count = 0;
+ foreach ($result as $value) {
+ if ($elem === $value) {
+ $count++;
+ }
+ }
+ return $count;
+ }
+
+ /**
+ * 调试用请无视
+ *
+ * @param $name
+ * @param $arguments
+ * @return mixed
+ */
+ public function __call($name, $arguments)
+ {
+ $this->preDispatch(); // 调试用，请无视
+ return call_user_func_array(array ($this, $name), $arguments);
+ }
+
+ /**
+ * 调试用
+ *
+ * @param bool $isDebug
+ * @return bool
+ */
+ protected function preDispatch($isDebug = true)
+ {
+ if (!$isDebug) {
+ return false;
+ }
+ $debug = debug_backtrace()[1];
+ $reflection = new ReflectionMethod($this, $debug['args'][0]);
+ $args = '';
+ if (isset($debug['args'][1])) {
+ foreach ($debug['args'][1] as &$value) {
+ if (is_array($value)) {
+ $args .= json_encode($debug['args'][1]) . ', ';
+ } else {
+ $args .= $value . ', ';
+ }
+ }
+ }
+ $args = trim($args, ', ');
+ echo "\t" . $reflection->getDocComment() . PHP_EOL;
+ echo "\t{$debug['args'][0]}({$args})\n" . PHP_EOL;
+ }
+}
+
+$echo = function ($str, $action) {
+ echo $str . "\t->\t" . var_export($action, true) . PHP_EOL;
+ echo "--------------------------- " . PHP_EOL;
+};
+
+//$stack = new StackExample();
+//$stack->setPushStack('First');
+//$stack->setPushStack('Second');
+//$echo('返回栈内所有元素', $stack->getAllElem());
+//$stack->setPushStack('Third');
+//$echo('返回栈内所有元素', $stack->getAllElem());
+//$stack->getPopStack();
+//$echo('返回栈内所有元素', $stack->getAllElem());
diff --git a/tests/BootStrapTest.php b/tests/BootStrapTest.php
new file mode 100644
index 0000000..a4abe2d
--- /dev/null
+++ b/tests/BootStrapTest.php
@@ -0,0 +1,2 @@
+chineseObj = new ChineseTextNumberSort();
+ }
+
+ /**
+ * testValidationModelA
+ *
+ * @test
+ * @throws \Exception
+ */
+ public function testValidationModelA()
+ {
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_A,
+ '第二章 我是Marco小哥哥'
+ ),
+ '二'
+ );
+
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_A,
+ '第一节 我是Marco小哥哥'
+ ),
+ '一'
+ );
+
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_A,
+ '第二单元 我是Marco小哥哥'
+ ),
+ '二'
+ );
+
+ $this->assertNotEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_A,
+ '第一章 我是Marco小哥哥'
+ ),
+ '1'
+ );
+ }
+
+ /**
+ * testValidationModelB
+ *
+ * @throws \Exception
+ * @test
+ */
+ public function testValidationModelB()
+ {
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_B,
+ '01我是Marco小哥哥'
+ ),
+ '01'
+ );
+
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_B,
+ '12我是Marco小哥哥'
+ ),
+ '12'
+ );
+
+ $this->assertNotEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_B,
+ '10章我是Marco小哥哥'
+ ),
+ '1'
+ );
+ }
+
+ /**
+ * testValidationModelC
+ *
+ * @throws \Exception
+ * @test
+ */
+ public function testValidationModelC()
+ {
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_C,
+ '1 我是Marco小哥哥'
+ ),
+ 1
+ );
+
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_C,
+ '22 我是Marco小哥哥'
+ ),
+ 22
+ );
+
+ $this->assertNotEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_C,
+ '22 我是Marco小哥哥'
+ ),
+ 21
+ );
+ }
+
+ /**
+ * testValidationModelD
+ *
+ * @throws \Exception
+ * @test
+ */
+ public function testValidationModelD()
+ {
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_D,
+ '1页-我是Marco小哥哥'
+ ),
+ 1
+ );
+
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_D,
+ '22页-+我是Marco小哥哥'
+ ),
+ 22
+ );
+
+ $this->assertNotEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_D,
+ '2页-+我是Marco小哥哥'
+ ),
+ 22
+ );
+ }
+
+ /**
+ * testValidationModelE
+ *
+ * @throws \Exception
+ * @test
+ */
+ public function testValidationModelE()
+ {
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_E,
+ '1-'
+ ),
+ 1
+ );
+
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_E,
+ '2-+我是Marco小哥哥'
+ ),
+ 2
+ );
+
+ $this->assertNotEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_E,
+ '23-我是Marco小哥哥'
+ ),
+ 24
+ );
+ }
+
+ /**
+ * testValidationModelF
+ *
+ * @throws \Exception
+ * @test
+ */
+ public function testValidationModelF()
+ {
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_F,
+ '1 但是'
+ ),
+ 1
+ );
+
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_F,
+ '1 2对对对'
+ ),
+ 1
+ );
+
+ $this->assertNotEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_F,
+ '22 我是Marco小哥哥'
+ ),
+ 2
+ );
+ }
+
+ /**
+ * testValidationModelG
+ *
+ * @throws \Exception
+ * @test
+ */
+ public function testValidationModelG()
+ {
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_G,
+ '1、、'
+ ),
+ 1
+ );
+
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_G,
+ '01、2对对对'
+ ),
+ 01
+ );
+
+ $this->assertNotEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_G,
+ '23、我是Marco小哥哥'
+ ),
+ 24
+ );
+ }
+
+ /**
+ * testValidationModelH
+ *
+ * @throws \Exception
+ * @test
+ */
+ public function testValidationModelH()
+ {
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_H,
+ '我爱Marco老师小册10 :'
+ ),
+ 10
+ );
+
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_H,
+ '我爱Marco老师小册1 ： 阳光鱼'
+ ),
+ 1
+ );
+
+ $this->assertNotEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_H,
+ '我爱Marco老师小册1 ： 阳光鱼'
+ ),
+ 122
+ );
+ }
+
+ /**
+ * testValidationModelI
+ *
+ * @throws \Exception
+ */
+ public function testValidationModelI()
+ {
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_I,
+ '识字一 01 十'
+ ),
+ '01'
+ );
+
+ $this->assertEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_I,
+ '狮子 03卧槽'
+ ),
+ '03'
+ );
+
+ $this->assertNotEquals(
+ $this->chineseObj->extractModel(
+ ChineseTextNumberSort::MODEL_REGULAR_I,
+ '狮子 03卧槽'
+ ),
+ '04'
+ );
+ }
+}
diff --git a/tests/Sort/ChineseTextNumberSortModelTest.php b/tests/Sort/ChineseTextNumberSortModelTest.php
new file mode 100644
index 0000000..6b18e90
--- /dev/null
+++ b/tests/Sort/ChineseTextNumberSortModelTest.php
@@ -0,0 +1,301 @@
+chineseObj = new ChineseTextNumberSort();
+ }
+
+ /**
+ * testValidationModelA
+ *
+ * @test
+ */
+ public function testValidationModelA()
+ {
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_A,
+ '第二章 我是Marco小哥哥'
+ )
+ );
+
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_A,
+ '第一节 我是Marco小哥哥'
+ )
+ );
+
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_A,
+ '第二单元 我是Marco小哥哥'
+ )
+ );
+
+ $this->assertNotTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_A,
+ '第一章我是Marco小哥哥'
+ )
+ );
+ }
+
+ /**
+ * testValidationModelB
+ *
+ * @test
+ */
+ public function testValidationModelB()
+ {
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_B,
+ '01我是Marco小哥哥'
+ )
+ );
+
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_B,
+ '12我是Marco小哥哥'
+ )
+ );
+
+ $this->assertNotTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_B,
+ '第一章我是Marco小哥哥'
+ )
+ );
+ }
+
+ /**
+ * testValidationModelC
+ *
+ * @test
+ */
+ public function testValidationModelC()
+ {
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_C,
+ '1 我是Marco小哥哥'
+ )
+ );
+
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_C,
+ '22 我是Marco小哥哥'
+ )
+ );
+
+ $this->assertNotTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_C,
+ '22我是Marco小哥哥'
+ )
+ );
+ }
+
+ /**
+ * testValidationModelD
+ *
+ * @test
+ */
+ public function testValidationModelD()
+ {
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_D,
+ '1页-我是Marco小哥哥'
+ )
+ );
+
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_D,
+ '1页-+我是Marco小哥哥'
+ )
+ );
+
+ $this->assertNotTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_D,
+ '22我是Marco小哥哥'
+ )
+ );
+ }
+
+ /**
+ * testValidationModelD
+ *
+ * @test
+ */
+ public function testValidationModelE()
+ {
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_E,
+ '1-'
+ )
+ );
+
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_E,
+ '1-+我是Marco小哥哥'
+ )
+ );
+
+ $this->assertNotTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_E,
+ '22我是Marco小哥哥'
+ )
+ );
+ }
+
+
+ /**
+ * MODEL_REGULAR_F
+ *
+ * @test
+ */
+ public function testValidationModelF()
+ {
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_F,
+ '1 但是'
+ )
+ );
+
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_F,
+ '1 2对对对'
+ )
+ );
+
+ $this->assertNotTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_F,
+ '22我是Marco小哥哥'
+ )
+ );
+ }
+
+ /**
+ * testValidationModelG
+ *
+ * @test
+ */
+ public function testValidationModelG()
+ {
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_G,
+ '1、、'
+ )
+ );
+
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_G,
+ '01、2对对对'
+ )
+ );
+
+ $this->assertNotTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_G,
+ '22我是Marco小哥哥'
+ )
+ );
+ }
+
+ /**
+ * testValidationModelG
+ *
+ * @test
+ */
+ public function testValidationModelH()
+ {
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_H,
+ '我爱Marco老师小册10 :'
+ )
+ );
+
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_H,
+ '我爱Marco老师小册1 ： 阳光鱼'
+ )
+ );
+
+ $this->assertNotTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_H,
+ '22我是Marco小哥哥'
+ )
+ );
+ }
+
+ /**
+ * testValidationModelG
+ *
+ * @test
+ */
+ public function testValidationModelI()
+ {
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_I,
+ '识字一 01 十'
+ )
+ );
+
+ $this->assertTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_I,
+ '狮子 03卧槽'
+ )
+ );
+
+ $this->assertNotTrue(
+ $this->chineseObj->regularModel(
+ ChineseTextNumberSort::MODEL_REGULAR_I,
+ '22我是Marco小哥哥'
+ )
+ );
+ }
+}
diff --git a/tests/Sort/ChineseTextNumberSortTest.php b/tests/Sort/ChineseTextNumberSortTest.php
new file mode 100644
index 0000000..7a50ef7
--- /dev/null
+++ b/tests/Sort/ChineseTextNumberSortTest.php
@@ -0,0 +1,246 @@
+chineseObj = new ChineseTextNumberSort();
+ }
+
+ /**
+ * testChineseTextListSorter
+ */
+ public function testChineseTextListSorter()
+ {
+ $this->assertArraySubset(
+ $this->chineseObj->chineseTextListSorter(
+ array (
+ '第五章 我是Marco小哥哥',
+ '第一章 我是Marco小哥哥',
+ '第三章 我是Marco小哥哥',
+ '第三章 我是Marco小哥哥',
+ '第二章 我是Marco小哥哥',
+ )),
+ array (
+ '第一章 我是Marco小哥哥',
+ '第二章 我是Marco小哥哥',
+ '第三章 我是Marco小哥哥',
+ '第三章 我是Marco小哥哥',
+ '第五章 我是Marco小哥哥',
+ )
+ );
+
+ $this->assertArraySubset(
+ $this->chineseObj->chineseTextListSorter(
+ array (
+ '05我是Marco小哥哥',
+ '03我是Marco小哥哥',
+ '02我是Marco小哥哥',
+ '04我是Marco小哥哥',
+ '01我是Marco小哥哥',
+ )),
+ array (
+ '01我是Marco小哥哥',
+ '02我是Marco小哥哥',
+ '03我是Marco小哥哥',
+ '04我是Marco小哥哥',
+ '05我是Marco小哥哥',
+ )
+ );
+
+ $this->assertArraySubset(
+ $this->chineseObj->chineseTextListSorter(
+ array (
+ '6页-我是Marco小哥哥',
+ '2页-我是Marco小哥哥',
+ '3页-我是Marco小哥哥',
+ '4页-我是Marco小哥哥',
+ '5页-我是Marco小哥哥',
+ '1页-我是Marco小哥哥',
+ )),
+ array (
+ '1页-我是Marco小哥哥',
+ '2页-我是Marco小哥哥',
+ '3页-我是Marco小哥哥',
+ '4页-我是Marco小哥哥',
+ '5页-我是Marco小哥哥',
+ '6页-我是Marco小哥哥',
+ )
+ );
+
+ $this->assertArraySubset(
+ $this->chineseObj->chineseTextListSorter(
+ array (
+ '我爱Marco老师小册6 :',
+ '我爱Marco老师小册2 :',
+ '我爱Marco老师小册3 :',
+ '我爱Marco老师小册4 :',
+ '我爱Marco老师小册5 :',
+ '我爱Marco老师小册1 :',
+ '我爱Marco老师小册7 :',
+ )),
+ array (
+ '我爱Marco老师小册1 :',
+ '我爱Marco老师小册2 :',
+ '我爱Marco老师小册3 :',
+ '我爱Marco老师小册4 :',
+ '我爱Marco老师小册5 :',
+ '我爱Marco老师小册6 :',
+ '我爱Marco老师小册7 :',
+ )
+ );
+
+ $this->assertArraySubset(
+ $this->chineseObj->chineseTextListSorter(
+ array (
+ '6、2对对对',
+ '2、2对对对',
+ '4、2对对对',
+ '3、2对对对',
+ '5、2对对对',
+ '1、2对对对',
+ )),
+ array (
+ '1、2对对对',
+ '2、2对对对',
+ '3、2对对对',
+ '4、2对对对',
+ '5、2对对对',
+ '6、2对对对',
+ )
+ );
+ }
+
+
+ /**
+ * testTextAnalysis
+ */
+ public function testTextAnalysis()
+ {
+ $this->assertEquals(
+ $this->chineseObj->textAnalysis('第二章 我是Marco小哥哥'),
+ 2
+ );
+ $this->assertEquals(
+ $this->chineseObj->textAnalysis('01我是Marco小哥哥'),
+ 1
+ );
+ $this->assertEquals(
+ $this->chineseObj->textAnalysis('1 我是Marco小哥哥'),
+ 1
+ );
+ $this->assertEquals(
+ $this->chineseObj->textAnalysis('1页-我是Marco小哥哥'),
+ 1
+ );
+ $this->assertEquals(
+ $this->chineseObj->textAnalysis('2-+我是Marco小哥哥'),
+ 2
+ );
+ $this->assertEquals(
+ $this->chineseObj->textAnalysis('1 2对对对'),
+ 1
+ );
+ $this->assertEquals(
+ $this->chineseObj->textAnalysis('1、2对对对'),
+ 1
+ );
+ $this->assertEquals(
+ $this->chineseObj->textAnalysis('我爱Marco老师小册10 :'),
+ 10
+ );
+ $this->assertNotEquals(
+ $this->chineseObj->textAnalysis('我爱Marco老师小册10 :'),
+ 12
+ );
+ }
+
+
+ /**
+ * testModelAnalysis
+ *
+ * @throws \ReflectionException
+ */
+ public function testModelAnalysis()
+ {
+ $this->assertEquals(
+ $this->chineseObj->modelAnalysis('第二章 我是Marco小哥哥'),
+ ChineseTextNumberSort::MODEL_REGULAR_A
+ );
+ $this->assertEquals(
+ $this->chineseObj->modelAnalysis('01我是Marco小哥哥'),
+ ChineseTextNumberSort::MODEL_REGULAR_B
+ );
+
+ $this->assertEquals(
+ $this->chineseObj->modelAnalysis('1 我是Marco小哥哥'),
+ ChineseTextNumberSort::MODEL_REGULAR_F
+ );
+
+ $this->assertEquals(
+ $this->chineseObj->modelAnalysis('1页-我是Marco小哥哥'),
+ ChineseTextNumberSort::MODEL_REGULAR_D
+ );
+ $this->assertEquals(
+ $this->chineseObj->modelAnalysis('2-+我是Marco小哥哥'),
+ ChineseTextNumberSort::MODEL_REGULAR_E
+ );
+ $this->assertEquals(
+ $this->chineseObj->modelAnalysis('1 2对对对'),
+ ChineseTextNumberSort::MODEL_REGULAR_F
+ );
+ $this->assertEquals(
+ $this->chineseObj->modelAnalysis('1、2对对对'),
+ ChineseTextNumberSort::MODEL_REGULAR_G
+ );
+ $this->assertEquals(
+ $this->chineseObj->modelAnalysis('我爱Marco老师小册10 :'),
+ ChineseTextNumberSort::MODEL_REGULAR_H
+ );
+ $this->assertNotEquals(
+ $this->chineseObj->modelAnalysis('我爱Marco老师小册10 :'),
+ ChineseTextNumberSort::MODEL_REGULAR_G
+ );
+ }
+
+ /**
+ * description
+ *
+ * @test
+ */
+ /**
+ * description
+ *
+ * @throws \ReflectionException
+ * @test
+ */
+ public function testAnalysisText()
+ {
+ var_dump($this->chineseObj->getAllModelRegular());
+ die;
+ }
+
+}