数据结构与算法_正在更新中。。。

最新推荐文章于 2024-02-27 16:18:37 发布
最新推荐文章于 2024-02-27 16:18:37 发布
阅读量413 收藏
点赞数 2
CC 4.0 BY-SA版权
分类专栏： Java后端工程师养成记 文章标签： 数据结构 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44743622/article/details/115017531

一、线型数据结构

00.复杂度

（1）时间复杂度

每访问一个元素，时间复杂度记为1。如果一个数组长度为n，如果我们用遍历的方式来进行操作，那么访问n次才能够确定，时间复杂度记为n；

常见的时间复杂度有：1，N，Log n，N2，N3

（2）空间复杂度

原始数据空间为n，我们新开辟的空间大小是n的多少倍。

01.数组

​ **特点：**数组对象直接指向数组首地址，物理空间上是连续的。数据呈线状排列。
​ **优点：**在查找的时候，效率高。
​ **缺点：**因为空间是连续的，所以当磁盘的控件碎片较多的时候，我们可能无法存入大数据。即使内存空间足够，也无法存储。

（1）遍历与求和

public class Array001 {

    //数组遍历
    public static void print(int[] arr) {
        if (arr == null || arr.length == 0) {
            System.out.println("数组为空，取消遍历");
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }

    //数组求和
    public static int sum(int[] arr) {
        int total = 0;
        if (arr == null) {
            return total;
        }
        for (int i = 0; i < arr.length; i++) {
            total += arr[i];
        }
        return total;
    }

    public static void main(String[] args) {
        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        System.out.println("数组遍历为：");
        print(arr);
        System.out.println();
        System.out.println("数组的和为：" + sum(arr));
    }
}

（2）数组排序

a.冒泡排序

特点是一遍比较，一边交换；

/**
 * 冒泡排序
 */
public class BubbleSort {

    public static void sort(int[] arr) {
        if (arr == null || arr.length == 0 || arr.length == 1) {
            return;
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = new int[]{4, 3, 5, 7, 9, 8, 6, 1, 2};
        sort(arr);
        for (int i : arr) {
            System.out.println(i);
        }
    }
}
b.选择排序

特点是先遍历选择最大值的索引，再和未排序的最后一个元素进行交换；

/**
 * 选择排序
 */
public class SelectionSort {

    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int maxIndex = 0;
            for (int j = 1; j < arr.length - i; j++) {
                if (arr[j] > arr[maxIndex]) {
                    maxIndex = j;
                }
            }
            int temp = arr[maxIndex];
            arr[maxIndex] = arr[arr.length - i - 1];
            arr[arr.length - i - 1] = temp;
        }
    }

    public static void main(String[] args) {
        int[] arr = new int[]{3, 2, 5, 6, 9, 1, 4, 7, 9, 8};
        sort(arr);
        for (int i : arr) {
            System.out.println(i);
        }
    }
}

（3）有序数组的合并

思路：新建一个足够长度的新数组，循环比较两个数组的较小值，谁小，谁就放到新数组中。

/**
 * 合并两个有序的数据
 */
public class OrderlyArrayMerge {

    public static int[] merge1(int[] arrA, int[] arrB) {
        if (arrA == null) {
            return arrB;
        }
        if (arrB == null) {
            return arrA;
        }
        int[] result = new int[arrA.length + arrB.length];
        int p1 = 0;     //第一个数组的索引
        int p2 = 0;     //第二个数组的索引
        int pr = 0;     //新数组的索引
        while (p1 < arrA.length && p2 < arrB.length) {      //当p1和p2都没有越界时
            if (arrA[p1] < arrB[p2]) {      //谁小，谁就放在新数组里
                result[pr++] = arrA[p1++];
            } else {
                result[pr++] = arrB[p2++];
            }
        }
        if (p1 >= arrA.length) {            //如果p1放完了
            while (p2 < arrB.length) {      //则把p2剩余的放到新数组里
                result[pr++] = arrB[p2++];
            }
        } else {
            while (p1 < arrA.length) {
                result[pr++] = arrA[p1++];
            }
        }
        return result;
    }

    public static int[] merge2(int[] arrA, int[] arrB) {
        if (arrA == null) {
            return arrB;
        }
        if (arrB == null) {
            return arrA;
        }
        int[] result = new int[arrA.length + arrB.length];
        int p1 = 0;
        int p2 = 0;
        int pr = 0;
        while (p1 < arrA.length || p2 < arrB.length) {          //当p1和p2有一个没放完时即循环
            //如果p2越界或p1比p2小，用p1的数据
            if (p2 >= arrB.length || arrA[p1] < arrB[p2]) {
                result[pr++] = arrA[p1++];
            } else {
                result[pr++] = arrB[p2++];
            }
        }
        return result;
    }

    public static void main(String[] args) {
        int[] a = new int[]{1, 3, 5, 7, 9, 11, 13, 15};
        int[] b = new int[]{2, 4, 5, 6, 8, 9, 10};
//        int[] c = merge1(a, b);
        int[] c = merge2(a, b);
        for (int i : c) {
            System.out.println(i);
        }
    }
}

02.链表

​ **特点：**空间可以不是连续的。需要在存放数据的同时，多创建一个空间用来存放数据。
​ **优点：**不受空间大小的影响，只要有空间，就能存储数据，不会受空间连续的制约。
​ **缺点：**查找效率没有数组高；需要多开辟一块空间。

（1）遍历与求和

  • 链表结点类Node

    public class Node {
    public int val;
    public Node next;

    public Node() {
    }

    public Node(int val) {
        this.val = val;
    }
}

  • 代码演示

public class LinkTable001 {

    //遍历链表
    public static void print(Node node) {
        while (node != null) {
            System.out.print(node.val + " ");
            node = node.next;
        }
    }

    //递归遍历
    public static void print2(Node node) {
        //递归出口
        if (node == null) return;
        //递归操作
        System.out.print(node.val + " ");
        //下一次递归
        print2(node.next);
        //每次完成之后做的事情
        System.out.print(node.val + " ");
    }

    //链表求和
    public static int sum(Node node) {
        if (null == node) {
            return 0;
        }
        int total = 0;
        while (node != null) {
            total += node.val;
            node = node.next;
        }
        return total;
    }

    //链表递归求和
    public static int sum2(Node node,int total) {
        //递归出口
        if (node == null) return total;
        //递归操作
        total += node.val;
        //下一次递归
        return sum2(node.next, total);
    }

    public static void main(String[] args) {
        Node head = new Node(1);
        Node node1 = new Node(2);
        Node node2 = new Node(3);
        Node node3 = new Node(4);
        Node node4 = new Node(5);

        head.next = node1;
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        System.out.println("链表普通遍历：");
        print(head);
        System.out.println();
        System.out.println("链表递归遍历：");
        print2(head);
        System.out.println();
        System.out.println("链表求和：" + sum(head));
        System.out.println("链表递归求和：" + sum2(head, 0));
    }
}

（2）链表逆置

public class LinkTable002 {

    //链表逆置
    public static Node change(Node node) {      //a传进来
        if (node.next.next != null) {
            Node result = change(node.next);    //a,change b;
            node.next.next = node;
            node.next = null;
            return result;
        } else {        //如果是倒数第二个结点
            Node result = node.next;    //记录最后一个结点
            node.next.next = node;      //最后一个结点指向前一个结点
            node.next = null;           //前一个结点指向空
            return result;              //返回最后一个结点
        }
    }

    public static Node change2(Node node) {
        Node result = null;
        if (node.next.next != null) {
            result = change(node.next);
        } else {
            result = node.next;
        }
        //递归操作
        node.next.next = node;
        node.next = null;
        return result;
    }

    public static void main(String[] args) {
        Node a = new Node(1);
        Node b = new Node(2);
        Node c = new Node(3);
        Node d = new Node(4);
        Node e = new Node(5);

        a.next = b;
        b.next = c;
        c.next = d;
        d.next = e;
    }
}

03.栈

  • 自定义栈MyStack

    /**
 * 用数组封装栈
 */
public class MyStack {

    private int top;
    private int[] data;

    public MyStack(int size) throws Exception {
        if (size <= 0) {
            throw new Exception("栈的长度必须大于0");
        }
        this.data = new int[size];
    }

    public void push(int value) throws Exception {
        if (top >= this.data.length) {
            throw new Exception("栈满了");
        }
        data[top++] = value;
    }

    public int pop() throws Exception {
        if (top <= 0) {
            throw new Exception("栈空了");
        }
        return data[--top];
    }

}

  • 测试栈

    public class StackTest {

    public static void main(String[] args) throws Exception {
        MyStack myStack = new MyStack(3);
        myStack.push(1);
        myStack.push(2);
        myStack.push(3);
        System.out.println(myStack.pop());
        System.out.println(myStack.pop());
        System.out.println(myStack.pop());
    }
}

04.队列

（1）用链表实现队列

/**
 * 用链表实现队列
 */
public class MyQueue {

    private Node head;      //队列的头
    private Node tail;      //队列的尾
    private int maxSize;    //队列的最大容量
    private int size;       //队列的当前存值个数

    public MyQueue(int maxSize) {
        this.maxSize = maxSize;
        this.size = 0;
    }

    public void push(int value) throws Exception {
        if (size >= maxSize) {
            throw new Exception("队列满啦");
        }
        Node node = new Node(value);
        if (size == 0) {
            head = node;
            tail = node;
        } else {
            tail.next = node;
            tail = node;
        }
        size++;
    }

    public int pop() throws Exception {
        if (size <= 0) {
            throw new Exception("队列空啦");
        }
        int result = head.val;
        head = head.next;
        size--;
        return result;
    }

}

（2）两个栈实现队列

public class MyQueueWithStack {

    private MyStack myStack1;
    private MyStack myStack2;

    public MyQueueWithStack(int size) throws Exception {
        myStack1 = new MyStack(size);
        myStack2 = new MyStack(size);
    }

    public void push(int value) throws Exception {
        myStack1.push(value);
    }

    public int pop() throws Exception {
        while (!myStack1.isEmpty()) {
            myStack2.push(myStack1.pop());
        }
        int result = myStack2.pop();
        while (!myStack2.isEmpty()) {
            myStack1.push(myStack2.pop());
        }
        return result;
    }
}

  • 测试队列

    public class QueueTest {

    public static void main(String[] args) throws Exception {
        MyQueue myQueue = new MyQueue(3);
        myQueue.push(1);
        myQueue.push(2);
        myQueue.push(3);
        System.out.println(myQueue.pop());
        System.out.println(myQueue.pop());
        System.out.println(myQueue.pop());
        MyQueueWithStack myQueueWithStack = new MyQueueWithStack(3);
        myQueueWithStack.push(1);
        myQueueWithStack.push(2);
        myQueueWithStack.push(3);
        System.out.println(myQueueWithStack.pop());
        System.out.println(myQueueWithStack.pop());
        System.out.println(myQueueWithStack.pop());
    }
}

二、二维数据结构

01.二维数组

02.邻接链表

03.拓扑结构-图

04.树

06.链表的递归遍历

public class Test {

    public static void printNode(Node node) {
        if (node == null) {			//递归出口
            return;
        }
        System.out.println(node.getVal());		//对每个节点的通用操作
        printNode(node.getNext());				//向下递归点
        System.out.println(node.getVal());
    }

    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);

        node1.setNext(node2);
        node2.setNext(node3);
        node3.setNext(node4);
        node4.setNext(node5);

        printNode(node1);   //1,2,3,4,5,5,4,3,2,1
    }
}

07.链表的逆置

    public static Node change(Node node) {
        if (node.next.next != null) {       //如果当前节点不是D
            Node result = change(node.next);    //将第二个节点传入递归执行
            node.next.next = node;
            node.next = null;
            return result;
        } else {            //如果当前节点是D节点
            Node result = node.next;        //得到E节点
            node.next.next = node;          //E节点指向D节点
            node.next = null;               //D节点指向null
            return result;                  //将E节点返回
        }
    }

    public static Node change2(Node node) {
        Node result = null;
        if (node.next.next != null) {
            result = change2(node.next);
        } else {
            result = node.next;
        }
        node.next.next = node;
        node.next = null;
        return result;
    }

08.栈和队列

public class Test {

    public static void main(String[] args) throws Exception {
//        MyStack myStack = new MyStack(3);     //测试栈
//        myStack.push(1);
//        myStack.push(2);
//        myStack.push(3);
//        System.out.println(myStack.pop());
//        System.out.println(myStack.pop());
//        System.out.println(myStack.pop());

        MyQueue myQueue = new MyQueue(3);
        myQueue.push(1);
        myQueue.push(2);
        myQueue.push(3);
        System.out.println(myQueue.pop());
        System.out.println(myQueue.pop());
        System.out.println(myQueue.pop());
        System.out.println(myQueue.pop());



    }
}

class MyQueue {
    Node head = null;
    Node tail = null;
    int maxSize;
    int size;

    public MyQueue(int maxSize) {
        this.maxSize = maxSize;
        this.size = 0;
    }

    public void push (int val) throws Exception {
        Node node = new Node(val);
        if (size >= maxSize) {
            throw new Exception("队列满了");
        }
        if (size == 0) {
            head = node;
            tail = node;
        } else {
            tail.next = node;
            tail = node;
        }
        size++;
    }

    public int pop() throws Exception {
        if (size <= 0) {
            throw new Exception("队列里没数据了");
        }
        size--;
        int result = head.val;
        head = head.next;
        return result;
    }

}

class MyStack {
    int[] data;
    int top = 0;
    public MyStack(int size) {
        this.data = new int[size];
    }

    public void push(int val) throws Exception {
        if (top >= this.data.length) {
            throw new Exception("栈满了");
        }
        this.data[top] = val;
        top++;
    }

    public int pop() throws Exception {
        if (top <= 0) {
            throw new Exception("栈里没数据了");
        }
        return this.data[--top];
    }
    public boolean isEmpty() {
        if (this.top == 0) {
            return true;
        } else {
            return false;
        }
    }
}

09.用两个栈模拟队列

class MyQueueWithStack {
    MyStack stack1;
    MyStack stack2;

    public MyQueueWithStack(int size) {
        stack1 = new MyStack(size);
        stack2 = new MyStack(size);
    }

    public void push(int val) throws Exception {
        stack1.push(val);
    }

    public int pop() throws Exception {
        while (!stack1.isEmpty()) {
            stack2.push(stack1.pop());
        }
        int result = stack2.pop();
        while (!stack2.isEmpty()) {
            stack1.push(stack2.pop());
        }
        return result;
    }
}

public class Test {

    public static void main(String[] args) throws Exception {
        MyQueueWithStack myQueueWithStack = new MyQueueWithStack(10);
        myQueueWithStack.push(1);
        myQueueWithStack.push(2);
        myQueueWithStack.push(3);
        System.out.println(myQueueWithStack.pop());
        System.out.println(myQueueWithStack.pop());
        System.out.println(myQueueWithStack.pop());
    }
}

10.时间复杂度

​ 假设我们有个数组，我们要查找数组中是否存在某个数。

​ 如何来衡量写的算法效率是否高？

​ 可以用时间吗？不可以

​ 每访问一个元素，时间复杂度记为1。如果一个数组长度为n，如果我们用遍历的方式来进行操作，那么访问n次才能够确定。时间复杂度记为n。

​ 1，N，Log n，N2，N3

11.空间复杂度

​ 用了多少额外的空间，我们暂且估计原始数据的大小为n，我们新开辟的空间是n的多少倍。

12.冒泡排序

//冒泡排序
public class Test {

    //排序的本质是什么？
    //排序是比较大小，非常错误的
    //排序是比较优先级，然后进行位置交换
    //在比较大小的时候，例如从小到大排列，数字越小，优先级越高

    public static boolean compare(int a, int b) {
        if (a > b) {
            return true;
        }
        return false;
    }

    public static void change(int[] arr, int aIndex, int bIndex) {
        int temp = arr[aIndex];
        arr[aIndex] = arr[bIndex];
        arr[bIndex] = temp;
    }

    public static void sort(int[] arr) {		//边比较边交换
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (compare(arr[j], arr[j + 1])) {
                    change(arr, j, j + 1);
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = new int[]{2, 4, 3, 1, 9, 0, 6, 7, 8, 5};
        sort(arr);
        for (int i : arr) {
            System.out.println(i);
        }
    }
}

13.选择排序

    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int maxIndex = 0;
            for (int j = 1; j < arr.length - i; j++) {
                if (compare(arr[j], arr[maxIndex])) {
                    maxIndex = j;
                }
            }
            change(arr, maxIndex, arr.length - 1 - i);
        }
    }

14.有序数组的合并

数据结构与算法分析--C语言描述_数据结构与算法_
10-01
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。C语言因其高效、底层特性，常被用于实现数据结构和算法，使得程序更接近硬件，性能更优。本资源"数据结构与算法分析--C语言描述"是针对数据...
数据结构_算法_美_极客学习专栏_1741869569.zip
最新发布
03-16
《数据结构_算法_美_极客学习专栏》是一套全方位、多层次的数据结构与算法学习资源，无论是对于在校学生还是职场人士，都是提高自身能力的宝贵资料。通过本专栏的学习，读者不仅可以掌握数据结构的核心知识，还能...
算法基础篇
qq_30593497的博客
02-27 709
算法基础 一、什么是算法与大O表示法 算法是一组完成任务的指令。任何代码片段都可视为算法。 算法是一种通过有限过程解决问题的解决方案。 大O 表示法： 大O表示法是一种特殊的表示法，指出了算法的速度有多快； 大O表示法让你能够比较操作数，它指出了算法运行时间的增速； 大O 表示法指出了最糟情况下的运行时间。 举例，假设列表包含n个元素： 简单查找需要检查每个元素，因此需要执行n次操作。使用大O表示法，这个运行时间为 O(n)。 二分查找需要执行log n次操作。使用大O表示法，这个运行时间为 O(log n
数据结构与算法学习（二）复杂度分析与数组
weixin_44254470的博客
03-27 742
// n表示数组array的长度 int find(int[] array, int n, int x) { int i = 0; int pos = -1; for (; i < n; ++i) { if (array[i] == x) { pos = i; break; } } return pos; } 最好情况时间复杂度 要查找的变量x恰巧是数组中的第一个元素,这个时候对应的时间复杂度就是最好情况时间复杂度，也就是O(1)。 最
【数据结构】数组 时间复杂度（查询 搜索 插入）
global_coding的博客
02-13 2321
数组，时间复杂度
从数组、链表到集合
柏修的专栏
03-10 3477
一、数组概念使用连续的一块内存空间保存，长度在初始化时确定。时间复杂度访问第n个元素时，时间复杂度为O（1）；当访问某个特定的元素时，时间复杂度为O（n）； 怎么理解这两个时间复杂度不一致的情况，举个例子String[]strings=newString[]{"1","2","3"}; System.out.println(strings[0]); for(Stringst
调用方法返回数组最大值
weixin_50874007的博客
12-05 2170
主方法中给定数组int[] arr= {10,20,30,40,50,60};这个数组没有重复元素.定义一个方法可以接受这个给定的数组并返回这个数组中最大元素值的索引值 package com.it; import java.util.Scanner; public class Test1 { public static void main(String[] args) { int[] arr= {10,20,30,40,50,60}; int max = get
数据结构与算法分析_java语言描述_Mark_Allen_Weiss著_课后习题答案.pdf
07-14
数据结构与算法分析_java语言描述_Mark_Allen_Weiss著_课后习题答案.pdf
数据结构与算法_java第3版.zip
06-25
本书把数据结构原理和算法...书中还引入了一些比较高级的数据结构与先进的算法分析技术，并介绍了可计算性理论的一般知识。本版的重要改进在于引入了参数化的模板，从而提高了算法中数据类型的通用性，支持高效的代码
数据结构与算法分析 C++描述(高清非扫描)_算法_数据结构_
10-03
在程序开发过程中通常需要做到如下两点：一是高效地描述数据；二是设计一个好的算法，该算法最终可用...要想高效地描述数据，必须具备数据结构领域的专门知识；而要想设计一个好的算法，则需要算法设计领域的专门知识。
MyBatis狂神说最全笔记
01-24
根据狂神说狂神说狂神说视频复现的一模一样的笔记
狂神说Spring5最全笔记
01-13
根据狂神说狂神说Spring5视频复现的一摸一样的笔记
数据结构——数组及简介时间复杂度
GuZhC的博客
12-05 1万+
数组基础 特性：数据码成一排进行存放，每一个数据对应一个索引，支持随机访问，初始化必须指定大小 使用：Java中初始化：int[] arr = new int[10]  或 int[] arr = new int[]{ 1,2,3 } 其他：数组索引可以有意义也可没有意义，但最好应用于索引有意义的情况因为其支持随机访问的特性，根据索引查找对应数据所用的时间复杂度为O(1) 动态数组 具体...
数据结构--时间复杂度（小白笔记）
qq_67503181的博客
02-27 1094
数组 (Array) 访问元素：O(1) 数组：O(1) 无论数组中有多少元素，只要知道索引，就可以直接访问元素。 链表：O(n) 链表需要从头开始逐个遍历节点，直到找到目标节点，因此访问的时间与链表的长度成正比。 搜索：O(n) 无序数组：O(n) 在无序数组中搜索需要逐个比较每个元素，直到找到目标元素或者遍历完整个数组。 有序数组：O(log n) 使用二分查找可以将搜索范围每次减半，因此时间复杂度是对数级别的。 二叉搜索树（BST）：O(log n) ~ O(n) 在平衡的情况
有关数组操作的时间复杂度
OHHYES的博客
10-27 4694
数组的几种基本操作有： 1、读取元素 数组中是通过索引来读取元素的。对于数组，计算机会在内存中为其申请一段连续的空间，并且记录下索引为“0”的内存地址。若要访问一个元素，计算机会在索引为“0”的内存地址的基础上加上索引值。 例如 索引“0”的内存地址为 2000，若要查找索引值为8处的元素，则只需进行 2000+8=2008，便查找到了目标元素。 综上，只要知道内存地址就可以立即访问该元素，故时间复杂度为O(1) 2、查找元素 在一个数组中进行元素的查找，最坏的情况就是目标元素是数组中的最...
数组访问随机元素的时间复杂度---O(1)
Clearlight's Blog
05-05 5471
数组在内存中存储是一段连续的存储区域. 数组可以通过下标,随机访问数组中的元素. 原理: 通过硬件内存管理器,通过访问数组中的下标来访问内存中存储的元素. 访问任何一个位置的数组元素,时间复杂度是O(1),硬件可以保证. 具体的访问原理很复杂 时间复杂度扩展 数组中的 操作 时间复杂度 删除与添加 O(n) 随机读取 O(1) 链表中 操作 时间复杂度 ...
数据结构与算法-数组（笔记）
qq_15231055的博客
02-14 330
数据结构与算法-数组什么是数组线性表非线性表连续内存空间和相同类型的数据随机访问 什么是数组 数组(Array)是 一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据 线性表 顾名思义，线性表就是数据排成像一条线一样的结构。每个线性表上的数据 最多只有前和后两个方向。 其实除了数组，链表、队列、栈等也是线性表结构 非线性表 二叉树、堆、图等。之所以叫非线性，是因为，在非线性表中，数据 之间并不是简单的前后关系。 连续内存空间和相同类型的数据 正是因为这两个限制，它才有了一个堪称“杀
访问单向链表和顺序数组第i个元素的时间复杂度的分析
热门推荐
halfsuccess的专栏
10-22 1万+
假设链表L有n个元素，如果这n个元素中每一个元素被访问的概率都为相同，则访问到第i个元素所前移的指针的平均次数为： Average = （1+2+3+......+n）/n = n(1+n)/2/n = n/2 + 1/2 所以，访问第i个元素的平均时间为O(n)。相比起来，在数组L中访问第i个元素的平均时间为O(1)。 其他操作时间代价见下表：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值