题目1468：Sharing

Problem:

Solution:

题目的意思让我们找出以链表存储的单词的公用存储区，也就是找其公共后缀开始的地方。先要构建两个链表分别存储两个单词，由于两个单词的长度是不相等的，要使它们的末尾对齐，那么必然要先对长的单词进行遍历，直到长单词剩余部门和短单词等长，然后开始对比它们的地址，如果相等，那么从此处开始就是它们的公共存储区了。

#include <iostream>
#include <string>
#include <stdlib.h>

using namespace std;

typedef struct LNode
{
    char val;
    LNode *next;
    int addr;
    int addr_next;
} LNode,*LinkList;

int main()
{
    LNode* head = (LNode*) malloc(sizeof(LNode));
    LNode* head1 = (LNode*) malloc(sizeof(LNode));
    LNode* head2 = (LNode*) malloc(sizeof(LNode));
    int input_1,input_2,input_3;
    while(cin >> input_1,cin >> input_2,cin >> input_3)
    {
        head1 -> addr_next = input_1;
        head2 -> addr_next = input_2;
        LNode* p = head;
        LNode* search_1,*search_2;
        LNode* temp1 = head1;
        LNode* temp2 = head2;
        int len1 = 0,len2 = 0;
        for (int i = 0;i < input_3;i++)
        {
            int elem1, elem3;
            char elem2;
            LNode *s = (LNode *) malloc(sizeof(LNode));
            cin >> elem1,cin >> elem2,cin >> elem3;
            s->addr = elem1;
            s->val = elem2;
            s->addr_next = elem3;
            p -> next = s;
            p = s;
        }
        p -> next = NULL;
        while(temp1 -> addr_next != -1)
        {
            search_1 = head;
            while (search_1 != NULL)
            {
                if(search_1 -> addr == temp1 ->addr_next)
                {
                    LNode* t = (LNode*)malloc(sizeof(LNode));
                    t ->next = search_1->next;
                    t->val = search_1->val;
                    t->addr = search_1->addr;
                    t->addr_next = search_1->addr_next;
                    temp1 -> next = t;
                    temp1 = t;
                    len1++;
                    break;
                }
                search_1 = search_1->next;
            }

        }
        while(temp2 -> addr_next != -1)
        {
            search_2 = head;
            while (search_2 != NULL)
            {
                if(search_2 -> addr == temp2 ->addr_next)
                {
                    LNode* t = (LNode*)malloc(sizeof(LNode));
                    t ->next = search_2->next;
                    t->val = search_2->val;
                    t->addr = search_2->addr;
                    t->addr_next = search_2->addr_next;
                    temp2 -> next = t;
                    temp2 = t;
                    len2++;
                    break;
                }
                search_2 = search_2->next;
            }

        }
        temp1 = head1->next;
        temp2 = head2->next;
        while (len1 != len2)
        {
            if (len1 > len2)
            {
                len1--;
                temp1 = temp1->next;
            }
            else
            {
                len2--;
                temp2 = temp2->next;
            }
        }
        while (temp1!= NULL && temp2!=NULL)
        {
            if (temp1->addr == temp2->addr)
            {
                cout << temp1->addr<<endl;
                break;
            }
            temp1 = temp1->next;
            temp2 = temp2->next;
        }
        if (temp1 == NULL || temp2 == NULL) cout<< -1 <<endl;
    }
    free(head);
    free(head1);
    free(head2);
    return 0;
}

很遗憾，我写的代码超出了规定的内存限制，因为结点的信息是打乱之后输入的，因此我的思路是先构建链表存储所有的结点，然后根据地址对应关系构建存储两个单词所需的链表，最后以这两个链表为基础进行查找，但很明显这种方法过于繁琐了。在网上看了看其他人做的，突然醒悟，这道题其实没必要用链表来存储数据的，如果直接用一个结构体数组，我觉得应该能节省不少空间。