这里有我的更多内容
flowus

链表的数组表示

（为了方便调试以及不需要使用malloc而耗费较多的时间）

链表的的程序程序实现

#include <bits/stdc++.h>
using namespace std;
#define N 100
struct Node
{
    int value;
    int next, prev;
}node[N];
int tot, tail, head;
stack<int >st;
void Clear()
{
    memset(node, 0, sizeof(node));
    tot = tail = head = 0;
}
void Init()
{
    tot = 2;
    head = 1;
    tail = 2;
    node[head].next = tail;
    node[tail].prev = head;
}
void Insert(int p, int val)
{
    int s;
    if(st.size())
    {
        s = st.top();
        st.pop();
    }
    else
    {
        s = ++tot;
    }
    node[s].value = val;
    node[node[p].next].prev = s;
    node[s].next = node[p].next;
    node[p].next = s;
    node[s].prev = p;
}
void remove(int p)
{
    node[node[p].prev].next = node[p].next;
    node[node[p].next].prev = node[p].prev;
    st.push(p);
}
void trans()
{
    int p = node[head].next;
    while(p != tail)
    {
        printf("%d ", node[p].value);
        p = node[p].next;
    }
}
int find(int val)
{
    int p = head;
    while(p != tail)
    {
        if(node[p].value == val)
            return p;
        p = node[p].next;
    }
    return 0;
}
int main()
{
    /* 这里是测试用例 */
    Clear();
    Init();
    Insert(1, 3);
    Insert(1, 2);
    Insert(1, 1);
    Insert(find(3), 4);
    trans();
    remove(find(2));
    Insert(find(4), 5);
    trans();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

AcWing\136. 邻值查找

题面

这道题目让我想起了平衡二叉树，可以使用map进行实现

map的实现（$lo{g}_{2}N$）瓶颈在于插入以及查询。

1. 动态插入（为了后面的节点查询最近的值）
2. 查询前驱以及后继，算出来值

注意：使用set并不需要使用二分查找进行查找值，仅仅需要插入之后查找前驱以及后继就可以了；

错误分析：

set< pair<int, int> >::iterator it = st.find(make_pair(buf, i));
        int x = INT_MAX;
        int k = 0;
        if((++it) != st.end())//这里不需要进行比较大小.
        {
            x = (*it).first - buf;
            k = (*it).second;
            printf("\tright\t%d\n", (*it).first);
        }
        
        if((it--) != st.begin() && buf - (*it).first <= x)
        {
            x = buf - (*it).first;
            k = (*it).second;
            printf("\tleft\t%d\n", (*it).first);
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

我在设置了it之后，没有进行归零。

正确代码

#include <bits/stdc++.h>
using namespace std;
set<pair<int , int > >st;
int main()
{
    int buf, n;
    cin >> n;
    cin >> buf;
    st.insert(make_pair(buf, 1));
    for(int i = 2; i <= n; i++)
    {
        scanf("%d", &buf);
        st.insert(make_pair(buf, i));
        set< pair<int, int> >::iterator it = st.find(make_pair(buf, i));
        int x = INT_MAX;
        int k = 0;
        if((++it) != st.end())//这里不需要进行比较大小.
        {
            x = (*it).first - buf;
            k = (*it).second;
            //printf("\tright\t%d\n", (*it).first);
        }
        it = st.find(make_pair(buf, i));
        if((it--) != st.begin() && buf - (*it).first <= x)
        {
            x = buf - (*it).first;
            k = (*it).second;
            //printf("\tleft\t%d\n", (*it).first);
        }
        printf("%d %d\n", x, k);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

链表的实现（$lo{g}_{2}N$）瓶颈在于排序。

1. 链表是线性结构。插入以及删除是O（1）的时间复杂度。
2. 但是不支持随机插入，可是删除却很快。
3. 需要删除的指针可以在开始一链表的形式初始化好。
4. 总结：
   • 链表插入删除快
   • 链表查找一个元素难
   • 链表在前期通过维护指针，可以快速找已经在链表里的

这道题使用链表的精髓就在于按照顺序排序，然后根据输入的顺序倒过来根据指针数组查找在链表里面找到前驱以及后继。

注意：数组链表在实际使用的过程中，可以直接串成链表，而不用像数据结构实验课那样进行头插法以及尾插法

错误分析：我漏掉了一句话：A 中的数各不相同。

正确代码

#include <bits/stdc++.h>
using namespace std;
#define N 100006
pair<int, int>s[N];
stack<int >output;
struct Node{
    int order;
    int value;
    int next, prev;
}node[N];
struct Ans{
    int x, k;
}ans[N];
int tail, head, tot;
int pos[N];
void Init()
{
    tot = 2;
    head = 1;
    tail = 2;
    node[head].next = tail;
    node[tail].prev = head;
}
void headinsert(int x, int yingshe)
{
    int s = ++tot;
    node[s].value = x;
    node[s].next = node[head].next;
    node[node[head].next].prev = s;
    node[head].next = s;
    node[s].prev = head;
    pos[yingshe] = s;
    node[s].order = yingshe;
}
int main()
{
    Init();
    int n;
    cin >> n;
    for(int i = 1; i <= n; i++)
    {
        scanf("%d", &s[i].first);
        s[i].second = i;
    }
    sort(s+1, s+1+n);
    for(int i = n; i >= 1; i--)
    {
        headinsert(s[i].first, s[i].second);
    }
    //for(int i = n+2; i>= 3; i--)
    //    printf("%d ", node[i].value);
    //putchar('\n');
    for(int i = n; i >= 2; i--)
    {
        int p = pos[i];
        if(node[p].next == tail)
        {
            ans[i].x = node[p].value - node[node[p].prev].value;
            ans[i].k = node[node[p].prev].order;
        }
        else if(node[p].prev == head)
        {
            ans[i].x = node[node[p].next].value - node[p].value;
            ans[i].k = node[node[p].next].order;
        }
        else
        {
            ans[i].x = node[node[p].next].value - node[p].value;//右面的
            ans[i].k = node[node[p].next].order;
            if(node[p].value - node[node[p].prev].value <=node[node[p].next].value - node[p].value)
            {
                ans[i].x = node[p].value - node[node[p].prev].value;
                ans[i].k = node[node[p].prev].order;
            }
        }
        node[node[p].prev].next = node[p].next;
        node[node[p].next].prev = node[p].prev;
    }
    for(int i = 2; i <= n; i++)
    {
        printf("%d %d\n", ans[i].x, ans[i].k);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84