2021年4.19TX笔试题第一题题解

最小字典序的旋转链表

有一个无环的单链表，可以将单链表进行旋转。
比如链表：1-2-3-4
经过旋转后可以得到以下链表：
2-3-4-1
3-4-1-2
4-1-2-3
1-2-3-4
要求找到最小字典序的链表！

输入例子:

{2，2，5，2，2}

输出例子：

{2，2，2，2，5}

思路

将链表值存入数组。

遍历数组，找到最小的值，如果有唯一的最小值，则此最小值作为头结点的链表具有最小字典序。

如果有多个最小值，保存所有最小值的下标i。遍历每一个下标i，找到i+1下标对应的最小值。重复这一步骤，直到找到唯一的最小值。

遍历时记录后移的次数，唯一的最小值的下标减去后移次数，即为最小字典序链表的头结点。（注意数组下标越界）

最后将链表连接成环，再从头结点前截断即可。

代码

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct ListNode {
    int val;
    struct ListNode* next;
};

void show(ListNode* s)
{
    while (s != nullptr)
    {
        cout << s->val << "->";
        s = s->next;
    }
    cout << endl;    
}
int main()
{
    ListNode* S = new ListNode();
    int z;
    ListNode* setup = S;
    ListNode* Node = nullptr;
    while (cin >> z)
    {
        Node = setup;
        setup->val = z;
        setup->next = new ListNode();
        setup = setup->next;
    }
    if (Node == nullptr)
        S = nullptr;
    else
        Node->next = nullptr;
    int countz = 0;
    vector<int> num;
    Node = S;
    ListNode* weiba = nullptr;
    if (S == nullptr)
    {
        cout << "空链表";
        return 0;
    }
    else
    {
        cout << "原始链表：";
        show(S);
    }  
    while (Node != nullptr)
    {
        num.push_back(Node->val);
        weiba = Node;
        Node = Node->next;
    }
    vector<int> vec;
    for (int i = 0; i < num.size(); i++)
    {
        if (vec.size() == num.size())
        {
            show(S);
            return 1;
        }
        if (vec.size() == 1)
            break;
        vector<int> newVec;
        int minValue = INT_MAX;
        if (vec.size() == 0)
        {
            for (int i = 0; i < num.size(); i++)
            {
                minValue = min(minValue, num[i]);
            }
            for (int i = 0; i < num.size(); i++)
            {
                if (minValue == num[i])
                {
                    newVec.push_back(i);
                }
            }
        }
        else
        {
            for (int i = 0; i < vec.size(); i++)
            {
                minValue = min(minValue, num[(vec[i] + 1) % num.size()]);
            }
            for (int i = 0; i < vec.size(); i++)
            {
                if (minValue == num[(vec[i] + 1) % num.size()])
                {
                    newVec.push_back((vec[i] + 1) % num.size());
                }
            }
            countz++;
        }
        vec.resize(newVec.size());
        copy(newVec.begin(), newVec.end(), vec.begin()); 
    }
    int index = vec[0] - countz >= 0 ? vec[0] - countz : vec[0] - countz + num.size();
    if (index == 0)
    {
        show(S);
        return 2;
    }
    else
    {
        weiba->next = S;
        Node = S;
        while (index--)
        {
            weiba = Node;
            Node = Node->next;
        }
        weiba->next = nullptr;
        show(Node);
        return 3;
    }
}

笔试时只A了50%。也没时间去检查。如果帮忙指出错误的地方，不胜感激。