#include<iostream>
using namespace std;
int link[100001];
int Data[100001];
bool mark[10001];
int main() {
????int begin;
????int N;
????cin >> begin >> N;
????int temp1;
????for (int i = 0; i < N; i++) {
????????cin >> temp1;
????????cin >> Data[temp1] >> link[temp1];
????}
????int tempAdd = begin;
????int advance = -1;
????int deleteStart = -1;
????int deleteCurrent = -1;
????while (tempAdd != -1) {
????????int value = Data[tempAdd];
????????if (value < 0) {
????????????value = -value;
????????}
????????if (!mark[value]) {
????????????mark[value] = true;
????????????advance = tempAdd;
????????????tempAdd = link[tempAdd];
????????}
????????else {
????????????if (deleteStart == -1) {
????????????????deleteStart = tempAdd;
????????????????deleteCurrent = tempAdd;
????????????}
????????????else {
????????????????link[deleteCurrent] = tempAdd;
????????????????deleteCurrent = tempAdd;
????????????}
????????????link[advance] = link[tempAdd];
????????????tempAdd = link[tempAdd];
????????}
????????
????}
????link[deleteCurrent] = -1;
????int coutAdd = begin;
????int coutDel = deleteStart;
????while (coutAdd != -1) {
????????printf("%05d %d ", coutAdd, Data[coutAdd]);
????????if (link[coutAdd] == -1) {
????????????printf("%d\n", link[coutAdd]);

????????}
????????else {
????????????printf("%05d\n", link[coutAdd]);
????????}
????????coutAdd = link[coutAdd];
????}
????while (coutDel != -1) {
????????printf("%05d %d ", coutDel, Data[coutDel]);
????????if (link[coutDel] == -1) {
????????????printf("%d\n", link[coutDel]);
????????}
????????else {
????????????printf("%05d\n", link[coutDel]);
????????}
????????coutDel = link[coutDel];
????}
????//cin >> coutAdd;
}

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		String headAddress = in.next();
		int n = in.nextInt();
		Map<String, Node> map = new HashMap<String, Node>();
		Set<Integer> set = new HashSet<Integer>();
		for(int i = 0;i<n;i++){
			String address = in.next();
			int val = in.nextInt();
			String nextAddress = in.next();
			map.put(address, new Node(address,val,nextAddress));
		}
		Node head = map.get(headAddress);
        set.add(Math.abs(head.val));
		Node head2 = new Node();
		Node cur = head;
		Node cur2 = head2;
		String nextAddress = head.nextAddress;
		while(!nextAddress.equals("-1")){
			Node next = map.get(nextAddress);
			if(set.add(Math.abs(next.val))){
				cur.next = next;
				cur = next;
			}else{
				cur2.next = next;
				cur2 = next;
			}
			nextAddress = next.nextAddress;
		}
		print(head);
		print(head2.next);
	}
    private static void print(Node head){
		while(head!=null){
			System.out.print(head.address+" "+head.val+" ");
			if(head.next==null){
				System.out.println(-1);
				break;
			}else{
				System.out.println(head.next.address);
			}
			head = head.next;
		}
	}
	private static class Node{
		String address;
		int val;
		String nextAddress;
		Node next;
		
		public Node() {}

		public Node(String address, int val,String nextAddress) {
			this.address = address;
			this.val = val;
			this.nextAddress = nextAddress;
		}
	}
}

#include <iostream>
#include <cstring>
#include <string>

using namespace std;

int a[1000000];
int Next[1000000];
bool c[10005];

int main()
{ ????int n,head; ????cin>>head>>n; ????for(int i=0;i<n;i++) ????{ ????????int x; ????????cin>>x; ????????cin>>a[x]>>Next[x]; ????} ????int h1=-1,h2=-1,t1=-1,t2=-1; ????for(;head>=0;head=Next[head]) ????{ ????????int x = (a[head]>=0?a[head]:-a[head]); ????????if(c[x]) ????????{ ????????????if(t2<0) ????????????????h2 = t2 = head; ????????????else ????????????????t2 = Next[t2] = head; ????????}else{ ????????????c[x] = true; ????????????if(t1<0) ????????????????h1 = t1 = head; ????????????else ????????????????t1 = Next[t1] = head; ????????} ????} ????if(t1>=0) ????{ ????????Next[t1] = -1; ????????for(head=h1;head>=0;head=Next[head]) ????????{ ????????????printf("%05d %d",head,a[head]); ????????????if(Next[head]>=0) ????????????????printf(" %05d\n",Next[head]); ????????????else ????????????????printf(" -1\n"); ????????} ????} ????if(t2>=0) ????{ ????????Next[t2] = -1; ????????for(head=h2;head>=0;head=Next[head]) ????????{ ????????????printf("%05d %d",head,a[head]); ????????????if(Next[head]>=0) ????????????????printf(" %05d\n",Next[head]); ????????????else ????????????????printf(" -1\n"); ????????} ????} ????return 0;
}

	

#include <iostream>
#include <algorithm>
using namespace std;
const int maxn=100010;
struct Node{
    int next,key;
}node[maxn];
int print[maxn],deleted[maxn],dup[maxn]={0};???????????????????? //定義一個(gè)保留一個(gè)刪除一個(gè)已重復(fù)（hash)數(shù)組
int main(){
    int head,n,adress;
?   cin>>head>>n;
    for(int i=0;i<n;i++){
        cin>>adress;
        cin>>node[adress].key>>node[adress].next;
    }  int p=0,q=0;
    for(adress=head;adress!=-1;adress=node[adress].next){?????? //按題目給出的首地址遍歷鏈表（排除不在鏈表上的無效結(jié)點(diǎn)）
??      int key=abs(node[adress].key);????????????????????????? //結(jié)點(diǎn)絕對(duì)值
??      if(dup[key]==0){??????????????????????????????????????? //第一次遍歷到這個(gè)key的絕對(duì)值，入保留數(shù)組并修改hash數(shù)組標(biāo)記
???         dup[key]=1;
???         print[p++]=adress;
??      }
??      else deleted[q++]=adress;?????????????????????????????? //并非第一次遍歷到這個(gè)key的絕對(duì)值，入刪除數(shù)組
    }
    for(int i=0;i<p;i++){
??      printf("%05d %d ",print[i],node[print[i]].key);
??      if(i!=p-1) printf("%05d\n",print[i+1]);
??      else printf("-1\n");??????????????????????????????????? //注意鏈尾輸出
    }
    for(int i=0;i<q;i++){
??      printf("%05d %d ",deleted[i],node[deleted[i]].key);
??      if(i!=q-1) printf("%05d\n",deleted[i+1]);
??      else printf("-1\n");
    }
    return 0;
} 
 

• 講道理就這么簡單的鏈表刪除操作，大家都還得搞半天，我覺得主要是因?yàn)檫@個(gè)輸出實(shí)在是***?。?！好我依你的，地址按照5位輸出，不足補(bǔ)0，好家伙，-1又變成特例！??

題目很簡單，就普通的靜態(tài)鏈表的刪除操作。---輸出很***

#include<bits/stdc++.h>
#define MaxN 100000
using namespace std;
int head, rm_head = -1; //分別用于存儲(chǔ)兩個(gè)鏈表的頭結(jié)點(diǎn)地址
int N;

struct node {
    int val;
    int next;

    node() : val(0), next(-1) {}
} linklist[MaxN];

queue<int> St; //存儲(chǔ)被刪除結(jié)點(diǎn)的地址
bitset<MaxN> check(0); //用于查重

//輸入和構(gòu)建鏈表
void Input() {
    scanf("%d%d", &head, &N);
    int c = N;
    while (c--) {
        int addr, val, next;
        scanf("%d%d%d", &addr, &val, &next);
        linklist[addr].val = val;
        linklist[addr].next = next;
    }
}

//處理鏈表的去重問題
void handle() {
    //正常刪除鏈表結(jié)點(diǎn)的處理方式
    int pre = head;
    check[abs(linklist[head].val)] = 1;
    for (int i = linklist[pre].next; i != -1; i = linklist[i].next) {
        int val = abs(linklist[i].val);
        if (!check[val]) {
            check[val] = 1;
            pre = i;
        }//一旦出現(xiàn)重復(fù)結(jié)點(diǎn)，把這個(gè)結(jié)點(diǎn)刪除就行，刪除結(jié)點(diǎn)的操作需要雙指針輔助
        else {
            linklist[pre].next = linklist[i].next;
            St.push(i);
        }
    }
    if (St.empty())
        return;
    //根據(jù)隊(duì)列進(jìn)行正確連接
    int num = St.front();
    St.pop();
    rm_head = num;
    while (!St.empty()) {
        linklist[num].next = St.front();
        num = linklist[num].next;
        St.pop();
    }
    linklist[num].next = -1;
}

//打印鏈表即可---注意小坑--(地址打印五位數(shù)字，少了補(bǔ)0,-1時(shí)不能打印五位數(shù))
void print() {
    handle();
    for (int i = head; i != -1; i = linklist[i].next) {
        if (linklist[i].next != -1)
            printf("%05d %d %05d\n", i, linklist[i].val, linklist[i].next);
        else {
            printf("%05d %d %d", i, linklist[i].val, linklist[i].next);
        }
    }
    if (rm_head == -1)
        return;
    printf("\n");
    for (int i = rm_head; i != -1; i = linklist[i].next) {
        if (linklist[i].next != -1)
            printf("%05d %d %05d\n", i, linklist[i].val, linklist[i].next);
        else {
            printf("%05d %d %d", i, linklist[i].val, linklist[i].next);
        }
    }
}

int main() {
    Input();
    print();
    return 0;
}

#include<bits/stdc++.h>
using?namespace?std;
int?ne[100000];
int?flag[100005];
vector<int>result;
vector<int>mv;
map<int,int>mp;
int?main(){
????int?head,n;
????cin>>head>>n;
????int?a,b,c;
????for(int?i=0;i<n;i++){
????????cin>>a>>b>>c;
????????ne[a]=c;
????????mp[a]=b;
????}
????int?now=head;
????for(int?i=0;i<n;i++){
????????if(flag[int(abs(mp[now]))]){
????????????mv.push_back(now);
????????}else{
????????????result.push_back(now);
????????????flag[int(abs(mp[now]))]=1;
????????}
????????now=ne[now];
????}
????for(int?i=0;i<result.size()-1;i++){
????????printf("%05d?%d?%05d\n",result[i],mp[result[i]],result[i+1]);
????}
????printf("%05d?%d?%d\n",result[result.size()-1],mp[result[result.size()-1]],-1);
????for(int?i=0;i<mv.size()-1;i++){
????????printf("%05d?%d?%05d\n",mv[i],mp[mv[i]],mv[i+1]);
????}
?????printf("%05d?%d?%d",mv[mv.size()-1],mp[mv[mv.size()-1]],-1);
}

#include?<iostream>
#include?<algorithm>
#include?<vector>
#include?<map>
using?namespace?std;
vector<string>?contain;
vector<string>?rp;
map<string,?vector<string>>?tab;
map<string,?string>?temp;
string?ad;
void?DL(){
????string?fad=ad,tad=ad;
????int?i=0;
????while?(tad!="-1")?{
????????if?(temp.find(to_string(abs(stoi(tab[tad][0]))))!=temp.end())?{
????????????tab[fad][1]=tab[tad][1];
????????????rp.push_back(tad);
????????????i=1;
????????}else{
????????????temp[to_string(abs(stoi(tab[tad][0])))]=1;
????????}
????????if?(i==0)?{
????????????fad=tad;
????????}
????????i=0;
????????tad=tab[tad][1];
????}
}
int?main(int?argc,?const?char?*?argv[])?{
????string?fad,contant,nad;
????int?n;
????cin>>ad>>n;
????for?(int?i=0;?i<n;?i++)?{
????????cin>>fad>>contant>>nad;
????????contain.push_back(contant);
????????contain.push_back(nad);
????????tab[fad]=contain;
????????contain.clear();
????}
????DL();
????
????for?(int?i=0;?i<rp.size()-1;?i++)?{
????????tab[rp[i]][1]=rp[i+1];
????}
????tab[*(rp.end()-1)][1]="-1";
????while?(ad!="-1")?{
????????cout<<ad<<"?"<<tab[ad][0]<<"?"<<tab[ad][1]<<endl;
????????ad=tab[ad][1];
????}
????ad=rp[0];
????while?(ad!="-1")?{
????????cout<<ad<<"?"<<tab[ad][0]<<"?"<<tab[ad][1]<<endl;
????????ad=tab[ad][1];
????}
????return?0;
}

//想要映射關(guān)系
#include<iostream>
#include<vector>
#include<unordered_map>
using?namespace?std;

unordered_map<string,int>e;
unordered_map<string,string>ne;
unordered_map<string,string>pre;
unordered_map<int,int>val;
vector<pair<string,string>>?str;
vector<int>vt;
int?idx=1;

void?insert(int?x,string?addre,string?neadd){??????//插入
????e[addre]=x;
????//jec_pos[idx]=addre;
????ne[addre]=neadd;
????pre[neadd]=addre;
}


int?main(){
????string?ini,s,end,ini2;
????cin>>ini;
????int?n,x;
????ini2=ini;
????cin>>n;
????while(n--){??//排序
????????cin>>s>>x>>end;
????????insert(x,s,end);
????}

????while(ne[ini]!="-1"){???//處理
????????int?t=e[ini];
????????if(val[abs(t)]>0)?{
????????????ne[pre[ini]]=ne[ini];??//雙向鏈表，不要的時(shí)候，將前后兩個(gè)節(jié)點(diǎn)連接
????????????pre[ne[ini]]=pre[ini];
????????????vt.push_back(t);
????????????str.push_back({ini,ne[ini]});
????????}
????????val[abs(t)]++;
????????ini=ne[ini];
????}
????int?t=e[ini];
????if(val[abs(t)]>0)?{

????????????ne[pre[ini]]=ne[ini];
????????????pre[ne[ini]]=pre[ini];
????????????vt.push_back(t);
????????????str.push_back({ini,ne[ini]});
????}
????ini=ini2;???//恢復(fù)初始節(jié)點(diǎn)
????while(ne[ini]!="-1"){
????????cout<<ini<<"?"<<e[ini]<<"?"<<ne[ini]<<endl;
????????ini=ne[ini];
????}
????cout<<ini<<"?"<<e[ini]<<"?"<<"-1"<<endl;


????for(int?i=0;i<str.size();i++){
????????if(i==str.size()-1){
????????????cout<<str[i].first<<"?"<<vt[i]<<"?"<<"-1"<<endl;
????????}
????????else?cout<<str[i].first<<"?"<<vt[i]<<"?"<<str[i+1].first<<endl;
????}

????return?0;
}


作者：magpie
鏈接：https://www.acwing.com/solution/content/27535/
來源：AcWing
著作權(quán)歸作者所有。商業(yè)轉(zhuǎn)載請(qǐng)聯(lián)系作者獲得授權(quán)，非商業(yè)轉(zhuǎn)載請(qǐng)注明出處。

#include?<iostream>
#include?<unordered_map>
#include?<vector>
using?namespace?std;
const?int?MAX?=?1e5;
unordered_map<string,?string>?Next;
unordered_map<string,?int>?value;
vector<pair<string,?int>>?link,?removeLink;
bool?vis[MAX];
int?main()
{
????ios::sync_with_stdio(false);
????string?start;
????int?n;
????cin?>>?start?>>?n;
????while?(n--)
????{
????????string?current,?next;
????????int?val;
????????cin?>>?current?>>?val?>>?next;
????????Next[current]?=?next;
????????value[current]?=?val;
????}
????string?tmp;?//指向上一個(gè)沒有重復(fù)的結(jié)點(diǎn)
????for?(string?cur?=?start;?cur?!=?"-1";?cur?=?Next[cur])
????{
????????if?(!vis[abs(value[cur])])
????????{
????????????link.push_back({cur,?value[cur]});
????????????tmp?=?cur;
????????}
????????else
????????{
????????????removeLink.push_back({cur,?value[cur]});
????????????Next[tmp]?=?Next[cur];?//結(jié)點(diǎn)重復(fù)刪去，并使上一個(gè)結(jié)點(diǎn)指向該重復(fù)結(jié)點(diǎn)的下一個(gè)結(jié)點(diǎn)
????????}
????????vis[abs(value[cur])]?=?true;
????}
????//cout?<<?"-----------------------"?<<?endl;
????for?(auto?ans?:?link)
????????cout?<<?ans.first?<<?"?"?<<?ans.second?<<?"?"?<<?Next[ans.first]?<<?endl;
????for?(int?i?=?0;?i?<?removeLink.size();?i++)
????????cout?<<?removeLink[i].first?<<?"?"?<<?removeLink[i].second?<<?"?"?<<?(i?+?1?<?removeLink.size()???removeLink[i?+?1].first?:?"-1")?<<?endl;
}

使用list的解法

PAT 的測試點(diǎn)1考察**測試點(diǎn)1 考察的是有多余無用的結(jié)點(diǎn)，可以考慮下面的測試點(diǎn)，看是否能通過**

87654 3
99999 -7 87654
23854 -15 00000
87654 15 -1

**測試點(diǎn)2  考察沒有重復(fù)的元素**
下面的代碼
#include 
(849)#include 
using namespace std;
#include 
(849)#include 
#include 
struct node
{
    int data;
    int pos;
    int next;
    node():next(-1) {}
};
int sign[100002];
int main()
{
    int start,N;
    cin>>start>>N;

    //使用Map保存結(jié)點(diǎn)的信息
    unordered_map mapPos;
    unordered_map mapData;

    for(int i=0; i<N; i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        mapPos[a]=c;
        mapData[a]=b;
    }
        //構(gòu)建鏈表
    list duo;
    for(int i=0; i<N; i++)
    {   
        //start是關(guān)鍵
        int data=mapData[start];
        int next=mapPos[start];
        node *p=new node();
        p->pos=start;
        p->data=data;
        p->next=next;
        duo.push_back(p);
        start=next;

        //測試點(diǎn)1 就是考察你有多余的元素，PAT之前就考察過這樣的測試點(diǎn)
        if(p->next==-1)
            break;
    }

    list shao;
    //去重
    for(auto it=duo.begin(); it!=duo.end(); it++)
    {
        node *p=*it;
        int data=p->data;
        //判斷
        if(data<0)
            data*=-1;
        if(sign[data]==0)
        {
            //第一次出現(xiàn)
            sign[data]=1;
        }
        else
        {
            //第二次出現(xiàn)了，需要把這個(gè)結(jié)點(diǎn)剔除了

            shao.push_back(p);
            //需要吧迭代器保存到另一個(gè)變量中
            auto dele=it;
            //迭代器-- 否則以erase 迭代器就失效了
            it--;
            duo.erase(dele);
        }
    }

    //逆遍歷鏈表，設(shè)置每個(gè)結(jié)點(diǎn)的next
    for(auto it =duo.rbegin(); it!=duo.rend(); it++)
    {
        if(it==duo.rbegin())
        {
            start=(*it)->pos;
            (*it)->next=-1;
        }
        else
        {
            (*it)->next=start;
            start=(*it)->pos;
        }
    }
    for(auto it =shao.rbegin(); it!=shao.rend(); it++)
    {
        if(it==shao.rbegin())
        {
            start=(*it)->pos;
            (*it)->next=-1;
        }
        else
        {
            (*it)->next=start;
            start=(*it)->pos;
        }
    }
    for(auto it=duo.begin(); it!=duo.end(); it++)
    {
        node *p=*it;
        //coutposdatanext<<endl;
        if(p->next==-1)
            printf("%05d %d %d\n",p->pos,p->data,p->next);
        else
            printf("%05d %d %05d\n",p->pos,p->data,p->next);
    }
    for(auto it=shao.begin(); it!=shao.end(); it++)
    {
        node *p=*it;
        //coutposdatanext<<endl;
        if(p->next==-1)
            printf("%05d %d %d\n",p->pos,p->data,p->next);
        else
            printf("%05d %d %05d\n",p->pos,p->data,p->next);
    }
    return 0;
}

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
public class lianbiao { ????static String start,a,b; ????static Map<String,Node> map; ????static int n,c; ????static Set<Integer> set; ????public static void main(String[] args) { ????????// TODO Auto-generated method stub ????????Scanner sc = new Scanner(System.in); ????????start = sc.next(); ????????n = sc.nextInt(); ????????map = new HashMap<String,Node>(); ????????set = new HashSet<Integer>(); ????????for(int i=0;i<n;i++) ????????{ ????????????a = sc.next(); ????????????c = sc.nextInt(); ????????????b = sc.next(); ????????????map.put(a, new Node(a,c,b)); ????????} ????????Node head1 = map.get(start); ????????set.add(Math.abs(head1.val)); ????????Node head2 = new Node(); ????????Node now1 = head1; ????????Node now2 = head2; ????????b = head1.nextadd; ????????while(!b.equals("-1")) ????????{ ????????????Node n = map.get(b); ????????????if (set.add(Math.abs(n.val))) ????????????{ ????????????????now1.next = n; ????????????????now1 = n; ????????????} ????????????else ????????????{ ????????????????now2.next = n; ????????????????now2 = n; ????????????} ????????????b = n.nextadd; ????????} ????????print(head1); ????????print(head2.next); ????} ????private static class Node ????{ ????????String add,nextadd; ????????int val; ????????Node next; ????????public Node() ????????{ ???????????? ????????} ????????public Node(String add,int val,String nextadd){ ????????????this.add = add; ????????????this.val = val; ????????????this.nextadd = nextadd; ????????} ????} ????private static void print(Node st) ????{ ????????while(st!=null) ????????{ ????????????System.out.print(st.add+" "+st.val+" "); ????????????if(st.next==null) ????????????{ ????????????????System.out.println(-1); ????????????????break; ????????????} ????????????else ????????????{ ????????????????System.out.println(st.next.add); ????????????} ????????????st = st.next; ????????} ????}
}

思路：花了一下午的時(shí)間認(rèn)識(shí)到了  vector erase的效率是多么低下，只有最后一個(gè)不過，不
甘心，然后減枝條然后就 把vector 換成 deque了
vector 是連續(xù)的 deque 也是連續(xù)的但是存有二級(jí)指針。似乎沒有人使用 list  改天遇到在研究一下。
#include <iostream>
#include <vector>
#include <math.h>
#include <fstream>
#include <string>
#include <algorithm>
#include <iomanip>
#include <deque>
using namespace std;

#define debug
#ifdef debug
ifstream ifile("case.txt");
#define cin ifile
#endif


int mark[10003] = { 0 };
int list1[100001] = { 0 };
int list2[100001] = { 0 };
struct list
{
?? ?int adr;
?? ?int number;
?? ?int nexAdr;
?? ?int count;
?? ?bool operator==(const int & l)
?? ?{
?? ??? ?return abs(this->number) == abs(l);
?? ?}
};


void Replace(deque<struct list> & v, int startAdr)
{
?? ?int i;
?? ?struct list tmp;
?? ?for (i = startAdr; list2[i]!= -1 ; i = list2[i])
?? ?{
?? ??? ?tmp.adr = i;
?? ??? ?tmp.number = list1[i];
?? ??? ?tmp.nexAdr = list2[i];
?? ??? ?v.push_back(tmp);
?? ?}
?? ?tmp.adr = i;
?? ?tmp.number = list1[i];
?? ?tmp.nexAdr = list2[i];
?? ?v.push_back(tmp);
?? ?for (int i = 0; i < v.size(); i++)
?? ?{
?? ??? ?mark[abs(v[i].number)]++;
?? ??? ?v[i].count = mark[abs(v[i].number)];
?? ?}
}

void GenRomove(deque<struct list> & v1, vector<struct list> & v2)
{
?? ?for (int i = 0; i < v1.size(); )
?? ?{
?? ??? ?// = find(v1.begin() + j, v1.end(), v1[i].number);
?? ??? ?if (v1[i].count < 2)
?? ??? ?{
?? ??? ??? ?i++;
?? ??? ?}
?? ??? ?else
?? ??? ?{
?? ??? ??? ?deque<struct list>::iterator it = v1.begin() + i;
?? ??? ??? ?if (it != v1.end())
?? ??? ??? ?{
?? ??? ??? ??? ?deque<struct list>::iterator pre = --it;
?? ??? ??? ??? ?++it;
?? ??? ??? ??? ?v2.push_back(*it);
?? ??? ??? ??? ?if (v2.size() > 1)
?? ??? ??? ??? ?{
?? ??? ??? ??? ??? ?v2[v2.size() - 2].nexAdr = v2[v2.size() - 1].adr;
?? ??? ??? ??? ?}
?? ??? ??? ??? ?if (++it != v1.end())
?? ??? ??? ??? ?{
?? ??? ??? ??? ??? ?pre->nexAdr = it->adr;
?? ??? ??? ??? ??? ?v1.erase(--it);
?? ??? ??? ??? ?}
?? ??? ??? ??? ?else
?? ??? ??? ??? ?{
?? ??? ??? ??? ??? ?v1.erase(--it);
?? ??? ??? ??? ?}
?? ??? ??? ?}

?? ??? ?}

?? ?}
}

int main()
{
?? ?vector<struct list> remove;
?? ?deque<struct list> origin;
?? ?int startAdr;
?? ?int n;
?? ?cin >> startAdr >> n;
?? ?struct list tmp;
?? ?for (int i = 0; i < n; i++)
?? ?{
?? ??? ?cin >> tmp.adr >> tmp.number >> tmp.nexAdr;
?? ??? ?list1[tmp.adr] = tmp.number;
?? ??? ?list2[tmp.adr] = tmp.nexAdr;
?? ??? ?//origin.push_back(tmp);
?? ?}
?? ?// 把原始表重新排列
?? ?Replace(origin, startAdr);
?? ?GenRomove(origin, remove);
?? ?int i;
?? ?for (i = 0; i < origin.size() - 1; i++)
?? ?{
?? ??? ?cout << setw(5) << setfill('0') << origin[i].adr << " ";
?? ??? ?cout << origin[i].number << " ";
?? ??? ?cout << setw(5) << setfill('0') << origin[i].nexAdr << endl;
?? ?}
?? ?cout << setw(5) << setfill('0') << origin[i].adr << " ";
?? ?cout << origin[i].number << " " << -1 << endl;
?? ?for (i = 0; i < remove.size() - 1; i++)
?? ?{
?? ??? ?cout << setw(5) << setfill('0') << remove[i].adr << " ";
?? ??? ?cout << remove[i].number << " ";
?? ??? ?cout << setw(5) << setfill('0') << remove[i].nexAdr << endl;
?? ?}
?? ?cout << setw(5) << setfill('0') << remove[i].adr << " ";
?? ?cout << remove[i].number << " " << -1 << endl;
?? ?system("pause");
}