数据结构与算法-链表与数组

最新推荐文章于 2020-08-03 14:10:14 发布
最新推荐文章于 2020-08-03 14:10:14 发布
阅读量147 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 回文字符串 LRU 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/freshbin000/article/details/105459761
版权

常见的链表：单链表，双链表，循环链表。

使用链表实现LRU缓存淘汰策略代码：代码如下，写了3个小时，而且也不知道正不正确，使用了一个节点类和一个管理节点的链表类。

package com.freshbin.dataStructAndAlgo.chapter06.Link.LRU;

/**
 * @author freshbin
 * @date 2020/4/11 21:59
 */
public class MyNode {
    public String token;
    public MyNode next;

    public MyNode(String token) {
        this.token = token;
    }

    public String getToken() {
        return this.token;
    }

    public void setToken(String token) {
        this.token = token;
    }

    public MyNode getNext() {
        return this.next;
    }

    public void setNext(MyNode next) {
        this.next = next;
    }

    @Override
    public String toString() {
        return "MyNode{" +
                "token='" + token + '\'' +
                ", next=" + next +
                '}';
    }
}

 

package com.freshbin.dataStructAndAlgo.chapter06.Link.LRU;

/**
 * 使用链表实现LRU缓存淘汰策略
 * @author freshbin
 * @date 2020/4/11 21:24
 */
public class MyLinkLRU {
    private volatile static MyLinkLRU myLinkLRU = null;
    private Integer maxSize = 3;
    private Integer currentCount = 0;
    public MyNode firstNode;

    private MyLinkLRU() {

    }

    public static synchronized MyLinkLRU getMyLinkLRU() {
        if(myLinkLRU == null) {
            synchronized (MyLinkLRU.class) {
                if(myLinkLRU == null) {
                    myLinkLRU = new MyLinkLRU();
                }
            }
        }

        return myLinkLRU;
    }

    /**
     * 0、判断缓存是否为空，如果为空，则直接插入头结点
     * 1、先查询该值是否在缓存中，如果存在，则将其从原来位置删除，并插入到头结点中
     * 2、如果该值不存在缓存中，则判断缓存是否满了，如果没满，那么就直接插入头结点，否则就删除尾结点，再插入头结点
     * @param token
     * @return
     */
    public MyNode useCacheByToken(String token) {
        MyNode cacheNode = new MyNode(token);

        // 0
        if(this.firstNode == null) {
            insertToFirstNode(cacheNode);
            return cacheNode;
        }

        // 1
        MyNode oldNode = this.firstNode;
        while (oldNode != null) {
            if(oldNode.token.equals(token)) {
                removeNodeByToken(token);
                insertToFirstNode(cacheNode);
                return firstNode;
            }
            oldNode = oldNode.next;
        }

        // 2
        if(currentCount < maxSize) {
            currentCount++;
            MyNode oldFirstNode = this.firstNode;
            this.firstNode = cacheNode;
            this.firstNode.next = oldFirstNode;
        } else {
            removeTailNode();
            insertToFirstNode(cacheNode);
        }

        return firstNode;
    }

    private void insertToFirstNode(MyNode newNode) {
//        if(newNode == null || newNode.token == this.firstNode.token) {
//            // 如果需要新插入的节点是头结点，那么不用再插入
//            return;
//        }
        currentCount++;
        MyNode node = firstNode;
        this.firstNode = newNode;
        this.firstNode.next = node;
    }

    public Boolean removeNodeByToken(String token) {
        if(this.firstNode == null) {
            return true;
        }
        if(currentCount > 0) {
            currentCount--;
        }
        if(this.firstNode.token == token) {
            // 删除头结点
            this.firstNode = this.firstNode.next;
            return true;
        }
        MyNode node = this.firstNode;
        while (node != null) {
            if(node.next != null && node.next.token == token) {
                node.next = node.next.next;
                return true;
            }
            node = node.next;
        }
        return false;
    }

    public Boolean removeTailNode() {
        if(this.firstNode == null) {
            return false;
        }

        MyNode preNode = firstNode;
        MyNode currentNode = firstNode;
        while (currentNode.next != null) {
            preNode = currentNode;
            currentNode = currentNode.next;
        }
        preNode.next = null;
        currentCount--;
        return true;
    }

    /**
     * 每次都从头结点插入
     * @param value
     * @return
     */
    public MyNode addLink(String value) {
        MyNode myNode = new MyNode(value);
        MyNode oldFirstNode = this.firstNode;
        this.firstNode = myNode;
        this.firstNode.next = oldFirstNode;
        return this.firstNode;
    }

    public MyNode getFirstNode() {
        return this.firstNode;
    }

    public void setFirstNode(MyNode firstNode) {
        this.firstNode = firstNode;
    }

    public Integer getCurrentCount() {
        return this.currentCount;
    }

    public void setCurrentCount(Integer currentCount) {
        this.currentCount = currentCount;
    }
}

 

package com.freshbin.dataStructAndAlgo.chapter06.Link.LRU;

/**
 * @author freshbin
 * @date 2020/4/11 21:36
 */
public class MyLinkLRUMain {
    public static void main(String[] arg) {
        String token01 = "token01";
        String token02 = "token02";
        String token03 = "token03";
        String token04 = "token04";

        MyLinkLRU myLinkLRU = MyLinkLRU.getMyLinkLRU();
        myLinkLRU.useCacheByToken(token01);
        myLinkLRU.useCacheByToken(token01);

        MyNode node = myLinkLRU.getFirstNode();
        System.out.print("缓存中的值：");
        while (node != null) {
            System.out.print(node.token + "->");
            node = node.next;
        }

        System.out.println();
        myLinkLRU.useCacheByToken(token02);
        myLinkLRU.useCacheByToken(token03);
        myLinkLRU.useCacheByToken(token04);
        myLinkLRU.useCacheByToken(token02);

        MyNode node02 = myLinkLRU.getFirstNode();
        System.out.print("缓存中的值：");
        while (node02 != null) {
            System.out.print(node02.token + "->");
            node02 = node02.next;
        }
    }
}

运行结果如下：

 

使用数组实现LRU缓存淘汰策略代码：写了一个多小时，看起来像是正确的，不过也是简单的代码，代码如下

package com.freshbin.dataStructAndAlgo.chapter06.Array.LRU;

/**
 * @author freshbin
 * @date 2020/4/12 9:23
 * 数组实现LRU缓存淘汰策略
 */
public class MyArrayLRU {
    private volatile static MyArrayLRU myArrayLRU = null;
    private Integer maxSize = 3;
    private String[] cacheArr = new String[3];
    private Integer currentCount = 0;

    private MyArrayLRU() { }

    public static synchronized MyArrayLRU getMyArrayLRU() {
        if(myArrayLRU == null) {
            synchronized (MyArrayLRU.class) {
                if(myArrayLRU == null) {
                    myArrayLRU = new MyArrayLRU();
                }
            }
        }

        return myArrayLRU;
    }

    /**
     * 0、判断缓存是否为空，如果为空，则直接插入到索引为0的位置
     * 1、先查询该值是否在缓存中，如果存在，则遍历原缓存数组从索引0开始到该值存在的位置，把数组的每一项都后移一位，并把该值写入索引为0的位置
     * 2、如果该值不存在缓存中，则判断缓存是否满了，
     * 如果没满，则遍历原缓存数组，把数组的每一项都后移一位，并把该值写入索引为0的位置,
     * 如果满了，那么就把数组前size-1项往后移一位（size为数组大小），再把该值写入索引为0的位置。
     * @param token
     * @return
     */
    public String useCache(String token) {
        if(cacheArr[0] == null) {
            cacheArr[0] = token;
            currentCount++;
            return token;
        }
        int index = findIndexInCacheArray(token);
        if(index == 0) {
            // 如果该值已经是第0个索引，那么也不用继续放到最前面。
            return token;
        }
        if(index != -1) {
            forwardArrayOneStep(0, index);
            cacheArr[0] = token;
            return token;
        }

        // 因为该值不在缓存中，所以缓存数量+1
        if(currentCount < maxSize) {
            currentCount++;
        }

        // 该值不在缓存中的情况
        if(currentCount < maxSize) {
            // 缓存没满
            forwardArrayOneStep(0, currentCount-1);
            cacheArr[0] = token;
        } else {
            // 缓存满了
            forwardArrayOneStep(0, maxSize-1);
            cacheArr[0] = token;
        }
        return token;
    }

    private void forwardArrayOneStep(int start, int end) {
        if(start >= end || end <= 0) {
            return;
        }
        for(; end > start; end--) {
            // 这里需要从后往前遍历，否则前面的会把后面的值覆盖了
            // 把前面的值放到后一位
            cacheArr[end] = cacheArr[end-1];
        }
    }

    /**
     * 返回-1表示没找到，否则返回索引值
     * @param token
     * @return
     */
    private int findIndexInCacheArray(String token) {
        for(int i = 0; i < cacheArr.length; i++) {
            if(cacheArr[i] == token) {
                return i;
            }
        }

        return -1;
    }

    public String[] getCacheArr() {
        return this.cacheArr;
    }
}

 

package com.freshbin.dataStructAndAlgo.chapter06.Array.LRU;

/**
 * @author freshbin
 * @date 2020/4/12 10:10
 */
public class MyArrayLRUMain {
    public static void main(String[] arg) {
        String token01 = "token01";
        String token02 = "token02";
        String token03 = "token03";
        String token04 = "token04";

        MyArrayLRU myArrayLRU = MyArrayLRU.getMyArrayLRU();
        myArrayLRU.useCache(token01);
        myArrayLRU.useCache(token01);

        String[] cacheArr = myArrayLRU.getCacheArr();
        System.out.print("缓存值：");
        for(int i = 0; i < cacheArr.length; i++) {
            if(cacheArr[i] != null) {
                System.out.print(cacheArr[i] + " ");
            }
        }

        System.out.println();

        System.out.print("缓存值：");
        myArrayLRU.useCache(token02);
        myArrayLRU.useCache(token03);
        myArrayLRU.useCache(token04);
        myArrayLRU.useCache(token02);
        for(int i = 0; i < cacheArr.length; i++) {
            if(cacheArr[i] != null) {
                System.out.print(cacheArr[i] + " ");
            }
        }
    }
}

运行结果：

 

使用单链表判断一个字符串是否是回文字符串：使用了两条链表来保存字符串。总共三个类，一个节点类（复用上面的），一个管理节点的链表类，一个测试类，代码如下：

package com.freshbin.dataStructAndAlgo.chapter06.Link.palindromicString;

import com.freshbin.dataStructAndAlgo.chapter06.Link.LRU.MyNode;

/**
 * 使用链表实现LRU缓存淘汰策略
 * @author freshbin
 * @date 2020/4/11 21:24
 */
public class MyLink {
    public MyNode firstNode;

    public MyLink() {

    }

    /**
     * 每次都从头结点插入
     * @param value
     * @return
     */
    public MyNode addLink(String value) {
        MyNode myNode = new MyNode(value);
        MyNode oldFirstNode = this.firstNode;
        this.firstNode = myNode;
        this.firstNode.next = oldFirstNode;
        return this.firstNode;
    }

    public MyNode getFirstNode() {
        return this.firstNode;
    }

    public void setFirstNode(MyNode firstNode) {
        this.firstNode = firstNode;
    }

}

package com.freshbin.dataStructAndAlgo.chapter06.Link.palindromicString;

import com.freshbin.dataStructAndAlgo.chapter06.Link.LRU.MyNode;

/**
 * 使用数组实现回文字符串校验
 *
 * 思路：
 * 1、首先将字符串按顺序写进链表1，再把字符串按逆序即从length-1到0的顺序写进链表2
 * 2、遍历链表1，从头结点遍历到中节点。
 * 使用currentIndex从0开始记录当前遍历的索引，使用middleIndex记录中节点的索引
 * 遍历方法内比较链表1和链表2的值是否一致，不一致则退出循环，表示不是回文数，否则是回文数。
 * 遍历一次currentIndex就+1，middeleIndex的值为(0+length)/2，length为字符串长度
 *
 * @author freshbin
 * @date 2020/4/12 11:28
 */
public class MyLinkPalindromicString {


    public static Boolean isPalindromicString(String target) {
        int currentIndex = 0;
        int middeleIndex = (target.length()) / 2;

        MyLink myNode01 = initMyLink01(target);
        MyLink myNode02 = initMyLink02(target);

        displayNode(myNode01);
        displayNode(myNode02);

        MyNode firstNode01 = myNode01.getFirstNode();
        MyNode firstNode02 = myNode02.getFirstNode();
        while(currentIndex < middeleIndex && firstNode01 != null) {
            if(!firstNode01.token.equals(firstNode02.token)) {
                return false;
            }

            firstNode01 = firstNode01.next;
            firstNode02 = firstNode02.next;
            currentIndex++;
        }
        return true;
    }

    private static void displayNode(MyLink myNode) {
        System.out.print("链表内容：");
        MyNode firstNode = myNode.getFirstNode();
        while(firstNode != null) {
            System.out.print(firstNode.token + "->");
            firstNode = firstNode.next;
        }
        System.out.println();
    }

    /**
     * 字符串逆序写入链表
     * @param target
     * @return
     */
    private static MyLink initMyLink02(String target) {
        MyLink myLink = new MyLink();
        // 因为该链表每次都是从头结点插入，所以这里字符串从后到前进行插入
        for(int i = 0; i < target.length(); i++) {
            myLink.addLink(String.valueOf(target.charAt(i)));
        }

        return myLink;
    }

    /**
     * 字符串顺序写入链表
     * @param target
     * @return
     */
    private static MyLink initMyLink01(String target) {
        MyLink myLink = new MyLink();
        // 因为该链表每次都是从头结点插入，所以这里字符串从后到前进行插入
        for(int i = target.length() - 1; i >= 0; i--) {
            myLink.addLink(String.valueOf(target.charAt(i)));
        }

        return myLink;
    }

    public static void main(String[] arg) {
        String s1 = "a";
        String s2 = "ab";
        String s3 = "abc";
        String s4 = "abcba";
        String s5 = "abcbabcba";

        System.out.println("a:" + isPalindromicString(s1));
        System.out.println("ab:" + isPalindromicString(s2));
        System.out.println("abc:" + isPalindromicString(s3));
        System.out.println("abcba:" + isPalindromicString(s4));
        System.out.println("abcbabcba:" + isPalindromicString(s5));
    }
}

测试结果如下：

使用数组判断一个字符串是否是回文字符串：代码如下，想清楚之后还是很容易写出来的。

package com.freshbin.dataStructAndAlgo.chapter06.Array.palindromicString;

/**
 * 使用数组实现回文字符串校验
 *
 * 思路：
 * 1、首先将字符串写进数组
 * 2、从索引0到(0+size)/2(小于该值)处遍历数组，
 * 同时用leftIndex记录从0递增到(0+size)/2（小于该值），用rightIndex记录从size-1递减到(0+size)/2（大于该值）
 * 左右两边同时进行移动，判断左右两边的值是否相等，不相等就退出循环表示不是回文数，否则就是回文数
 * @author freshbin
 * @date 2020/4/12 10:45
 */
public class MyArrayPalindromicString {
    public static Boolean isPalindromicString(String target) {
        if(target == null && target.length() == 0) {
            return false;
        }
        target = target.trim();

        // 写进数组
        String[] targetArray = initArray(target);
        int leftIndex = 0;
        int rightIndex = targetArray.length-1;
        int middleIndex = (0+targetArray.length)/2;

        while(leftIndex < middleIndex) {
            if(!targetArray[leftIndex].equals(targetArray[rightIndex])) {
                return false;
            }
            leftIndex++;
            rightIndex--;
        }

        return true;
    }

    private static String[] initArray(String target) {
        String[] arr = new String[target.length()];
        System.out.print("需要判断回文的字符串：");
        for(int i = 0; i < arr.length; i++) {
            arr[i] = String.valueOf(target.charAt(i));
            System.out.print(arr[i]);
        }
        System.out.println();
        return arr;
    }

    public static void main(String[] arg) {
        String s1 = "a";
        String s2 = "ab";
        String s3 = "abc";
        String s4 = "abcba";
        String s5 = "abcbabcba";

        System.out.println("a:" + isPalindromicString(s1));
        System.out.println("ab:" + isPalindromicString(s2));
        System.out.println("abc:" + isPalindromicString(s3));
        System.out.println("abcba:" + isPalindromicString(s4));
        System.out.println("abcbabcba:" + isPalindromicString(s5));
    }
}

结果如下：

感想：写出来之后才感到原来这么简单啊，虽然想了很久才搞定，不过总算是比我几年前刚学java有进步，这要是放到以前，我无论如何也不可能在没有任何参考的情况下完整写出来。还是太菜了，学了好几年了，也该有进步了，是该要有进步了啊！

github代码地址：https://github.com/freshbin/dataStructAndAlgo.git

课程例题的github地址：https://github.com/wangzheng0822/algo/tree/master/java/06_linkedlist

freshbin000
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第2讲 | 数据结构与算法 | 【数组和链表】
econe_wei的博客
08-19 157
- 《数据结构与算法》专栏完整版在公众号【书伟认视界】中查看，转载需联系微信【econe0219】 数组和链表 数组：一种线性表（具有前后顺序）数据结构。用一组连续的内存空间，来存储一组具有相同类型的数据。 链表：通过指针将零散的内存快串联在一起。 单向链表： 插入、删除操作时，数组的时间复杂度是O(n)，而链表不需要保证数据的连贯性，时间复杂度是O(1)，但是访问元素时，需要根据指针一个结点一个结点地遍历，直到找到相应元素的节点，所以需要O(n)的时间复杂度。 循环链表： 循环链表的优点是，从链尾到
算法：数组和链表-理论
yingqi的博客
07-17 207
目录 数组 Java的数组是怎么实现 链表 Java的链表是怎么实现 我们先看看百度百科关于数组和链表的介绍吧。 数组 所谓数组，是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。 数组 既然我们刚刚讲到了算法的时间复杂度。 数组访问的时间复杂度是多少呢！O(1）。 数组插入...
【算法】数组和链表的通俗比较
玫瑰与鹿°
08-05 661
前言 小编认为，只要对数据结构有些了解，就能分清数组和链表。所以这篇分享看似无意义。BUT，小编最近在看《图解算法》，觉得作者对两者的区分的思路挺棒，所以总结下来，分享出来。 两者的图片定义                                                  图1 数组图                                    
常见数据结构与算法-数组与链表（python3 代码）
weixin_42791474的博客
10-22 186
  常见数据结构有线性表（数组与链表），栈与队列，树与二叉树，图。 1.线性表 线性表是最常用且最简单的一种数据结构，它是数据元素的有限序列。线性表有两种实现形式，第一种是用一组连续的存储单元依次存储线性表的数据元素，使用数组存储线性表的元素，也就是python里面的List。第二种就是用一组任意的存储单元存储线性表的数据元素，使用链表存储线性表的元素，这里存储单元可以连续，也可以不连续，也...
数据结构与算法(一)数组、链表
SunSatan的博客
04-14 309
数组和链表是最重要的、最基本的数据结构，它们是其它所有数据结构的基础，它们无处不在。 我们通常将数组和链表当作线性表使用，以下介绍数组和链表默认当作线性表。 1、数组 数组是应用最广泛的一种数据结构，几乎所有高级编程语言都会将数组作为基本数据类型使用，因此，数组通常不会被当做一种数据结构单独拿出来讲解。 数组是最简单的数据结构，当做学习数据结构的敲门砖，以此为基础，了解数据结构的基本概念以...
【数据结构与算法】数组与链表
dadongwudi的博客
08-03 468
数组的定义和特性 数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。 线性表（Linear List）：数组、链表、队列、栈 非线性表：树 图 连续的内存空间和相同类型的数据 性能 低效“插入”和“删除” 警惕 数组越界 数组和链表的区别 “链表适合插入、删除，时间复杂度 O(1)；数组适合查找，数组支持随机访问，根据下标随机访问的时间复杂度为 O(1)”。 （数组是适合查找操作，但是查找的时间复杂度并不为 O(1)。即便是排好序的数组，你
数据结构与算法之链表
乞力马扎罗的雪CYF的博客
02-23 3066
链表的分类：（1）单链表头插法：只需要维护一个头结点即可，常用来模拟堆栈；尾插法：需要维护头结点和尾结点，常用来模拟队列。（2）双向链表双向遍历，可以用来保存网页的历史记录等；（3）循环链表经常出现在面试题中，判断链表是否有环。链表的删除方式一：维护两个指针，current（表示当前节点）和previous（表示当前节点的前一个节点）。当current遍历到要删除的元素时，执行previous->
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。C语言因其高效、底层特性，常被用于实现数据结构和算法，使得程序更接近硬件，性能更优。本资源"数据结构与算法分析--C语言描述"是针对数据...
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
数据结构与算法-C#版
03-09
这是C#版的数据结构与算法的代码实现，包括：顺序表，单链表，双链表；顺序栈，链栈；顺序队列，链队列；顺序串；用数组进行特殊矩阵的存储，稀疏矩阵的存储；顺序存储二叉树，链式存储二叉树，哈夫曼树；多重链表...
python算法-数组和链表 数组和链表.pdf
04-18
Python算法中，数组和链表是两种常用的数据结构。它们都是用于存储和管理数据的，但是它们在实现和使用上有很大的区别。 数组是具有相同的数据类型且按一定次序排列的集合体。它的元素在内存中的地址是连续相邻的...
链表_数据结构--链表_
10-01
栈是一种后进先出（LIFO）的数据结构，通常用数组实现，但在某些情况下，如内存限制或动态增长需求时，链表可以作为有效的替代方案。 链表模拟栈的优势在于，由于链表的插入和删除操作通常比数组更快，尤其是在数据...
数据结构与算法-数组练习题
freshbin000的博客
05-01 889
工作的时候，一个bug改一天，一个需求看一周。刷题的时候，三个问题解一天，还是简单的那种，急躁的时候不要继续当前的事情，急躁的时候不要继续当前的事情，急躁的时候不要继续当前的事情（手动敲三遍，希望能牢记）。下面是解了一天的三个leetcode简单小问题： package com.freshbin.basics.array; import java.util.HashMap; /** * ...
数据结构与算法-链表练习题
freshbin000的博客
05-04 557
leetcode的几道链表练习题： package com.freshbin.basics.linkedlist; /** * @author freshbin * @date 2020/5/2 14:54 */ public class ListNode { int val; ListNode next; ListNode(int x) { ...
数据结构与算法-动态规划
freshbin000的博客
04-28 423
动态规划问题一般遵循一个模型三个特征。一个模型表示在解决问题时，可以把该问题分解成多个阶段求解，每个阶段称为决策阶段，我们需要找到一组决策阶段，这组决策阶段能够产生我们期望的最优解。三个特征是指最优子结构，无后效性和重复子问题。 最优子结构：子问题的最优解可以推出问题的最优解，而父问题的最优解可以推出子问题的最优解，也就是说后面阶段的最优状态可以由前面的最优状态推导出来。（感觉有点像是贪心算法每...
数据结构与算法-拓扑排序
freshbin000的博客
04-29 393
拓扑排序，感觉就是图的广度优先搜索和深度优先搜索。 拓扑排序的两种实现方法：Kahn算法与DFS深度优先搜索算法 Kahn算法：使用的是贪心算法思想，借助一个队列，以及一个统计当前顶点入度数的数组。当顶点的入度为0，那么就把顶点入队列。当队列不为空，那么就取出队列的顶点，同时把该顶点所有指向的顶点取出来，同时把这些顶点的入度都减一，然后判断这些顶点的入度是否为0，如果为0，就将该顶点入队列，不...
数据结构与算法-堆
freshbin000的博客
04-22 372
堆有两个特征：1、是一颗完全二叉树；2、堆中的每个节点都必须大于等于或者小于等于其子树节点的值，大于等于子节点的堆称为大顶堆，小于或等于子节点的堆称为小顶堆。 堆化：当堆的插入或者删除操作会破坏堆的特征，那么这时候会重新调整，让其重新满足堆的特征。堆化有从下往上和从上往下两种。堆化就是顺着节点从上往下或者从下往上进行对比，然后交换。 大顶堆的插入操作（从下往上）：将准备插入的值设置为数组的最后...
数据结构与算法-时间复杂度与空间复杂度
freshbin000的博客
04-11 369
今天开始学习王争老师的数据结构与算法。 一、时间复杂度 1、时间复杂度由来 1.1、上面代码段中，第2,3行执行分别需要1个unit_time的执行时间，第4,5执行分别需要n个unit_time的执行时间，所以这段代码总的执行时间为T（n）=（2+2n）*unit_time。 1.2、上面的代码中，第2,3,4分别需要1个unit_time的执行时间，第5,6行分别需要n个uni...
数据结构与算法-分治算法
freshbin000的博客
04-28 292
分治算法一般用递归来实现，分治算法是一种处理问题的思想，递归是一种编程技巧，在分治算法的递归实现中，每一层递归都会涉及这三个操作： 1、分解：将原问题分解成一系列子问题； 2、解决：递归求解各个子问题，若子问题足够小，则直接求解； 3、合并：将子问题的结果合并成原问题。 满足下面几个条件，则可以使用分治算法： 1、原问题与分解成的小问题具有相同的模式； 2、原问题分解成的子问题可以独立...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值