atom.xml

<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <id>https://carrollwang.github.io/</id>
    <title>我爱你啊</title>
    <updated>2019-11-18T14:16:01.729Z</updated>
    <generator>https://github.com/jpmonette/feed</generator>
    <link rel="alternate" href="https://carrollwang.github.io/"/>
    <link rel="self" href="https://carrollwang.github.io//atom.xml"/>
    <subtitle>一生所求，爱与自由.</subtitle>
    <logo>https://carrollwang.github.io//images/avatar.png</logo>
    <icon>https://carrollwang.github.io//favicon.ico</icon>
    <rights>All rights reserved 2019, 我爱你啊</rights>
    <entry>
        <title type="html"><![CDATA[剑指offer （2）数组中的重复数字]]></title>
        <id>https://carrollwang.github.io//post/jian-zhi-offer-shu-zu-zhong-de-chong-fu-shu-zi</id>
        <link href="https://carrollwang.github.io//post/jian-zhi-offer-shu-zu-zhong-de-chong-fu-shu-zi">
        </link>
        <updated>2019-11-17T14:56:15.000Z</updated>
        <content type="html"><![CDATA[<p>题目描述<br>
在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。</p>
<blockquote>
<p>1.利用特性的方法<br>
分析：数组的长度为 n 且所有数字都在 0 到 n-1 的范围内，我们可以将每次遇到的数进行&quot;归位&quot;，当某个数发现自己的&quot;位置&quot;被相同的数占了，则出现重复。<br>
扫描整个数组，当扫描到下标为 i 的数字时，首先比较该数字（m）是否等于 i，如果是，则接着扫描下一个数字；如果不是，则拿 m 与第 m 个数比较。如果 m 与第 m 个数相等，则说明出现重复了；如果 m 与第 m 个数不相等，则将 m 与第 m 个数交换，将 m &quot;归位&quot;，再重复比较交换的过程，直到发现重复的数</p>
</blockquote>
<p>举个栗子：<br>
以数组 {2,3,1,0,2,5,3} 为例<br>
当 i = 0 时，nums[i] = 2 != i，判断 nums[i] 不等于 nums[nums[i]]，交换 nums[i] 和 nums[nums[i]]，交换后数组为：{1,3,2,0,2,5,3}<br>
此时 i = 0，nums[i] = 1 != i，判断 nums[i] 不等于 nums[nums[i]]，交换 nums[i] 和 nums[nums[i]]，交换后数组为：{3,1,2,0,2,5,3}<br>
此时 i = 0，nums[i] = 3 != i，判断 nums[i] 不等于 nums[nums[i]]，交换 nums[i] 和 nums[nums[i]]，交换后数组为：{0,1,2,3,2,5,3}<br>
此时 i = 0，nums[i] = 0 = i，继续下一组<br>
当 i = 1，nums[i] = 1 = i，继续下一组<br>
当 i = 2，nums[i] = 2 = i，继续下一组<br>
当 i = 3，nums[i] = 3 = i，继续下一组<br>
当 i = 4，nums[i] = 2 != i，判断 nums[i] 等于 nums[nums[i]]，出现重复，赋值返回</p>
<pre><code>代码：
</code></pre>
<pre><code class="language-java">import java.util.*;
public class Solution {
    public boolean duplicate(int nums[],int length,int [] duplication) {
        if(nums == null || length == 0){
            return false;
        }
        for(int i=0;i&lt;length;i++){
            while(nums[i] != i){
                if(nums[i] == nums[nums[i]]){
                    duplication[0] = nums[i];
                    return true;
                }
                // swap
                int tmp = nums[i];
                nums[i] = nums[tmp];
                nums[tmp] = tmp;
            }
        }
        return false;
    }
}    
</code></pre>
<p>复杂度：<br>
时间复杂度：O(n)<br>
空间复杂度：O(1)</p>
<blockquote>
<p>2.排序<br>
分析：将输入的数组排序，判断相邻位置是否存在相同数字，如果存在，对duplication赋值返回<br>
代码：</p>
</blockquote>
<pre><code class="language-java">import java.util.*;
public class Solution {
    public boolean duplicate(int numbers[],int length,int [] duplication) {
        if(numbers == null || length == 0){
            return false;
        }
        Arrays.sort(numbers);
        for(int i=0;i&lt;length-1;i++){
            if(numbers[i] == numbers[i+1]){
                duplication[0] = numbers[i];
                return true;
            }
        }
        return false;
    }
}
</code></pre>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[剑指Offer(1)二维数组中的查找]]></title>
        <id>https://carrollwang.github.io//post/jian-zhi-offer1er-wei-shu-zu-zhong-de-cha-zhao</id>
        <link href="https://carrollwang.github.io//post/jian-zhi-offer1er-wei-shu-zu-zhong-de-cha-zhao">
        </link>
        <updated>2019-11-16T07:32:05.000Z</updated>
        <content type="html"><![CDATA[<p>题目描述:<br>
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。</p>
<blockquote>
<p>1.暴力解法</p>
</blockquote>
<pre><code class="language-java">   public class Solution{
   public boolean Find(int target,int arr [][] ){
       for(int i =0 ;i &lt; arr.length ; i++){
           for (int j = 0 ;j&lt;arr[0].length ; j++){
               if(arr[i][j] == target){
                   return true;
               }
           }
       }
       return false;
   }
}
</code></pre>
<blockquote>
<p>2.左上法</p>
</blockquote>
<ol>
<li>分析<br>
利用该二维数组的性质：</li>
</ol>
<p>每一行都按照从左到右递增的顺序排序，<br>
每一列都按照从上到下递增的顺序排序<br>
改变个说法，即对于左下角的值 m，m 是该行最小的数，是该列最大的数<br>
每次将 m 和目标值 target 比较：</p>
<p>当 m &lt; target，由于 m 已经是该行最大的元素，想要更大只有从列考虑，取值右移一位<br>
当 m &gt; target，由于 m 已经是该列最小的元素，想要更小只有从行考虑，取值上移一位<br>
当 m = target，找到该值，返回 true<br>
用某行最小或某列最大与 target 比较，每次可剔除一整行或一整列<br>
2. 复杂度<br>
时间复杂度：O(行高 + 列宽)O(行高+列宽)<br>
空间复杂度：O(1)O(1)</p>
<pre><code class="language-java">public class Solution {
    public boolean Find(int target, int arr[][]) {
        int rows = arr.length;
        if (rows == 0) {
            return false;
        }
        int cols = arr[0].length;
        if (cols == 0) {
            return false;
        }
        //col是列 row 是行；
        int row = rows - 1;
        int col = 0;
        while (row &gt;= 0 &amp;&amp; col &lt;cols){
            if (arr[row][col] &lt; target) {
                col++;
            } else if (arr[row][col] &gt;target) {
                row--;
            } else {
                return true;
            }
        }
        return false;
    }
}
</code></pre>
<blockquote>
<p>3.右上法</p>
</blockquote>
<pre><code class="language-java">public class Solution {
    public boolean Find(int target, int [][] array) {
        int rows = array.length;
        if(rows == 0){
            return false;
        }
        int cols = array[0].length;
        if(cols == 0){
            return false;
        }
        // 右上
        int row = 0;   //注意
        int col = cols-1;    //注意
        while(row&lt;rows &amp;&amp; col&gt;=0){    //注意
            if(array[row][col] &lt; target){
                row++;        //注意
            }else if(array[row][col] &gt; target){
                col--;      //注意
            }else{
                return true;
            }
        }
        return false;
    }
}
</code></pre>
<blockquote>
<blockquote>
<p>注意：1.为什么14行的col &lt;cols 不能写成 col &lt;= cols<br>
答：会出现越界问题</p>
</blockquote>
</blockquote>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[牛客网算法基础班（04）]]></title>
        <id>https://carrollwang.github.io//post/niu-ke-wang-suan-fa-ji-chu-ban-04</id>
        <link href="https://carrollwang.github.io//post/niu-ke-wang-suan-fa-ji-chu-ban-04">
        </link>
        <updated>2019-11-16T04:37:12.000Z</updated>
        <content type="html"><![CDATA[<blockquote>
<p>题目一：实现二叉树的先序、中序、后序遍历，包括递归方式和非递归</p>
</blockquote>
<pre><code class="language-java">System.out.println();
</code></pre>
<blockquote>
<p>题目二：如何直观的打印一颗二叉树</p>
</blockquote>
<pre><code class="language-java">System.out.println();
</code></pre>
<blockquote>
<p>题目三：在二叉树中找到一个节点的后继节点【题目】 现在有一种新的二叉树节点类型如下：public class Node { public int value; public Node left;public Node right; public Node parent;public Node(int data) { this.value = data; }}该结构比普通二叉树节点结构多了一个指向父节点的parent指针。假设有一 棵Node类型的节点组成的二叉树，树中每个节点的parent指针都正确地指向 自己的父节点，头节点的parent指向null。只给一个在二叉树中的某个节点 node，请实现返回node的后继节点的函数。在二叉树的中序遍历的序列中node的下一个节点叫作node的后继节点</p>
</blockquote>
<pre><code class="language-java">System.out.println();
</code></pre>
<blockquote>
<p>题目四：介绍二叉树的序列化和反序列化</p>
</blockquote>
<pre><code class="language-java">System.out.println();
</code></pre>
<blockquote>
<p>题目五：折纸问题<br>
【题目】 请把一段纸条竖着放在桌子上，然后从纸条的下边向<br>
上方对折1次，压出折痕后展开。此时 折痕是凹下去的，即折痕<br>
突起的方向指向纸条的背面。如果从纸条的下边向上方连续对折<br>
2 次，压出折痕后展开，此时有三条折痕，从上到下依次是下折<br>
痕、下折痕和上折痕。<br>
给定一 个输入参数N，代表纸条都从下边向上方连续对折N次，<br>
请从上到下打印所有折痕的方向。 例如：N=1时，打印： down<br>
N=2时，打印： down down up</p>
</blockquote>
<pre><code class="language-java">System.out.println();
</code></pre>
<blockquote>
<p>题目六：判断一棵二叉树是否是平衡二叉树.</p>
</blockquote>
<pre><code class="language-java">System.out.println();
</code></pre>
<blockquote>
<p>题目七：判断一棵树是否是搜索二叉树、判断一棵树是否是完全二叉树。</p>
</blockquote>
<pre><code class="language-java">System.out.println();
</code></pre>
<blockquote>
<p>题目八：已知一棵完全二叉树，求其节点的个数要求：时间复杂度低于O(N)，N为这棵树的节点个数</p>
</blockquote>
<pre><code class="language-java">System.out.println();
</code></pre>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[牛客网算法基础班（03）]]></title>
        <id>https://carrollwang.github.io//post/niu-ke-wang-suan-fa-ji-chu-ban-03</id>
        <link href="https://carrollwang.github.io//post/niu-ke-wang-suan-fa-ji-chu-ban-03">
        </link>
        <updated>2019-11-15T06:52:31.000Z</updated>
        <content type="html"><![CDATA[<blockquote>
<p>题目一：用数组结构实现大小固定的队列</p>
</blockquote>
<pre><code class="language-java">    System.out.println(&quot;Hello world！&quot;);
</code></pre>
<blockquote>
<p>题目二：实现一个特殊的栈，在实现栈的基本功能的基础上，再实现返回栈中最小元素的操作。<br>
【要求】1．pop、push、getMin操作的时间复杂度都是O(1)。<br>
2．设计的栈类型可以使用现成的栈结</p>
</blockquote>
<pre><code class="language-java">    System.out.println(&quot;Hello world！&quot;);
</code></pre>
<blockquote>
<p>题目三：如何仅用队列结构实现栈结构？如何仅用栈结构实现队列结构？</p>
</blockquote>
<pre><code class="language-java">    System.out.println(&quot;Hello world！&quot;);
</code></pre>
<blockquote>
<p>题目四：猫狗队列 【题目】 宠物、狗和猫的类如下：public class Pet { private String type;public Pet(String type) { this.type = type; }public String getPetType() { return this.type; }}public class Dog extends Pet { public Dog() { super(&quot;dog&quot;); } }public class Cat extends Pet { public Cat() { super(&quot;cat&quot;); } }实现一种狗猫队列的结构，要求如下： 用户可以调用add方法将cat类或dog类的实例放入队列中； 用户可以调用pollAll方法，将队列中所有的实例按照进队列的先后顺序依次弹出； 用户可以调用pollDog方法，将队列中dog类的实例按照进队列的先后顺序依次弹出； 用户可以调用pollCat方法，将队列中cat类的实例按照进队列的先后顺序依次弹出； 用户可以调用isEmpty方法，检查队列中是否还有dog或cat的实例； 用户可以调用isDogEmpty方法，检查队列中是否有do类的实例； 用户可以调用isCatEmpty方法，检查队列中是否有cat类的实例。</p>
</blockquote>
<pre><code class="language-java">System.out.println(&quot;Hello world！&quot;);
</code></pre>
<blockquote>
<p>题目五：转圈打印矩阵<br>
【题目】 给定一个整型矩阵matrix，请按照转圈的方式打印它。<br>
例如： 1 2 3 4 5 6 7 8 9 10 11 12 13 14<br>
15 16 打印结果为：1，2，3，4，8，12，16，15，14，13，9，<br>
5，6，7，11， 10<br>
【要求】 额外空间复杂度为O(1)。</p>
</blockquote>
<pre><code class="language-java">System.out.println(&quot;Hello world！&quot;);
</code></pre>
<blockquote>
<p>题目六：旋转正方形矩阵【题目】 给定一个整型正方形矩阵matrix，请把该矩阵调整成顺时针旋转90度的样子。【要求】 额外空间复杂度为O(1).</p>
</blockquote>
<pre><code class="language-java">System.out.println(&quot;Hello world！&quot;);
</code></pre>
<blockquote>
<p>题目七：反转单向和双向链【题目】 分别实现反转单向链表和反转双向链表的函数。【要求】 如果链表长度为N，时间复杂度要求为O(N)，额外空间复杂度要求为O(1).</p>
</blockquote>
<pre><code class="language-java">System.out.println(&quot;Hello world！&quot;);
</code></pre>
<blockquote>
<p>题目八：“之”字形打印矩阵【题目】 给定一个矩阵matrix，按照“之”字形的方式打印这个矩阵，例如： 1 2 3 4 5 6 7 8 9  10 11 12“之”字形打印的结果为：1，2，5，9，6，3，4，7，10，11，8，12【要求】 额外空间复杂度为O(1).</p>
</blockquote>
<pre><code class="language-java">System.out.println(&quot;Hello world！&quot;);
</code></pre>
<blockquote>
<p>题目九：在行列都排好序的矩阵中找数<br>
【题目】 给定一个有N*M的整型矩阵matrix和一个整数K，<br>
matrix的每一行和每一 列都是排好序的。实现一个函数，判断K<br>
是否在matrix中。 例如： 0 1 2 5 2 3 4 7 4<br>
4 4 8 5 7 7 9 如果K为7，返回true；如果K为6，返<br>
回false。<br>
【要求】 时间复杂度为O(N+M)，额外空间复杂度为O(1)。</p>
</blockquote>
<pre><code class="language-java">System.out.println(&quot;Hello world！&quot;);
</code></pre>
<blockquote>
<p>题目十：打印两个有序链表的公共部分【题目】 给定两个有序链表的头指针head1和head2，打印两个链表的公共部分。</p>
</blockquote>
<pre><code class="language-java">System.out.println(&quot;Hello world！&quot;);
</code></pre>
<blockquote>
<p>题目十一：判断一个链表是否为回文结构【题目】 给定一个链表的头节点head，请判断该链表是否为回文结构。 例如： 1-&gt;2-&gt;1，返回true。 1-&gt;2-&gt;2-&gt;1，返回true。15-&gt;6-&gt;15，返回true。 1-&gt;2-&gt;3，返回false。进阶： 如果链表长度为N，时间复杂度达到O(N)，额外空间复杂度达到O(1).</p>
</blockquote>
<pre><code class="language-java">System.out.println(&quot;Hello world！&quot;);
</code></pre>
<blockquote>
<p>题目十二：将单向链表按某值划分成左边小、中间相等、右边大的形式【题目】 给定一个单向链表的头节点head，节点的值类型是整型，再给定一个整 数pivot。实现一个调整链表的函数，将链表调整为左部分都是值小于 pivot的节点，中间部分都是值等于pivot的节点，右部分都是值大于 pivot的节点。除这个要求外，对调整后的节点顺序没有更多的要求。 例如：链表9-&gt;0-&gt;4-&gt;5-&gt;1，pivot=3。 调整后链表可以是1-&gt;0-&gt;4-&gt;9-&gt;5，也可以是0-&gt;1-&gt;9-&gt;5-&gt;4。总之，满 足左部分都是小于3的节点，中间部分都是等于3的节点（本例中这个部分为空），右部分都是大于3的节点即可。对某部分内部的节点顺序不做 要求。进阶： 在原问题的要求之上再增加如下两个要求。在左、中、右三个部分的内部也做顺序要求，要求每部分里的节点从左 到右的顺序与原链表中节点的先后次序一致。 例如：链表9-&gt;0-&gt;4-&gt;5-&gt;1，pivot=3。调整后的链表是0-&gt;1-&gt;9-&gt;4-&gt;5。 在满足原问题要求的同时，左部分节点从左到右为0、1。在原链表中也 是先出现0，后出现1；中间部分在本例中为空，不再讨论；右部分节点 从左到右为9、4、5。在原链表中也是先出现9，然后出现4，最后出现5。如果链表长度为N，时间复杂度请达到O(N)，额外空间复杂度请达到O(1).</p>
</blockquote>
<pre><code class="language-java">System.out.println(&quot;Hello world！&quot;);
</code></pre>
<blockquote>
<p>题目十三：复制含有随机指针节点的链表【题目】 一种特殊的链表节点类描述如下：public class Node { public int value; public Node next; publiNode rand;public Node(int data) { this.value = data; }}Node类中的value是节点值，next指针和正常单链表中next指针的意义一 样，都指向下一个节点，rand指针是Node类中新增的指针，这个指针可 能指向链表中的任意一个节点，也可能指向null。 给定一个由Node节点类型组成的无环单链表的头节点head，请实现一个 函数完成这个链表中所有结构的复制，并返回复制的新链表的头节点。 进阶：不使用额外的数据结构，只用有限几个变量，且在时间复杂度为 O(N)内完成原问题要实现的函数。</p>
</blockquote>
<pre><code class="language-java">System.out.println(&quot;Hello world！&quot;);
</code></pre>
<blockquote>
<p>题目十四：两个单链表相交的一系列问题<br>
【题目】 在本题中，单链表可能有环，也可能无环。给定两个<br>
单链表的头节点 head1和head2，这两个链表可能相交，也可能<br>
不相交。请实现一个函数， 如果两个链表相交，请返回相交的<br>
第一个节点；如果不相交，返回null 即可。 要求：如果链表1<br>
的长度为N，链表2的长度为M，时间复杂度请达到 O(N+M)，额外<br>
空间复杂度请达到O(1)。</p>
</blockquote>
<pre><code class="language-java">System.out.println(&quot;Hello world！&quot;);
</code></pre>
<blockquote>
<blockquote>
<p>题目十五：二分的小扩展。</p>
</blockquote>
</blockquote>
<pre><code class="language-java">System.out.println(&quot;Hello world！&quot;);
</code></pre>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[牛客网算法基础班（02）]]></title>
        <id>https://carrollwang.github.io//post/niu-ke-wang-suan-fa-ji-chu-ban-02</id>
        <link href="https://carrollwang.github.io//post/niu-ke-wang-suan-fa-ji-chu-ban-02">
        </link>
        <updated>2019-11-09T14:39:26.000Z</updated>
        <content type="html"><![CDATA[<p>一.随机快速排序<br>
时间复杂度O(N*logN)，额外空间复杂度O(logN)</p>
<p>二.堆排序<br>
堆排序的细节和复杂度分析时间复杂度O(N*logN)，额外空间复杂度O(1)堆结构非常重要1，堆结构的heapInsert与heapify2，堆结构的增大和减少3，如果只是建立堆的过程，时间复杂度为O(N)4，优先级队列结构，就是堆</p>
<p>稳定性：O（n2）的排序，冒泡排序和插入排序可以做到保证稳定性，选择排序做不到。<br>
题目：给定一个数组，求如果排序之后，相邻两数的最大差值，要求时间复杂度为O（N）,且要求不能用非基于比较的排序。</p>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[牛客网算法基础班（01）]]></title>
        <id>https://carrollwang.github.io//post/niu-ke-wang-suan-fa-ji-chu-ban-01</id>
        <link href="https://carrollwang.github.io//post/niu-ke-wang-suan-fa-ji-chu-ban-01">
        </link>
        <updated>2019-11-09T14:20:02.000Z</updated>
        <content type="html"><![CDATA[<p>一.时间复杂度</p>
<blockquote>
<blockquote>
<p>常数时间的操作：一个操作如果和数据量没有关系，每次都是固定时间内完成的操作，叫做常数操作。时间复杂度为一个算法流程中，常数操作数量的指标。常用O（读作big O）来表示。具体来说，在常数操作数量的表达式中只要高阶项，不要低阶项，也不要高阶项的系数，剩下的部分如果记为f(N)，那么时间复杂度为O(f(N))。评价一个算法流程的好坏，先看时间复杂度的指标，然后再分析不同数据样本下的实际运行时间，也就是常数项时</p>
</blockquote>
</blockquote>
<p>二.冒泡排序<br>
冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。</p>
<p>1、算法步骤<br>
比较相邻的元素。如果第一个比第二个大，就交换他们两个。<br>
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。<br>
针对所有的元素重复以上的步骤，除了最后一个。<br>
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。</p>
<p>2、动图演示<br>
<img src="https://carrollwang.github.io//post-images/1573810335169.gif" alt=""><br>
代码实现：</p>
<pre><code class="language-java">public class BubbleSort implements IArraySort {
    @Override
    public int[] sort(int[] sourceArray) throws Exception {
// 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
        for (int i = 1; i &lt; arr.length; i++) {
// 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
            boolean flag = true;
            for (int j = 0; j &lt; arr.length - i; j++) {
                if (arr[j] &gt; arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;

                    flag = false;
                }
            }
            if (flag) {
                break;
            }
        }
        return arr;
    }
}
</code></pre>
<p>三.选择排序<br>
选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。<br>
1、算法步骤<br>
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置<br>
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。<br>
重复第二步，直到所有元素均排序完毕。<br>
2、动图演示<br>
<img src="https://carrollwang.github.io//post-images/1573810464016.gif" alt=""><br>
四.插入排序（扑克牌）<br>
动图<br>
<img src="https://carrollwang.github.io//post-images/1573309537523.gif" alt=""><br>
直接插入算法的执行过程<br>
<img src="https://carrollwang.github.io//post-images/1573309579191.jpg" alt=""></p>
<p>代码：</p>
<pre><code class="language-java">// 时间复杂度O(n^2)
    // 控件复杂度O(1)
    // 稳定性： 稳定
    // 内部排序
    for (int i = 0; i &lt; dataArr.count; i++) {
        for (int j = i; j &gt; 0; j--) {
            if ([dataArr[j] intValue] &lt; [dataArr[j - 1] intValue]) {
                [dataArr exchangeObjectAtIndex:j withObjectAtIndex:j-1];
            }
        }
    }
</code></pre>
<p>五.递归</p>
<blockquote>
<blockquote>
<p>master公式的使用<br>
T(N) = a*T(N/b) + O(N^d)</p>
</blockquote>
</blockquote>
<ol>
<li>log(b,a) &gt; d -&gt; 复杂度为O(N^log(b,a))</li>
<li>log(b,a) = d -&gt; 复杂度为O(N^d * logN)</li>
<li>log(b,a) &lt; d -&gt; 复杂度为O(N^d)</li>
</ol>
<p>六.归并排序<br>
时间复杂度O(N*logN)，额外空间复杂度O(N）<br>
归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。</p>
<p>作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：<br>
自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；<br>
自下而上的迭代；<br>
在《数据结构与算法 JavaScript 描述》中，作者给出了自下而上的迭代方法。但是对于递归法，作者却认为：<br>
However, it is not possible to do so in JavaScript, as the recursion goes too deep for the language to handle.<br>
然而，在 JavaScript 中这种方式不太可行，因为这个算法的递归深度对它来讲太深了。<br>
说实话，我不太理解这句话。意思是 JavaScript 编译器内存太小，递归太深容易造成内存溢出吗？还望有大神能够指教。<br>
和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间。</p>
<p>1、算法步骤<br>
申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；<br>
设定两个指针，最初位置分别为两个已经排序序列的起始位置；<br>
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；<br>
重复步骤 3 直到某一指针达到序列尾；<br>
将另一序列剩下的所有元素直接复制到合并序列尾。<br>
2、动图演示<br>
<img src="https://carrollwang.github.io//post-images/1573816257191.gif" alt=""><br>
3.Java代码实现</p>
<pre><code class="language-java">public class MergeSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
if (arr.length &lt; 2) {
return arr;
}
int middle = (int) Math.floor(arr.length / 2);
int[] left = Arrays.copyOfRange(arr, 0, middle);
int[] right = Arrays.copyOfRange(arr, middle, arr.length);
return merge(sort(left), sort(right));
}
protected int[] merge(int[] left, int[] right) {
int[] result = new int[left.length + right.length];
int i = 0;
while (left.length &gt; 0 &amp;&amp; right.length &gt; 0) {
if (left[0] &lt;= right[0]) {
result[i++] = left[0];
left = Arrays.copyOfRange(left, 1, left.length);
} else {
result[i++] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
}
while (left.length &gt; 0) {
result[i++] = left[0];
left = Arrays.copyOfRange(left, 1, left.length);
}
while (right.length &gt; 0) {
result[i++] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
return result;
}
}
</code></pre>
<p>七、快速排序<br>
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。</p>
<p>快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。</p>
<p>快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。</p>
<p>快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高！它是处理大数据最快的排序算法之一了。虽然 Worst Case 的时间复杂度达到了 O(n²)，但是人家就是优秀，在大多数情况下都比平均时间复杂度为 O(n logn) 的排序算法表现要更好，可是这是为什么呢，我也不知道。好在我的强迫症又犯了，查了 N 多资料终于在《算法艺术与信息学竞赛》上找到了满意的答案：</p>
<p>快速排序的最坏运行情况是 O(n²)，比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn)，且 O(nlogn) 记号中隐含的常数因子很小，比复杂度稳定等于 O(nlogn) 的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。</p>
<p>1、算法步骤</p>
<p>从数列中挑出一个元素，称为 “基准”（pivot）;</p>
<p>重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；</p>
<p>递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；</p>
<p>递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。</p>
<p>2、动图演示<br>
<img src="https://carrollwang.github.io//post-images/1573823339015.gif" alt=""></p>
<p>3、Java 代码实现</p>
<pre><code class="language-java">public class QuickSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
return quickSort(arr, 0, arr.length - 1);
}
private int[] quickSort(int[] arr, int left, int right) {
if (left &lt; right) {
int partitionIndex = partition(arr, left, right);
quickSort(arr, left, partitionIndex - 1);
quickSort(arr, partitionIndex + 1, right);
}
return arr;
}
private int partition(int[] arr, int left, int right) {
// 设定基准值（pivot）
int pivot = left;
int index = pivot + 1;
for (int i = index; i &lt;= right; i++) {
if (arr[i] &lt; arr[pivot]) {
swap(arr, i, index);
index++;
}
}
swap(arr, pivot, index - 1);
return index - 1;
}
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
</code></pre>
<p>七、堆排序<br>
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：<br>
大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；<br>
小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；</p>
<p>堆排序的平均时间复杂度为 Ο(nlogn)。<br>
1、算法步骤<br>
创建一个堆 H[0……n-1]；<br>
把堆首（最大值）和堆尾互换；<br>
把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；<br>
重复步骤 2，直到堆的尺寸为 1。</p>
<p>2、动图演示<br>
<img src="https://carrollwang.github.io//post-images/1573823493066.gif" alt=""></p>
<p>3、Java 代码实现</p>
<pre><code class="language-java">public class HeapSort implements IArraySort {
@Override
public int[] sort(int[] sourceArray) throws Exception {
// 对 arr 进行拷贝，不改变参数内容
int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
int len = arr.length;
buildMaxHeap(arr, len);
for (int i = len - 1; i &gt; 0; i--) {
swap(arr, 0, i);
len--;
heapify(arr, 0, len);
}
return arr;
}
private void buildMaxHeap(int[] arr, int len) {
for (int i = (int) Math.floor(len / 2); i &gt;= 0; i--) {
heapify(arr, i, len);
}
}
private void heapify(int[] arr, int i, int len) {
int left = 2 * i + 1;
int right = 2 * i + 2;
int largest = i;
if (left &lt; len &amp;&amp; arr[left] &gt; arr[largest]) {
largest = left;
}
if (right &lt; len &amp;&amp; arr[right] &gt; arr[largest]) {
largest = right;
}
if (largest != i) {
swap(arr, i, largest);
heapify(arr, largest, len);
}
}
private void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
</code></pre>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[时间复杂度O(1)和O(n)的区别]]></title>
        <id>https://carrollwang.github.io//post/shi-jian-fu-za-du-o1he-onde-qu-bie</id>
        <link href="https://carrollwang.github.io//post/shi-jian-fu-za-du-o1he-onde-qu-bie">
        </link>
        <updated>2019-10-30T14:26:51.000Z</updated>
        <content type="html"><![CDATA[<p>O(1)解析<br>
O(1)就是最低的时空复杂度了，也就是耗时/耗空间与输入数据大小无关，无论输入数据增大多少倍，耗时/耗空间都不变。 哈希算法就是典型的O(1)时间复杂度，无论数据规模多大，都可以在一次计算后找到目标（不考虑冲突的话），冲突的话很麻烦的，指向的value会做二次hash到另外一快存储区域。</p>
<p>通俗易懂的例子</p>
<p>什么是O(1)呢，就比如你是一个酒店的管理员，你负责管理酒店的钥匙，你很聪明，你把酒店的100把钥匙放在了100个格子里面存着，并且把格子从1~100进行了编号，有一天有客人来了，酒店老板说，给我拿10号房间的钥匙给我，你迅速从10号格子里面拿出钥匙给老板，速度非常快，这时候你就是一个电脑了，老板跟你说拿几号房房间的钥匙，你只需要看一眼就能知道钥匙在哪里。</p>
<p>O(n)解析<br>
比如时间复杂度为O(n)，就代表数据量增大几倍，耗时也增大几倍。</p>
<p>比如常见的遍历算法。</p>
<p>要找到一个数组里面最大的一个数，你要把n个变量都扫描一遍，操作次数为n，那么算法复杂度是O(n).</p>
<p>通俗易懂的例子</p>
<p>突然，有一天，你的老板给你说，你用100个箱子存100把钥匙，太浪费空间了，你能补能把钥匙上编号一下，然后把钥匙要用绳子穿起来，这样我们可以把这个放箱子的地方再装修一个房间出来。你想了一下，是啊，现在房价这么贵，这样能多赚点钱。所以你就不能通过上面的方法来找到钥匙了，老板跟你说，给我拿45号房间的钥匙出来，你就需要从100个钥匙里面挨个找45个房间的钥匙。</p>
<p>从<br>
原文链接：https://blog.csdn.net/lkp1603645756/article/details/85013126</p>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[线性表]]></title>
        <id>https://carrollwang.github.io//post/xian-xing-biao</id>
        <link href="https://carrollwang.github.io//post/xian-xing-biao">
        </link>
        <updated>2019-10-30T12:33:41.000Z</updated>
        <content type="html"><![CDATA[<p>定义：另个或者多个数据元素的有限序列。<br>
1.首先他是一序列，也就是说，元素之间是有顺序的。<br>
2、线性表强调是有限的，元素个数是有限的。事实上，在计算机中处理的对象都是有限的，那种无限的数列，只存在于数学的概念中<br>
3.线性表元素的个数n（n&gt;=0）定义为线性表的长度，当n=0时，称为空表。<br>
4.相同类型的数据<br>
5.<img src="https://carrollwang.github.io//post-images/1572439397394.png" alt=""><br>
6.线性表的顺序存储结构，指的是用一段地址连续的存储单元一次存储线性表的数据元素。<br>
7.<img src="https://carrollwang.github.io//post-images/1572442158486.png" alt=""><br>
描述顺序存储结构需要三个属性：</p>
<blockquote>
<p>①存储空间的起始位置：数组data,它的存储位置就是存储空间的存储位置<br>
②线性表的最大存储容量：数组长度MaxSize<br>
③线性表的当前长度：length</p>
</blockquote>
<p>8.数组的长度是存放线性表的存储空间的长度，存储分配后这个量一般是不变的。<br>
线性表的长度是线性表中数据元素的个数，随着线性表插入和删除操作的进行，这个量是变化的。<br>
在任意时刻，线性表的长度应该小于等于数组的长度。<br>
数组的长度：<br>
线性表的长度：<br>
9.<img src="https://carrollwang.github.io//post-images/1572443012065.png" alt=""><br>
<img src="https://carrollwang.github.io//post-images/1572443020652.png" alt=""><br>
10.<img src="https://carrollwang.github.io//post-images/1572443516001.png" alt=""><br>
11.结点由存放数据元素的数据域和存放后继结点地址的指针域组成<br>
12.#单链表的读取</p>
<blockquote>
<p>获得链表第i个数据的算法思路<br>
a、声明一个结点p指向链表第一个结点，初始化j从1开始。<br>
b、当j&lt;i时，就遍历链表，让p的指针向后移动，不断指向下一结点，j累加1。<br>
c、若到链表末尾P为空，则说明第i个元素不存在。<br>
d、否则查找成功，返回结点P的数据。</p>
</blockquote>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[05讲数组：为什么很多编程语言中数组都从0开始编号]]></title>
        <id>https://carrollwang.github.io//post/05-jiang-shu-zu-wei-shi-me-hen-duo-bian-cheng-yu-yan-zhong-shu-zu-du-cong-0-kai-shi-bian-hao</id>
        <link href="https://carrollwang.github.io//post/05-jiang-shu-zu-wei-shi-me-hen-duo-bian-cheng-yu-yan-zhong-shu-zu-du-cong-0-kai-shi-bian-hao">
        </link>
        <updated>2019-10-28T08:52:19.000Z</updated>
        <content type="html"><![CDATA[<p>##数组看起来简单基础，但是很多人没有理解这个数据结构的精髓。带着为什么数组要从0开始编号，而不是从1开始的问题，进入主题。</p>
<ol>
<li>数组如何实现随机访问<br>
1）	数组是一种线性数据结构，用连续的存储空间存储相同类型数据<br>
I）	线性表：数组、链表、队列、栈 非线性表：树 图<br>
II）	连续的内存空间、相同的数据，所以数组可以随机访问，但对数组进行删除插入，为了保证数组的连续性，就要做大量的数据搬移工作<br>
a)	数组如何实现下标随机访问。<br>
引入数组再内存种的分配图，得出寻址公式<br>
b)	纠正数组和链表的错误认识。数组的查找操作时间复杂度并不是O(1)。即便是排好的数组，用二分查找，时间复杂度也是O（logn）。<br>
正确表述：数组支持随机访问，根据下标随机访问的时间复杂度为O（1）</li>
<li>低效的插入和删除<br>
1）	插入：从最好O(1) 最坏O(n) 平均O(n)<br>
2）	插入：数组若无序，插入新的元素时，可以将第K个位置元素移动到数组末尾，把心的元素，插入到第k个位置，此处复杂度为O(1)。作者举例说明<br>
3）	删除：从最好O(1) 最坏O(n) 平均O(n)<br>
4）	多次删除集中在一起，提高删除效率<br>
记录下已经被删除的数据，每次的删除操作并不是搬移数据，只是记录数据已经被删除，当数组没有更多的存储空间时，再触发一次真正的删除操作。即JVM标记清除垃圾回收算法。</li>
<li>警惕数组的访问越界问题<br>
用C语言循环越界访问的例子说明访问越界的bug。此例在《C陷阱与缺陷》出现过，很惭愧，看过但是现在也只有一丢丢印象。翻了下书，替作者加上一句话：如果用来编译这段程序的编译器按照内存地址递减的方式给变量分配内存，那么内存中的i将会被置为0，则为死循环永远出不去。</li>
<li>容器能否完全替代数组<br>
相比于数字，java中的ArrayList封装了数组的很多操作，并支持动态扩容。一旦超过村塾容量，扩容时比较耗内存，因为涉及到内存申请和数据搬移。<br>
数组适合的场景：<br>
1）	Java ArrayList 的使用涉及装箱拆箱，有一定的性能损耗，如果特别管柱性能，可以考虑数组<br>
2）	若数据大小事先已知，并且涉及的数据操作非常简单，可以使用数组<br>
3）	表示多维数组时，数组往往更加直观。<br>
4）	业务开发容器即可，底层开发，如网络框架，性能优化。选择数组。</li>
<li>解答开篇问题<br>
1）	从偏移角度理解a[0] 0为偏移量，如果从1计数，会多出K-1。增加cpu负担。为什么循环要写成for(int i = 0;i&lt;3;i++) 而不是for(int i = 0 ;i&lt;=2;i++)。第一个直接就可以算出3-0 = 3 有三个数据，而后者 2-0+1个数据，多出1个加法运算，很恼火。<br>
2）	也有一定的历史原因</li>
</ol>
]]></content>
    </entry>
    <entry>
        <title type="html"><![CDATA[04讲复杂度分析（下）：浅析最好、最坏、平均、均摊时间复杂度]]></title>
        <id>https://carrollwang.github.io//post/04-jiang-fu-za-du-fen-xi-xia-qian-xi-zui-hao-zui-pi-ping-jun-jun-tan-shi-jian-fu-za-du</id>
        <link href="https://carrollwang.github.io//post/04-jiang-fu-za-du-fen-xi-xia-qian-xi-zui-hao-zui-pi-ping-jun-jun-tan-shi-jian-fu-za-du">
        </link>
        <updated>2019-10-27T05:56:58.000Z</updated>
        <content type="html"><![CDATA[<p>一、复杂度分析的4个概念<br>
1.最坏情况时间复杂度：代码在最理想情况下执行的时间复杂度。<br>
2.最好情况时间复杂度：代码在最坏情况下执行的时间复杂度。<br>
3.平均时间复杂度：用代码在所有情况下执行的次数的加权平均值表示。<br>
4.均摊时间复杂度：在代码执行的所有复杂度情况中绝大部分是低级别的复杂度，个别情况是高级别复杂度且发生具有时序关系时，可以将个别高级别复杂度均摊到低级别复杂度上。基本上均摊结果就等于低级别复杂度。</p>
<p>二、为什么要引入这4个概念？<br>
1.同一段代码在不同情况下时间复杂度会出现量级差异，为了更全面，更准确的描述代码的时间复杂度，所以引入这4个概念。<br>
2.代码复杂度在不同情况下出现量级差别时才需要区别这四种复杂度。大多数情况下，是不需要区别分析它们的。</p>
<p>三、如何分析平均、均摊时间复杂度？<br>
1.平均时间复杂度<br>
代码在不同情况下复杂度出现量级差别，则用代码所有可能情况下执行次数的加权平均值表示。<br>
2.均摊时间复杂度<br>
两个条件满足时使用：1）代码在绝大多数情况下是低级别复杂度，只有极少数情况是高级别复杂度；2）低级别和高级别复杂度出现具有时序规律。均摊结果一般都等于低级别复杂度。</p>
]]></content>
    </entry>
</feed>