題目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;
}

很遺憾，我寫的代碼超出了規定的內存限制，因爲結點的信息是打亂之後輸入的，因此我的思路是先構建鏈表存儲所有的結點，然後根據地址對應關係構建存儲兩個單詞所需的鏈表，最後以這兩個鏈表爲基礎進行查找，但很明顯這種方法過於繁瑣了。在網上看了看其他人做的，突然醒悟，這道題其實沒必要用鏈表來存儲數據的，如果直接用一個結構體數組，我覺得應該能節省不少空間。