Doubly-linked list data structure

OCTA-500:用于光学相干断层扫描血管造影研究的视网膜数据集|文献速递-基于生成模型的数据增强与疾病监测应用 数据集提供了丰富的图像和注释,包括两种模态(OCT/OCTA体积)、六种投影类型、四种文本标签(年龄/性别/眼别/疾病)以及七种分割标签(大血管/毛细血管/动脉/静脉/2D FAZ/3D FAZ/视网膜层)。我们介绍了新的 OCTA-500 数据集,该数据集包含来自 500 名受试者的 OCTA 成像,并提供了丰富的图像和标注集。(C) OCTA-500 切片的人工标注示例。图 4. OCTA-500 数据集中文本标签的统计直方图:(a) 性别,(b) 眼别,(c) 年龄,(d) 疾病。 阅读详情


Introduction
In this lab, you will deepen and solidify the concept of pointers through the concept of a
doubly-linked list data structure. You will implement a library to create, modify, and delete linked
lists. You will also learn to allocate and deallocate space during runtime. Finally, you will use
your library to compare two algorithms for counting unique words in a list. This lab will be
completed on both the Nucleo development kit and Linux.
Reading
● K&R – Chapters 5, 6.7, 7.8.5, appendix B5
Concepts
● Doubly-linked lists
● Memory allocation
● Sorting
● Pointers (including NULL)
● Algorithmic analysis
Required Files:
● LinkedList.c
● LinkedListTest.c
● sort.c
● README.pdf
BOARD OF STUDIES IN COMPUTER ENGINEERING
Linked Lists
20 Points
Lab Files:
● DO NOT edit these files:
o LinkedList.h – Contains the spec and prototypes for the linked-list functions you
will implement.
o BOARD.c/h – Standard hardware library for ECE013.
o stopwatch.c/h – Tools for benchmarking the execution time of your program.
o Lab06_main.c – Default Makefile target; contains the main() function that you
will use to benchmark the algorithms that you develop in sort.c.
o GNUmakefile — Used for compiling this lab on Linux.
● Edit these files:
o sort.c – This file contains some starter code for a demonstration of the testing
for the sorting algorithms along with a function to generate a word list for the
sorts to operate on.
▪ It is included as sort_template.c
● Create these files:
o LinkedList.c – Implement the library described in LinkedList.h.
o LinkedListTest.c – A test harness for your LinkedList library. Should include a
main().
Assignment requirements
● Your program will implement the functions whose prototypes are provided in
LinkedList.h. The functions all have appropriate documentation and describe the
required functionality.
● Within LinkedListTest.c you will:
o Create a test harness代写Doubly-linked list data structure that tests your linked list functions and ensures
that they return the correct values. As in previous labs, at least two tests
are required per function.
o Once you are done testing the functionality of LinkedList.c, you will need
to exclude LinkedListTest.c from the project.
● Within sort.c you will:
o Implement two algorithms for sorting linked lists inside the functions
SelectionSort() and InsertionSort(). You will use these with the
provided main() code to perform timing experiments that will
(hopefully) demonstrate the usefulness of linked lists. You should not
modify either main() or CreateUnsortedList() in this file.
● Add inline comments to explain your code.
● Create a readme file and export it to PDF named README.pdf containing the
following items. Spelling and grammar count as part of your grade so you'll want
to proof-read this before submitting. This will follow the same rough outline as a
lab report for a regular science class. It should be on the order of three
paragraphs with several sentences in each paragraph.
o First you should list your name & the names of colleagues who you have
collaborated with.
1
o Report the results of the timing experiment in sort.c. Which was faster,
SelectionSort() or InsertionSort()? Explain why. Was this what you
expected? How does performance compare on Linux vs your Nucleo?
o In the next section you should provide a summary of the lab in your own
words. Highlight what you thought were the important aspects of the
lab. If these differ from how the lab manual presents things, make a
note of that.
o The following section should describe your approach to the lab. What
was your general approach to the lab? Did you read the manual first or
what were your first steps? What went wrong as you worked through it?
What worked well? How would you approach this lab differently if you
were to do it again? How did you work with other students in the class
and what did you find helpful/unhelpful?
o The final section should describe the results of you implementing the
lab. How did it end up finally? How many hours did you end up spending
on it? What did you like about it? What did you dislike? Was this a
worthwhile lab? Do you have any suggestions for altering it to make it
better? What were the hardest parts of it? Did the points distribution for
the grading seem appropriate? Did the lab manual cover the material in
enough detail to start you off? Did examples or discussions during class
help you understand this lab or would more teaching on the concepts in
this lab help?
1 NOTE: collaboration != copying. If you worked with someone else, be DETAILED in your
description of what you did together.
● Make sure that your code triggers no errors or warnings when compiling as they
will result in a significant loss of points.
● Follow the style guidelines.
Doing this Lab on Linux:
For this lab we will continue using the make system. The commands as before are
below. For this to work the file ‘GNUmakefile’ needs to be in the same directory as
the rest of your files, it is only used when compiling on Linux.
● $ make
o This command will create the final executable named Lab06
● $ make LinkedListTest
o This command will compile your linked list test harness into the
executable LinkedListTest
Grading:
This assignment consists of 20 points:
● 8.5: Automated Components:
o 6.5 – LinkedList library
▪ 3.5 = 0.5 points per function for each of LinkedListNew(),
LinkedListCreateAfter(), LinkedListCreateBefore(), LinkedListRemove(),
LinkedListSize(), LinkedListGetFirst(), LinkedListGetLast(), and
LinkedListData().
▪ 1.0 point, all functions handle null pointer inputs
▪ 1.0 point, all functions that allocate can handle malloc() failures
▪ 0.5 no functions reference deallocated data
▪ 0.5 no functions allocate unnecessary memory
o 2.0 – Sort.c
▪ 1.0 SelectionSort() gives correct results, and does not print.
▪ 1.0 InsertionSort() gives correct results, and does not print.
● 11.5: Human components:
o 0.5 -- LinkedListPrint()
o 4.0 -- Test harness for LinkedList
▪ 1 point for testing each function.
▪ 1 point for thorough and diverse tests.
▪ 1 point for readability of output.
▪ 1 point for correctly performing the timing experiment on
SelectionSort() and InsertionSort(), then reporting your results in
README.pdf.
o 1.0 sort.c:
▪ 1 – explanation in README.pdf is clear, accurate, and demonstrates
understanding of why linked lists are useful.
o 1.5 points – Readability and code style
o 4.5 points – Lab writeup
● Deductions:
o NO CREDIT for sections where required files don't compile
o -1 changing the name of a prototyped function in sort.c (this will break our
autochecker scripts!)
o -2: At least one compilation warning
o -2: Extremely bad coding practice (Used extern or goto, extreme inefficiency or
unreadability)
o Other deductions at grader’s discretion.
o It must compile within Visual Studio Code/PlatformIO and Linux using the C11
standard. Code that does not compile will receive no credit.
Pointers
Pointers are covered thoroughly in the required reading for this lab, so if you are having
trouble, refer back to chapter 5 of K&R. However, there is one concept about pointers
that is not directly addressed in the reading: null pointers. A null pointer is a pointer to
nothing. These pointers must be handled as a special case if they are passed to a
function that expects non-null data pointers. This is one of the major sources of crashes
in programs.
The main problem with null pointers arises from when you try to dereference them
(assuming x is an int pointer and equal to NULL): *x = 6;
The reason for why becomes clear when you think about what memory location x points
to. 0, or NULL, is an invalid memory location, and a "null pointer dereference" error
occurs because there is no memory location to write to, so an error occurs. This is a
"fatal" error, which means that the program has no way to handle it, so the only thing it
can do is crash! This is a common cause of Windows blue-screen-of-death errors (when
this dereferencing happens in kernel space
2
). The solution to this is to check for null
pointers before dereferencing. An especially important case for checking to see if a
pointer is null is after any call to malloc() or calloc(), which we will cover a little later.
Doubly-linked lists
In computer programs, much as in real life, keeping a list of things can be useful. Usually
the number of items that will be in this list is known ahead of time and so in a computer
program this list could be kept in a standard C array. There will be occasions, like when
processing user input, when the number of items to be stored in a list is not known
ahead of time. This is a problem with C’s statically-allocated arrays. The common
solution is to use another data type called a linked list.
Linked lists are exactly what they sound like: a collection of objects that are all linked
together to form a single list. As each item is linked to at least one other item in the list
there is a set ordering to the list: from a “head” item at the start to a “tail” item at the
end. Since these items are all connected it is easy to access any item from any other item
by just traversing or “walking” through the list.
For this lab you will be implementing a doubly-linked list, the more useful sibling of the
linked lists. A doubly-linked list is also straightforward: each item is linked to both the
item before it and after it. This allows for traversal of the list from any element to any
other element by walking along it, which makes using the list very easy.
2Note that kernel space vs user space is a key concept in protected mode multitasking operating systems
such as Linux and WinNT derivatives. Using protected mode, a misbehaving user program cannot (in
theory) crash the entire system. The absence of protected mode is a key property of embedded systems.
The items in the list you are implementing are stored as structs in C because they will
be storing a few different pieces of data. Specifically it holds a pointer to the previous
ListItem, which will be NULL if it is the head of the list; a pointer to the next
ListItem, which will be NULL if it’s at the end of the list; and a pointer to any kind of
data (NULL if there’s no data). The typedef and the name after the “}” let you refer to
the struct in a similar fashion to any other data type, by using the single name
“ListItem” instead of the longer “struct ListItem”.
The definition of the ListItem struct in LinkedList.h:
typedef struct ListItem {
struct ListItem *previousItem;
struct ListItem *nextItem;
char *data;
} ListItem;
Now that you understand the structure of a linked list we will introduce the various
operations that can be performed upon a list. The standard operations are creating a
new list, adding elements to a list, finding the head of a list, and removing elements
from a list.
3
Creating a new list: A new list is created by just making a single ListItem. As this ListItem
is both the head and tail of the list there is no item before it or after it in the list.
Adding to a list: Now that you have a list, how do you add more elements to it? With the
arrays that you are familiar with, you need to know two things: the position to insert into
and the data that will be inserted. With linked lists it’s a little different because there’s
never a “free spot” to insert a new item into. What is done instead is that the position of
the new list item is relative to an existing item, generally the item before it in the list. So
to insert an item into the list, that item is inserted after an existing item. If the list went
3
It is incredibly useful to your understanding to draw this out on a piece of paper or a white board. Make
boxes for each member of the struct, and use arrows to point to the next list element and the previous
ones (in other words, use arrows to show what the pointers point to). Go through all of the functions and
make sure you understand what you need to do. Once you understand it conceptually, coding it up is very
simple.
A <-> B <-> C and you want to insert D after B then the list would become A <-> B <-> D
<-> C. So that means that the previous item and next item pointers of both B and C will
need to change to accommodate the new item D.
Finding the head: The head of a list is a special item because it has no preceding
element (represented by a NULL pointer). Since all the elements in a list are connected,
finding the head merely requires traversing the list until a list item is found with no
preceding element. A function that finds the head of the list has one odd scenario; see if
you can figure out what it is.
Removing an element: Removing an element from a list is the opposite of adding to it.
Following the example above you’d go from a list like A <-> B <-> D <-> C to A <-> B <-> C.
The pointers of B and C both need to be modified to account for the removal of D.
Generally the data that was stored within D is also desired after the removal of the item
and should be returned.
malloc(), calloc(), and free()
This lab also relies on the use of memory allocation using malloc() (and/or calloc())
and free(). These are discussed somewhat in chapter 5 of K&R. As they are standard
library functions they are documented thoroughly online or in the Linux man-pages.
Refer to those resources to understand them.
It should be emphasized here that after any call to malloc() or calloc() you should
always check for NULL pointers! Memory allocation relies on the heap, which PlatformIO
specifies as 8192 bytes (0x200) for our Nucleo development kit by default. This project
requires at least a couple hundred bytes for malloc() and calloc() to work, so we can
proceed with the default heap size.
4
4The linker script used by PlatformIO (which defines heap size) is auto-generated for all
supported chip architectures. You can find the location of the linker script for STM32
architectures under the “~/.platformio/packages/tool-ldscripts-ststm32/” path on
Linux/UNIX-like operating systems.
Note that this makes it easy to test that your code is properly checking for NULL
pointers: if you set the heap to 0, ALL calls to malloc()/calloc() will fail; if your code
doesn't crash, it's working!
Sorting
Sorting is an incredibly important function in computer programming. While you may
not think it is used a lot, it is quite common within a program to have the need to sort a
series of numbers. Sorting is an entire field of study within computer science and so
there are a huge number of algorithms that do just that. In this lab, you will be focusing
on two: Selection Sort is simple, intuitive, and easy to implement on a static array, but it
is slow. Insertion Sort is usually significantly faster, but it relies on a data structure that
allows insertion.
Selection sort partitions the list into two partitions. The first partition is sorted, while
the second partition is unsorted. At the start of the algorithm, the sorted partition is
empty. With each iteration, the sorted partition grows by one element, and the
unsorted partition shrinks, until there are no remaining unsorted items. This is achieved
by finding the smallest element in the unsorted partition and moving it to the sorted
partition.
Pseudo-code for selection sort is provided below. This pseudocode is written in a way
that makes it easy to apply to linkedLists, but note that in this case the pointers could
easily be replaced with indexes to a static array. We use two pointers: “FU” stands for
“First Unsorted”, representing the first item in the unsorted portion of the list. “S”
stands for “Scan”, since it “scans” through the unsorted partition, looking for the
smallest item.
FU is pointer to first item
while FU is not tail:
S is pointer to FU’s nextItem
while S is in list:
if FU > S:
swap FU and S contents
advance S
advance FU
The outer for loop effectively tracks the right-most element of the sorted array filling up
the left portion of the array. This means that for each iteration of the outer-loop, the
inner-loop can perform many element swaps.
Below is an example of Selection Sort in action:
D A C E B //
^FU ^S // D > A, swap and advance S
A D C E B //
^FU ^S // A < C, advance S
^FU ^S // A < E, advance S
^FU ^S // A < B, advance S
// S is at end of list, advance FU
A D C E B //
^FU ^S // D > C, swap and advance S
A C D E B //
^FU ^S // C < E, advance S
^FU ^S // C > B, swap and advance S
A B D E C //
// S is at end of list, advance FU
A B D E C //
^FU ^S // D < E, advance S
^FU ^S // D > C, swap and advance S
A B C E D //
// S is at end of list, advance FU
A B C E D //
^FU ^S // E > D, swap and advance S
A B C D E //
// S is at end of list, advance FU
// FU is at tail, return
Insertion Sort operates in a similar way to selection sort. Like Selection Sort, it partitions the list
into a sorted and unsorted portion, and uses a double-loop structure to move items from the
unsorted portion into the sorted portion. Unlike its slower cousin, insertion sort leverages an
“insert” operation to reduce the average time spent in the inner loop. Rather than “scanning”
through the unsorted partition in search of the smallest element, it scans through the sorted
portion to find the best place to insert the next item. It has the advantage that this scan does
not need to cover the entire sorted partition, instead stopping as soon as it finds the appropriate
place to insert.
Pseudocode for an insertion sort algorithm is given below. We use three pointers: “FS” stands
for “First Sorted”, and represents the first item in the sorted partition of the array. “LU” stands
for “Last Unsorted,” and represents the last item in the unsorted partition. Again “S” stands for
“scan,” since its job is to scan through the sorted partition to find the appropriate insertion
point.
FS = tail of list
while FS is not head of list:
LU = FS’s previous item
if LU < FS:
FS = LU
else:
S = FS
while (S is not tail of list):
if S's next item is greater than LU:
break
else:
S = S's next item
remove LU item
re-insert after S
Insertion Sort is slower than Selection Sort in a static array, but can be very quick in a linked list
data structure.
Note that LinkedList.h does not have a true “insert” function. You can achieve something similar
by removing an item and then using CreateAfter() or CreateBefore() to insert it back in
5
. You will
also need to account for inserting items at the beginning and end of your list.
Below, you can see the InsertionSort in action:
5 Don’t forget to save the pointer to the ListItem’s data member before you remove!
D A C E B //
^LU ^FS // E > B, make an S pointer
^S // B < E, advance S
// S is at end of list, insert
D A C B E //
^LU ^FS // C > B, make an S pointer
^S // C < E, insert
D A B C E //
^LU ^FS // A < B, advance FS and LU
D A B C E //
^LU ^FS // D > A, make S pointer
^S // D > B, advance S
^S // D > C, advance S
^S // D < E, insert
A B C D E // FS is head, return
^FS
You will write code for both of these algorithms inside of the SelectionSort() and InsertionSort()
functions in sort.c.
Evaluating SelectionSort() and InsertionSort() in Lab06_main.c
Although we have stated that InsertionSort() is faster than SelectionSort(), we should
test that claim experimentally. To do this, we will use the “stopwatch” library [included
in this assignment’s directory] to start, stop, and report the differences between their
execution times.
To measure the time required to execute SelectionSort(), we need to track the system
time immedIately before and after SelectionSort(), and then run our code. To do this
using the stopwatch.c library included with this lab:
1. Stopwatch_Init() – This function sets up your system’s clock; only needs to be
called once.
2. Stopwatch_StartBenchmark() – Starts or restarts the stopwatch timer.
3. Stopwatch_StopBenchmark() – Stops the stopwatch timer and saves the results
in its local scope.
4. Stopwatch_PrintBenchmarkResults() – Displays information about the cycles
required/time past for the last benchmark run. NOTE: You will need to call this
function to see the results after running “Stopwatch_StopBenchmark()”!
Approaching this lab
Like all labs for this class, you should first start with implementing the LinkedList library.
Be sure to handle when malloc() returns NULL, NULL pointers as arguments to functions,
and whether the function expects the head of the list or not.
1. Implement LinkedListNew().
Test this by writing code to create a new list of size 1. Manually inspect the
resultant struct that is created using the Variables window in VS
Code/PlatformIO to see that it is correct while running on your Nucleo.
2. Implement LinkedListCreateAfter() and LinkedListCreateBefore().
Test these by creating a list of multiple sizes greater than 1. Manually inspect the
resultant list using the Variables window in VS Code/PlatformIO.
3. Now that you can create lists of a multitude of sizes, implement
LinkedListGetFirst(). This function will be helpful for implementing the other
functions.
Test this function by creating a few different lists, storing the pointer to the head
node. Pass a non-head node to GetFirst() and see if it matches the memory
address of the head node.
4. Implement LinkedListGetSize().
Run it on the different size lists you created earlier and confirm that results are
as expected.
5. Implement LinkedListPrint() and LinkedListSwapData().
These should be straight-forward to test.
6. At this point you are now ready for implementing SelectionSort() and
InsertionSort in sort.c. The debugger will be very useful here. You may find it
convenient to use a shorter list during testing.
7. Once SelectionSort() and InsertionSort() are functional, use the stopwatch tool
and the debugger to measure the time required for each sort. Record the
results in README.pdf and explain them.
A note on using GNUmakefile
One beautiful perk of using Makefiles is easy cleanup. While in the previous lab, you had to
remove every object (.o) file and executable individually, the GNUmakefile provided for you in
this lab assignment can take care of this mess for you. Simply type into your terminal:
Unset
$ make clean
This is just one of many useful features that you can reap from having a well-built Makefile,
especially when dealing with larger projects. We encourage you to read more about building
Makefiles.
6
A note on testing with PlatformIO/VS Code
While Makefiles (e.g. GNUmakefile) allow you to specify the target that you would like to
compile and run on your microcontroller, for the purposes of our course you will only be able to
build a PlatformIO project with one “main()” function declared within its scope. For example in
this lab assignment, you will need to move either your LinkedListTest.c or your Lab06_main.c to a
directory outside of the “src/” directory of your project for it to compile. We suggest leaving any
files that you do not want to build in your “Lab06/” directory for safe-keeping, then swapping
them between there and the “Lab06/src/” directory depending on which main() function you
would like to run.
How your code will be tested
Like previous labs, your code will be tested using your code as a library where we will
test with different programs to exercise your library on both Nucleo and Linux. Your
LinkedListTest.c program will also be run so that we can observe your testing output.
6 A thorough (but perhaps overwhelming) guide to writing Makefiles is the GNU Make manual. This guide
contains a comprehensive description of the features offered by Makefiles, and it is not terribly-written;
however, it is very long. A more practical approach, as with much software development, is to read and
analyze other developers’ code when you encounter it (key word: “analyze”).

核密度估计及其Python实践 一、参数估计简介 很多情况下,我们只有有限的样本集,而类条件概率密度函数p(x|ωi)和先验概率P(ωi)是未知的,需要根据已有样本进行参数估计,然后将估计值当作真实值来使用。 由给定样本集求解随机变量的分布密度函数问题是统计机器学习和概率统计学的基本问题之一。解决该问题的方法包括参数估计和非参数估计两大类: 1.参数估计方法 已知概率密度函数的形式而函数的有关参数未知,通过估计参数来估计概率密度函数的方法。有两种主要参数估计法:确定性参数估计方法是把参数看作确定而未知的, 典型方法为最大似然估计。随机参数 阅读详情

相关推荐

驯服电源尖峰:从BUCK/BOOST环路剖析到高di/dt噪声的实战抑制

本文深入探讨了电源系统中高di/dt噪声的产生机制及抑制方法,通过BUCK/BOOST电路的环路分析,揭示了电流路径不连续导致的电压尖峰问题。文章提供了实用的PCB布局技巧和噪声抑制策略,包括最短回路原则、铺铜优化和过孔阵列战术,帮助工程师有效降低EMI噪声,提升电源系统的稳定性。

weixin_29587015的博客 275

Data Structure - Doubly Linked List (Java)

分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net package chimomo.learning.java.datastructure; /** * @author Created by Chimomo */ public class DoublyLinkedList&lt;AnyTyp...

了解➔熟悉➔掌握➔精通 3万+

【爬虫】Python实现爬取淘宝商品信息(超详细)

项目基于Python的第三方库Selenium模拟浏览器运行、PyQuery解析和操作HTML文档,获取淘宝平台中某类商品的详细信息(商品标题、价格、销量、商铺名称、地区、商品详情页链接、商铺链接等),并基于第三方库openpyxl建立、存储于Excel表格中。# 全局变量count = 1 # 写入Excel商品计数# 启动ChromeDriver服务# 关闭自动测试状态显示 // 会导致浏览器报:请停用开发者模式# 把chrome设为selenium驱动的浏览器代理;# 窗口最大化。

qq_46315152的博客 4万+

Data Structure Binary Tree: Convert a given Binary Tree to Doubly Linked List

http://www.geeksforgeeks.org/in-place-convert-a-given-binary-tree-to-doubly-linked-list/ 1 #include <iostream> 2 #include <vector> 3 #include <algorithm> 4 #include <que...

weixin_30909575的博客 99

决策规划算法四:Piecewise Jerk Path Optimizer

一,问题分析 路径规划的本质目的:规划出一条安全(无碰撞),舒适(平滑),符合车辆运动学的轨迹。 如下图所示,决策算法开辟凸空间后,路径规划算法用数值优化的方法搜索出一条最优路径,即将问题转化为二次规划的问题,采用二次规划的求解器进行求解。 二次规划问题的求解顺序: 1,确定优化变量 2,确定目标函数 3,确定约束条件 4,将目标函数和约束条件变形为二次规划的标准形式 5,用二次规划求解器进行求解,获得优化变量的序列,使得目标函数取得最小值。 注:路径的最终表达式为:,..

肥嘟嘟的左卫门 8562

【已验证】基于STM32F407与AD9833的幅频特性测试装置设计与实现

本文详细介绍了基于STM32F407微控制器和AD9833 DDS芯片的低成本幅频特性测试装置设计与实现方法。通过扫频原理,该装置能自动生成正弦波信号,测量滤波器等电路的输出幅度变化,并在LCD屏幕或示波器上绘制幅频特性曲线。文章提供了从硬件选型、CubeMX工程配置、关键驱动代码编写到数据处理与可视化的完整教程,帮助电子爱好者与工程师快速搭建实用的滤波器测试工具。

weixin_35649491的博客 121

sk_buff

All network-related queues and buffers in the kernel use a common data structure, struct sk_buff.This is a large struct containing all the control information required for the packet (datagram, cell, w

HelloCooper的博客 1056

从 0 搭建一个智能问答工单系统:低代码 + 大模型的实战融合方案

企业智能问答工单系统解决方案:通过橙武低代码平台集成DeepSeek大模型,实现自动化工单处理与智能问答。系统能自动匹配知识库、分类工单,支持多渠道接入,显著提升响应效率(答复时间从12小时降至5分钟)。采用MySQL8表结构设计,结合向量数据库实现语义搜索,客服人力需求减少70%。系统支持知识库持续优化,AI答复满意度达88%,助力企业低成本构建智能客服中台。

欢迎来到我的优快云博客!我专注于技术创新和数字化转型,特别是在低代码平台、人工智能和大数据分析领域的探索与应用。通过深入分析各种行业案例,帮助企业加速数字化进程,提升运营效率与创新能力。在这里,您将找到关于低代码平台、AI技术、数据分析与 1549

Doubly linked list

Doubly linked list - Wikipedia, the free encyclopediaDoubly linked list From Wikipedia, the free encyclopedia Jump to: navigation, search This article does not cite any references or source...

weixin_34115824的博客 103

python文件转为可执行文件(.exe)的详细步骤

本文详细介绍了如何从零开始把python文件打包成为可执行文件(.exe)。

m0_67093160的博客 3万+

在 FlexSim 中建 AGV 小车模型时,如果设定“每次充电需要 2 小时才能充满”,应该如何配置 AGV 的充电功能?

🏆本文收录于 《全栈 Bug 调优(实战版)》 专栏。专栏聚焦真实项目中的各类疑难 Bug,从成因剖析 → 排查路径 → 解决方案 → 预防优化全链路拆解,形成一套可复用、可沉淀的实战知识体系。无论你是初入职场的开发者,还是负责复杂项目的资深工程师,都可以在这里构建一套属于自己的「问题诊断与性能调优」方法论,助你稳步进阶、放大技术价值。

**My Coding Family** 883

Linux Kernel Linked List Explained

参见:http://isis.poly.edu/kulesh/stuff/src/klist/Introduction:Linux kernel is mostly written in the C language. Unlike many other languages C does not havea good collection of data structures

王以山的专栏 1703

华为OD机试真题2025双机位B卷 Java&Go 实现【朋友圈个数】

给定一组朋友关系,统计一下该朋友关系网中的朋友圈个数。 朋友圈的定义:一个朋友圈至少由3个朋友组成,且要求同一个朋友圈中的任意两个人都具有直接的朋友关系。 输入描述 输入一个朋友关系列表,如 Fiends =A.B],[A.C],IB,DI,其中的每一个元素 Friendsi表示 Friends[i][0)和 Friends [i][1] 是朋友关系 先输入一个数字 N 代表关系的总数,后面每条关系一行,两个成员以逗号分隔

MISAYAONE的博客 521

[TS] Implement a doubly linked list in TypeScript

In a doubly linked list each node in the list stores the contents of the node and a pointer or reference to the next and the previous nodes in the list. It is one of the simplest way to store a collec...

weixin_30664539的博客 142

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Rust Rosetta Code数据结构:链表、树和图在Rust中的优雅实现

Rust Rosetta Code项目提供了丰富的算法和数据结构实现,本文将深入探讨Rust中链表、树和图的优雅实现方式,帮助开发者掌握Rust内存安全和性能优化的核心优势。 ## 📚 数据结构在Rust中的独特魅力 Rust以其内存安全和零成本抽象著称,在数据结构实现方面展现出独特的优势。通过所有权系统和类型系统,Rust确保了数据结构操作的安全性和高效性,同时保持了代码的清晰可读性。

gitblog_00071的博客 521

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

COBOL语言的双向链表

COBOL(Common Business Oriented Language)是一种面向商业的高级编程语言,主要用于企业级应用开发。它的语法易于理解,特别适合处理大型数据集合。虽然在现代编程中使用得相对较少,但COBOL依然在许多金融、政府和企业系统中占据重要地位。COBOL语言在数据结构的实现上并不如C、C++等语言直观,但通过结合文件操作和数据定义,可以实现复杂的数据结构。首先,我们需要定义一个节点的数据结构。在COBOL中,可以通过对记录(Record)进行定义来实现节点。cobol。

2501_91241404的博客 329

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

Guava Cache Deep Dive

Guava Cache 是 Google Guava 提供的本地缓存实现,基于 JDK7 的 ConcurrentHashMap 分段锁设计。它支持自动加载、容量控制、过期策略和基于引用的回收机制,但已停止更新,Google 推荐使用 Caffeine 替代。 核心架构采用三层设计:LoadingCache → LocalCache → Segment[],每个 Segment 包含哈希表、写入队列、访问队列和最近使用队列。 主要功能: CacheLoader 机制实现自动加载,避免缓存穿透 提供 get(

quwenqian的专栏 441

数据结构——红黑树

快速实现一棵红黑树。提供免序列化版本,能够网络发送,本地存盘等

yuanshenqiang的博客 592

Caffeine Deep Dive

Caffeine: A High-Performance Java Cache Caffeine is a modern Java in-process cache library featuring: W-TinyLFU eviction: Combines LRU and LFU with a window (1% capacity) for burst traffic and adaptive sizing (0.2%-80%) Lock-free concurrency: Uses MPSC buf

quwenqian的专栏 529

InnoDB 内存结构总览:Change Buffer、AHI 与 Log Buffer

本文系统梳理InnoDB内存结构中的ChangeBuffer、Adaptive Hash Index(AHI)与LogBuffer。ChangeBuffer缓存二级索引页不在内存时的变更,减少随机IO,仅在页加载时合并;聚簇索引修改立即执行,因数据本身不可延后。AHI基于高频等值查询自动构建哈希索引,加速定位,仅支持等值操作。LogBuffer为redo log内存缓冲,配合磁盘日志实现崩溃恢复。三者均服务于性能优化,其中ChangeBuffer与AHI共享BufferPool空间,而LogBuffer独立

bksczm的博客 310

信创环境下PageOffice文档控件适配与实践

信创适配做到文档控件这一层,拼的已经不是"有没有国产版本",而是同一个功能在两类终端上是否真的等价。等价的标准很具体:同一次点击能得到同样的结果,同一份公文能得到同样的版式,同一个项目不需要维护两套代码。这背后是三件并不轻松的工作:服务端用一套接口同时支撑两类终端,客户端把两种系统与四种芯片的安装包分发清楚,文档内核层由产品侧跟着 WPS 的版本走。浏览器这一层的压力,则被收进了产品自己的窗口里——升级节奏由产品掌握,不再交给运气。

zi_wu_xian的专栏 336

第三篇 第 6 课

前置:第三篇第 1 课(stdx 引入),第二篇第 1 课(std.regex)。环境:仓颉 SDK 1.2.0。本文所有代码与输出均逐行实测。

weixin_41618057的博客 557

【从零理解 Spring AI · 12】MCP 的两种角色:做客户端还是做服务端

上一篇讲了 MCP 的概念:标准协议、三大角色、M+N 替代 M×N。

nice_lcj520的博客 615

pcl2启动器下载(Minecraft PCL2 启动器 最新版 安装与使用说明)

摘要:PCL2(Plain Craft Launcher 2)是一款面向 Minecraft 的第三方启动器,支持正式版与快照版本管理、模组与整合包安装、Java 运行时自动匹配,绿色免安装、双击即可运行。适合在 Windows 上玩单机整合包、需要多版本共存或离线启动的用户使用

2611_96675819的博客 226

spring boot 4集成SQLLite,及其SQLLite的建库

spring boot 4集成SQLLite,及其SQLLite的建库

weixin_41463944的博客 237

Java 集合容器高频面试题全解:HashMap 树化阈值、1.7 死循环与 ConcurrentHashMap 演进(2026 招聘 JD 真题复盘)

HashMap 树化阈值 8 的泊松分布依据、退化阈值 6 的防抖设计、JDK 1.7 头插成环死循环的排查与修复、1.8 尾插后为何仍线程不安全、ConcurrentHashMap 放弃分段锁的原因与 ForwardingNode 协作扩容、computeIfAbsent 死锁陷阱、大集合找重复的场景题选型,附三层追问链自测。题目来源为 38 期公开招聘 JD 样本与字节、拼多多、建行、美团、快手公开面经。

蒙眼过河 427
上一篇: CS250 Profiling an Assembly Program
下一篇: CA3 Problem Solving
wx____codinghelp
博客等级 码龄2年 771粉丝 115原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值