《算法》笔记

最新推荐文章于 2024-11-07 18:59:45 发布
最新推荐文章于 2024-11-07 18:59:45 发布
阅读量211 收藏
点赞数
分类专栏： 编程笔记 算法-java 文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/s1293678392/article/details/78653354
版权

早就说要开始系统的学算法了，可总是被这个事那个事所拖累，从今天开始，认真拿着《算法》跟着coursera上的课程学算法。

1Union_Find判断问题：

算法的设计总是由API的设计开始，先将需要解决的问题抽象化，对需要的功能写出相应的API，然后在考虑解决这个问题用什么数据结构最好，最后再开始实现各个API。
关于Union_Find问题，判断两个对象之间是否联通的一个抽象的想法便是将union的对象放进同一个集合中，查询时若两个对象在一个集合中就是有路线可以联通。相应的我们就可以用数组来模拟对象所在集合，并且我们需要union，connected这两个简单的操作，还有一个构造函数读入对象。

<1>Quick-connect算法：很明显，算法的核心问题就是如何实现union和connected这两个API。快查算法的实现非常简单，初始化时给所有对象一个id，表示每个对象处于不同的集合。进行union操作时，如果id不同，就遍历整个数组将所有和其中一个对象id相同的对象的id都改成后一个对象的id。查询操作就会非常方便，只要比较两者id是否相同，即可判断是否联通。

<2>Quick-union算法：第一种实现方法最大的问题便是每次union都要遍历数组，效率太低，Quick-union算法是模拟树的实现，union时只要将根节点相连，整个集合就合二为一了。但这种问题带来了另外一个问题，那就是可能存在“瘦高”的树，那么去查询这种树的根节点将会非常耗费时间。

<3>Quick-union improvements：不过，我们完全可以优化上一算法来解决这个问题。增加一个数组变量来记录每个树的大小，当union时，总是将小树连接在大树的根节点下。这个看似小小的操作将大大提升运算效率，在大数据量下，会将平方级的运算提升至对数级。

华丽的分割线

2.Java栈与队列的实现：

栈和队列是两种相像的经典的数据类型，都是对数据添加删除做限制的线性表。其不同之处就在于出栈（pop）和出列（dequeue）的方式。栈是先进后出，队列是先进先出。

<1>Java虽说没有所谓的指针，但其实对于每个对象的引用就是指针，所以，栈可以用链表来实现：

public class Stack {
    Node first = null;
    private class Node {//定义内部类，实现节点的数据类型
        String value;
        Node next;
    }

    public boolean isEmpty() {//判空函数
        return first == null;
    }

    public void push(String item) {//入栈
        Node oldfirst = first;
        first = new Node();
        first.value = item;
        first.next = oldfirst;
    }

    public String pop() {//出栈
        String item = first.value;
        first = first.next;
        return item;
    }

    public static void main(String[] args) {
        Stack zhan = new Stack();
        System.out.println(zhan.isEmpty());
        zhan.push("hello");
        zhan.push("world!");
        System.out.println(zhan.pop());

    }

}

当然，栈也可以用简单数组实现：

public class Stack {
    String S[];
    int n = 0;//代表了栈顶

    public Stack(int capacity) {//要求客户端定义栈大小
        S = new String[capacity];
    }

    public boolean isEmpty() {//判空函数
        return n == 0;
    }

    public void push(String item) {//入栈
        S[n++] = item;
    }

    public String pop() {//出栈
        String item = S[--n];
        S[n] = null;//这两行代码是细节，如果直接返回S[--n]数组中对对象的引用还存在，可能会造成内存浪费。
        return item;
    }

    public static void main(String[] args) {
        Stack zhan = new Stack(2);
        System.out.println(zhan.isEmpty());
        zhan.push("hello");
        zhan.push("world!");
        System.out.println(zhan.pop());

    }

}

数组实现栈确实方便简单，但是它却必须规定大小，而在实际应用中我们的客户端往往不知道究竟需要多大的栈，所以我们可以对程序进行改进，动态改变数组大小：

public class Stack {
    String S[] = new String[1];
    int n = 0;

    public boolean isEmpty() //判空函数
    {
        return n == 0;
    }

    public void push(String item) //入栈
    {
        S[n++] = item;
        if( n == S.length )
            resize(2*S.length); 
    }

    public String pop() //出栈
    {
        String item = S[--n];
        S[n] = null;
        if( n == S.length/4)//如果判断是否等于S.length/2可能会出现“抖动”现象
            resize(S.length/2);

        return item;
    }

    private void resize(int capacity)//重规定数组大小
    {
        String copy[] = new String[capacity];
        for( int i = 0; i<n; i++ )
            copy[i] = S[i];
        S = copy;
    }

    public static void main(String[] args) {
        Stack zhan = new Stack();
        System.out.println(zhan.isEmpty());
        zhan.push("hello");
        zhan.push("world!");
        System.out.println(zhan.pop());

    }

}

这样就解决了数组实现栈大小限定的弊端。

对于两种不同的实现，我们应当发现，数组的基本操作要比链表更快，这就使得在处理数据时整体上是数组实现的栈效率更高。不过当数组进行动态伸缩的时候，操作时间会明显变长。所以可以根据实际需求选择实现方法。

<2>对于队列的实现，基本上和栈类似，但是链表实现我们要维护两个节点：first和last，enqueue时从last节点入队，dequeue时从first节点出队：

public class Queue {
    private Node first, last;

    private class Node{
        String value;
        Node next;
    }

    public boolean isEmpty()//判空函数
    {
        return first == null;
    }

    public void enqueue(String value)//从last节点入队
    {
        Node oldlast = last;
        last = new Node();
        last.value = value;
        last.next = null;
        if(isEmpty())
            first = last;
        else
            oldlast.next = last;
    }

    public String dequeue()//从first节点出队
    {
        String item = first.value;
        first = first.next;
        return item;
    }

    public static void main(String[] args) {
        Queue duilie = new Queue();
        System.out.println(duilie.isEmpty());
        duilie.enqueue("hello");
        duilie.enqueue("world!");
        System.out.println(duilie.dequeue());
    }

}

以下是数组实现：

public class Queue {
    private int first, last;
    String S[] = new String[1];


    public boolean isEmpty()//判空函数
    {
        return first == last;
    }

    public void enqueue(String value)//入队
    {
        S[last++] = value;
        if( last == S.length )
            resize(2*S.length);
    }

    public String dequeue()//出队
    {
        String item = S[first];
        S[first++] = null;
        if( last == S.length/4 )
            resize(S.length/2);
        return item;
    }

    private void resize(int size)//此处重定义数组比栈稍微复杂，需要找到first节点，将其重新归零 
    {
        String copy[] = new String[size];
        int j = 0;
        while( S[j] == null)
            j++;    
        for( int i = 0; i<last; i++ )
            copy[i] = S[i+j];
        S = copy;
    }

    public static void main(String[] args) {
        Queue duilie = new Queue();
        System.out.println(duilie.isEmpty());
        duilie.enqueue("hello");
        duilie.enqueue("world!");
        System.out.println(duilie.dequeue());
    }

}

数组实现多了一些栈不需要考虑的因素，关于两种实现方法的性能分析同栈。

（关于背包的实现，就是一个不可以取出的栈，除掉pop方法即可。）

华丽的分割线

3.初级排序算法

<1>选择排序：

public class Selection_sort {

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

    public static void main(String[] args) {
        int a[] = {23,324,45,32,2,3,123,5,234,52,3,67,95};
        sort(a);
        for( int i = 0; i<a.length; i++ )
        {
            System.out.println(a[i]);
        }
    }

}

<2>插入排序：

public class Insertion_sort {

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

    public static void main(String[] args) {
        int a[] = {23,324,45,32,2,3,123,5,234,52,3,67,95};
        sort(a);
        for( int i = 0; i<a.length; i++ )
        {
            System.out.println(a[i]);
        }
    }

}

<3>希尔排序：

public class Shellsort {

    public static void sort(int[] a)
    {
        int h = 1;
        while( h<a.length/3 )
            h = 3*h+1;
        while( h>=1)
        {
            for( int i = h; i<a.length; i++ )
            {
                for( int j = i; j>=h; j-=h )
                {
                    if( a[j]<a[j-h] )
                    {
                        int t = a[j];
                        a[j] = a[j-h];
                        a[j-h] = t;
                    }
                }
            }
            h = h/3;
        }
    }

    public static void main(String[] args) {
        int a[] = {23,324,45,32,2,3,123,5,234,52,3,67,95};
        sort(a);
        for( int i = 0; i<a.length; i++ )
        {
            System.out.println(a[i]);
        }
    }

}

华丽的分割线

4.归并排序

public class Mergesort {

    public static void sort(int[] a)
    {
        int item[] = new int[a.length];
        sort(a, item, 0, a.length-1);
    }

    private static void sort(int[] a, int[] item, int head, int tail)
    {
        if( head>=tail )
            return;
        int middle = (head+tail)/2;
        sort(a, item, head, middle);
        sort(a, item, middle+1, tail);
        merge(a, item, head, tail, middle);
    }

    private static void merge(int[] a, int[] item, int head, int tail, int middle)
    {
        for( int i = head; i<=tail; i++ )
            item[i] = a[i];
        int j = head;
        int k = middle+1;
        for( int i = head; i<=tail; i++ )
        {
            if( j>middle )
                a[i] = item[k++];
            else if( k>tail )
                a[i] = item[j++];
            else if( item[j]<=item[k] )
                a[i] = item[j++];
            else
                a[i] = item[k++];
        }
    }

    public static void main(String[] args) {
        int a[] = {23,324,45,32,2,3,123,5,234,52,3,67,95};
        sort(a);
        for( int i = 0; i<a.length; i++ )
        {
            System.out.println(a[i]);
        }
    }

}

自底向上的归并排序：

public class Mergesort {
    private static int item[];

    public static void sort(int[] a)
    {
        item = new int[a.length];
        sort(a, 0, a.length-1);
    }

    private static void sort(int[] a, int head, int tail)
    {
        for( int i = 1; i<a.length; i=i*2 )
        {
            for( int j = head; j<a.length; j=j+i+i )
            {
                merge(a, j, Math.min(a.length-1, j+i+i-1), j+i-1);
            }
        }
    }

    private static void merge(int[] a, int head, int tail, int middle)
    {
        for( int i = head; i<=tail; i++ )
            item[i] = a[i];
        int j = head;
        int k = middle+1;
        for( int i = head; i<=tail; i++ )
        {
            if( j>middle )
                a[i] = item[k++];
            else if( k>tail )
                a[i] = item[j++];
            else if( item[j]<=item[k] )
                a[i] = item[j++];
            else
                a[i] = item[k++];
        }
    }

    public static void main(String[] args) {
        int a[] = {23,324,45,32,2,3,123,5,234,52,3,67,95};
        sort(a);
        for( int i = 0; i<a.length; i++ )
        {
            System.out.println(a[i]);
        }
    }

}
卓尔货币
关注
专栏目录
算法学习（《算法》学习笔记）
duanlang2016的博客
02-17 636
一、排序 1.基本排序 选择排序：基本思路，每次找出最小的然后交换。时间复杂度为平方级别。 插入排序：在每次迭代i，a[i]和左边比它大的交换，不用管右边。最好的情况是实现已经排好了，最差的情况是去完全是从大到小排的。 希尔排序：出发点是插入排序，先笼统排再精细排。这个排序方法非常实用。 2.归并排序（分治的思想） 归并排序：基本思路，把数组分为两半，对每一部分进行递归排序，合并...
《算法》读书笔记（一）
mpw小白的博客
10-31 1985
第1章 基础 本书研究的是算法和数据结构，本章介绍的是学习算法和数据结构所需要的基本工具。它讲解了在随后的章节中用来实现、分析和比较算法的基本原则和方法，包括Java编程模型、数据抽象、基本数据结构、集合类的抽象数据类型、算法性能分析的方法和一个案例分析。 1.1 基础编程模型 介绍了相关的语法、语言特性和库。 本书使用Java编程语言编写的程序实现算法。我们把描述和实现算法所...
《算法图解》整理笔记
热门推荐
qq_42379006的博客
07-04 2万+
一，第一章 算法简介 1.2 二分查找 二分查找是一种算法，其输入是一个有序的元素列表（必须有序的原因稍后解释）。如果要查找的元素包含在列表中，二分查找返回其位置；否则返回null。 使用二分查找时，每次都排除一半的数字。 一般而言，对于包含n个元素的列表，用二分查找最多需要log2n步，而简单查找最多需要n步。仅当列表是有序的时候，二分查找才管用。 二分法代码实现： def ...
学习【labuladong的算法笔记】算法笔记（2024.3.18）
m0_67548374的博客
03-05 907
数学算法本质是数学计算机算法本质是穷举。
算法笔记-胡凡-两本完整PDF
Eli_Code
02-23 1万+
算法笔记-胡凡-两本完整PDF
《算法笔记》pdf版，欢迎下载学习~
10-10
《算法笔记》是一本专注于算法学习的书籍，其PDF版本为学习者提供了便捷的电子阅读体验。这本书特别针对想要提高CSP（计算机软件能力认证）分数的读者，无论是初学者还是有一定基础的学习者，都能从中受益。CSP是...
《算法笔记》
02-28
对算法的入门和深入了解都有很大帮助，而且还可用于考研机试，PAT等级考试等，希望对大家有帮助
数据结构与算法笔记.pdf
11-20
数据结构与算法笔记.pdf 数据结构与算法是计算机科学中两个紧密相关的概念。数据结构是指计算机中存储、组织和管理数据的方式，而算法是指解决问题的步骤和方法。在这份笔记中，我们将详细介绍算法的五个特性、算法...
算法笔记1_算法笔记PAT_算法笔记_
10-01
《算法笔记1_算法笔记PAT_算法笔记》是一份针对浙江大学计算机科学与技术学院机试以及PAT（Programming Ability Test）考试的学习参考资料，主要以C/C++编程语言为载体，深入讲解了各种算法的设计与实现。...
算法笔记
04-09
【标题】算法笔记 【描述】这是我多年总结而来的算法经验，变卖换积分，最近等着积分使用。而且如果想学习算法的话自己可以学习这本，我个人的笔记总结。 【标签】数据结构 图论 算法笔记 【部分内容解读】 1. ...
《算法笔记》——笔记
Derait的博客
07-20 878
算法笔记 胡凡 曾磊 主编 机械工业出版社 文章目录算法笔记C/C++快速入门提醒memsetsscanf与sprintf引用浮点数的比较圆周率复杂度黑盒测试入门篇(1)——入门模拟入门篇(2)——算法初步排序冒泡排序选择排序插入排序sort函数的应用排名的实现散列字符串hash初步递归分治递归全排列n皇后问题贪心简单贪心B1023 组个最小数 (20 分)区间贪心二分二分查找二分法拓展快速幂two pointers什么是two pointers归并排序快速排序其他高效技巧和算法打表活用递推随机选择算法
算法笔记3_算法笔记_浙大_
09-30
《算法笔记3》是针对浙江大学计算机科学与技术专业学生及准备参加PAT（全国计算机等级考试——编程类）的考生编写的参考资料，主要采用C/C++语言进行讲解。这本书旨在帮助读者提升算法理解与编程能力，为机试和PAT...
算法基础-链表
August的专栏
11-05 211
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
100种算法【Python版】第51篇——希尔排序
AnFany
11-06 232
100种算法【Python版】第51篇——希尔排序
字符串-06-整数与ip地址之间的转换
qq_45480682的博客
11-04 311
华为od算法——HJ33
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 278
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 1915
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
LeetCode每日一题3254---长度为 K 的子数组的能量值 I
niulinbiao的博客
11-06 306
输入：nums = [1,2,3,4,3,2,5], k = 3。输入：nums = [3,2,3,2,3,2], k = 2。输入：nums = [2,2,2,2,2], k = 4。[3, 4, 3] 中元素 不是 连续的。[4, 3, 2] 中元素 不是 上升的。[3, 2, 5] 中元素 不是 连续的。[1, 2, 3] 中最大元素为 3。[2, 3, 4] 中最大元素为 4。的，那么能量值为 最大 的元素。输出：[3,4,-1,-1,-1]输出：[-1,3,-1,3,-1]
数组类算法【leetcode】
最新发布
随便写写
11-07 176
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。二分查找 用于有序数组中，没有重复的数组。首先需要定义一个头（left）和尾(right)，最后通过mid和target对比不断修改头和尾指向的位置。【需要注意区间问题，根据区间的开和闭决定边界条件】推荐练习 leetcode35.
二分查找算法—C++
2401_82677021的博客
11-03 397
关于求中点位置的操作什么时候需要加1，什么时候不需要。只需看下面的left和right ，如果出现-1，mid就需要加1。否则，不需要加1.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值