在链串上实现判断两个串是否相等的功能

链串可以通过遍历每个节点，逐个比较每个字符来判断两个串是否相等。

具体实现步骤如下：

1. 判断两个链串的长度是否相等，如果不相等，则两个串一定不相等，直接返回 false。
2. 分别定义两个指针 p 和 q，分别指向两个链串的头节点。
3. 逐个比较每个节点的值是否相等，如果存在不相等的节点，则两个串不相等，直接返回 false。
4. 如果遍历完链串后，没有返回 false，则说明两个链串相等，返回 true。

以下是示例代码：

bool isEqual(LinkStrNode* s, LinkStrNode* t) {
    int len1 = s->length;
    int len2 = t->length;
    if (len1 != len2) {
        return false;
    }
    LinkStrNode *p = s->next;
    LinkStrNode *q = t->next;
    while (p != nullptr && q != nullptr) {
        if (p->data != q->data) {
            return false;
        }
        p = p->next;
        q = q->next;
    }
    return true;
}

相关问题

设计一个算法Equal()，在链串上实现判断两个串是否相等的功能

算法思路：

首先比较两个链串的长度是否相等，若不相等，则两个串一定不相等；若相等，则逐个比较两个链串中的每个字符是否相等，若有不相等的字符，则两个串不相等，否则两个串相等。

算法步骤：

1. 定义一个函数Equal(str1, str2)，其中str1和str2分别表示两个链串的头节点指针；
2. 定义两个指针p1和p2，分别指向str1和str2；
3. 定义两个变量len1和len2，分别表示str1和str2的长度；
4. 如果len1不等于len2，则返回false；
5. 从头节点开始，逐个比较p1和p2指向的字符是否相等，如果有不相等的字符，则返回false；
6. 如果比较完所有字符都相等，则返回true。

算法实现：

bool Equal(LinkStrNode *str1, LinkStrNode *str2) {
    LinkStrNode *p1 = str1, *p2 = str2;
    int len1 = 0, len2 = 0;
    while (p1->next != NULL) {
        len1++;
        p1 = p1->next;
    }
    while (p2->next != NULL) {
        len2++;
        p2 = p2->next;
    }
    if (len1 != len2) {
        return false;
    }
    p1 = str1->next;
    p2 = str2->next;
    while (p1 != NULL && p2 != NULL) {
        if (p1->data != p2->data) {
            return false;
        }
        p1 = p1->next;
        p2 = p2->next;
    }
    return true;
}

用devc++编写设计一个算法Equal()，在链串上实现判断两个串是否相等的功能。 （1）S1=“a,b,c,d,e,c,f”；S2=“a,b,c,d,e,c,f”。（2）S1=“a,b,c,d,e”；S2=“a,b,c,d,c”。

#include<stdio.h>
#include<stdlib.h>

typedef struct node{
    char data; // 存储字符
    struct node *next; // 指向下一个节点的指针
}Node, *LinkString;

// 初始化链串
void Init(LinkString &L){
    L = (LinkString)malloc(sizeof(Node)); // 申请头结点空间
    L->next = NULL; // 头结点初始指向为空
}

// 插入字符
void Insert(LinkString &L, char c){
    Node *p = (Node *)malloc(sizeof(Node)); // 申请新节点
    p->data = c; // 新节点存储字符
    p->next = L->next; // 新节点指向原头结点的下一个节点
    L->next = p; // 头结点指向新的头节点
}

// 判断两个链串是否相等
bool Equal(LinkString L1, LinkString L2){
    Node *p1 = L1->next, *p2 = L2->next; // 分别指向两个链串的第一个节点
    while(p1 && p2){ // 两个链串都没有遍历结束
        if(p1->data != p2->data){ // 发现字符不相同
            return false;
        }
        p1 = p1->next; // 遍历下一个节点
        p2 = p2->next;
    }
    if(p1 == NULL && p2 == NULL){ // 两个链串都遍历结束
        return true;
    }
    else{ // 两个链串长度不相等
        return false;
    }
}

int main(){
    LinkString L1, L2;
    Init(L1);
    Init(L2);

    Insert(L1, 'f');
    Insert(L1, 'c');
    Insert(L1, 'e');
    Insert(L1, 'd');
    Insert(L1, 'c');
    Insert(L1, 'b');
    Insert(L1, 'a');

    Insert(L2, 'f');
    Insert(L2, 'c');
    Insert(L2, 'e');
    Insert(L2, 'd');
    Insert(L2, 'c');
    Insert(L2, 'b');
    Insert(L2, 'a');

    if(Equal(L1, L2)){
        printf("两个链串相等\n");
    }
    else{
        printf("两个链串不相等\n");
    }

    return 0;
}