算法第二部分（1）

最新推荐文章于 2023-03-27 16:32:52 发布
最新推荐文章于 2023-03-27 16:32:52 发布
阅读量109 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39100543/article/details/92426150
版权

算法第一章

使我们可以高效获取数据和修改数据

分为 线性结构，树结构，图结构

数据库中包含大量数据结构，系统任务切换，文件切换，寻路算法。

线性结构

数组，栈，队列，链表，哈希表

其中，动态数组，栈，队列，底层依托静态数组，靠resize解决固定容量问题

树结构

二叉树，二分搜索树，红黑树

图结构

邻接矩阵，邻接表

算法第二章

新建一个数组

private E[] data;
    //data有多少有效容量
    private int size;

    /**
     * 构造函数，传入数组的容量capacity构造Array
     * @param capacity
     */
    public Array(int capacity){
        data= (E[])new Object[capacity];
        size=0;
    }

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

    public Array(E[] arr){
        data= (E[]) new Object[arr.length];
        for (int i=0;i<arr.length;i++){
            data[i] = arr[i];
        }
        size=arr.length;
    }

    public int getSize(){
        return size;
    }
    public int getCapacity(){
        return data.length;
    }
    public boolean isEmpty(){
        return size==0;
    }

    public void addLast(E e){
        add(size,e);
    }
    public void addFirst(E e){
        add(0,e);
    }
    //在第index个位置插入新元素e
    public void add(int index,E e){
        if(index<0||index>size){
            throw new IllegalArgumentException("Require index in 0 to 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++;
    }
    public E get(int index){
        if(index<0||index>size){
            throw  new IllegalArgumentException("Get failed.Index is illegal.");
        }
        return data[index];
    }

    public void set(int index,E e){
        if(index<0||index>=size){
            throw  new IllegalArgumentException("Set failed.Index is illegal.");
        }
        data[index]=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.Index is illegal.");
        }
        E ret=data[index];
        for (int i=index+1;i<size;i++){
            data[i-1]=data[i];
        }
        size--;
        data[size]=null;//loitering objects!=memory leak
        if(size==data.length/4&&data.length/2!=0){
            resize(data.length/2);
        }
        return ret;
    }
    public E removeFirst(){
        return remove(0);
    }
    public E removeLast(){
        return remove(size-1);
    }

    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;
    }

    public E getLast(){
        return get(size-1);
    }
    public E getFirst(){
        return get(0);
    }

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

    public void swap(int i,int j){
        if(i < 0 || i >= size || j <0 || j>=size){
            throw new IllegalArgumentException("index is illegal.");
        }
        E t = data[i];
        data[i] = data[j];
        data[j] = t;
    }

算法复杂度-时间复杂度

O(1),O(n),O(nlogn),O(n^2)

大O描述的是算法的运行时间和输入数据之间的关系

n是nums中的元素个数 算法和n呈线性关系

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

栈 Stack

栈也是一种线性结构

栈是一种后进先出的数据结构

相比数组，栈对应的操作是数组的子集

栈只能从一端添加元素，也只能从一端取出元素

这一端称为栈顶

一个简单的数组栈：
public class ArrayStack<E> implements Stack<E> {
    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(E e){
        array.addLast(e);
    }
    @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();
    }
栈的应用

undo操作(撤销)

程序调用的系统栈(方法找到上次中断的位置)

使用栈解决括号匹配的问题
  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();
    }

队列 Queue

队列是一种先进先出的数据结构

一个简单的数组队列
public class ArrayQueue<E> implements Queue<E> {

    private Array<E> array;
    public ArrayQueue(int capacity){
        array=new Array<>(capacity);
    }
    public ArrayQueue(){
        array=new Array<>();
    }
    @Override
    public void enqueue(E e) {
        array.addLast(e);
    }

    /**
     *出队时间复杂度是O(n)级别
     * @return
     */
    @Override
    public E dequeue() {
      return array.removeFirst();
    }

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

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

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

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

}
指定头与尾的循环数组队列
public class LoopQueue2<E> implements Queue<E> {
    private E[] data;
    private int front,tail;
    //private int size; size代表当前队列中元素个数  tail-front

    public int getSize(){
        if(tail>front){
            return (tail-front)+1;
        }else if(tail<front){
            return tail+getCapacity()-front;
        }else{
            return 0;
        }
    }
    public LoopQueue2(int capacity){
        data=(E[])new Object[capacity+1];
        front=0;
        tail=0;
    }
    public LoopQueue2(){
        this(10);
    }
    public int getCapacity(){
        return data.length-1;
    }

    @Override
    public void enqueue(E e) {
       if((tail+1)%data.length==front){
           resize(getCapacity()*2);
       }
       data[tail]=e;
       tail=(tail+1)%data.length;
    }

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

    @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;
        if(getSize()==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 int getSize() {
        return size;
    }*/

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

    @Override
    public String toString(){
        StringBuilder res=new StringBuilder();
        res.append(String.format("Queue:size=%d,capacity=%d\n",getSize(),getCapacity()));
        //res.append("Queue: ");
        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();
    }
}

链表 Linked List

在这里插入图片描述
真正的动态数据结构。

最简单的动态数据结构。

更深入的理解引用(或者指针)

更深入的理解递归
所在内存地址随机

链表：
public class LinkedList<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 dummyHead;
    int size;
    public LinkedList(){
        dummyHead=new Node(null,null);
        size=0;
    }

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

    //在链表头添加新的元素e
    public void addFirst(E e){
        add(0,e);
    }

    //在链表的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 addLast(E e){
        add(size,e);
    }

    //在链表的第index
    public E get(int index){
        if(index<0||index>=size){
            throw new IllegalArgumentException("Get 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);
    }
    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 void removeElement(E e){
        //查找元素，查找到则退出
        Node prev=dummyHead;
        while (prev.next!=null){
            if(prev.next.e.equals(e)){
                break;
            }
            prev=prev.next;
        }
        if(prev.next!=null){
            Node delNode=prev.next;
            prev.next=delNode.next;
            delNode.next=null;
        }
    }
    //查找链表中是否有元素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;
    }

    @Override
    public String toString(){
        StringBuilder res=new StringBuilder();
        /*Node cur=dummyHead.next;
        while (cur!=null){
            res.append(cur+"->");
            cur=cur.next;
        }*/
        for (Node cur=dummyHead.next;cur!=null;cur=cur.next){
            res.append(cur+"->");
        }
        res.append("NULL");
        return res.toString();
    }

    //从链表中删除index位置的元素
    public E remove(int index){
        if(index<0||index>=size){
            throw new IllegalArgumentException("Set 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);
    }
}

算法第五章

链表与递归

递归本质上，将原来的问题，转化为更小的同一问题

递归函数的微观解读

递归函数的调用，本质是函数的调用

双链表

yang haikun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SM9第2部分 数字签名算法1
08-04
《SM9第2部分：数字签名算法1》是关于SM9标识密码算法的详细规范，主要涉及数字签名的生成和验证过程，以及相关的辅助函数和算法参数。该算法基于椭圆曲线密码学，提供了一种基于标识而非传统公钥基础设施（PKI）的...
普林斯顿大学算法第二部分编程答案
12-13
Coursera上的普林斯顿大学算法第二部分的答案，1个92分 一个98分，3个100分。
普林斯顿《算法》笔记（二）
weixin_34080571的博客
06-01 342
官方网站 官方代码 第二章 排序 2.1 初级排序算法 排序就是将一组对象按照某种逻辑顺序重新排列的过程。这里我们主要关注重新排列含有元素的数组 (arrays of items)的算法，其中每个元素都有一个主键 (key)。排序算法的目的是重新排列所有元素，使得元素的主键能以某种方式排列。以下代码是本章通用的排序算法模板： public cl...
算法知识梳理(3) 字符串算法第二部分
weixin_33958585的博客
12-21 170
一、概要 本文介绍了有关字符串的算法第二部分的Java代码实现，所有代码均可通过 在线编译器 直接运行，算法目录： 查找字符串中的最长重复子串 求长度为N的字符串的最长回文子串 将字符串中的*移到前部，并且不改变非*的顺序 不开辟用于交换的空间，完成字符串的逆序C++ 最短摘要生成 最长公共子序列 二、代码实现 2.1 查找字符串中的最长重复子串 问题描述 给定一个文本文件作为输入，查找其中最...
【数据结构】栈：LeetCode题 20.有效的括号，155.最小栈，84.柱状图的最大矩形
A minor
09-26 2213
20.有效的括号¹ 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。 注意空字符串可被认为是有效字符串。 示例 1: 输入: "()" 输出: true 示例 2: 输入: "()[]{}" 输出: true 示例 3: 输入: "(]" 输出: false 示例 4: 输入: "([)]" 输出: false 示例 5: 输入: "{[]}" 输出: true
关于leetcode第二十题有效的括号
weixin_44804405的博客
11-07 175
这是官方给出的题目描述 其实看到这道题，很容易就能想到使用stack来解决。一旦想到这一点，问题就变得很容易解决了 class Solution { public boolean isValid(String s) { Stack<Character> stack=new Stack<Character>(); for(char c:s.toCharArray()){ if(c=='('){
【leetcode】栈与队列
qq_53869058的博客
03-27 493
我们可以按以下顺序执行： push(1), push(2), push(3), push(4), pop() -> 4, push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1。入栈：先将元素放入a队列中，如果b不空，将b中所有元素导入到a中。（1）利用两个栈，一个为正常栈(保存所有的进出栈数据)，一个为最小栈(只有当数据为最小时，才会入栈)（2）核心在于：入栈时，若数据最小，需要两个栈都要入栈，出栈时，如果出的数据为最小，需要更新最小栈。
算法训练营第二天1
08-03
"算法训练营第二天1" 本节课程主要讲解了算法训练营第二天的内容，涵盖了查找、排序、哈希表、Trie、LRU Cache 等多种数据结构和算法思想。 首先，课程讲解了二分查找（Binary Search）算法的实现细节，包括如何...
工程数值算法第二部分
03-03
对应工程数值算法的第二部分，包括详细的有限元介绍。
GMT 0001.1-2012 祖冲之序列密码算法第1部分：算法描述.pdf
06-29
GM/ T 0001《祖冲之序列密码算法》包括三部分: 第1部分:算法描述; 第2部分:基于祖冲之算法的机密性算法; 第3部分:基于祖冲之算法的完整性算法。 本部分为GM/T 0001的第1部分。
dubbo-无法找到提供者问题（一）
m0_54850825的博客
08-14 2963
然后我们定位下 服务端的 ip 获取方式，因为RegistryProtocol是开始zk注册的入口，我们直接看下 org.apache.dubbo.registry.integration.RegistryProtocol#export。我们看下 url中的refer中的register.ip的存储时机的代码，毫无疑问 在org.apache.dubbo.config.ReferenceConfig中。此处我们找到了问题的根源，当前我们的mac环境的hostname是篡改为了虚拟的，...
dubbo check=true源码分析
u010627840的专栏
01-02 498
1. 问题 check=true到底检查的是什么？ 2. debug查看 ReferenceConfig里面的createProxy方法 if (shouldCheck() && !invoker.isAvailable()) { throw new IllegalStateException("Failed to check the statu...
java哲学家就餐_哲学家就餐的问题--java实现
weixin_29232121的博客
02-12 195
先来看看运行结果吧：代码分为4个文件：Chopstick.javapackage Philosopher;/*** 表示筷子的类* */public class Chopstick{public Chopstick(){}public Chopstick(int id){this.id = id;}public boolean isAvailable(){return available;}pub...
android NetWorkInfo类的isConnected()与isAvailable()两个函数
大的的专栏
08-10 2995
2011-12-01 22:13:17|  分类： android|举报|字号 订阅 1，显示连接已保存，但标题栏没有，即没有实质连接上   not connect， available 2，显示连接已保存，标题栏也有已连接上的图标，          connect， available 3，选择不保存后
Boolean的使用
gashli的专栏
11-04 1162
public boolean needBankSendMsg(){         return Boolean.TRUE==vcode_Map.get("bank");     }
pyzmq-26.0.0a2-pp38-pypy38_pp73-macosx_10_9_x86_64.whl
最新发布
06-18
Python库是一组预先编写的代码模块，旨在帮助开发者实现特定的编程任务，无需从零开始编写代码。这些库可以包括各种功能，如数学运算、文件操作、数据分析和网络编程等。Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
小程序版通过CNN卷积神经网络的人物表情识别-不含数据集图片-含逐行注释和说明文档.zip
06-18
本代码是基于python pytorch环境安装的。 下载本代码后，有个环境安装的requirement.txt文本 如果有环境安装不会的，可自行网上搜索如何安装python和pytorch,这些环境安装都是有很多教程的，简单的 环境需要自行安装,推荐安装anaconda然后再里面推荐安装python3.7或3.8的版本，pytorch推荐安装1.7.1或1.8.1版本 首先是代码的整体介绍 总共是3个py文件，十分的简便 且代码里面的每一行都是含有中文注释的,小白也能看懂代码 然后是关于数据集的介绍。 本代码是不含数据集图片的，下载本代码后需要自行搜集图片放到对应的文件夹下即可 在数据集文件夹下是我们的各个类别,这个类别不是固定的，可自行创建文件夹增加分类数据集 需要我们往每个文件夹下搜集来图片放到对应文件夹下，每个对应的文件夹里面也有一张提示图，提示图片放的位置 然后我们需要将搜集来的图片，直接放到对应的文件夹下，就可以对代码进行训练了。 运行01数据集文本生成制作.py,是将数据集文件夹下的图片路径和对应的标签生成txt格式,划分了训练集和验证集 运行02深度学习模型训练.py,
php语言入门教程-自学笔记
06-18
PHP（Hypertext Preprocessor）是一种广泛使用的服务器端脚本语言，特别适用于Web开发。以下是关于PHP的简介，内容将按照分点表示和归纳的方式呈现： 起源与发展： PHP最初由Rasmus Lerdorf在1994年创建，最初只是用于统计他自己网站访问者数量的简单程序。 1995年，PHP发布了第一个版本PHP1，并逐渐增加了对数据库的支持等功能。 经过多年的发展，PHP经历了多个版本的迭代，如PHP2、PHP3、PHP4、PHP5、PHP7和PHP8等。 每一次的版本更新都带来了性能提升、功能增强和语法的改进。
数据结构与算法第二版的实验
05-30
《数据结构与算法（第2版）》这本书的实验是为了帮助读者更好地理解和掌握书中所讲述的数据结构与算法知识点，同时也是为了帮助读者巩固所学的知识，提高编程能力。这本书的实验包括两个部分：数据结构实验和算法...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值