数据结构面试知识点总结3

最新推荐文章于 2024-07-20 11:22:21 发布
最新推荐文章于 2024-07-20 11:22:21 发布
阅读量852 收藏 13
点赞数 12
文章标签： 数据结构 面试 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_77186925/article/details/140540844
版权

#来自ウルトラマンティガ（迪迦）

1 线性表

最基本、最简单、最常用的一种数据结构。一个线性表是 n 个具有相同特性的数据元素的有限序列。

特征：数据元素之间是一对一的逻辑关系。

  • 第一个数据元素没有前驱，称为头结点；
  • 最后一个数据元素没有后继，称为尾结点；
  • 除了头结点和尾结点，其他数据元素有且仅有一个前驱和一个后继。

分类：

  • 顺序存储
  • 链式存储

2 顺序表

顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素。

public class SequenceList<T> implements Iterable<T> {
    //存储元素的数组
    private T[] eles;
    //记录当前顺序表中的元素个数
    private int N;

    //构造方法
    public SequenceList(int capacity) {
        //初始化数组
        this.eles = (T[]) new Object[capacity];
        //初始化长度
        this.N = 0;
    }

    //将一个线性表置为空表
    public void clear() {
        this.N = 0;
    }

    //判断当前线性表是否为空表
    public boolean isEmpty() {
        return N == 0;
    }

    //获取线性表的长度
    public int length() {
        return N;
    }

    //获取指定位置的元素
    public T get(int i) {
        return eles[i];
    }

    //向线型表中添加元素 t
    public void insert(T t) {
        if (N == eles.length) {
            resize(2 * eles.length);
        }

        eles[N++] = t;
    }

    //在 i 元素处插入元素 t
    public void insert(int i, T t) {
        if (N == eles.length) {
            resize(2 * eles.length);
        }

        //先把i索引处的元素及其后面的元素依次向后移动一位
        for (int index = N; index > i; index--) {
            eles[index] = eles[index - 1];
        }
        //再把t元素放到i索引处即可
        eles[i] = t;
        //元素个数+1
        N++;
    }

    //删除指定位置i处的元素，并返回该元素
    public T remove(int i) {
        //记录索引i处的值
        T current = eles[i];
        //索引i后面元素依次向前移动一位即可
        for (int index = i; index < N - 1; index++) {
            eles[index] = eles[index + 1];
        }
        //元素个数-1
        N--;
        if (N < eles.length / 4) {
            resize(eles.length / 2);
        }
        return current;
    }


    //查找t元素第一次出现的位置
    public int indexOf(T t) {
        for (int i = 0; i < N; i++) {
            if (eles[i].equals(t)) {
                return i;
            }
        }
        return -1;
    }

    //根据参数newSize，重置eles的大小
    public void resize(int newSize) {
        //定义一个临时数组，指向原数组
        T[] temp = eles;
        //创建新数组
        eles = (T[]) new Object[newSize];
        //把原数组的数据拷贝到新数组即可
        for (int i = 0; i < N; i++) {
            eles[i] = temp[i];
        }
    }


    @Override
    public Iterator<T> iterator() {
        return new SIterator();
    }

    private class SIterator implements Iterator {
        private int cursor;
        public SIterator() {
            this.cursor = 0;
        }

        @Override
        public boolean hasNext() {
            return cursor < N;
        }

        @Override
        public T next() {
            return eles[cursor++];
        }
    }
}

复杂度：

get(i)：时间复杂度 O(1)

insert(int i, T t)：时间复杂度 O(n)

remove(int i)：时间复杂度 O(n)

3 链表

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列的结点（链表中的每一个元素称为结点）组成，结点可以在运行时动态生成。

//链表结点
public class Node<T> { 
    //存储元素 
    public T item; 
    //指向下一个结点 
    public Node next; 
    
    public Node(T item, Node next) { 
        this.item = item;
        this.next = next; 
    } 
}

复杂度：

get(i)：时间复杂度 O(n)

insert(int i, T t)：时间复杂度 O(1)

remove(int i)：时间复杂度 O(1)

3.1 单向链表

单向链表是链表的一种，它由多个结点组成，每个结点都由一个数据域和一个指针域组成，数据域用来存储数据，指针域用来指向其后继结点。链表的头结点的数据域不存储数据，指针域指向第一个真正存储数据的结点。

public class LinkList<T> implements Iterable<T> {
    //头结点
    private Node head;
    //链表的长度
    private int N;
    //结点类
    private class Node {
        //存储数据
        T item;
        //下一个结点
        Node next;

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }
    }

    public LinkList() {
        //初始化头结点、
        this.head = new Node(null, null);
        //初始化元素个数
        this.N = 0;
    }

    //清空链表
    public void clear() {
        head.next = null;
        this.N = 0;
    }

    //获取链表的长度
    public int length() {
        return N;
    }

    //判断链表是否为空
    public boolean isEmpty() {
        return N == 0;
    }

    //获取指定位置i出的元素
    public T get(int i) {
        //通过循环,从头结点开始往后找，依次找i次，就可以找到对应的元素
        Node n = head.next;
        for (int index = 0; index < i; index++) {
            n = n.next;
        }
        return n.item;
    }

    //向链表中添加元素t
    public void insert(T t) {
        //找到当前最后一个结点
        Node n = head;
        while (n.next != null) {
            n = n.next;
        }
        //创建新结点，保存元素t
        Node newNode = new Node(t, null);
        //让当前最后一个结点指向新结点
        n.next = newNode;
        //元素的个数+1
        N++;
    }

    //向指定位置i出，添加元素t
    public void insert(int i, T t) {
        //找到i位置前一个结点
        Node pre = head;
        for (int index = 0; index <= i - 1; index++) {
            pre = pre.next;
        }

        //找到i位置的结点
        Node curr = pre.next;
        //创建新结点，并且新结点需要指向原来i位置的结点
        Node newNode = new Node(t, curr);
        //原来i位置的前一个节点指向新结点即可
        pre.next = newNode;
        //元素的个数+1
        N++;
    }

    //删除指定位置i处的元素，并返回被删除的元素
    public T remove(int i) {
        //找到i位置的前一个节点
        Node pre = head;
        for (int index = 0; index <= i - 1; i++) {
            pre = pre.next;
        }
        //要找到i位置的结点
        Node curr = pre.next;
        //找到i位置的下一个结点
        Node nextNode = curr.next;
        //前一个结点指向下一个结点
        pre.next = nextNode;
        //元素个数-1
        N--;
        return curr.item;
    }

    //查找元素t在链表中第一次出现的位置
    public int indexOf(T t) {
        //从头结点开始，依次找到每一个结点，取出item，和t比较，如果相同，就找到了
        Node n = head;
        for (int i = 0; n.next != null; i++) {
            n = n.next;
            if (n.item.equals(t)) {
                return i;
            }
        }
        return -1;
    }


    @Override
    public Iterator<T> iterator() {
        return new LIterator();
    }

    private class LIterator implements Iterator {
        private Node n;

        public LIterator() {
            this.n = head;
        }

        @Override
        public boolean hasNext() {
            return n.next != null;
        }

        @Override
        public Object next() {
            n = n.next;
            return n.item;
        }
    }

    //用来反转整个链表
    public void reverse() {
        //判断当前链表是否为空链表，如果是空链表，则结束运行，如果不是，则调用重载的reverse方法完成反转
        if (isEmpty()) {
            return;
        }
        reverse(head.next);
    }

    //反转指定的结点curr，并把反转后的结点返回
    public Node reverse(Node curr) {
        if (curr.next == null) {
            head.next = curr;
            return curr;
        }
        //递归的反转当前结点curr的下一个结点；返回值就是链表反转后，当前结点的上一个结点
        Node pre = reverse(curr.next);
        //让返回的结点的下一个结点变为当前结点curr；
        pre.next = curr;
        //把当前结点的下一个结点变为null
        curr.next = null;
        return curr;
    }
}

3.2 双向链表

双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域用来存储数据，其中一个指针域用来指向其后继结点，另一个指针域用来指向前驱结点。链表的头结点的数据域不存储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一个真正存储数据的结点。

public class TowWayLinkList<T> implements Iterable<T> {
    //首结点
    private Node head;
    //最后一个结点
    private Node last;

    //链表的长度
    private int N;


    //结点类
    private class Node {
        //存储数据
        T item;
        //指向上一个结点
        Node pre;
        //指向下一个结点
        Node next;

        public Node(T item, Node pre, Node next) {
            this.item = item;
            this.pre = pre;
            this.next = next;
        }


    }

    public TowWayLinkList() {
        //初始化头结点和尾结点
        this.head = new Node(null, null, null);
        this.last = null;
        //初始化元素个数
        this.N = 0;
    }

    //清空链表
    public void clear() {
        this.head.next = null;
        this.head.pre = null;
        this.head.item = null;
        this.last = null;
        this.N = 0;
    }

    //获取链表长度
    public int length() {
        return N;
    }

    //判断链表是否为空
    public boolean isEmpty() {
        return N == 0;
    }

    //获取第一个元素
    public T getFirst() {
        if (isEmpty()) {
            return null;
        }
        return head.next.item;
    }

    //获取最后一个元素
    public T getLast() {
        if (isEmpty()) {
            return null;
        }
        return last.item;
    }

    //插入元素t
    public void insert(T t) {
        if (isEmpty()) {
            //如果链表为空：

            //创建新的结点
            Node newNode = new Node(t, head, null);
            //让新结点称为尾结点
            last = newNode;
            //让头结点指向尾结点
            head.next = last;
        } else {
            //如果链表不为空
            Node oldLast = last;

            //创建新的结点
            Node newNode = new Node(t, oldLast, null);

            //让当前的尾结点指向新结点
            oldLast.next = newNode;
            //让新结点称为尾结点
            last = newNode;
        }

        //元素个数+1
        N++;

    }

    //向指定位置i处插入元素t
    public void insert(int i, T t) {
        //找到i位置的前一个结点
        Node pre = head;
        for (int index = 0; index < i; index++) {
            pre = pre.next;
        }
        //找到i位置的结点
        Node curr = pre.next;
        //创建新结点
        Node newNode = new Node(t, pre, curr);
        //让i位置的前一个结点的下一个结点变为新结点
        pre.next = newNode;
        //让i位置的前一个结点变为新结点
        curr.pre = newNode;
        //元素个数+1
        N++;
    }

    //获取指定位置i处的元素
    public T get(int i) {
        Node n = head.next;
        for (int index = 0; index < i; index++) {
            n = n.next;
        }
        return n.item;
    }

    //找到元素t在链表中第一次出现的位置
    public int indexOf(T t) {
        Node n = head;
        for (int i = 0; n.next != null; i++) {
            n = n.next;
            if (n.next.equals(t)) {
                return i;
            }
        }
        return -1;
    }

    //删除位置i处的元素，并返回该元素
    public T remove(int i) {
        //找到i位置的前一个结点
        Node pre = head;
        for (int index = 0; index < i; index++) {
            pre = pre.next;
        }
        //找到i位置的结点
        Node curr = pre.next;
        //找到i位置的下一个结点
        Node nextNode = curr.next;
        //让i位置的前一个结点的下一个结点变为i位置的下一个结点
        pre.next = nextNode;
        //让i位置的下一个结点的上一个结点变为i位置的前一个结点
        nextNode.pre = pre;
        //元素的个数-1
        N--;
        return curr.item;
    }

    @Override
    public Iterator<T> iterator() {
        return new TIterator();
    }

    private class TIterator implements Iterator {
        private Node n;

        public TIterator() {
            this.n = head;
        }

        @Override
        public boolean hasNext() {
            return n.next != null;
        }

        @Override
        public Object next() {
            n = n.next;
            return n.item;
        }
    }
}

3.3 循环链表

链表整体要形成一个圆环状。让单向链表的最后一个节点的指针指向头结点。

4 题目

4.1 反转链表

LeetCode:24 题

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例：

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null) {
           ListNode tmp =  cur.next;
           cur.next = pre;
           pre = cur;
           cur = tmp;
        }
        return pre;
    }
}

4.2 快慢指针

给定一个链表，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。 否则，返回 false 。

示例：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。
public class Solution {
    public boolean hasCycle(ListNode head) {
        //快慢指针
        if(head == null || head.next == null) return false;
        ListNode slow = head;
        ListNode fast = head.next;
        while(slow != fast){
            if(fast == null || fast.next == null) return false;
            slow = slow.next;
            fast = fast.next.next;
        }
        return true;
    }
}
M78星云小码农
关注
  • 12
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Unity 面试篇|（六）数据结构和算法篇 【全面总结 | 持续更新】
游戏开发小Y的博客
01-20 4万+
先拿10000个数建堆，然后一次添加剩余元素，如果大于堆顶的数（10000中最小的），将这个数替换堆顶，并调整结构使之仍然是一个最小堆，这样遍历完后，堆中的10000个数就是所需的最大的10000个。桶排序是计数排序的升级版。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。这样处理就可以分别在每个文件的10^6个数据中找出最大的10000个数，合并到一起在再找出1000*10000中的最终的结果。
C/C++常见面试知识点总结附面试真题----20220326更新
生命在于折腾！
09-19 14万+
以下内容部分整理自网络，部分为自己面试的真题。 第一部分：计算机基础 1. C/C++内存有哪几种类型？ C中，内存分为5个区：堆(malloc)、栈(如局部变量、函数参数)、程序代码区（存放二进制代码）、全局/静态存储区（全局变量、static变量）和常量存储区（常量）。此外，C++中有自由存储区（new）一说。 2. 堆和栈的区别？ 1).堆存放动态分配的对象——即那些在程序运行时分配的对象......
【C++】面试常用知识点总结——基础篇
沙师弟专栏
07-15 5万+
三次握手的最主要目的是确认双方都有收发数据的能力。三次握手完成两个重要的功能，既要双方做好发送数据的准备工作(双方都知道彼此已准备好)，也要允许双方就初始序列号进行协商，这个序列号在握手过程中被发送和确认。第一次： A发给B。证明A有发消息的能力。第二次： B收到并发消息给A。证明B有收消息，并且有发消息的能力。第三次： A收到B消息。证明A有收消息的能力。二次握手达不到目的，四次多余。双方关闭连接要经过双方都同意。
《大话数据结构》知识点总结
江州月
07-03 1070
《大话数据结构》总共9章，今晚把全书大致看完了。 在此使用百度脑图把重要知识点做了梳理，方便自己回顾、复习。
数据结构面试题以及答案整理
weixin_42340902的博客
07-17 4万+
一、什么是数据结构？ 数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。结构包括逻辑结构和物理结构。 数据的逻辑结构包括4种 (1)集合：数据元素之间除了有相同的数据类型再没有其他的关系 (2)线性结构：数据元素之间是一对一的关系 ——线性表、栈、队列 (3)树形结构：数据元素之间是一对多的关系 (4)图状结构：数据元素之间是多对多的关系。 物理结构包括顺序存储结构和链式存储结构。 二、解释一下顺序存储与链式存储 顺序存储结构是用一段连续的存储空间来存储数据元
C/C++面试笔试知识点总结
weixin_42538789的博客
03-04 1万+
C/C++面试问题 1 const关键字的作用？ 1）欲阻止一个变量被改变，可使用const，在定义该const变量时，需先初始化，以后就没有机会改变他了； 2）对指针而言，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const； 3）在一个函数声明中，const可以修饰形参表明他是一个输入参数，在函数内部不可以改变其值； 4）对于类的成员函数，有时候必须指定其为const类型，表明其是一个常函数，不能修改类的成员变量； 5）对于类的成员函数，有时候必须指定其返回值为
深度学习知识点全面总结
热门推荐
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
01-05 23万+
本文详细介绍深度学习概念及原理，参考网上相关资料汇总，内容包含众多章节，包括神经网络基础及常见深度学习网络结构介绍，用于个人学习总结，适合深度学习初学者学习。同时介绍机器学习常见的分类算法：SVM、神经网络、随机森林、逻辑回归、KNN、贝叶斯。常见的监督学习算法：感知机、SVM、人工神经网络、决策树、逻辑回归.........
数据结构与算法面试知识点汇总（超全）
CSDN_dzh的博客
01-31 1万+
文章目录哈希函数和哈希表哈希函数哈希表 哈希函数和哈希表 哈希函数 哈希函数（散列函数）：类似于函数调用一样，给一个字符串作为输入，返回一个哈希码 性质： 1）输入域是无穷大的 2）输出域是有穷的，输出域要比输入域小 3）哈希函数不是一个随机函数，只要输入一样，输出就一样 4）输入域这么大而输出域这么小，而由于特性3的关系，就会导致输入不一样也有可能得到输出一样的值（哈希碰撞） 5）虽然有哈希...
Java基础知识点总结
是阿超
09-25 4695
Java基础知识点总结
谷粒商城面试知识点总结（二）
weixin_57869541的博客
10-06 1767
谷粒商城面试知识点总结（二）
面试知识点总结--数据结构1.pdf
01-25
"面试知识点总结--数据结构1.pdf" 本文档总结了数据结构的基础知识点，涵盖了算法的基本概念、算法的设计方法、数据结构的定义、存储结构、图形表示、线性结构和非线性结构、线性表的定义、顺序存储结构、插入和...
数据结构知识总结与结构网图
08-14
本文将围绕标题"数据结构知识总结与结构网图"展开，涵盖数组、链表、栈、队列、串、树和图等核心数据结构，并讨论它们的应用场景、特点以及相关算法。 首先，数组是最基本的数据结构，它提供了通过索引直接访问元素...
嵌入式面试知识点总结
03-20
嵌入式面试通常会涵盖一系列关键概念和技术，以下是一些重要的嵌入式面试知识点总结： 1. **处理器架构**： - **微控制器（MCU）**：理解其工作原理，包括CPU、内存、外设接口等组成部分。 - **ARM架构**：ARM...
Java面试高频知识点总结
12-21
以上是Java面试中常见的NIO和HashMap知识点的总结。理解和掌握这些概念对于提升Java编程能力以及应对面试至关重要。在实际开发中，合理使用NIO可以提高程序的并发性和效率，而深入理解HashMap的工作原理则有助于优化...
数组算法--基本查找
最新发布
2303_78660417的博客
07-20 211
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
数据结构专项-字符串
qq_52241267的博客
07-16 397
面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。深拷贝和浅拷贝：浅拷贝实际上是复制了被拷贝对象的引用，也就是说浅拷贝的和被拷贝对象指向的是同一块内存空间，而深拷贝则是连同引用的对象也被拷贝，两者指向的是不同的内存空间。然后计算乘法，故之后是*，再计算加法，因此+要在6的前面，不然就是计算4*(x+3)+6了，故选D。中缀表达式中应该先计算x+3，因此后缀表达式中+应该出现在x和3的后面，排除BC。
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1068
如有错误，欢迎指出~
HALCON数据结构
qq_44744164的博客
07-17 1013
HALCON数据结构

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值