数据结构算法题日志

于 2023-04-25 16:04:08 发布
阅读量104 收藏
点赞数
文章标签： 算法 数据结构 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59159431/article/details/129065428
版权

Lecode 算法。

链接：https://leetcode.cn
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

1.(53) 最大子数组和

题目：
在这里插入图片描述
解题思路：
   考虑数组中的元素是单独成一段还是加入之前的那一段，故比较该元素于前一段组合大小，取大者即可。
java代码如下所示：
在这里插入图片描述
** java求最大值Math.max**

2.(1)两数之和

题目：
在这里插入图片描述

解题思路：
（1）暴力破解
在这里插入图片描述
注意：（1）nums长度为nums.length
(2)return 数组为return new int[]{i,j}

3(88)合并两个有序数组

题目：
在这里插入图片描述
解题方法：
（1）使用sort内置函数
在这里插入图片描述
**注：Arrays.sort()为内置Array函数
（2）双指针

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p1 = 0, p2 = 0;
        int[] sorted = new int[m + n];
        int cur;
        while (p1 < m || p2 < n) {
            if (p1 == m) {
                cur = nums2[p2++];
            } else if (p2 == n) {
                cur = nums1[p1++];
            } else if (nums1[p1] < nums2[p2]) {
                cur = nums1[p1++];
            } else {
                cur = nums2[p2++];
            }
            sorted[p1 + p2 - 1] = cur;
        }
        for (int i = 0; i != m + n; ++i) {
            nums1[i] = sorted[i];
        }
    }
}

(4)(350)两个数组的交集II

题目：
在这里插入图片描述
解题思路：
（1）哈希表
    由于同一个数字在两个数组中都可能出现多次，因此需要用哈希表存储每个数字出现的次数。对于一个数字，其在交集中出现的次数等于该数字在两个数组中出现次数的最小值。
代码如下所示：

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        // 挑选出两个数组找个短的那个
        if (nums1.length > nums2.length) {
            return intersect(nums2, nums1);
        }

        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        // nums1 = [4,9,5], nums2 = [9,4,9,8,4]
        for (int num : nums1) {
            // map.getOrDefault : 存在这个数就返回，不存在就返回默认值
            int count = map.getOrDefault(num, 0) + 1;
            map.put(num, count);
        }
        // 开辟一块内存空间用来存放两个数组的交集
        int[] intersection = new int[nums1.length];
        int index = 0;
        for (int num : nums2) {
            // num1中不存在这个数就在map中添加num=0
            int count = map.getOrDefault(num, 0);
            // 存在这个数就往后执行
            if (count > 0) {
                // 把这个数填充到数组中
                intersection[index++] = num;
                // 计数减一
                count--;
                // 如果还大于0
                if (count > 0) {
                    // 再次添加进去，覆盖之前那个key
                    map.put(num, count);
                } else {
                    // 不大于0移除这个数
                    map.remove(num);
                }
            }
        }
        // public static int[] copyOfRange(int[] original, int from, int to)
        // 对已有([9, 4, 0])的数组进行截取和赋值,结果为[9,4]
        return Arrays.copyOfRange(intersection, 0, index);
    }
}

注意：（1）Map的用法：Map.getOrDefault(key，默认值)；
Map中会存储一一对应的key和value。
如果 在Map中存在key，则返回key所对应的的value。
如果 在Map中不存在key，则返回默认值。
（2）Arrays的用法：Arrays.copyOfRange(T[] original, int from, int to)复制from到to的元素。

(5)(121)买卖股票的最佳时机

题目为：
在这里插入图片描述
解题思路：
（1）暴力破解：会超时；
（2）一次遍历：记录当前遍历最小值，如果当前值小于最小值，替换最小值，如何不小于，计算差值后于最大利润比较，若大于，则替换最大利润。
代码如下所示：

public class Solution {
    public int maxProfit(int prices[]) {
        int minprice = Integer.MAX_VALUE;# Integer.MAX_VALUE表示int数据
        类型的最大取值数：2 147 483 647
		Integer.MIN_VALUE表示int数据类型的最小取值数：-2 147 483 648
        int maxprofit = 0;
        for (int i = 0; i < prices.length; i++) {
            if (prices[i] < minprice) {
                minprice = prices[i];
            } else if (prices[i] - minprice > maxprofit) {
                maxprofit = prices[i] - minprice;
            }
        }
        return maxprofit;
    }
}

注意： Integer.MAX_VALUE表示int数据类型的最大取值数：2 147 483 647
Integer.MIN_VALUE表示int数据类型的最小取值数：-2 147 483 648

(6)(118)杨辉三角

题目如下所示：
在这里插入图片描述
解题思路：
代码如下：

class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> ret = new ArrayList<List<Integer>>();
        for (int i = 0; i < numRows; ++i) {
            List<Integer> row = new ArrayList<Integer>();
            for (int j = 0; j <= i; ++j) {
                if (j == 0 || j == i) {
                    row.add(1);
                } else {
                    row.add(ret.get(i - 1).get(j - 1) 
                    + ret.get(i - 1).get(j));//将上一级的数进行两两相加
                }
            }
            ret.add(row);
        }
        return ret;
    }
}

(7)36.有效的数独

题目如下所示：
在这里插入图片描述
解题思路：
用哈希表记录每一行、每一列、每一个小九宫格中，每个数字出现的次数。后判断对应条件即可。代码如下所示：

class Solution {
    public boolean isValidSudoku(char[][] board) {
        int[][] rows = new int[9][9];
        int[][] columns = new int[9][9];
        int[][][] subboxes = new int[3][3][9];
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                char c = board[i][j];
                if (c != '.') {
                    int index = c - '0' - 1; // 字符转int，计算该c为多少，ASCII码计算
                    rows[i][index]++;
                    columns[j][index]++;
                    subboxes[i / 3][j / 3][index]++; // 判别为第几个方块里出现的数字。
                    if (rows[i][index] > 1 || columns[j][index] > 1 || subboxes[i / 3][j / 3][index] > 1) {
                        return false;
                    }
                }
            }
        }
        return true;
    }
}

(8)73.矩阵置零

题目如下所示：
在这里插入图片描述
注：原地算法：一个原地算法（in-place algorithm）是一种使用小的，固定数量的额外之空间来转换资料的算法。当算法执行时，输入的资料通常会被要输出的部分覆盖掉。
解题思路：
（1）普通标记数组，占用O（M+N）
设定行标和列标，当有0，置1.后更新全部。
代码如下所示：

class Solution {
    public void setZeroes(int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        boolean[] row = new boolean[m];
        boolean[] col = new boolean[n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (matrix[i][j] == 0) {
                    row[i] = col[j] = true;
                }
            }
        }
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (row[i] || col[j]) {
                    matrix[i][j] = 0;
                }
            }
        }
    }
}

（2）使用两个标记变量
其第一行第一列用于判断剩余行列是否存在0；
代码如下所示：

class Solution {
    public void setZeroes(int[][] matrix) {
        int m = matrix.length, n = matrix[0].length;
        boolean flagCol0 = false, flagRow0 = false;
        for (int i = 0; i < m; i++) {
            if (matrix[i][0] == 0) {
                flagCol0 = true;
            }
        }
        for (int j = 0; j < n; j++) {
            if (matrix[0][j] == 0) {
                flagRow0 = true;
            }
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (matrix[i][j] == 0) {
                    matrix[i][0] = matrix[0][j] = 0;
                }
            }
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (matrix[i][0] == 0 || matrix[0][j] == 0) {
                    matrix[i][j] = 0;
                }
            }
        }
        if (flagCol0) {
            for (int i = 0; i < m; i++) {
                matrix[i][0] = 0;
            }
        }
        if (flagRow0) {
            for (int j = 0; j < n; j++) {
                matrix[0][j] = 0;
            }
        }
    }
}

(9) 387.字符串中的第一个唯一字符

题目如下所示：
在这里插入图片描述
解题思路：
（1）使用哈希表存储频数
代码如下所示：

class Solution {
    public int firstUniqChar(String s) {
        Map<Character, Integer> frequency = new HashMap<Character, Integer>();
        for (int i = 0; i < s.length(); ++i) {
            char ch = s.charAt(i);
            frequency.put(ch, frequency.getOrDefault(ch, 0) + 1);
        }
        for (int i = 0; i < s.length(); ++i) {
            if (frequency.get(s.charAt(i)) == 1) {
                return i;
            }
        }
        return -1;
    }
}

注意：String中操作charAt(),此方法返回这个字符串的指定索引处的char值

（10）383 赎金信

题目如下所示：
在这里插入图片描述
解题思路：进行字符统计，使用Map或者int[26] 进行相关的统计。代码如下所示：

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
            Map<Character,Integer> map=new HashMap<Character,Integer>();
            for(int i=0;i<ransomNote.length();i++){
                char a=ransomNote.charAt(i);
                map.put(a,map.getOrDefault(a,0)+1);
            }
            for(int i=0;i<magazine.length();i++){
                char b=magazine.charAt(i);
                map.put(b,map.getOrDefault(b,0)-1);
            }
            for (Map.Entry<Character, Integer> entry : map.entrySet()) {
                int pos = entry.getValue();
                if(pos>0){
                    return false;
                }
    }
    return true;
}
}

也可以如下所示：

public boolean canConstruct(String ransomNote, String magazine) {
    int[] arr = new int[26];
    for (int i = 0; i < magazine.length(); i++)
        arr[magazine.charAt(i) - 'a']++;
    for (int i = 0; i < ransomNote.length(); i++)
        if (arr[ransomNote.charAt(i) - 'a']-- == 0) return false;
    return true;
}

注：（1）map的用法：java中获取map中key和value的方式有两种:
map.keySet() : 先获取map中的key，然后根据key获取value。
map.entrySet() : 获取map中的key和value，只需查询一次。
ToCharArray( )的用法，将字符串对象中的字符转换为一个字符数组char[]。
(2)题目为小写字母，故可以分配26个空间来进行相关字符的计数实现。

(11)141 环形链表

题目如下所示：
在这里插入图片描述
解题思路：
（1）使用哈希表来存储已经遍历过的结点
代码如下所示：

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        Set<ListNode> a=new HashSet<ListNode>();
        while(head!=null){
            if(!a.add(head)){
                return true;
            }
            head=head.next;
        }
        return false;
    }
}

（2）Floyd 判圈算法(龟兔赛跑算法)
围绕成一个圈，双指针，分别按不同速率前进，若最终兔子能超过乌龟，则说明有圈。
代码如下所示：

public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null || head.next == null) { //防止初始后序为空
            return false;  
        }
        ListNode slow = head;
        ListNode fast = head.next;
        while (slow != fast) {
            if (fast == null || fast.next == null) {
                return false;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        return true;
    }
}

注：（1）|和||的差别：
||：短路或。当符号"||"左边程序为真(true)后。结果就为true。不去运算符号右边程序。如果左边程序为false，运算右边程序，右边程序为true,结果为true。符号左右两边有一个为true，结果为true。
|：符号左右程序都会运算。两边都为true，结果为true。两边有一个为false，则结果为false；符号左右两边有一个为true，结果为true。
（2）定义链表ListNode时，

  • 链表的首个值不能为0，当首个参数为0时，代表着链表为空。 只需要定义一个ListNode xx = newListNode(0);即可。即只定义一个空链表。 不需要定义长度 。
  • 赋值时 通过xx.next = newListNode(4);来赋值，注意此时是赋值给下一个指针指向的位置,此时此链表一个值，值为4。
  • 取第一个值时，只需要xx.val即可。 取第二或之后的值时，需要xx = xx.next;int x = xx.val;这个方式取值。

（12）21.合并两个有序链表

题目如下所示：
在这里插入图片描述
解题思路：
（1）递归
两个链表头部值较小的与另一个剩下元素操作结果合并。
代码如下所示：

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        } else if (l2 == null) {
            return l1;
        } else if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}

(2)迭代
设置哨兵结点，比较l1和l2，进行合并。
代码如下所示：

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode prehead = new ListNode(-1);
        ListNode prev = prehead;
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                prev.next = l1;
                l1 = l1.next;
            } else {
                prev.next = l2;
                l2 = l2.next;
            }
            prev = prev.next;
        }

        // 合并后 l1 和 l2 最多只有一个还未被合并完，我们直接将链表末尾指向未合并完的链表即可
        prev.next = l1 == null ? l2 : l1;

        return prehead.next;
    }
}

注意：创建链表哨兵头可以为：ListNode pre = new ListNode(-1);
ListNode prehead = pre;

(13)移除链表元素

题目如下所示：
在这里插入图片描述
解题思路：
（1）递归
递归的终止条件是 head 为空，此时直接返回 head。当 head 不为空时，递归地进行删除操作，然后判断 head 的节点值是否等于 val并决定是否要删除 head。
代码如下所示：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if (head == null) {
            return head;
        }
        head.next = removeElements(head.next, val);
        return head.val == val ? head.next : head;
    }
}

(2)迭代
由于链表的头节点 head 有可能需要被删除，因此创建哑节点 dummyHead，令 dummyHead.next=head，初始化 temp=dummyHead，然后遍历链表进行删除操作。最终返回 dummyHead.next 即为删除操作后的头节点。
代码如下所示：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode temp = dummyHead;
        while (temp.next != null) {
            if (temp.next.val == val) {
                temp.next = temp.next.next;
            } else {
                temp = temp.next;
            }
        }
        return dummyHead.next;
    }
}

（14）206反转链表

题目如下所示：
在这里插入图片描述
解题思路为：
（1）迭代
在遍历链表时，将当前节点的 next指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。
代码如下所示：

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
}

（2）递归
n k.next.next=nk
需要注意的是 n1的下一个节点必须指向 ∅。如果忽略了这一点，链表中可能会产生环。
代码如下所示：

class Solution {
    public ListNode reverseList(ListNode head) {
            if(head==null||head.next==null){
                return head;
            }
            ListNode newhead=reverseList(head.next);
            head.next.next=head;//加环
            head.next=null;//删环，防止循环
            return newhead;
    }
}

(15)83删除排序链表中的重复元素

题目如下所示：
在这里插入图片描述
解题思路如下：
一次遍历：
由于给定的链表是排好序的，因此重复的元素在链表中出现的位置是连续的，因此我们只需要对链表进行一次遍历，就可以删除重复的元素。
代码如下所示：

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
            ListNode result=head;
            while(head!=null&&head.next!=null){
                if(head.val==head.next.val){
                    head.next=head.next.next;
                }else{
                    head=head.next;
                }
            }
            return result;
    }
}

(16)有效的括号

题目如下所示：
在这里插入图片描述
解题思路：
使用栈这一数据结构来解决。
我们遍历给定的字符串 sss。当我们遇到一个左括号时，我们会期望在后续的遍历中，有一个相同类型的右括号将其闭合。由于后遇到的左括号要先闭合，因此我们可以将这个左括号放入栈顶。
代码如下所示：

class Solution {
    public boolean isValid(String s) {
        int n = s.length();
        if (n % 2 == 1) {
            return false;
        }

        Map<Character, Character> pairs = new HashMap<Character, Character>() {{
            put(')', '(');
            put(']', '[');
            put('}', '{');
        }};
        Deque<Character> stack = new LinkedList<Character>();
        for (int i = 0; i < n; i++) {
            char ch = s.charAt(i);
            if (pairs.containsKey(ch)) {
                if (stack.isEmpty() || stack.peek() != pairs.get(ch)) {
                    return false;
                }
                stack.pop();
            } else {
                stack.push(ch);
            }
        }
        return stack.isEmpty();
    }
}

注：（1）Java中Stack栈中的 peek()方法 和 pop()方法 的区别
stack.peek() 的作用是返回栈顶元素，但不是将栈顶元素弹出。
stack.pop() 的作用是返回栈底元素，并且同时将栈顶元素出栈。
（2）新建一个栈：Deque stack = new LinkedList();
从官方解释来看，ArrayDeque是无初始容量的双端队列，LinkedList则是双向链表。

（17）232 用栈实现队列

题目如下所示：
在这里插入图片描述
解题思路：
将一个栈当作输入栈，用于压入 push传入的数据；另一个栈当作输出栈，用于 pop 和 peek操作。
每次 pop 或 peek 时，若输出栈为空则将输入栈的全部数据依次弹出并压入输出栈，这样输出栈从栈顶往栈底的顺序就是队列从队首往队尾的顺序。
代码如下所示：

class MyQueue {
    Deque<Integer> inStack;
    Deque<Integer> outStack;

    public MyQueue() {
        inStack = new ArrayDeque<Integer>();
        outStack = new ArrayDeque<Integer>();
    }

    public void push(int x) {
        inStack.push(x);
    }

    public int pop() {
        if (outStack.isEmpty()) {
            in2out();
        }
        return outStack.pop();
    }

    public int peek() {
        if (outStack.isEmpty()) {
            in2out();
        }
        return outStack.peek();
    }

    public boolean empty() {
        return inStack.isEmpty() && outStack.isEmpty();
    }

    private void in2out() {
        while (!inStack.isEmpty()) {
            outStack.push(inStack.pop());
        }
    }
}

注：
在这里插入图片描述

(18)二叉树的前序遍历

题目如下所示：
在这里插入图片描述
解题思路：
（1）递归
可以显而易见，可以使用递归的方法进行解决。
代码如下所示：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        preorder(root, res);
        return res;
    }

    public void preorder(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        res.add(root.val);
        preorder(root.left, res);
        preorder(root.right, res);
    }
}

（2）迭代
代码如下所示：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }

        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode node = root;
        while (!stack.isEmpty() || node != null) {
            while (node != null) {
                res.add(node.val);
                stack.push(node);
                node = node.left;
            }
            node = stack.pop();
            node = node.right;
        }
        return res;
    }
}

（19）二叉树的后序遍历

题目如下所示：

在这里插入图片描述
解题思路：
（1）递归
（2）迭代（难）
代码如下所示：

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        if (root == null) {
            return res;
        }

        Deque<TreeNode> stack = new LinkedList<TreeNode>();
        TreeNode prev = null;
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            if (root.right == null || root.right == prev) {
                res.add(root.val);
                prev = root; //用于辨别是否重复添加，防止循环
                root = null; // 防止重复增添左结点
            } else {
                stack.push(root);
                root = root.right;
            }
        }
        return res;
    }
}

（20）二叉树的层序遍历

题目如下所示：
在这里插入图片描述
解题思路：
（1）BFS（广度优先算法）
广度优先遍历是按层层推进的方式，遍历每一层的节点。
代码如下所示：

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ret = new ArrayList<List<Integer>>();
        if (root == null) {
            return ret;
        }

        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<Integer>();
            int currentLevelSize = queue.size();
            for (int i = 1; i <= currentLevelSize; ++i) {
                TreeNode node = queue.poll();
                level.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            ret.add(level);
        }
        
        return ret;
    }
}

（2）DFS（深度优先算法）
递归的思想。
代码如下所示:

import java.util.*;	
class Solution {
	public List<List<Integer>> levelOrder(TreeNode root) {
		if(root==null) {
			return new ArrayList<List<Integer>>();
		}
		//用来存放最终结果
		List<List<Integer>> res = new ArrayList<List<Integer>>();
		dfs(1,root,res);
		return res;
	}
	
	void dfs(int index,TreeNode root, List<List<Integer>> res) {
		//假设res是[ [1],[2,3] ]， index是3，就再插入一个空list放到res中
		if(res.size()<index) {
			res.add(new ArrayList<Integer>());
		}
		//将当前节点的值加入到res中，index代表当前层，假设index是3，节点值是99
		//res是[ [1],[2,3] [4] ]，加入后res就变为 [ [1],[2,3] [4,99] ]
		res.get(index-1).add(root.val);
		//递归的处理左子树，右子树，同时将层数index+1
		if(root.left!=null) {
			dfs(index+1, root.left, res);
		}
		if(root.right!=null) {
			dfs(index+1, root.right, res);
		}
	}
}

注：
在这里插入图片描述
1、add()和offer()区别:
add()和offer()都是向队列中添加一个元素。一些队列有大小限制，因此如果想在一个满的队列中加入一个新项，调用 add() 方法就会抛出一个 unchecked 异常，而调用 offer() 方法会返回 false。因此就可以在程序中进行有效的判断！
2、poll()和remove()区别：
remove() 和 poll() 方法都是从队列中删除第一个元素。如果队列元素为空，调用remove() 的行为与 Collection 接口的版本相似会抛出异常，但是新的 poll() 方法在用空集合调用时只是返回 null。因此新的方法更适合容易出现异常条件的情况。

似忆
关注
《算法与数据结构》课程设计
m0_55769200的博客
09-26 3933
一．设计目的 1．提高数据抽象能力。根据实际问题，能利用数据结构理论课中所学到的知识选择合适的逻辑结构以及存储结构，并设计出有效解决问题的算法。 2．提高程序设计和调试能力。学生通过上机练习，验证自己设计的算法的正确性。学会有效利用基本调试方法，迅速找出程序代码中的错误并且修改。 3．初步了解开发过程中问题分析、整体设计、程序编码、测试等基本方法和技能。 二．设计任务 设计一个基于DOS菜单的应用程序。要求利用多级菜单实现各种功能。内容如下： 单链表的基本操作及应用 创建 插入 删除 ..
数据结构算法——Visual.C.6.0程序集] 清晰
11-30
数据结构算法——Visual.C.6.0程序集].侯识忠.清晰。 节省硬盘资源，放在这里留用。
数据结构-算法日志
u011809807的博客
09-15 303
算法培训第一周内容Day1 链表 课件： //SRCT_Certi/8.第三期Pro培训/培训课件/day1_链表/习题： POJ 3481 Day2 栈，队列 课件： //SRCT_Certi/8.第三期Pro培训/培训课件/day2_栈,队列/习题： 进制转换：//SRCT_Certi/8.第三期Pro培训/培训课件/day
数据结构与算法学习日记【1】
horizon_157 Blog
03-06 345
文章目录什么是数据结构？定义抽象数据类型（Abstract Data Type）什么是算法定义算法的复杂度好算法的取决复杂度分析应用实例（最大子数列）算法一算法二算法三（分而治之）算法四（线上/在线处理）关于课程 解决问题方法的效率，跟算法的巧妙程度有关。 什么是数据结构？ 定义 1、数据对象在计算机中的组织方式⬇️ 逻辑结构 物理存储结构 2、数据对象与一系列加在其身上的操作相关 3、完成上述操作所用的方法即为算法 抽象数据类型（Abstract Data Type） 1、数据类型 数据对象集
数据结构和算法学习日记——栈
我要，我要，我还要
09-22 250
栈 栈是一个陷入后出的有序列表。 栈只能在表的一端进行添加和删除，不可对另一端进行操作，也不可在中间进行插入操作。 栈的可进行添加删除操作的一端被称为栈顶，另一端成为栈底。 栈有两种基本操作：出栈（pop）、入栈（push） 栈的应用场景 子程序 的调用 处理递归调用 表达式的转换（中缀表达式转换为后缀表达式） 二叉树的遍历 图的深度优先搜索 栈的简单实现 栈有两种基本的实现方式：数组、链表。...
数据结构与算法学习日记【2】
horizon_157 Blog
04-27 178
二叉树的遍历二叉树图遍历说明前序遍历中序遍历后序遍历说明二叉树的三种遍历前序遍历中序遍历后序遍历 二叉树图 遍历说明 前序遍历 前序遍历是三种遍历中最为简单的一种遍历，只需从头往下遍历完左子树然后再遍历右子树即可。 中序遍历 找到左子树的中间结点，遍历完左子树再遍历右子树，然后再寻找右子树的中间结点同理遍历。 后序遍历 后序遍历即为前序遍历的反方向，从左子树的底部往上遍历，然后再遍历右子树 说明 所有遍历都是先左子树再右子树！！！ 二叉树的三种遍历 前序遍历 遍历结果：ABDGHICEJF 遍历过程⬇️
数据结构与算法学习日记（1）-- 链表1
daoyanjia的博客
02-23 229
1. 链表结构 class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next 2. 链表创建 class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next class ListLink(obj.
刷题算法提高阶段-数据结构7
12-22
在编程和计算机科学领域，数据结构与算法是两个至关重要的概念，它们构成了高效代码的基础。在"刷题算法提高阶段-数据结构7"这个主题中，我们主要关注的是通过实践来提升对数据结构的理解和应用能力，特别是针对解决...
数据结构 & 算法 & Redis & Kafka & MongoDB &
最新发布
01-14
数据结构、算法、Redis、Kafka、MongoDB以及Spring和Zookeeper是计算机科学和技术领域中的核心组成部分，尤其在Java开发中扮演着至关重要的角色。这些技术涵盖了基础理论、分布式系统、数据库管理和中间件等多个方面...
数据结构查找算法的C语言实现
07-01
在本资源"数据结构查找算法的C语言实现"中，我们聚焦于查找算法这一主题，它是数据结构的重要组成部分，用于在数据集合中定位特定元素。 查找算法的效率直接影响到程序的性能，尤其是在大数据量的情况下。C语言因其...
C++学习日志day19-----数据结构与算法
displayMessage的博客
04-26 190
冒泡排序，选择排序，插入排序，快速排序，折半查找
数据结构与算法学习笔记
tanqing24520的博客
09-12 3369
1. 数据结构与算法 1.1 知识脑图 1.2 什么是 数据结构 与 算法 数据结构 就是一组数据的存储结构 算法 就是操作一组数据的方法 数据结构是为算法服务的，算法要作用在特定的数据结构之上 1.3 为什么需要数据结构和算法 在计算机科学和互联网迅猛发展下，需要计算的数据量越来越庞大。但是计算机的计算能力是有限的，这么大量的数据计算，需要越来越多的计算机，需要越来越长的计算时间，注重效率的我们需要尽可能的提高计算效率 选用合适的数据结构和算法，特别是在处理体量非常庞大的数据的时候，可以极
数据结构与算法笔记系列一：算法概述
chenHARDEN的博客
09-19 343
一、数据结构与算法概述 1、数据结构 数据结构：用来组织和存储数据的集合 数据结构可分为逻辑结构和物理结构。逻辑结构从数据与数据之间的关系来划分，物理结构从计算机存储角度来分类（又称存储结构）。 逻辑结构：集合结构、线性结构、树形结构、图形结构 物理结构（存储结构）：顺序存储结构、链式存储结构 2、算法 算法：算法即分步骤解决问题的过程。 二、算法分析 衡量算法优劣的标准：时间、空间 1、算法的时间复杂度分析 分析一个算法的运行时间，最重要的就是把核心操作的次数和输入规模关联起来 1.1 函数渐进增长
数据结构学习日志（一）什么是数据结构与算法
weixin_42526504的博客
03-09 260
数据结构学习日记。
无限深蓝的专栏
03-12 1202
想想还真是汗颜啊！一大把的年纪了，来学习数据结构，谁让咱底子薄呢！不是科班出身，又耽搁了这么多年，现在才觉得要做的更好，真的是太难了，水平就在那放这呢，也没什么好办法，生命不熄，战斗不止啊！其实零零星星的也看了好多了，就是不系统，现在系统的学，还真实别有风味！今天下了一个教程，不错。好，现在就开课了！ 
【算法和数据结构】仓库日志
weixin_38213410的博客
07-25 257
题目描述 ​ 某仓库购入新的货物（每次购入的货物均不同）并将一部分老货物发出，这个过程会有软件对数据以日志形式保存，规则如下： ​ 该日志记录了两类操作：第一类操作为入库操作，以及该次入库的货物数量；第二类操作为出库操作。这些记录都严格按时间顺序排列。入库和出库的规则为先进后出，即每次出库操作货物为当前在仓库里所有货物中最晚入库的货物。 ​ 为了便于分析，现在加入了第三类查询操作，每次查询时，输出当前仓库数量最多的货物的数量。 输入 输出 样例输入 13 0 1 0 2 2 0 4.
数据结构学习日记----1
James__qiu的博客
02-10 314
数据结构学习日记----1 ▪ 数据结构是学习计算机科学的基础，它能让我们学习到一些计算机底层的东西，能够帮助我们更好的去理解和应用计算机。 ▪ 历史来源：1968年美国的高德纳在《计算机程序设计艺术》一书中提出。 A.什么是数据？ 数据是描述客观事物的符号，是计算机中可以操作的对象。 数据，数据对象，数据元素，数据项的关系可有下面的导图直观的看到。 B.什么是数据结构？ 数据结构是相互之间存在...
数据结构学习日记----2
James__qiu的博客
02-11 222
数据结构学习日记----2 1.算法：算法是指解决特定问题求解步骤的描述。 2.算法的特点：输入，输出，有穷性，确定性，可行性。 3.算法的设计要求：正确性，可读性，健壮性，时间效率高，储存量低。 - 解决不同的问题就需要不同的算法，而要评价一个算法的好坏我们通常会用到时间复杂度，空间复杂度。 **1. 时间复杂度：我们常用大O阶来反映时间的复杂度。 O(1)<O(logn)<O(n...
数据结构学习笔记Day7
qq_38401906的博客
11-10 98
好吧，今天没学习，打lol去了，shit好久没打游戏体验极差，我估计已经是黑铁段位的水平了吧。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值