不要小瞧数组

分类：数据结构作者：编程之家用户

一、使用java中的数组

数组：把数据码成一排进行存放

public class array {

    public static void main(String[] args ){

        //定义数组指定长度
        int[] arr = new int[10];
        for (int i = 0; i<arr.length; i++)
            arr[i] = i;

        //
        int[] scores = new int[]{100,99,66};
        for (int i = 0; i<scores.length; i++)
            System.out.println(scores[i]);

        // 数组可遍历
        scores[0] = 98;
        for (int score: scores)
            System.out.println(score);

    }
}

二、二次封装属于我们自己的数组

数组最大的优点：快速查询 score[2]

数组最好应用于“索引有语意”的情况

但并非所有有语意的索引都适合用于数组，例如身份证号

数组也可以处理“索引没有语意”的情况，这里主要处理“索引没有语义”的情况数组的使用

public class array {

    private int[] data;
    private int size;

    // 构造函数,传入数组的容量capacity构造array
    public array(int capacity){
        data = new int[capacity];
        size = 0;
    }

    // 无参数的构造函数，默认数组容量capaciay=10
    public array(){
        this(10);
    }

    // 获取数组中的元素个数
    public int getSize(){
        return size;
    }

    // 获取数组的容量
    public int getCapacity(){
        return data.length;
    }

    // 判断数组是否为空
    public boolean isEmpty(){
        return size == 0;
    }

}

三、向数组添加元素

向数组末尾添加元素，还是在上面的类中添加方法

   // 向所有元素后添加一个新元素
    public void addList(int e){

        // 如果元素的个数等于数组的容量，那么抛出异常
        if (size == data.length)
            throw new IllegalArgumentException("AddLast failed. array is full");
        data[size] =  e;
        size++;
    }

指定位置添加元素

 // 在第index个位置插入一个新元素e
    public void add(int index,int e){

        if (size == data.length)
            throw new IllegalArgumentException("Add failed. array is full");

        if (index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. array is full");
        }

        for (int i = size - 1; i >= index; i--){
            data[i+1] = data[i];
        }

        data[index] = e;
        size++;

    }

在元素前面添加一个新元素

 // 在所有元素前添加一个新元素
    public void addFirst(int e){
        add(0,e);
    }

四、数组中查询元素和修改元素

还是在上面的类中写方法，这里重写toString方法，用于查询元素

 @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("array: size = %d,capacity = %d\n",size,data.length));

        res.append('[');
        for (int i = 0 ; i < size; i++){
            res.append(data[i]);
            if(i != size - 1)
                res.append(",");
        }
        res.append(']');
        return  res.toString();
    }

获取元素以及修改元素

  // 获取index索引位置的元素
    int get(int index){
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("GET failed. array is full");
        return data[index];
    }


    // 修改index索引位置的元素e
    void set (int index,int e){
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("set failed. array is full");
        data[index] = e;
    }

把前面写的功能进行测试

public class Main {

    public static void main(String[] args ){

        array arr = new array(20);
        for (int i = 0 ; i < 10 ; i++){
            arr.addList(i);
        }

        System.out.println(arr);

        // 索引为1的位置添加100
        arr.add(1,100);
        System.out.println(arr);

        // 开始添加-1
        arr.addFirst(-1);
        System.out.println(arr);

    }
}

// 打印结果
array: size = 10,capacity = 20
[0,1,2,3,4,5,6,7,8,9]
array: size = 11,100,9]
array: size = 12,capacity = 20
[-1,9]

五、包含，搜索和删除

还是在上面的类中写方法，包含

 // 查找数组中是否有元素e
public boolean contains(int e){
        for (int i = 0 ; i < size ; i++){
            if (data[i] == e){
                return true;
            }
        }
        return false;
    }

搜索

 // 查找数组中元素e所在的索引，如果元素不存在，返回-1
    public int find(int e){
        for (int i = 0 ; i < size ; i++){
            if (data[i] == e){
                return i;
            }
        }
        return -1;
    }

删除

// 从数组中删除index位置的元素，返回删除的元素
    public int remove(int index){
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("Remove failed");

        int ret = data[index];
        for (int i = index + 1 ; i < size ; i++)
            data [ i - 1] = data[i];
        
        // 这个地方需要注意
        size --;
        return ret;
    }


    // 从数组中删除第一个元素，返回删除的元素
    public int removeFirst(){
        return remove(0);
    }
    // 从数组中删除最后一个元素，返回删除的元素
    public int removeLast(){
        return remove(size - 1);
    }


    // 从数组中删除元素e
    public void removeElement(int e){
        int index = find(e);
        if (index != -1){
            remove(index);
        }
    }

进行测试

public class Main {

    public static void main(String[] args ){

        array arr = new array(20);
        for (int i = 0 ; i < 10 ; i++){
            arr.addList(i);
        }

        System.out.println(arr);

        arr.add(1,100);
        System.out.println(arr);

        arr.addFirst(-1);
        System.out.println(arr);


        arr.remove(2);
        System.out.println(arr);

        arr.removeElement(4);
        System.out.println(arr);

        arr.removeFirst();
        arr.removeLast();
        System.out.println(arr);
    }
}

array: size = 10,9]
array: size = 10,9]
array: size = 8,8]

基本功能已经实现，但是还是有很多需要完善的地方。

六、使用泛型

  1. 让我们的数据结构可以放置任何的数据类型
  2. 不可以是基本数据类型，只能是类对象：boolean、byte、chat、short、int、long、float、double
  3. 每个基本数据类型都有对应的包装类：Boolean、Byte、Chat、Short、Int、Long、Float、Double
  4. 下面还是针对上面的进行修改，由于使用了泛型，这里将array类全部放在这里方便大家观看
public class array<E> {

	// 数据类型由之前的int改成现在的
    private E[] data;
    private int size;


    // 构造函数,传入数组的容量capacity构造array
    // 这里使用了强制类型转化
    public array(int capacity){
        data = (E[]) new Object[capacity];
        size = 0;
    }

    // 无参数的构造函数，默认数组容量capaciay=10
    public array(){
        this(10);
    }


    // 获取数组中的元素个数
    public int getSize(){
        return size;
    }

    // 获取数组的容量
    public int getCapacity(){
        return data.length;
    }

    // 判断数组是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    // 向所有元素后添加一个新元素，转入参数类型改变
    public void addLast(E e){

        // 如果元素的个数等于数组的容量，那么抛出异常
        if (size == data.length)
            throw new IllegalArgumentException("AddLast failed. array is full");
        data[size] =  e;
        size++;

    }


    // 在所有元素前添加一个新元素，转入参数类型改变
    public void addFirst(E e){
        add(0,e);
    }

    // 在第index个位置插入一个新元素e，转入参数类型改变
    public void add(int index,E e){

        if (size == data.length)
            throw new IllegalArgumentException("Add failed. array is full");

        if (index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. array is full");
        }

        for (int i = size - 1; i >= index; i--){
            data[i+1] = data[i];
        }

        data[index] = e;
        size++;


    }



    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("array: size = %d,");
        }
        res.append(']');
        return  res.toString();

    }


    // 获取index索引位置的元素，返回类型改变
    E get(int index){
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("GET failed. array is full");
        return data[index];
    }


    // 修改index索引位置的元素e，转入参数类型改变
    void set (int index,E e){
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("set failed. array is full");
        data[index] = e;
    }


    // 查找数组中是否有元素e
    public boolean contains(E e){
        for (int i = 0 ; i < size ; i++){
            if (data[i] .equals(e) ){
                return true;
            }
        }
        return false;
    }


    // 查找数组中元素e所在的索引，如果元素不存在，返回-1，转入参数类型改变
    public int find(E e){
        for (int i = 0 ; i < size ; i++){
            if (data[i] .equals(e) ){
                return i;
            }
        }
        return -1;
    }

    // 从数组中删除index位置的元素，返回删除的元素，返回类型改变
    public E remove(int index){
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("Remove failed");

        E ret = data[index];
        for (int i = index + 1 ; i < size ; i++)
            data [ i - 1] = data[i];
        size --;
        // data[size] = null;    // loitering objects
        return ret;
    }


    // 从数组中删除第一个元素，返回删除的元素
    public E removeFirst(){
        return remove(0);
    }
    // 从数组中删除最后一个元素，返回删除的元素
    public E removeLast(){
        return remove(size - 1);
    }

    // 从数组中删除元素e
    public void removeElement(E e){
        int index = find(e);
        if (index != -1){
            remove(index);
        }
    }

}

为了进行测试，从新建一个Student类来进行测试，这样就可以使用任意类型的数据

public class Student {

    private String name;
    private int score;

    public Student(String studentName,int studentScore){
        name = studentName;
        score = studentScore;
    }

    @Override
    public String toString() {
        return String.format("Student(name: %s,score: %d)\n",name,score);
    }

    public static void main(String[] args){

        // 使用泛型
        array<Student> arr = new array<>();
        arr.addLast(new Student("Alice",100));
        arr.addLast(new Student("Bob",88));
        arr.addLast(new Student("Char",66));

        System.out.println(arr);
    }

}
public class Student {

    private String name;
    private int score;

    public Student(String studentName,66));

        System.out.println(arr);
    }


}

array: size = 3,capacity = 10
[Student(name: Alice,score: 100),Student(name: Bob,score: 88),Student(name: Char,score: 66)
]

说明还是成功的，由于int类型太单调，之后都将使用泛型来进行操作

七、动态数组

由于数组是由限制的，在用户不知道数据的个数的时候，容易抛出异常，这个时候就要使用动态数组，而不用再考虑数据的个数

具体的实现，还是在array类中

    // 动态数组
    private void resize(int newCapacity){
        // 使用泛型，强制类型转换
        E[] newData = (E[])new Object[newCapacity];

        // 把之前数组中的数据传到新的数组中
        for (int i = 0 ; i < size ; i ++){
            newData[i] = data[i];
        }
        //新的数组再指向到原来的数组，狸猫换太子
        data = newData;

    }

把添加元素的方法进行改写，

 public void add(int index,E e){

        // 如果数组已经满了
        if (size == data.length)
//            throw new IllegalArgumentException("Add failed. array is full");
            // 调用动态数组，扩容到之前容量的二倍
            resize(2 * data.length);


        if (index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. array is full");
        }

        for (int i = size - 1; i >= index; i--){
            data[i+1] = data[i];
        }

        data[index] = e;
        size++;


    }

把删除元素的方法也进行改写

  public E remove(int index){
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("Remove failed");

        E ret = data[index];
        for (int i = index + 1 ; i < size ; i++)
            data [ i - 1] = data[i];
        size --;
        // data[size] = null;    // loitering objects

		// 如果数组中剩余的数量是数组长度的二倍，那么就把数组的长度减半
        if (size == data.length / 2)
            resize(data.length / 2);

        return ret;
    }

进行测试

public class Main {

    public static void main(String[] args ){

        // int类型的包装类
        array<Integer> arr = new array<>(5);

        for (int i = 0 ; i < 5 ; i++){
            arr.addLast(i);
        }

        System.out.println(arr);

        arr.add(1,100);
        System.out.println(arr);

        arr.addFirst(-1);
        System.out.println(arr);


        arr.remove(2);
        System.out.println(arr);

        arr.removeElement(4);
        System.out.println(arr);

        arr.removeFirst();
        arr.removeLast();
        System.out.println(arr);
    }
}

array: size = 5,capacity = 5
[0,4]
当数据多的时候，自动扩容的之前的两倍
array: size = 6,capacity = 10
[0,4]
array: size = 7,capacity = 10
[-1,4]
array: size = 6,4]
当数据少的时候，自动缩少两倍
array: size = 5,capacity = 5
[-1,3]
array: size = 3,2]

这样就基本实现了动态的数组

八、简单的时间复杂度分析

  1. O(1)，O(n)，O(lgn)，O(nlogn)，O(n^2)
  2. 大O描述的是算法的运行时间和输入数据之间的关系
public static int sum(int[] nums){
    int sun = 0;
    for(int num: nums) sum += num;
    return sum;
}

这里算法是O(n)，这里n是nums中元素的个数

也就是说这个算法运行的时间的多少和这里的nums中元素的个数呈线性关系，也就是nums中的个数越多时间就越多

  1. 为什么要用大O，叫做O(n)？忽略常数，实际时间(线性)
    $$
    T = c1*n + c2
    $$

具体分析算法的时候就直接忽略常数，渐进时间复杂度，描述n趋近于无穷的情况
T = 2*n + 2 O(n)
T = 2000*n + 1000 O(n)
T = nn1 + 0 O(n^2)
T = 2nn + 300*n + 10 O(n^2)

其中n的幂数越大性能越差

分析动态数组的时间复杂度

向数组头添加元素的时候，要把数组中的每一个元素往后面移动，所以是O(n)，整体来看，通常做最坏的打算，也是O(n)，添加的还有注意resize方法

添加操作 O(n)
addLast(e) O(1)
addFirst(e) O(n)
add(index,e) O(n/2) = O(n)
resize O(n)

删除操作和上面的一样，也是做最坏的打算，也是O(n)，删除时还要注意resize方法

删除操作 O(n)
removeLast(e) O(1)
removeFirst(e) O(n)
remove(index,e) O(n/2) = O(n)

修改操作，这个是最简单的，O(1)

修改操作 O(1)
set(index,e) O(1)

查找操作，也是O(n)

查找操作 O(n)
get(index) O(1)
contains(e) O(n)
find(e) O(n)

总结
增 O(n)
删 O(n)
改 已知索引O(1)，未知索引O(n)
查 已知索引O(1)，未知索引O(n)

注意：对于增和删，如果只对最后一个元素操作依然是O(n)？，因为resize方法？

九、均摊复杂度和防止复杂度的震荡

  1. resize的复杂度分析

从最坏的方面来看，addLast(e)的复杂度是O(1)，如果此时数组容量不够需要扩容的时候就要调用resize方法，但是resize方法的复杂度是O(n)，所以综合来说addLast(e)的复杂度是O(n)，但是也不是每一次添加就会扩容，所以用最坏的来分析有点不合理，这里用到下面的知识了

假设当前的capacity = 8 ，并且每一次添加操作都使用addLast
$$
1+1+1+1+1+1+1+1+8+1
$$
9次addLast操作，触发resize，总共进行了17次的基本操作，9次添加，8次转移，

平均来说也就是每次addLast操作，进行了大约两次基本操作

假设capacity = n，n+1次addLast，触发resize，总共进行2n+1次基本操作

平均，每次addLast操作，进行2次基本操作

这样均摊计算，时间复杂程度是O(1)

所以在这个例子中，均摊计算，比计算最坏情况有意义

  1. 均摊复杂度

addLast的均摊复杂度是O(1)

同理，removeLast的均摊复杂度也是O(1)

  1. 复杂度的震荡

但是，我们同时来看addLast和removeLast操作

当capacity = n时，调用addLast，这里进行扩容，复杂度O(n)，然后执行removeLast，进行缩容，复杂度也是O(n)，如此循环，复杂度就一直是O(n)了

出现问题的原因：removeLast是resize过于着急(Eager)，不必一下子就缩容

解决方案：Lazy，当数据是总长度的1/4时进行缩容，缩容还是变回原来的一半

当size == capacity /4 时，才将capacity减半

通过这样的方法，就解决了复杂度震荡的问题

下面用代码实现，还是在array类中修改，把remove方法改写就可以了，

public E remove(int index){
        if (index < 0 || index >= size)
            throw new IllegalArgumentException("Remove failed");

        E ret = data[index];
        for (int i = index + 1 ; i < size ; i++)
            data [ i - 1] = data[i];
        size --;
        // data[size] = null;    // loitering objects

        // 这里等于1/4的才进行缩容，但是还要注意长度除于2不能等于0
        if (size == data.length / 4 && data.length / 2 != 0)
            resize(data.length / 2);

        return ret;
    }

​

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

【啊哈！算法】算法3：最常用的排序——快速排序
【啊哈！算法】算法3：最常用的排序——快速排序       上一节的冒泡排序可以说是我们学习第一个真正的排序算法，并且解决了桶排序浪费空间的问题，但在算法的执行效率上却牺牲了很多，它的时间复杂度达到了O(N2)。假如我们的计算机每秒钟可以运行10亿次，那么对1亿个数进行排序，桶排序则只需要0.1秒，而冒泡排序则需要1千万秒，达到115天之久，是不是很吓人。那有没有既不浪费空间又可以快一点的排序算法
[数据结构与算法]模式匹配与文本处理-匿名组与命名组
匿名组 这里可能用到几个不同的分组构造。通过括号内围绕的正则表达式就可以组成第一个构造。正如稍后要介绍的一样，既然也可以命名组，大家就有考虑把这个构造作为匿名组。作为一个实例，请看看下列字符串： “08/14/57 46 02/25/59 45 06/05/85 18 03/12/88 16 09/09/90 13“ 这个字符串就是由生日和年龄组成的。如果需要匹配年两而不要生日，就可以把正则
[C#]选择排序
选择排序：从数组的起始位置处开始，把第一个元素与数组中其他元素进行比较。然后，将最小的元素方式在第0个位置上，接着再从第1个位置开始再次进行排序操作。这种操作一直到除最后一个元素外的每一个元素都作为新循环的起始点操作过后才终止。 public void SelectionSort() { int min, temp;
[数据结构与算法]队列的优先级
public struct Pqitem { public int priority; public string name; } class CQueue { private ArrayList pqueue; public CQueue() { pqueue
[数据结构与算法]模式匹配-数量词
在编写正则表达式的时候，经常会向要向正则表达式添加数量型数据，诸如”精确匹配两次”或者”匹配一次或多次”。利用数量词就可以把这些数据添加到正则表达式里面了。 数量词(+):这个数量词说明正则表达式应该匹配一个或多个紧紧接其前的字符。 string[] words = new string[] { "bad", "boy", "baad", "baaad" ,"bear", "b
[数据结构与算法]白话经典算法系列之五 归并排序的实现
来自：http://blog.csdn.net/morewindows/article/details/6678165/归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列
[C#]插入排序
插入排序算法有两层循环。外层循环会啄个遍历数组元素，而内存循环则会把外层循环所选择的元素与该元素在数组内的下一个元素进行比较。如果外层循环选择的元素小于内存循环选择的元素，那么瘦元素都想右移动以便为内存循环元素留出位置。 public void InsertionSort() { int inner, temp;
[C#]二叉查找法
public int binSearch(int value) { int upperBround, lowerBound, mid; upperBround = arr.Length - 1; lowerBound = 0; while (lowerBound <= upper
[数据结构与算法]双向链表
虽然从表内第一个节点到最后一个节点的遍历操作是非常简单的，但是反向遍历链表却不是一件容易的事情。如果为Node类添加一个字段来存储指向前一个节点的连接，那么久会使得这个反向操作过程变得容易许多。当向链表插入节点的时候，为了吧数据复制给新的字段会需要执行更多的操作，但是当腰吧节点从表移除的时候就能看到他的改进效果了。 首先需要修改Node类来为累增加一个额外的链接。为了区别两个连接，这个把指
[数据结构]树及树的遍历
八、树（Tree）树，顾名思义，长得像一棵树，不过通常我们画成一棵倒过来的树，根在上，叶在下。不说那么多了，图一看就懂：当然了，引入了树之后，就不得不引入树的一些概念，这些概念我照样尽量用图，谁会记那么多文字？树这种结构还可以表示成下面这种方式，可见树用来描述包含关系是很不错的，但这种包含关系不得出现交叉重叠区域，否则就不能用树描述了，看图：面试的时候我们经常被考到的是一种叫“二叉树”的结构，二叉
[数据结构]队列的操作
Queue的实现： 就像Stack类的实现所做的一样，Queue类的实现用ArrayList简直是毋庸置疑的。对于这些数据结构类型而言，由于他们都是动态内置的结构，所以ArrayList是极好的实现选择。当需要往队列中插入数据项时，ArrayList会在表中把每一个保留的数据项向前移动一个元素。 class CQueue { private ArrayLis
[数据结构与算法]常用排序算法的动画效果图
来自：http://yingyingol.iteye.com/blog/13348911 快速排序介绍：快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地
[C#]Stack类的实现
Stack的实现必须采用一种基本结构来保存数据。因为再新数据项进栈的时候不需要担心调整表的大小，所以选择用arrayList.using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Collecti
[C#]冒泡排序
数组类测试环境与排序算法using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace Data_structure_and_algorithm{ class CArray { pr
[数据结构与算法]二叉树与二叉树遍历
一、构造二叉树 二叉树查找树由节点组成，所以需要有个Node类，这个类类似于链表实现中用到的Node类。首先一起来看看Node类的代码。 public class Node { public int Data; public Node Left; public Node Right; public v
【啊哈！算法】算法10：二叉树
二叉树是一种特殊的树。二叉树的特点是每个结点最多有两个儿子，左边的叫做左儿子，右边的叫做右儿子，或者说每个结点最多有两棵子树。更加严格的递归定义是：二叉树要么为空，要么由根结点、左子树和右子树组成，而左子树和右子树分别是一棵二叉树。 下面这棵树就是一棵二叉树。         二叉树的使用范围最广，一棵多叉树也可以转化为二叉树，因此我们将着重讲解二叉树。二叉树中还有连两种特殊的二叉树叫做满二叉树和
【啊哈！算法】算法4：解密QQ号——队列
上一节中我们学习了队列，它是一种先进先出的数据结构。还有一种是后进先出的数据结构它叫做栈。栈限定只能在一端进行插入和删除操作。比如说有一个小桶，小桶的直径只能放一个小球，我们现在向小桶内依次放入2号、1号、3号小球。假如你现在需要拿出2号小球，那就必须先将3号小球拿出，再拿出1号小球，最后才能将2号小球拿出来。在刚才取小球的过程中，我们最先放进去的小球最后才能拿出来，而最后放进去的小球却可以最先拿
[数据结构与算法]模式匹配与文本处理-零宽度正预测先行断言 and 零宽度正回顾后发断言
msdn中的描述如下：(?= 子表达式)（零宽度正预测先行断言。） 仅当子表达式在此位置的右侧匹配时才继续匹配。例如，w+(?=d) 与后跟数字的单词匹配，而不与该数字匹配。此构造不会回溯。(?（零宽度正回顾后发断言。） 仅当子表达式在此位置的左侧匹配时才继续匹配。例如，(?此构造不会回溯。msdn描述的比较清楚，如：w+(?=ing) 可以匹配以ing结尾的单词(匹配结果不包括ing)，(
[数据结构]线索二叉树
1.引入线索二叉树 二叉树的遍历实质上是对一个非线性结构实现线性化的过程，使每一个节点(除第一个和最后一个外)在这些线性序列中有且仅有一个直接前驱和直接后继。但在二叉链表存储结构中，只能找到一个节点的左、右孩子信息，而不能直接得到节点在任一遍历序列中的前驱和后继信息。这些信息只有在遍历的动态过程中才能得到，因此，引入线索二叉树来保存这些从动态过程中得到的信息。 2.建立线索二叉树 为了保
[数据结构与算法]超级详细解读基本排序算法不看后悔，带排序演示动画
排序与我们日常生活中息息相关，比如，我们要从电话簿中找到某个联系人首先会按照姓氏排序、买火车票会按照出发时间或者时长排序、买东西会按照销量或者好评度排序、查找文件会按照修改时间排序等等。在计算机程序设计中，排序和查找也是最基本的算法，很多其他的算法都是以排序算法为基础，在一般的数据处理或分析中，通常第一步就是进行排序，比如说二分查找，首先要对数据进行排序。在Donald Knuth 的计算机程序设
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot