用xcode运行 总是输入数据后出现调试台 不输出结果

/*
问题描述:
给定一个键值为整数的单链表 L，将键值的绝对值有重复的结点删除:即对任意键值 K，只 有键值或其绝对值等于 K 的第一个结点被保留在 L 中。例如，下面单链表 L 包含键值 21、 -15、15、7、-15，如下图(a)所示;去重后的链表 L 包含键值 21、-15、7，如下图(b) 所示。

输入说明:
输入的第一行包含两个整数，分别表示链表第一个结点的地址和结点个数 n(1≤n≤100)。结 点地址是一个非负的 5 位整数，NULL 指针用-1 表示。
随后 n 行，每行含 3 个整数，按下列格式给出一个结点的信息:
Address Key Next
其中 Address 是结点的地址，Key 是绝对值不超过 10000 的整数，Next 是下一个结点的地址。 输出说明:
输出的第一行为去重后链表 L 的长度，换行;接下来按顺序输出 L 的所有结点，每个结点 占一行，按照 Address Key Next 的格式输出，间隔 1 个空格。
测试样例:
输入样例 1 00100 5
99999 7 87654
23854 -15 00000
87654 -15 -1
00000 15 99999
00100 21 23854
输出样例 1
3
00100 21 23854
23854 -15 99999
99999 7 -1

*/
#include <stdio.h>
#include <stdlib.h>
#define MAX 100

typedef struct Node{
int self_add;
int next_add;
int key;
struct Node *pNext;
}NODE,*PNODE;

PNODE Ini(void){
PNODE Head=(PNODE)malloc(sizeof(NODE));
Head->pNext=NULL;
return Head;
}//定义头节点的初始化函数

PNODE Search(PNODE Head,PNODE a){
PNODE b=Head->pNext;
while(b->pNext!=a){
b=b->pNext;
}
return b;
}//寻找前一个节点的函数

int sum_length(PNODE Head){
PNODE p=Head->pNext;
int length=0;

while(p){
    length++;
    p=p->pNext;
}

return length;

}

PNODE Ini(void);
PNODE Search(PNODE Head,PNODE a);
int sum_length(PNODE Head);

int main(int argc, const char * argv[]) {
//初始化头指针
// PNODE phead=(PNODE)malloc(sizeof(NODE));
//phead=NULL;

int first_adr,n,i;
printf("请输入首地址和节点个数");
scanf("%d %d",&first_adr,&n);

NODE List[MAX];
printf("请输入节点信息");

for(i=0;i<n;i++){
    scanf("%d %d %d",&List[i].self_add,&List[i].key,&List[i].next_add);
}

//按照输入前后地址对结点进行排序
//思路：
int j,k;
NODE temp;
for(j=0;j<n;j++){
    for(k=j;k<n;k++){
        if(List[k].self_add==first_adr){
            first_adr=List[k].next_add;
            temp=List[j];
            List[j]=List[k];
            List[k]=temp;
            break;
        }
    }
}

//用链表把这些节点连接起来
PNODE p,q,head;

head=Ini();
q=head;
for(i=0;i<n;i++){
    p=(PNODE)malloc(sizeof(NODE));
    p=&List[i];
    p->pNext=NULL;
    q->pNext=p;
    q=q->pNext;
}
q=head;
p=q->pNext;

//实现去重

// PNODE m;
while(p){
q=p->pNext;
while(q){
if(q->key==p->key||q->key==-(p->key)){
PNODE s=Search(head,q);

            if((p->pNext=NULL)){
            s->next_add=-1;
            s->pNext=NULL;
            }
            else{
            s->next_add = q->pNext->self_add;
            s->pNext=q->pNext;
            }
           
            
        }
        q=q->pNext;
    }
    p=p->pNext;
}

q=head;
int length;
length=sum_length(q);
printf("%d\n",length);

//打印节点
while(q->pNext){
    p=q->pNext;
    if(p->next_add==-1)
        printf("%05d %d %d\n",p->self_add,p->key,p->next_add);
    else
        printf("%05d %d %05d\n",p->self_add,p->key,p->next_add);
   // printf("%d %d %d",(*p).self_add,(*p).key,(*p).next_add);
    q=q->pNext;
}


return 0;

}

只能帮你到这了：

/*
问题描述:
给定一个键值为整数的单链表 L，将键值的绝对值有重复的结点删除:即对任意键值 K，只 有键值或其绝对值等于 K 的第一个结点被保留在 L 中。例如，下面单链表 L 包含键值 21、 -15、15、7、-15，如下图(a)所示;去重后的链表 L 包含键值 21、-15、7，如下图(b) 所示。
输入说明:
输入的第一行包含两个整数，分别表示链表第一个结点的地址和结点个数 n(1≤n≤100)。结 点地址是一个非负的 5 位整数，NULL 指针用-1 表示。
随后 n 行，每行含 3 个整数，按下列格式给出一个结点的信息:
Address Key Next
其中 Address 是结点的地址，Key 是绝对值不超过 10000 的整数，Next 是下一个结点的地址。 输出说明:
输出的第一行为去重后链表 L 的长度，换行;接下来按顺序输出 L 的所有结点，每个结点 占一行，按照 Address Key Next 的格式输出，间隔 1 个空格。
测试样例:
输入样例1
00100 5
99999 7 87654
23854 -15 00000
87654 -15 -1
00000 15 99999
00100 21 23854
输出样例1
3
00100 21 23854
23854 -15 99999
99999 7 -1
*/
#include <stdio.h>
#include <stdlib.h>
#define MAX 100
typedef struct Node {
    int self_add;
    int next_add;
    int key;
    struct Node *pNext;
} NODE,*PNODE;

PNODE Ini(void) {//头节点的初始化
    PNODE Head=(PNODE)malloc(sizeof(NODE));
    Head->pNext=NULL;
    return Head;
}

PNODE Search(PNODE Head,PNODE a) {//寻找前一个节点
    PNODE b=Head->pNext;
    while(b->pNext!=a) {
        b=b->pNext;
    }
    return b;
}

int sum_length(PNODE Head) {
    PNODE p=Head->pNext;
    int length=0;

    while(p) {
        length++;
        p=p->pNext;
    }
    return length;
}

int main() {
    int first_adr,n,i;
    NODE List[MAX];

//  printf("请输入首地址和节点个数");
    scanf("%d%d",&first_adr,&n);
    printf("first_adr:%05d,n:%d\n",first_adr,n);
//  printf("请输入节点信息");

    for(i=0;i<n;i++) {
        scanf("%d%d%d",&List[i].self_add,&List[i].key,&List[i].next_add);
    }
    for(i=0;i<n;i++) {
        printf("List[%d].self_add:%05d,List[%d].key:%6d,&List[%d].next_add;%05d\n",i,List[i].self_add,i,List[i].key,i,List[i].next_add);
    }

    //按照输入前后地址对结点进行排序
    int j,k;
    NODE temp;
    for(j=0;j<n;j++) {
        for(k=j;k<n;k++) {
            if(List[k].self_add==first_adr) {
                first_adr=List[k].next_add;
                temp=List[j];
                List[j]=List[k];
                List[k]=temp;
                break;
            }
        }
    }

    //用链表把这些节点连接起来
    PNODE p,q,head;

    head=Ini();
    q=head;
    for(i=0;i<n;i++) {
        p=(PNODE)malloc(sizeof(NODE));
        p=&List[i];
        p->pNext=NULL;
        q->pNext=p;
        q=q->pNext;
    }
    q=head;
    p=q->pNext;

    //实现去重
    while(p) {
        q=p->pNext;
        while(q) {
            if(q->key==p->key||q->key==-(p->key)) {
                PNODE s=Search(head,q);

                if((p->pNext=NULL)) {
                    s->next_add=-1;
                    s->pNext=NULL;
                } else {
                    s->next_add = q->pNext->self_add;
                    s->pNext=q->pNext;
                }


            }
            q=q->pNext;
        }
        p=p->pNext;
    }

    q=head;
    int length;
    length=sum_length(q);
    printf("%d\n",length);

    //打印节点
    while(q->pNext) {
        p=q->pNext;
        if(p->next_add==-1)
            printf("%05d %d %d\n",p->self_add,p->key,p->next_add);
        else
            printf("%05d %d %05d\n",p->self_add,p->key,p->next_add);
        q=q->pNext;
    }

    return 0;
}