数据结构与算法实战（三）基础数据结构

最新推荐文章于 2024-07-23 12:24:57 发布
最新推荐文章于 2024-07-23 12:24:57 发布
阅读量104 收藏
点赞数
分类专栏： 数据结构与算法实战 文章标签： 数据结构 java 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43533806/article/details/109476465
版权

数据结构与算法实战（三）基础数据结构

一、数组

数组最大优点：快速查询

1、二次封装属于我们的数组类

public class Array {
    
    private int[] data;
    private int size;
    
    //构造函数，传入数组的容量capacity构造Array
    public Array(int capacity){
        data = new int[capacity];
        size = 0;
    }
    //无参构造函数，传入数组的容量capacity = 10
    public Array(){
        this(10);
    }
    
    //获取数组中的元素个数
    public int getSize(){
        return size;
    }
    //获取数组的容量
    public int getCapacity(){
        return data.length;
    }

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

2、向数组中添加元素

向数组末添加元素
public void addLast(int e){
    if(size == data.length)
        throw new IllegalArgumentException("AddLast failed,Array is already full");

    data[size] = e;
    size++;
}
向指定位置添加元素
//向指定位置添加元素
public void add(int index,int e){
    if(size == data.length)
        throw new IllegalArgumentException("AddLast failed,Array is already full");
    
    if(index < 0 || index > size)
        throw new IllegalArgumentException("AddLast failed,Required index >= 0 and index <= size");

    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().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();
}

3、查询和修改元素

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

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

4、包含、搜索和删除元素

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

//查找数组中元素e所在的索引，如果不存在元素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.Index is illegal");

    E ret = data[index];

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

    if(size <= data.length / 2)
        resize(data.length / 2);
    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);
}
//动态数组
  private void resize(int newCapacity) {

        E[] newData = (E[]) new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

5、动态添加元素

//向指定位置添加元素
public void add(int index, E e) {

    if (index < 0 || index > size)
        throw new IllegalArgumentException("AddLast failed,Required index >= 0 and index <= size");

    if (size == data.length)
        resize(2 * data.length);

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

private void resize(int newCapacity) {

    E[] newData = (E[]) new Object[newCapacity];
    for (int i = 0; i < size; i++) {
        newData[i] = data[i];
    }
    data = newData;
}

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

添加操作 O(n)

addLast(e) : O(1)

addFirst(e) : O(n)

add(index , e) : O(n)

删除操作 O(n)

removeLast(e) : O(1)

removeFirst(e) : O(n)

remove(index , e) : O(n)

修改操作（支持随机访问） O(1)

set(index , e)

查询操作

get(index) O(1)

contains(e) O(n)

find(e) O(n)

二、栈

  • 栈是一种线性结构
  • 相比数组，栈对应的操作是数组的子集
  • 只能从栈顶添加或取出元素
  • 后进先出（LIFO）

栈的实现

先定义一个接口

public interface Stack<E> {
    
    int getSize();
    boolean isEmpty();
    void push(E e);
    E pop();
    E push();
}

基于之前说过的动态数组实现栈结构

//基于动态数组，实现栈
public class ArrayStack<E> implements Stack {

    Array<E> array;

    public ArrayStack(int capacity){
        array = new Array<>(capacity);
    }

    public ArrayStack(){
        array = new Array<>();
    }

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

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

    public int getCapacity(){
        return array.getCapacity();
    }

    @Override
    public void push(Object o) {
        array.addLast((E) o);
    }

    @Override
    public E pop() {
        return array.removeLast();
    }

    @Override
    public E peek() {
        return array.getLast();
    }

    @Override
    public String toString() {

        StringBuilder res = new StringBuilder();
        res.append("Stack :");
        res.append("[");
        for (int i = 0; i < array.getSize(); i++) {
            res.append(array.get(i));
            if(i != array.getSize() -1)
                res.append(", ");
        }
        res.append("]  top");

        return res.toString();
    }
}

注意：栈的五个基本操作都是O(1)的时间复杂度

栈的应用

20. 有效的括号

难度简单1947

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。

注意空字符串可被认为是有效字符串。

示例 1:

输入: "()"
输出: true

示例 2:

输入: "()[]{}"
输出: true

示例 3:

输入: "(]"
输出: false

class Solution {
    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();
    }

三、队列

  • 也是一种线性结构
  • 相比数组，队列的操作是数组的子集
  • 只能从队尾添加元素，只能从队首取出元素
  • 先进先出

数组队列的实现

先定义一个接口

public interface Queue<E> {
    
    int getSize();
    boolean isEmpty();
    void enqueue();
    E dequeue();
    E getFront();
    
}

public class ArrayQueue<E> implements Queue {

    private Array<E> array;

    public ArrayQueue(int capacity){
        array = new Array<>(capacity);
    }

    public ArrayQueue(){
        array = new Array<>();
    }

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

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

    public int getCapacity(){
        return array.getCapacity();
    }

    @Override
    public void enqueue(Object e) {
        array.addLast((E) e);
    }

    @Override
    public E dequeue() {
        return array.removeFirst();
    }

    @Override
    public E getFront() {
        return array.getFirst();
    }
    @Override
    public String toString() {

        StringBuilder res = new StringBuilder();
        res.append("Queue :");
        res.append("front [");
        for (int i = 0; i < array.getSize(); i++) {
            res.append(array.get(i));
            if(i != array.getSize() -1)
                res.append(", ");
        }
        res.append("] tail");

        return res.toString();
    }
ArrayQueue的复杂度分析

除了dequeue() 为O(n) ,其余都为O(1)

数组队列的问题

删除首元素是O(n)的复杂度

由此引出循环队列

循环队列

front指向首元素，tail指向尾元素的后一个位置

起始的时候front == size 队列为空，然后一直向后添加元素a，b…，直到添加到f的时候满了，现在删除a，b两元素，front指向c，然后计算(tail+1) % capacity ，这是tail新指向的索引

在这里插入图片描述

当(tail+1) % capacity == front 时，队列满

capacity中会浪费一个空间

代码实现
public class LoopQueue<E> implements Queue{

    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 tail == front;
    }

    @Override
    public void enqueue(Object e) {

        if((tail+1) % data.length == front)
            resize(getCapacity() * 2);

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

    private void resize(int newCapacity) {
        E[] newData = (E[]) new Object[newCapacity + 1];
        for (int i = 0; i < size; i++) {
            newData[i] = data[(i + front) % data.length];
        }
        data = newData;
        front = 0;
        tail = 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().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();
    }

    public static void main(String[] args) {
        LoopQueue<Integer> queue = new LoopQueue<>();
        for (int i = 0; i < 10; i++) {
            queue.enqueue(i);
            System.out.println(queue);

            if(i % 3 == 2){
                queue.dequeue();
                System.out.println("1111"+queue); }
        }
    }
}

数组队列和循环队列性能比较

import java.util.Random;

public class Main {

    public static void main(String[] args) {

        int opCount = 200000;

        ArrayQueue<Integer> arrayQueue = new ArrayQueue<>();
        double time1 = testQueue(arrayQueue,opCount);
        System.out.println("ArrayQueue , time:  "+ time1 + "s");

        LoopQueue<Integer> loopQueue = new LoopQueue<>();
        double time2 = testQueue(loopQueue,opCount);
        System.out.println("LoopQueue , time:  "+ time2 + "s");

    }

    //测试使用队列q运行opCount个入队、出队操作所需要的时间，单位：秒
    private static double testQueue(Queue<Integer> q, int opCount){

        long startTime = System.nanoTime();

        Random random = new Random();
        for (int i = 0; i < opCount; i++) {
            q.enqueue(random.nextInt(Integer.MAX_VALUE));
        }
        for (int i = 0; i < opCount; i++) {
            q.dequeue();
        }

        long endTime = System.nanoTime();

        return (endTime - startTime)/1000000000.0;

    }
}

在这里插入图片描述

155. 最小栈

设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。

  • push(x) —— 将元素 x 推入栈中。
  • pop() —— 删除栈顶的元素。
  • top() —— 获取栈顶元素。
  • getMin() —— 检索栈中的最小元素。
import java.util.Stack;
/**
 * 解题思路：
 *          使用一个栈，每输入一个数字，入栈两次，第一次是自身元素，第二次是入栈元素和栈顶元素之间的最小值
 *          保持栈顶就是整个栈中元素的最小值
 *          例如输入2，3，1。 在栈中就是 2，2，3，2，1，1
 */
public class MinStack {

    private Stack<Integer> stack;
    /** initialize your data structure here. */
    public MinStack() {
        stack = new Stack<>();
    }

    public void push(int x) {

        if(stack.isEmpty()){
            stack.push(x);
            stack.push(x);
        }else {
            int temp = stack.peek();
            stack.push(x);
            if(x > temp){
                stack.push(temp);
            }else {
                stack.push(x);
            }
        }
    }

    public void pop() {

        stack.pop();
        stack.pop();
    }

    //获取栈顶元素
    public int top() {

        return stack.get(stack.size() - 2);
    }

    public int getMin() {

        return stack.peek();
    }
}
ycjisme
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构和算法学习(二)-数据结构基础
休憩小屋
06-25 390
基本数据结构：数组、链表、栈和队列相关知识
数据结构与算法（三）
SiranTang的博客
04-03 188
C++ 数据结构与算法 后台开发 面试
栈的应用（三种应用）
weixin_73193549的博客
08-23 2866
栈的引入简化了程序设计的问题，使得我们不需要像数组一样关注下标的增减，随机位置的插入与删除，在一些情况下可以以较小的时间复杂度解决问题，下面介绍一下栈常用的三个场景：递归，后缀表达式以及浏览器的前进后退。由图可知，显然符合栈这样的数据结构，简单的说，在前行阶段，对于每一层递归，函数的局部变量，参数值以及返回地址都被压入栈中；浏览器使用栈来存储用户访问的页面，每次访问新页面时，将其压入栈中，点击后退按钮时，从栈顶弹出页面。在计算机中，中缀表达式是人们常用的表达式形式，但计算机在计算表达式时，为了方便处理。
栈及其应用
weixin_51550438的博客
10-04 1799
Java语言介绍栈数据结构
栈的应用举例
qq_57484399的博客
10-07 4248
栈和队列主要用于计算过程中保存的临时数据，如果数据在编程时就可以确定，那么使用几个变量就可以临时存储，但是如果存储的数据项数不能确定，就需要复杂的存储机制。这样的存储机制称为缓存。栈和队列就是使用最多的缓存结构。我们在调用方法的时候 , 时常调用别的成员方法, 递归循环调用 , 那调用到最后,又从最后一个函数,依次返回值 , 我们熟悉这个机制.但是我们却不知道 , 编译器是如何把这些调用信息存储起来的,用什么方法存储起来的, 这里就需要我们用到栈了,先进后出还有生活中 , 我们往木桶里放球 ,
栈的实际应用
weixin_44547668的博客
03-18 3072
概述 1)栈的英文为(stack) 2)栈是一个先入后出的有序列表 3)栈是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表,允许插入和删除的一端,为变化的一段,称为栈顶(TOP),另一端为固定的一段,称为栈底(BOTTOM) 4)根据栈的定义可知,最先放入栈中元素在栈底,最后放入的元素在栈顶,而删除元素相反,最后放入的元素先删除,最先放入的元素后删除 栈的应用场景 1)子程序的调用:在跳往子程序前,会先将下个指令的地址存到堆栈中,直到子程序执行完后再将地址取出,以回到原来的程序中 2)
【数据结构】 栈（Stack）的应用场景
m0_71731682的博客
08-26 3350
栈（Stack）又名堆栈，作为一个== 先进后出== 的数据结构。它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。
数据结构与算法 实战代码
03-13
数据结构与算法是计算机科学的基础，对于任何编程领域，尤其是软件开发和系统设计，都有着至关重要的作用。在Java编程中，理解和熟练运用数据结构与算法能够显著提高程序的效率和可维护性。以下是对这些核心概念的...
西安电子科技大学-数据结构与算法-期末知识点总结.pdf
01-05
"西安电子科技大学-数据结构与算法-期末知识点...本资源涵盖了数据结构与算法的基本概念、线性表、栈与队列、树与二叉树、图、查找算法和排序算法等方面的知识点，对于学习数据结构与算法的学生具有重要的参考价值。
约瑟夫生者死者游戏-Python数据结构与算法实战项目完整源码与界面资源
07-01
约瑟夫生者死者问题是数据结构与算法中的经典问题，本项目基于单向循环链表这一数据结构实现，并使用 tkinter技术 实现约瑟夫问题的可视化。项目使用了图形用户界面GUI技术，使用的开发工具为PyCharm 2021.3。实现了...
数据结构与算法资料_数据结构与算法_
09-29
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。在Java编程中，掌握数据结构和算法能够帮助开发者编写出性能优越、可维护性高的代码。以下将详细阐述相关知识点。 1. **数据结构**: 数据...
python 数据结构与算法.zip
06-16
在IT领域，数据结构与算法是编程的基础，尤其对于学习C/C++/JAVA/Python等语言的大学生来说，这是必须掌握的重要知识。"python 数据结构与算法.zip"这个压缩包很可能包含了丰富的学习资源，帮助学生深入理解数据结构...
栈和栈的应用
AX_Chu的博客
04-17 2448
一、栈 1、栈的介绍 定义：栈是只允许在一端插入或删除的特定线性表。 栈的应用场景： 1、子程序的调用：在跳往子程序前，会将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。 2、处理递归调用：和子程序调用类似，除了存储下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。 3、 表达式的转换[中缀表达式转后缀表达式]与求值（实际解决）—使用操作数栈和运算符栈来完成 4、二叉树的遍历—行遍历 5、图形的深度优先（depth—first）搜索法。 2、使用数组来模拟栈 思路分析：
栈的四个应用
iEucliwood的博客
12-25 4850
平衡符号 每个右花括号，右方括号及右圆括号必然对应相应的左括号。序列“[ ( ) ]”是合法的，“ [ ( ])“ 是错误的。 显然也不值得为此编写一个大型程序。事实上检验这些是很容易的，为简单起见我们仅就圆括号、方括号和花括号进行检验，并忽略其他字符。 这个简单的算法用到一个栈，叙述如下： 做一个空栈。读入字符直到文件尾。如果字符是一个开放字符（即左符号），将其推入栈中。如果字符是一个封闭符号(即右符号），则当栈空时报错...
数据结构-栈及栈的应用
初始化的博客
07-19 4541
栈的概述 栈式一种重要的线性结构，属于一种操作受限的线性表 栈(stack) 是限定尽在表尾进行插入或删除操作的线性表 表尾端称为栈顶(top)，表头端称为栈底(bottom) 栈的元素先进后出(后进先出)，即最先进入栈的元素最后出栈 ...
栈的简单实现及应用
南猿北者博客
11-10 2368
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。入栈：栈的插入操作叫做进栈/压栈/入栈；（从栈顶插入数据）出栈：栈的删除操作叫做出栈；（也是从栈顶删除数据）做个简单的比喻：我们的栈就相当于一个弹夹，入栈操作就相当向弹夹之中压入子弹；出栈操作就相当将弹夹里面的子弹取出来；而这个压入子弹和取出子弹都只有一个口；这个口就是栈顶，出入数据都从栈顶进行；
栈的应用
热门推荐
Gavin
05-07 3万+
本文讲述了栈的四个应用的例子，包括进制转换、括号匹配检验、迷宫求解以及中缀表达式转后缀表达式和表达式的求值
数据结构与算法实战
jiqiren1994的博客
04-24 217
作业一：数据结构与算法基础 判断数组中所有的数字是否只出现一次。给定一个数组array，判断数组 array 中是否所有的数字都只 出现过一次。例如，arr = {1, 2, 3}，输出 YES。又如，arr = {1, 2, 1}，输出 NO。约束时间复杂度为 O(n)。 理题 判断一系列数中的数字是否都只出现过一次，或者判断一系列数中的数字是否有重复出现过。 都只出现过一次则输出yes，否则输出no。 思路一 两两相比，时间复杂度为O(n^2) 思路二 排序加前后比较是否相等，时间复杂度为O(n^2)
数据结构——二叉树性质
最新发布
鲸落博客
07-23 293
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
数据结构-＞线性结构-＞顺序存储-＞静态链表
qq_68495605的博客
07-20 218
【代码】数据结构-＞线性结构-＞顺序存储-＞静态链表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值