Code on 孤筝の温暖小家

MicroPython Function Library

lvbowen040427@163.com (孤筝) — Thu, 15 Feb 2024 11:44:33 +0800

MicroPython Function Library

Author: 孤筝(lvbowen040427@163.com)

Pin Class

`machine.Pin(id, mode=None, pull=None, value)`

Pin object constructor

id: GPIO number (0-29 for Pico)
mode: Pin mode, options: None, Pin.IN(0), Pin.OUT(1), Pin.OPEN_DRAIN(2)
pull: Internal pull-up/down resistor (only valid in input mode), options: None, Pin.PULL_UP(1), Pin.DOWN(2)
value: Port value in output or open-drain mode (0 for low, 1 for high)

`Pin.init(mode=None, pull=None)`

Reinitialize GPIO port

`Pin.value([x])`

Returns GPIO port value when no parameter is given
Writes value to GPIO port when parameter 0/1 is provided

`Pin.toggle()`

Toggles port state in output or open-drain mode

Example: LED blinking

from machine import Pin
import time
led = Pin(25, Pin.OUT)
while True:
    led.toggle()
    time.sleep(1)  # Toggle LED every second

`Pin.irq(handler=None, trigger=(Pin.IRQ_FALLING|PIN.IRQ_RISING))`

External interrupt function

handler: Callback function when interrupt triggers
trigger: Interrupt trigger condition (edge/level triggered)

Other Functions

For output/open-drain mode:

Pin.low(), Pin.off(): Set port to low voltage
Pin.high(), Pin.on(): Set port to high voltage

Example: LED Control

from machine import Pin
import utime
# Button on GPIO15, input mode with pull-up
button_num = 15
button = Pin(button_num, Pin.IN, Pin.PULL_UP)
# Onboard LED on GP25, external LED on GP16
led1_num = 25
led2_num = 16
led1 = Pin(led1_num, Pin.OUT)
led2 = Pin(led2_num, Pin.OUT)

while True:
    led2.off()  # Turn off external LED
    if button.value() == 0:  # Check if button pressed (0 when pressed)
        utime.sleep(0.01)
        if button.value() == 0:  # Software debounce
            led1.toggle()  # Toggle onboard LED
            led2.on()  # Turn on external LED (GP16 high)
            print("The button is pressed.")
            while button.value() == 0:
                # Wait while button remains pressed (external LED stays on)
                utime.sleep(0.01)

PWM Class

`machine.PWM(pin)`

Reinitialize specified GPIO as PWM output

pin: Pin class object

`PWM.deinit()`

Deinitialize PWM, stop PWM output

`PWM.freq([value])`

Set PWM frequency (in Hz), automatically calculates divider and TOP register values

`PWM.duty_u16([value])`

Set duty cycle

value: Duty cycle ratio [0,65536], calculates corresponding value for CC register

`PWM.duty_ns([value])`

Set high-level duration per cycle in nanoseconds

Example: Breathing LED

from machine import Pin, PWM
import time

led = PWM(Pin(25))  # Initialize onboard LED as PWM
led.freq(1000)  # Set frequency
led_duty = 0  # Initial value
led_direction = 1  # Step size

while True:
    led_duty += led_direction  # Increase/decrease duty cycle
    if led_duty >= 100:  # Max
        led_duty = 100
        led_direction = -1
    elif led_duty <= 0:  # Min
        led_duty = 0
        led_direction = 1
        
    led.duty_u16(int(led_duty * 655.36))  # Convert ratio to value
    
    if led_duty % 5 == 0:
        print(led_duty)  # For monitoring
        
    time.sleep(0.01)
    # 2-second cycle

ADC Class

`machine.ADC(id)`

Initialize as ADC object

id: Can be GPIO or ADC channel (GPIO must support ADC when using Pin object)
Channels 0-3: Pico GPIO 26-29
Channel 4: Internal temperature sensor

`ADC.read_u16()`

Read ADC channel value [0,65525]

Published on 2024-02-15 at 孤筝の温暖小家, last modified on 2024-02-15

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!

Data Structure Lab Report 8 - Critical Path

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 15:00:26 +0800

Data Structure Lab Report 8 - Critical Path

Author: 孤筝(lvbowen040427@163.com)

a. Problem Analysis

In the Critical Path Method (CPM), we need to identify the critical path in a project, which is the sequence of activities that determines the project’s total duration. To solve this problem, we first construct a data structure Activity to represent project activities and design a Project class to handle project calculations and output.

The calculation of the critical path primarily relies on two key steps:

Earliest Start Time (ES) Calculation: Starting from the initial event, we use topological sorting and dynamic programming to compute the earliest start time for each activity.
Latest Start Time (LS) Calculation: Starting from the final event, we perform a reverse traversal of the topological order and use dynamic programming to compute the latest start time for each activity.

By comparing the earliest and latest start times, we can identify the activities on the critical path, which are crucial for determining the project’s total duration.

b. Algorithm Design

1. Calculating Earliest Start Time

We use topological sorting and dynamic programming to compute the earliest start time. First, we identify all initial events (activities with no predecessors) and then traverse the graph starting from these events, updating the earliest start time for each activity.

// Calculate earliest start time
void calculateEarliestStart() {
    queue<int> q;
    for (const Activity& activity : activities) { // Traverse topological order
        if (activity.next.empty()) { // If a node's adjacency list is empty (i.e., it's an initial event)
            q.push(activity.id); // Enqueue
            earliestStart[activity.id] = 0; // Set earliest start time to 0
        }
    }

    while (!q.empty()) { // While queue is not empty
        int currentId = q.front(); // Dequeue the highest-priority event (currentId)
        q.pop();

        for (int nextId : activities[currentId].next) { // Traverse currentId's adjacency list
            earliestStart[nextId] = max(earliestStart[nextId], earliestStart[currentId] + activities[currentId].duration);
            // nextId's earliest start time = max{current recorded earliest start time, predecessor currentId's earliest start time + currentId's duration}
            q.push(nextId);
        }
    }
}

2. Calculating Latest Start Time

By traversing the topological order in reverse, we compute the latest start time. Starting from the final event, we iteratively update the latest start time for each activity.

// Calculate latest start time
void calculateLatestStart() {
    latestStart = earliestStart; // Initialize latest start time as earliest start time

    for (int i = activities.size() - 1; i >= 0; --i) { // Reverse traversal starting from the last event (i)
        for (int nextId : activities[i].next) {
            latestStart[i] = min(latestStart[i], latestStart[nextId] - activities[i].duration);
            // Current event's latest start time = min{recorded latest start time, next event nextId's latest start time - current event i's duration}
        }
    }
}

c. Data Structure Design

We use two key data structures:

Activity Struct: Represents a project activity, including the activity ID, duration, and subsequent activities.

// Struct representing a project activity
struct Activity {
    int id;      // Activity ID
    int duration; // Duration
    vector<int> next; // Subsequent activities
};

Project Class: Manages the project, including methods for adding activities, calculating earliest and latest start times, printing the critical path, and displaying time information.

d. Debugging Process

During debugging, we focused on the following aspects:

Data Structure Correctness: Ensuring the Activity struct and Project class accurately represent project and activity relationships.
Algorithm Correctness: Verifying the correctness of the algorithms for calculating earliest and latest start times.
Output Accuracy: Checking if the printed critical path and time information meet expectations.

e. Output Results

After running the program, we obtained the following output:

Critical Path: 0 1 2 3 4 5 
Activity 0: ES=0, LS=0
Activity 1: ES=2, LS=2
Activity 2: ES=6, LS=6
Activity 3: ES=9, LS=9
Activity 4: ES=14, LS=14
Activity 5: ES=16, LS=16

From the results, we can see that the critical path consists of activities 0, 1, 2, 3, 4, and 5. The earliest and latest start times for each activity are correctly calculated, confirming the effectiveness of our algorithm and data structure design.

f. Source Code

#include 
#include 
#include 
#include 

using namespace std;

// Struct representing a project activity
struct Activity {
    int id;      // Activity ID
    int duration; // Duration
    vector<int> next; // Subsequent activities
};

class Project {
private:
    vector<Activity> activities; // Vector storing project activities
    vector<int> earliestStart;   // Earliest start time
    vector<int> latestStart;     // Latest start time

public:
    // Add an activity
    void addActivity(int id, int duration, const vector<int>& next) {
        activities.push_back({id, duration, next});
    }

    // Calculate earliest start time
    void calculateEarliestStart() {
        queue<int> q;
        for (const Activity& activity : activities) { // Traverse topological order
            if (activity.next.empty()) { // If a node's adjacency list is empty (i.e., it's an initial event)
                q.push(activity.id); // Enqueue
                earliestStart[activity.id] = 0; // Set earliest start time to 0
            }
        }

        while (!q.empty()) { // While queue is not empty
            int currentId = q.front(); // Dequeue the highest-priority event (currentId)
            q.pop();

            for (int nextId : activities[currentId].next) { // Traverse currentId's adjacency list
                earliestStart[nextId] = max(earliestStart[nextId], earliestStart[currentId] + activities[currentId].duration);
                // nextId's earliest start time = max{current recorded earliest start time, predecessor currentId's earliest start time + currentId's duration}
                q.push(nextId);
            }
        }
    }

    // Calculate latest start time
    void calculateLatestStart() {
        latestStart = earliestStart; // Initialize latest start time as earliest start time

        for (int i = activities.size() - 1; i >= 0; --i) { // Reverse traversal starting from the last event (i)
            for (int nextId : activities[i].next) {
                latestStart[i] = min(latestStart[i], latestStart[nextId] - activities[i].duration);
                // Current event's latest start time = min{recorded latest start time, next event nextId's latest start time - current event i's duration}
            }
        }
    }

    // Print the critical path
    void printCriticalPath() {
        cout << "Critical Path: ";
        for (const Activity& activity : activities) { // Traverse topological order
            if (earliestStart[activity.id] == latestStart[activity.id]) { // Critical path activities have ES == LS
                cout << activity.id << " ";
            }
        }
        cout << endl;
    }

    // Print earliest and latest start times
    void printTimeInfo() {
        for (const Activity& activity : activities) {
            cout << "Activity " << activity.id << ": ES=" << earliestStart[activity.id]
                 << ", LS=" << latestStart[activity.id] << endl;
        }
    }

    // Constructor for initialization
    Project(int numActivities) : earliestStart(numActivities), latestStart(numActivities) {}

};

int main() {
    Project project(6); // Assume there are 6 activities

    // Add activities in the format: activity ID, duration, subsequent activity IDs
    project.addActivity(0, 2, {1});
    project.addActivity(1, 4, {2});
    project.addActivity(2, 3, {3});
    project.addActivity(3, 5, {4});
    project.addActivity(4, 2, {5});
    project.addActivity(5, 1, {});

    // Calculate earliest and latest start times
    project.calculateEarliestStart();
    project.calculateLatestStart();

    // Print critical path and time information
    project.printCriticalPath();
    project.printTimeInfo();

    return 0;
}

Published on 2023-12-12 at 孤筝の温暖小家, last modified on 2023-12-12

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!

Data Structure Lab Report 7 – Kruskal's Algorithm and the Minimum Spanning Tree Problem, Dijkstra's Algorithm and the Shortest Path Problem in Weighted Graphs

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 14:58:44 +0800

Data Structure Lab Report 7 – Kruskal's Algorithm and the Minimum Spanning Tree Problem, Dijkstra's Algorithm and the Shortest Path Problem in Weighted Graphs

Author: 孤筝(lvbowen040427@163.com)

Kruskal’s Algorithm for Generating Minimum Spanning Trees

a Problem Analysis

We need to use Kruskal’s algorithm to find the minimum spanning tree (MST) for a graph with 10 nodes and 20 edges. Kruskal’s algorithm is based on a greedy approach, constructing the MST by iteratively selecting edges with the smallest weights while ensuring no cycles are formed.

b Algorithm Design

Key Steps of Kruskal’s Algorithm:

Edge Sorting:

All edges are sorted in ascending order of their weights.

sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) {
    return a.weight < b.weight;
});

The sort function sorts the elements in a container based on a specified comparison rule. Here, it sorts edges in ascending order of their weights, allowing Kruskal’s algorithm to select edges with the smallest weights first. 1. edges.begin() and edges.end(): These parameters define the range of elements to be sorted. begin() returns an iterator to the first element, and end() returns an iterator to the position after the last element. 2. [](const Edge& a, const Edge& b) { return a.weight < b.weight; }: This is a lambda expression that defines the comparison rule. It compares two edges a and b based on their weights and returns true if a.weight is less than b.weight, ensuring ascending order. 3. const Edge& a and const Edge& b are the parameters of the lambda function, representing the two edges being compared. 4. return a.weight < b.weight; ensures that edges are sorted in ascending order of their weights.

Union-Find Initialization:

Initialize the Union-Find (Disjoint Set Union, DSU) data structure, where each node is initially its own parent.

The Union-Find data structure is used to manage sets of elements, supporting two primary operations: Find (to determine the root of an element) and Union (to merge two sets).
Basic Operations:
1. Find: Determines the root of an element, which identifies the set it belongs to.
2. Union: Merges two sets by connecting their roots.
Implementation Details:
- Typically implemented using arrays where each element’s value represents its parent. Initially, each element is its own parent.
Optimizations:
- Path Compression: During the Find operation, the path from the element to its root is flattened, improving future Find operations.
- Union by Rank: During the Union operation, the smaller tree (in terms of depth) is attached to the root of the larger tree to keep the tree balanced and operations efficient.

Edge Traversal:

Traverse the sorted edges, adding each edge to the MST if it does not form a cycle.

Implementation:

// Kruskal's Algorithm
vector<Edge> kruskal(vector<Edge>& edges, int numNodes) { // Input: edge list and number of nodes
    // Sort edges by weight in ascending order
    sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) 
// Parameters: start iterator, end iterator, lambda expression (comparison function)
{
        return a.weight < b.weight; // Comparison rule: sort edges by weight in ascending order
    });

    // Initialize Union-Find
    UnionFind uf(numNodes); // UnionFind(size)

    // Store edges of the MST
    vector<Edge> result;

    // Traverse sorted edges
    for (const Edge& edge : edges) {
        // Check if adding this edge forms a cycle
        if (uf.find(edge.start) != uf.find(edge.end)) { // If the start and end nodes are in different sets (subtrees)
            // No cycle formed, add edge to MST
            result.push_back(edge);
            uf.unite(edge.start, edge.end); // Merge the two subtrees (mark as the same set) to prevent cycles
        }
    }

    return result;
}

c Data Structure Design

1. Edge Struct:

// Edge struct
struct Edge {
    int start, end, weight; // Start node, end node, and weight of the edge
};

The Edge struct represents an edge in the graph, containing the start node, end node, and weight.

2. UnionFind Class:

// Union-Find implementation
class UnionFind {
public:
    UnionFind(int size) : parent(size), rank(size, 0) {
// `parent` stores the root of each node, initially set to itself; `rank` approximates tree depth, initialized to 0
        for (int i = 0; i < size; ++i) {
            parent[i] = i; // Root initially set to itself
        }
    }

    int find(int x) { // Find the root of a node
        if (x != parent[x]) { // If `x` is not its own parent (has an ancestor)
            parent[x] = find(parent[x]); // Path compression: set parent to root
        }
        return parent[x]; // Return the root
    }

    void unite(int x, int y) { // Merge two subtrees
        int rootX = find(x); // Root of `x`
        int rootY = find(y); // Root of `y`

        if (rootX != rootY) { // If `x` and `y` are in different sets (subtrees)
            if (rank[rootX] < rank[rootY]) {
                // If `x`'s subtree is shallower than `y`'s
                parent[rootX] = rootY;
                // Attach `x`'s subtree to `y`'s to avoid increasing depth
            } else if (rank[rootX] > rank[rootY]) {
                parent[rootY] = rootX;
            } else { // If subtrees have the same depth
                parent[rootX] = rootY; // Attach `x`'s subtree to `y`'s
                rank[rootY]++; // Increment depth after merge
            }
        }
    }

private:
    vector<int> parent;
    vector<int> rank;
};

The UnionFind class implements the Union-Find data structure for cycle detection. The find function locates the root of a node, and the unite function merges two sets.
In the constructor, the rank array is initialized to 0, representing the approximate depth of each tree. Initially, each node is its own tree with depth 0.
During unite, the rank array ensures that the smaller tree is attached to the larger one to maintain balance and efficiency.

d Debugging Process

During debugging, intermediate outputs (e.g., sorted edges, MST construction steps, and Union-Find states) were examined to verify the algorithm’s correctness. Edge cases, such as disconnected graphs, were also tested.

e Output

Graph:
0 - 1 : 4
0 - 2 : 1
1 - 3 : 2
1 - 4 : 8
2 - 5 : 3
2 - 6 : 7
3 - 7 : 5
3 - 8 : 1
4 - 9 : 6
5 - 6 : 2
6 - 8 : 6
7 - 9 : 3
8 - 9 : 9
1 - 2 : 2
3 - 4 : 3
5 - 7 : 4
6 - 9 : 7
0 - 3 : 6
2 - 8 : 5
4 - 5 : 4
Edges in the minimum spanning tree:
0 - 2 : 1
3 - 8 : 1
1 - 3 : 2
1 - 2 : 2
5 - 6 : 2
2 - 5 : 3
3 - 4 : 3
7 - 9 : 3
5 - 7 : 4

f Source Code

#include 
#include 
#include  // For `sort`

using namespace std;

// Edge struct
struct Edge {
    int start, end, weight; // Start node, end node, and weight of the edge
};

// Union-Find implementation
class UnionFind {
public:
    UnionFind(int size) : parent(size), rank(size, 0) {
// `parent` stores the root of each node, initially set to itself; `rank` approximates tree depth, initialized to 0
        for (int i = 0; i < size; ++i) {
            parent[i] = i; // Root initially set to itself
        }
    }

    int find(int x) { // Find the root of a node
        if (x != parent[x]) { // If `x` is not its own parent (has an ancestor)
            parent[x] = find(parent[x]); // Path compression: set parent to root
        }
        return parent[x]; // Return the root
    }

    void unite(int x, int y) { // Merge two subtrees
        int rootX = find(x); // Root of `x`
        int rootY = find(y); // Root of `y`

        if (rootX != rootY) { // If `x` and `y` are in different sets (subtrees)
            if (rank[rootX] < rank[rootY]) {
                // If `x`'s subtree is shallower than `y`'s
                parent[rootX] = rootY;
                // Attach `x`'s subtree to `y`'s to avoid increasing depth
            } else if (rank[rootX] > rank[rootY]) {
                parent[rootY] = rootX;
            } else { // If subtrees have the same depth
                parent[rootX] = rootY; // Attach `x`'s subtree to `y`'s
                rank[rootY]++; // Increment depth after merge
            }
        }
    }

private:
    vector<int> parent;
    vector<int> rank;
};

// Kruskal's Algorithm
vector<Edge> kruskal(vector<Edge>& edges, int numNodes) { // Input: edge list and number of nodes
    // Sort edges by weight in ascending order
    sort(edges.begin(), edges.end(), [](const Edge& a, const Edge& b) 
// Parameters: start iterator, end iterator, lambda expression (comparison function)
{
        return a.weight < b.weight; // Comparison rule: sort edges by weight in ascending order
    });

    // Initialize Union-Find
    UnionFind uf(numNodes); // UnionFind(size)

    // Store edges of the MST
    vector<Edge> result;

    // Traverse sorted edges
    for (const Edge& edge : edges) {
        // Check if adding this edge forms a cycle
        if (uf.find(edge.start) != uf.find(edge.end)) { // If the start and end nodes are in different sets (subtrees)
            // No cycle formed, add edge to MST
            result.push_back(edge);
            uf.unite(edge.start, edge.end); // Merge the two subtrees (mark as the same set) to prevent cycles
        }
    }

    return result;
}

int main() {
    // Create a graph with 10 nodes
    int numNodes = 10;

    // Manually define edges with start, end, and weight
    vector<Edge> edges = {
        {0, 1, 4},
        {0, 2, 1},
        {1, 3, 2},
        {1, 4, 8},
        {2, 5, 3},
        {2, 6, 7},
        {3, 7, 5},
        {3, 8, 1},
        {4, 9, 6},
        {5, 6, 2},
        {6, 8, 6},
        {7, 9, 3},
        {8, 9, 9},
        {1, 2, 2},
        {3, 4, 3},
        {5, 7, 4},
        {6, 9, 7},
        {0, 3, 6},
        {2, 8, 5},
        {4, 5, 4}
    };
    // Output the graph
    cout << "Graph:" << endl;
    for (const Edge& edge : edges) {
        cout << edge.start << " - " << edge.end << " : " << edge.weight << endl;
    }
    // Run Kruskal's algorithm
    vector<Edge> minSpanningTree = kruskal(edges, numNodes);

    // Output edges in the MST
    cout << "Edges in the minimum spanning tree:" << endl;
    for (const Edge& edge : minSpanningTree) {
        cout << edge.start << " - " << edge.end << " : " << edge.weight << endl;
    }

    return 0;
}

Dijkstra’s Algorithm for Solving Shortest Path in Weighted Graphs

a Problem Analysis

The code implements Dijkstra’s algorithm to solve the single-source shortest path problem in a weighted graph. Given an adjacency matrix representation of the graph, the algorithm computes the shortest distances from a specified start node to all other nodes.

b Algorithm Design

1. Initialization

int n = graph.size();
distances.resize(n, INF);

Analysis: The number of nodes n is determined from the graph’s size. The distances array is initialized with INF (infinity), representing initially unknown distances.

2. Priority Queue Setup

priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
distances[start] = 0;
pq.push({0, start});

Analysis: A priority queue pq is created to manage nodes by their current shortest distance. The start node’s distance is set to 0, and it is added to the queue.

3. Main Loop

while (!pq.empty()) {
    int u = pq.top().second;
    pq.pop();

    for (int v = 0; v < n; ++v) {
        if (graph[u][v] != 0 && distances[v] > distances[u] + graph[u][v]) {
            distances[v] = distances[u] + graph[u][v];
            pq.push({distances[v], v});
        }
    }
}

Analysis: The loop extracts the node u with the smallest current distance. For each neighbor v of u, if a shorter path is found via u, the distance is updated, and v is added to the queue.

4. Termination

Analysis: The algorithm terminates when the queue is empty, having processed all nodes and finalized their shortest distances.

c Data Structure Design

1. Graph (Adjacency Matrix)

typedef vector<vector<int>> Graph;

Analysis: The Graph is represented as a 2D vector where graph[u][v] holds the weight of the edge from node u to v. A weight of 0 indicates no edge.

2. Distances Array

vector<int> distances;

Analysis: The distances array stores the shortest known distances from the start node to each node, initialized to INF and updated during the algorithm’s execution.

3. Priority Queue

priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;

Analysis: The priority queue pq holds pairs of distances and nodes, ordered by distance. The greater comparator ensures the smallest distance is always processed first.

d Debugging Process

Intermediate outputs (e.g., queue states, distance updates) were logged to verify correctness.
Edge cases (e.g., no edges, negative weights) were tested to ensure robustness.
Multiple test cases confirmed the algorithm’s accuracy and efficiency.

e Output

The final output shows the shortest distances from the start node to all other nodes, matching expectations.

Distance from node 0 to 0: 0
Distance from node 0 to 1: 2
Distance from node 0 to 2: 3
Distance from node 0 to 3: 9
Distance from node 0 to 4: 6

f Source Code

#include 
#include 
#include  // For priority_queue
#include  // For INT_MAX

using namespace std;

#define INF INT_MAX

// Graph representation using adjacency matrix
typedef vector<vector<int>> Graph;
// 2D vector where graph[u][v] represents the weight of the edge from node `u` to `v`

// Dijkstra's Algorithm
void dijkstra(const Graph& graph, int start, vector<int>& distances) {
// Input: graph, start node, and distances array
    int n = graph.size(); // Number of nodes
    distances.resize(n, INF);  // Initialize distances to infinity

    // Priority queue to manage nodes by their current shortest distance
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
// Pairs are {distance, node}, stored in a vector, ordered by distance (smallest first)

    distances[start] = 0;  // Distance from start to itself is 0
    pq.push({0, start});   // Add start node to the queue

    while (!pq.empty()) {
        int u = pq.top().second;  // Extract the node with the smallest current distance
        pq.pop();

        for (int v = 0; v < n; v++) {
            if (graph[u][v] != 0 && distances[v] > distances[u] + graph[u][v]) {
                // If a shorter path to `v` is found via `u`, update the distance
                distances[v] = distances[u] + graph[u][v];
                pq.push({distances[v], v});  // Add the updated distance and node to the queue
            }
        }
    }
}

int main() {
    // Example graph represented as an adjacency matrix
    Graph graph = {
        {0, 2, 4, 0, 0},
        {0, 0, 1, 7, 0},
        {0, 0, 0, 0, 3},
        {0, 0, 0, 0, 1},
        {0, 0, 0, 0,

Published on 2023-12-12 at 孤筝の温暖小家, last modified on 2023-12-12

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!

Data Structure Lab Report 6 — Threading Binary Trees with Preorder and Postorder Traversals, Adjacency Matrix and Adjacency List Storage for Graphs

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 14:56:33 +0800

Data Structure Lab Report 6 — Threading Binary Trees with Preorder and Postorder Traversals, Adjacency Matrix and Adjacency List Storage for Graphs

Author: 孤筝(lvbowen040427@163.com)

Threading a Binary Tree in Pre-order and Post-order

a. Problem Analysis

We need to implement pre-order threading of a binary tree. Threading is a method that converts null pointer fields in a binary linked list into pointers pointing to the predecessor or successor node of the current node in a specific traversal order (pre-order, in-order, or post-order). This allows us to start traversal from any node in the specified order, not just the root node.

b. Algorithm Design

Our algorithm first creates a binary tree and then threads it. The threading process is implemented via a recursive function that traverses each node and checks whether its left or right child exists. If a child is absent, the corresponding left/right pointer is set to point to the predecessor/successor node. Finally, an in-order traversal is performed to verify the success of the threading.

Here is the threading code snippet:

// Function to create threads  
void createThread(Node* p) {  
    if (p == NULL) { // If the node is null, return directly  
        return;  
    }  
    createThread(p->left); // Recursively process the left subtree  
    if (!p->left) { // If the left child is null, set the left pointer to the predecessor and mark the left thread flag as 1  
        p->left = pre;  
        p->ltag = 1;  
    }  
    if (pre && !pre->right) { // If the predecessor's right child is null, set its right pointer to the current node and mark the right thread flag as 1  
        pre->right = p;  
        pre->rtag = 1;  
    }  
    pre = p; // Update the predecessor node  
    createThread(p->right); // Recursively process the right subtree  
}

c. Data Structure Design

We use a struct to represent a binary tree node, which includes a data field and two pointer fields pointing to the left and right children. Additionally, we add two flag fields to indicate whether the left and right pointers have been threaded.

Here is the data structure code snippet:

// Struct definition for a binary tree node  
struct Node {  
    int data; // Node data  
    Node* left; // Left child  
    Node* right; // Right child  
    int ltag, rtag; // Left and right thread flags  
};

d. Debugging Process

First, we create a binary tree and thread it. Then, we perform an in-order traversal to check whether the threading is successful. If the traversal result matches the expected output, we consider the threading successful.

Here is the debugging code snippet:

int main() {  
    // Create a binary tree  
    Node n1, n2, n3, n4, n5;  
    n1 = {1, &n2, &n3, 0, 0};  
    n2 = {2, &n4, &n5, 0, 0};  
    n3 = {3, NULL, NULL, 0, 0};  
    n4 = {4, NULL, NULL, 0, 0};  
    n5 = {5, NULL, NULL, 0, 0};  
    // Thread the binary tree  
    createThread(&n1);  
    // Perform in-order traversal of the threaded binary tree  
    inOrder(&n1);  
    return 0;  
}

e. Output Result

The program’s output should be the in-order traversal result of the binary tree. In our example, the expected output is 4 2 5 1 3. The in-order traversal of the created binary tree should yield this sequence.

f. Source Code

#include  
using namespace std;  

// Struct definition for a binary tree node  
struct Node {  
    int data; // Node data  
    Node* left; // Left child  
    Node* right; // Right child  
    int ltag, rtag; // Left and right thread flags  
};  

// Global variable pre to store the predecessor node  
Node* pre = NULL;  

// Function to create threads  
void createThread(Node* p) {  
    if (p == NULL) { // If the node is null, return directly  
        return;  
    }  
    createThread(p->left); // Recursively process the left subtree  
    if (!p->left) { // If the left child is null, set the left pointer to the predecessor and mark the left thread flag as 1  
        p->left = pre;  
        p->ltag = 1;  
    }  
    if (pre && !pre->right) { // If the predecessor's right child is null, set its right pointer to the current node and mark the right thread flag as 1  
        pre->right = p;  
        pre->rtag = 1;  
    }  
    pre = p; // Update the predecessor node  
    createThread(p->right); // Recursively process the right subtree  
}  

// Function for in-order traversal of a threaded binary tree  
void inOrder(Node* p) {  
    while (p) {  
        while (!p->ltag) { // Find the leftmost node  
            p = p->left;  
        }  
        cout << p->data << " "; // Output node data  
        while (p->rtag) { // If the right pointer is a thread, jump directly to the successor node  
            p = p->right;  
            cout << p->data << " ";  
        }  
        p = p->right; // Process the right subtree  
    }  
}  

int main() {  
    // Create a binary tree  
    Node n1, n2, n3, n4, n5;  
    n1 = {1, &n2, &n3, 0, 0};  
    n2 = {2, &n4, &n5, 0, 0};  
    n3 = {3, NULL, NULL, 0, 0};  
    n4 = {4, NULL, NULL, 0, 0};  
    n5 = {5, NULL, NULL, 0, 0};  
    // Thread the binary tree  
    createThread(&n1);  
    // Perform in-order traversal of the threaded binary tree  
    inOrder(&n1);  
    return 0;  
}

Adjacency Matrix and Adjacency List Storage for Graphs

a. Problem Analysis

Our goal is to implement adjacency matrix and adjacency list storage for graphs in C++. This involves two different data structures: arrays (for adjacency matrices) and linked lists (for adjacency lists).

b. Algorithm Design

Adjacency Matrix

We use a 2D array adj[MAX][MAX] to store the adjacency matrix of the graph. Each element adj[i][j] indicates whether an edge exists from node i to node j. If it exists, adj[i][j] = 1; otherwise, adj[i][j] = 0.

for (i = 1; i <= max_edges; i++) {  
    cin >> origin >> destin;  
    if ((origin == -1) && (destin == -1))  
        break;  
    if (origin >= n || destin >= n || origin < 0 || destin < 0) {  
        i--;  
    } else {  
        adj[origin][destin] = 1;  
    }  
}

Adjacency List

We use an array of linked lists list *adj to store the adjacency list of the graph. Each element adj[i] is a linked list containing all nodes adjacent to node i.

void Graph::addEdge(int v, int w) {  
    adj[v].push_back(w);  
}

c. Data Structure Design

Adjacency Matrix

We use a 2D array int adj[MAX][MAX] to store the adjacency matrix. MAX is the maximum number of nodes in the graph.

Adjacency List

We use an array of linked lists list *adj to store the adjacency list. V is the number of nodes in the graph.

d. Debugging Process

During implementation and debugging, we first ensured that the input edges are valid. If an edge is invalid (e.g., referencing a non-existent node), we prompt the user to re-enter it.

When adding edges to the adjacency matrix or adjacency list, we included error checks to prevent out-of-bounds array or list accesses.

e. Output Result

Finally, we can print the adjacency matrix or adjacency list to verify the correctness of our code. For the adjacency list, we traverse each node’s linked list and print all adjacent nodes.

void Graph::printGraph() {  
    for (int v = 0; v < V; v++) {  
        cout << "\n Adjacency list of vertex " << v << "\n head ";  
        for (auto x : adj[v])  
            cout << "-> " << x;  
        printf("\n");  
    }  
}

f. Source Code

Adjacency Matrix Storage

#include  
#define MAX 20  
using namespace std;  

int adj[MAX][MAX];  
int n;  

void create_graph() {  
    int i, max_edges, origin, destin;  

    cout << "Enter number of nodes : ";  
    cin >> n;  
    max_edges = n * (n - 1);  

    for (i = 1; i <= max_edges; i++) {  
        cout << "Enter edge " << i << " (-1 -1 to quit) : ";  
        cin >> origin >> destin;  

        if ((origin == -1) && (destin == -1))  
            break;  

        if (origin >= n || destin >= n || origin < 0 || destin < 0) {  
            cout << "Invalid edge!\n";  
            i--;  
        } else {  
            adj[origin][destin] = 1;  
        }  
    }  
}

Adjacency List Storage

#include  
#include  
using namespace std;  

class Graph {  
    int V;  
    list<int> *adj;  

public:  
    Graph(int V);  

    void addEdge(int v, int w);  

    void printGraph();  
};  

Graph::Graph(int V) {  
    this->V = V;  
    adj = new list<int>[V];  
}  

void Graph::addEdge(int v, int w) {  
    adj[v].push_back(w);  
}  

void Graph::printGraph() {  
    for (int v = 0; v < V; v++) {  
        cout << "\n Adjacency list of vertex " << v << "\n head ";  
        for (auto x : adj[v])  
            cout << "-> " << x;  
        printf("\n");  
    }  
}

Published on 2023-12-12 at 孤筝の温暖小家, last modified on 2023-12-12

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!

Data Structure Lab Report 5 - Huffman Tree Encoding and Decoding, Construction and Node Deletion of Binary Search Tree

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 14:54:04 +0800

Data Structure Lab Report 5 - Huffman Tree Encoding and Decoding, Construction and Node Deletion of Binary Search Tree

Author: 孤筝(lvbowen040427@163.com)

Implementing Huffman Tree Encoding and Decoding

a. Problem Analysis

Objective:

Implement Huffman tree encoding and decoding.

Key Questions:

Is the Huffman tree construction process correct?
Are the Huffman codes generated accurately?
Does the encoding and decoding process function correctly?
Can the algorithm handle characters with identical frequencies?

b. Algorithm Design

1. Constructing the Huffman Tree:

Calculate character frequencies from input text.
Build the Huffman tree using a priority queue (min-heap).

Input: Character frequency map frequencies.
Output: Root node root of the Huffman tree.

HuffmanNode* buildHuffmanTree(map<char, int>& frequencies) {
    // 1. Create a priority queue (min-heap) for tree construction
    priority_queue<HuffmanNode*, vector<HuffmanNode*>, CompareNodes> minHeap;

    // 2. Create leaf nodes and add to the min-heap
    for (auto& entry : frequencies) {
        HuffmanNode* node = new HuffmanNode(entry.first, entry.second);
        minHeap.push(node);
    }

    // 3. Build the Huffman tree
    while (minHeap.size() > 1) {
        HuffmanNode* left = minHeap.top();
        minHeap.pop();

        HuffmanNode* right = minHeap.top();
        minHeap.pop();

        HuffmanNode* internalNode = new HuffmanNode('$', left->frequency + right->frequency);
        internalNode->left = left;
        internalNode->right = right;

        minHeap.push(internalNode);
    }

    // 4. Return the root node
    return minHeap.top();
}

2. Generating Huffman Codes:

Traverse the Huffman tree recursively to generate codes for each character.

Input: Root node root, empty string code, empty map huffmanCodes.
Output: Map huffmanCodes containing character-to-code mappings.

void generateHuffmanCodes(HuffmanNode* root, string code, map<char, string>& huffmanCodes) {
    // 1. Base case: leaf node
    if (root == nullptr) return;

    // 2. Store code for leaf nodes
    if (root->data != '$') {
        huffmanCodes[root->data] = code;
    }

    // 3. Recursively generate left and right subtree codes
    generateHuffmanCodes(root->left, code + "0", huffmanCodes);
    generateHuffmanCodes(root->right, code + "1", huffmanCodes);
}

3. Huffman Encoding:

Replace each character in the input text with its corresponding Huffman code.

Input: Original text text, Huffman code map huffmanCodes.
Output: Encoded text encodedText.

string huffmanEncode(string text, map<char, string>& huffmanCodes) {
    string encodedText = "";
    for (char c : text) {
        encodedText += huffmanCodes[c];
    }
    return encodedText;
}

4. Huffman Decoding:

Traverse the encoded text using the Huffman tree to reconstruct the original text.

Input: Encoded text encodedText, Huffman tree root root.
Output: Decoded text decodedText.

string huffmanDecode(string encodedText, HuffmanNode* root) {
    string decodedText = "";
    HuffmanNode* current = root;

    for (char bit : encodedText) {
        current = (bit == '0') ? current->left : current->right;

        if (current->data != '$') {
            decodedText += current->data;
            current = root;
        }
    }
    return decodedText;
}

c. Data Structure Design

HuffmanNode Struct:
- Stores character (data), frequency, and left/right child pointers.
CompareNodes Struct:
- Defines comparison rules for min-heap prioritization.
std::priority_queue:
- Min-heap to manage Huffman nodes during tree construction.
std::map:
- Tracks character frequencies.

d. Debugging Process

Tree Construction:
- Verified frequency calculations.
- Ensured min-heap correctly prioritizes nodes.
Code Generation:
- Manually validated Huffman codes for sample inputs.
Encoding/Decoding:
- Tested with simple cases (e.g., repeated characters).
- Confirmed handling of equal-frequency characters.

e. Output Results

For input "hello world", the program outputs:

Huffman Codes:
d: 00
r: 010
$: 011
w: 1000
e: 1001
o: 101
l: 110
h: 1110
 : 1111
Encoded Text: 111000110010100010010010110111010010011110111100
Decoded Text: hello world

f. Source Code

#include 
#include 
#include 
#include 
using namespace std;

struct HuffmanNode {
    char data;
    int frequency;
    HuffmanNode *left, *right;
    HuffmanNode(char d, int freq) : data(d), frequency(freq), left(nullptr), right(nullptr) {}
};

struct CompareNodes {
    bool operator()(HuffmanNode* a, HuffmanNode* b) {
        return a->frequency > b->frequency;
    }
};

HuffmanNode* buildHuffmanTree(map<char, int>& frequencies) {
    priority_queue<HuffmanNode*, vector<HuffmanNode*>, CompareNodes> minHeap;

    for (auto& entry : frequencies) {
        HuffmanNode* node = new HuffmanNode(entry.first, entry.second);
        minHeap.push(node);
    }

    while (minHeap.size() > 1) {
        HuffmanNode* left = minHeap.top();
        minHeap.pop();
        HuffmanNode* right = minHeap.top();
        minHeap.pop();
        HuffmanNode* internalNode = new HuffmanNode('$', left->frequency + right->frequency);
        internalNode->left = left;
        internalNode->right = right;
        minHeap.push(internalNode);
    }
    return minHeap.top();
}

void generateHuffmanCodes(HuffmanNode* root, string code, map<char, string>& huffmanCodes) {
    if (root == nullptr) return;
    if (root->data != '$') huffmanCodes[root->data] = code;
    generateHuffmanCodes(root->left, code + "0", huffmanCodes);
    generateHuffmanCodes(root->right, code + "1", huffmanCodes);
}

string huffmanEncode(string text, map<char, string>& huffmanCodes) {
    string encodedText = "";
    for (char c : text) encodedText += huffmanCodes[c];
    return encodedText;
}

string huffmanDecode(string encodedText, HuffmanNode* root) {
    string decodedText = "";
    HuffmanNode* current = root;
    for (char bit : encodedText) {
        current = (bit == '0') ? current->left : current->right;
        if (current->data != '$') {
            decodedText += current->data;
            current = root;
        }
    }
    return decodedText;
}

int main() {
    string text;
    cin >> text;
    map<char, int> frequencies;

    for (char c : text) frequencies[c]++;

    HuffmanNode* root = buildHuffmanTree(frequencies);
    map<char, string> huffmanCodes;
    generateHuffmanCodes(root, "", huffmanCodes);

    cout << "Huffman Codes:" << endl;
    for (auto& entry : huffmanCodes) cout << entry.first << ": " << entry.second << endl;

    string encodedText = huffmanEncode(text, huffmanCodes);
    cout << "Encoded Text: " << encodedText << endl;

    string decodedText = huffmanDecode(encodedText, root);
    cout << "Decoded Text: " << decodedText << endl;

    return 0;
}

Summary

The implementation correctly constructs Huffman trees, generates codes, and performs encoding/decoding. Special cases (e.g., equal frequencies) are handled by the min-heap’s stable sorting. Testing confirmed accurate results for varied inputs.

Binary Search Tree Construction and Node Deletion

a. Problem Analysis

This experiment aims to implement node insertion, inorder traversal, entire tree deletion, and single-node deletion in a binary search tree (BST). Key requirements include using a struct for nodes and supporting insertion/deletion operations.

b. Algorithm Design

Node Insertion

Recursively inserts a value by comparing with the current node. Creates a new node if the subtree is empty.

TreeNode* insert(TreeNode* root, int val) {
    if (root == nullptr) return new TreeNode(val);
    if (val <= root->data) root->left = insert(root->left, val);
    else root->right = insert(root->right, val);
    return root;
}

BST Construction

Iteratively inserts each input value into the BST.

TreeNode* buildTree(int input[], int size) {
    TreeNode* root = nullptr;
    for (int i = 0; i < size; ++i) root = insert(root, input[i]);
    return root;
}

Inorder Traversal

Outputs node values in ascending order.

void inorderTraversal(TreeNode* node) {
    if (node != nullptr) {
        inorderTraversal(node->left);
        cout << node->data << " ";
        inorderTraversal(node->right);
    }
}

Entire Tree Deletion

Recursively deletes all nodes.

void deleteTree(TreeNode* node) {
    if (node != nullptr) {
        deleteTree(node->left);
        deleteTree(node->right);
        delete node;
    }
}

Single-Node Deletion

Handles three cases: no children, one child, or two children (replaced by the right subtree’s minimum).

TreeNode* deleteNode(TreeNode* root, int val) {
    if (root == nullptr) return root;
    if (val < root->data) root->left = deleteNode(root->left, val);
    else if (val > root->data) root->right = deleteNode(root->right, val);
    else {
        if (root->left == nullptr) {
            TreeNode* temp = root->right;
            delete root;
            return temp;
        } else if (root->right == nullptr) {
            TreeNode* temp = root->left;
            delete root;
            return temp;
        }
        TreeNode* minRight = root->right;
        while (minRight->left != nullptr) minRight = minRight->left;
        root->data = minRight->data;
        root->right = deleteNode(root->right, minRight->data);
    }
    return root;
}

c. Data Structure Design

struct TreeNode {
    int data;
    TreeNode *left, *right;
    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

d. Debugging

Validated deleteNode by checking inorder traversal post-deletion.
Confirmed edge cases (e.g., deleting root or leaves).

e. Output Results

Input: 7, 5, 9, 2, 5, 2, 6, 3, 7, 0

BST: 0 2 2 3 5 5 6 7 7 9 
After deleting 3: 0 2 2 5 5 6 7 7 9 
After deleting 5: 0 2 2 6 7 7 9

f. Source Code

#include 
using namespace std;

struct TreeNode {
    int data;
    TreeNode *left, *right;
    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

TreeNode* insert(TreeNode* root, int val) {
    if (root == nullptr) return new TreeNode(val);
    if (val <= root->data) root->left = insert(root->left, val);
    else root->right = insert(root->right, val);
    return root;
}

void inorderTraversal(TreeNode* node) {
    if (node != nullptr) {
        inorderTraversal(node->left);
        cout << node->data << " ";
        inorderTraversal(node->right);
    }
}

void deleteTree(TreeNode* node) {
    if (node != nullptr) {
        deleteTree(node->left);
        deleteTree(node->right);
        delete node;
    }
}

TreeNode* deleteNode(TreeNode* root, int val) {
    if (root == nullptr) return root;
    if (val < root->data) root->left = deleteNode(root->left, val);
    else if (val > root->data) root->right = deleteNode(root->right, val);
    else {
        if (root->left == nullptr) {
            TreeNode* temp = root->right;
            delete root;
            return temp;
        } else if (root->right == nullptr) {
            TreeNode* temp = root->left;
            delete root;
            return temp;
        }
        TreeNode* minRight = root->right;
        while (minRight->left != nullptr) minRight = minRight->left;
        root->data = minRight->data;
        root->right = deleteNode(root->right, minRight->data);
    }
    return root;
}

int main() {
    int input[] = {7, 5, 9, 2, 5, 2, 6, 3, 7, 0};
    TreeNode* root = nullptr;

    for (int i = 0; i < 10; ++i) root = insert(root, input[i]);

    cout << "BST: ";
    inorderTraversal(root);
    cout << endl;

    root = deleteNode(root, 3);
    cout << "After deleting 3: ";
    inorderTraversal(root);
    cout << endl;

    root = deleteNode(root, 5);
    cout << "After deleting 5: ";
    inorderTraversal(root);
    cout << endl;

    deleteTree(root);
    return 0;
}

Summary

The BST implementation supports insertion, traversal, and deletion (both entire tree and single nodes). Testing confirmed correct behavior for all operations.

Published on 2023-12-12 at 孤筝の温暖小家, last modified on 2023-12-12

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!

Data Structure Lab Report 4 - Binary Tree Construction, Storage, and Traversal

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 14:43:54 +0800

Data Structure Lab Report 4 - Binary Tree Construction, Storage, and Traversal

Author: 孤筝(lvbowen040427@163.com)

1. Creating Binary Trees from Input: Sequential and Linked Storage

a. Problem Analysis:

This task requires creating a binary tree from an input character sequence, implementing two storage methods: sequential storage and linked storage. The character ‘@’ in the input sequence represents an empty node.

b. Algorithm Design:

Sequential Storage Method:

Initialize an array to represent the sequentially stored binary tree.
Traverse the input character sequence and store characters in the array sequentially.
Use array indices to represent node positions: for a parent node at index i, its left child is at 2*i + 1 and right child at 2*i + 2.
Skip ‘@’ characters (empty nodes), storing only actual data.

Linked Storage Method:

Create a TreeNode struct to represent binary tree nodes, containing data, left subtree pointer, and right subtree pointer.
Use a queue data structure to assist in building the tree. Initialize with a root node and enqueue it.
Traverse the input sequence, dequeuing nodes to create left and right children, then enqueue them.

c. Data Structure Design:

Sequential Storage:

struct TreeNode represents binary tree nodes.
Array stores nodes sequentially.

Linked Storage:

struct TreeNode represents nodes with data and subtree pointers.
Queue assists in tree construction.

d. Debugging Process:

Run the program with sample input to build the tree.
Ensure correct input sequence with ‘@’ for empty nodes.
Use ‘#’ to mark input completion in linked storage.
Verify correct sequential and linked storage implementations.

e. Output Results:

Output includes sequentially stored node data and traversal results for linked storage.

2. Depth-First Traversal Implementation

a. Problem Analysis:

Implement depth-first traversals: pre-order, in-order, and post-order for sequentially stored trees.

b. Algorithm Design:

Pre-order:

Visit root, then recursively traverse left and right subtrees.

In-order:

Recursively traverse left subtree, visit root, then right subtree.

Post-order:

Recursively traverse left and right subtrees, then visit root.

c. Data Structure Design:

Recursive algorithms.

3. Breadth-First Traversal Implementation

a. Problem Analysis:

Implement level-order traversal for linked storage trees.

b. Algorithm Design:

Use a queue, starting from root, enqueuing nodes level by level while visiting them.

c. Data Structure Design:

Queue data structure.

Sample Cases

Inputs: abc@@@d@ef@ and abc@@@d@ef@#

Debugging Process:

Sequential Storage:
- Input characters: ‘a’, ‘b’, ‘c’, ‘@’, ‘@’, ‘@’, ’d’, ‘@’, ’e’, ‘f’.
- Sequential array: ['a', 'b', 'c', '@', '@', '@', 'd', '@', 'e', 'f'].
Linked Storage:
- Create root ‘a’, enqueue.
- ‘b’ becomes left child of ‘a’, enqueue.
- ‘c’ becomes right child of ‘a’, enqueue.
- ‘@’ indicates empty left child.
- ‘@’ indicates empty right child.
- ’d’ becomes left child of ‘b’, enqueue.
- ‘@’ indicates empty right child.
- ’e’ becomes left child of ‘c’, enqueue.
- ‘f’ becomes right child of ‘c’, enqueue.

Output Results:

Sequential Storage:
- Pre-order: a b d c e f
- In-order: d b a e c f
- Post-order: d b e f c a
Linked Storage:
- Pre-order: a b d c e f
- In-order: b d a e c f
- Post-order: d b e f c a
- Level-order: a b c d e f

Source Code

Sequential Storage

#include
using namespace std;
#define MAX_NODES 1000  // Maximum node count
// Binary tree node structure
struct TreeNode {
    char data;
};
// Create new tree node
TreeNode* createNode(char data) {
    TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
    newNode->data = data;
    return newNode;
}
// Sequential storage tree structure
struct SequentialTree {
    TreeNode* nodes[MAX_NODES];
    int size; // Node count
};
// Initialize sequential tree
void initSequentialTree(SequentialTree* tree) {
    tree->size = 0;
    for (int i = 0; i < MAX_NODES; i++) {
        tree->nodes[i] = nullptr;
    }
}
// Insert node into sequential tree
void insertNode(SequentialTree* tree, char data) {
    if (tree->size < MAX_NODES) {
        TreeNode* newNode = createNode(data);
        tree->nodes[tree->size] = newNode;
        tree->size++;
    } else {
        printf("Tree is full, cannot insert\n");
    }
}
// Get root node
TreeNode* getRoot(SequentialTree* tree) {
    return tree->nodes[0];
}
// Get left child
TreeNode* getLeftChild(SequentialTree* tree, int parentIndex) {
    int leftChildIndex = 2 * parentIndex + 1;
    if (leftChildIndex < tree->size) {//Check existence
        return tree->nodes[leftChildIndex];
    }
    return nullptr;
}
// Get right child
TreeNode* getRightChild(SequentialTree* tree, int parentIndex) {
    int rightChildIndex = 2 * parentIndex + 2;
    if (rightChildIndex < tree->size) {
        return tree->nodes[rightChildIndex];
    }
    return nullptr;
}
// Pre-order traversal
void preorderTraversal(struct SequentialTree* tree, int index) {
    if (index >= tree->size || tree->nodes[index]->data == '@') {
        return;
    }
    printf("%c ", tree->nodes[index]->data); // Visit root
    preorderTraversal(tree, 2 * index + 1); // Traverse left
    preorderTraversal(tree, 2 * index + 2); // Traverse right
}
// In-order traversal
void inorderTraversal(struct SequentialTree* tree, int index) {
    if (index >= tree->size || tree->nodes[index]->data == '@') {
        return;
    }
    inorderTraversal(tree, 2 * index + 1); // Traverse left
    printf("%c ", tree->nodes[index]->data); // Visit root
    inorderTraversal(tree, 2 * index + 2); // Traverse right
}
// Post-order traversal
void postorderTraversal(struct SequentialTree* tree, int index) {
    if (index >= tree->size || tree->nodes[index]->data == '@') {
        return;
    }
    postorderTraversal(tree, 2 * index + 1); // Traverse left
    postorderTraversal(tree, 2 * index + 2); // Traverse right
    printf("%c ", tree->nodes[index]->data); // Visit root
}
int main() {
    SequentialTree* tree=(SequentialTree*)malloc(sizeof(SequentialTree));
    initSequentialTree(tree);
    char data='a';
    while (1){
        cin>>data;
        if(data=='#'){
            break;
        }
        insertNode(tree,data);
    }
    cout<<"Pre-order traversal:"<<endl;
    preorderTraversal(tree,0);
    cout<<endl;
    cout<<"In-order traversal:"<<endl;
    inorderTraversal(tree,0);
    cout<<endl;
    cout<<"Post-order traversal:"<<endl;
    postorderTraversal(tree,0);
    cout<<endl;
    cout<<"Level-order traversal:"<<endl;
    for(int i=0;i<tree->size;i++){
        if(tree->nodes[i]->data!='@')
            cout<<tree->nodes[i]->data<<' ';
    }
    cout<<endl;
    return 0;
}

Linked Storage

#include
using namespace std;
// Binary tree node structure
struct TreeNode {
    char data;
    TreeNode* left;
    TreeNode* right;
    TreeNode(char val) : data(val), left(nullptr), right(nullptr) {}
};
// Create linked binary tree
TreeNode* createBinaryTree(const string& input) {
    if (input.empty()) {
        return nullptr;
    }
    queue<TreeNode*> nodeQueue;
    TreeNode* root = new TreeNode(input[0]);
    nodeQueue.push(root);
    for (int i = 1; i < input.length(); i += 2) {
        TreeNode* current = nodeQueue.front();
        nodeQueue.pop();
        if (input[i] != '@') {
            current->left = new TreeNode(input[i]);
            nodeQueue.push(current->left);
        }
        if (i + 1 < input.length() && input[i + 1] != '@') {
            current->right = new TreeNode(input[i + 1]);
            nodeQueue.push(current->right);
        }
    }
    return root;
}
// Pre-order traversal
void preorderTraversal(TreeNode* root) {
    if (root) {
        cout << root->data << " ";
        preorderTraversal(root->left);
        preorderTraversal(root->right);
    }
}
// In-order traversal
void inorderTraversal(TreeNode* root) {
    if (root) {
        inorderTraversal(root->left);
        cout << root->data << " ";
        inorderTraversal(root->right);
    }
}
// Post-order traversal
void postorderTraversal(TreeNode* root) {
    if (root) {
        postorderTraversal(root->left);
        postorderTraversal(root->right);
        cout << root->data << " ";
    }
}
// Level-order traversal
void breadthFirstTraversal(TreeNode* root) {
    if (!root) {
        return;
    }
    queue<TreeNode*> nodeQueue;
    nodeQueue.push(root);
    while (!nodeQueue.empty()) {
        TreeNode* current = nodeQueue.front();
        nodeQueue.pop();
        cout << current->data << " ";
        if (current->left) {
            nodeQueue.push(current->left);
        }
        if (current->right) {
            nodeQueue.push(current->right);
        }
    }
}
int main() {
    string input;
    cin>>input;
    TreeNode* root = createBinaryTree(input);
    cout << "Pre-order traversal: ";
    preorderTraversal(root);
    cout << endl;
    cout << "In-order traversal: ";
    inorderTraversal(root);
    cout << endl;
    cout << "Post-order traversal: ";
    postorderTraversal(root);
    cout << endl;
    cout << "Level-order traversal: ";
    breadthFirstTraversal(root);
    cout << endl;
    return 0;
}

Published on 2023-12-12 at 孤筝の温暖小家, last modified on 2023-12-12

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!

Data Structure Lab Report 3 – Using KMP Algorithm for String Search

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 14:42:01 +0800

Data Structure Lab Report 3 – Using KMP Algorithm for String Search

Author: 孤筝(lvbowen040427@163.com)

Experiment Objective:

This experiment aims to analyze and test the implementation of the KMP algorithm and explore its application in string searching.

Experiment Content:

a. Problem Analysis:

How to construct the Longest Prefix Suffix (LPS) array to improve search efficiency?
How to perform matching in the text string using the LPS array to avoid unnecessary character comparisons?
How to design an algorithm to search for a pattern string?

b. Algorithm Design:

The KMP algorithm involves the following key steps:

Constructing the LPS array: The computeLPSArray function calculates the LPS array for the pattern string, which indicates the longest matching length of prefixes and suffixes at each position in the pattern.
Performing matching in the text: The KMPSearch function executes pattern matching in the text string. It utilizes the LPS array to backtrack intelligently, thereby improving search efficiency.

c. Data Structure Design:

In this experiment, the following data structures were used:

Strings: To represent the text and pattern strings.
Vectors: To store the LPS array.
Integer variables: To track indices during the matching process.

d. Debugging Process:

While writing and testing the code, some potential issues such as logical errors or edge cases were encountered. Careful debugging was required to ensure the algorithm’s correctness and performance. By step-by-step debugging and printing intermediate results, the code was verified to correctly identify the positions of pattern matches in the text.

e. Output Results:

Below are some example output results:

When the text string is "ABABDABACDABABCABAB" and the pattern string is "ABABCABAB", the KMP algorithm locates the pattern in the text at:
```
Match found at index 10  
```
When both the text and pattern strings are provided by the user, the KMP algorithm searches for the user-specified pattern in the given text and outputs the matching positions.

f. Source Code:

#include
using namespace std;

// Computes the Longest Prefix Suffix (LPS) array for the pattern
void computeLPSArray(const string& pattern, vector<int>& lps) {
    int length = 0;  // Length of the previous longest prefix suffix

    lps[0] = 0;  // lps[0] is always 0

    int i = 1;

    while (i < pattern.length()) {
        if (pattern[i] == pattern[length]) {
            length++;
            lps[i] = length;
            i++;
        } else {
            if (length != 0) {
                length = lps[length - 1];
            } else {
                lps[i] = 0;
                i++;
            }
        }
    }
}

// Searches for the pattern in the text using the KMP algorithm
void KMPSearch(const string& text, const string& pattern) {
    int m = pattern.length();
    int n = text.length();

    vector<int> lps(m);
    computeLPSArray(pattern, lps);

    int i = 0;  // Index for text[]
    int j = 0;  // Index for pattern[]

    while (i < n) {
        if (pattern[j] == text[i]) {
            i++;
            j++;
        }

        if (j == m) {
            // Pattern found, print the starting index
            cout << "Match found at index " << i - j << endl;
            j = lps[j - 1];
        } else if (i < n && pattern[j] != text[i]) {
            if (j != 0) {
                j = lps[j - 1];
            } else {
                i++;
            }
        }
    }
}

// int main() {
//     string text = "ABABDABACDABABCABAB";
//     string pattern = "ABABCABAB";

//     KMPSearch(text, pattern);

//     return 0;
// }


int main() {
    string text;
    string pattern;
    cin>>text;
    cin>>pattern;

    KMPSearch(text, pattern);

    return 0;
}

Published on 2023-12-12 at 孤筝の温暖小家, last modified on 2023-12-12

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!

Data Structure Lab Report 2 — Sparse Matrix Multiplication

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 14:38:24 +0800

Data Structure Lab Report 2 — Sparse Matrix Multiplication

Author: 孤筝(lvbowen040427@163.com)

Problem Analysis

The primary objective of this experiment is to develop a sparse matrix multiplication algorithm capable of multiplying two sparse matrices, A and B, and outputting the resulting matrix C. In this algorithm, sparse matrices are represented using triplets, and users can input different matrix data multiple times to compute their products.

Algorithm Design

The sparse matrix multiplication algorithm is designed as follows:

A struct is used to represent the matrix, which includes the number of rows (m), columns (n), the count of non-zero elements (L), and an array to store node information.
The input function input retrieves the triplet representation of the matrix, checks the validity of the input, and stores it in the memory structure.
The output function output prints the sparse matrix in standard matrix form for user review.
The matrix multiplication function multiplier takes two input matrices, A and B, computes their product, and stores the result in matrix C.

Data Structure Design

The matrix struct contains the number of rows (m), columns (n), the count of non-zero elements (L), and the Ma array for storing node information.
The node struct represents each non-zero element in the sparse matrix, including the row index (i), column index (j), and the element value (data).

Debugging Process

The code includes error-handling mechanisms, such as validating input legality, checking memory allocation success, and ensuring matrix multiplication compatibility.
When inputting sparse matrix data, users receive error messages and are prompted to re-enter data if it exceeds the matrix dimensions.
The sparse matrix multiplication algorithm checks whether the columns of the first matrix match the rows of the second matrix to ensure valid multiplication.

Output Results

Matlab verification results:

Users can input two matrices, A and B, and the program will compute their product and output the resulting matrix C. Users may choose to continue with additional sparse matrix multiplications or exit the program. The program runs continuously until the user opts to exit.

Summary

Overall, this experiment successfully implements sparse matrix multiplication, providing a user-friendly interface and robust error-handling mechanisms to ensure valid matrix input. It correctly computes the product of two sparse matrices and outputs the result in standard matrix form.

Source Code

#include
using namespace std;
#define MAX 1000

struct node{
    int i;
    int j;
    int data;
};
struct matrix{
    int m;
    int n;
    int L;
    node* Ma[MAX];
};

int input(matrix* A){
    int m,n,data;
    for(int i=0;i<A->L;i++){
        cin>>m>>n>>data;
        if(m<0||m>=A->m||n<0||n>=A->n){
            cout<<"Input error: Row/column exceeds matrix dimensions!"<<endl;
            return 1;
        }
        A->Ma[i]=(node*)malloc(sizeof(node));
        if(!A->Ma[i]){
            cout<<"Memory allocation failed!"<<endl;
            return 2;
        }else{
            A->Ma[i]->i=m;
            A->Ma[i]->j=n;
            A->Ma[i]->data=data;
        }
    }
    return 0;
}

void output(matrix* A,string name){
    cout<<"Matrix "<<name<<":"<<endl;
    int nums[A->m][A->n];

    memset(nums,0,sizeof(nums));
    for(int i=0;i<A->L;i++){
        nums[A->Ma[i]->i][A->Ma[i]->j]=A->Ma[i]->data;
    }
    for(int i=0;i<A->m;i++){
        for(int j=0;j<A->n;j++){
            cout<<nums[i][j]<<'\t';
        }
        cout<<endl;
    }
}

void multiplier(matrix* A,matrix* B,matrix* C){
    C->m=A->m;
    C->n=B->n;
    C->L=0;
    int x,y,z;
    bool found=false;
    for(int i=0;i<A->L;i++){
        for(int j=0;j<B->L;j++){
            if(A->Ma[i]->j==B->Ma[j]->i){ // Column of A matches row of B
                x=A->Ma[i]->i;
                y=B->Ma[j]->j;
                z=A->Ma[i]->data*B->Ma[j]->data;
                found=false;
                for(int k=0;k<C->L;k++){
                    if(x==C->Ma[k]->i&&y==C->Ma[k]->j){
                        C->Ma[k]->data+=z;
                        found=true;
                        break;
                    }
                }
                if(!found){
                    C->L++;
                    C->Ma[C->L-1]=(node*)malloc(sizeof(node));
                    C->Ma[C->L-1]->i=x;
                    C->Ma[C->L-1]->j=y;
                    C->Ma[C->L-1]->data=z;
                }
            }
        }
    }
}

int main(){
start:
    matrix* A=(matrix*)malloc(sizeof(matrix));
    matrix* B=(matrix*)malloc(sizeof(matrix));
    matrix* C=(matrix*)malloc(sizeof(matrix));
    cout<<"Enter triplet length, rows, and columns for matrix A:"<<endl;
    cin>>A->L>>A->m>>A->n;
    cout<<"Enter matrix A:"<<endl;
    if(input(A)){
        cout<<"Error detected. Please re-enter!"<<endl;
        goto start;
    }
    output(A,"A");
    cout<<"Enter triplet length, rows, and columns for matrix B:"<<endl;
    cin>>B->L>>B->m>>B->n;
    cout<<"Enter matrix B:"<<endl;
    if(input(B)){
        cout<<"Error detected. Please re-enter!"<<endl;
        goto start;
    }
    output(B,"B");
    multiplier(A,B,C);
    output(C,"C");

    cout<<"Continue sparse matrix multiplication? (y/n):";
    char choice;
choice_input:
    cin>>choice;
    if(choice=='y'||choice=='Y'){
        goto start;
    }else if(choice=='n'||choice=='N'){
        return 0;
    }else{
        cout<<"Invalid input. Please re-enter:";
        goto choice_input;
    }
    return 0;
}

Published on 2023-12-12 at 孤筝の温暖小家, last modified on 2023-12-12

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!

Lab Report 1 on Data Structure Experiments——Fibonacci Sequence & Set Partition Problem

lvbowen040427@163.com (孤筝) — Tue, 12 Dec 2023 14:31:17 +0800

Lab Report 1 on Data Structure Experiments——Fibonacci Sequence & Set Partition Problem

Author: 孤筝(lvbowen040427@163.com)

Fibonacci Sequence

Problem Analysis

To correctly implement recursive function calls and returns, parameter passing and return address handling must be properly addressed. Specifically, during each recursive call, new storage space must be allocated for all parameters, while preserving the actual parameters from the previous call and the return address for the current call.

Algorithm Design

The algorithm is described as follows:

int Fib(int n){
    int fib;
    if(n==0) fib=0;
    else if(n==1) fib=1;
    else fib=Fib(n-1)+Fib(n-2);
    return fib;
}

Data Structure Design

A stack is used to allocate and manage storage space. The system creates a “working record” for each procedure call, storing the values of all parameters before the call and the return address after the call. This working record is pushed onto the stack to ensure correct information retrieval upon return.

Debugging Process

During each function call, outputting the passed parameters provides a clearer visualization of the stack’s call process.
For example, in the initial recursive call Fib(2), the program first pushes Fib(5), Fib(4), …, Fib(1) onto the stack. When n == 1, the value is returned to the previous address. Similarly, when n == 0, its value is returned, allowing Fib(2) to compute its value, which is then returned to its caller Fib(3).

Output Result

Source Code

#include
using namespace std;

int Fibonacci(int n){
    int fib;
    if(n==0){
        fib=0;
    }else if(n==1){
        fib=1;
    }else if(n==2){
        fib=2;
    }else{
        fib=Fibonacci(n-1)+Fibonacci(n-2);
    }
    return fib;
}

int main(){
    int n=0;
    cout<<"Enter n:";
start:
    cin>>n;
    cout<<"The nth Fibonacci number is "<<Fibonacci(n)<<endl;
    cout<<"Continue calculation? (y/n):";
    char choice;
choice:
    cin>>choice;
    if(choice=='y'||choice=='Y'){
        goto start;
    }else if(choice=='n'||choice=='N'){
        return 0;
    }else{
        cout<<"Invalid input, please re-enter:";
        goto choice;
    }
    return 0;
}

Set Partitioning Problem

Problem Analysis

The task requires partitioning a set into mutually disjoint subsets such that no elements within any subset conflict with each other, while minimizing the number of subsets. Such problems are commonly encountered in scheduling applications.

Algorithm Design

Conflict relationships are represented using a 2D array, where 1 indicates a conflict and 0 indicates no conflict. A cyclic screening method is employed for partitioning: starting with the first element, it is isolated, and other elements are checked for conflicts with the isolated elements. Non-conflicting elements are grouped together. This process repeats until all mutually non-conflicting elements are grouped, iterating until all elements are partitioned.

Data Structure Design

A circular queue stores the data, allowing iterative processing without requiring additional storage space.

Debugging Process

Output Result

Source Code

#include
using namespace std;
int newr[9];

void DivideIntoGroup(int n, int R[][9], int cp[], int result[]) {
    int front, rear, group, pre, I, i;
    front = n - 1;
    rear = n - 1;
    for (i = 0; i < n; i++) {
        newr[i] = 0;
        cp[i] = i + 1;
    }
    group = 1;
    pre = 0;
    do {
        front = (front + 1) % n;
        I = cp[front];
        if (I < pre) {
            group = group + 1;
            result[I - 1] = group;
            for (i = 0; i < n; i++) {
                newr[i] = R[I - 1][i];
            }
        } else {
            if (newr[I - 1] != 0) {
                rear = (rear + 1) % n;
                cp[rear] = I;
            } else {
                result[I - 1] = group;
                for (i = 0; i < n; i++) {
                    newr[i] += R[I - 1][i];
                }
            }
        }
        pre = I;
    } while (rear != front);
}

int main() {
    int result[9], cp[9];
    int R[9][9] = {
        {0, 1, 0, 0, 0, 0, 0, 0, 0},
        {1, 0, 0, 0, 1, 1, 0, 1, 1},
        {0, 0, 0, 0, 0, 1, 1, 0, 0},
        {0, 0, 0, 0, 1, 0, 0, 0, 1},
        {0, 1, 0, 1, 0, 1, 1, 0, 1},
        {0, 1, 1, 0, 1, 0, 1, 0, 0},
        {0, 0, 1, 0, 1, 1, 0, 0, 0},
        {0, 1, 0, 0, 0, 0, 0, 0, 0},
        {0, 1, 0, 1, 1, 0, 0, 0, 0},
    };
    DivideIntoGroup(9, R, cp, result);
    for (int i = 0; i < 9; i++) {
        cout << i + 1 << " ";
    }
    cout << endl;
    for (int i = 0; i < 9; i++) {
        cout << result[i] << " ";
    }
    return 0;
}

Published on 2023-12-12 at 孤筝の温暖小家, last modified on 2023-12-12

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!

Basic Data Structures in Python

lvbowen040427@163.com (孤筝) — Sun, 27 Aug 2023 21:40:39 +0800

Basic Data Structures in Python

Author: 孤筝(lvbowen040427@163.com)

elem is the abbreviation of the word “element”, representing an indeterminate type in programming definitions, i.e., an abstract data type.

List

Definition

A container formed by a sequence of elements arranged in order.

Elements can be of any type.
Elements are arranged in a determined order, exhibiting sequentiality.

Creating a List

Method 1: Create an empty list instance and then add elements

list()
.append() method

>>> wife = list()  # Instantiation  
>>> wife.append("Nishimiya Shoko")  
>>> wife.append("Sakurajima Mai")  
>>> wife.append("Elysia")  
>>> wife  
['Nishimiya Shoko', 'Sakurajima Mai', 'Elysia']

Method 2: Directly define and populate the list

>>> phones = ["Apple", "Huawei", "Xiaomi"]  
>>> phones  
['Apple', 'Huawei', 'Xiaomi']

Accessing Elements

Using Indexing
Access the (i+1)th element with [i].
index() Method
name.index(x)
Searches for the first element with value x in list name and returns its index.
count() Method
name.count(x)
Counts how many elements in list name have the value x and returns the count.
len() Method
len(name)
Returns the total number of elements in list name.

Adding Elements

append() Method
name.append(x)
Adds element x to the end of name.
insert() Method
name.insert(i, x)
Inserts object x at index i in name, shifting subsequent elements backward.
extend() Method
name.extend(name2)
Appends list name2 to the end of list name.

Modifying Elements

Direct Assignment via Index
Assign a new value to an element using its index.

Deleting Elements

pop() Method
name.pop()
Removes the last element by default.
name.pop(i)
Removes the element at index i, shifting subsequent elements forward.
remove() Method
name.remove(x)
Removes the first element with value x, shifting subsequent elements forward.
clear() Method
name.clear()
Deletes all elements (empties the list).
del Statement
del name[a:b]
Deletes elements with indices in [a, b) (includes a, excludes b).
del name[:] clears the list.
del name[i] deletes the element at index i.

Reversing a List

reverse() Method
name.reverse()
Reverses the list in place (last element becomes first, etc.).

Slicing Method

>>> nums = [1, 2, 3, 4, 5]  
>>> new_nums = nums[::-1]  
>>> new_nums  
[5, 4, 3, 2, 1]

The original list nums remains unchanged; a new reversed list new_nums is created.

Sorting a List

sort() Method
name.sort()
name.sort(cmp=None, key=None, reverse=False)
- Modifies the original list in place (no return value).
- cmp is an optional parameter (deprecated in Python 3).
- key specifies a function to extract a comparison key from each element.
  - Omitted if elements are single-parameter (e.g., numbers or single characters).
```
def takeSecond(elem):  
    return elem[1]  
random = [(2, 2), (3, 4), (4, 1), (1, 3)]  
random.sort(key=takeSecond)  # Sorts by the second element of each tuple.  
print(random)  
# Output: [(4, 1), (2, 2), (1, 3), (3, 4)]  
```
- reverse: False for ascending (default), True for descending.

Tuple

Definition

A tuple is an immutable sequence of elements, similar to a list but unchangeable.

Creating a Tuple

Use parentheses () to enclose elements (lists use []).
Sometimes tuples can be created without () (not recommended).

Tuple Comprehension:

atuple = (i+1 for i in range(31, 42))

For single-element tuples, add a trailing comma , to avoid confusion with non-tuple objects.
Empty Tuple:
```
a = tuple()  
b = ()  
```

Tuples Are Immutable

Tuples do not support addition, deletion, or modification of elements.

Converting Between Tuples and Lists

Tuple → List:

atuple = (1, 'love', 3.334, 'Y')  
alist = list(atuple)  # Converts to list

List → Tuple:

alist = ['I', 2, 3.1415, 'polaris']  
atuple = tuple(alist)  # Converts to tuple

Dictionary (dict)

Definition

A collection of key-value pairs.
Keys must be hashable (e.g., strings, numbers).
- Hash: A process that maps data of arbitrary size to fixed-size values.
Values can be any object.

Creating a Dictionary

Empty Dictionary + Assignment:
```
profile = dict(name='孤筝', age=19, hobby='明月栞那')  
```
(Note: Keys as identifiers do not need quotes.)

Direct {} Syntax:

profile = {'name': '孤筝', 'age': 19, 'hobby': '明月栞那'}

(Keys as strings require quotes.)

From Sequence of Pairs:

alist = [('name', '孤筝'), ('age', 19), ('hobby', '明月栞那')]  
profile = dict(alist)

Dictionary Comprehension:

adict = {i: i**2 for i in range(2, 6)}  
# Output: {2: 4, 3: 9, 4: 16, 5: 25}

Accessing Elements

dict[key]:
Raises KeyError if the key is missing.
dict.get(key[, default]):
Returns default (or None) if the key is missing.
If the key is absent, it can optionally add the key with the default value.

Adding/Modifying Elements

Add/Modify: dict[key] = value

Deleting Elements

dict.pop(key): Removes the key-value pair.
del dict[key]: Deletes the pair.

Other Key Methods

Checking Key Existence

in/not in
dict.has_key() (Python 2 only; removed in Python 3).

Setting Default Values

Conditional Check:

if "gender" not in profile:  
    profile["gender"] = "male"

setdefault():
dict.setdefault(key, default=None)
Sets default if the key is missing.

Set

Definition

An unordered collection of unique elements (like a mathematical set).
Question: If sets are unordered, how are elements ordered when printed/stored?

Creating a Set

Curly Braces {}: Duplicates are automatically removed.

set() Constructor:

aset = {1314, '520'}  
bset = set()  # Empty set  
cset = set(['I', 'love', 'ishimiya'])

Adding Elements

add():
aset.add(elem)
- No effect if elem already exists (no error).
- elem must be immutable (e.g., numbers, strings).
update():
aset.update(iterable)
Adds elements from any iterable (e.g., list, tuple, dict keys).

Deleting Elements

remove(): Raises KeyError if the element is missing.
discard(): No error if the element is missing.
pop(): Randomly removes and returns an element.
clear(): Empties the set.

Set Operations

Union

aset.union(bset) or aset | bset

Difference

aset.difference(bset) or aset - bset

Intersection

intersection(): aset.intersection(bset) or aset & bset
intersection_update(): Updates aset in place.

Symmetric Difference (Non-Overlapping Elements)

symmetric_difference(): Returns new set.
symmetric_difference_update(): Updates aset in place.

Other Operations

Membership Check: elem in aset
Disjoint Check: aset.isdisjoint(bset) (True if no common elements).
Subset Check: bset.issubset(aset) (True if bset is a subset).

Iterator

Iterable Objects

Objects usable in for loops (e.g., lists, tuples).

Iterable Protocol

Implements __iter__(): Returns an iterator instance.
- isinstance(obj, Iterable) returns True.
Fallback to __getitem__(): If __iter__() is missing, Python checks for __getitem__() to simulate iteration.
- isinstance(obj, Iterable) returns False for this case.

Iterator Objects

Created via iter(iterable).
Elements are accessed using next(), raising StopIteration when exhausted.

alist = ['人', '生', '若', '只', '如', '初', '见']  
gen = iter(alist)  
for _ in alist:  
    print(next(gen))  # Outputs elements sequentially

Iterable vs. Iterator

Iterable: The container (e.g., list).
Iterator: The object returned by iter(), enabling element-by-element traversal.

Generator

A function that produces values lazily (like an iterator), usable in for loops.

Creating Generators

List Comprehension → Generator

alist = [i for i in range(5)]  # List  
gen = (i for i in range(5))    # Generator  
print(next(gen))  # Output: 0

`yield` Keyword

Pauses function execution and returns a value.
Resumes from the paused state on subsequent calls.

def generator():  
    top = 5  
    i = 0  
    while i < top:  
        print(f'Current value: {i}')  
        i += 1  
        yield i  
    raise StopIteration  

gen = generator()  
for _ in range(5):  
    print(next(gen))

Key Difference: `yield` vs. `return`

yield pauses execution; return terminates it.
yield can resume; return cannot.

Published on 2023-08-27 at 孤筝の温暖小家, last modified on 2023-08-27

All articles on this blog are licensed under the BY-NC-SA license agreement unless otherwise stated. Please indicate the source when reprinting!

Code on 孤筝の温暖小家

MicroPython Function Library

MicroPython Function Library

Machine - Hardware Related Functions

Pin Class

machine.Pin(id, mode=None, pull=None, value)

Pin.init(mode=None, pull=None)

Pin.value([x])

Pin.toggle()

Pin.irq(handler=None, trigger=(Pin.IRQ_FALLING|PIN.IRQ_RISING))

Other Functions

Example: LED Control

PWM Class

machine.PWM(pin)

PWM.deinit()

PWM.freq([value])

PWM.duty_u16([value])

PWM.duty_ns([value])

Example: Breathing LED

ADC Class

machine.ADC(id)

ADC.read_u16()

Data Structure Lab Report 8 - Critical Path

Data Structure Lab Report 8 - Critical Path

a. Problem Analysis

b. Algorithm Design

1. Calculating Earliest Start Time

2. Calculating Latest Start Time

c. Data Structure Design

d. Debugging Process

e. Output Results

f. Source Code

Data Structure Lab Report 7 – Kruskal's Algorithm and the Minimum Spanning Tree Problem, Dijkstra's Algorithm and the Shortest Path Problem in Weighted Graphs

Data Structure Lab Report 7 – Kruskal's Algorithm and the Minimum Spanning Tree Problem, Dijkstra's Algorithm and the Shortest Path Problem in Weighted Graphs

Kruskal’s Algorithm for Generating Minimum Spanning Trees

a Problem Analysis

b Algorithm Design

Key Steps of Kruskal’s Algorithm:

Edge Sorting:

Union-Find Initialization:

Edge Traversal:

Implementation:

c Data Structure Design

1. Edge Struct:

2. UnionFind Class:

d Debugging Process

e Output

f Source Code

Dijkstra’s Algorithm for Solving Shortest Path in Weighted Graphs

a Problem Analysis

b Algorithm Design

1. Initialization

2. Priority Queue Setup

3. Main Loop

4. Termination

c Data Structure Design

1. Graph (Adjacency Matrix)

2. Distances Array

3. Priority Queue

d Debugging Process

e Output

f Source Code

Data Structure Lab Report 6 — Threading Binary Trees with Preorder and Postorder Traversals, Adjacency Matrix and Adjacency List Storage for Graphs

Data Structure Lab Report 6 — Threading Binary Trees with Preorder and Postorder Traversals, Adjacency Matrix and Adjacency List Storage for Graphs

Threading a Binary Tree in Pre-order and Post-order

a. Problem Analysis

b. Algorithm Design

c. Data Structure Design

d. Debugging Process

e. Output Result

f. Source Code

Adjacency Matrix and Adjacency List Storage for Graphs

a. Problem Analysis

b. Algorithm Design

Adjacency Matrix

Adjacency List

c. Data Structure Design

Adjacency Matrix

Adjacency List

d. Debugging Process

`machine.Pin(id, mode=None, pull=None, value)`

`Pin.init(mode=None, pull=None)`

`Pin.value([x])`

`Pin.toggle()`

`Pin.irq(handler=None, trigger=(Pin.IRQ_FALLING|PIN.IRQ_RISING))`

`machine.PWM(pin)`

`PWM.deinit()`

`PWM.freq([value])`

`PWM.duty_u16([value])`

`PWM.duty_ns([value])`

`machine.ADC(id)`

`ADC.read_u16()`