Data Structures on 孤筝の温暖小家

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!