数据结构笔记

最新推荐文章于 2023-08-01 10:31:47 发布
最新推荐文章于 2023-08-01 10:31:47 发布
阅读量2k 收藏 5
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38009252/article/details/95951006
版权

Chapter 1 简介

在这里插入图片描述
在这里插入图片描述

Chapter 2 数组

三种初始化方法：
1.int[] a = new int[100];
2.int[] a = new int[]{1, 2, 3};
3.int[] a = {1, 2, 3};

动态数组

private void resize(int newCapacity) {
   
    E[] newData = (E[])new Object[newCapacity];
    for (int i = 0; i < size; i++)
        newData[i] = data[i];
    data = newData;//指向重定义尺寸的数组
}

时间复杂度分析

在这里插入图片描述
均摊情况下，resize的复杂度为O(1)，addLast时间复杂度O(1)，removeLast时间复杂度O(1)

复杂度震荡

在这里插入图片描述
解决：Lazy

if (size == data.length / 4 && data.length / 2 != 0)
    resize(data.length / 2);
return result;

Chapter 3 栈和队列

栈

线性结构，只能在栈顶进行添加和删除——Last In First Out
应用：Undo、程序调用的系统栈
栈的实现

interface Stack<E>
void push(E)
E pop()
E peek()
int getSize()
boolean isEmpty()

在这里插入图片描述

括号匹配

栈顶元素反应了在嵌套的层次关系中，最近的需要匹配的元素

public boolean isValid(String s){
   
    
    Stack<Character> stack = new Stack<>();
    for (int i = 0; i < s.length(); i ++){
   
        char c = s.charAt(i);
        if (c == '(' || c == '[' || c == '{')
            stack.push(c);
        else {
   
            if (stack.isEmpty())
                return false;
            
            char topChar = stack.pop();
            if (c == ')' && topChar != '(')
                return false;
            if (c == ']' && topChar != '[')
                return false;
            if (c == '}' && topChar != '{')
                return false;
        }
    }
    
    return stack.isEmpty();
    
}

队列

线性结构，只能在队尾添加元素，在队首取出元素——First In First Out
队列的实现

interface Queue<E>
void enqueue(E)
E dequeue()
E getFront()
int getSize()
boolean isEmpty()

在这里插入图片描述

循环队列

front指向队首，tail指向队尾元素后一个位置
front == tail, 队列为空;
（tail + 1) % c == front, 队列满
注：capacity中，浪费一个空间
在这里插入图片描述

public class LoopQueue<E> implements Queue<E> {
   

    private E[] data;
    private int front, tail;
    private int size;

    public LoopQueue(int capacity){
   
        data = (E[])new Object[capacity + 1];
        front = 0;
        tail = 0;
        size = 0;
    }

    public LoopQueue(){
   
        this(10);
    }

    public int getCapacity(){
   
        return data.length - 1;
    }

    @Override
    public int getSize() {
   
        return size;
    }

    @Override
    public boolean isEmpty() {
   
        return front == tail;
    }

    private void resize(int newCapacity){
   
        E[] newData = (E[])new Object[newCapacity + 1];
        for (int i = 0; i < size; i++)
            newData[i] = data[(front + i) % data.length];

        data = newData;
        front = 0;
        tail = size;
    }

    @Override
    public void enqueue(E e) {
   

        if ((tail + 1) % data.length == front)
            resize(getCapacity() * 2);//不用length，因为天然浪费一个位置

        data[tail] = e;
        tail = (tail + 1) % data.length;
        size ++;

    }

    @Override
    public E dequeue() {
   

        if (isEmpty())
            throw new IllegalArgumentException("cannot dequeue from an empty queue!");

        E ret = data[front];
        data[front] = null;
        front = (front + 1) % data.length;
        size --;
        if (size == getCapacity() / 4 && getCapacity() / 2 != 0)
            resize(getCapacity() / 2);

        return ret;
    }

    @Override
    public E getFront() {
   
        if (isEmpty())
            throw new IllegalArgumentException("queue is empty!");

        return data[front];
    }

    @Override
    public String toString(){
   

        StringBuilder res = new StringBuilder();
        res.append(String.format("Queue: size = %d, capacity = %d\n", size, getCapacity()));
        res.append("front [");
        for (int i = front; i != tail; i = (i + 1) % data.length){
   
            res.append(data[i]);
            if ((i + 1) % data.length != tail)
                res.append(", ");
        }
        res.append("] tail");
        return res.toString();

    }
}

在这里插入图片描述

数组队列和循环队列的比较

在这里插入图片描述

Chapter 4 链表

线性数据结构

在这里插入图片描述
在这里插入图片描述
优点：真正动态，不需要处理固定容量的问题
缺点：丧失了随机访问的能力
在这里插入图片描述

链表的节点

private class Node{
   
    public E e;
    public Node next;

    public Node(E e, Node next){
   
        this.e = e;
        this.next = next;
    }

    public Node(E e){
   
        this(e, null);
    }

    public Node(){
   
        this(null, null);
    }

    @Override
    public String toString(){
   
        return e.toString();
    }
}

为链表添加元素

//在链表中间index(0-based)位置添加元素e
    public void add(int index, E e){
   
        if (index < 0 || index > size)
            throw new IllegalArgumentException("add failed, illegal index");

            Node prev = dummyHead;
            for (int i = 0; i < index; i++)
                prev = prev.next;

//            Node node = new Node(e);
//            node.next = prev.next;
//            prev.next = node;
            prev.next = new Node(e, prev.next);
            size ++;
    }

    //在链表头添加元素e
    public void addFirst(E e){
   
//        Node node = new Node(e);
//        node.next = head;
//        head = node;
        add(0, e);
    }

    //在链表末尾添加元素e
    public void addLast(E e){
   
        add(size, e);
    }

在这里插入图片描述
在这里插入图片描述
注：顺序不能颠倒

为链表设立虚拟头结点

在这里插入图片描述

从链表中删除元素

//从链表中删除index(0-based)位置的元素，返回删除的元素
public E remove(int index){
   
    if (index < 0 || index > size)
        throw new IllegalArgumentException("remove failed, illegal index");

    Node prev = dummyHead;
    for (int i = 0; i < index; i++){
   
        prev = prev.next;
    }
    Node retNode = prev.next;

    prev.next = retNode.next;
    retNode.next = null;
    size --;

    return retNode.e;
}

public E removeFirst(){
   
    return remove(0);
}
public E removeLast(){
   
    return remove(size - 1);
}

在这里插入图片描述

其他操作

//获得链表第index(0-based)个位置的元素
public E get(int index){
   
    if (index < 0 || index > size)
        throw new IllegalArgumentException("add failed, illegal index");

    Node cur = dummyHead.next;
    for (int i = 0; i < index; i++)
        cur = cur.next;
    return cur.e;
}

//获得链表第一个元素
public E getFirst(){
   
    return get(0);
}

//获得链表最后一个元素
public E getLast(){
   
    return get(size - 1);
}

//修改链表第index(0-based)个位置的元素为e
public void set(int index, E e){
   
    if (index < 0 || index > size)
        throw new IllegalArgumentException("set failed, illegal index");

    Node cur = dummyHead.next;
    for (int i = 0; i < index; i++)
        cur = cur.next;
    cur.e = e;
}

//查找链表中是否有元素e
public boolean contains(E e){
   
    Node cur = dummyHead.next;
    while (cur != null){
   
        if (cur.e.equals(e))
            return true;
        cur = cur.next;
    }
    return false;
}

时间复杂度分析

增删改查：O(n)
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

使用链表实现栈

将链表头做为栈顶

public class LinkedListStack<E> implements Stack<E> {
   

    private LinkedList<E> list;

    public LinkedListStack(){
   
        list = new LinkedList<E>();
    }

    @Override
    public int getSize() {
   
        return list.getSize();
    }

    @Override
    public boolean isEmpty() {
   
        return list.isEmpty();
    }

    @Override
    public E pop() {
   
        return list.removeFirst();
    }

    @Override
    public void push(E e) {
   
        list.addFirst(e);
    }

    @Override
    public E peek() {
   
        return list.getFirst();
    }
 }

带有尾指针的链表：使用链表实现队列

在这里插入图片描述
注：由于没有dummyHead，要注意链表为空的情况

public class LinkedListQueue<E> implements Queue<E> {
   

    private class Node{
   
        public E e;
        public Node next;

        public Node(E e, Node next){
   
            this.e = e;
            this.next = next;
        }

        public Node(E e){
   
            this(e, null);
        }

        public Node(){
   
            this(null, null);
        }

        @Override
        public String toString(){
   
            return e.toString();
        }
    }

    private Node head, tail;
    private int size;

    public LinkedListQueue(){
   
        head = null;
        tail = null;
        size = 0;
    }

    @Override
    public int getSize() {
   
        return size;
    }

    @Override
    public boolean isEmpty() {
   
        return size == 0;
    }

    @Override
    public void enqueue(E e) {
   
        if (tail == null){
   
            tail = new Node(e);
            head = tail;
        }else {
   
            tail.next = new Node(e);
            tail = tail.next;
        }
        size ++;
    }

    @Override
    public E dequeue() {
   
        if (isEmpty())
            throw new IllegalArgumentException("cannot dequeue from a empty queue");

        Node retNode = head;
        head = head.next;
        retNode.next = null;

        if (head == null)//队列中只有一个元素的情况
            tail = null;
        size --;

        return retNode.e;
    }

    @Override
    public E getFront() {
   
        if (isEmpty())
            throw new IllegalArgumentException("queue is empty");
        return head.e;
    }

    @Override
    public String toString(){
   
        StringBuilder res = new StringBuilder();
        res.append("Queue: front");

        Node cur = head;
        while (cur != null){
   
            res.append(cur + "->");
            cur = cur.next;
        }

        res.append("null tail");
        return res.toString();
    }

}

Chapter 5 链表与递归

删除单链表中所有val元素

解法一

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */

public class Solution {
   

    public ListNode removeElements(ListNode head, int val){
   

        while (head != null && head.val == val){
   
            //head = head.next;
            ListNode delNode = head;
            head = head.next;
            delNode.next = null;
        }

        if (head == null)
            return null;

        ListNode prev = head;
        while (prev.next != null){
   

            if (prev.next.val == val){
   
                //prev.next = prev.next.next;
                ListNode delNode = prev.next;
                prev.next = delNode.next;
                delNode.next = null;
            }else {
   
                prev = prev.next;
            }

        }

        return head;

    }

}

解法二——使用虚拟头结点

public class Solution2 {
   

    public ListNode removeElements(ListNode head, int val){
   

        //创建虚拟头结点
        ListNode dummyHead = new ListNode(-1);
        dummyHead.next = head;
        
        ListNode prev = dummyHead;
        while (prev.next != null){
   
            if (prev.next.val == val){
   
                //prev.next = prev.next.next;
                ListNode delNode = prev.next;
                prev.next = delNode.next;
                delNode.next = null;
            } else {
   
                prev = prev.next;
            }
        }
        
        return dummyHead.next;

    }
}

链表和递归

本质：将原来的问题，转化为更小的同一问题
例：

public class Sum {
   

    public static int sum(int[] arr){
   
        return sum(arr, 0);
    }

    private static int sum(int[] arr, int l){
   
        //求解基本问题
        if (l == arr.length)
            return 0;
        //把原问题转化成更小的问题
        return arr[l] + sum(arr, l + 1);
    }

    public static void main(String[] args) {
   

        int[] nums = {
   1, 2, 3, 4, 5, 6, 7, 8};
        System.out.println(sum(nums));

    }

}

在这里插入图片描述
解法三——删除链表中所有val

public class Solution3 {
   

    public ListNode removeElements(ListNode head, int val){
   

        if (head == null)
            return null;

        //res是head后跟的链表删除val后的结果
        head.next = removeElements(head.next, val);
//        if (head.val == val){
   
//            //head需要删除，返回head后跟的链表删除val后的结果
//            return head.next;
//        }else {
   
//            //head不需要删除
//            return head;
//        }
        return head.val == val ? head.next : head;

    }

递归运行机制

在这里插入图片描述
递归调用是有代价的：函数调用+系统栈空间

递归算法的调试

在这里插入图片描述

更多问题

双链表

class Node{
   
	E e;
	Node next, prev;
}

在这里插入图片描述
循环链表

class Node{
   
	E e;
	Node next, prev;
}

在这里插入图片描述
数组链表

class Node{
   
	E e;
	int next;
}

在这里插入图片描述

Chapter 6 二分搜索树

二叉树

动态数据结构、具有天然递归结构（左子树，右子树）

class Node {
   
	E e;
	Node left;
	Node right;
}

二叉树是递归定义的，逻辑上二叉树有5中基本形态：

·空二叉树
·只有一个根节点的二叉树
·只有左子树
·只有右子树
·完全二叉树

在这里插入图片描述
满二叉树、完全二叉树、…

二分搜索树(Binary Search Tree)

·二分搜索树是二叉树
·二分搜索树的每个节点的值：
   ·大于其左子树所有节点的值
   ·小于其右子树所有节点的值
·二分搜索树的每一棵子树也是二分搜索树

注：存储的元素必须有可比较性: BST<E extends Comparable>

public class BST<E extends Comparable<E>> {
   

    private class Node{
   
        public E e;
        public Node left, right;

        public Node(E e){
   
            this.e = e;
            left = null;
            right = null;
        }
    }

    private Node root;
    private int size;

    public BST(){
   
        root = null;
        size = 0;
    }

    public int size(){
   
        return size;
    }

    public boolean isEmpty(){
   
        return size == 0;
    }
    
}

1.BST添加新元素

//向BST添加新元素e
public void add(E e){
   

    if (root == null){
   
        root = new Node(e);
        size ++;
    }else {
   
        add(root, e);
    }

}

//向以node为根的BST插入元素e，递归算法
private void add(Node node, E e){
   

    //递归终止条件
    if (e.equals(node.e))
最低0.47元/天 解锁文章
你好丑啊
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
LeetCode之俩数相加
weixin_44827241的博客
10-13 176
题目： 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外，这两个数都不会以 0 开头。 示例： 方法：模拟 题目解析：此题解法不难，不过容易被题目中的示例所误导，并不需要去判断原因，而我就是陷入此误区，还有一个问题需要注意的是相加之后的进位问题，个位数相加进位的话必定是1。 class Solution { pu
【新手小白刷leetcode记录贴】2.两数相加
qq_39187593的博客
10-13 371
最近课程有些紧，没太多时间刷题，今天抽出点时间来做做第二题：两数相加： 刚一拿到题，有些思路，但是因为不会java中的创建链表和链表相关的操作，所以无法下手，只好参考题解，才发现，自己的思路也考虑的不周全。 首先，题中给出的链表类的定义（觉得类似于c语言中的结构体），思路：创建两个ListNode的对象，（在java中没有指针 ，这两个对象就是地址）分别叫做 head 和tail ，这两个结点用来代表 两数相加的和 所组成链表的 头结点和尾结点。然后再定义一个carry代表进位...
记录LC：两数相加
一只程序小洋的博客
03-06 338
给你两个非空 的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0开头。 class Solution { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { //定义一个新联表伪指针，用来指向头指针，返回结果 ListNod...
数据结构——绪论
互联网底层民工的博客
08-01 816
**数据**：数据是对客观事物的符号表示，在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。 **数据元素**：数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。一个数据元素可由若干个数据项组成，数据项是构成数据元素的不可分割的最小单位。 **数据对象**：数据对象是性质相同的数据元素的集合，是数据的一个子集。 **数据结构**：数据结构是相互之间存在一种或多种特定关系的数据元素的集合。 数据元素都不是孤立存在的，而是在它们之间存在着某种关系，这种数据元素相
力扣刷题-单链表两数相加
Hi_shallyi的博客
03-25 2713
每日一道力扣刷题总结：单链表-两数之和，难易程度：中等。
数据结构笔记.docx
12-19
数据结构笔记 数据结构是计算机科学中的一门重要学科，涉及到数据的存储、表示和操作等方面。本笔记涵盖了数据结构的基本概念、线性表、栈和队列、树、图、排序和查找等重要知识点。 一、数据结构的基本概念 数据...
郝斌数据结构笔记.pdf
09-11
郝斌数据结构笔记 数据结构概述： 数据结构是指在计算机中对数据的存储、组织和管理的方式。它是软件最核心的课程，学完了啥也干不了。数据结构 = 个体的存储 + 个体的关系存储，算法 = 对存储数据的操作。 知识点...
数据结构 笔记
07-20
这份“数据结构笔记”涵盖了这一主题的各个方面，旨在帮助学习者深入理解并掌握数据结构的基本原理和应用。 一、数组 数组是最基本的数据结构之一，它是由相同类型元素构成的有序集合。每个元素都有一个唯一的索引...
数据结构笔记2022.pdf
08-19
数据结构笔记2022.pdf
数据结构笔记：栈
01-20
分类目录——数据结构笔记](https://blog.csdn.net/bbjg_001/category_9753496.html) 栈（stack），有些地方也成为堆栈，是一种容器，可存储元素、访问元素、删除元素，他的特点是值能允许在容器的一段（称之为 栈顶...
自考数据结构笔记.ppt
02-21
自考数据结构笔记 本资源摘要信息来自自考数据结构笔记.ppt，涵盖了数据结构的基本概念、算法和算法分析、线性表的逻辑结构和存储结构等知识点。 一、数据结构基本概念 数据结构是研究非数值计算的程序设计问题中...
郝斌数据结构笔记
11-13
郝斌数据结构笔记 。
王道考研-数据结构笔记
最新发布
09-16
"王道考研-数据结构笔记"是一份专为准备计算机专业考研的学生编写的参考资料，旨在帮助他们系统地学习和复习这个关键领域的知识点。 首先，我们要理解数据结构的基本概念。数据结构是组织和存储数据的方式，它不仅...
数据结构 (1)_数据结构笔记_
09-29
在"数据结构 (1)_数据结构笔记_"中，可能涵盖以下几个主要知识点： 1. **线性数据结构**：这类数据结构中元素呈线性排列，如数组和链表。数组是最基础的数据结构，元素通过索引访问，但插入和删除操作相对复杂。...
力扣刷题2
qq_45616828的博客
05-06 364
第二题，两个链表 ，思路很清晰，从头相加，如果res>10，此位留res%10，下一位res则需要加1，以此类推。 1、但是有许多细节需要考虑，比如长度不一样？需要怎么处理？变为0？ 2、最后一个相加>10，需要开辟新的空间存储额外的1。 3、 嗯。。思路很简单 ，但是代码不会写。。。 4、参考了别人的代码，自己做详细的注释。大体思路是采用双指针。 classSolution{ public: ListNode*addTwoNumbers(ListNode*l...
Leetcode Hot 100题 题解
weixin_43757333的博客
04-10 2732
1.两数之和 原来以为和剑指offer上的题一样，后面发现不是，本题不是有序数组所以不能用双指针和滑动窗口。 普通的暴力解法就是一个双循环，对于每个x，遍历数组查看是否有对应的target-x。 但是由于有一点，例如1 4 5 7 9 2 1 target为8的情况下，下标为1的1，和下标为4的7可以组成一个，但是当遍历到下标为4的7时，不能再和第一个1组成一个。原因在于题目的设定： 并且只需要遍历到倒数第二个数即可，最后一个数已经没有可以匹配的了 所以代码如下： class S
笔记：数据结构基本概念和术语
m0_60272036的博客
10-07 241
数据：是对客观事务的符号的表示，在计算机科学中是指所有能输入到计算机中并被计算机程序 处理的符号的总称。 数据的含义极其广泛，如图像，声音等都可以通过编码而归之于数据的范畴。 数据元素：1.数据基本单位，在计算机中通常作为一个整体进行考虑和处理。 2.一个数据元素由若干的数据项组成（例如一本书的书目消息为一个数据元素，而书目 消息中每一项书名，作者名为一个数据项，数据项为数据不可分最小...
【LeetCode】2. 两数相加
记录、总结
02-10 999
题目描述： 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 示例 1： 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. 示例 2： 输入：l1 = [0], l2 = [0] 输出：[0] 示例 3： 输入：l1 = [9,9,9,9,9,9,9]
数据结构学习笔记.docx
12-02
《数据结构学习笔记.docx》是一份包含关于算法时间复杂度、空间复杂度以及线性表的基本特点和存储结构的学习笔记。在学习笔记中提到，算法的时间复杂度T(n)表示算法执行时间的增长率和问题规模n的增长率相同，用O(f...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值