Initial commit

Author: TonyLianLong

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1 @@
+.DS_Store

Chapter1/Chapter1.md

@@ -0,0 +1,87 @@
+<notice>教程读者请不要直接阅读本文件，因为诸多功能在此无法正常使用，请移步至[程谱 coderecipe.cn](https://coderecipe.cn/learn/5)学习完整教程。如果您喜欢我们的教程，请在右上角给我们一个“Star”，谢谢您的支持！</notice>
+递归
+======
+
+从这里开始学习吧！💖
+
+递归方法
+------
+**递归方法**（recursion methods）简单地说就是直接或间接地调用自己的方法。比如这就是一个最简单的递归方法：
+```java
+public void recursion()
+{
+	recursion();
+} 
+```
+
+千万别运行这个函数！因为如果我们主动调用了`recursion()`，然后在这个方法里`recursion()`会再调用，然后又再次调用……一直这样下去，导致电脑卡住，最后还会导致Java报错（实际上是一个叫做“栈”的结构存不下了），程序被迫退出。
+
+递归的最简形式
+-----
+
+要理解递归，我们要先理解**栈**（stack）这个概念。栈就像烤串的签，我们往里插东西（叫压栈或者入栈，push），先插进去的在下，后插进去的在上，并且最后拿（叫出栈，pop）的时候，只有上面拿出来了才能拿出下面的。在Java里，每调用一个函数都是往栈里面存储了一个新的状态，就像往签上插了东西一样。
+
+在Java里，每调用一个函数都会先暂停当前函数的状态，然后用一个新的状态来从头执行这个函数。这两个函数中定义的变量可以是不相同的。
+
+知道了栈的定义，接下来让我们来看一个递归的小例子：
+
+<lab lang="java" parameters="filename=Hello.java">
+<notice>练习环境在此无法显示，请移步至[程谱 coderecipe.cn](https://coderecipe.cn/learn/5)查看。</notice>
+public class Hello {
+  public static void main(String[] args) {
+      recursion(3);
+  }
+  public static void recursion(int val) {
+    System.out.println(val);
+    if(val>0){
+      recursion(val-1);
+    }
+  } 
+}
+</lab>
+
+运行以后我们会发现输出了3、2、1和0。这是因为首先我们调用了`recursion`函数并给了参数3，根据上面的说明，在栈上压入了`recursion`这个状态，并且里面的`val`是3，然后输出3。然后又调用了一次`recursion`，参数为`2`，又压栈，输出2。一直这样下去，直到最后状态中的`val`值为0，`if`语句不执行为止。然后我们碰到了函数的末尾，释放出来，最后结束，依次反过来释放三个栈中的状态。
+
+除了上面的那个会一直运行下去的递归函数，每个递归函数都有两个部分：
+1. 一个基本的条件来终止递归的继续调用
+2. 非基本条件使递归向基本条件运行
+也就是说，递归的最终目的是遇到那个我们需要的“基本条件”，然后就不继续递归了。
+	
+在上面的例子中，让`val`不再大于0就是我们所需要达到的目的，达到目的之后我们就会终止调用本身了，我们在这个方法的结尾调用了`recursion`，后面就没有内容了，这样的递归就是结尾递归（tail recursion）。
+
+分析递归函数
+------
+比如我们有如下的一个递归函数：
+```java
+public static int fib(int n){
+if(n == 1||n == 2){
+  return 1;
+} else {
+  return fib(n - 1) + fib(n - 2);
+}
+```
+于是我们就要开始展开分析工作了，首先我们可以发现，在n == 1或n == 2的时候这个方法会返回1，其他时候会返回fib(n - 1) + fib(n - 2)，也就可以写成如下函数（n是正整数）：
+![Pic1](Pic1.png)
+然后我们开始计算函数的返回值，从fib(5)开始，通过对数学函数的分析我们可以画出如下的分析图。
+![Pic2](Pic2.png)
+因为每一个函数都会调用两个函数，所以树状分析图看起来会比栈图简洁明了，从下往上，把下面的两个小树枝（子节点）的数值计算出来，相加就得到上面的数值，最后就能计算出fib(5)了，结果是5。
+
+递归的注意事项
+------
+从上面的分析图可以看出，函数`fib`每一次递归都需要调用两个子函数，而这两个子函数又会调用其它函数。刚才我们说过，函数调用的时候需要使用栈来存储当前函数和调用的函数的状态，因此在有大量函数调用的情况下，就要频繁访问栈来存取函数的状态，这样就会消耗掉大量的时间。因此如果有简单的循环能解决这个问题，就尽量不要使用递归来解决。另外递归还有如下需要注意的地方：
+1. 在递归中尽量不要使用过多局部变量、局部数组，因为在函数调用时计算机要再次初始化局部变量、局部数组，而这样会消耗大量时间
+2. 只在递归可以大量简化代码的时候使用，如果能用循环等简单解决就不要使用递归
+3. 递归在以下两个方面很有用：分支树的处理和二进制等分支搜索
+4. 可以使用帮助方法（helper method）来调用递归，这样可以使代码更简洁
+
+小练习
+------
+让我们来练习一下我们刚学习的知识吧。
+<lab lang="java" parameters="filename=Hello.java">
+<notice>练习环境在此无法显示，请移步至[程谱 coderecipe.cn](https://coderecipe.cn/learn/5)查看。</notice>
+public class Hello {
+  public static void main(String[] args) {
+      // 在这里输入代码
+  }
+}
+</lab>

Chapter1/Pic1.png

@@ -0,0 +1,136 @@
+<notice>教程读者请不要直接阅读本文件，因为诸多功能在此无法正常使用，请移步至[程谱 coderecipe.cn](https://coderecipe.cn/learn/5)学习完整教程。如果您喜欢我们的教程，请在右上角给我们一个“Star”，谢谢您的支持！</notice>
+排序
+======
+
+在这一章，我们要学习几种在计算机算法中极其重要的排序算法，让我们这就开始吧！💖
+
+所谓的**排序**（sorting），就是让一个数组里的数，按照从大到小或者从小到大排列。下面是几种常用的排序算法：
+
+选择排序
+------
+**选择排序**（selection sort）就是首先在数组中找到最小的一个值放在第一位，然后再找次小的放到第二位，以此类推一直到n-1次排序后，就能够得到一个递增的数列了。
+
+以下是选择排序在Java里的一种实现，大家可以在纸上用一个实验数据来演算一遍：
+```java
+/*
+    @param elements an array containing the items to be sorted.
+    
+    Postcondition: elements contains its original items and items 
+                   in elements are sorted in ascending order.
+*/
+public static void selectionSort(int[] elements){
+    for (int j = 0; j <elements.length){
+        int minIndex = j;
+        for (int k = j+1; k < elements .length;k++){
+            if (elements[k]<elements[minIndex])
+                minIndex = k;
+        }
+        int temp = elements[j];
+        elements[j]= elements[minIndex];
+        elements[minIndex] = temp;
+    }
+}
+```
+
+插入排序
+-----
+**插入排序**（insertion sort）的原本是一个排列好的数组插入一个数组。当我们把第一个数elements[0]看成一个数组时，我们就能够对整个数组进行插入排列。我们是将要插入的数组的第一个数拿出来，一个一个往前推，看哪个合适插在哪里。之后依次类推。
+e.g.蓝色是我们已经排好的数组，红色为未排好的。
+![Pic1](Pic1.png)
+```java
+/*
+    @param elements an array containing the items to be sorted.
+    
+    Postcondition: elements contains its original items and items 
+                   in elements are sorted in ascending order.
+*/
+public static void insertionSort(int[] elements){
+    for(int j = 1; j< elements.length; j++){
+        int temp = elements[j];
+        int possibleIndex = j;
+        while(possibleIndex > 0 && temp < elements[possibleIndex - 1]){
+            elements[possibleIndex] = elements[possibleIndex - 1];
+            possibleIndex --;
+        }
+        elements[possibleIndex] = temp;
+    }
+}
+```
+
+归并排序
+------
+**归并排序** （merge esort）是一种递归排序，它将数组拆成几个小的单元，之后对小的单元进行排序。然后再把小的单元组合在一起再进行排序。
+它的缺点十分明显：它需要储存一个跟原始数组一样长的数据。它还有个显著特点，就是排序时间不受原本数据排序的影响，不论是最好的情况还是最坏的情况。
+
+```java
+public static void mergeSort(int[] elements){
+    int n = elements.length;
+    int[] temp = new int[n];
+    mergeSortHelper(elements,0,n-1,temp);
+}
+
+/*
+* @param elements, an array containing the items to be sorted.
+* @param from, the begining index of the items in elements to be sorted.
+* @param to, the ending index of the itens in elements to be sorted.
+* @param temp, a temporary array to use during the merge process.
+*   Precondition: 
+*       (elements.length == 0 || 
+*           0<= from <= to <= elements.length &&
+*           elements.length == temp.length)
+*   Postcondition:
+*       elements contains its original items and the items in 
+*       elements[from]...<= elements[to] are sorted in ascending order
+*/
+private static void mergeSortHelper(int[] elements, int from, int to, int[] temp){
+    if (from < to){
+        int middle = (from + to)/2;
+        mergeSortHelper(elements, from , middle, temp);
+        mergeSortHelper(elements, middle+1, to, temp);
+        merge(elements, from, middle,to,temp);
+    }
+}
+
+private static void merge(int[] elements, int from, int mid, int to, int[] temp){
+    int i = from;
+    int j = mid +1;
+    int k = from;
+    
+    while(i<=mid && j <=to){
+        if(elements[i]<elements[j]){
+            temp[k] = elements[i];
+            i++;
+        }
+        else{
+            temp[k] = elements[j];
+            j++
+        }
+        k++;
+    }
+    while (i <= mid){
+        temp[k] = elements[i];
+        i++;
+        k++;
+    }
+    
+    while(j<=to){
+        temp[k] = elements[j];
+        j++;
+        k++
+    }
+    
+    for (k = from; k<=to; k++)
+        elements[k] = temp[k];
+}
+```
+小练习
+------
+让我们来练习一下我们刚学习的知识吧。
+<lab lang="java" parameters="filename=Hello.java">
+<notice>练习环境在此无法显示，请移步至[程谱 coderecipe.cn](https://coderecipe.cn/learn/5)查看。</notice>
+public class Hello {
+  public static void main(String[] args) {
+      // 在这里输入代码
+  }
+}
+</lab>

Chapter1/Pic2.png

@@ -0,0 +1,62 @@
+<notice>教程读者请不要直接阅读本文件，因为诸多功能在此无法正常使用，请移步至[程谱 coderecipe.cn](https://coderecipe.cn/learn/5)学习完整教程。如果您喜欢我们的教程，请在右上角给我们一个“Star”，谢谢您的支持！</notice>
+搜索
+======
+**搜索**（searching）在这里指的是从数组中找出指定的内容所在的位置。
+
+顺序搜索
+------
+**顺序搜索**（sequential searching）就是把数组从头到尾搜索一遍，直到找到所要找的元素或者搜索完所有元素为止。
+
+以下是顺序搜索在Java里的一种实现：
+```java
+/***
+    @param elements an array containing the items to be searched
+    @param target the item to be found in element.
+    @return an index of target in elements if foun; -1 otherwise;
+    ***/
+public static  int sequentialSerach(int[] elements, int target){
+    for (int j = 0; j< elements.length; j++)
+        if (elements[j == target]) //String uses equals()
+            return j;
+    return -1;
+}
+```
+
+二叉搜索
+-----
+**二叉搜索**（binary search）是一种高效率的检索方法。将搜索范围逐渐一步一步二分（分为两部分）减小到只剩下一个。
+
+其思想就是我们查看一个数组中间的内容，如果比我们想要的大，那么我就在左边搜索，
+如果比我们想要的小，我们就在右边搜索。然后在缩小后的搜索范围查看判断后数组中间的数，就这样依次进行下去，直到找到结果或者全部搜索完成。不过，利用二进制搜索的数组必须是排列好的，否则比如先排序才行。
+
+```java
+/*
+    @param elements an array containing the items to be sorted.
+    
+    Postcondition: elements contains its original items and items 
+                   in elements are sorted in ascending order.
+*/
+public static void insertionSort(int[] elements){
+    for(int j = 1; j< elements.length; j++){
+        int temp = elements[j];
+        int possibleIndex = j;
+        while(possibleIndex > 0 && temp < elements[possibleIndex - 1]){
+            elements[possibleIndex] = elements[possibleIndex - 1];
+            possibleIndex --;
+        }
+        elements[possibleIndex] = temp;
+    }
+}
+```
+
+小练习
+------
+让我们来练习一下我们刚学习的知识吧。
+<lab lang="java" parameters="filename=Hello.java">
+<notice>练习环境在此无法显示，请移步至[程谱 coderecipe.cn](https://coderecipe.cn/learn/5)查看。</notice>
+public class Hello {
+  public static void main(String[] args) {
+      // 在这里输入代码
+  }
+}
+</lab>

Chapter2/Chapter2.md

@@ -0,0 +1,38 @@
+<notice>教程读者请不要直接阅读本文件，因为诸多功能在此无法正常使用，请移步至[程谱 coderecipe.cn](https://coderecipe.cn/learn/5)学习完整教程。如果您喜欢我们的教程，请在右上角给我们一个“Star”，谢谢您的支持！</notice>
+
+初入编程
+======
+
+有的时候我们想知道这个小人在哪里，这样怎么办呢？
+
+条件块
+------
+拖动左边的条件块，就可以产生条件效果。
+
+其他条件块
+------
+拖动左边的条件块，就可以产生条件效果。
+```java
+    if (this.successful) {
+      // We'll succeed
+    } else {
+      // No! We won't reach this
+    }
+```
+Blocks实验室：
+<lab lang="blocks" parameters="logic=false&math=false&loops=false&lists=false&color=false&variables=false&functions=false&text=false">
+  <notice>练习环境在此无法显示，请移步至[程谱 coderecipe.cn](https://coderecipe.cn/learn/5)查看。</notice>
+</lab>
+
+Java实验室：
+<lab lang="java" parameters="filename=Hello.java">
+<notice>练习环境在此无法显示，请移步至[程谱 coderecipe.cn](https://coderecipe.cn/learn/5)查看。</notice>
+public class Hello {
+  public static void main(String[] args) {
+      System.out.println("Hello Java!");
+  }
+}
+</lab>
+
+下面的内容要按一下才会显示：
+<cr type="hidden"><notice>隐藏内容功能在此无法正常显示，请移步至[程谱 coderecipe.cn](https://coderecipe.cn/learn/5)查看。</notice>答案已经被显示出来了</cr>

Chapter2/Pic1.png

@@ -0,0 +1,47 @@
+# Java算法基础教程 by 程谱 Code Recipe
+
+** 如果你喜欢我们的教程，那么就点击右上角的“Star”给我们贡献一份力量吧~ **
+
+欢迎来到程谱社区！😁 我们是一群留学生，致力于搭建一个系统而又不枯燥的零基础入门编程学习平台。希望大家能多多支持我们，如果发现我们的不足之处也欢迎联系我们~
+
+这个教程给初学编程者使用，是大多数程谱学员学完[Java Array和ArrayList教程](https://coderecipe.cn/learn/4)以后的教程。这个教程主要配合Java介绍编程的基础知识概念，对学习和备考AP以及入门计算机编程都会很有帮助。
+
+最后，谢谢大家对程谱的支持和厚爱~💖
+
+P.S: 教程读者请不要直接阅读本项目的文件，因为诸多功能在此无法正常使用，请移步至[程谱官网](https://coderecipe.cn/learn/5)免费学习这个教程的完整版哦。
+
+目录
+------
+1. 递归
+  * 递归方法
+  * 递归的最简形式
+  * 分析递归函数
+  * 递归的注意事项
+  * 小练习
+2. 排序
+  * 选择排序
+  * 插入排序
+  * 归并排序
+  * 小练习
+3. 搜索
+  * 顺序搜索
+  * 二叉搜索
+  * 小练习
+
+看完目录以后，如果你想学习本教程，那么就点击[这里](https://coderecipe.cn/learn/5)里开始吧。
+
+贡献
+------
+如果你发现教程有错别字或者有不妥之处，欢迎提交issues或者pull requests，成为本教程的contributor，程谱项目组及本教程作者感谢您的支持！
+
+使用本教程
+------
+本项目为程谱项目组编写，我们推荐教师直接使用程谱网站来作为教学工具。
+
+为了搭建一个友好互助的社区，我们同样也允许您以**在醒目处保留“本教程来源于程谱”并链接到[程谱](https://coderecipe.cn/learn/5)的方式**以**非商业用途**使用本教程。其他使用方式请[联系我们](mailto:[email protected])获得许可。
+
+一切对本教程的最终解释权归程谱所有。
+
+致谢
+------
+本教程参考了AP CS A手册的部分内容，在此向作者Tony和刘淼致谢。