从单向链表中删除指定值的节点

templist = input().split(' ')
numNodes = int(templist[0])
myls = [templist[1]]

for i in range(numNodes-1):
    target, insert = templist[2+2*i], templist[3+2*i]
    myls.insert(myls.index(insert)+1, target)

myls.remove(templist[-1])

for item in myls:
    print(item, end=' ')

"""
[说明]：
    1，本题的输入格式有问题，实际输入格式是将各元素在一行进行输入！！！
        比如例子中的输入格式为：5 2 3 2 4 3 5 2 1 4 3
    2，每组例子输出完成（在每个字符后都要加空格）后，还需要加上单独的一个换行！！！

    3，题目中的->符号表示按照顺序插入
        例如，2->1，2->3，2->7，表示先 2->1，然后 2->3->1，最后 2->7->3->1
    
    4，其他的就和常规链表删除结点操作一样了，下面用数组进行处理。
"""
class Solution:
    def fun(self, head, target, arr):
        # 用来存储整个链表的最终表示（未删除前），例如，2->5->3->4->1
        ans = [head]
        for num in arr:
            idx = ans.index(num[1])   # 找到当前结点在ans中的位置
            ans.insert(idx+1, num[0])  # 再将当前结点的下一个结点插入到ans中的下一个位置
        # 找到要删除结点的位置
        tmp = ans.index(target)
        # 删除目标结点
        ans.pop(tmp)
        return ans
    
if __name__ == '__main__':
    while True:
        try:
            # 题目中的输入是将所以元素在同一行输入，同时中间用空格
            tmp = list(map(int, input().split()))
            # 结点总个数
            n = tmp[0]
            # 头结点
            head = tmp[1]
            # 需要删除的目标结点
            target = tmp[-1]
            # 将各结点的链接重新处理一下，例如，arr = [[3,2], [4,3], [5,2], [1, 4]]
            tmp = tmp[2:len(tmp)-1]
            arr = []
            for i in range(len(tmp)//2):
                arr.append([tmp[2*i], tmp[2*i+1]])
            ans = Solution().fun(head, target, arr)
            for i in range(len(ans)):
                print(str(ans[i]), end=' ')
            # 在每一个例子输出完后，还要加上一个换行！！！
            print()
        except:
            break

while 1:
    try:
        n = input()
        head = input()
        num = [head]
        for i in range(int(n)-1):
            a, b = input().split()
            num.insert(num.index(b)+1, a)
        del_num = input()
        num.remove(del_num)
        print(' '.join(num))
    except:
        break

while True:
    try:
        s = input().split(' ')
        ls = []
        ls.append(s[1])
        m = 2
        for i in range(eval(s[0])-1):
            a,b = s[m],s[m+1]
            for j in range(len(ls)):
                if a == ls[j]:
                    ls.insert(j+1,b)
                    break
                if b == ls[j]:
                    ls.insert(j,a)
                    break
            m += 2
        ls.remove(s[-1])
        ls.reverse()
        print(' '.join(ls)+' ')
    except:
        break

while 1:
    try:
        inputlist = input().split()
        N, head, mylist = inputlist[0], inputlist[1], inputlist[2:]
        newlist = []
        newlist.append(head)
        i = 0
        while i<=len(mylist)-3:
            m,n = mylist[i], mylist[i+1]
            newlist.insert(newlist.index(n)+1,m)
            i += 2
        if mylist[-1] in newlist:
            newlist.remove(mylist[-1])
            mylist.index()
        else:
            pass
        print(' '.join(newlist))

    except:
        break

class Node(object):
    def __init__(self,elem):
        self.elem = elem
        self.next = None

class SingleLinkList(object):
    def __init__(self,node=None):
        self._head = node

    def length(self):
        cur = self._head
        count = 0
        while cur:
            cur = cur.next
            count += 1
        return count

    def travel(self):
        cur = self._head
        while cur:
            print(cur.elem, end = " ")
            cur = cur.next
        print("")

    def add(self,item):
        node = Node(item)
        node.next = self._head
        self._head = node

    def insert(self,item,index):
        node = Node(item)
        if not self._head:
            self._head = node
        else:
            cur = self._head
            count = 0
            while cur:
                if cur.elem == index:
                    node.next = cur.next
                    cur.next = node
                    break
                else:
                    cur = cur.next

    def remove(self,item):
        node = Node(item)
        cur = self._head
        pre = None
        while cur:
            if cur.elem == item:
                if cur == self._head:
                    self._head = cur.next
                else:
                    pre.next = cur.next
                break
            else:
                pre = cur
                cur = cur.next
while True:
    try:
        ll = SingleLinkList()
        a = list(map(int,input().split()))
        n = a[0]
        ll.add(a[1])
        for i in range(n-1):
            c = a[2+i*2]
            d = a[3+i*2]
            ll.insert(c,d)
        ll.remove(a[-1])
        ll.travel()
    except:
        break

/*只能说bug有点多，输出最后还要加空格，题目也没有说清楚，佛了佛了……*/
def result(head,arr,rem):
    res = []
    res.append(head)
    for item in arr:
        index = res.index(item[1])
        res.insert(index+1,item[0])
    res.remove(rem)
    return res

while True:
    try:
        temp = list(map(int,input().split()))
        n = temp[0]
        head = temp[1]
        rem = temp[-1]
        arr = []
        for i in range(2,len(temp)-1,2):
            arr.append([temp[i],temp[i+1]])
        ss = result(head,arr,rem)
        res = list(map(str, ss))
        print(" ".join(res)+' ')
    except:
        break

try:
    while 1:
        a = []
        s = raw_input().split()
        Node = int(s[0])
        a.append(int(s[1]))
        k = 2
        for i in xrange(Node - 1):
            m, n = int(s[k]), int(s[k + 1])
            a.insert(a.index(n) + 1, m)
            k += 2
        a.remove(int(s[-1]))
        for i in a[:-1]:
            print i,
        print a[-1],
        print ''
except:
    pass

def solution(lst, val):
    if val in lst:
        lst.remove(val)
        return lst
    return None

import sys
try:
    while 1:
        inp = sys.stdin.readline().strip('\n') # 输入只有一行,空格分隔
        if not inp:
            break
        nums = map(int, inp.split())
        # print 'n',nums[0],'head', nums[1], 'del_val', nums[-1]
        lst = [nums[1]]
        i = 2
        while i < nums[0]*2:
            target = nums[i+1]
            idx = lst.index(target)
            lst.insert(idx+1, nums[i])
            i += 2
        
        ret = solution(lst, nums[-1])
        # print ret
        for i in ret[:-1]:
            print i,
        print ret[-1],
        print ''

        
except:
    pass